First take of applying assertion funcs to shared tests

beacon-chain/core/blocks/spectest/block_header_test.go

@@ -41,8 +41,8 @@ func runBlockHeaderTest(t *testing.T, config string) {
 			postSSZExists := true
 			if err != nil && strings.Contains(err.Error(), "could not locate file") {
 				postSSZExists = false
-			} else if err != nil {
-				t.Fatal(err)
+			} else {
+				require.NoError(t, err)
 			}
 
 			// Spectest blocks are not signed, so we'll call NoVerify to skip sig verification.

shared/BUILD.bazel

@@ -14,4 +14,5 @@ go_test(
     size = "small",
     srcs = ["service_registry_test.go"],
     embed = [":go_default_library"],
+    deps = ["//shared/testutil/require:go_default_library"],
 )

shared/bls/herumi/signature_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/prysmaticlabs/prysm/shared/bls/herumi"
 	"github.com/prysmaticlabs/prysm/shared/bls/iface"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 func TestSignVerify(t *testing.T) {
@@ -88,15 +89,9 @@ func TestMultipleSignatureVerification_FailsCorrectly(t *testing.T) {
 	secondLastSig := sigs[len(sigs)-2]
 	// Convert to bls object
 	rawSig := new(bls12.Sign)
-	if err := rawSig.Deserialize(secondLastSig.Marshal()); err != nil {
-		t.Fatal(err)
-	}
-
+	require.NoError(t, rawSig.Deserialize(secondLastSig.Marshal()))
 	rawSig2 := new(bls12.Sign)
-	if err := rawSig2.Deserialize(lastSig.Marshal()); err != nil {
-		t.Fatal(err)
-	}
-
+	require.NoError(t, rawSig2.Deserialize(lastSig.Marshal()))
 	// set random field prime value
 	fprime := new(bls12.Fp)
 	fprime.SetInt64(100)
@@ -110,10 +105,7 @@ func TestMultipleSignatureVerification_FailsCorrectly(t *testing.T) {
 	fp2.D = [2]bls12.Fp{*fprime, *fprime2}
 
 	g2Point := new(bls12.G2)
-	if err := bls12.MapToG2(g2Point, fp2); err != nil {
-		t.Fatal(err)
-	}
-
+	require.NoError(t, bls12.MapToG2(g2Point, fp2))
 	// We now add/subtract the respective g2 points by a fixed
 	// value. This would cause singluar verification to fail but
 	// not aggregate verification.
@@ -123,13 +115,9 @@ func TestMultipleSignatureVerification_FailsCorrectly(t *testing.T) {
 	bls12.G2Sub(secondG2, secondG2, g2Point)
 
 	lastSig, err := herumi.SignatureFromBytes(rawSig.Serialize())
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	secondLastSig, err = herumi.SignatureFromBytes(rawSig2.Serialize())
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	sigs[len(sigs)-1] = lastSig
 	sigs[len(sigs)-2] = secondLastSig
 

shared/bls/spectest/BUILD.bazel

@@ -35,6 +35,7 @@ go_test(
         "//shared/bls/iface:go_default_library",
         "//shared/bytesutil:go_default_library",
         "//shared/testutil:go_default_library",
+        "//shared/testutil/require:go_default_library",
         "@com_github_ghodss_yaml//:go_default_library",
     ],
 )

shared/bls/spectest/aggregate_test.go

@@ -1,7 +1,6 @@
 package spectest
 
 import (
-	"bytes"
 	"encoding/hex"
 	"path"
 	"strings"
@@ -11,6 +10,7 @@ import (
 	"github.com/prysmaticlabs/prysm/shared/bls"
 	"github.com/prysmaticlabs/prysm/shared/bls/iface"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 func TestAggregateYaml(t *testing.T) {
@@ -19,23 +19,15 @@ func TestAggregateYaml(t *testing.T) {
 	for _, folder := range testFolders {
 		t.Run(folder.Name(), func(t *testing.T) {
 			file, err := testutil.BazelFileBytes(path.Join(testFolderPath, folder.Name(), "data.yaml"))
-			if err != nil {
-				t.Fatalf("Failed to read file: %v", err)
-			}
+			require.NoError(t, err)
 			test := &AggregateTest{}
-			if err := yaml.Unmarshal(file, test); err != nil {
-				t.Fatalf("Failed to unmarshal: %v", err)
-			}
+			require.NoError(t, yaml.Unmarshal(file, test))
 			var sigs []iface.Signature
 			for _, s := range test.Input {
 				sigBytes, err := hex.DecodeString(s[2:])
-				if err != nil {
-					t.Fatalf("Cannot decode string to bytes: %v", err)
-				}
+				require.NoError(t, err)
 				sig, err := bls.SignatureFromBytes(sigBytes)
-				if err != nil {
-					t.Fatalf("Unable to unmarshal signature from bytes: %v", err)
-				}
+				require.NoError(t, err)
 				sigs = append(sigs, sig)
 			}
 			if len(test.Input) == 0 {
@@ -52,12 +44,8 @@ func TestAggregateYaml(t *testing.T) {
 				return
 			}
 			outputBytes, err := hex.DecodeString(test.Output[2:])
-			if err != nil {
-				t.Fatalf("Cannot decode string to bytes: %v", err)
-			}
-			if !bytes.Equal(outputBytes, sig.Marshal()) {
-				t.Fatal("Output does not equal marshaled aggregated sig bytes")
-			}
+			require.NoError(t, err)
+			require.DeepEqual(t, outputBytes, sig.Marshal())
 		})
 	}
 }

shared/bls/spectest/aggregate_verify_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/prysmaticlabs/prysm/shared/bls/iface"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 func TestAggregateVerifyYaml(t *testing.T) {
@@ -18,41 +19,26 @@ func TestAggregateVerifyYaml(t *testing.T) {
 	for i, folder := range testFolders {
 		t.Run(folder.Name(), func(t *testing.T) {
 			file, err := testutil.BazelFileBytes(path.Join(testFolderPath, folder.Name(), "data.yaml"))
-			if err != nil {
-				t.Fatalf("Failed to read file: %v", err)
-			}
+			require.NoError(t, err)
 			test := &AggregateVerifyTest{}
-			if err := yaml.Unmarshal(file, test); err != nil {
-				t.Fatalf("Failed to unmarshal: %v", err)
-			}
-
+			require.NoError(t, yaml.Unmarshal(file, test))
 			pubkeys := make([]iface.PublicKey, 0, len(test.Input.Pubkeys))
 			msgs := make([][32]byte, 0, len(test.Input.Messages))
 			for _, pubKey := range test.Input.Pubkeys {
 				pkBytes, err := hex.DecodeString(pubKey[2:])
-				if err != nil {
-					t.Fatalf("Cannot decode string to bytes: %v", err)
-				}
+				require.NoError(t, err)
 				pk, err := bls.PublicKeyFromBytes(pkBytes)
-				if err != nil {
-					t.Fatalf("Cannot unmarshal input to secret key: %v", err)
-				}
+				require.NoError(t, err)
 				pubkeys = append(pubkeys, pk)
 			}
 			for _, msg := range test.Input.Messages {
 				msgBytes, err := hex.DecodeString(msg[2:])
-				if err != nil {
-					t.Fatalf("Cannot decode string to bytes: %v", err)
-				}
-				if len(msgBytes) != 32 {
-					t.Fatalf("Message: %#x is not 32 bytes", msgBytes)
-				}
+				require.NoError(t, err)
+				require.Equal(t, 32, len(msgBytes))
 				msgs = append(msgs, bytesutil.ToBytes32(msgBytes))
 			}
 			sigBytes, err := hex.DecodeString(test.Input.Signature[2:])
-			if err != nil {
-				t.Fatalf("Cannot decode string to bytes: %v", err)
-			}
+			require.NoError(t, err)
 			sig, err := bls.SignatureFromBytes(sigBytes)
 			if err != nil {
 				if test.Output == false {

shared/bls/spectest/fast_aggregate_verify_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/prysmaticlabs/prysm/shared/bls/iface"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 func TestFastAggregateVerifyYaml(t *testing.T) {
@@ -18,36 +19,23 @@ func TestFastAggregateVerifyYaml(t *testing.T) {
 	for i, folder := range testFolders {
 		t.Run(folder.Name(), func(t *testing.T) {
 			file, err := testutil.BazelFileBytes(path.Join(testFolderPath, folder.Name(), "data.yaml"))
-			if err != nil {
-				t.Fatalf("Failed to read file: %v", err)
-			}
+			require.NoError(t, err)
 			test := &FastAggregateVerifyTest{}
-			if err := yaml.Unmarshal(file, test); err != nil {
-				t.Fatalf("Failed to unmarshal: %v", err)
-			}
+			require.NoError(t, yaml.Unmarshal(file, test))
 
 			pubkeys := make([]iface.PublicKey, len(test.Input.Pubkeys))
 			for j, raw := range test.Input.Pubkeys {
 				pkBytes, err := hex.DecodeString(raw[2:])
-				if err != nil {
-					t.Fatalf("Cannot decode string to bytes: %v", err)
-				}
+				require.NoError(t, err)
 				pk, err := bls.PublicKeyFromBytes(pkBytes)
-				if err != nil {
-					t.Fatalf("Cannot unmarshal input to secret key: %v", err)
-				}
+				require.NoError(t, err)
 				pubkeys[j] = pk
 			}
 
 			msgBytes, err := hex.DecodeString(test.Input.Message[2:])
-			if err != nil {
-				t.Fatalf("Cannot decode string to bytes: %v", err)
-			}
-
+			require.NoError(t, err)
 			sigBytes, err := hex.DecodeString(test.Input.Signature[2:])
-			if err != nil {
-				t.Fatalf("Cannot decode string to bytes: %v", err)
-			}
+			require.NoError(t, err)
 			sig, err := bls.SignatureFromBytes(sigBytes)
 			if err != nil {
 				if test.Output == false {

shared/bls/spectest/sign_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/ghodss/yaml"
 	"github.com/prysmaticlabs/prysm/shared/bls"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 func TestSignMessageYaml(t *testing.T) {
@@ -19,37 +20,24 @@ func TestSignMessageYaml(t *testing.T) {
 	for i, folder := range testFolders {
 		t.Run(folder.Name(), func(t *testing.T) {
 			file, err := testutil.BazelFileBytes(path.Join(testFolderPath, folder.Name(), "data.yaml"))
-			if err != nil {
-				t.Fatalf("Failed to read file: %v", err)
-			}
+			require.NoError(t, err)
 			test := &SignMsgTest{}
-			if err := yaml.Unmarshal(file, test); err != nil {
-				t.Fatalf("Failed to unmarshal: %v", err)
-			}
-
+			require.NoError(t, yaml.Unmarshal(file, test))
 			pkBytes, err := hex.DecodeString(test.Input.Privkey[2:])
-			if err != nil {
-				t.Fatalf("Cannot decode string to bytes: %v", err)
-			}
+			require.NoError(t, err)
 			sk, err := bls.SecretKeyFromBytes(pkBytes)
-			if err != nil {
-				t.Fatalf("Cannot unmarshal input to secret key: %v", err)
-			}
+			require.NoError(t, err)
 
 			msgBytes, err := hex.DecodeString(test.Input.Message[2:])
-			if err != nil {
-				t.Fatalf("Cannot decode string to bytes: %v", err)
-			}
+			require.NoError(t, err)
 			sig := sk.Sign(msgBytes)
 
 			if !sig.Verify(sk.PublicKey(), msgBytes) {
 				t.Fatal("could not verify signature")
 			}
 
 			outputBytes, err := hex.DecodeString(test.Output[2:])
-			if err != nil {
-				t.Fatalf("Cannot decode string to bytes: %v", err)
-			}
+			require.NoError(t, err)
 
 			if !bytes.Equal(outputBytes, sig.Marshal()) {
 				t.Fatalf("Test Case %d: Signature does not match the expected output. "+

shared/bls/spectest/verify_test.go

@@ -8,6 +8,7 @@ import (
 	"github.com/ghodss/yaml"
 	"github.com/prysmaticlabs/prysm/shared/bls"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 func TestVerifyMessageYaml(t *testing.T) {
@@ -16,32 +17,20 @@ func TestVerifyMessageYaml(t *testing.T) {
 	for i, folder := range testFolders {
 		t.Run(folder.Name(), func(t *testing.T) {
 			file, err := testutil.BazelFileBytes(path.Join(testFolderPath, folder.Name(), "data.yaml"))
-			if err != nil {
-				t.Fatalf("Failed to read file: %v", err)
-			}
+			require.NoError(t, err)
 			test := &VerifyMsgTest{}
-			if err := yaml.Unmarshal(file, test); err != nil {
-				t.Fatalf("Failed to unmarshal: %v", err)
-			}
+			require.NoError(t, yaml.Unmarshal(file, test))
 
 			pkBytes, err := hex.DecodeString(test.Input.Pubkey[2:])
-			if err != nil {
-				t.Fatalf("Cannot decode string to bytes: %v", err)
-			}
+			require.NoError(t, err)
 			pk, err := bls.PublicKeyFromBytes(pkBytes)
-			if err != nil {
-				t.Fatalf("Cannot unmarshal input to secret key: %v", err)
-			}
+			require.NoError(t, err)
 
 			msgBytes, err := hex.DecodeString(test.Input.Message[2:])
-			if err != nil {
-				t.Fatalf("Cannot decode string to bytes: %v", err)
-			}
+			require.NoError(t, err)
 
 			sigBytes, err := hex.DecodeString(test.Input.Signature[2:])
-			if err != nil {
-				t.Fatalf("Cannot decode string to bytes: %v", err)
-			}
+			require.NoError(t, err)
 			sig, err := bls.SignatureFromBytes(sigBytes)
 			if err != nil {
 				if test.Output == false {

shared/bytesutil/bytes_test.go

@@ -311,9 +311,7 @@ func TestHighestBitIndex(t *testing.T) {
 	for _, tt := range tests {
 		i, err := bytesutil.HighestBitIndex(tt.a)
 		if !tt.error {
-			if err != nil {
-				t.Fatal(err)
-			}
+			require.NoError(t, err)
 			require.NoError(t, err)
 			assert.DeepEqual(t, tt.b, i)
 		} else {