fix 2

consensus/tests/engine_v2_tests/adaptor_test.go

@@ -136,7 +136,7 @@ func TestAdaptorGetMasternodesV2(t *testing.T) {
 	err := blockchain.InsertBlock(currentBlock)
 	assert.Nil(t, err)
 	masternodes1 := adaptor.GetMasternodes(blockchain, currentBlock.Header())
-	assert.Equal(t, 20, len(masternodes1))
+	assert.Equal(t, 5, len(masternodes1))
 	masternodes1ByNumber := adaptor.GetMasternodesByNumber(blockchain, currentBlock.NumberU64())
 	assert.True(t, reflect.DeepEqual(masternodes1, masternodes1ByNumber), "at block number", blockNum)
 	for blockNum = 902; blockNum < 915; blockNum++ {

consensus/tests/engine_v2_tests/authorised_masternode_test.go

@@ -1,7 +1,6 @@
 package engine_v2_tests
 
 import (
-	"fmt"
 	"math/big"
 	"testing"
 	"time"
@@ -47,21 +46,25 @@ func TestIsYourTurnConsensusV2(t *testing.T) {
 	err := blockchain.InsertBlock(currentBlock)
 	assert.Nil(t, err)
 	// Less then Mine Period
-	isYourTurn, err := adaptor.YourTurn(blockchain, currentBlockHeader, common.StringToAddress(fmt.Sprintf("%02d", 2)))
+	// isYourTurn, err := adaptor.YourTurn(blockchain, currentBlockHeader, common.StringToAddress(fmt.Sprintf("%02d", 2)))
+	isYourTurn, err := adaptor.YourTurn(blockchain, currentBlockHeader, acc2Addr)
 	assert.Nil(t, err)
 	assert.False(t, isYourTurn)
 
 	time.Sleep(time.Duration(minePeriod) * time.Second)
 	// The second address is valid as the round starting from 1
-	isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, common.StringToAddress(fmt.Sprintf("%02d", 2)))
+	// isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, common.StringToAddress(fmt.Sprintf("%02d", 2)))
+	isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, acc2Addr)
 	assert.Nil(t, err)
 	assert.True(t, isYourTurn)
 
 	// The first and third address are not valid
-	isYourTurn, err = adaptor.YourTurn(blockchain, currentBlock.Header(), common.StringToAddress(fmt.Sprintf("%02d", 1)))
+	// isYourTurn, err = adaptor.YourTurn(blockchain, currentBlock.Header(), common.StringToAddress(fmt.Sprintf("%02d", 1)))
+	isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, acc1Addr)
 	assert.Nil(t, err)
 	assert.False(t, isYourTurn)
-	isYourTurn, err = adaptor.YourTurn(blockchain, currentBlock.Header(), common.StringToAddress(fmt.Sprintf("%02d", 3)))
+	// isYourTurn, err = adaptor.YourTurn(blockchain, currentBlock.Header(), common.StringToAddress(fmt.Sprintf("%02d", 3)))
+	isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, acc3Addr)
 	assert.Nil(t, err)
 	assert.False(t, isYourTurn)
 
@@ -73,13 +76,16 @@ func TestIsYourTurnConsensusV2(t *testing.T) {
 	time.Sleep(time.Duration(minePeriod) * time.Second)
 
 	adaptor.EngineV2.SetNewRoundFaker(blockchain, 2, false)
-	isYourTurn, _ = adaptor.YourTurn(blockchain, currentBlock.Header(), common.StringToAddress(fmt.Sprintf("%02d", 2)))
+	// isYourTurn, _ = adaptor.YourTurn(blockchain, currentBlock.Header(), common.StringToAddress(fmt.Sprintf("%02d", 2)))
+	isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, acc2Addr)
 	assert.False(t, isYourTurn)
 
-	isYourTurn, _ = adaptor.YourTurn(blockchain, currentBlock.Header(), common.StringToAddress(fmt.Sprintf("%02d", 3)))
+	// isYourTurn, _ = adaptor.YourTurn(blockchain, currentBlock.Header(), common.StringToAddress(fmt.Sprintf("%02d", 3)))
+	isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, acc3Addr)
 	assert.True(t, isYourTurn)
 
-	isYourTurn, _ = adaptor.YourTurn(blockchain, currentBlock.Header(), common.StringToAddress(fmt.Sprintf("%02d", 1)))
+	// isYourTurn, _ = adaptor.YourTurn(blockchain, currentBlock.Header(), common.StringToAddress(fmt.Sprintf("%02d", 1)))
+	isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, acc1Addr)
 	assert.False(t, isYourTurn)
 
 }
@@ -100,7 +106,8 @@ func TestIsYourTurnConsensusV2CrossConfig(t *testing.T) {
 	assert.Nil(t, err)
 	// after first mine period
 	time.Sleep(time.Duration(firstMinePeriod) * time.Second)
-	isYourTurn, err := adaptor.YourTurn(blockchain, currentBlockHeader, common.HexToAddress("xdc0000000000000000000000000000000000003131"))
+	// isYourTurn, err := adaptor.YourTurn(blockchain, currentBlockHeader, common.HexToAddress("xdc0000000000000000000000000000000000003131"))
+	isYourTurn, err := adaptor.YourTurn(blockchain, currentBlockHeader, acc1Addr)
 	assert.Nil(t, err)
 	assert.False(t, isYourTurn)
 
@@ -110,7 +117,8 @@ func TestIsYourTurnConsensusV2CrossConfig(t *testing.T) {
 	secondMinePeriod := blockchain.Config().XDPoS.V2.CurrentConfig.MinePeriod
 
 	time.Sleep(time.Duration(secondMinePeriod-firstMinePeriod) * time.Second)
-	isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, common.HexToAddress("xdc0000000000000000000000000000000000003131"))
+	// isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, common.HexToAddress("xdc0000000000000000000000000000000000003131"))
+	isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, acc1Addr)
 	assert.Nil(t, err)
 	assert.True(t, isYourTurn)
 }

consensus/tests/engine_v2_tests/helper.go

@@ -143,7 +143,7 @@ func getCommonBackend(t *testing.T, chainConfig *params.ChainConfig, signer comm
 
 	caps = append(caps, voterCap, acc1Cap, acc2Cap, acc3Cap, signerCap)
 	candidates = append(candidates, voterAddr, acc1Addr, acc2Addr, acc3Addr, signer)
-	candidates = append([]common.Address{}, voterAddr, acc1Addr, acc2Addr, acc3Addr, signer)
+	candidates = append([]common.Address{}, acc1Addr, acc2Addr, acc3Addr, signer, voterAddr)
 	fmt.Println("initial setup candidates", candidates)
 	for i := 0; i < len(candidates); i++ {
 		fmt.Println(candidates[i].Hex())
@@ -237,6 +237,7 @@ func getMultiCandidatesBackend(t *testing.T, chainConfig *params.ChainConfig, n
 	voterCap.SetString("2000000000", 10) // give voter the highest cap to make it win the masternode selection
 
 	caps = append(caps, voterCap, acc1Cap, acc2Cap, acc3Cap)
+	candidates = append(candidates, voterAddr, acc1Addr, acc2Addr, acc3Addr)
 
 	// initial helper backend, give a very large gas limit
 	contractBackendForSC := backends.NewXDCSimulatedBackend(core.GenesisAlloc{
@@ -613,7 +614,7 @@ func PrepareQCandProcess(t *testing.T, blockchain *BlockChain, currentBlock *typ
 func CreateBlock(blockchain *BlockChain, chainConfig *params.ChainConfig, startingBlock *types.Block, blockNumber int, roundNumber int64, blockCoinBase string, signer common.Address, signFn func(account accounts.Account, hash []byte) ([]byte, error), penalties []common.Address, signersKey []*ecdsa.PrivateKey, merkleRoot string) *types.Block {
 	currentBlock := startingBlock
 	if len(merkleRoot) == 0 {
-		merkleRoot = "5658f4800d32dcf4e82ec393c1b4d90d3efb46959eb69ea0f5920bc50da2fd51"
+		merkleRoot = "dcd8c0551ccc086594ad552dfd2c2fae99dc51ef5a4de6c84fe8dcd5c48b5883"
 	}
 	var header *types.Header
 	statedb, err := blockchain.State()

consensus/tests/engine_v2_tests/mine_test.go

@@ -28,7 +28,7 @@ func TestYourTurnInitialV2(t *testing.T) {
 	t.Logf("Inserting block with propose at 11...")
 	blockCoinbaseA := "0xaaa0000000000000000000000000000000000011"
 	//Get from block validator error message
-	merkleRoot := "b3e34cf1d3d80bcd2c5add880842892733e45979ddaf16e531f660fdf7ca5787"
+	merkleRoot := "dcd8c0551ccc086594ad552dfd2c2fae99dc51ef5a4de6c84fe8dcd5c48b5883"
 	extraInBytes := generateV2Extra(11, parentBlock, signer, signFn, nil)
 
 	header := &types.Header{
@@ -55,10 +55,12 @@ func TestYourTurnInitialV2(t *testing.T) {
 	time.Sleep(time.Duration(minePeriod) * time.Second)
 
 	// YourTurn is called before mine first v2 block
-	b, err := adaptor.YourTurn(blockchain, block11.Header(), common.HexToAddress("xdc0000000000000000000000000000000000003031"))
+	// b, err := adaptor.YourTurn(blockchain, block11.Header(), common.HexToAddress("xdc0000000000000000000000000000000000003031"))
+	b, err := adaptor.YourTurn(blockchain, block11.Header(), acc1Addr)
 	assert.Nil(t, err)
 	assert.False(t, b)
-	b, err = adaptor.YourTurn(blockchain, block11.Header(), common.HexToAddress("xdc0000000000000000000000000000000000003132"))
+	// b, err = adaptor.YourTurn(blockchain, block11.Header(), common.HexToAddress("xdc0000000000000000000000000000000000003132"))
+	b, err = adaptor.YourTurn(blockchain, block11.Header(), acc2Addr)
 	assert.Nil(t, err)
 	// round=1, so masternode[1] has YourTurn = True
 	assert.True(t, b)
@@ -128,7 +130,7 @@ func TestUpdateMasterNodes(t *testing.T) {
 		t.Fatal(err)
 	}
 	//Get from block validator error message
-	merkleRoot := "42970e0f2265db7d85d0d9cd7328d58bd53bdb54d85d7997e95a1c3f60845602"
+	merkleRoot := "9a6581d720171de875e57b76ec70bebc5973229b35faf9597e2d6a56b5887200"
 	header := &types.Header{
 		Root:       common.HexToHash(merkleRoot),
 		Number:     big.NewInt(int64(1350)),
@@ -247,7 +249,7 @@ func TestPrepareHappyPath(t *testing.T) {
 	}
 	// process QC for passing prepare verification
 
-	adaptor.EngineV2.SetNewRoundFaker(blockchain, types.Round(919), false) // round 919 is this signer's turn to mine
+	adaptor.EngineV2.SetNewRoundFaker(blockchain, types.Round(916), false) // round 916 is this signer's turn to mine
 	err = adaptor.Prepare(blockchain, header900)
 	assert.Nil(t, err)
 
@@ -256,7 +258,7 @@ func TestPrepareHappyPath(t *testing.T) {
 	var decodedExtraField types.ExtraFields_v2
 	err = utils.DecodeBytesExtraFields(header900.Extra, &decodedExtraField)
 	assert.Nil(t, err)
-	assert.Equal(t, types.Round(919), decodedExtraField.Round)
+	assert.Equal(t, types.Round(916), decodedExtraField.Round)
 	assert.Equal(t, types.Round(899), decodedExtraField.QuorumCert.ProposedBlockInfo.Round)
 }