github.com/platonnetwork/platon-go@v0.7.6/cases/tests/govern/test_submit_proposal.py (about)

     1  from common.log import log
     2  from dacite import from_dict
     3  from tests.lib import Genesis
     4  import pytest, allure
     5  from tests.lib.utils import wait_block_number, assert_code, get_governable_parameter_value
     6  from tests.lib.client import get_client_by_nodeid
     7  import time
     8  import math
     9  from tests.govern.test_voting_statistics import submitcppandvote, submitcvpandvote
    10  
    11  
    12  @pytest.mark.P0
    13  @pytest.mark.compatibility
    14  @allure.title('Submit version proposal function verification')
    15  def test_VP_SU_001(submit_version):
    16      pip = submit_version
    17      proposalinfo = pip.get_effect_proposal_info_of_vote()
    18      log.info('Get version proposal information : {}'.format(proposalinfo))
    19      endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.consensus_size +
    20                                       proposalinfo.get('EndVotingRounds')
    21                                       ) * pip.economic.consensus_size - 20
    22      log.info('Calculated endvoting block{},interface returned endvoting block{}'.format(endvotingblock_count,
    23                                                                                          proposalinfo.get('EndVotingBlock')))
    24      assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock')
    25      assert int(endvotingblock_count) + 21 == proposalinfo.get('ActiveBlock')
    26  
    27  
    28  @pytest.mark.P0
    29  @pytest.mark.compatibility
    30  @allure.title('Submit cancel proposal function verification')
    31  def test_CP_SU_001_CP_UN_001(submit_cancel):
    32      pip = submit_cancel
    33      proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal)
    34      log.info('cancel proposalinfo : {}'.format(proposalinfo))
    35      endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.consensus_size +
    36                                       proposalinfo.get('EndVotingRounds')
    37                                       ) * pip.economic.consensus_size - 20
    38      log.info('Calculated endvoting block{},interface returned endvoting block{}'.format(endvotingblock_count,
    39                                                                                          proposalinfo.get('EndVotingBlock')))
    40      assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock')
    41      result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo.get('ProposalID'),
    42                                    pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
    43      log.info('Submit cancel proposal result : {}'.format(result))
    44      assert_code(result, 302014)
    45  
    46  
    47  class TestsubmitCP:
    48      @pytest.mark.P0
    49      @allure.title('Submit param proposal function verification')
    50      def test_CP_SU_002_CP_SU_003(self, submit_param):
    51          pip = submit_param
    52          proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal)
    53          log.info('param proposalinfo : {}'.format(proposalinfo))
    54          endvotingrounds_count = (proposalinfo.get('EndVotingBlock') -
    55                                   math.ceil(pip.node.block_number/pip.economic.consensus_size) *
    56                                   pip.economic.consensus_size) / pip.economic.consensus_size
    57          log.info('caculated endvoting rounds is {}'.format(endvotingrounds_count))
    58          result = pip.submitCancel(pip.node.node_id, str(time.time()), endvotingrounds_count + 1, proposalinfo.get('ProposalID'),
    59                                        pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
    60          log.info('Submit cancel proposal result : {}'.format(result))
    61          assert_code(result, 302010)
    62          result = pip.submitCancel(pip.node.node_id, str(time.time()), endvotingrounds_count, proposalinfo.get('ProposalID'),
    63                                        pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
    64          log.info('Submit cancel proposal result : {}'.format(result))
    65          assert_code(result, 0)
    66  
    67      @pytest.mark.P0
    68      @allure.title('Submit cancel param proposal function verification')
    69      def test_CP_SU_002_CP_UN_002(self, submit_cancel_param):
    70          pip = submit_cancel_param
    71          proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal)
    72          log.info('cancel proposalinfo : {}'.format(proposalinfo))
    73          endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.consensus_size +
    74                                           proposalinfo.get('EndVotingRounds')
    75                                           ) * pip.economic.consensus_size - 20
    76          log.info('Calculated endvoting block{},interface returned endvoting block{}'.format(endvotingblock_count,
    77                                                                                              proposalinfo.get('EndVotingBlock')))
    78          assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock')
    79          result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo.get('ProposalID'),
    80                                        pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
    81          log.info('Submit cancel proposal result : {}'.format(result))
    82          assert_code(result, 302014)
    83  
    84  
    85  @pytest.mark.P0
    86  @pytest.mark.compatibility
    87  @allure.title('Submit param proposal function verification')
    88  def test_PP_SU_001_PP_UN_001_VP_UN_003(submit_param):
    89      pip = submit_param
    90      log.info('test chain version : {}'.format(pip.chain_version))
    91      proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal)
    92      log.info('param proposalinfo : {}'.format(proposalinfo))
    93      endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.settlement_size +
    94                                       pip.economic.pp_vote_settlement_wheel
    95                                       ) * pip.economic.settlement_size
    96      log.info('Calculated endvoting block {},interface returned endvoting block {}'.format(endvotingblock_count,
    97                                                                                            proposalinfo.get('EndVotingBlock')))
    98      assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock')
    99      result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '22',
   100                                   pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   101      log.info('There is a voting param proposal,submit param proposal result : {}'.format(result))
   102      assert_code(result, 302032)
   103  
   104      result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1,
   105                                     pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   106      log.info('There is a voting param proposal,submit version proposal result : {}'.format(result))
   107      assert_code(result, 302032)
   108  
   109  @pytest.mark.P2
   110  def test_PP_SU_021(new_genesis_env, client_consensus):
   111      genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config)
   112      genesis.config.cbft.period = 1000 * 2 * genesis.config.cbft.amount
   113      genesis.economicModel.common.maxEpochMinutes = 6
   114      genesis.economicModel.gov.textProposalVoteDurationSeconds = 161
   115      new_genesis_env.set_genesis(genesis.to_dict())
   116      new_genesis_env.deploy_all()
   117      pip = client_consensus.pip
   118      result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', '99', pip.node.staking_address,
   119                               transaction_cfg=pip.cfg.transaction_cfg)
   120      assert_code(result, 0)
   121      proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal)
   122      log.info('Param proposal information : {}'.format(proposalinfo))
   123      endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.settlement_size +
   124                                       pip.economic.pp_vote_settlement_wheel
   125                                       ) * pip.economic.settlement_size
   126      log.info('Calculated endvoting block {},interface returned endvoting block {}'.format(endvotingblock_count,
   127                                                                                            proposalinfo.get(
   128                                                                                                'EndVotingBlock')))
   129      assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock')
   130      result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address,
   131                              transaction_cfg=pip.cfg.transaction_cfg)
   132      log.info('Submit text proposal result : {}'.format(result))
   133      assert_code(result, 0)
   134      proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal)
   135      log.info('Get text proposal information :{}'.format(proposalinfo))
   136      endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.consensus_size + 4
   137                                       ) * pip.economic.consensus_size - 20
   138      log.info('calcuted endvoting block {},interface returns {}'.format(endvotingblock_count,
   139                                                                         proposalinfo.get('EndVotingBlock')))
   140      assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock')
   141  
   142  
   143  
   144  @pytest.mark.P0
   145  @allure.title('Submit version proposal function verification')
   146  def test_VP_VE_001_to_VP_VE_005(no_vp_proposal):
   147      pip_tmp = no_vp_proposal
   148      result = pip_tmp.submitVersion(pip_tmp.node.node_id, str(time.time()), pip_tmp.cfg.version1, 1,
   149                                         pip_tmp.node.staking_address, transaction_cfg=pip_tmp.cfg.transaction_cfg)
   150      log.info('Submit version proposal result : {}'.format(result))
   151      assert_code(result, 302011)
   152  
   153      result = pip_tmp.submitVersion(pip_tmp.node.node_id, str(time.time()), pip_tmp.cfg.version2, 1,
   154                                         pip_tmp.node.staking_address, transaction_cfg=pip_tmp.cfg.transaction_cfg)
   155      log.info('Submit version proposal result : {}'.format(result))
   156      assert_code(result, 302011)
   157  
   158      result = pip_tmp.submitVersion(pip_tmp.node.node_id, str(time.time()), pip_tmp.cfg.version3, 1,
   159                                         pip_tmp.node.staking_address, transaction_cfg=pip_tmp.cfg.transaction_cfg)
   160      log.info('Submit version proposal result : {}'.format(result))
   161      assert_code(result, 302011)
   162  
   163      result = pip_tmp.submitVersion(pip_tmp.node.node_id, str(time.time()), pip_tmp.chain_version, 1,
   164                                         pip_tmp.node.staking_address, transaction_cfg=pip_tmp.cfg.transaction_cfg)
   165      log.info('Submit version proposal result : {}'.format(result))
   166      assert_code(result, 302011)
   167  
   168      result = pip_tmp.submitVersion(pip_tmp.node.node_id, str(time.time()), pip_tmp.cfg.version8, 1,
   169                                         pip_tmp.node.staking_address, transaction_cfg=pip_tmp.cfg.transaction_cfg)
   170      log.info('Submit version proposal result : {}'.format(result))
   171      assert_code(result, 0)
   172  
   173  
   174  @pytest.mark.P2
   175  @allure.title('Nostaking address, submit version proposal function verification')
   176  def test_VP_WA_001(no_vp_proposal):
   177      pip_tmp = no_vp_proposal
   178      address, _ = pip_tmp.economic.account.generate_account(pip_tmp.node.web3, 10**18 * 10000000)
   179      result = pip_tmp.submitVersion(pip_tmp.node.node_id, str(time.time()), pip_tmp.cfg.version5, 1,
   180                                         address, transaction_cfg=pip_tmp.cfg.transaction_cfg)
   181      log.info('Submit version proposal reuslt : {}'.format(result))
   182      assert_code(result, 302021)
   183  
   184  
   185  @pytest.mark.P2
   186  @allure.title('Nostaking address, submit text proposal function verification')
   187  def test_TP_WA_001(client_verifier):
   188      pip = client_verifier.pip
   189      address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000000)
   190      result = pip.submitText(pip.node.node_id, str(time.time()), address,
   191                                  transaction_cfg=pip.cfg.transaction_cfg)
   192      log.info('Submit text proposal reuslt : {}'.format(result))
   193      assert_code(result, 302021)
   194  
   195  
   196  @pytest.mark.P0
   197  @allure.title('submit text proposal function verification')
   198  def test_TP_UN_001(submit_text):
   199      pip = submit_text
   200      result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address,
   201                                  transaction_cfg=pip.cfg.transaction_cfg)
   202      log.info('There is voting text proposal, submit text proposal result : {}'.format(result))
   203      assert_code(result, 0)
   204  
   205  
   206  @pytest.mark.P0
   207  @pytest.mark.compatibility
   208  @allure.title('Submit version proposal function verification')
   209  def test_VP_SU_001_VP_UN_001(submit_version):
   210      pip = submit_version
   211      result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1,
   212                                     pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   213      log.info('There is voting version proposal, submit version proposal result : {}'.format(result))
   214      assert_code(result, 302012)
   215  
   216  
   217  @pytest.mark.P0
   218  @allure.title('There is preactive proposal, submit proposal function verification')
   219  def test_VP_UN_002_CP_ID_002(preactive_proposal_pips, new_genesis_env):
   220      pip = preactive_proposal_pips[0]
   221      proposalinfo = pip.get_effect_proposal_info_of_preactive()
   222      log.info('Get preactive proposal info: {}'.format(proposalinfo))
   223  
   224      result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1,
   225                                     pip.node.staking_address,
   226                                     transaction_cfg=pip.cfg.transaction_cfg)
   227      log.info('There is preactive version proposal, submit version proposal result : {}'.format(result))
   228      assert_code(result, 302013)
   229  
   230      result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo.get('ProposalID'),
   231                                    pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   232      log.info('there is preactive version proposal, submit cancel proposal result: {}'.format(result))
   233      assert_code(result, 302017)
   234  
   235  
   236  @pytest.mark.P0
   237  @allure.title('There is preactive proposal, submit cancel parammeter proposal function verification')
   238  def test_PP_UN_003(preactive_proposal_pips, new_genesis_env):
   239      pip = preactive_proposal_pips[0]
   240      proposalinfo = pip.get_effect_proposal_info_of_preactive()
   241      log.info('Get preactive proposal info: {}'.format(proposalinfo))
   242  
   243      result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward',
   244                                   '84', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   245      log.info('there is preactive version proposal, submit cancel param proposal result: {}'.format(result))
   246      assert_code(result, 302013)
   247  
   248  
   249  class TestEndVotingRounds:
   250      def update_setting(self, new_genesis_env, pip, value=0):
   251          genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config)
   252          genesis.economicModel.gov.versionProposalVoteDurationSeconds = 2 * pip.economic.consensus_size + value
   253          genesis.economicModel.gov.textProposalVoteDurationSeconds = 2 * pip.economic.consensus_size + value
   254          new_genesis_env.set_genesis(genesis.to_dict())
   255          new_genesis_env.deploy_all()
   256  
   257      @pytest.mark.P1
   258      @allure.title('Submit version and text proposal function verification--endvoting rounds')
   259      def test_VP_CR_001_VP_CR_002_VP_CR_007_TP_TE_002(self, new_genesis_env, client_verifier):
   260          '''
   261          Proposal vote duration set consensus size's accompanying number +1
   262          :param pip_env:
   263          :param pip:
   264          :return:
   265          '''
   266          pip = client_verifier.pip
   267          self.update_setting(new_genesis_env, pip, value=1)
   268          result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 3,
   269                                         pip.node.staking_address,
   270                                         transaction_cfg=pip.cfg.transaction_cfg)
   271          log.info('endvoting rounds is three, subtmit version proposal result : {}'.format(result))
   272          assert_code(result, 302010)
   273  
   274          result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 0,
   275                                         pip.node.staking_address,
   276                                         transaction_cfg=pip.cfg.transaction_cfg)
   277          log.info('endvoting rounds is zero, subtmit version proposal result : {}'.format(result))
   278          assert_code(result, 302009)
   279  
   280          result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 2,
   281                                         pip.node.staking_address,
   282                                         transaction_cfg=pip.cfg.transaction_cfg)
   283          log.info('endvoting rounds is two, subtmit version proposal result : {}'.format(result))
   284          assert_code(result, 0)
   285  
   286          result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address,
   287                                      transaction_cfg=pip.cfg.transaction_cfg)
   288          log.info('Submit text proposal result : {}'.format(result))
   289          assert_code(result, 0)
   290          proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal)
   291          log.info('Get text proposal information :{}'.format(proposalinfo))
   292          endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.consensus_size + 2
   293                                           ) * pip.economic.consensus_size - 20
   294          log.info('calcuted endvoting block {},interface returns {}'.format(endvotingblock_count,
   295                                                                             proposalinfo.get('EndVotingBlock')))
   296          assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock')
   297  
   298      @pytest.mark.P1
   299      @allure.title('Submit version and text proposal function verification--endvoting rounds')
   300      def test_VP_CR_003_VP_CR_004_VP_CR_007_TP_TE_003(self, new_genesis_env, client_verifier):
   301          pip = client_verifier.pip
   302          self.update_setting(new_genesis_env, pip, value=-1)
   303          result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 2, pip.node.staking_address,
   304                                         transaction_cfg=pip.cfg.transaction_cfg)
   305          log.info('endvoting rounds is two, subtmit version proposal result : {}'.format(result))
   306          assert_code(result, 302010)
   307  
   308          result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 0, pip.node.staking_address,
   309                                         transaction_cfg=pip.cfg.transaction_cfg)
   310          log.info('Endvoting rounds is zero, subtmit version proposal result : {}'.format(result))
   311          assert_code(result, 302009)
   312  
   313          result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1, pip.node.staking_address,
   314                                         transaction_cfg=pip.cfg.transaction_cfg)
   315          log.info('Endvoting rounds is one, subtmit version proposal result : {}'.format(result))
   316          assert_code(result, 0)
   317  
   318          result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address,
   319                                      transaction_cfg=pip.cfg.transaction_cfg)
   320          log.info('Submit text proposal result : {}'.format(result))
   321          assert_code(result, 0)
   322          proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal)
   323          log.info('Get text proposal information : {}'.format(proposalinfo))
   324          endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.consensus_size + 1
   325                                           ) * pip.economic.consensus_size - 20
   326          log.info('Calcuted endvoting block {},interface return {}'.format(endvotingblock_count,
   327                                                                            proposalinfo.get('EndVotingBlock')))
   328          assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock')
   329  
   330      @pytest.mark.P1
   331      @pytest.mark.compatibility
   332      @allure.title('Submit version and text proposal function verification--endvoting rounds')
   333      def test_VP_CR_005_VP_CR_006_TP_TE_001(self, new_genesis_env, client_verifier):
   334          pip = client_verifier.pip
   335          self.update_setting(new_genesis_env, pip)
   336          result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 3,
   337                                         pip.node.staking_address,
   338                                         transaction_cfg=pip.cfg.transaction_cfg)
   339          log.info('Endvoting rounds is three, subtmit version proposal result : {}'.format(result))
   340          assert_code(result, 302010)
   341  
   342          result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 0,
   343                                         pip.node.staking_address,
   344                                         transaction_cfg=pip.cfg.transaction_cfg)
   345          log.info('Endvoting rounds is zero, subtmit version proposal result : {}'.format(result))
   346          assert_code(result, 302009)
   347  
   348          result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 2,
   349                                         pip.node.staking_address,
   350                                         transaction_cfg=pip.cfg.transaction_cfg)
   351          log.info('Endvoting rounds is two, subtmit version proposal result : {}'.format(result))
   352          assert_code(result, 0)
   353  
   354          result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address,
   355                                      transaction_cfg=pip.cfg.transaction_cfg)
   356          log.info('Submit text proposal result : {}'.format(result))
   357          assert_code(result, 0)
   358          proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal)
   359          log.info('Get text proposal information {}'.format(proposalinfo))
   360          endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.consensus_size + 2
   361                                           ) * pip.economic.consensus_size - 20
   362          log.info('calcuted endvoting block {},interface return {}'.format(endvotingblock_count,
   363                                                                            proposalinfo.get('EndVotingBlock')))
   364          assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock')
   365  
   366          proosalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal)
   367          log.info('text proposalinfo: {}'.format(proosalinfo))
   368          result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proosalinfo.get('ProposalID'),
   369                                        pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   370          log.info('submit cancel result: {}'.format(result))
   371          assert_code(result, 302016)
   372  
   373  
   374  class TestNoVerifierSubmitProposal:
   375      @pytest.mark.P0
   376      @allure.title('New node submit version and text proposal function verification')
   377      def test_VP_PR_002_TP_PR_002(self, no_vp_proposal, client_new_node):
   378          pip = client_new_node.pip
   379          address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000000)
   380          result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1, address,
   381                                         transaction_cfg=pip.cfg.transaction_cfg)
   382          log.info('New node submit version proposal : {}'.format(result))
   383          assert_code(result, 302022)
   384  
   385          result = pip.submitText(pip.node.node_id, str(time.time()), address,
   386                                      transaction_cfg=pip.cfg.transaction_cfg)
   387          log.info('New node submit text proposal : {}'.format(result))
   388          assert_code(result, 302022)
   389  
   390      @pytest.mark.P0
   391      @allure.title('Candidate node submit version and text proposal function verification')
   392      def test_VP_PR_001_TP_PR_001(self, client_candidate):
   393          pip = client_candidate.pip
   394          result = pip.submitVersion(pip.node.node_id, str(time.time()),
   395                                         pip.cfg.version5, 1, pip.node.staking_address,
   396                                         transaction_cfg=pip.cfg.transaction_cfg)
   397          log.info('Candidate node {} submit version proposal result : {}'.format(pip.node.node_id, result))
   398          assert_code(result, 302022)
   399  
   400          result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address,
   401                                      transaction_cfg=pip.cfg.transaction_cfg)
   402          log.info('candidate node {} submit text proposal result : {}'.format(pip.node.node_id, result))
   403          assert_code(result, 302022)
   404  
   405      @pytest.mark.P2
   406      @allure.title('Abnormal node submit proposal')
   407      def test_VP_PR_003_VP_PR_004_TP_PR_003_TP_PR_004(self, client_verifier):
   408          address = client_verifier.node.staking_address
   409          result = client_verifier.staking.withdrew_staking(address)
   410          log.info('Node {} withdrew staking result : {}'.format(client_verifier.node.node_id, result))
   411          assert_code(result, 0)
   412          result = client_verifier.pip.submitVersion(client_verifier.node.node_id, str(time.time()),
   413                                                     client_verifier.pip.cfg.version5, 1, address,
   414                                                     transaction_cfg=client_verifier.pip.cfg.transaction_cfg)
   415          log.info('Node exiting submit version proposal :{}'.format(result))
   416          assert_code(result, 302020)
   417  
   418          result = client_verifier.pip.submitText(client_verifier.node.node_id, str(time.time()), address,
   419                                                  transaction_cfg=client_verifier.pip.cfg.transaction_cfg)
   420          log.info('Node exiting submit text proposal : {}'.format(result))
   421          assert_code(result, 302020)
   422  
   423          client_verifier.economic.wait_settlement_blocknum(client_verifier.node,
   424                                                            number=client_verifier.economic.unstaking_freeze_ratio)
   425          result = client_verifier.pip.submitVersion(client_verifier.node.node_id, str(time.time()),
   426                                                     client_verifier.pip.cfg.version5, 1, address,
   427                                                     transaction_cfg=client_verifier.pip.cfg.transaction_cfg)
   428          log.info('Node exited submit version proposal : {}'.format(result))
   429          assert_code(result, 302022)
   430  
   431          client_verifier.economic.wait_settlement_blocknum(client_verifier.node,
   432                                                            number=client_verifier.economic.unstaking_freeze_ratio)
   433          result = client_verifier.pip.submitText(client_verifier.node.node_id, str(time.time()), address,
   434                                                  transaction_cfg=client_verifier.pip.cfg.transaction_cfg)
   435          log.info('Node exited submit text proposal : {}'.format(result))
   436          assert_code(result, 302022)
   437  
   438  
   439  class TestSubmitCancel:
   440      @pytest.mark.P0
   441      @allure.title('Nostaking address submit cancel proposal')
   442      def test_CP_WA_001(self, submit_version):
   443          pip = submit_version
   444          address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000)
   445          proposalinfo = pip.get_effect_proposal_info_of_vote()
   446          log.info('Get version proposal information : {}'.format(proposalinfo))
   447          result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo.get('ProposalID'),
   448                                        address, transaction_cfg=pip.cfg.transaction_cfg)
   449          log.info('Submit cancel proposal result : {}'.format(result))
   450          assert_code(result, 302021)
   451  
   452      @pytest.mark.P0
   453      @allure.title('New node submit cancel proposal')
   454      def test_CP_PR_001(self, new_node_has_proposal):
   455          pip = new_node_has_proposal
   456          address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000)
   457          proposalinfo = pip.get_effect_proposal_info_of_vote()
   458          log.info('Get version proposal information : {}'.format(proposalinfo))
   459          result = pip.submitCancel(pip.node.node_id, str(time.time()), 1,
   460                                        proposalinfo.get('ProposalID'),
   461                                        address, transaction_cfg=pip.cfg.transaction_cfg)
   462          log.info('Submit cancel proposal resullt : {}'.format(result))
   463          assert_code(result, 302022)
   464  
   465      @pytest.mark.P0
   466      @allure.title('Candidate node submit cancel proposal')
   467      def test_CP_PR_002(self, candidate_has_proposal):
   468          pip = candidate_has_proposal
   469          proposalinfo = pip.get_effect_proposal_info_of_vote()
   470          if not proposalinfo:
   471              time.sleep(10)
   472              proposalinfo = pip.get_effect_proposal_info_of_vote()
   473          log.info('Get proposal information {}'.format(proposalinfo))
   474          result = pip.submitCancel(pip.node.node_id, str(time.time()), 1,
   475                                        proposalinfo.get('ProposalID'),
   476                                        pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   477          log.info('Candidate submit cancel proposal result : {}'.format(result))
   478          assert_code(result, 302022)
   479  
   480      @pytest.mark.P2
   481      @allure.title('Abnormal node submit cancel proposal')
   482      def test_CP_PR_003_CP_PR_004(self, new_genesis_env, client_consensus):
   483          genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config)
   484          genesis.economicModel.gov.versionProposalVoteDurationSeconds = 10000
   485          new_genesis_env.set_genesis(genesis.to_dict())
   486          new_genesis_env.deploy_all()
   487          pip = client_consensus.pip
   488          result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 20,
   489                                         pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   490          log.info('Submit version proposal result : {}'.format(result))
   491          assert_code(result, 0)
   492          proposalinfo = pip.get_effect_proposal_info_of_vote()
   493          log.info('proposalinfo: {}'.format(proposalinfo))
   494          client = client_consensus
   495          address = pip.node.staking_address
   496          result = client.staking.withdrew_staking(address)
   497          log.info('nodeid: {} withdrewstaking result: {}'.format(client.node.node_id, result))
   498          assert_code(result, 0)
   499          result = client.pip.submitCancel(client.node.node_id, str(time.time()), 1,
   500                                               proposalinfo.get('ProposalID'), address,
   501                                               transaction_cfg=client.pip.cfg.transaction_cfg)
   502          log.info('node exiting,cancel proposal result: {}'.format(result))
   503          assert_code(result, 302020)
   504  
   505          client.economic.wait_settlement_blocknum(client.node, number=client.economic.unstaking_freeze_ratio)
   506          result = client.pip.submitCancel(client.node.node_id, str(time.time()), 1,
   507                                               proposalinfo.get('ProposalID'), address,
   508                                               transaction_cfg=client.pip.cfg.transaction_cfg)
   509          log.info('exited node,cancel proposal result: {}'.format(result))
   510          assert_code(result, 302022)
   511  
   512      @pytest.mark.P0
   513      @allure.title('Submit version  proposal function verification--endvoting rounds')
   514      def test_CP_CR_001_CP_CR_002(self, submit_version):
   515          pip = submit_version
   516          proposalinfo = pip.get_effect_proposal_info_of_vote()
   517          log.info('proposalinfo: {}'.format(proposalinfo))
   518          endvoting_rounds = (proposalinfo.get('EndVotingBlock') + 20 - math.ceil(
   519              pip.node.block_number / pip.economic.consensus_size) * pip.economic.consensus_size
   520              ) / pip.economic.consensus_size
   521          result = pip.submitCancel(pip.node.node_id, str(time.time()), endvoting_rounds,
   522                                        proposalinfo.get('ProposalID'), pip.node.staking_address,
   523                                        transaction_cfg=pip.cfg.transaction_cfg)
   524          log.info('endvoting_rounds:{}, cancel proposal result:{}'.format(endvoting_rounds, result))
   525          assert_code(result, 302010)
   526  
   527          result = pip.submitCancel(pip.node.node_id, str(time.time()), endvoting_rounds + 1,
   528                                        proposalinfo.get('ProposalID'), pip.node.staking_address,
   529                                        transaction_cfg=pip.cfg.transaction_cfg)
   530          log.info('endvoting_rounds:{}, cancel proposal result:{}'.format(endvoting_rounds + 1, result))
   531          assert_code(result, 302010)
   532  
   533      @pytest.mark.P0
   534      @allure.title('Submit cancel  proposal function verification--ineffective proposal id')
   535      def test_CP_ID_001(self, no_vp_proposal):
   536          pip = no_vp_proposal
   537          result = pip.submitCancel(pip.node.node_id, str(time.time()), 1,
   538                                        '0x49b83cfc4b99462f7131d14d80c73b6657237753cd1e878e8d62dc2e9f574123',
   539                                        pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   540          log.info('cancel proposal result: {}'.format(result))
   541          assert_code(result, 302015)
   542  
   543      @pytest.mark.P0
   544      @allure.title('Submit parammeter  proposal function verification')
   545      def test_CP_ID_004_CP_ID_003(self, new_genesis_env, client_consensus):
   546          genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config)
   547          genesis.economicModel.gov.paramProposalVoteDurationSeconds = 0
   548          new_genesis_env.set_genesis(genesis.to_dict())
   549          new_genesis_env.deploy_all()
   550          pip = client_consensus.pip
   551          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '123',
   552                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   553          log.info('Submit parameter proposal result : {}'.format(result))
   554          assert_code(result, 0)
   555          result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address,
   556                                      transaction_cfg=pip.cfg.transaction_cfg)
   557          log.info('Submit text proposal result : {}'.format(result))
   558          assert_code(result, 0)
   559          proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal)
   560          log.info('Get parameter proposal information : {}'.format(proposalinfo_param))
   561          proposalinfo_text = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal)
   562          log.info('Get text proposal information : {}'.format(proposalinfo_text))
   563          result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo_text.get('ProposalID'),
   564                                        pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   565          log.info('Submit cancel proposal result : {}'.format(result))
   566          wait_block_number(pip.node, proposalinfo_param.get('EndVotingBlock'))
   567          result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo_param.get('ProposalID'),
   568                                        pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   569          log.info('Submit cancel proposal result : {}'.format(result))
   570          assert_code(result, 302017)
   571  
   572  
   573  class TestPP:
   574      @pytest.mark.P0
   575      @allure.title('Submit parammeter  proposal function verification')
   576      def test_PP_SU_001_PP_SU_002(self, no_vp_proposal, all_clients):
   577          pip = no_vp_proposal
   578          client = get_client_by_nodeid(pip.node.node_id, all_clients)
   579          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '',
   580                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   581          log.info('Submit param proposal result : {}'.format(result))
   582          assert_code(result, 3)
   583  
   584          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '1.1',
   585                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   586          log.info('Submit param proposal result : {}'.format(result))
   587          assert_code(result, 3)
   588  
   589          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '-1',
   590                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   591          log.info('Submit param proposal result : {}'.format(result))
   592          assert_code(result, 3)
   593  
   594          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '50000',
   595                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   596          log.info('Submit param proposal result : {}'.format(result))
   597          assert_code(result, 3)
   598  
   599          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', 1,
   600                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   601          log.info('Submit param proposal result : {}'.format(result))
   602          assert_code(result, 3)
   603  
   604          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '1000000',
   605                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   606          log.info('Submit param proposal result : {}'.format(result))
   607          assert_code(result, 3)
   608  
   609          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward',
   610                                       str(get_governable_parameter_value(client, 'slashBlocksReward')),
   611                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   612          log.info('Submit param proposal result : {}'.format(result))
   613          assert_code(result, 302034)
   614  
   615          if pip.economic.slash_blocks_reward != 0:
   616              result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '0',
   617                                           pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   618              log.info('Submit param proposal result : {}'.format(result))
   619              assert_code(result, 0)
   620  
   621      @pytest.mark.P0
   622      @allure.title('Submit parammeter  proposal function verification')
   623      def test_PP_SU_002(self, no_vp_proposal, all_clients):
   624          pip = no_vp_proposal
   625          if str(get_governable_parameter_value(all_clients[0], 'slashBlocksReward')) != 49999:
   626              result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '49999',
   627                                           pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   628              log.info('Submit param proposal result : {}'.format(result))
   629              assert_code(result, 0)
   630  
   631      @pytest.mark.P0
   632      @allure.title('Submit parammeter  proposal function verification')
   633      def test_PP_SU_003_PP_SU_004(self, no_vp_proposal, all_clients):
   634          pip = no_vp_proposal
   635          client = get_client_by_nodeid(pip.node.node_id, all_clients)
   636          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge', '',
   637                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   638          log.info('Submit param proposal result : {}'.format(result))
   639          assert_code(result, 3)
   640  
   641          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge', '1.1',
   642                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   643          log.info('Submit param proposal result : {}'.format(result))
   644          assert_code(result, 3)
   645  
   646          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge', '-1',
   647                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   648          log.info('Submit param proposal result : {}'.format(result))
   649          assert_code(result, 3)
   650  
   651          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge', '0',
   652                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   653          log.info('Submit param proposal result : {}'.format(result))
   654          assert_code(result, 3)
   655  
   656          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge', 1,
   657                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   658          log.info('Submit param proposal result : {}'.format(result))
   659          assert_code(result, 3)
   660  
   661          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge',
   662                                       str(get_governable_parameter_value(client, 'maxEvidenceAge')),
   663                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   664          log.info('Submit param proposal result : {}'.format(result))
   665          assert_code(result, 302034)
   666  
   667          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge',
   668                                       str(get_governable_parameter_value(client, 'unStakeFreezeDuration')),
   669                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   670          log.info('Submit param proposal result : {}'.format(result))
   671          assert_code(result, 3)
   672  
   673          if int(get_governable_parameter_value(client, 'maxEvidenceAge')) != 1:
   674              result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge', '1',
   675                                           pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   676              log.info('Submit param proposal result : {}'.format(result))
   677              assert_code(result, 0)
   678  
   679      @pytest.mark.P0
   680      @allure.title('Submit parammeter  proposal function verification')
   681      def test_PP_SU_004(self, no_vp_proposal, all_clients):
   682          pip = no_vp_proposal
   683          if str(get_governable_parameter_value(all_clients[0], 'maxEvidenceAge')) != str(
   684              pip.economic.unstaking_freeze_ratio - 1) and str(pip.economic.unstaking_freeze_ratio - 1) <= str(
   685                  get_governable_parameter_value(all_clients[0], 'unStakeFreezeDuration')):
   686              result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge',
   687                                           str(pip.economic.unstaking_freeze_ratio - 1),
   688                                           pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   689              log.info('Submit param proposal result : {}'.format(result))
   690              assert_code(result, 0)
   691  
   692      @pytest.mark.P0
   693      @allure.title('Submit parammeter  proposal function verification')
   694      def test_PP_SU_005_PP_SU_006(self, no_vp_proposal, all_clients):
   695          pip = no_vp_proposal
   696          client = get_client_by_nodeid(pip.node.node_id, all_clients)
   697          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign', '',
   698                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   699          log.info('Submit param proposal result : {}'.format(result))
   700          assert_code(result, 3)
   701  
   702          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign', '1.1',
   703                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   704          log.info('Submit param proposal result : {}'.format(result))
   705          assert_code(result, 3)
   706  
   707          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign', '-1',
   708                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   709          log.info('Submit param proposal result : {}'.format(result))
   710          assert_code(result, 3)
   711  
   712          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign', '0',
   713                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   714          log.info('Submit param proposal result : {}'.format(result))
   715          assert_code(result, 3)
   716  
   717          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign', 1,
   718                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   719          log.info('Submit param proposal result : {}'.format(result))
   720          assert_code(result, 3)
   721  
   722          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign',
   723                                       '10001', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   724          log.info('Submit param proposal result : {}'.format(result))
   725          assert_code(result, 3)
   726  
   727          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign',
   728                                       str(get_governable_parameter_value(client, 'slashFractionDuplicateSign')),
   729                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   730          log.info('Submit param proposal result : {}'.format(result))
   731          assert_code(result, 302034)
   732  
   733          if int(get_governable_parameter_value(client, 'maxEvidenceAge')) != 1:
   734              result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign', '1',
   735                                           pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   736              log.info('Submit param proposal result : {}'.format(result))
   737              assert_code(result, 0)
   738  
   739      @pytest.mark.P0
   740      @allure.title('Submit parammeter  proposal function verification')
   741      def test_PP_SU_006(self, no_vp_proposal):
   742          pip = no_vp_proposal
   743          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign', '10000',
   744                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   745          log.info('Submit param proposal result : {}'.format(result))
   746          assert_code(result, 0)
   747  
   748      @pytest.mark.P0
   749      @allure.title('Submit parammeter  proposal function verification')
   750      def test_PP_SU_007_PP_SU_008(self, no_vp_proposal, all_clients):
   751          pip = no_vp_proposal
   752          client = get_client_by_nodeid(pip.node.node_id, all_clients)
   753          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward', '',
   754                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   755          log.info('Submit param proposal result : {}'.format(result))
   756          assert_code(result, 3)
   757  
   758          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward', '1.1',
   759                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   760          log.info('Submit param proposal result : {}'.format(result))
   761          assert_code(result, 3)
   762  
   763          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward', '-1',
   764                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   765          log.info('Submit param proposal result : {}'.format(result))
   766          assert_code(result, 3)
   767  
   768          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward', '0',
   769                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   770          log.info('Submit param proposal result : {}'.format(result))
   771          assert_code(result, 3)
   772  
   773          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward', 1,
   774                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   775          log.info('Submit param proposal result : {}'.format(result))
   776          assert_code(result, 3)
   777  
   778          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward',
   779                                       '81', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   780          log.info('Submit param proposal result : {}'.format(result))
   781          assert_code(result, 3)
   782  
   783          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward',
   784                                       str(get_governable_parameter_value(client, 'duplicateSignReportReward')),
   785                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   786          log.info('Submit param proposal result : {}'.format(result))
   787          assert_code(result, 302034)
   788  
   789          if int(get_governable_parameter_value(client, 'duplicateSignReportReward')) != 1:
   790              result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward', '1',
   791                                           pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   792              log.info('Submit param proposal result : {}'.format(result))
   793              assert_code(result, 0)
   794  
   795      @pytest.mark.P0
   796      @allure.title('Submit parammeter  proposal function verification')
   797      def test_PP_SU_008(self, no_vp_proposal, all_clients):
   798          pip = no_vp_proposal
   799          if int(get_governable_parameter_value(all_clients[0], 'duplicateSignReportReward')) != 80:
   800              result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward',
   801                                           '80', pip.node.staking_address,
   802                                           transaction_cfg=pip.cfg.transaction_cfg)
   803              log.info('Submit param proposal result : {}'.format(result))
   804              assert_code(result, 0)
   805  
   806      @pytest.mark.P0
   807      @allure.title('Submit parammeter  proposal function verification')
   808      def test_PP_SU_009_PP_SU_010(self, no_vp_proposal, all_clients):
   809          pip = no_vp_proposal
   810          client = get_client_by_nodeid(pip.node.node_id, all_clients)
   811          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold', '',
   812                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   813          log.info('Submit param proposal result : {}'.format(result))
   814          assert_code(result, 3)
   815  
   816          value = 10**18 * 1000000 + 0.1
   817          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold', str(value),
   818                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   819          log.info('Submit param proposal result : {}'.format(result))
   820          assert_code(result, 3)
   821  
   822          value = -10**18 * 1000000
   823          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold', str(value),
   824                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   825          log.info('Submit param proposal result : {}'.format(result))
   826          assert_code(result, 3)
   827  
   828          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold', '0',
   829                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   830          log.info('Submit param proposal result : {}'.format(result))
   831          assert_code(result, 3)
   832  
   833          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold', 10**18 * 1000000,
   834                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   835          log.info('Submit param proposal result : {}'.format(result))
   836          assert_code(result, 3)
   837  
   838          value = 10**18 * 1000000 - 1
   839          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold',
   840                                       str(value), pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   841          log.info('Submit param proposal result : {}'.format(result))
   842          assert_code(result, 3)
   843  
   844          value = 10**18 * 10000000 + 1
   845          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold',
   846                                       str(value), pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   847          log.info('Submit param proposal result : {}'.format(result))
   848          assert_code(result, 3)
   849  
   850          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold',
   851                                       str(get_governable_parameter_value(client, 'stakeThreshold')),
   852                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   853          log.info('Submit param proposal result : {}'.format(result))
   854          assert_code(result, 302034)
   855  
   856          if int(get_governable_parameter_value(client, 'stakeThreshold')) != 10**18 * 1000000:
   857              value = 10**18 * 1000000
   858              result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold', str(value),
   859                                           pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   860              log.info('Submit param proposal result : {}'.format(result))
   861              assert_code(result, 0)
   862  
   863      @pytest.mark.P0
   864      @allure.title('Submit parammeter  proposal function verification')
   865      def test_PP_SU_010(self, no_vp_proposal):
   866          pip = no_vp_proposal
   867          value = 10**18 * 10000000
   868          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold',
   869                                       str(value),
   870                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   871          log.info('Submit param proposal result : {}'.format(result))
   872          assert_code(result, 0)
   873  
   874      @pytest.mark.P0
   875      @allure.title('Submit parammeter  proposal function verification')
   876      def test_PP_SU_011_PP_SU_012(self, no_vp_proposal, all_clients):
   877          pip = no_vp_proposal
   878          client = get_client_by_nodeid(pip.node.node_id, all_clients)
   879          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold', '',
   880                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   881          log.info('Submit param proposal result : {}'.format(result))
   882          assert_code(result, 3)
   883  
   884          value = 10**18 * 10 + 0.5
   885          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold', str(value),
   886                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   887          log.info('Submit param proposal result : {}'.format(result))
   888          assert_code(result, 3)
   889  
   890          value = -10**18 * 10
   891          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold', str(value),
   892                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   893          log.info('Submit param proposal result : {}'.format(result))
   894          assert_code(result, 3)
   895  
   896          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold', '0',
   897                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   898          log.info('Submit param proposal result : {}'.format(result))
   899          assert_code(result, 3)
   900  
   901          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold', 1,
   902                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   903          log.info('Submit param proposal result : {}'.format(result))
   904          assert_code(result, 3)
   905  
   906          value = 10**18 * 10 - 1
   907          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold',
   908                                       str(value), pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   909          log.info('Submit param proposal result : {}'.format(result))
   910          assert_code(result, 3)
   911  
   912          value = 10**18 * 10000 + 1
   913          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold',
   914                                       str(value), pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   915          log.info('Submit param proposal result : {}'.format(result))
   916          assert_code(result, 3)
   917  
   918          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold',
   919                                       str(get_governable_parameter_value(client, 'operatingThreshold')),
   920                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   921          log.info('Submit param proposal result : {}'.format(result))
   922          assert_code(result, 302034)
   923  
   924          if int(get_governable_parameter_value(client, 'operatingThreshold')) != 10**18 * 10:
   925              value = 10**18 * 10
   926              result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold', str(value),
   927                                           pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   928              log.info('Submit param proposal result : {}'.format(result))
   929              assert_code(result, 0)
   930  
   931      @pytest.mark.P0
   932      @allure.title('Submit parammeter  proposal function verification')
   933      def test_PP_SU_012(self, no_vp_proposal):
   934          pip = no_vp_proposal
   935          value = 10**18 * 10000
   936          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold',
   937                                       str(value), pip.node.staking_address,
   938                                       transaction_cfg=pip.cfg.transaction_cfg)
   939          log.info('Submit param proposal result : {}'.format(result))
   940          assert_code(result, 0)
   941  
   942      @pytest.mark.P0
   943      @allure.title('Submit parammeter  proposal function verification')
   944      def test_PP_SU_013_PP_SU_014(self, no_vp_proposal, all_clients):
   945          pip = no_vp_proposal
   946          client = get_client_by_nodeid(pip.node.node_id, all_clients)
   947          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration', '',
   948                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   949          log.info('Submit param proposal result : {}'.format(result))
   950          assert_code(result, 3)
   951  
   952          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration', '10.5',
   953                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   954          log.info('Submit param proposal result : {}'.format(result))
   955          assert_code(result, 3)
   956  
   957          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration', '-100',
   958                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   959          log.info('Submit param proposal result : {}'.format(result))
   960          assert_code(result, 3)
   961  
   962          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration', '0',
   963                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   964          log.info('Submit param proposal result : {}'.format(result))
   965          assert_code(result, 3)
   966  
   967          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration', 11,
   968                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   969          log.info('Submit param proposal result : {}'.format(result))
   970          assert_code(result, 3)
   971  
   972          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration',
   973                                       '113', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   974          log.info('Submit param proposal result : {}'.format(result))
   975          assert_code(result, 3)
   976  
   977          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration',
   978                                       str(get_governable_parameter_value(client, 'unStakeFreezeDuration')),
   979                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   980          log.info('Submit param proposal result : {}'.format(result))
   981          assert_code(result, 302034)
   982  
   983          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration',
   984                                       str(get_governable_parameter_value(client, 'maxEvidenceAge')),
   985                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   986          log.info('Submit param proposal result : {}'.format(result))
   987          assert_code(result, 3)
   988  
   989          if int(get_governable_parameter_value(client, 'unStakeFreezeDuration')) != 112:
   990              result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration', '112',
   991                                           pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   992              log.info('Submit param proposal result : {}'.format(result))
   993              assert_code(result, 0)
   994  
   995      @pytest.mark.P0
   996      @allure.title('Submit parammeter  proposal function verification')
   997      def test__PP_SU_014(self, no_vp_proposal, all_clients):
   998          pip = no_vp_proposal
   999          if int(get_governable_parameter_value(all_clients[0], 'unStakeFreezeDuration')) != str(
  1000                  int(get_governable_parameter_value(all_clients[0], 'maxEvidenceAge')) - 1):
  1001              result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration',
  1002                                       str(int(get_governable_parameter_value(all_clients[0], 'maxEvidenceAge')) + 5),
  1003                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1004              log.info('Submit param proposal result : {}'.format(result))
  1005              assert_code(result, 0)
  1006  
  1007      @pytest.mark.P0
  1008      @allure.title('Submit parammeter  proposal function verification')
  1009      def test_PP_SU_015_PP_SU_016(self, no_vp_proposal, all_clients):
  1010          pip = no_vp_proposal
  1011          client = get_client_by_nodeid(pip.node.node_id, all_clients)
  1012          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', '',
  1013                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1014          log.info('Submit param proposal result : {}'.format(result))
  1015          assert_code(result, 3)
  1016  
  1017          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', '30.5',
  1018                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1019          log.info('Submit param proposal result : {}'.format(result))
  1020          assert_code(result, 3)
  1021  
  1022          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', '-100',
  1023                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1024          log.info('Submit param proposal result : {}'.format(result))
  1025          assert_code(result, 3)
  1026  
  1027          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', '0',
  1028                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1029          log.info('Submit param proposal result : {}'.format(result))
  1030          assert_code(result, 3)
  1031  
  1032          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', 25,
  1033                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1034          log.info('Submit param proposal result : {}'.format(result))
  1035          assert_code(result, 3)
  1036  
  1037          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators',
  1038                                       '3', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1039          log.info('Submit param proposal result : {}'.format(result))
  1040          assert_code(result, 3)
  1041  
  1042          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators',
  1043                                       '202', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1044          log.info('Submit param proposal result : {}'.format(result))
  1045          assert_code(result, 3)
  1046  
  1047          result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators',
  1048                                       str(get_governable_parameter_value(client, 'maxValidators')),
  1049                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1050          log.info('Submit param proposal result : {}'.format(result))
  1051          assert_code(result, 302034)
  1052  
  1053          if int(get_governable_parameter_value(client, 'maxValidators')) != 4:
  1054              result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', '4',
  1055                                           pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1056              log.info('Submit param proposal result : {}'.format(result))
  1057              assert_code(result, 0)
  1058  
  1059      @pytest.mark.P0
  1060      @allure.title('Submit parammeter  proposal function verification')
  1061      def test_PP_SU_016(self, no_vp_proposal, all_clients):
  1062          pip = no_vp_proposal
  1063          if int(get_governable_parameter_value(all_clients[0], 'maxValidators')) != 201:
  1064              result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', '201',
  1065                                           pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1066              log.info('Submit param proposal result : {}'.format(result))
  1067              assert_code(result, 0)
  1068  
  1069      @pytest.mark.P0
  1070      @allure.title('Submit parammeter  proposal function verification')
  1071      def test_PP_SU_016(self, no_vp_proposal, all_clients):
  1072          pip = no_vp_proposal
  1073          client = get_client_by_nodeid(pip.node.node_id, all_clients)
  1074          if int(get_governable_parameter_value(client, 'maxValidators')) != 201:
  1075              result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', '201',
  1076                                           pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1077              log.info('Submit param proposal result : {}'.format(result))
  1078              assert_code(result, 0)
  1079  
  1080      @pytest.mark.P0
  1081      @allure.title('Submit parammeter  proposal function verification')
  1082      def test_PP_SU_017_PP_SU_018(self, no_vp_proposal, all_clients):
  1083          pip = no_vp_proposal
  1084          client = get_client_by_nodeid(pip.node.node_id, all_clients)
  1085          result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit', '',
  1086                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1087          log.info('Submit param proposal result : {}'.format(result))
  1088          assert_code(result, 3)
  1089  
  1090          result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit', '4712388.5',
  1091                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1092          log.info('Submit param proposal result : {}'.format(result))
  1093          assert_code(result, 3)
  1094  
  1095          result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit', '-4712388',
  1096                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1097          log.info('Submit param proposal result : {}'.format(result))
  1098          assert_code(result, 3)
  1099  
  1100          result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit', '0',
  1101                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1102          log.info('Submit param proposal result : {}'.format(result))
  1103          assert_code(result, 3)
  1104  
  1105          result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit', 4712388,
  1106                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1107          log.info('Submit param proposal result : {}'.format(result))
  1108          assert_code(result, 3)
  1109  
  1110          result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit',
  1111                                       '4712387', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1112          log.info('Submit param proposal result : {}'.format(result))
  1113          assert_code(result, 3)
  1114  
  1115          result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit',
  1116                                       '210000001', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1117          log.info('Submit param proposal result : {}'.format(result))
  1118          assert_code(result, 3)
  1119  
  1120          result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit',
  1121                                       str(get_governable_parameter_value(client, 'maxBlockGasLimit')),
  1122                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1123          log.info('Submit param proposal result : {}'.format(result))
  1124          assert_code(result, 302034)
  1125  
  1126          if int(get_governable_parameter_value(client, 'maxBlockGasLimit')) != 4712388:
  1127              result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit', '4712388',
  1128                                           pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1129              log.info('Submit param proposal result : {}'.format(result))
  1130              assert_code(result, 0)
  1131  
  1132      @pytest.mark.P0
  1133      @allure.title('Submit parammeter  proposal function verification')
  1134      def test_PP_SU_018(self, no_vp_proposal):
  1135          pip = no_vp_proposal
  1136          result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit', '210000000',
  1137                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1138          log.info('Submit param proposal result : {}'.format(result))
  1139          assert_code(result, 0)
  1140  
  1141      @pytest.mark.P0
  1142      @allure.title('Submit parammeter  proposal function verification')
  1143      def test_PP_SU_019(self, no_vp_proposal):
  1144          pip = no_vp_proposal
  1145          result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', '', '1',
  1146                                       pip.node.staking_address,
  1147                                       transaction_cfg=pip.cfg.transaction_cfg)
  1148          log.info('Submit param proposal result : {}'.format(result))
  1149          assert_code(result, 302031)
  1150  
  1151          result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'unStakeFreezeDuration', '100',
  1152                                       pip.node.staking_address,
  1153                                       transaction_cfg=pip.cfg.transaction_cfg)
  1154          log.info('Submit param proposal result : {}'.format(result))
  1155          assert_code(result, 302031)
  1156  
  1157          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'SlashBlocksReward', '100',
  1158                                       pip.node.staking_address,
  1159                                       transaction_cfg=pip.cfg.transaction_cfg)
  1160          log.info('Submit param proposal result : {}'.format(result))
  1161          assert_code(result, 302031)
  1162  
  1163          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slash BlocksReward', '100',
  1164                                       pip.node.staking_address,
  1165                                       transaction_cfg=pip.cfg.transaction_cfg)
  1166          log.info('Submit param proposal result : {}'.format(result))
  1167          assert_code(result, 302031)
  1168  
  1169          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocks./,.Reward', '100',
  1170                                       pip.node.staking_address,
  1171                                       transaction_cfg=pip.cfg.transaction_cfg)
  1172          log.info('Submit param proposal result : {}'.format(result))
  1173          assert_code(result, 302031)
  1174  
  1175      @pytest.mark.P0
  1176      @allure.title('Submit parammeter  proposal function verification')
  1177      def test_PP_SU_020(self, no_vp_proposal):
  1178          pip = no_vp_proposal
  1179          result = pip.submitParam(pip.node.node_id, str(time.time()), '', 'slashBlocksReward', '100',
  1180                                       pip.node.staking_address,
  1181                                       transaction_cfg=pip.cfg.transaction_cfg)
  1182          log.info('Submit param proposal result : {}'.format(result))
  1183          assert_code(result, 302031)
  1184  
  1185          result = pip.submitParam(pip.node.node_id, str(time.time()), 'Slashing', 'slashBlocksReward', '100',
  1186                                       pip.node.staking_address,
  1187                                       transaction_cfg=pip.cfg.transaction_cfg)
  1188          log.info('Submit param proposal result : {}'.format(result))
  1189          assert_code(result, 302031)
  1190  
  1191          result = pip.submitParam(pip.node.node_id, str(time.time()), 'sLashing', 'SlashBlocksReward', '100',
  1192                                       pip.node.staking_address,
  1193                                       transaction_cfg=pip.cfg.transaction_cfg)
  1194          log.info('Submit param proposal result : {}'.format(result))
  1195          assert_code(result, 302031)
  1196  
  1197          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing123', 'slash BlocksReward', '100',
  1198                                       pip.node.staking_address,
  1199                                       transaction_cfg=pip.cfg.transaction_cfg)
  1200          log.info('Submit param proposal result : {}'.format(result))
  1201          assert_code(result, 302031)
  1202  
  1203          result = pip.submitParam(pip.node.node_id, str(time.time()), 's lashing', 'slashBlocks./,.Reward', '100',
  1204                                       pip.node.staking_address,
  1205                                       transaction_cfg=pip.cfg.transaction_cfg)
  1206          log.info('Submit param proposal result : {}'.format(result))
  1207          assert_code(result, 302031)
  1208  
  1209          result = pip.submitParam(pip.node.node_id, str(time.time()), 's.,.lashing', 'slashBlocks./,.Reward', '100',
  1210                                       pip.node.staking_address,
  1211                                       transaction_cfg=pip.cfg.transaction_cfg)
  1212          log.info('Submit param proposal result : {}'.format(result))
  1213          assert_code(result, 302031)
  1214  
  1215  
  1216  class TestSubmitPPAbnormal:
  1217      @pytest.mark.P0
  1218      @allure.title('New node submit parammeter  proposal function verification')
  1219      def test_PP_PR_002(self, no_vp_proposal, client_new_node):
  1220          pip = client_new_node.pip
  1221          address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000)
  1222          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '88',
  1223                                       address, transaction_cfg=pip.cfg.transaction_cfg)
  1224          log.info('new node submit param proposal result : {}'.format(result))
  1225          assert_code(result, 302022)
  1226  
  1227      @pytest.mark.P0
  1228      @allure.title('Candidate submit parammeter  proposal function verification')
  1229      def test_PP_PR_001(self, no_vp_proposal, client_candidate):
  1230          pip = client_candidate.pip
  1231          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '87',
  1232                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1233          log.info('candidate submit param proposal result :{}'.format(result))
  1234          assert_code(result, 302022)
  1235  
  1236      @pytest.mark.P0
  1237      @allure.title('There is a voting version proposal, submit parammeter  proposal function verification')
  1238      def test_PP_UN_002(self, submit_version):
  1239          pip = submit_version
  1240          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '99',
  1241                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1242          log.info('There is voting version proposal, submit a param proposal : {}'.format(result))
  1243          assert_code(result, 302012)
  1244  
  1245      @pytest.mark.P2
  1246      @allure.title('Abnormal submit parammeter  proposal function verification')
  1247      def test_PP_PR_003_PP_PR_004(self, no_vp_proposal, all_clients):
  1248          pip = no_vp_proposal
  1249          client = get_client_by_nodeid(pip.node.node_id, all_clients)
  1250          address = pip.node.staking_address
  1251          result = client.staking.withdrew_staking(address)
  1252          log.info('nodeid: {} withdrewstaking result: {}'.format(client.node.node_id, result))
  1253          assert_code(result, 0)
  1254          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward',
  1255                                       '86', address, transaction_cfg=pip.cfg.transaction_cfg)
  1256          log.info('node exiting,param proposal result: {}'.format(result))
  1257          assert_code(result, 302020)
  1258  
  1259          client.economic.wait_settlement_blocknum(client.node,
  1260                                                       number=client.economic.unstaking_freeze_ratio)
  1261          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward',
  1262                                       '86', address, transaction_cfg=pip.cfg.transaction_cfg)
  1263          log.info('exited node,cancel proposal result: {}'.format(result))
  1264          assert_code(result, 302022)
  1265  
  1266      @pytest.mark.P2
  1267      @allure.title('Not staking address submit parammeter  proposal function verification')
  1268      def test_PP_WA_001(self, no_vp_proposal):
  1269          pip = no_vp_proposal
  1270          address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000)
  1271          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '87',
  1272                                       address, transaction_cfg=pip.cfg.transaction_cfg)
  1273          log.info('candidate submit param proposal result :{}'.format(result))
  1274          assert_code(result, 302021)
  1275  
  1276  
  1277  class TestSubmitAgain:
  1278      @pytest.mark.P2
  1279      @allure.title('Submit parammeter  proposal function verification')
  1280      def test_PP_TI_001_002(self, new_genesis_env, clients_consensus):
  1281          genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config)
  1282          genesis.economicModel.gov.paramProposalVoteDurationSeconds = 0
  1283          new_genesis_env.set_genesis(genesis.to_dict())
  1284          new_genesis_env.deploy_all()
  1285          submitcppandvote(clients_consensus[:3], [1, 1, 1])
  1286          pip = clients_consensus[0].pip
  1287          proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal)
  1288          log.info('Param proposal information : {}'.format(proposalinfo_param))
  1289          proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal)
  1290          log.info('Cancel proposal information : {}'.format(proposalinfo_cancel))
  1291          wait_block_number(pip.node, proposalinfo_cancel.get('EndVotingBlock'))
  1292          assert_code(pip.get_status_of_proposal(proposalinfo_cancel.get('ProposalID')), 2)
  1293          assert_code(pip.get_status_of_proposal(proposalinfo_param.get('ProposalID')), 6)
  1294  
  1295          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '998',
  1296                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1297          log.info('Submit param proposal result : {}'.format(result))
  1298          assert_code(result, 0)
  1299          proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal)
  1300          log.info('Param proposal information : {}'.format(proposalinfo_param))
  1301          wait_block_number(pip.node, proposalinfo_param.get('EndVotingBlock'))
  1302  
  1303          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '998',
  1304                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1305          log.info('Submit param proposal result : {}'.format(result))
  1306          assert_code(result, 0)
  1307  
  1308      @pytest.mark.P2
  1309      @allure.title('Submit parammeter  proposal function verification')
  1310      def test_VP_TI_001_002(self, no_vp_proposal, clients_verifier):
  1311          submitcvpandvote(clients_verifier[:3], 1, 1, 1)
  1312          pip = clients_verifier[0].pip
  1313          proposalinfo_version = pip.get_effect_proposal_info_of_vote(pip.cfg.version_proposal)
  1314          log.info('Version proposal information : {}'.format(proposalinfo_version))
  1315          proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal)
  1316          log.info('Cancel proposal information : {}'.format(proposalinfo_cancel))
  1317          wait_block_number(pip.node, proposalinfo_cancel.get('EndVotingBlock'))
  1318          assert_code(pip.get_status_of_proposal(proposalinfo_cancel.get('ProposalID')), 2)
  1319          assert_code(pip.get_status_of_proposal(proposalinfo_version.get('ProposalID')), 6)
  1320  
  1321          result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1,
  1322                                         pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1323          log.info('Submit version proposal result : {}'.format(result))
  1324          assert_code(result, 0)
  1325          proposalinfo_version = pip.get_effect_proposal_info_of_vote(pip.cfg.version_proposal)
  1326          log.info('Version proposal information : {}'.format(proposalinfo_version))
  1327          wait_block_number(pip.node, proposalinfo_version.get('EndVotingBlock'))
  1328  
  1329          result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1,
  1330                                         pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1331          log.info('Submit version proposal result : {}'.format(result))
  1332          assert_code(result, 0)
  1333  
  1334  
  1335  class TestPIPVerify:
  1336      @pytest.mark.P0
  1337      @allure.title('Submit  proposal function verification---PIPID')
  1338      def test_VP_PIP_001_003_TP_PI_001_003_CP_PI_001_003_CP_PI_001_003(self, no_vp_proposal):
  1339          pip = no_vp_proposal
  1340          pip_id_text = str(time.time())
  1341          result = pip.submitText(pip.node.node_id, pip_id_text, pip.node.staking_address,
  1342                                      transaction_cfg=pip.cfg.transaction_cfg)
  1343          log.info('Submit text proposal result : {}'.format(result))
  1344          assert_code(result, 0)
  1345  
  1346          result = pip.submitVersion(pip.node.node_id, pip_id_text, pip.cfg.version5, 1, pip.node.staking_address,
  1347                                         transaction_cfg=pip.cfg.transaction_cfg)
  1348          log.info('Same PIPID, submit version proposal result : {}'.format(result))
  1349          assert_code(result, 302008)
  1350  
  1351          result = pip.submitText(pip.node.node_id, pip_id_text, pip.node.staking_address,
  1352                                      transaction_cfg=pip.cfg.transaction_cfg)
  1353          log.info('Same PIPID, submit text proposal result : {}'.format(result))
  1354          assert_code(result, 302008)
  1355  
  1356          result = pip.submitParam(pip.node.node_id, pip_id_text, 'slashing', 'slashBlocksReward', '889',
  1357                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1358          log.info('Same PIPID, submit param proposal result : {}'.format(result))
  1359          assert_code(result, 302008)
  1360  
  1361          result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 3,
  1362                                         pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1363          log.info('Differ PIPID, submit version proposal result : {}'.format(result))
  1364          assert_code(result, 0)
  1365  
  1366          proposalinfo_version = pip.get_effect_proposal_info_of_vote(pip.cfg.version_proposal)
  1367          log.info('Version proposal information : {}'.format(proposalinfo_version))
  1368          pip_id_version = proposalinfo_version.get('PIPID')
  1369  
  1370          result = pip.submitCancel(pip.node.node_id, pip_id_text, 1, proposalinfo_version.get('ProposalID'),
  1371                                        pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1372          log.info('Same PIPID, submit cancel proposal result : {}'.format(result))
  1373          assert_code(result, 302008)
  1374  
  1375          result = pip.submitCancel(pip.node.node_id, pip_id_version, 1, proposalinfo_version.get('ProposalID'),
  1376                                        pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1377          log.info('Same PIPID, submit cancel proposal result : {}'.format(result))
  1378          assert_code(result, 302008)
  1379  
  1380          result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo_version.get('ProposalID'),
  1381                                        pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1382          log.info('Differ PIPID, submit cancel proposal result : {}'.format(result))
  1383          assert_code(result, 0)
  1384  
  1385          proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal)
  1386          log.info('Version proposal information : {}'.format(proposalinfo_cancel))
  1387          pip_id_cancel = proposalinfo_cancel.get('PIPID')
  1388  
  1389          result = pip.submitText(pip.node.node_id, pip_id_version, pip.node.staking_address,
  1390                                      transaction_cfg=pip.cfg.transaction_cfg)
  1391          log.info('Same PIPID, submit text proposal result : {}'.format(result))
  1392          assert_code(result, 302008)
  1393  
  1394          result = pip.submitText(pip.node.node_id, pip_id_cancel, pip.node.staking_address,
  1395                                      transaction_cfg=pip.cfg.transaction_cfg)
  1396          log.info('Same PIPID, submit text proposal result : {}'.format(result))
  1397          assert_code(result, 302008)
  1398  
  1399          wait_block_number(pip.node, proposalinfo_version.get('EndVotingBlock'))
  1400          result = pip.submitVersion(pip.node.node_id, pip_id_version, pip.cfg.version5, 1,
  1401                                         pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1402          log.info('Same PIPID, submit version proposal result : {}'.format(result))
  1403          assert_code(result, 0)
  1404  
  1405          proposalinfo_version = pip.get_effect_proposal_info_of_vote(pip.cfg.version_proposal)
  1406          log.info('Version proposal information : {}'.format(proposalinfo_version))
  1407          wait_block_number(pip.node, proposalinfo_version.get('EndVotingBlock'))
  1408          result = pip.submitParam(pip.node.node_id, pip_id_version, 'slashing', 'slashBlocksReward', '889',
  1409                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1410          log.info('Differ PIPID, submit param proposal result : {}'.format(result))
  1411          assert_code(result, 0)
  1412  
  1413          proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal)
  1414          log.info('Param proposal information : {}'.format(proposalinfo_param))
  1415  
  1416          result = pip.submitCancel(pip.node.node_id, pip_id_cancel, 1, proposalinfo_param.get('ProposalID'),
  1417                                        pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1418          log.info('Same PIPID, submit cancel proposal result : {}'.format(result))
  1419          assert_code(result, 0)
  1420  
  1421          proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal)
  1422          log.info('Cancel proposal information : {}'.format(proposalinfo_cancel))
  1423  
  1424          wait_block_number(pip.node, proposalinfo_cancel.get('EndVotingBlock'))
  1425          result = pip.submitText(pip.node.node_id, pip_id_cancel, pip.node.staking_address,
  1426                                      transaction_cfg=pip.cfg.transaction_cfg)
  1427          log.info('Same PIPID, submit text proposal result : {}'.format(result))
  1428          assert_code(result, 0)
  1429  
  1430      @pytest.mark.P0
  1431      @allure.title('Submit  proposal function verification---PIPID')
  1432      def test_VP_PIP_002_TP_PI_002_CP_PI_002_CP_PI_002(self, no_vp_proposal, clients_verifier):
  1433          pip = clients_verifier[0].pip
  1434          submitcvpandvote(clients_verifier, 1, 1, 1, 1)
  1435          proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal)
  1436          pip_id = proposalinfo.get('PIPID')
  1437          wait_block_number(pip.node, proposalinfo.get('EndVotingBlock'))
  1438          assert_code(pip.get_status_of_proposal(proposalinfo.get('ProposalID')), 2)
  1439          result = pip.submitText(pip.node.node_id, pip_id, pip.node.staking_address,
  1440                                      transaction_cfg=pip.cfg.transaction_cfg)
  1441          log.info('Same pipid, submit text proposal result : {}'.format(result))
  1442          assert_code(result, 302008)
  1443          result = pip.submitVersion(pip.node.node_id, pip_id, pip.cfg.version5, 1, pip.node.staking_address,
  1444                                         transaction_cfg=pip.cfg.transaction_cfg)
  1445          log.info('Same pipid, submit text proposal result : {}'.format(result))
  1446          assert_code(result, 302008)
  1447  
  1448          result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 2,
  1449                                         pip.node.staking_address,
  1450                                         transaction_cfg=pip.cfg.transaction_cfg)
  1451          log.info('Differ pipid, submit version proposal result : {}'.format(result))
  1452          assert_code(result, 0)
  1453          proposalinfo_version = pip.get_effect_proposal_info_of_vote()
  1454          log.info('Proposal information : {}'.format(proposalinfo_version))
  1455          result = pip.submitCancel(pip.node.node_id, pip_id, 1, proposalinfo_version.get('ProposalID'),
  1456                                        pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1457          log.info('Same pipid, submit cancel proposal result : {}'.format(result))
  1458          assert_code(result, 302008)
  1459  
  1460          wait_block_number(pip.node, proposalinfo_version.get('EndVotingBlock'))
  1461          result = pip.submitParam(pip.node.node_id, pip_id, 'slashing', 'slashBlocksReward', '19',
  1462                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1463          log.info('Same pipid, submit param proposal result : {}'.format(result))
  1464          assert_code(result, 302008)
  1465  
  1466          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '19',
  1467                                       pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1468          log.info('Differ pipid, submit param proposal result : {}'.format(result))
  1469          assert_code(result, 0)
  1470  
  1471          proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal)
  1472          log.info('Get param proposal information : {}'.format(proposalinfo_param))
  1473  
  1474          result = pip.submitCancel(pip.node.node_id, pip_id, 1, proposalinfo_param.get('ProposalID'),
  1475                                        pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1476          log.info('Same pipid, submit cancel proposal result : {}'.format(result))
  1477          assert_code(result, 302008)
  1478  
  1479  
  1480  @pytest.mark.P0
  1481  @allure.title('Submit cancel  proposal function verification---endvoting rounds')
  1482  def test_CP_CR_003_CP_CR_004(submit_param):
  1483      pip = submit_param
  1484      proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal)
  1485      log.info('proposalinfo: {}'.format(proposalinfo))
  1486      endvoting_rounds = (proposalinfo.get('EndVotingBlock') - math.ceil(
  1487          pip.node.block_number / pip.economic.consensus_size) * pip.economic.consensus_size
  1488          ) / pip.economic.consensus_size
  1489      result = pip.submitCancel(pip.node.node_id, str(time.time()), endvoting_rounds + 1,
  1490                                    proposalinfo.get('ProposalID'), pip.node.staking_address,
  1491                                    transaction_cfg=pip.cfg.transaction_cfg)
  1492      log.info('endvoting_rounds:{}, cancel proposal result:{}'.format(endvoting_rounds, result))
  1493      assert_code(result, 302010)
  1494  
  1495      result = pip.submitCancel(pip.node.node_id, str(time.time()), endvoting_rounds,
  1496                                    proposalinfo.get('ProposalID'), pip.node.staking_address,
  1497                                    transaction_cfg=pip.cfg.transaction_cfg)
  1498      log.info('endvoting_rounds:{}, cancel proposal result:{}'.format(endvoting_rounds + 1, result))
  1499      assert_code(result, 0)
  1500  
  1501  
  1502  class TestGas:
  1503      @pytest.mark.P2
  1504      @allure.title('Submit version proposal function verification---gasprice')
  1505      def test_VP_GP_001_VP_GP_002(self, no_vp_proposal):
  1506          pip = no_vp_proposal
  1507          transaction_cfg = {"gasPrice": 2100000000000000 - 1}
  1508          try:
  1509              pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1,
  1510                                    pip.node.staking_address, transaction_cfg=transaction_cfg)
  1511          except ValueError as e:
  1512              assert e.args[0].get('message') == "the tx data is invalid: Invalid parameter:Gas price under the min gas price."
  1513  
  1514          transaction_cfg = {"gasPrice": 2100000000000000}
  1515          result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1,
  1516                                         pip.node.staking_address, transaction_cfg=transaction_cfg)
  1517          log.info('Submit version proposal result : {}'.format(result))
  1518          assert_code(result, 0)
  1519  
  1520      @pytest.mark.P2
  1521      @allure.title('Submit param proposal function verification---gasprice')
  1522      def test_PP_GP_001_PP_GP_002(self, no_vp_proposal):
  1523          pip = no_vp_proposal
  1524          transaction_cfg = {"gasPrice": 2000000000000000 - 1}
  1525          try:
  1526              pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '123',
  1527                                  pip.node.staking_address, transaction_cfg=transaction_cfg)
  1528          except ValueError as e:
  1529              assert e.args[0].get('message') == "the tx data is invalid: Invalid parameter:Gas price under the min gas price."
  1530  
  1531          transaction_cfg = {"gasPrice": 2000000000000000}
  1532          result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '123',
  1533                                       pip.node.staking_address, transaction_cfg=transaction_cfg)
  1534          log.info('Submit param proposal result : {}'.format(result))
  1535          assert_code(result, 0)
  1536  
  1537      @pytest.mark.P2
  1538      @allure.title('Submit text proposal function verification---gasprice')
  1539      def test_TP_GP_001_TP_GP_002(self, client_verifier):
  1540          pip = client_verifier.pip
  1541          transaction_cfg = {"gasPrice": 1500000000000000 - 1}
  1542          try:
  1543              pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address,
  1544                                 transaction_cfg=transaction_cfg)
  1545          except ValueError as e:
  1546              assert e.args[0].get('message') == "the tx data is invalid: Invalid parameter:Gas price under the min gas price."
  1547  
  1548          transaction_cfg = {"gasPrice": 1500000000000000}
  1549          result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address,
  1550                                      transaction_cfg=transaction_cfg)
  1551          log.info('Submit text proposal result : {}'.format(result))
  1552          assert_code(result, 0)
  1553  
  1554      @pytest.mark.P2
  1555      @allure.title('Submit cancel proposal function verification---gas')
  1556      def test_CP_GP_001_CP_GP_002(self, no_vp_proposal):
  1557          pip = no_vp_proposal
  1558          transaction_cfg = {"gasPrice": 3000000000000000 - 1, "gas": 100000}
  1559          try:
  1560              result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 3,
  1561                                             pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
  1562              assert_code(result, 0)
  1563              proposalinfo = pip.get_effect_proposal_info_of_vote()
  1564              log.info('Get proposal information {}'.format(proposalinfo))
  1565              pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo.get('ProposalID'),
  1566                                   pip.node.staking_address, transaction_cfg=transaction_cfg)
  1567          except ValueError as e:
  1568              assert e.args[0].get('message') == "the tx data is invalid: Invalid parameter:Gas price under the min gas price."
  1569          transaction_cfg = {"gasPrice": 3000000000000000}
  1570          result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo.get('ProposalID'),
  1571                                        pip.node.staking_address, transaction_cfg=transaction_cfg)
  1572          log.info('Submit cancel proposal result : {}'.format(result))
  1573          assert_code(result, 0)
  1574  
  1575  if __name__ == '__main__':
  1576      pytest.main(['./tests/govern/', '-s', '-q', '--alluredir', './report/report'])