change test plan and log output

operator/noRelatedCase.go

@@ -31,6 +31,7 @@ func NrCoinTranCase(txCount int, testAccArr *tool.AccArrFormat, accountNonceMap
 		ChainId:  tool.Cfg.ChainId,
 	}
 	sendBeforeBal := make(map[common.Address]*big.Int, 0)
+	receiveBeforeBal := make(map[common.Address]*big.Int, 0)
 	for i := 0; i < txCount; i++ {
 		toAddr := testAccArr.ToAddr[i]
 		fromAddr := testAccArr.FromAddr[i]
@@ -38,7 +39,12 @@ func NrCoinTranCase(txCount int, testAccArr *tool.AccArrFormat, accountNonceMap
 		if beforeBal == nil {
 			return nil, nil
 		}
+		beforeToBal := util.GetAccBal(client, toAddr)
+		if beforeBal == nil {
+			return nil, nil
+		}
 		sendBeforeBal[fromAddr] = beforeBal
+		receiveBeforeBal[toAddr] = beforeToBal
 		coinTrade.FromPrv = testAccArr.FromPrv[i]
 		value, _ := accountNonceMap.Load(fromAddr)
 		coinTrade.FromNonce = big.NewInt(value.(int64))
@@ -51,21 +57,35 @@ func NrCoinTranCase(txCount int, testAccArr *tool.AccArrFormat, accountNonceMap
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		for i := 0; i < txCount; i++ {
+			toAddr := testAccArr.ToAddr[i]
 			fromAddr := testAccArr.FromAddr[i]
 			sendAfterBal := util.GetAccBal(client, fromAddr)
 			if sendAfterBal == nil {
 				log.Error("Verify error:", "get sendAfterBal err")
-				return false
+				res = false
+			}
+			receiveAfterBal := util.GetAccBal(client, toAddr)
+			if receiveAfterBal == nil {
+				log.Error("Verify error:", "get receiveAfterBal err")
+				res = false
 			}
+			subToBal := receiveAfterBal.Sub(receiveAfterBal, receiveBeforeBal[toAddr])
+			if subToBal.Cmp(amount) != 0 {
+				log.Error("receiveAfterBal:", receiveAfterBal)
+				log.Error("receiveBeforeBal[toAddr]:", receiveBeforeBal[toAddr])
+				res = false
+			}
+
 			subBal := sendBeforeBal[fromAddr].Sub(sendBeforeBal[fromAddr], sendAfterBal)
 			if subBal.Cmp(amount) != 1 {
-				log.Error("sendBeforeBal[fromAddr]:", sendBeforeBal[fromAddr])
+				log.Error("sendBeforeBal[fromAddr]:", sendBeforeBal[fromAddr].String())
 				log.Error("sendAfterBal:", sendAfterBal)
-				return false
+				res = false
 			}
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -82,17 +102,31 @@ func NrContractCoinTranCase(txCount int, testAccArr *tool.AccArrFormat, contract
 		log.Error("NewChainCoinTransfer error:", err.Error())
 		return nil, nil
 	}
+	sendBeforeFromBal := make(map[common.Address]*big.Int, 0)
+	sendBeforeToBal := make(map[common.Address]*big.Int, 0)
 	sendBeforeBal := util.GetAccBal(client, coinTranAddr)
 	if sendBeforeBal == nil {
 		return nil, nil
 	}
-	for i := 0; i < txCount; i++ {
-		contractCoinTrade.ToAddr = []common.Address{testAccArr.ToAddr[i]}
+	for i := 0; i < 2; i++ {
+		from := testAccArr.FromAddr[i]
+		to := testAccArr.ToAddr[i]
+		fromBal := util.GetAccBal(client, from)
+		if fromBal == nil {
+			return nil, nil
+		}
+		sendBeforeFromBal[from] = fromBal
+		toBal := util.GetAccBal(client, to)
+		if toBal == nil {
+			return nil, nil
+		}
+		sendBeforeToBal[to] = toBal
+		contractCoinTrade.ToAddr = []common.Address{to}
 		auth, err := bind.NewKeyedTransactorWithChainID(testAccArr.FromPrv[i], tool.Cfg.ChainId)
 		if err != nil {
 			log.Errorf("DeployTokenTransfer func newKeyedTransactorWithChainID err:", err)
 		}
-		value, _ := accountNonceMap.Load(testAccArr.FromAddr[i])
+		value, _ := accountNonceMap.Load(from)
 		auth.Nonce = big.NewInt(value.(int64))
 		auth.NoSend = true
 		auth.GasLimit = 500000
@@ -104,14 +138,41 @@ func NrContractCoinTranCase(txCount int, testAccArr *tool.AccArrFormat, contract
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		sendAfterBal := util.GetAccBal(client, coinTranAddr)
 		if sendAfterBal == nil {
-			return false
-		}
-		if sendBeforeBal.Sub(sendBeforeBal, sendAfterBal).Cmp(amount.Mul(amount, big.NewInt(int64(txCount)))) != 0 {
-			return false
+			res = false
+		}
+		if sendBeforeBal.Sub(sendBeforeBal, sendAfterBal).Cmp(amount.Mul(amount, big.NewInt(int64(2)))) != 0 {
+			res = false
+		}
+		for i := 0; i < 2; i++ {
+			from := testAccArr.FromAddr[i]
+			to := testAccArr.ToAddr[i]
+			fromBal := util.GetAccBal(client, from)
+			if fromBal == nil {
+				log.Error("Verify get from bal failed")
+				res = false
+			}
+			if sendBeforeFromBal[from].Sub(sendBeforeFromBal[from], fromBal).Cmp(big.NewInt(0)) != 1 {
+				log.Error("From bal verify failed")
+				res = false
+			} else {
+				log.Info("From bal verify successful")
+			}
+			toBal := util.GetAccBal(client, to)
+			if toBal == nil {
+				log.Error("Verify get to bal failed")
+				res = false
+			}
+			if toBal.Sub(toBal, sendBeforeToBal[to]).Cmp(amount) != 0 {
+				log.Error("To bal verify failed")
+				res = false
+			} else {
+				log.Info("To bal verify successful")
+			}
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -129,17 +190,31 @@ func NrContractOneCoinTranCase(txCount int, testAccArr *tool.AccArrFormat, contr
 		log.Error("NewOneChainCoinTransfer error:", err.Error())
 		return nil, nil
 	}
+	sendBeforeFromBal := make(map[common.Address]*big.Int, 0)
+	sendBeforeToBal := make(map[common.Address]*big.Int, 0)
 	sendBeforeBal := util.GetAccBal(client, coinTranAddr)
 	if sendBeforeBal == nil {
 		return nil, nil
 	}
 	for i := 0; i < txCount; i++ {
-		contractCoinOneTrade.ToAddr = []common.Address{testAccArr.ToAddr[i]}
+		from := testAccArr.FromAddr[i]
+		to := testAccArr.ToAddr[i]
+		fromBal := util.GetAccBal(client, from)
+		if fromBal == nil {
+			return nil, nil
+		}
+		sendBeforeFromBal[from] = fromBal
+		toBal := util.GetAccBal(client, to)
+		if toBal == nil {
+			return nil, nil
+		}
+		sendBeforeToBal[to] = toBal
+		contractCoinOneTrade.ToAddr = []common.Address{to}
 		auth, err := bind.NewKeyedTransactorWithChainID(testAccArr.FromPrv[i], tool.Cfg.ChainId)
 		if err != nil {
 			log.Errorf("DeployTokenTransfer func newKeyedTransactorWithChainID err:", err)
 		}
-		value, _ := accountNonceMap.Load(testAccArr.FromAddr[i])
+		value, _ := accountNonceMap.Load(from)
 		auth.Nonce = big.NewInt(value.(int64))
 		auth.NoSend = true
 		auth.GasLimit = 500000
@@ -152,14 +227,41 @@ func NrContractOneCoinTranCase(txCount int, testAccArr *tool.AccArrFormat, contr
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		sendAfterBal := util.GetAccBal(client, coinTranAddr)
 		if sendAfterBal == nil {
-			return false
+			res = false
 		}
 		if sendBeforeBal.Sub(sendBeforeBal, sendAfterBal).Cmp(amount.Mul(amount, big.NewInt(int64(txCount)))) != 0 {
-			return false
+			res = false
+		}
+		for i := 0; i < txCount; i++ {
+			from := testAccArr.FromAddr[i]
+			to := testAccArr.ToAddr[i]
+			fromBal := util.GetAccBal(client, from)
+			if fromBal == nil {
+				log.Error("Verify get from bal failed")
+				res = false
+			}
+			if sendBeforeFromBal[from].Sub(sendBeforeFromBal[from], fromBal).Cmp(big.NewInt(0)) != 1 {
+				log.Error("From bal verify failed")
+				res = false
+			} else {
+				log.Info("From bal verify successful")
+			}
+			toBal := util.GetAccBal(client, to)
+			if toBal == nil {
+				log.Error("Verify get to bal failed")
+				res = false
+			}
+			if toBal.Sub(toBal, sendBeforeToBal[to]).Cmp(amount) != 0 {
+				log.Error("To bal verify failed")
+				res = false
+			} else {
+				log.Info("To bal verify successful")
+			}
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -196,16 +298,17 @@ func NrWRTranCase(testAccArr *tool.AccArrFormat, contractMap map[string]common.A
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		varString, err := readWriteVar.GetVarString(&bind.CallOpts{})
 		if err != nil {
 			log.Error("GetVarString error:", err.Error())
-			return false
+			res = false
 		}
 		if varString != readWriteTrade.StringParam {
 			log.Error(varString, " != ", readWriteTrade.StringParam)
-			return false
+			res = false
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -244,16 +347,17 @@ func NrOneWRTranCase(testAccArr *tool.AccArrFormat, contractMap map[string]commo
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		varString, err := readWriteVar.OneGetVarString(&bind.CallOpts{}, readWriteAddr)
 		if err != nil {
 			log.Error("GetVarString error:", err.Error())
-			return false
+			res = false
 		}
 		if varString != readWriteTrade.StringParam {
 			log.Error(varString, " != ", readWriteTrade.StringParam)
-			return false
+			res = false
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -314,25 +418,26 @@ func NrErc20TranCase(txCount int, testAccArr *tool.AccArrFormat, contractMap map
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		afterToken20Bal, err := erc20Contract.BalanceOf(&bind.CallOpts{}, contractMap[constant.TOKEN20_TRANSFER])
 		if err != nil {
 			log.Error("Get erc20 balanceOf error:", err.Error())
-			return false
+			res = false
 		}
 		if beforeToken20Bal.Sub(beforeToken20Bal, afterToken20Bal).Cmp(big.NewInt(1).Mul(big.NewInt(10000000000000000), big.NewInt(int64(txCount)))) != 0 {
-			return false
+			res = false
 		}
 		for i := 0; i < txCount; i++ {
 			of, err := erc20Contract.BalanceOf(&bind.CallOpts{}, testAccArr.ToAddr[i])
 			if err != nil {
 				log.Error("Get erc20 balanceOf error:", err.Error())
-				return false
+				res = false
 			}
 			if of.Sub(of, beforeToAddrErc20Bal[testAccArr.ToAddr[i]]).Cmp(big.NewInt(1).Mul(big.NewInt(10000000000000000), big.NewInt(2))) != 0 {
-				return false
+				res = false
 			}
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -386,25 +491,26 @@ func NrOneErc20TranCase(txCount int, testAccArr *tool.AccArrFormat, contractMap
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		afterToken20Bal, err := erc20Contract.BalanceOf(&bind.CallOpts{}, contractMap[constant.TOKEN20_TRANSFER])
 		if err != nil {
 			log.Error("Get token20ContractBal erc20 balanceOf error:", err.Error())
-			return false
+			res = false
 		}
 		for i := 0; i < txCount; i++ {
 			of, err := erc20Contract.BalanceOf(&bind.CallOpts{}, testAccArr.ToAddr[i])
 			if err != nil {
 				log.Error("Get erc20 balanceOf error:", err.Error())
-				return false
+				res = false
 			}
 			if of.Sub(of, beforeToAddrErc20Bal[testAccArr.ToAddr[i]]).Cmp(amount) != 0 {
-				return false
+				res = false
 			}
 		}
 		if beforeToken20Bal.Sub(beforeToken20Bal, afterToken20Bal).Cmp(amount.Mul(amount, big.NewInt(int64(txCount)))) != 0 {
-			return false
+			res = false
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -460,25 +566,26 @@ func NrErc721TranCase(startIndex int, txCount int, testAccArr *tool.AccArrFormat
 		startIndex++
 	}
 	verify := func() bool {
+		res := true
 		for i := 0; i < txCount; i++ {
 			toErc721Bal, err := erc721Contract.BalanceOf(&bind.CallOpts{}, testAccArr.ToAddr[i])
 			if err != nil {
 				log.Error("Get erc721 bal error:", err.Error())
-				return false
+				res = false
 			}
 			if toErc721Bal.Sub(toErc721Bal, beforeToErc721Bal[testAccArr.ToAddr[i]]).Cmp(big.NewInt(1)) != 0 {
-				return false
+				res = false
 			}
 			fromErc721Bal, err := erc721Contract.BalanceOf(&bind.CallOpts{}, testAccArr.FromAddr[i])
 			if err != nil {
 				log.Error("Get erc721 bal error:", err.Error())
-				return false
+				res = false
 			}
 			if beforeFromErc721Bal[testAccArr.FromAddr[i]].Sub(beforeFromErc721Bal[testAccArr.FromAddr[i]], fromErc721Bal).Cmp(big.NewInt(1)) != 0 {
-				return false
+				res = false
 			}
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -533,25 +640,26 @@ func NrOneErc721TranCase(startIndex int, txCount int, testAccArr *tool.AccArrFor
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		for i := 0; i < txCount; i++ {
 			toErc721Bal, err := erc721Contract.BalanceOf(&bind.CallOpts{}, testAccArr.ToAddr[i])
 			if err != nil {
 				log.Error("Get erc721 bal error:", err.Error())
-				return false
+				res = false
 			}
 			if toErc721Bal.Sub(toErc721Bal, beforeToErc721Bal[testAccArr.ToAddr[i]]).Cmp(big.NewInt(1)) != 0 {
-				return false
+				res = false
 			}
 			fromErc721Bal, err := erc721Contract.BalanceOf(&bind.CallOpts{}, testAccArr.FromAddr[i])
 			if err != nil {
 				log.Error("Get erc721 bal error:", err.Error())
-				return false
+				res = false
 			}
 			if beforeFromErc721Bal[testAccArr.FromAddr[i]].Sub(beforeFromErc721Bal[testAccArr.FromAddr[i]], fromErc721Bal).Cmp(big.NewInt(1)) != 0 {
-				return false
+				res = false
 			}
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }

operator/partlyRelatedCase.go

@@ -56,24 +56,25 @@ func PrReCoinTranCase(txCount int, testAccArr *tool.AccArrFormat, accountNonceMa
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		for i := 0; i < txCount; i++ {
 			fromAddr := testAccArr.FromAddr[i]
 			sendAfterBal := util.GetAccBal(client, fromAddr)
 			if sendAfterBal == nil {
-				return false
+				res = false
 			}
 			if sendBeforeBal[fromAddr].Sub(sendBeforeBal[fromAddr], sendAfterBal).Cmp(amount) != 1 {
-				return false
+				res = false
 			}
 		}
 		reToAfterBal := util.GetAccBal(client, toAddr)
 		if reToAfterBal == nil {
-			return false
+			res = false
 		}
 		if reToAfterBal.Sub(reToAfterBal, beforeToBal).Cmp(amount.Mul(amount, big.NewInt(int64(txCount)))) != 0 {
-			return false
+			res = false
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -113,24 +114,25 @@ func PrSpCoinTranCase(txCount int, testAccArr *tool.AccArrFormat, accountNonceMa
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		for i := 0; i < txCount; i++ {
 			toAddr := testAccArr.ToAddr[i]
 			reAfterBal := util.GetAccBal(client, toAddr)
 			if reAfterBal == nil {
-				return false
+				res = false
 			}
 			if reAfterBal.Sub(reAfterBal, reBeforeBal[toAddr]).Cmp(amount) != 0 {
-				return false
+				res = false
 			}
 		}
 		sendAfterBal := util.GetAccBal(client, fromAddr)
 		if sendAfterBal == nil {
-			return false
+			res = false
 		}
 		if beforeFromBal.Sub(beforeFromBal, sendAfterBal).Cmp(amount.Mul(amount, big.NewInt(int64(txCount)))) != 1 {
-			return false
+			res = false
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -182,31 +184,32 @@ func PrSpReCoinTranCase(txCount int, testAccArr *tool.AccArrFormat, accountNonce
 	resTxArr = append(resTxArr, tx)
 
 	verify := func() bool {
+		res := true
 		// A账户余额校验
 		sendFromAfterBal := util.GetAccBal(client, fromAddr)
 		if sendFromAfterBal == nil {
-			return false
+			res = false
 		}
 		if beforeFromBal.Sub(beforeFromBal, sendFromAfterBal).Cmp(amount) != 1 {
-			return false
+			res = false
 		}
 		// B账户余额校验
 		reToAfterBal := util.GetAccBal(client, toAddr)
 		if reToAfterBal == nil {
-			return false
+			res = false
 		}
 		if beforeToBal.Sub(beforeToBal, reToAfterBal).Cmp(big.NewInt(0)) != 1 {
-			return false
+			res = false
 		}
 		// C账户余额校验
 		reTo1AfterBal := util.GetAccBal(client, toAddr1)
 		if reTo1AfterBal == nil {
-			return false
+			res = false
 		}
 		if reTo1AfterBal.Sub(reTo1AfterBal, beforeTo1Bal).Cmp(amount) != 0 {
-			return false
+			res = false
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -253,23 +256,24 @@ func AllPrSpReCoinTranCase(txCount int, testAccArr *tool.AccArrFormat, accountNo
 	resTxArr = append(resTxArr, tx)
 
 	verify := func() bool {
+		res := true
 		// A账户余额校验
 		sendFromAfterBal := util.GetAccBal(client, fromAddr)
 		if sendFromAfterBal == nil {
-			return false
+			res = false
 		}
 		if beforeFromBal.Sub(beforeFromBal, sendFromAfterBal).Cmp(big.NewInt(0)) != 1 {
-			return false
+			res = false
 		}
 		// B账户余额校验
 		reToAfterBal := util.GetAccBal(client, toAddr)
 		if reToAfterBal == nil {
-			return false
+			res = false
 		}
 		if beforeToBal.Sub(beforeToBal, reToAfterBal).Cmp(big.NewInt(0)) != 1 {
-			return false
+			res = false
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -315,25 +319,26 @@ func PrReContractCoinTranCase(txCount int, testAccArr *tool.AccArrFormat, contra
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		for i := 0; i < txCount; i++ {
 			coinAddr := contractMap[i][constant.COIN_TRANSFER]
 			sendBeforeBal := sendBeforeContractBalMap[coinAddr]
 			sendAfterBal := util.GetAccBal(client, coinAddr)
 			if sendBeforeBal == nil {
-				return false
+				res = false
 			}
 			if sendBeforeBal.Sub(sendBeforeBal, sendAfterBal).Cmp(amount) != 0 {
-				return false
+				res = false
 			}
 		}
 		reAfterToBal := util.GetAccBal(client, toAddr)
 		if reAfterToBal == nil {
-			return false
+			res = false
 		}
 		if reAfterToBal.Sub(reAfterToBal, reBeforeToBal).Cmp(big.NewInt(1).Mul(amount, big.NewInt(int64(txCount)))) != 0 {
-			return false
+			res = false
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -383,25 +388,26 @@ func PrSpContractCoinTranCase(txCount int, testAccArr *tool.AccArrFormat, contra
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		for i := 0; i < txCount; i++ {
 			toAddr := testAccArr.ToAddr[i]
 			reAfterToBal := util.GetAccBal(client, toAddr)
 			if reAfterToBal == nil {
-				return false
+				res = false
 			}
 			if reAfterToBal.Sub(reAfterToBal, beforeToBalMap[toAddr]).Cmp(amount) != 0 {
-				return false
+				res = false
 			}
 		}
 		sendAfterBal, err := client.BalanceAt(context.Background(), coinTranAddr, nil)
 		if err != nil {
 			log.Error("Get ", coinTranAddr, " balance error: ", err.Error())
-			return false
+			res = false
 		}
 		if sendBeforeBal.Sub(sendBeforeBal, sendAfterBal).Cmp(amount.Mul(amount, big.NewInt(int64(txCount)))) != 0 {
-			return false
+			res = false
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -484,42 +490,43 @@ func PrReSpContractCoinTranCase(txCount int, testAccArr *tool.AccArrFormat, cont
 	resTxArr = append(resTxArr, tx)
 
 	verify := func() bool {
+		res := true
 		// 校验 a合约
 		sendAfterBal := util.GetAccBal(client, coinTranAddr)
 		if sendAfterBal == nil {
-			return false
+			res = false
 		}
 		if sendBeforeCoinBal.Sub(sendBeforeCoinBal, sendAfterBal).Cmp(amount) != 0 {
-			return false
+			res = false
 		}
 
 		// 校验 b合约
 		sendAfterCoin1Bal := util.GetAccBal(client, coinTranAddr1)
 		if sendAfterBal == nil {
-			return false
+			res = false
 		}
 		if sendBeforeCoin1Bal.Sub(sendBeforeCoin1Bal, sendAfterCoin1Bal).Cmp(amount) != 0 {
-			return false
+			res = false
 		}
 
 		// 校验 B 账户
 		reAfterToBal := util.GetAccBal(client, toAddr)
 		if reAfterToBal == nil {
-			return false
+			res = false
 		}
 		if reAfterToBal.Sub(reAfterToBal, reBeforeToBal).Cmp(amount) != -1 {
-			return false
+			res = false
 		}
 
 		// 校验 C 账户
 		reAfterTo1Bal := util.GetAccBal(client, toAddr1)
 		if reAfterTo1Bal == nil {
-			return false
+			res = false
 		}
 		if reAfterTo1Bal.Sub(reAfterTo1Bal, reBeforeTo1Bal).Cmp(amount) != 0 {
-			return false
+			res = false
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -567,25 +574,26 @@ func PrReContractOneCoinTranCase(txCount int, testAccArr *tool.AccArrFormat, con
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		for i := 0; i < txCount; i++ {
 			coinAddr := contractMap[i][constant.COIN_TRANSFER]
 			sendBeforeBal := sendBeforeContractBalMap[coinAddr]
 			sendAfterBal := util.GetAccBal(client, coinAddr)
 			if sendAfterBal == nil {
-				return false
+				res = false
 			}
 			if sendBeforeBal.Sub(sendBeforeBal, sendAfterBal).Cmp(amount) != 0 {
-				return false
+				res = false
 			}
 		}
 		reAfterToBal := util.GetAccBal(client, toAddr)
 		if reAfterToBal == nil {
-			return false
+			res = false
 		}
 		if reAfterToBal.Sub(reAfterToBal, reBeforeToBal).Cmp(big.NewInt(1).Mul(amount, big.NewInt(int64(txCount)))) != 0 {
-			return false
+			res = false
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -633,26 +641,27 @@ func PrSpContractOneCoinTranCase(txCount int, testAccArr *tool.AccArrFormat, con
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		for i := 0; i < txCount; i++ {
 			reAfterToBal := util.GetAccBal(client, testAccArr.ToAddr[i])
 			if reAfterToBal == nil {
-				return false
+				res = false
 			}
 			if reAfterToBal.Sub(reAfterToBal, reBeforeToBalMap[testAccArr.ToAddr[i]]).Cmp(amount) != 0 {
-				return false
+				res = false
 			}
 		}
 
 		coinAddr := contractMap[0][constant.COIN_TRANSFER]
 		sendAfterBal := util.GetAccBal(client, coinAddr)
 		if sendAfterBal == nil {
-			return false
+			res = false
 		}
 		if sendBeforeBal.Sub(sendBeforeBal, sendAfterBal).Cmp(amount.Mul(amount, big.NewInt(int64(txCount)))) != 0 {
-			return false
+			res = false
 		}
 
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -689,16 +698,17 @@ func PrReWRTranCase(testAccArr *tool.AccArrFormat, contractMap map[string]common
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		varString, err := readWriteVar.GetVarString(&bind.CallOpts{})
 		if err != nil {
 			log.Error("GetVarString error:", err.Error())
-			return false
+			res = false
 		}
 		if varString != readWriteTrade.StringParam {
 			log.Error(varString, " != ", readWriteTrade.StringParam)
-			return false
+			res = false
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -735,16 +745,17 @@ func PrSpWRTranCase(testAccArr *tool.AccArrFormat, contractMap map[string]common
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		varString, err := readWriteVar.GetVarString(&bind.CallOpts{})
 		if err != nil {
 			log.Error("GetVarString error:", err.Error())
-			return false
+			res = false
 		}
 		if varString != readWriteTrade.StringParam {
 			log.Error(varString, " != ", readWriteTrade.StringParam)
-			return false
+			res = false
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -784,23 +795,24 @@ func PrReOneWRTranCase(testAccArr *tool.AccArrFormat, contractMap []map[string]c
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		for i := 0; i < len(funcStr); i++ {
 			readWriteVar, err := contractReadWrite.NewOneReadWriteVar(contractMap[i][constant.ONE_READ_WRITE], client)
 			if err != nil {
 				log.Error("NewReadWriteVar error:", err.Error())
-				return false
+				res = false
 			}
 			varString, err := readWriteVar.OneGetVarString(&bind.CallOpts{}, readWriteAddr)
 			if err != nil {
 				log.Error("GetVarString error:", err.Error())
-				return false
+				res = false
 			}
 			if varString != readWriteTrade.StringParam {
 				log.Error(varString, " != ", readWriteTrade.StringParam)
-				return false
+				res = false
 			}
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -854,25 +866,26 @@ func PrReErc20TranCase(txCount int, testAccArr *tool.AccArrFormat, contractMap m
 	}
 	resTxArr = append(resTxArr, tx)
 	verify := func() bool {
+		res := true
 		afterToken20Bal, err := erc20Contract.BalanceOf(&bind.CallOpts{}, contractMap[constant.TOKEN20_TRANSFER])
 		if err != nil {
 			log.Error("Get erc20 balanceOf error:", err.Error())
-			return false
+			res = false
 		}
 		if beforeToken20Bal.Sub(beforeToken20Bal, afterToken20Bal).Cmp(big.NewInt(1).Mul(erc20Trade.Amount, big.NewInt(int64(txCount)))) != 0 {
-			return false
+			res = false
 		}
 		for i := 0; i < txCount; i++ {
 			of, err := erc20Contract.BalanceOf(&bind.CallOpts{}, testAccArr.ToAddr[i])
 			if err != nil {
 				log.Error("Get erc20 balanceOf error:", err.Error())
-				return false
+				res = false
 			}
 			if of.Sub(of, beforeToAddrErc20Bal[testAccArr.ToAddr[i]]).Cmp(erc20Trade.Amount) != 0 {
-				return false
+				res = false
 			}
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -928,25 +941,26 @@ func PrSpOneErc20TranCase(txCount int, testAccArr *tool.AccArrFormat, contractMa
 	resTxArr = append(resTxArr, tx)
 
 	verify := func() bool {
+		res := true
 		afterToken20Bal, err := erc20Contract.BalanceOf(&bind.CallOpts{}, contractMap[constant.TOKEN20_TRANSFER])
 		if err != nil {
 			log.Error("Get token20ContractBal erc20 balanceOf error:", err.Error())
-			return false
+			res = false
 		}
 		if beforeToken20Bal.Sub(beforeToken20Bal, afterToken20Bal).Cmp(big.NewInt(1).Mul(amount, big.NewInt(int64(txCount)))) != 0 {
-			return false
+			res = false
 		}
 		for i := 0; i < txCount; i++ {
 			of, err := erc20Contract.BalanceOf(&bind.CallOpts{}, testAccArr.ToAddr[i])
 			if err != nil {
 				log.Error("Get erc20 balanceOf error:", err.Error())
-				return false
+				res = false
 			}
 			if of.Sub(of, beforeToAddrErc20Bal[testAccArr.ToAddr[i]]).Cmp(amount) != 0 {
-				return false
+				res = false
 			}
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -1001,28 +1015,29 @@ func PrReSpErc20TranCase(txCount int, testAccArr *tool.AccArrFormat, contractMap
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		for i := 0; i < txCount; i++ {
 			toAddr := testAccArr.ToAddr[i]
 			to, err := erc20Contract.BalanceOf(&bind.CallOpts{}, toAddr)
 			if err != nil {
 				log.Error("Get erc20 balanceOf error:", err.Error())
-				return false
+				res = false
 			}
 			if to.Sub(to, beforeAddrErc20Bal[toAddr]).Cmp(erc20Trade.Amount) != 0 {
-				return false
+				res = false
 			}
 
 			fromAddr := testAccArr.FromAddr[i]
 			from, err := erc20Contract.BalanceOf(&bind.CallOpts{}, fromAddr)
 			if err != nil {
 				log.Error("Get erc20 balanceOf error:", err.Error())
-				return false
+				res = false
 			}
 			if beforeAddrErc20Bal[fromAddr].Sub(beforeAddrErc20Bal[fromAddr], from).Cmp(erc20Trade.Amount) != 0 {
-				return false
+				res = false
 			}
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -1078,26 +1093,27 @@ func PrReOneErc20TranCase(txCount int, testAccArr *tool.AccArrFormat, contractMa
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		for i := 0; i < txCount; i++ {
 			to, err := erc20Contract.BalanceOf(&bind.CallOpts{}, testAccArr.ToAddr[i])
 			if err != nil {
 				log.Error("Get erc20 balanceOf error:", err.Error())
-				return false
+				res = false
 			}
 			if to.Sub(to, beforeAddrErc20Bal[testAccArr.ToAddr[i]]).Cmp(amount) != 0 {
-				return false
+				res = false
 			}
 
 			from, err := erc20Contract.BalanceOf(&bind.CallOpts{}, testAccArr.FromAddr[i])
 			if err != nil {
 				log.Error("Get erc20 balanceOf error:", err.Error())
-				return false
+				res = false
 			}
 			if beforeAddrErc20Bal[testAccArr.FromAddr[i]].Sub(beforeAddrErc20Bal[testAccArr.FromAddr[i]], from).Cmp(amount) != 1 {
-				return false
+				res = false
 			}
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -1137,17 +1153,18 @@ func PrSpErc20ApproveTranCase(txCount int, testAccArr *tool.AccArrFormat, contra
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		for i := 0; i < txCount; i++ {
 			of, err := erc20Contract.Allowance(&bind.CallOpts{}, testAccArr.FromAddr[i], testAccArr.ToAddr[i])
 			if err != nil {
 				log.Error("Get erc20 balanceOf error:", err.Error())
-				return false
+				res = false
 			}
 			if of.Sub(of, beforeFromToAllowanceArr[i]) != amount {
-				return false
+				res = false
 			}
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }
@@ -1207,25 +1224,26 @@ func PrReErc721TranCase(txCount int, testAccArr *tool.AccArrFormat, contractMap
 		resTxArr = append(resTxArr, tx)
 	}
 	verify := func() bool {
+		res := true
 		for i := 0; i < txCount; i++ {
 			toErc721Bal, err := erc721Contract.BalanceOf(&bind.CallOpts{}, testAccArr.ToAddr[i])
 			if err != nil {
 				log.Error("Get erc721 bal error:", err.Error())
-				return false
+				res = false
 			}
 			if beforeToErc721Bal[testAccArr.ToAddr[i]].Sub(beforeToErc721Bal[testAccArr.ToAddr[i]], toErc721Bal).Cmp(big.NewInt(1)) != 0 {
-				return false
+				res = false
 			}
 			fromErc721Bal, err := erc721Contract.BalanceOf(&bind.CallOpts{}, testAccArr.FromAddr[i])
 			if err != nil {
 				log.Error("Get erc721 bal error:", err.Error())
-				return false
+				res = false
 			}
 			if beforeFromErc721Bal[testAccArr.FromAddr[i]].Sub(beforeToErc721Bal[testAccArr.FromAddr[i]], fromErc721Bal).Cmp(big.NewInt(1)) != 0 {
-				return false
+				res = false
 			}
 		}
-		return true
+		return res
 	}
 	return resTxArr, verify
 }

test/contract_test.go

@@ -14,13 +14,12 @@ import (
 
 func TestGetContractAbi(t *testing.T) {
 	// 连接以太坊网络
-	client, err := ethclient.Dial("http://54.72.101.87:50000")
+	client, err := ethclient.Dial("http://192.168.1.118:50000")
 	if err != nil {
 		log.Fatal(err)
 	}
-
 	// 从合约地址获取合约代码
-	contractAddress := common.HexToAddress("0xb11ba93a30352b831909db093b253fa51e152cb9")
+	contractAddress := common.HexToAddress("0xfb1bF24c0C7e7C1B89c4A496aACf01aBF26C0B94")
 
 	//code, err := client.CodeAt(context.Background(), contractAddress, nil)
 	//if err != nil {
@@ -42,12 +41,12 @@ func TestGetContractAbi(t *testing.T) {
 	}
 	log.Info("balance:", balance.String())
 
-	receipt, err := client.TransactionReceipt(context.Background(), common.HexToHash("0x0358adba05683b259434198ed760b4b9341f8ab041a8980d8d4a0182c4b6021e"))
+	receipt, err := client.TransactionReceipt(context.Background(), common.HexToHash("0x9699843dbe3a809a928ad7a68c009c7c2316bce09566ea9a579fae33e899c95b"))
 	if err != nil {
 		log.Fatal("Get receipt error:", err.Error())
 		return
 	}
-	log.Info("status:", receipt.Status, ",tranNonce:", receipt.TransactionIndex)
+	log.Info("status:", receipt.Status, ",tranNonce:", receipt.TransactionIndex, ",GasUsed:", receipt.GasUsed)
 }
 
 func TestGetErc20Balance(t *testing.T) {