Adding junit test dependency, at test annotations for Secp256k1 test cases to sbt tests

src/main/java/org/bitcoin/NativeSecp256k1.java

@@ -52,7 +52,7 @@ public class NativeSecp256k1 {
      * @param pub The public key which did the signing
      */
     public static boolean verify(byte[] data, byte[] signature, byte[] pub) throws AssertFailException{
-        Preconditions.checkArgument(data.length == 32 && signature.length <= 520 && pub.length <= 520);
+        checkInvariant(data.length == 32 && signature.length <= 520 && pub.length <= 520);
 
         ByteBuffer byteBuff = nativeECDSABuffer.get();
         if (byteBuff == null || byteBuff.capacity() < 520) {
@@ -85,7 +85,7 @@ public class NativeSecp256k1 {
      * @param sig byte array of signature
      */
     public static byte[] sign(byte[] data, byte[] sec) throws AssertFailException{
-        Preconditions.checkArgument(data.length == 32 && sec.length <= 32);
+        checkInvariant(data.length == 32 && sec.length <= 32);
 
         ByteBuffer byteBuff = nativeECDSABuffer.get();
         if (byteBuff == null || byteBuff.capacity() < 32 + 32) {
@@ -121,7 +121,7 @@ public class NativeSecp256k1 {
      * @param seckey ECDSA Secret key, 32 bytes
      */
     public static boolean secKeyVerify(byte[] seckey) {
-        Preconditions.checkArgument(seckey.length == 32);
+        checkInvariant(seckey.length == 32);
 
         ByteBuffer byteBuff = nativeECDSABuffer.get();
         if (byteBuff == null || byteBuff.capacity() < seckey.length) {
@@ -151,7 +151,7 @@ public class NativeSecp256k1 {
      */
     //TODO add a 'compressed' arg
     public static byte[] computePubkey(byte[] seckey) throws AssertFailException{
-        Preconditions.checkArgument(seckey.length == 32);
+        checkInvariant(seckey.length == 32);
 
         ByteBuffer byteBuff = nativeECDSABuffer.get();
         if (byteBuff == null || byteBuff.capacity() < seckey.length) {
@@ -207,7 +207,7 @@ public class NativeSecp256k1 {
      * @param seckey 32-byte seckey
      */
     public static byte[] privKeyTweakMul(byte[] privkey, byte[] tweak) throws AssertFailException{
-        Preconditions.checkArgument(privkey.length == 32);
+        checkInvariant(privkey.length == 32);
 
         ByteBuffer byteBuff = nativeECDSABuffer.get();
         if (byteBuff == null || byteBuff.capacity() < privkey.length + tweak.length) {
@@ -246,7 +246,7 @@ public class NativeSecp256k1 {
      * @param seckey 32-byte seckey
      */
     public static byte[] privKeyTweakAdd(byte[] privkey, byte[] tweak) throws AssertFailException{
-        Preconditions.checkArgument(privkey.length == 32);
+        checkInvariant(privkey.length == 32);
 
         ByteBuffer byteBuff = nativeECDSABuffer.get();
         if (byteBuff == null || byteBuff.capacity() < privkey.length + tweak.length) {
@@ -285,7 +285,7 @@ public class NativeSecp256k1 {
      * @param pubkey 32-byte seckey
      */
     public static byte[] pubKeyTweakAdd(byte[] pubkey, byte[] tweak) throws AssertFailException{
-        Preconditions.checkArgument(pubkey.length == 33 || pubkey.length == 65);
+        checkInvariant(pubkey.length == 33 || pubkey.length == 65);
 
         ByteBuffer byteBuff = nativeECDSABuffer.get();
         if (byteBuff == null || byteBuff.capacity() < pubkey.length + tweak.length) {
@@ -324,7 +324,7 @@ public class NativeSecp256k1 {
      * @param pubkey 32-byte seckey
      */
     public static byte[] pubKeyTweakMul(byte[] pubkey, byte[] tweak) throws AssertFailException{
-        Preconditions.checkArgument(pubkey.length == 33 || pubkey.length == 65);
+        checkInvariant(pubkey.length == 33 || pubkey.length == 65);
 
         ByteBuffer byteBuff = nativeECDSABuffer.get();
         if (byteBuff == null || byteBuff.capacity() < pubkey.length + tweak.length) {
@@ -363,7 +363,7 @@ public class NativeSecp256k1 {
      * @param pubkey byte array of public key used in exponentiaion
      */
     public static byte[] createECDHSecret(byte[] seckey, byte[] pubkey) throws AssertFailException{
-        Preconditions.checkArgument(seckey.length <= 32 && pubkey.length <= 65);
+        checkInvariant(seckey.length <= 32 && pubkey.length <= 65);
 
         ByteBuffer byteBuff = nativeECDSABuffer.get();
         if (byteBuff == null || byteBuff.capacity() < 32 + pubkey.length) {
@@ -398,7 +398,7 @@ public class NativeSecp256k1 {
      * @param seed 32-byte random seed
      */
     public static synchronized boolean randomize(byte[] seed) throws AssertFailException{
-        Preconditions.checkArgument(seed.length == 32 || seed == null);
+        checkInvariant(seed.length == 32 || seed == null);
 
         ByteBuffer byteBuff = nativeECDSABuffer.get();
         if (byteBuff == null || byteBuff.capacity() < seed.length) {
@@ -443,4 +443,12 @@ public class NativeSecp256k1 {
 
     private static native byte[][] secp256k1_ecdh(ByteBuffer byteBuff, long context, int inputLen);
 
-}
+
+    private static void checkInvariant(boolean result) throws IllegalArgumentException {
+        if (!result) throw new IllegalArgumentException();
+    }
+
+}
+
+
+

src/main/java/org/bitcoin/NativeSecp256k1Util.java

@@ -16,7 +16,7 @@
 
 package org.bitcoin;
 
-public class NativeSecp256k1Util{
+public class NativeSecp256k1Util {
 
     public static void assertEquals( int val, int val2, String message ) throws AssertFailException{
         if( val != val2 )

src/test/java/org/bitcoin/NativeSecp256k1Test.java

@@ -1,10 +1,10 @@
 package org.bitcoin;
 
 import com.google.common.io.BaseEncoding;
-import java.util.Arrays;
-import java.math.BigInteger;
-import javax.xml.bind.DatatypeConverter;
-import static org.bitcoin.NativeSecp256k1Util.*;
+import org.junit.Test;
+
+import static org.bitcoin.NativeSecp256k1Util.AssertFailException;
+import static org.bitcoin.NativeSecp256k1Util.assertEquals;
 
 /**
  * This class holds test cases defined for testing this library.
@@ -15,7 +15,8 @@ public class NativeSecp256k1Test {
     /**
      * This tests verify() for a valid signature
      */
-    public static void testVerifyPos() throws AssertFailException{
+    @Test
+    public void testVerifyPos() throws AssertFailException {
         boolean result = false;
         byte[] data = BaseEncoding.base16().lowerCase().decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".toLowerCase()); //sha256hash of "testing"
         byte[] sig = BaseEncoding.base16().lowerCase().decode("3044022079BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F817980220294F14E883B3F525B5367756C2A11EF6CF84B730B36C17CB0C56F0AAB2C98589".toLowerCase());
@@ -28,7 +29,8 @@ public class NativeSecp256k1Test {
     /**
      * This tests verify() for a non-valid signature
      */
-    public static void testVerifyNeg() throws AssertFailException{
+    @Test
+    public void testVerifyNeg() throws AssertFailException{
         boolean result = false;
         byte[] data = BaseEncoding.base16().lowerCase().decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A91".toLowerCase()); //sha256hash of "testing"
         byte[] sig = BaseEncoding.base16().lowerCase().decode("3044022079BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F817980220294F14E883B3F525B5367756C2A11EF6CF84B730B36C17CB0C56F0AAB2C98589".toLowerCase());
@@ -42,7 +44,8 @@ public class NativeSecp256k1Test {
     /**
      * This tests secret key verify() for a valid secretkey
      */
-    public static void testSecKeyVerifyPos() throws AssertFailException{
+    @Test
+    public void testSecKeyVerifyPos() throws AssertFailException{
         boolean result = false;
         byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
 
@@ -54,7 +57,8 @@ public class NativeSecp256k1Test {
     /**
      * This tests secret key verify() for a invalid secretkey
      */
-    public static void testSecKeyVerifyNeg() throws AssertFailException{
+    @Test
+    public void testSecKeyVerifyNeg() throws AssertFailException{
         boolean result = false;
         byte[] sec = BaseEncoding.base16().lowerCase().decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".toLowerCase());
 
@@ -66,7 +70,8 @@ public class NativeSecp256k1Test {
     /**
      * This tests public key create() for a valid secretkey
      */
-    public static void testPubKeyCreatePos() throws AssertFailException{
+    @Test
+    public void testPubKeyCreatePos() throws AssertFailException{
         byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
 
         byte[] resultArr = NativeSecp256k1.computePubkey( sec);
@@ -77,7 +82,8 @@ public class NativeSecp256k1Test {
     /**
      * This tests public key create() for a invalid secretkey
      */
-    public static void testPubKeyCreateNeg() throws AssertFailException{
+    @Test
+    public void testPubKeyCreateNeg() throws AssertFailException{
         byte[] sec = BaseEncoding.base16().lowerCase().decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".toLowerCase());
 
         byte[] resultArr = NativeSecp256k1.computePubkey( sec);
@@ -88,7 +94,8 @@ public class NativeSecp256k1Test {
     /**
      * This tests sign() for a valid secretkey
      */
-    public static void testSignPos() throws AssertFailException{
+    @Test
+    public void testSignPos() throws AssertFailException{
 
         byte[] data = BaseEncoding.base16().lowerCase().decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".toLowerCase()); //sha256hash of "testing"
         byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
@@ -101,7 +108,8 @@ public class NativeSecp256k1Test {
     /**
      * This tests sign() for a invalid secretkey
      */
-    public static void testSignNeg() throws AssertFailException{
+    @Test
+    public void testSignNeg() throws AssertFailException{
         byte[] data = BaseEncoding.base16().lowerCase().decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".toLowerCase()); //sha256hash of "testing"
         byte[] sec = BaseEncoding.base16().lowerCase().decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".toLowerCase());
 
@@ -113,7 +121,8 @@ public class NativeSecp256k1Test {
     /**
      * This tests private key tweak-add
      */
-    public static void testPrivKeyTweakAdd_1() throws AssertFailException {
+    @Test
+    public void testPrivKeyTweakAdd_1() throws AssertFailException {
         byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
         byte[] data = BaseEncoding.base16().lowerCase().decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".toLowerCase()); //sha256hash of "tweak"
 
@@ -125,7 +134,8 @@ public class NativeSecp256k1Test {
     /**
      * This tests private key tweak-mul
      */
-    public static void testPrivKeyTweakMul_1() throws AssertFailException {
+    @Test
+    public void testPrivKeyTweakMul_1() throws AssertFailException {
         byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
         byte[] data = BaseEncoding.base16().lowerCase().decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".toLowerCase()); //sha256hash of "tweak"
 
@@ -137,7 +147,8 @@ public class NativeSecp256k1Test {
     /**
      * This tests private key tweak-add uncompressed
      */
-    public static void testPrivKeyTweakAdd_2() throws AssertFailException {
+    @Test
+    public void testPrivKeyTweakAdd_2() throws AssertFailException {
         byte[] pub = BaseEncoding.base16().lowerCase().decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase());
         byte[] data = BaseEncoding.base16().lowerCase().decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".toLowerCase()); //sha256hash of "tweak"
 
@@ -149,7 +160,8 @@ public class NativeSecp256k1Test {
     /**
      * This tests private key tweak-mul uncompressed
      */
-    public static void testPrivKeyTweakMul_2() throws AssertFailException {
+    @Test
+    public void testPrivKeyTweakMul_2() throws AssertFailException {
         byte[] pub = BaseEncoding.base16().lowerCase().decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase());
         byte[] data = BaseEncoding.base16().lowerCase().decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".toLowerCase()); //sha256hash of "tweak"
 
@@ -161,13 +173,15 @@ public class NativeSecp256k1Test {
     /**
      * This tests seed randomization
      */
-    public static void testRandomize() throws AssertFailException {
+    @Test
+    public void testRandomize() throws AssertFailException {
         byte[] seed = BaseEncoding.base16().lowerCase().decode("A441B15FE9A3CF56661190A0B93B9DEC7D04127288CC87250967CF3B52894D11".toLowerCase()); //sha256hash of "random"
         boolean result = NativeSecp256k1.randomize(seed);
         assertEquals( result, true, "testRandomize");
     }
 
-    public static void testCreateECDHSecret() throws AssertFailException{
+    @Test
+    public void testCreateECDHSecret() throws AssertFailException{
 
         byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
         byte[] pub = BaseEncoding.base16().lowerCase().decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase());
@@ -177,50 +191,4 @@ public class NativeSecp256k1Test {
         assertEquals( ecdhString, "2A2A67007A926E6594AF3EB564FC74005B37A9C8AEF2033C4552051B5C87F043" , "testCreateECDHSecret");
     }
 
-    public static void main(String[] args) throws AssertFailException{
-
-
-        System.out.println("\n libsecp256k1 enabled: " + Secp256k1Context.isEnabled() + "\n");
-
-        assertEquals( Secp256k1Context.isEnabled(), true, "isEnabled" );
-
-        //Test verify() success/fail
-        testVerifyPos();
-        testVerifyNeg();
-
-        //Test secKeyVerify() success/fail
-        testSecKeyVerifyPos();
-        testSecKeyVerifyNeg();
-
-        //Test computePubkey() success/fail
-        testPubKeyCreatePos();
-        testPubKeyCreateNeg();
-
-        //Test sign() success/fail
-        testSignPos();
-        testSignNeg();
-
-        //Test privKeyTweakAdd() 1
-        testPrivKeyTweakAdd_1();
-
-        //Test privKeyTweakMul() 2
-        testPrivKeyTweakMul_1();
-
-        //Test privKeyTweakAdd() 3
-        testPrivKeyTweakAdd_2();
-
-        //Test privKeyTweakMul() 4
-        testPrivKeyTweakMul_2();
-
-        //Test randomize()
-        testRandomize();
-
-        //Test ECDH
-        testCreateECDHSecret();
-
-        NativeSecp256k1.cleanup();
-
-        System.out.println(" All tests passed." );
-
-    }
 }

src/test/scala/org/bitcoins/core/crypto/ECPublicKeyTest.scala

@@ -48,7 +48,8 @@ class ECPublicKeyTest extends FlatSpec with MustMatchers {
     val bitcoinsPrivKey = ECPrivateKey.freshPrivateKey
     val bitcoinsSignature = bitcoinsPrivKey.sign(Sha256Hash.ZERO_HASH.getBytes)
     val bitcoinjPublicKey = org.bitcoinj.core.ECKey.fromPublicOnly(bitcoinsPrivKey.publicKey.bytes.toArray)
-    bitcoinjPublicKey.verify(Sha256Hash.ZERO_HASH.getBytes, bitcoinsSignature.bytes.toArray) must be (true)
+    bitcoinjPublicKey.verify(Sha256Hash.ZERO_HASH.getBytes,
+      bitcoinsSignature.bytes.toArray) must be (true)
   }
 
 }