all: replace t.Log(); t.FailNow() with t.Fatal() (ethereum#19849)

gzliudan · gzliudan · commit b4f0e6e33ffe · 2025-01-06T09:12:27.000+08:00
diff --git a/accounts/abi/abi_test.go b/accounts/abi/abi_test.go
@@ -21,7 +21,6 @@ import (
 	"encoding/hex"
 	"errors"
 	"fmt"
-	"log"
 	"math/big"
 	"reflect"
 	"strings"
@@ -105,8 +104,7 @@ func TestReader(t *testing.T) {
 func TestTestNumbers(t *testing.T) {
 	abi, err := JSON(strings.NewReader(jsondata2))
 	if err != nil {
-		t.Error(err)
-		t.FailNow()
+		t.Fatal(err)
 	}
 
 	if _, err := abi.Pack("balance"); err != nil {
@@ -143,8 +141,7 @@ func TestTestNumbers(t *testing.T) {
 func TestTestString(t *testing.T) {
 	abi, err := JSON(strings.NewReader(jsondata2))
 	if err != nil {
-		t.Error(err)
-		t.FailNow()
+		t.Fatal(err)
 	}
 
 	if _, err := abi.Pack("string", "hello world"); err != nil {
@@ -155,8 +152,7 @@ func TestTestString(t *testing.T) {
 func TestTestBool(t *testing.T) {
 	abi, err := JSON(strings.NewReader(jsondata2))
 	if err != nil {
-		t.Error(err)
-		t.FailNow()
+		t.Fatal(err)
 	}
 
 	if _, err := abi.Pack("bool", true); err != nil {
@@ -167,8 +163,7 @@ func TestTestBool(t *testing.T) {
 func TestTestSlice(t *testing.T) {
 	abi, err := JSON(strings.NewReader(jsondata2))
 	if err != nil {
-		t.Error(err)
-		t.FailNow()
+		t.Fatal(err)
 	}
 
 	slice := make([]uint64, 2)
@@ -224,8 +219,7 @@ func TestMethodSignature(t *testing.T) {
 func TestMultiPack(t *testing.T) {
 	abi, err := JSON(strings.NewReader(jsondata2))
 	if err != nil {
-		t.Error(err)
-		t.FailNow()
+		t.Fatal(err)
 	}
 
 	sig := crypto.Keccak256([]byte("bar(uint32,uint16)"))[:4]
@@ -235,8 +229,7 @@ func TestMultiPack(t *testing.T) {
 
 	packed, err := abi.Pack("bar", uint32(10), uint16(11))
 	if err != nil {
-		t.Error(err)
-		t.FailNow()
+		t.Fatal(err)
 	}
 
 	if !bytes.Equal(packed, sig) {
@@ -249,11 +242,11 @@ func ExampleJSON() {
 
 	abi, err := JSON(strings.NewReader(definition))
 	if err != nil {
-		log.Fatalln(err)
+		panic(err)
 	}
 	out, err := abi.Pack("isBar", common.HexToAddress("01"))
 	if err != nil {
-		log.Fatalln(err)
+		panic(err)
 	}
 
 	fmt.Printf("%x\n", out)
diff --git a/consensus/tests/engine_v2_tests/forensics_test.go b/consensus/tests/engine_v2_tests/forensics_test.go
@@ -3,6 +3,7 @@ package engine_v2_tests
 import (
 	"crypto/ecdsa"
 	"encoding/json"
+	"errors"
 	"math/big"
 	"testing"
 	"time"
@@ -16,6 +17,8 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+var errTimeoutAfter5Seconds = errors.New("timeout after 5 seconds")
+
 func TestProcessQcShallSetForensicsCommittedQc(t *testing.T) {
 	t.Skip("Skipping this test for now as we disable forensics")
 
@@ -200,7 +203,7 @@ func TestForensicsMonitoringNotOnSameChainButHaveSameRoundQC(t *testing.T) {
 			assert.Equal(t, 5, len(content.LargerRoundInfo.SignerAddresses))
 			return
 		case <-time.After(5 * time.Second):
-			t.FailNow()
+			t.Fatal(errTimeoutAfter5Seconds)
 		}
 	}
 }
@@ -262,7 +265,7 @@ func TestForensicsMonitoringNotOnSameChainDoNotHaveSameRoundQC(t *testing.T) {
 			assert.Equal(t, 2, len(content.LargerRoundInfo.SignerAddresses))
 			return
 		case <-time.After(5 * time.Second):
-			t.FailNow()
+			t.Fatal(errTimeoutAfter5Seconds)
 		}
 	}
 }
@@ -327,7 +330,7 @@ func TestForensicsAcrossEpoch(t *testing.T) {
 			assert.Equal(t, 2, len(content.LargerRoundInfo.SignerAddresses))
 			return
 		case <-time.After(5 * time.Second):
-			t.FailNow()
+			t.Fatal(errTimeoutAfter5Seconds)
 		}
 	}
 }
@@ -395,7 +398,7 @@ func TestVoteEquivocationSameRound(t *testing.T) {
 			assert.Equal(t, types.Round(5), content.LargerRoundVote.ProposedBlockInfo.Round)
 			return
 		case <-time.After(5 * time.Second):
-			t.FailNow()
+			t.Fatal(errTimeoutAfter5Seconds)
 		}
 	}
 }
@@ -452,7 +455,7 @@ func TestVoteEquivocationDifferentRound(t *testing.T) {
 			assert.Equal(t, acc1Addr, content.Signer)
 			return
 		case <-time.After(5 * time.Second):
-			t.FailNow()
+			t.Fatal(errTimeoutAfter5Seconds)
 		}
 	}
 }
diff --git a/core/blockchain_test.go b/core/blockchain_test.go
@@ -157,8 +157,7 @@ func testHeaderChainImport(chain []*types.Header, blockchain *BlockChain) error
 func insertChain(done chan bool, blockchain *BlockChain, chain types.Blocks, t *testing.T) {
 	_, err := blockchain.InsertChain(chain)
 	if err != nil {
-		fmt.Println(err)
-		t.FailNow()
+		t.Fatal(err)
 	}
 	done <- true
 }
diff --git a/core/txpool/lending_pool_test.go b/core/txpool/lending_pool_test.go
@@ -177,8 +177,7 @@ func TestSendLending(t *testing.T) {
 	}
 	nonce, err := getLendingNonce(crypto.PubkeyToAddress(privateKey.PublicKey))
 	if err != nil {
-		t.Error("fail to get nonce")
-		t.FailNow()
+		t.Fatal("fail to get nonce")
 	}
 
 	for {
@@ -249,8 +248,7 @@ func TestCancelLending(t *testing.T) {
 	}
 	nonce, err := getLendingNonce(crypto.PubkeyToAddress(privateKey.PublicKey))
 	if err != nil {
-		t.Error("fail to get nonce")
-		t.FailNow()
+		t.Fatal("fail to get nonce")
 	}
 
 	// 10%
@@ -272,16 +270,14 @@ func TestRecallLending(t *testing.T) {
 	}
 	nonce, err := getLendingNonce(crypto.PubkeyToAddress(privateKey.PublicKey))
 	if err != nil {
-		t.Error("fail to get nonce")
-		t.FailNow()
+		t.Fatal("fail to get nonce")
 	}
 	interestRate := 10 * common.BaseLendingInterest.Uint64()
 	testSendLending(key, nonce, USDAddress, common.Address{}, new(big.Int).Mul(_1E8, big.NewInt(1000)), interestRate, lendingstate.Investing, lendingstate.LendingStatusNew, true, 0, 0, common.Hash{}, "")
 	time.Sleep(2 * time.Second)
 	nonce, err = getLendingNonce(crypto.PubkeyToAddress(privateKey.PublicKey))
 	if err != nil {
-		t.Error("fail to get nonce")
-		t.FailNow()
+		t.Fatal("fail to get nonce")
 	}
 	testSendLending(key, nonce, USDAddress, common.XDCNativeAddressBinary, new(big.Int).Mul(_1E8, big.NewInt(1000)), interestRate, lendingstate.Borrowing, lendingstate.LendingStatusNew, true, 0, 0, common.Hash{}, "")
 	time.Sleep(2 * time.Second)
diff --git a/core/types/transaction_test.go b/core/types/transaction_test.go
@@ -230,14 +230,12 @@ func TestRecipientEmpty(t *testing.T) {
 	_, addr := defaultTestKey()
 	tx, err := decodeTx(common.Hex2Bytes("f8498080808080011ca09b16de9d5bdee2cf56c28d16275a4da68cd30273e2525f3959f5d62557489921a0372ebd8fb3345f7db7b5a86d42e24d36e983e259b0664ceb8c227ec9af572f3d"))
 	if err != nil {
-		t.Error(err)
-		t.FailNow()
+		t.Fatal(err)
 	}
 
 	from, err := Sender(HomesteadSigner{}, tx)
 	if err != nil {
-		t.Error(err)
-		t.FailNow()
+		t.Fatal(err)
 	}
 	if addr != from {
 		t.Error("derived address doesn't match")
@@ -249,18 +247,16 @@ func TestRecipientNormal(t *testing.T) {
 
 	tx, err := decodeTx(common.Hex2Bytes("f85d80808094000000000000000000000000000000000000000080011ca0527c0d8f5c63f7b9f41324a7c8a563ee1190bcbf0dac8ab446291bdbf32f5c79a0552c4ef0a09a04395074dab9ed34d3fbfb843c2f2546cc30fe89ec143ca94ca6"))
 	if err != nil {
-		t.Error(err)
-		t.FailNow()
+		t.Fatal(err)
 	}
 
 	from, err := Sender(HomesteadSigner{}, tx)
 	if err != nil {
-		t.Error(err)
-		t.FailNow()
+		t.Fatal(err)
 	}
 
 	if addr != from {
-		t.Error("derived address doesn't match")
+		t.Fatal("derived address doesn't match")
 	}
 }
 

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@ package engine_v2_tests`
`3`	`3`	`import (`
`4`	`4`	`"crypto/ecdsa"`
`5`	`5`	`"encoding/json"`
	`6`	`+ "errors"`
`6`	`7`	`"math/big"`
`7`	`8`	`"testing"`
`8`	`9`	`"time"`
`@@ -16,6 +17,8 @@ import (`
`16`	`17`	`"github.com/stretchr/testify/assert"`
`17`	`18`	`)`
`18`	`19`
	`20`	`+var errTimeoutAfter5Seconds = errors.New("timeout after 5 seconds")`
	`21`	`+`
`19`	`22`	`func TestProcessQcShallSetForensicsCommittedQc(t *testing.T) {`
`20`	`23`	`t.Skip("Skipping this test for now as we disable forensics")`
`21`	`24`
`@@ -200,7 +203,7 @@ func TestForensicsMonitoringNotOnSameChainButHaveSameRoundQC(t *testing.T) {`
`200`	`203`	`assert.Equal(t, 5, len(content.LargerRoundInfo.SignerAddresses))`
`201`	`204`	`return`
`202`	`205`	`case <-time.After(5 * time.Second):`
`203`		`- t.FailNow()`
	`206`	`+ t.Fatal(errTimeoutAfter5Seconds)`
`204`	`207`	`}`
`205`	`208`	`}`
`206`	`209`	`}`
`@@ -262,7 +265,7 @@ func TestForensicsMonitoringNotOnSameChainDoNotHaveSameRoundQC(t *testing.T) {`
`262`	`265`	`assert.Equal(t, 2, len(content.LargerRoundInfo.SignerAddresses))`
`263`	`266`	`return`
`264`	`267`	`case <-time.After(5 * time.Second):`
`265`		`- t.FailNow()`
	`268`	`+ t.Fatal(errTimeoutAfter5Seconds)`
`266`	`269`	`}`
`267`	`270`	`}`
`268`	`271`	`}`
`@@ -327,7 +330,7 @@ func TestForensicsAcrossEpoch(t *testing.T) {`
`327`	`330`	`assert.Equal(t, 2, len(content.LargerRoundInfo.SignerAddresses))`
`328`	`331`	`return`
`329`	`332`	`case <-time.After(5 * time.Second):`
`330`		`- t.FailNow()`
	`333`	`+ t.Fatal(errTimeoutAfter5Seconds)`
`331`	`334`	`}`
`332`	`335`	`}`
`333`	`336`	`}`
`@@ -395,7 +398,7 @@ func TestVoteEquivocationSameRound(t *testing.T) {`
`395`	`398`	`assert.Equal(t, types.Round(5), content.LargerRoundVote.ProposedBlockInfo.Round)`
`396`	`399`	`return`
`397`	`400`	`case <-time.After(5 * time.Second):`
`398`		`- t.FailNow()`
	`401`	`+ t.Fatal(errTimeoutAfter5Seconds)`
`399`	`402`	`}`
`400`	`403`	`}`
`401`	`404`	`}`
`@@ -452,7 +455,7 @@ func TestVoteEquivocationDifferentRound(t *testing.T) {`
`452`	`455`	`assert.Equal(t, acc1Addr, content.Signer)`
`453`	`456`	`return`
`454`	`457`	`case <-time.After(5 * time.Second):`
`455`		`- t.FailNow()`
	`458`	`+ t.Fatal(errTimeoutAfter5Seconds)`
`456`	`459`	`}`
`457`	`460`	`}`
`458`	`461`	`}`
Original file line number	Diff line number	Diff line change
`@@ -157,8 +157,7 @@ func testHeaderChainImport(chain []types.Header, blockchain BlockChain) error`
`157`	`157`	`func insertChain(done chan bool, blockchain BlockChain, chain types.Blocks, t testing.T) {`
`158`	`158`	`_, err := blockchain.InsertChain(chain)`
`159`	`159`	`if err != nil {`
`160`		`- fmt.Println(err)`
`161`		`- t.FailNow()`
	`160`	`+ t.Fatal(err)`
`162`	`161`	`}`
`163`	`162`	`done <- true`
`164`	`163`	`}`
Original file line number	Diff line number	Diff line change
`@@ -177,8 +177,7 @@ func TestSendLending(t *testing.T) {`
`177`	`177`	`}`
`178`	`178`	`nonce, err := getLendingNonce(crypto.PubkeyToAddress(privateKey.PublicKey))`
`179`	`179`	`if err != nil {`
`180`		`- t.Error("fail to get nonce")`
`181`		`- t.FailNow()`
	`180`	`+ t.Fatal("fail to get nonce")`
`182`	`181`	`}`
`183`	`182`
`184`	`183`	`for {`
`@@ -249,8 +248,7 @@ func TestCancelLending(t *testing.T) {`
`249`	`248`	`}`
`250`	`249`	`nonce, err := getLendingNonce(crypto.PubkeyToAddress(privateKey.PublicKey))`
`251`	`250`	`if err != nil {`
`252`		`- t.Error("fail to get nonce")`
`253`		`- t.FailNow()`
	`251`	`+ t.Fatal("fail to get nonce")`
`254`	`252`	`}`
`255`	`253`
`256`	`254`	`// 10%`
`@@ -272,16 +270,14 @@ func TestRecallLending(t *testing.T) {`
`272`	`270`	`}`
`273`	`271`	`nonce, err := getLendingNonce(crypto.PubkeyToAddress(privateKey.PublicKey))`
`274`	`272`	`if err != nil {`
`275`		`- t.Error("fail to get nonce")`
`276`		`- t.FailNow()`
	`273`	`+ t.Fatal("fail to get nonce")`
`277`	`274`	`}`
`278`	`275`	`interestRate := 10 * common.BaseLendingInterest.Uint64()`
`279`	`276`	`testSendLending(key, nonce, USDAddress, common.Address{}, new(big.Int).Mul(_1E8, big.NewInt(1000)), interestRate, lendingstate.Investing, lendingstate.LendingStatusNew, true, 0, 0, common.Hash{}, "")`
`280`	`277`	`time.Sleep(2 * time.Second)`
`281`	`278`	`nonce, err = getLendingNonce(crypto.PubkeyToAddress(privateKey.PublicKey))`
`282`	`279`	`if err != nil {`
`283`		`- t.Error("fail to get nonce")`
`284`		`- t.FailNow()`
	`280`	`+ t.Fatal("fail to get nonce")`
`285`	`281`	`}`
`286`	`282`	`testSendLending(key, nonce, USDAddress, common.XDCNativeAddressBinary, new(big.Int).Mul(_1E8, big.NewInt(1000)), interestRate, lendingstate.Borrowing, lendingstate.LendingStatusNew, true, 0, 0, common.Hash{}, "")`
`287`	`283`	`time.Sleep(2 * time.Second)`
Original file line number	Diff line number	Diff line change
`@@ -230,14 +230,12 @@ func TestRecipientEmpty(t *testing.T) {`
`230`	`230`	`_, addr := defaultTestKey()`
`231`	`231`	`tx, err := decodeTx(common.Hex2Bytes("f8498080808080011ca09b16de9d5bdee2cf56c28d16275a4da68cd30273e2525f3959f5d62557489921a0372ebd8fb3345f7db7b5a86d42e24d36e983e259b0664ceb8c227ec9af572f3d"))`
`232`	`232`	`if err != nil {`
`233`		`- t.Error(err)`
`234`		`- t.FailNow()`
	`233`	`+ t.Fatal(err)`
`235`	`234`	`}`
`236`	`235`
`237`	`236`	`from, err := Sender(HomesteadSigner{}, tx)`
`238`	`237`	`if err != nil {`
`239`		`- t.Error(err)`
`240`		`- t.FailNow()`
	`238`	`+ t.Fatal(err)`
`241`	`239`	`}`
`242`	`240`	`if addr != from {`
`243`	`241`	`t.Error("derived address doesn't match")`
`@@ -249,18 +247,16 @@ func TestRecipientNormal(t *testing.T) {`
`249`	`247`
`250`	`248`	`tx, err := decodeTx(common.Hex2Bytes("f85d80808094000000000000000000000000000000000000000080011ca0527c0d8f5c63f7b9f41324a7c8a563ee1190bcbf0dac8ab446291bdbf32f5c79a0552c4ef0a09a04395074dab9ed34d3fbfb843c2f2546cc30fe89ec143ca94ca6"))`
`251`	`249`	`if err != nil {`
`252`		`- t.Error(err)`
`253`		`- t.FailNow()`
	`250`	`+ t.Fatal(err)`
`254`	`251`	`}`
`255`	`252`
`256`	`253`	`from, err := Sender(HomesteadSigner{}, tx)`
`257`	`254`	`if err != nil {`
`258`		`- t.Error(err)`
`259`		`- t.FailNow()`
	`255`	`+ t.Fatal(err)`
`260`	`256`	`}`
`261`	`257`
`262`	`258`	`if addr != from {`
`263`		`- t.Error("derived address doesn't match")`
	`259`	`+ t.Fatal("derived address doesn't match")`
`264`	`260`	`}`
`265`	`261`	`}`
`266`	`262`