From 3b65c66d2139aaff516ab4ca8af19b8d6fc401fc Mon Sep 17 00:00:00 2001 From: Donald Adu-Poku Date: Wed, 23 Aug 2017 00:26:12 +0000 Subject: [PATCH] dcrec: remove testify dependency. --- dcrec/edwards/curve_test.go | 40 +++++++--- dcrec/edwards/ecdsa_test.go | 97 ++++++++++++++++++----- dcrec/edwards/primitives_test.go | 47 ++++++++--- dcrec/edwards/threshold_test.go | 59 ++++++++++---- dcrec/secp256k1/schnorr/ecdsa_test.go | 68 +++++++++++----- dcrec/secp256k1/schnorr/threshold_test.go | 71 +++++++++++++---- glide.lock | 19 ++--- glide.yaml | 6 +- 8 files changed, 299 insertions(+), 108 deletions(-) diff --git a/dcrec/edwards/curve_test.go b/dcrec/edwards/curve_test.go index b75e5f38..da7aefbd 100644 --- a/dcrec/edwards/curve_test.go +++ b/dcrec/edwards/curve_test.go @@ -5,11 +5,10 @@ package edwards import ( + "bytes" "encoding/hex" "math/rand" "testing" - - "github.com/stretchr/testify/assert" ) type XRecoveryVector struct { @@ -58,22 +57,37 @@ func TestXRecovery(t *testing.T) { x2 := curve.RecoverXBigInt(isNegative, y) if !curve.IsOnCurve(x2, y) { - assert.Equal(t, notOnCurve, true) + if !notOnCurve { + t.Fatalf("expected %v, got %v", true, notOnCurve) + } } else { - assert.Equal(t, notOnCurve, false) + if notOnCurve { + t.Fatalf("expected %v, got %v", false, notOnCurve) + } b2 := BigIntPointToEncodedBytes(x2, y) - assert.Equal(t, vector.bIn, b2) + cmp := bytes.Compare(vector.bIn[:], b2[:]) == 0 + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } } yFE := EncodedBytesToFieldElement(vector.bIn) x3 := curve.RecoverXFieldElement(isNegative, yFE) x3BI := FieldElementToBigInt(x3) if !curve.IsOnCurve(x3BI, y) { - assert.Equal(t, notOnCurve, true) + if !notOnCurve { + t.Fatalf("expected %v, got %v", true, notOnCurve) + } } else { - assert.Equal(t, notOnCurve, false) + if notOnCurve { + t.Fatalf("expected %v, got %v", false, notOnCurve) + } + b3 := BigIntPointToEncodedBytes(x3BI, y) - assert.Equal(t, vector.bIn, b3) + cmp := bytes.Compare(vector.bIn[:], b3[:]) == 0 + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } } } } @@ -125,7 +139,10 @@ func TestAdd(t *testing.T) { pointEncAsStr := hex.EncodeToString(pointEnc[:]) // Assert our results. pointHexStr := pointHexStrSet[pointHexStrIdx] - assert.Equal(t, pointEncAsStr, pointHexStr) + cmp := pointEncAsStr == pointHexStr + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } pointHexStrIdx++ } } @@ -205,6 +222,9 @@ func TestScalarMult(t *testing.T) { sBig := EncodedBytesToBigInt(vector.s) // We need big endian xMul, yMul := curve.ScalarMult(x, y, sBig.Bytes()) finalPoint := BigIntPointToEncodedBytes(xMul, yMul) - assert.Equal(t, vector.bRes, finalPoint) + cmp := bytes.Equal(vector.bRes[:], finalPoint[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } } } diff --git a/dcrec/edwards/ecdsa_test.go b/dcrec/edwards/ecdsa_test.go index 6ad2a515..4051af9b 100644 --- a/dcrec/edwards/ecdsa_test.go +++ b/dcrec/edwards/ecdsa_test.go @@ -15,8 +15,6 @@ import ( "os" "strings" "testing" - - "github.com/stretchr/testify/assert" ) func TestGolden(t *testing.T) { @@ -82,24 +80,61 @@ func TestGolden(t *testing.T) { pkS2 := privkeyS2.SerializeSecret() pubkS1 := pubkeyS1.Serialize() pubkS2 := pubkeyS2.Serialize() - assert.Equal(t, pkS1, pkS2) - assert.Equal(t, privArray, copyBytes64(pkS1)) - assert.Equal(t, privArray, copyBytes64(pkS2)) - assert.Equal(t, pubkS1, pubkS2) - assert.Equal(t, pubArray, copyBytes(pubkS1)) - assert.Equal(t, pubArray, copyBytes(pubkS2)) + cmp := bytes.Equal(pkS1[:], pkS2[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } + + cmp = bytes.Equal(privArray[:], copyBytes64(pkS1)[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } + + cmp = bytes.Equal(privArray[:], copyBytes64(pkS2)[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } + + cmp = bytes.Equal(pubkS1[:], pubkS2[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } + + cmp = bytes.Equal(pubArray[:], copyBytes(pubkS1)[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } + + cmp = bytes.Equal(pubArray[:], copyBytes(pubkS2)[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } // Deserialize pubkey and test functions. pubkeyP, err := ParsePubKey(curve, pubKeyBytes) pubkP := pubkeyP.Serialize() - assert.Equal(t, pubkS1, pubkP) - assert.Equal(t, pubkS2, pubkP) - assert.Equal(t, pubArray, copyBytes(pubkP)) + cmp = bytes.Equal(pubkS1[:], pubkP[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } + + cmp = bytes.Equal(pubkS2[:], pubkP[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } + + cmp = bytes.Equal(pubArray[:], copyBytes(pubkP)[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } // Deserialize signature and test functions. internalSig, err := ParseSignature(curve, sig) iSigSerialized := internalSig.Serialize() - assert.Equal(t, sigArray, copyBytes64(iSigSerialized)) + cmp = bytes.Equal(sigArray[:], copyBytes64(iSigSerialized)[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } sig2r, sig2s, err := Sign(curve, privkeyS2, msg) sig2 := &Signature{sig2r, sig2s} @@ -174,21 +209,39 @@ func TestNonStandardSignatures(t *testing.T) { pks := randPrivScalarKeyList(curve, 50) for _, pk := range pks { r, s, err := Sign(curve, pk, msg) - assert.NoError(t, err) + if err != nil { + t.Fatalf("unexpected error %s", err) + } pubX, pubY := pk.Public() pub := NewPublicKey(curve, pubX, pubY) ok := Verify(pub, msg, r, s) - assert.True(t, ok) + if !ok { + t.Fatalf("expected %v, got %v", true, ok) + } // Test serializing/deserializing. privKeyDupTest, _, err := PrivKeyFromScalar(curve, copyBytes(pk.ecPk.D.Bytes())[:]) - assert.NoError(t, err) - assert.Equal(t, privKeyDupTest.GetD(), pk.GetD()) + + if err != nil { + t.Fatalf("unexpected error %s", err) + } + + cmp := privKeyDupTest.GetD().Cmp(pk.GetD()) == 0 + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } + privKeyDupTest2, _, err := PrivKeyFromScalar(curve, pk.Serialize()) - assert.NoError(t, err) - assert.Equal(t, privKeyDupTest2.GetD(), pk.GetD()) + if err != nil { + t.Fatalf("unexpected error %s", err) + } + + cmp = privKeyDupTest2.GetD().Cmp(pk.GetD()) == 0 + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } // Screw up a random bit in the signature and // make sure it still fails. @@ -204,7 +257,9 @@ func TestNonStandardSignatures(t *testing.T) { continue } ok = Verify(pub, msg, bSig.GetR(), bSig.GetS()) - assert.False(t, ok) + if ok { + t.Fatalf("expected %v, got %v", false, ok) + } // Screw up a random bit in the pubkey and // make sure it still fails. @@ -220,7 +275,9 @@ func TestNonStandardSignatures(t *testing.T) { bPub, err := ParsePubKey(curve, pkBad) if err == nil && bPub != nil { ok = Verify(bPub, msg, r, s) - assert.False(t, ok) + if ok { + t.Fatalf("expected %v, got %v", false, ok) + } } } } diff --git a/dcrec/edwards/primitives_test.go b/dcrec/edwards/primitives_test.go index b832b579..95a5395c 100644 --- a/dcrec/edwards/primitives_test.go +++ b/dcrec/edwards/primitives_test.go @@ -9,8 +9,6 @@ import ( "encoding/hex" "math/rand" "testing" - - "github.com/stretchr/testify/assert" ) type ConversionVector struct { @@ -158,31 +156,49 @@ func TestConversion(t *testing.T) { // Test encoding to FE --> bytes. feFB := EncodedBytesToFieldElement(vector.bIn) feTB := FieldElementToEncodedBytes(feFB) - assert.Equal(t, vector.bIn, feTB) + cmp := bytes.Equal(vector.bIn[:], feTB[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } // Test encoding to big int --> FE --> bytes. big := EncodedBytesToBigInt(vector.bIn) fe := BigIntToFieldElement(big) b := FieldElementToEncodedBytes(fe) - assert.Equal(t, vector.bIn, b) + cmp = bytes.Equal(vector.bIn[:], b[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } // Test encoding to big int --> bytes. b = BigIntToEncodedBytes(big) - assert.Equal(t, vector.bIn, b) + cmp = bytes.Equal(vector.bIn[:], b[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } // Test encoding FE --> big int --> bytes. feBig := FieldElementToBigInt(fe) b = BigIntToEncodedBytes(feBig) - assert.Equal(t, vector.bIn, b) + cmp = bytes.Equal(vector.bIn[:], b[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } // Asert our results. encodedNumStr := encodedNumToStrSet[encodedNumToStrIdx] - assert.Equal(t, encodedNumStr, big.String()) + cmp = encodedNumStr == big.String() + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } encodedNumToStrIdx++ // Assert our results. encodedBytesToStr := encodedBytesToStrSet[encodedBytesToStrIdx] - assert.Equal(t, hex.EncodeToString(vector.bIn[:]), encodedBytesToStr) + cmp = hex.EncodeToString(vector.bIn[:]) == encodedBytesToStr + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } encodedBytesToStrIdx++ } } @@ -280,7 +296,10 @@ func TestPointConversion(t *testing.T) { } yB := BigIntPointToEncodedBytes(x, y) - assert.Equal(t, vector.bIn, yB) + cmp := bytes.Equal(vector.bIn[:], yB[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } // Assert our results. var buffer bytes.Buffer @@ -289,12 +308,18 @@ func TestPointConversion(t *testing.T) { buffer.WriteString(y.String()) localStr := buffer.String() decodedPoint := decodedPointsSet[decodedPointsIdx] - assert.Equal(t, localStr, decodedPoint) + cmp = localStr == decodedPoint + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } decodedPointsIdx++ // Assert our results. encodedPoint := encodedPointsSet[encodedPointsIdx] - assert.Equal(t, hex.EncodeToString(vector.bIn[:]), encodedPoint) + cmp = hex.EncodeToString(vector.bIn[:]) == encodedPoint + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } encodedPointsIdx++ } } diff --git a/dcrec/edwards/threshold_test.go b/dcrec/edwards/threshold_test.go index be8165c5..8711e34b 100644 --- a/dcrec/edwards/threshold_test.go +++ b/dcrec/edwards/threshold_test.go @@ -10,8 +10,6 @@ import ( "math/big" "math/rand" "testing" - - "github.com/stretchr/testify/assert" ) type signerHex struct { @@ -91,9 +89,19 @@ func TestSchnorrThreshold(t *testing.T) { privNonce, pubNonce, err := PrivKeyFromScalar(curve, nonce[:]) - assert.NotNil(t, privNonce) - assert.NotNil(t, pubNonce) - assert.NoError(t, err) + cmp := privNonce != nil + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } + + cmp = pubNonce != nil + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } + + if err != nil { + t.Fatalf("unexpected error %s, ", err) + } privNoncesToUse[j] = privNonce pubNoncesToUse[j] = pubNonce @@ -103,20 +111,27 @@ func TestSchnorrThreshold(t *testing.T) { // Partial signature generation. publicNonceSum := CombinePubkeys(curve, pubNoncesToUse) - assert.NotNil(t, publicNonceSum) + cmp := publicNonceSum != nil + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } for j := range keysToUse { r, s, err := schnorrPartialSign(curve, msg, keysToUse[j].Serialize(), allPksSum.Serialize(), privNoncesToUse[j].Serialize(), publicNonceSum.Serialize()) - assert.NoError(t, err) - localSig := NewSignature(r, s) + if err != nil { + t.Fatalf("unexpected error %s, ", err) + } + localSig := NewSignature(r, s) partialSignatures[j] = localSig } // Combine signatures. combinedSignature, err := SchnorrCombineSigs(curve, partialSignatures) - assert.NoError(t, err) + if err != nil { + t.Fatalf("unexpected error %s, ", err) + } // Make sure the combined signatures are the same as the // signatures that would be generated by simply adding @@ -135,20 +150,32 @@ func TestSchnorrThreshold(t *testing.T) { combinedPrivkey, _, err := PrivKeyFromScalar(curve, copyBytes(combinedPrivkeysD.Bytes())[:]) - assert.NoError(t, err) + if err != nil { + t.Fatalf("unexpected error %s, ", err) + } combinedNonce, _, err := PrivKeyFromScalar(curve, copyBytes(combinedNonceD.Bytes())[:]) - assert.NoError(t, err) + if err != nil { + t.Fatalf("unexpected error %s, ", err) + } cSigR, cSigS, err := SignFromScalar(curve, combinedPrivkey, combinedNonce.Serialize(), msg) sumSig := NewSignature(cSigR, cSigS) - assert.Equal(t, sumSig.Serialize(), combinedSignature.Serialize()) + cmp = bytes.Equal(sumSig.Serialize(), combinedSignature.Serialize()) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } + + if err != nil { + t.Fatalf("unexpected error %s, ", err) + } // Verify the combined signature and public keys. ok := Verify(allPksSum, msg, combinedSignature.GetR(), combinedSignature.GetS()) - assert.NoError(t, err) - assert.Equal(t, true, ok) + if !ok { + t.Fatalf("expected %v, got %v", true, ok) + } // Corrupt some memory and make sure it breaks something. corruptWhat := tRand.Intn(3) @@ -217,7 +244,9 @@ func TestSchnorrThreshold(t *testing.T) { if allPksSum != nil && combinedSignature != nil { ok = Verify(allPksSum, msg, combinedSignature.GetR(), combinedSignature.GetS()) - assert.Equal(t, false, ok) + if ok { + t.Fatalf("expected %v, got %v", false, ok) + } } } } diff --git a/dcrec/secp256k1/schnorr/ecdsa_test.go b/dcrec/secp256k1/schnorr/ecdsa_test.go index 2eb5aa8f..d8a9a29a 100644 --- a/dcrec/secp256k1/schnorr/ecdsa_test.go +++ b/dcrec/secp256k1/schnorr/ecdsa_test.go @@ -12,7 +12,6 @@ import ( "github.com/decred/dcrd/chaincfg/chainhash" "github.com/decred/dcrd/dcrec/secp256k1" - "github.com/stretchr/testify/assert" ) type SchorrSigningTestVectorHex struct { @@ -130,22 +129,33 @@ func TestSchnorrSigning(t *testing.T) { sig, err := schnorrSign(curve, tv.msg, tv.priv, tv.nonce, nil, nil, testSchnorrHash) + if err != nil { + t.Fatalf("unexpected error %v", err) + } - assert.NoError(t, err) - assert.Equal(t, sig.Serialize(), tv.sig) + cmp := bytes.Equal(sig.Serialize()[:], tv.sig[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } // Make sure they verify too while we're at it. _, err = schnorrVerify(curve, sig.Serialize(), pubkey, tv.msg, testSchnorrHash) - assert.NoError(t, err) + if err != nil { + t.Fatalf("unexpected error %v", err) + } // See if we can recover the public keys OK. var pkRecover *secp256k1.PublicKey pkRecover, _, err = schnorrRecover(curve, sig.Serialize(), tv.msg, testSchnorrHash) - assert.NoError(t, err) - if err == nil { - assert.Equal(t, pubkey.Serialize(), pkRecover.Serialize()) + if err != nil { + t.Fatalf("unexpected error %v", err) + } + + cmp = bytes.Equal(pubkey.Serialize()[:], pkRecover.Serialize()[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) } // Screw up the signature at a random bit and make sure that breaks it. @@ -155,16 +165,23 @@ func TestSchnorrSigning(t *testing.T) { sigBad[pos] ^= 1 << uint8(bitPos) _, err = schnorrVerify(curve, sigBad, pubkey, tv.msg, testSchnorrHash) - assert.Error(t, err) + if err == nil { + t.Fatalf("expected an error, got %v", err) + } // Make sure it breaks pubkey recovery too. valid := false pkRecover, valid, err = schnorrRecover(curve, sigBad, tv.msg, testSchnorrHash) if valid { - assert.NotEqual(t, pubkey.Serialize(), pkRecover.Serialize()) + cmp = bytes.Equal(pubkey.Serialize()[:], pkRecover.Serialize()[:]) + if cmp { + t.Fatalf("expected %v, got %v", false, cmp) + } } else { - assert.Error(t, err) + if err == nil { + t.Fatalf("expected an error, got %v", err) + } } } } @@ -279,18 +296,26 @@ func TestSignaturesAndRecovery(t *testing.T) { // Make sure we can verify the original signature. _, err := schnorrVerify(curve, sig.Serialize(), pubkey, tv.msg, chainhash.HashB) - assert.NoError(t, err) + if err != nil { + t.Fatalf("expected an error, got %v", err) + } ok := Verify(curve, pubkey, tv.msg, sig.R, sig.S) - assert.Equal(t, true, ok) + if !ok { + t.Fatalf("expected %v, got %v", true, ok) + } // See if we can recover the public keys OK. var pkRecover *secp256k1.PublicKey pkRecover, _, err = schnorrRecover(curve, sig.Serialize(), tv.msg, chainhash.HashB) - assert.NoError(t, err) - if err == nil { - assert.Equal(t, pubkey.Serialize(), pkRecover.Serialize()) + if err != nil { + t.Fatalf("unexpected error %s", err) + } + + cmp := bytes.Equal(pubkey.Serialize()[:], pkRecover.Serialize()[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) } // Screw up the signature at some random bits and make sure @@ -305,16 +330,23 @@ func TestSignaturesAndRecovery(t *testing.T) { } _, err = schnorrVerify(curve, sigBad, pubkey, tv.msg, chainhash.HashB) - assert.Error(t, err) + if err == nil { + t.Fatalf("expected an error, got %v", err) + } // Make sure it breaks pubkey recovery too. valid := false pkRecover, valid, err = schnorrRecover(curve, sigBad, tv.msg, testSchnorrHash) if valid { - assert.NotEqual(t, pubkey.Serialize(), pkRecover.Serialize()) + cmp := bytes.Equal(pubkey.Serialize()[:], pkRecover.Serialize()[:]) + if cmp { + t.Fatalf("expected %v, got %v", false, cmp) + } } else { - assert.Error(t, err) + if err == nil { + t.Fatalf("expected an error, got %v", err) + } } } } diff --git a/dcrec/secp256k1/schnorr/threshold_test.go b/dcrec/secp256k1/schnorr/threshold_test.go index 9bc041bd..c4ae693b 100644 --- a/dcrec/secp256k1/schnorr/threshold_test.go +++ b/dcrec/secp256k1/schnorr/threshold_test.go @@ -13,7 +13,6 @@ import ( "github.com/decred/dcrd/chaincfg/chainhash" "github.com/decred/dcrd/dcrec/secp256k1" - "github.com/stretchr/testify/assert" ) type signerHex struct { @@ -224,13 +223,22 @@ func TestSchnorrThresholdRef(t *testing.T) { for i, signer := range tv.signers { nonce := nonceRFC6979(signer.privkey, tv.msg, nil, Sha256VersionStringRFC6979) - assert.Equal(t, nonce, signer.privateNonce) + cmp := bytes.Equal(nonce[:], signer.privateNonce[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } _, pubkey := secp256k1.PrivKeyFromBytes(curve, signer.privkey) - assert.Equal(t, pubkey.Serialize(), signer.pubkey.Serialize()) + cmp = bytes.Equal(pubkey.Serialize()[:], signer.pubkey.Serialize()[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } _, pubNonce := secp256k1.PrivKeyFromBytes(curve, nonce) - assert.Equal(t, pubNonce.Serialize(), signer.publicNonce.Serialize()) + cmp = bytes.Equal(pubNonce.Serialize()[:], signer.publicNonce.Serialize()[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } // Calculate the public nonce sum. pubKeys := make([]*secp256k1.PublicKey, len(tv.signers)-1, @@ -246,20 +254,35 @@ func TestSchnorrThresholdRef(t *testing.T) { itr++ } publicNonceSum := CombinePubkeys(curve, pubKeys) - assert.Equal(t, publicNonceSum, signer.pubKeySumLocal) + cmp = bytes.Equal(publicNonceSum.Serialize()[:], signer.pubKeySumLocal.Serialize()[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } sig, err := schnorrPartialSign(curve, tv.msg, signer.privkey, nonce, publicNonceSum, testSchnorrSha256Hash) - assert.NoError(t, err) - assert.Equal(t, sig.Serialize(), signer.partialSignature) + if err != nil { + t.Fatalf("unexpected error %s, ", err) + } + + cmp = bytes.Equal(sig.Serialize()[:], signer.partialSignature[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } partialSignatures[i] = sig } // Combine signatures. combinedSignature, err := CombineSigs(curve, partialSignatures) - assert.NoError(t, err) - assert.Equal(t, combinedSignature.Serialize(), tv.combinedSignature) + if err != nil { + t.Fatalf("unexpected error %s, ", err) + } + + cmp := bytes.Equal(combinedSignature.Serialize()[:], tv.combinedSignature[:]) + if !cmp { + t.Fatalf("expected %v, got %v", true, cmp) + } // Combine pubkeys. allPubkeys := make([]*secp256k1.PublicKey, len(tv.signers), @@ -272,8 +295,13 @@ func TestSchnorrThresholdRef(t *testing.T) { // Verify the combined signature and public keys. ok, err := schnorrVerify(curve, combinedSignature.Serialize(), allPksSum, tv.msg, testSchnorrSha256Hash) - assert.NoError(t, err) - assert.Equal(t, true, ok) + if err != nil { + t.Fatalf("unexpected error %s, ", err) + } + + if !ok { + t.Fatalf("expected %v, got %v", true, ok) + } } } @@ -335,14 +363,18 @@ func TestSchnorrThreshold(t *testing.T) { sig, err := schnorrPartialSign(curve, msg, keysToUse[j].Serialize(), privNoncesToUse[j].Serialize(), publicNonceSum, chainhash.HashB) - assert.NoError(t, err) + if err != nil { + t.Fatalf("unexpected error %s, ", err) + } partialSignatures[j] = sig } // Combine signatures. combinedSignature, err := CombineSigs(curve, partialSignatures) - assert.NoError(t, err) + if err != nil { + t.Fatalf("unexpected error %s, ", err) + } // Combine pubkeys. allPubkeys := make([]*secp256k1.PublicKey, numKeysForTest) @@ -353,8 +385,13 @@ func TestSchnorrThreshold(t *testing.T) { // Verify the combined signature and public keys. ok, err := schnorrVerify(curve, combinedSignature.Serialize(), allPksSum, msg, chainhash.HashB) - assert.NoError(t, err) - assert.Equal(t, true, ok) + if err != nil { + t.Fatalf("unexpected error %s, ", err) + } + + if !ok { + t.Fatalf("expected %v, got %v", true, ok) + } // Corrupt some memory and make sure it breaks something. corruptWhat := tRand.Intn(3) @@ -427,7 +464,9 @@ func TestSchnorrThreshold(t *testing.T) { if allPksSum != nil && combinedSignature != nil { ok, _ = schnorrVerify(curve, combinedSignature.Serialize(), allPksSum, msg, chainhash.HashB) - assert.Equal(t, false, ok) + if ok { + t.Fatalf("expected %v, got %v", false, ok) + } } } } diff --git a/glide.lock b/glide.lock index f6b51de3..56399180 100644 --- a/glide.lock +++ b/glide.lock @@ -1,5 +1,5 @@ hash: 08687d42743fa8e53a336734ae67bd4801a606ced8c7c2dd774404f32391eca6 -updated: 2017-08-29T16:54:41.153871329-04:00 +updated: 2017-08-30T22:08:08.795369694Z imports: - name: github.com/agl/ed25519 version: 278e1ec8e8a6e017cd07577924d6766039146ced @@ -51,7 +51,7 @@ imports: - name: github.com/decred/dcrrpcclient version: abc326aeb97b299c7eb6b13b81353fc375e9b95d - name: github.com/decred/dcrutil - version: 166211f0196be1d3be344ae64149e7c4f5ca36b0 + version: 4ce0f41cf3f957fcdf3f0de049602ac834449b9c subpackages: - base58 - bloom @@ -61,21 +61,12 @@ imports: subpackages: - rotator - name: golang.org/x/crypto - version: 81e90905daefcd6fd217b62423c0908922eadb30 + version: 6914964337150723782436d56b3f21610a74ce7b subpackages: - ripemd160 - ssh/terminal - name: golang.org/x/sys - version: ab9e364efd8b52800ff7ee48a9ffba4e0ed78dfb + version: 90796e5a05ce440b41c768bd9af257005e470461 subpackages: - unix - - windows -testImports: -- name: github.com/pmezard/go-difflib - version: d8ed2627bdf02c080bf22230dbb337003b7aba2d - subpackages: - - difflib -- name: github.com/stretchr/testify - version: 69483b4bd14f5845b5a1e55bca19e954e827f1d0 - subpackages: - - assert +testImports: [] diff --git a/glide.yaml b/glide.yaml index 601e44ea..c816ab68 100644 --- a/glide.yaml +++ b/glide.yaml @@ -41,8 +41,6 @@ import: subpackages: - ripemd160 - ssh/terminal -testImport: -- package: github.com/stretchr/testify - version: ^1.1.0 +- package: github.com/jrick/logrotate subpackages: - - assert + - rotator