diff --git a/.gitignore b/.gitignore index 197e472e0..ebd08290e 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,7 @@ build # ignore IDE config and use instead the following command to re-generate them correctly: ./gradlew cleanEclipse eclipse +.idea/* .settings/* .vscode/* .settings/org.eclipse.buildship.core.prefs diff --git a/.idea/.gitignore b/.idea/.gitignore deleted file mode 100644 index 26d33521a..000000000 --- a/.idea/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -# Default ignored files -/shelf/ -/workspace.xml diff --git a/.idea/.name b/.idea/.name deleted file mode 100644 index 9065abbdd..000000000 --- a/.idea/.name +++ /dev/null @@ -1 +0,0 @@ -minima \ No newline at end of file diff --git a/.idea/compiler.xml b/.idea/compiler.xml deleted file mode 100644 index fb7f4a8a4..000000000 --- a/.idea/compiler.xml +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - \ No newline at end of file diff --git a/.idea/gradle.xml b/.idea/gradle.xml deleted file mode 100644 index 611e7c8ad..000000000 --- a/.idea/gradle.xml +++ /dev/null @@ -1,17 +0,0 @@ - - - - - - - \ No newline at end of file diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml deleted file mode 100644 index efa46250b..000000000 --- a/.idea/jarRepositories.xml +++ /dev/null @@ -1,20 +0,0 @@ - - - - - - - - - - - \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml deleted file mode 100644 index 31a4e772a..000000000 --- a/.idea/misc.xml +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml deleted file mode 100644 index 35eb1ddfb..000000000 --- a/.idea/vcs.xml +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - \ No newline at end of file diff --git a/src/org/minima/objects/base/MiniData.java b/src/org/minima/objects/base/MiniData.java index f573e6295..db6051e15 100644 --- a/src/org/minima/objects/base/MiniData.java +++ b/src/org/minima/objects/base/MiniData.java @@ -293,16 +293,4 @@ public static MiniData getRandomData(int len) { rand.nextBytes(data); return new MiniData(data); } - - public static void main(String[] zArgs) { - - MiniData dd = new MiniData(BigInteger.ONE.multiply(new BigInteger("-1"))); - System.out.println(dd.getDataValue()+" "+dd.to0xString()); - - MiniData ff = dd.shiftr(1); - - System.out.println(dd.getDataValue()+" "+ff.getDataValue()+" "+ff.shiftr(1).getDataValue()); - System.out.println(dd.to0xString()+" "+ff.to0xString()+" "+ff.shiftr(1).to0xString()); - - } } diff --git a/test/org/minima/tests/objects/AddressTests.java b/test/org/minima/tests/objects/AddressTests.java index 82ec38de2..e7060d428 100644 --- a/test/org/minima/tests/objects/AddressTests.java +++ b/test/org/minima/tests/objects/AddressTests.java @@ -3,7 +3,10 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertThrows; import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; @@ -11,120 +14,169 @@ import java.io.DataOutputStream; import java.io.IOException; import java.io.InputStream; +import org.junit.Assert; import org.junit.Test; import org.junit.internal.ArrayComparisonFailure; import org.minima.objects.Address; import org.minima.objects.base.MiniData; +import org.minima.utils.json.JSONObject; public class AddressTests { @Test - public void testAddress() { - MiniData c = new MiniData(); - MiniData j = new MiniData("0xFFFF"); - MiniData n = new MiniData("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"); - Address ad = new Address(); - Address a = new Address("0xf0f0"); - Address abc = new Address("0xf0f0"); - assertNotNull("should not be null", a); - // System.out.println("address value " + a); - a.getAddressData(); - // System.out.println("address value " + a.getAddressData()); - Address adr = new Address(j); - // System.out.println("address value " + adr); - Address adrTwo = new Address(n); - // System.out.println("address value " + adrTwo); - Address adrThree = new Address(c); - // System.out.println("address value " + adrThree); - // System.out.println("json value " + adrTwo.toJSON()); - // System.out.println("script value " + adrTwo.getScript()); - // System.out.println("minima addess value " + adrTwo.getMinimaAddress()); - assertFalse("should not be equal ", a.isEqual(adrThree)); - assertTrue("should not be equal ", a.isEqual(abc)); - + public void testConstructors() { + { + Address addr = Address.TRUE_ADDRESS; + assertNotNull(addr); + assertEquals("RETURN TRUE", addr.getScript()); + } + { + Address addr = new Address(); + assertNotNull(addr); + //assertNull(addr.getScript()); // default constructor does not initialize MiniString + } + { + Address addr = new Address("RETURN TRUE"); + assertNotNull(addr); + assertEquals("RETURN TRUE", addr.getScript()); + } + { + MiniData md = new MiniData(); + Address addr = new Address(md); + assertNotNull(addr); + assertEquals("", addr.getScript()); + } + { + for (int i = 16; i <= 68; i = i + 4) { + if (i == 44) { + continue; + } + MiniData md1 = MiniData.getRandomData(i); + Address addr1 = new Address(md1); + assertNotNull(addr1); + assertEquals("", addr1.getScript()); + assertEquals(md1, addr1.getAddressData()); + assertEquals(Address.makeMinimaAddress(md1), addr1.getMinimaAddress()); + + MiniData md2 = MiniData.getRandomData(i); + Address addr2 = new Address(md2); + assertNotNull(addr2); + assertEquals("", addr2.getScript()); + assertEquals(md2, addr2.getAddressData()); + assertEquals(Address.makeMinimaAddress(md2), addr2.getMinimaAddress()); + + assertTrue(addr1.isEqual(addr1)); + assertFalse(addr1.isEqual(addr2)); + + } + } } @Test public void testWriteAndReadDataStream() { try { - MiniData i = new MiniData("0xfff0f0"); - Address a = new Address(i); - - ByteArrayOutputStream bos = new ByteArrayOutputStream(); - DataOutputStream dos = new DataOutputStream(bos); - a.writeDataStream(dos); - - InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); - DataInputStream dis = new DataInputStream(inputStream); - - a.readDataStream(dis); - // System.out.println("minima value " + a.toString()); - - assertNotNull(i); - assertEquals("0xFFF0F0", a.toString()); + for (int i = 16; i <= 64; i = i + 4) { + if (i == 44) { + continue; + } + MiniData md1 = MiniData.getRandomData(i); + Address addr1 = new Address(md1); + assertNotNull(addr1); + assertEquals("", addr1.getScript()); + assertEquals(md1, addr1.getAddressData()); + assertEquals(Address.makeMinimaAddress(md1), addr1.getMinimaAddress()); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + addr1.writeDataStream(dos); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + Address addr2 = new Address(); + addr2.readDataStream(dis); + + assertTrue(addr1.isEqual(addr2)); + } } catch (final IOException e) { - System.out.println("IOException: " + e.toString() + " msg=" + e.getMessage()); - assertTrue(" there should not be an IOException", false); + fail(); } - } @Test - public void testMakeMinimaAddress() { - - MiniData i = new MiniData("0xffffffffffffffffffffffffffffffffffffffff"); - - String mxAddress = Address.makeMinimaAddress(i); - MiniData j = Address.convertMinimaAddress(mxAddress); - try { - assertEquals("should be equal", i, j); - System.out.println("should be equal to - " + i); - } catch (ArrayComparisonFailure failure) { - System.out.println("Test failed: " + failure.getMessage()); - assertFalse("test should not fail:" + failure.getMessage(), true); + public void testJSONConversion() { + for (int i = 16; i <= 68; i = i + 4) { + if (i == 44) { + continue; + } + MiniData md1 = MiniData.getRandomData(i); + Address addr1 = new Address(md1); + assertNotNull(addr1); + assertEquals("", addr1.getScript()); + assertEquals(md1, addr1.getAddressData()); + assertEquals(Address.makeMinimaAddress(md1), addr1.getMinimaAddress()); + + JSONObject json = addr1.toJSON(); + + assertTrue("JSON object should contain script key", json.containsKey("script")); + assertTrue("JSON object should contain hexaddress key", json.containsKey("hexaddress")); + assertTrue("JSON object should contain miniaddress key", json.containsKey("miniaddress")); } + } - MiniData q = new MiniData( - "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); - // byte[] data1 = q.getData(); - - // //First hash it to add some checksum digits.. - // byte[] hash1 = Crypto.getInstance().hashData(data1, 160); - // //Calculate a new length - ONLY certain lengths allowed! - // int len1 = data1.length; - // System.out.println("New 32bit len1 " + len1); - String mxAddress1 = Address.makeMinimaAddress(q); - MiniData p = Address.convertMinimaAddress(mxAddress1); - try { - assertEquals("should be equal", q, p); - // System.out.println("should be equal to - " + q); - } catch (ArrayComparisonFailure failure) { - System.out.println("Test failed: " + failure.getMessage()); - assertFalse("test should not fail:" + failure.getMessage(), true); + @Test + public void testToString() { + for (int i = 16; i <= 68; i = i + 4) { + if (i == 44) { + continue; + } + MiniData md1 = MiniData.getRandomData(i); + Address addr1 = new Address(md1); + assertNotNull(addr1); + assertEquals("", addr1.getScript()); + assertEquals(md1, addr1.getAddressData()); + assertEquals(Address.makeMinimaAddress(md1), addr1.getMinimaAddress()); + + String exp_s = addr1.getAddressData().toString(); + String obj_s = addr1.toString(); + assertEquals("should be equal ", exp_s, obj_s); } + } - MiniData l = new MiniData("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); - MiniData o = new MiniData("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); - MiniData v = new MiniData("0xffffffffffffffffffffffffffffffffffffffff"); - - String mxAddress3 = Address.makeMinimaAddress(l); - String mxAddress4 = Address.makeMinimaAddress(v); - String mxAddress5 = Address.makeMinimaAddress(o); - MiniData m = Address.convertMinimaAddress(mxAddress3); - MiniData m2 = Address.convertMinimaAddress(mxAddress4); - MiniData m3 = Address.convertMinimaAddress(mxAddress5); - - try { - assertEquals("should be equal", l, m); - assertEquals("should be equal", v, m2); - assertEquals("should be equal", o, m3); - - // System.out.println("should be equal to - " + l); - } catch (ArrayComparisonFailure failure) { - System.out.println("Test failed: " + failure.getMessage()); - assertFalse("test should not fail:" + failure.getMessage(), true); + @Test + public void testconvertMinimaAddress() { + { + for (int i = 16; i <= 68; i = i + 4) { + if (i == 44) { + continue; + } + MiniData md1 = MiniData.getRandomData(i); + Address addr1 = new Address(md1); + assertNotNull(addr1); + assertEquals("", addr1.getScript()); + assertEquals(md1, addr1.getAddressData()); + assertEquals(Address.makeMinimaAddress(md1), addr1.getMinimaAddress()); + + if (i == 16) { + // makeMinimaAddress does not create mx address for length less than 20 + assertThrows(ArithmeticException.class, () -> { + Address.convertMinimaAddress(addr1.getMinimaAddress()); + }); + continue; + } + if (i == 68) { + // makeMinimaAddress does not create mx address for length greater than 64 + assertThrows(ArithmeticException.class, () -> { + Address.convertMinimaAddress(addr1.getMinimaAddress()); + }); + continue; + } + + MiniData md2 = Address.convertMinimaAddress(addr1.getMinimaAddress()); + assertEquals(md1, md2); + } } - } } diff --git a/test/org/minima/tests/objects/CoinTests.java b/test/org/minima/tests/objects/CoinTests.java index 00063b575..e3661355e 100644 --- a/test/org/minima/tests/objects/CoinTests.java +++ b/test/org/minima/tests/objects/CoinTests.java @@ -16,11 +16,12 @@ import org.minima.objects.Coin; import org.minima.objects.base.MiniData; import org.minima.objects.base.MiniNumber; +import org.minima.utils.json.JSONObject; public class CoinTests { @Test - public void testCoin() { + public void testConstructors() { MiniData md = Coin.COINID_OUTPUT; MiniData md3 = Coin.TOKENID_CREATE; MiniData md2 = Coin.MINIMA_TOKENID; @@ -104,4 +105,39 @@ public void testStaticReadAndWriteDataStream() { assertTrue(" there should not be an IOException", false); } } + + @Test + public void testGettersAndSetters() { + } + + @Test + public void testJSONConversion() { + MiniData coinId = MiniData.getRandomData(16); + MiniData coinAddress = MiniData.getRandomData(20); + MiniNumber twelve = MiniNumber.TWELVE; + MiniData tokenId = MiniData.getRandomData(16); + Coin c = new Coin(coinId, coinAddress, twelve, tokenId); + + JSONObject json = c.toJSON(); + + assertTrue("JSON object should contain coinid key", json.containsKey("coinid")); + assertTrue("JSON object should contain address key", json.containsKey("address")); + assertTrue("JSON object should contain mxaddress key", json.containsKey("mxaddress")); + assertTrue("JSON object should contain amount key", json.containsKey("amount")); + assertTrue("JSON object should contain tokenid key", json.containsKey("tokenid")); + assertTrue("JSON object should contain floating key", json.containsKey("floating")); + } + + @Test + public void testToString() { + MiniData coinId = MiniData.getRandomData(16); + MiniData coinAddress = MiniData.getRandomData(20); + MiniNumber twelve = MiniNumber.TWELVE; + MiniData tokenId = MiniData.getRandomData(16); + Coin c = new Coin(coinId, coinAddress, twelve, tokenId); + + String exp_s = c.toJSON().toString(); + String obj_s = c.toString(); + assertEquals("should be equal ", exp_s, obj_s); + } } diff --git a/test/org/minima/tests/objects/MagicTests.java b/test/org/minima/tests/objects/MagicTests.java new file mode 100644 index 000000000..ca5b1cf18 --- /dev/null +++ b/test/org/minima/tests/objects/MagicTests.java @@ -0,0 +1,72 @@ +package org.minima.tests.objects; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import java.io.InputStream; +import static org.junit.Assert.fail; + +import org.junit.Test; +import org.minima.objects.Magic; +import org.minima.utils.json.JSONObject; + +public class MagicTests { + + @Test + public void testConstructors() { + Magic m = new Magic(); + } + + @Test + public void testReadAndWriteDataStream() { + try { + Magic m = new Magic(); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + m.writeDataStream(dos); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + Magic m2 = new Magic(); + m2.readDataStream(dis); + + assertTrue(m.mDesiredMaxKISSVMInstructions.isEqual(m2.mDesiredMaxKISSVMInstructions)); + assertTrue(m.mDesiredMaxTxPoWSize.isEqual(m2.mDesiredMaxTxPoWSize)); + assertTrue(m.mDesiredMaxTxnPerBlock.isEqual(m2.mDesiredMaxTxnPerBlock)); + assertEquals(m.mPRNG, m2.mPRNG); + } catch (final IOException e) { + fail(); + } + } + + @Test + public void testJSONConversion() { + Magic m = new Magic(); + + JSONObject json = m.toJSON(); + + assertTrue("JSON object should contain prng key", json.containsKey("prng")); + assertTrue("JSON object should contain maxtxpow key", json.containsKey("maxtxpow")); + assertTrue("JSON object should contain maxtxn key", json.containsKey("maxtxn")); + assertTrue("JSON object should contain maxkissvm key", json.containsKey("maxkissvm")); + } + + @Test + public void testToString() { + Magic m = new Magic(); + + String exp_s = m.toJSON().toString(); + String obj_s = m.toString(); + assertEquals("should be equal ", exp_s, obj_s); + } +} diff --git a/test/org/minima/tests/objects/PubPrivKeyTests.java b/test/org/minima/tests/objects/PubPrivKeyTests.java index 06c3a342d..fc87f16b2 100644 --- a/test/org/minima/tests/objects/PubPrivKeyTests.java +++ b/test/org/minima/tests/objects/PubPrivKeyTests.java @@ -1,10 +1,19 @@ package org.minima.tests.objects; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import java.io.InputStream; +import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; import org.junit.Test; +import org.minima.objects.Magic; import org.minima.objects.base.MiniData; import org.minima.objects.keys.PubPrivKey; import org.minima.utils.json.JSONObject; @@ -40,8 +49,8 @@ public void testConstructors() { k = new PubPrivKey(theSeed); MiniData nonEmptySeed2 = k.getPrivateSeed(); assertTrue("seed should exist", nonEmptySeed2 != null); - assertTrue("seed should have correct length", nonEmptySeed2.getData().length == w*3); - + assertTrue("seed should have correct length", nonEmptySeed2.getData().length == w * 3); + } private void testSigningAndVerifying(String msg) { @@ -69,4 +78,28 @@ public void testSignAndVerifyGenesis() { public void testSignAndVerifyEvolution() { testSigningAndVerifying("The Evolution will not be Centralised"); } + + @Test + public void testStaticReadAndWriteDataStream() { + try { + PubPrivKey pk = new PubPrivKey(MiniData.getRandomData(32)); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + pk.writeDataStream(dos); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + PubPrivKey pk2 = new PubPrivKey(); + pk2.readDataStream(dis); + + assertTrue(pk.getPublicKey().isEqual(pk2.getPublicKey())); + assertTrue(pk.getPrivateSeed().isEqual(pk2.getPrivateSeed())); + assertEquals(pk.getBitLength(), pk2.getBitLength()); + } catch (final IOException e) { + fail(); + } + } } diff --git a/test/org/minima/tests/objects/StateVariableTests.java b/test/org/minima/tests/objects/StateVariableTests.java new file mode 100644 index 000000000..1c1fed774 --- /dev/null +++ b/test/org/minima/tests/objects/StateVariableTests.java @@ -0,0 +1,72 @@ +package org.minima.tests.objects; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import org.junit.Test; +import org.minima.objects.base.MiniData; +import org.minima.objects.keys.PubPrivKey; +import org.minima.utils.json.JSONObject; + +public class StateVariableTests { + + public static final int w = 12; + + @Test + public void testConstructors() { + PubPrivKey k = new PubPrivKey(); + MiniData emptySeed = k.getPrivateSeed(); + assertTrue("default seed should be empty", emptySeed == null); + k = new PubPrivKey(w * 3 * 8); + MiniData nonEmptySeed = k.getPrivateSeed(); + assertTrue("seed should exist", nonEmptySeed != null); + assertTrue("seed should have correct length", nonEmptySeed.getData().length == w * 3); + assertTrue("key bitlength has correct length", k.getBitLength() == 3 * w * 8); + byte[] pubkey = k.getPublicKey().getData(); + assertTrue("pub key should have correct length", pubkey.length == 3 * w); + String pubkeyStr = k.toString(); + assertNotNull("key str should not be null", pubkeyStr); + JSONObject json = k.toJSON(); + System.out.println("JSON: " + json.toJSONString()); + assertTrue("JSON object should contain public key", json.containsValue(pubkeyStr)); + assertTrue("JSON object should have correct length", json.containsValue(3 * w * 8)); + + byte[] seedBytes = new byte[w * 3]; + for (byte i = 0; i < seedBytes.length; i++) { + seedBytes[i] = i; + } + MiniData theSeed = new MiniData(seedBytes); + k = new PubPrivKey(theSeed); + MiniData nonEmptySeed2 = k.getPrivateSeed(); + assertTrue("seed should exist", nonEmptySeed2 != null); + assertTrue("seed should have correct length", nonEmptySeed2.getData().length == w * 3); + + } + + private void testSigningAndVerifying(String msg) { + PubPrivKey k = new PubPrivKey(w * 3 * 8); + MiniData miniMsg = new MiniData(msg.getBytes()); + MiniData sig = k.sign(miniMsg); + assertNotNull("signature should not be null"); + assertFalse("signature hould not have value zero", sig.isEqual(new MiniData("0"))); + assertTrue("signature is valid", k.verify(miniMsg, sig)); + } + + @Test + public void testSignAndVerifyHelloWorld() { + testSigningAndVerifying("Hello World"); + } + + public void testSignAndVerifyLoremIpsum() { + testSigningAndVerifying("Lorem ipsum"); + } + + public void testSignAndVerifyGenesis() { + testSigningAndVerifying("The Times 03/Jan/2009 Chancellor on brink of second bailout for banks"); + } + + public void testSignAndVerifyEvolution() { + testSigningAndVerifying("The Evolution will not be Centralised"); + } +} diff --git a/test/org/minima/tests/objects/TokenProofTests.java b/test/org/minima/tests/objects/TokenProofTests.java deleted file mode 100644 index cd9bbb571..000000000 --- a/test/org/minima/tests/objects/TokenProofTests.java +++ /dev/null @@ -1,71 +0,0 @@ -package org.minima.tests.objects; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; - -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.DataInputStream; -import java.io.DataOutputStream; -import java.io.IOException; -import java.io.InputStream; - -import org.junit.Test; -import org.minima.objects.base.MiniData; -import org.minima.objects.base.MiniNumber; -import org.minima.objects.base.MiniString; -import org.minima.objects.proofs.TokenProof; - -public class TokenProofTests { - - @Test - public void testTokenProof() { - MiniString name = new MiniString("token-name"); - MiniString script = new MiniString("FFFF"); - MiniData coinId = new MiniData("0xffff"); - MiniNumber twelve = MiniNumber.TWELVE; - TokenProof t = new TokenProof(coinId, twelve, twelve, name, script); - assertNotNull(t); - assertEquals("Should be equal ", twelve, t.getAmount()); - System.out.println("amount value " + t.getAmount()); - assertEquals("Should be equal ", name, t.getName()); - System.out.println("name value " + t.getName()); - System.out.println("script value " + script + " " + t.getTokenScript()); - // assertTrue("should be equal", t.getTokenScript().equals(script)); - // assertEquals("Should be equal ",script, t.getTokenScript()); - System.out.println("tokenscript value " + t.getTokenScript()); - System.out.println("coin id value " + t.getCoinID()); - System.out.println("token id value " + t.getTokenID()); - assertEquals("Should be equal ", twelve, t.getScale()); - System.out.println("scale value " + t.getScale()); -// System.out.println("scale factor value " + t.getScaleFactor()); - System.out.println("Json value " + t.toJSON()); - - } - - @Test - public void testStaticReadAndWriteDataStream() { - try { - MiniString name = new MiniString("token-name"); - MiniString script = new MiniString("FFFF"); - MiniData coinId = new MiniData("0xffff"); - MiniNumber twelve = MiniNumber.TWELVE; - TokenProof t = new TokenProof(coinId, twelve, twelve, name, script); - - ByteArrayOutputStream bos = new ByteArrayOutputStream(); - DataOutputStream dos = new DataOutputStream(bos); - t.writeDataStream(dos); - - InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); - DataInputStream dis = new DataInputStream(inputStream); - TokenProof.ReadFromStream(dis); - System.out.println("Proof json values in read and write stream - " + t.toJSON()); - - assertNotNull(t); - } catch (final IOException e) { - System.out.println("IOException: " + e.toString() + " msg=" + e.getMessage()); - assertTrue(" there should not be an IOException", false); - } - } -} diff --git a/test/org/minima/tests/objects/TxHeaderTests.java b/test/org/minima/tests/objects/TxHeaderTests.java index b4328d1ab..0c55b6f8d 100644 --- a/test/org/minima/tests/objects/TxHeaderTests.java +++ b/test/org/minima/tests/objects/TxHeaderTests.java @@ -17,7 +17,6 @@ public class TxHeaderTests { - public void TxHeaderTests() { // in real use case Txheader is configured / built by TxPoW TxHeader mHeader = new TxHeader(); diff --git a/test/org/minima/tests/objects/base/MiniByteTests.java b/test/org/minima/tests/objects/base/MiniByteTests.java index cd6249ff5..d058f1bde 100644 --- a/test/org/minima/tests/objects/base/MiniByteTests.java +++ b/test/org/minima/tests/objects/base/MiniByteTests.java @@ -10,11 +10,14 @@ import java.io.DataOutputStream; import java.io.IOException; import java.io.InputStream; +import org.junit.Assert; +import static org.junit.Assert.assertEquals; import org.junit.Test; import org.minima.objects.base.MiniByte; public class MiniByteTests { + @Test public void testValueBytes() { byte byt = 0; @@ -56,8 +59,11 @@ public void testReadFromByte() { InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); DataInputStream dis = new DataInputStream(inputStream); - i.ReadFromStream(dis); - assertNotNull(i); + MiniByte i1 = MiniByte.ReadFromStream(dis); + assertNotNull(i1); + + assertEquals(i.getValue(), i1.getValue()); + assertEquals(i.getByteValue(), i1.getByteValue()); System.out.println(" i is now equal to " + i); } catch (final IOException e) { System.out.println("IOException: " + e.toString() + " msg=" + e.getMessage()); diff --git a/test/org/minima/tests/objects/base/MiniDataTests.java b/test/org/minima/tests/objects/base/MiniDataTests.java index 9992fa897..060e23236 100644 --- a/test/org/minima/tests/objects/base/MiniDataTests.java +++ b/test/org/minima/tests/objects/base/MiniDataTests.java @@ -1,21 +1,22 @@ package org.minima.tests.objects.base; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; - import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.io.InputStream; +import java.math.BigInteger; import java.util.Arrays; import org.junit.Test; +import org.minima.kissvm.exceptions.ExecutionException; import org.minima.objects.base.MiniData; +import static org.junit.Assert.*; + public class MiniDataTests { + @Test public void testValueBytes() { MiniData i = new MiniData("0x1388"); @@ -83,6 +84,16 @@ public void testValueBytes() { System.out.println("i.isMoreEqual(j) i:" + i + " j:" + j + " resolves as " + i.isMoreEqual(j)); assertTrue("should be more that or equal with value true", j.isMoreEqual(j)); System.out.println("j.isMoreEqual(j) j:" + j + " j:" + j + " resolves as " + j.isMoreEqual(j)); + + assertThrows(IllegalArgumentException.class, () -> { + MiniData md = new MiniData(BigInteger.valueOf(-1)); + }); + assertThrows(IllegalArgumentException.class, () -> { + MiniData md = new MiniData(BigInteger.valueOf(-100)); + }); + assertThrows(IllegalArgumentException.class, () -> { + MiniData md = new MiniData(BigInteger.valueOf(-123456789)); + }); } @Test @@ -118,6 +129,133 @@ public void testReadFromStreamData() { } + @Test + public void testWriteAndReadDataStream() { + { + try { + MiniData md = new MiniData(""); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + md.writeDataStream(dos); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + MiniData md1 = new MiniData("01234567"); + md1.readDataStream(dis); + + assertEquals(md.getLength(), md1.getLength()); + assertTrue(md.isEqual(md1)); + } catch (Exception e) { + fail(); + } + } + + { + try { + MiniData md = new MiniData("1234567890"); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + md.writeDataStream(dos); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + MiniData md1 = new MiniData("01234567"); + md1.readDataStream(dis, md.getLength()); + + assertEquals(md.getLength(), md1.getLength()); + assertTrue(md.isEqual(md1)); + } catch (Exception e) { + fail(); + } + } + + { + try { + MiniData md = new MiniData("1234567890"); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + md.writeDataStream(dos); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + MiniData md1 = new MiniData("01234567"); + assertThrows(IOException.class, () -> { + md1.readDataStream(dis, md.getLength() + 16); + }); + } catch (Exception e) { + fail(); + } + } + } + + @Test + public void testWriteAndReadHashDataStream() { + { + try { + MiniData md = MiniData.getRandomData(65); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + assertThrows(IOException.class, () -> { + md.writeHashToStream(dos); + }); + } catch (Exception e) { + fail(); + } + } + { + try { + MiniData md = MiniData.getRandomData(65); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + md.writeDataStream(dos); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + MiniData md1 = new MiniData("01234567"); + assertThrows(IOException.class, () -> { + md1.readHashFromStream(dis); + }); + } catch (Exception e) { + fail(); + } + } + { + try { + MiniData md = MiniData.getRandomData(65); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + dos.writeInt(-5); + dos.write(md.getData()); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + MiniData md1 = new MiniData("01234567"); + assertThrows(IOException.class, () -> { + md1.readHashFromStream(dis); + }); + } catch (Exception e) { + fail(); + } + } + } + @Test public void testReadFromStreamDataTooBig() { try { @@ -275,4 +413,15 @@ public void testReadHashStreamDataLarge() { } + @Test + public void testgetMiniDataVersion() { + { + try { + MiniData md = MiniData.getRandomData(128); + MiniData md1 = MiniData.getMiniDataVersion(md); + } catch (Exception e) { + fail(); + } + } + } } diff --git a/test/org/minima/tests/objects/base/MiniNumberTests.java b/test/org/minima/tests/objects/base/MiniNumberTests.java index 51bc3e6c3..482841a9b 100644 --- a/test/org/minima/tests/objects/base/MiniNumberTests.java +++ b/test/org/minima/tests/objects/base/MiniNumberTests.java @@ -12,8 +12,13 @@ import java.io.InputStream; import java.math.BigDecimal; import java.math.BigInteger; +import org.junit.Assert; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.fail; import org.junit.Test; +import org.minima.objects.base.MiniData; import org.minima.objects.base.MiniNumber; public class MiniNumberTests { @@ -50,6 +55,7 @@ public void testValues() { BigInteger k = new BigInteger("2147483649"); MiniNumber l = new MiniNumber(k); BigDecimal m = new BigDecimal(1.0); + MiniNumber n = new MiniNumber(l); System.out.println("MiniNumber() i value is " + i); System.out.println("MiniNumber(2147483649L) j value is " + j); System.out.println("BigInteger(\"2147483649\") k value is " + k); @@ -60,6 +66,7 @@ public void testValues() { assertNotNull("should not be null", k); assertNotNull("should not be null", l); assertNotNull("should not be null", MiniNumber.ONE); + assertNotNull("should not be null", n); System.out.println("MiniNumber.ONE value is " + MiniNumber.ONE); assertNotNull("should not be null", MiniNumber.ONE.getAsBigInteger()); System.out.println("MiniNumber.ONE.getAsBigInteger() value is " + MiniNumber.ONE.getAsBigInteger()); @@ -127,6 +134,50 @@ public void testValues() { + MiniNumber.ONE.getAsBigDecimal().equals(m)); } + @Test + public void testLimits() { + MiniNumber mn = new MiniNumber("0.111111111111111111111111111111111111111111111"); + assertEquals(mn.getNumber().scale(), MiniNumber.MAX_DECIMAL_PLACES); + assertEquals(mn.decimalPlaces(), MiniNumber.MAX_DECIMAL_PLACES); + + assertThrows(NumberFormatException.class, () -> { + MiniNumber mn1 = new MiniNumber(MiniNumber.MAX_MININUMBER.add(BigDecimal.TEN)); + }); + + assertThrows(NumberFormatException.class, () -> { + MiniNumber mn2 = new MiniNumber(MiniNumber.MIN_MININUMBER.subtract(BigDecimal.TEN)); + }); + + mn = new MiniNumber(-1); + assertFalse(mn.isValidMinimaValue()); + + mn = new MiniNumber(0); + assertFalse(mn.isValidMinimaValue()); + + mn = new MiniNumber(1); + assertTrue(mn.isValidMinimaValue()); + + mn = new MiniNumber(999999999); + assertTrue(mn.isValidMinimaValue()); + + mn = new MiniNumber(1000000000); + assertTrue(mn.isValidMinimaValue()); + + mn = new MiniNumber(1000000001); + assertFalse(mn.isValidMinimaValue()); + + mn = new MiniNumber(2000000001); + assertFalse(mn.isValidMinimaValue()); + + assertThrows(NumberFormatException.class, () -> { + MiniNumber.ONE.setSignificantDigits(MiniNumber.MAX_DIGITS + 1); + }); + assertThrows(NumberFormatException.class, () -> { + MiniNumber.ONE.setSignificantDigits(-1); + }); + + } + @Test public void testWriteDataStream() { try { @@ -164,6 +215,47 @@ public void testReadDataStream() { } + @Test + public void testInvalidReadDataStream() { + try { + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + dos.writeInt(0); + dos.writeInt(65); + dos.write(MiniData.getRandomData(65).getData()); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + assertThrows(IOException.class, () -> { + MiniNumber mn = MiniNumber.ONE; + mn.readDataStream(dis); + }); + } catch (Exception e) { + fail(); + } + + try { + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + dos.writeInt(0); + dos.writeInt(0); + dos.write(MiniData.getRandomData(65).getData()); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + assertThrows(IOException.class, () -> { + MiniNumber mn = MiniNumber.ONE; + mn.readDataStream(dis); + }); + } catch (Exception e) { + fail(); + } + } + @Test public void testReadStreamTooLarge() { try { diff --git a/test/org/minima/tests/objects/base/MiniStringTests.java b/test/org/minima/tests/objects/base/MiniStringTests.java index 321dfb27b..4468230ca 100644 --- a/test/org/minima/tests/objects/base/MiniStringTests.java +++ b/test/org/minima/tests/objects/base/MiniStringTests.java @@ -1,5 +1,6 @@ package org.minima.tests.objects.base; +import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; @@ -19,16 +20,20 @@ public class MiniStringTests { public void testValueString() { MiniString i = new MiniString("MinimaTest"); MiniString j = new MiniString(i); + MiniString k = new MiniString(i.getData()); System.out.println("MiniString(\"MinimaTest\") i is now equal to " + i); System.out.println("MiniString(i) j is now equal to " + j); assertNotNull("should not be null", i); System.out.println("i value is " + i); assertNotNull("should not be null", j); System.out.println("j value is " + j); + assertNotNull("should not be null", k); + System.out.println("j value is " + k); assertNotNull("should not be null", i.toString()); System.out.println("i.toString() value is " + i.toString()); assertNotNull("should not be null", i.getData()); System.out.println("i.getData() value is " + i.getData()); + assertEquals(i.toString(), k.toString()); } @Test diff --git a/test/org/minima/tests/objects/greet/GreetingTests.java b/test/org/minima/tests/objects/greet/GreetingTests.java new file mode 100644 index 000000000..e386ffd07 --- /dev/null +++ b/test/org/minima/tests/objects/greet/GreetingTests.java @@ -0,0 +1,102 @@ +package org.minima.tests.objects.greet; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.InputStream; +import java.util.ArrayList; + +import org.junit.Test; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.fail; + +import org.minima.GlobalParams; +import org.minima.objects.TxPoW; +import org.minima.objects.base.MiniNumber; +import org.minima.objects.greet.Greeting; + +public class GreetingTests { + + @Test + public void testConstructors() { + Greeting g = new Greeting(); + assertEquals(-1, g.getTopBlock().getAsInt()); + assertEquals(-1, g.getFirstBlock().getAsInt()); + assertEquals(0, g.getList().size()); + assertEquals(GlobalParams.MINIMA_VERSION, g.getVersion()); + assertEquals(0, g.getDetails().size()); + } + + @Test + public void testGettersAndSetters() { + Greeting g = new Greeting(); + assertEquals(-1, g.getTopBlock().getAsInt()); + assertEquals(-1, g.getFirstBlock().getAsInt()); + assertEquals(0, g.getList().size()); + assertEquals(GlobalParams.MINIMA_VERSION, g.getVersion()); + assertEquals(0, g.getDetails().size()); + + for (int i = 0; i < 16; i++) { + TxPoW txp = new TxPoW(); + txp.setBlockNumber(new MiniNumber(i + 5)); + txp.calculateTXPOWID(); + g.addBlock(txp); + } + assertEquals(16, g.getList().size()); + assertEquals(20, g.getTopBlock().getAsInt()); + assertEquals(5, g.getFirstBlock().getAsInt()); + + { + TxPoW txp = new TxPoW(); + txp.setBlockNumber(new MiniNumber(4)); + txp.calculateTXPOWID(); + g.addBlock(txp); + } + assertEquals(17, g.getList().size()); + assertEquals(20, g.getTopBlock().getAsInt()); + assertEquals(4, g.getFirstBlock().getAsInt()); + + g.setTopBlock(MiniNumber.MILLION); + assertEquals(MiniNumber.MILLION.getAsInt(), g.getTopBlock().getAsInt()); + + g.setTopBlock(new MiniNumber(-1000)); // can set negative values + assertEquals(-1000, g.getTopBlock().getAsInt()); + + g.setTopBlock(new MiniNumber(-1)); // and revert to default state + assertEquals(-1, g.getTopBlock().getAsInt()); + } + + @Test + public void testWriteAndReadDataStream() { + try { + Greeting g = new Greeting(); + for (int i = 0; i < 16; i++) { + TxPoW txp = new TxPoW(); + txp.setBlockNumber(new MiniNumber(i)); + txp.calculateTXPOWID(); + g.addBlock(txp); + } + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + g.writeDataStream(dos); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + Greeting g1 = Greeting.ReadFromStream(dis); + + assertEquals(g.getTopBlock().getAsInt(), g1.getTopBlock().getAsInt()); + assertEquals(g.getFirstBlock().getAsInt(), g1.getFirstBlock().getAsInt()); + assertEquals(g.getList().size(), g1.getList().size()); + assertEquals(g.getVersion(), g1.getVersion()); + assertEquals(g.getDetails().size(), g1.getDetails().size()); + } catch (Exception e) { + fail(); + } + } + +} diff --git a/test/org/minima/tests/objects/greet/SyncPackageTests.java b/test/org/minima/tests/objects/greet/SyncPackageTests.java new file mode 100644 index 000000000..88fec233c --- /dev/null +++ b/test/org/minima/tests/objects/greet/SyncPackageTests.java @@ -0,0 +1,91 @@ +package org.minima.tests.objects.greet; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.math.BigInteger; +import java.util.ArrayList; + +import org.junit.Test; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.fail; + +import org.minima.GlobalParams; +import org.minima.database.mmr.MMRSet; +import org.minima.database.txpowtree.BlockTreeNode; +import org.minima.objects.TxPoW; +import org.minima.objects.base.MiniData; +import org.minima.objects.base.MiniNumber; +import org.minima.objects.greet.SyncPackage; +import org.minima.objects.greet.SyncPacket; +import org.minima.utils.MiniFile; + +public class SyncPackageTests { + + @Test + public void testConstructors() { + { + SyncPackage sp = new SyncPackage(); + + assertEquals(0, sp.getAllNodes().size()); + assertEquals(MiniNumber.ZERO, sp.getCascadeNode()); + assertEquals(BigInteger.ZERO.longValue(), sp.calculateWeight().longValue()); + + sp.setCascadeNode(MiniNumber.ONE); + assertEquals(MiniNumber.ONE, sp.getCascadeNode()); + sp.setCascadeNode(MiniNumber.TWO); + assertEquals(MiniNumber.TWO, sp.getCascadeNode()); + sp.setCascadeNode(MiniNumber.FOUR); + assertEquals(MiniNumber.FOUR, sp.getCascadeNode()); + } + } + + @Test + public void testGettersAndSetters() { + } + + @Test + public void testWriteAndReadDataStream() { + try { + SyncPackage sp = new SyncPackage(); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + sp.writeDataStream(dos); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + SyncPackage sp1 = new SyncPackage(); + sp1.readDataStream(dis); + + assertEquals(sp.getAllNodes().size(), sp1.getAllNodes().size()); + assertEquals(sp.getCascadeNode().getAsInt(), sp1.getCascadeNode().getAsInt()); + assertEquals(sp.calculateWeight().longValue(), sp1.calculateWeight().longValue()); + } catch (Exception e) { + fail(); + } + } + + @Test + public void testToString() { + { + SyncPackage sp = new SyncPackage(); + + String exp_s = ""; + for (SyncPacket node : sp.getAllNodes()) { + exp_s += node + ","; + } + String obj_s = sp.toString(); + assertEquals(exp_s, obj_s); + } + } +} diff --git a/test/org/minima/tests/objects/greet/SyncPacketTests.java b/test/org/minima/tests/objects/greet/SyncPacketTests.java new file mode 100644 index 000000000..c3ef75ff9 --- /dev/null +++ b/test/org/minima/tests/objects/greet/SyncPacketTests.java @@ -0,0 +1,231 @@ +package org.minima.tests.objects.greet; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; + +import org.junit.Test; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.fail; + +import org.minima.GlobalParams; +import org.minima.database.mmr.MMRSet; +import org.minima.database.txpowtree.BlockTreeNode; +import org.minima.objects.TxPoW; +import org.minima.objects.base.MiniData; +import org.minima.objects.base.MiniNumber; +import org.minima.objects.greet.SyncPacket; +import org.minima.utils.MiniFile; + +public class SyncPacketTests { + + @Test + public void testConstructors() { + { + SyncPacket sp = new SyncPacket(); + assertNull(sp.getMMRSet()); + assertNull(sp.getTxPOW()); + assertFalse(sp.isCascade()); + } + { + TxPoW txp = new TxPoW(); + txp.calculateTXPOWID(); + + BlockTreeNode btn = new BlockTreeNode(txp); + + SyncPacket sp = new SyncPacket(btn); + + assertEquals(btn.getMMRSet(), sp.getMMRSet()); + assertEquals(txp, sp.getTxPOW()); + assertEquals(btn.isCascade(), sp.isCascade()); + } + { + TxPoW txp = new TxPoW(); + txp.calculateTXPOWID(); + + BlockTreeNode btn = new BlockTreeNode(txp); + + SyncPacket sp = new SyncPacket(btn, true); + + assertNull(sp.getMMRSet()); + assertEquals(txp, sp.getTxPOW()); + assertEquals(btn.isCascade(), sp.isCascade()); + } + } + + @Test + public void testWriteAndReadDataStream() { + // Fails on unpopulated object + //try { + // SyncPacket sp = new SyncPacket(); + // + // ByteArrayOutputStream bos = new ByteArrayOutputStream(); + // DataOutputStream dos = new DataOutputStream(bos); + // + // sp.writeDataStream(dos); + // + // InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + // DataInputStream dis = new DataInputStream(inputStream); + // + // SyncPacket sp1 = new SyncPacket(); + // sp1.readDataStream(dis); + // + // assertEquals(sp.getMMRSet(), sp1.getMMRSet()); + // assertEquals(sp.getTxPOW(), sp1.getTxPOW()); + // assertEquals(sp.isCascade(), sp1.isCascade()); + //} catch (Exception e) { + // fail(); + //} + + // Fails on partially populated object + //try { + // TxPoW txp = new TxPoW(); + // txp.calculateTXPOWID(); + // + // BlockTreeNode btn = new BlockTreeNode(txp); + // + // SyncPacket sp = new SyncPacket(btn); + // + // ByteArrayOutputStream bos = new ByteArrayOutputStream(); + // DataOutputStream dos = new DataOutputStream(bos); + // + // sp.writeDataStream(dos); + // + // InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + // DataInputStream dis = new DataInputStream(inputStream); + // + // SyncPacket sp1 = new SyncPacket(); + // // Read fails on partially populated object + // sp1.readDataStream(dis); + // + // assertEquals(sp.getMMRSet(), sp1.getMMRSet()); + // assertEquals(sp.getTxPOW(), sp1.getTxPOW()); + // assertEquals(sp.isCascade(), sp1.isCascade()); + //} catch (Exception e) { + // fail(); + //} + try { + TxPoW txp = new TxPoW(); + txp.calculateTXPOWID(); + + MMRSet mmrs = new MMRSet(512); + mmrs.addLeafNode(MiniData.getRandomData(16)); + + BlockTreeNode btn = new BlockTreeNode(txp); + btn.setMMRset(mmrs); + + SyncPacket sp = new SyncPacket(btn); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + sp.writeDataStream(dos); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + SyncPacket sp1 = new SyncPacket(); + sp1.readDataStream(dis); + + //assertEquals(sp.getMMRSet(), sp1.getMMRSet()); + assertEquals(sp.getTxPOW().toString(), sp1.getTxPOW().toString()); + assertEquals(sp.isCascade(), sp1.isCascade()); + } catch (Exception e) { + fail(); + } + + try { + TxPoW txp = new TxPoW(); + txp.calculateTXPOWID(); + + BlockTreeNode btn = new BlockTreeNode(txp); + btn.setCascade(true); + + SyncPacket sp = new SyncPacket(btn, true); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + sp.writeDataStream(dos); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + SyncPacket sp1 = SyncPacket.ReadFromStream(dis); + + assertEquals(sp.getMMRSet(), sp1.getMMRSet()); + assertEquals(sp.getTxPOW().toString(), sp1.getTxPOW().toString()); + assertEquals(sp.isCascade(), sp1.isCascade()); + } catch (Exception e) { + fail(); + } + } + + @Test + public void testToString() { + { + TxPoW txp = new TxPoW(); + txp.calculateTXPOWID(); + + BlockTreeNode btn = new BlockTreeNode(txp); + btn.setCascade(false); + + SyncPacket sp = new SyncPacket(btn); + + String exp_s = "MMR:" + !sp.isCascade() + " " + sp.getTxPOW(); + String obj_s = sp.toString(); + assertEquals(exp_s, obj_s); + } + { + TxPoW txp = new TxPoW(); + txp.calculateTXPOWID(); + + BlockTreeNode btn = new BlockTreeNode(txp); + btn.setCascade(true); + + SyncPacket sp = new SyncPacket(btn); + + String exp_s = "MMR:" + !sp.isCascade() + " " + sp.getTxPOW(); + String obj_s = sp.toString(); + assertEquals(exp_s, obj_s); + } + } + + @Test + public void testLoadBlock() { + TxPoW txp = new TxPoW(); + txp.calculateTXPOWID(); + + MMRSet mmrs = new MMRSet(512); + mmrs.addLeafNode(MiniData.getRandomData(16)); + + BlockTreeNode btn = new BlockTreeNode(txp); + btn.setMMRset(mmrs); + + SyncPacket sp = new SyncPacket(btn); + + try { + File f = new File("testLoadBlock.bin"); + f.createNewFile(); + MiniFile.writeObjectToFile(f, sp); + } catch (IOException ex) { + fail(); + } + + File f = new File("testLoadBlock.bin"); + SyncPacket sp1 = SyncPacket.loadBlock(f); + + //assertEquals(sp.getMMRSet(), sp1.getMMRSet()); + assertEquals(sp.getTxPOW().toString(), sp1.getTxPOW().toString()); + assertEquals(sp.isCascade(), sp1.isCascade()); + } + +} diff --git a/test/org/minima/tests/objects/greet/TxPoWListTests.java b/test/org/minima/tests/objects/greet/TxPoWListTests.java new file mode 100644 index 000000000..f05232369 --- /dev/null +++ b/test/org/minima/tests/objects/greet/TxPoWListTests.java @@ -0,0 +1,78 @@ +package org.minima.tests.objects.greet; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.InputStream; +import java.util.ArrayList; + +import org.junit.Test; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.fail; + +import org.minima.GlobalParams; +import org.minima.objects.TxPoW; +import org.minima.objects.base.MiniNumber; +import org.minima.objects.greet.TxPoWList; + +public class TxPoWListTests { + + @Test + public void testConstructors() { + TxPoWList txpl = new TxPoWList(); + assertEquals(0, txpl.getList().size()); + assertEquals(0, txpl.size()); + } + + @Test + public void testAdd() { + TxPoWList txpl = new TxPoWList(); + assertEquals(0, txpl.getList().size()); + assertEquals(0, txpl.size()); + + for (int i = 0; i < 16; i++) { + TxPoW txp = new TxPoW(); + txp.setBlockNumber(new MiniNumber(i + 5)); + txp.calculateTXPOWID(); + txpl.addTxPow(txp); + } + assertEquals(16, txpl.getList().size()); + assertEquals(16, txpl.size()); + } + + @Test + public void testWriteAndReadDataStream() { + try { + TxPoWList txpl = new TxPoWList(); + assertEquals(0, txpl.getList().size()); + assertEquals(0, txpl.size()); + + for (int i = 0; i < 16; i++) { + TxPoW txp = new TxPoW(); + txp.setBlockNumber(new MiniNumber(i)); + txp.calculateTXPOWID(); + txpl.addTxPow(txp); + } + assertEquals(16, txpl.getList().size()); + assertEquals(16, txpl.size()); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + txpl.writeDataStream(dos); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + TxPoWList txpl1 = new TxPoWList(); + txpl1.readDataStream(dis); + + assertEquals(txpl.getList().size(), txpl.getList().size()); + assertEquals(txpl.size(), txpl.size()); + } catch (Exception e) { + fail(); + } + } +} diff --git a/test/org/minima/tests/objects/keys/BaseKeyDummy.java b/test/org/minima/tests/objects/keys/BaseKeyDummy.java new file mode 100644 index 000000000..f0365664e --- /dev/null +++ b/test/org/minima/tests/objects/keys/BaseKeyDummy.java @@ -0,0 +1,45 @@ +package org.minima.tests.objects.keys; + +import org.minima.objects.base.MiniData; +import org.minima.objects.base.MiniNumber; +import org.minima.objects.keys.BaseKey; +import org.minima.utils.digest.WinternitzOTSignature; + +/** + * + * @author obucina + */ +public class BaseKeyDummy extends BaseKey { + + public BaseKeyDummy() { + super(); + } + + @Override + protected void initKeys(MiniData zPrivateSeed) { + mLevel = MiniNumber.ONE; + mMaxUses = MiniNumber.ONE; + mUses = MiniNumber.ZERO; + //Number of Bits of security + mBitLength = new MiniNumber(zPrivateSeed.getLength() * 8); + + //Create a random seed + mPrivateSeed = zPrivateSeed; + + //Create a WOTS + WinternitzOTSignature wots = new WinternitzOTSignature(mPrivateSeed.getData(), getHashFunction(mBitLength), getWinternitz()); + + //Get the Public Key.. + mPublicKey = new MiniData(wots.getPublicKey()); + } + + @Override + public MiniData sign(MiniData zData) { + return zData; + } + + @Override + public boolean verify(MiniData zData, MiniData zSignature) { + return true; + } +} diff --git a/test/org/minima/tests/objects/keys/BaseKeyTests.java b/test/org/minima/tests/objects/keys/BaseKeyTests.java new file mode 100644 index 000000000..371bbb749 --- /dev/null +++ b/test/org/minima/tests/objects/keys/BaseKeyTests.java @@ -0,0 +1,122 @@ +package org.minima.tests.objects.keys; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.fail; + +import org.junit.Test; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import java.io.InputStream; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import org.minima.objects.Magic; +import org.minima.objects.base.MiniData; +import org.minima.objects.base.MiniNumber; + +import org.minima.tests.objects.keys.BaseKeyDummy; +import org.minima.utils.json.JSONObject; + +public class BaseKeyTests { + + @Test + public void testConstructors() { + BaseKeyDummy bk = new BaseKeyDummy(); + MiniData RndMD = MiniData.getRandomData(32); + bk.initKeys(RndMD); + + assertTrue(MiniNumber.ONE.isEqual(bk.getLevel())); + assertTrue(MiniNumber.ONE.isEqual(bk.getMaxUses())); + assertTrue(MiniNumber.ZERO.isEqual(bk.getUses())); + } + + @Test + public void testGettersAndSetters() { + BaseKeyDummy bk = new BaseKeyDummy(); + MiniData RndMD = MiniData.getRandomData(32); + bk.initKeys(RndMD); + + MiniData PubKey = MiniData.getRandomData(32); + bk.setPublicKey(PubKey); + + assertEquals(PubKey.getLength() * 8, bk.getBitLength()); + assertTrue(PubKey.isEqual(bk.getPublicKey())); + + assertTrue(MiniNumber.ONE.isEqual(bk.getLevel())); + assertTrue(MiniNumber.ONE.isEqual(bk.getMaxUses())); + assertTrue(MiniNumber.ZERO.isEqual(bk.getUses())); + + bk.incrementUses(); + assertTrue(MiniNumber.ONE.isEqual(bk.getUses())); + bk.incrementUses(); // uses increases beyond MaxUses + assertTrue(MiniNumber.TWO.isEqual(bk.getUses())); + bk.incrementUses(); + assertTrue((new MiniNumber(3)).isEqual(bk.getUses())); + + bk.setUses(MiniNumber.SIXTYFOUR); // uses set beyond MaxUses + assertTrue(MiniNumber.SIXTYFOUR.isEqual(bk.getUses())); + } + + @Test + public void testWriteAndReadDataStream() { + try { + BaseKeyDummy bk = new BaseKeyDummy(); + bk.initKeys(MiniData.getRandomData(32)); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + bk.writeDataStream(dos); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + BaseKeyDummy bk2 = new BaseKeyDummy(); + bk2.readDataStream(dis); + + assertEquals(bk.getBitLength(), bk2.getBitLength()); + assertEquals(bk.getLevel().getAsLong(), bk2.getLevel().getAsLong()); + assertEquals(bk.getMaxUses().getAsLong(), bk2.getMaxUses().getAsLong()); + assertTrue(bk.getPrivateSeed().isEqual(bk2.getPrivateSeed())); + assertTrue(bk.getPublicKey().isEqual(bk2.getPublicKey())); + assertEquals(bk.getTotalAllowedUses().getAsLong(), bk2.getTotalAllowedUses().getAsLong()); + assertEquals(bk.getUses().getAsLong(), bk2.getUses().getAsLong()); + assertEquals(bk.getBitLength(), bk2.getBitLength()); + + } catch (Exception e) { + fail(); + } + } + + @Test + public void testJSONConversion() { + BaseKeyDummy bk = new BaseKeyDummy(); + bk.initKeys(MiniData.getRandomData(32)); + + JSONObject json = bk.toJSON(); + + assertTrue("JSON object should contain bits key", json.containsKey("bits")); + assertTrue("JSON object should contain uses key", json.containsKey("uses")); + assertTrue("JSON object should contain allowed key", json.containsKey("allowed")); + assertTrue("JSON object should contain publickey key", json.containsKey("publickey")); + } + + @Test + public void testToString() { + BaseKeyDummy bk = new BaseKeyDummy(); + bk.initKeys(MiniData.getRandomData(32)); + + String exp_s = bk.getPublicKey().toString(); + String obj_s = bk.toString(); + assertEquals("should be equal ", exp_s, obj_s); + } +} diff --git a/test/org/minima/tests/objects/keys/MultiKeyTests.java b/test/org/minima/tests/objects/keys/MultiKeyTests.java new file mode 100644 index 000000000..eaacf9ae0 --- /dev/null +++ b/test/org/minima/tests/objects/keys/MultiKeyTests.java @@ -0,0 +1,94 @@ +package keys; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.fail; + +import org.junit.Test; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import java.io.InputStream; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import org.minima.objects.Magic; +import org.minima.objects.base.MiniData; +import org.minima.objects.base.MiniNumber; +import org.minima.objects.keys.MultiKey; +import org.minima.utils.json.JSONObject; + +public class MultiKeyTests { + + @Test + public void testConstructors() { + { + MultiKey mk = new MultiKey(); + assertThrows(NullPointerException.class, () -> { // uninitialized members + MiniNumber.ONE.isEqual(mk.getLevel()); + }); + } + + { + MiniData RndMD = MiniData.getRandomData(32); + MultiKey mk = new MultiKey(RndMD); + + assertTrue(RndMD.isEqual(mk.getPublicKey())); + } + + { + MultiKey mk = new MultiKey(256); + + assertTrue(MultiKey.DEFAULT_LEVELS.isEqual(mk.getLevel())); + assertTrue(MultiKey.DEFAULT_KEYS_PER_LEVEL.isEqual(mk.getMaxUses())); + assertTrue(MultiKey.DEFAULT_KEYS_PER_LEVEL.pow(MultiKey.DEFAULT_LEVELS.getAsInt()).isEqual(mk.getTotalAllowedUses())); + assertTrue(MiniNumber.ZERO.isEqual(mk.getUses())); + assertTrue(mk.getBitLength() == 256); + } + + { + int BitLength = 512; + MiniNumber KeysPerLevel = new MiniNumber(4); + MiniNumber Level = new MiniNumber(4); + + MultiKey mk = new MultiKey(BitLength, KeysPerLevel, Level); + + assertTrue(Level.isEqual(mk.getLevel())); + assertTrue(KeysPerLevel.isEqual(mk.getMaxUses())); + assertTrue(KeysPerLevel.pow(Level.getAsInt()).isEqual(mk.getTotalAllowedUses())); + assertTrue(MiniNumber.ZERO.isEqual(mk.getUses())); + assertTrue(mk.getBitLength() == 512); + } + } + + @Test + public void testSignAndVerification() { + int BitLength = 160; + MiniNumber KeysPerLevel = new MiniNumber(4); + MiniNumber Level = new MiniNumber(4); + + MultiKey mk = new MultiKey(BitLength, KeysPerLevel, Level); + + { + MiniData DataToSign = MiniData.getRandomData(256); + MiniData Signature = mk.sign(DataToSign); + assertTrue(mk.verify(DataToSign, Signature)); + } + { + for (int i = 0; i < 1000; i++) { + // Multiple signing allowed, regardless of max use + MiniData DataToSign = MiniData.getRandomData(256); + MiniData Signature = mk.sign(DataToSign); + assertTrue(mk.verify(DataToSign, Signature)); + } + } + } + +} diff --git a/test/org/minima/tests/objects/keys/MultiSigTests.java b/test/org/minima/tests/objects/keys/MultiSigTests.java new file mode 100644 index 000000000..c4ae7f565 --- /dev/null +++ b/test/org/minima/tests/objects/keys/MultiSigTests.java @@ -0,0 +1,152 @@ +package keys; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.fail; + +import org.junit.Test; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import java.io.InputStream; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import org.minima.database.mmr.MMRSet; +import org.minima.objects.Magic; +import org.minima.objects.base.MiniData; +import org.minima.objects.base.MiniNumber; +import org.minima.objects.keys.MultiKey; +import org.minima.objects.keys.MultiSig; +import org.minima.objects.keys.SingleKey; +import org.minima.objects.proofs.Proof; +import org.minima.utils.BaseConverter; +import org.minima.utils.Crypto; +import org.minima.utils.json.JSONObject; + +public class MultiSigTests { + + @Test + public void testConstructors() { + { + MiniData zPrivateSeed = MiniData.getRandomData(32); + MiniNumber zKeysPerLevel = MultiKey.DEFAULT_KEYS_PER_LEVEL; + MiniNumber zLevel = MultiKey.DEFAULT_LEVELS; + MiniNumber zBitLength = new MiniNumber(zPrivateSeed.getLength() * 8); + SingleKey[] zSingleKeys = new SingleKey[zKeysPerLevel.getAsInt()]; + MMRSet zMMRset = new MMRSet(null, zBitLength.getAsInt()); + + for (int i = 0; i < zKeysPerLevel.getAsInt(); i++) { + MiniData numberdata = new MiniData(BaseConverter.numberToHex(i)); + MiniData newdata = numberdata.concat(zPrivateSeed); + byte[] hashdata = Crypto.getInstance().hashData(newdata.getData(), zBitLength.getAsInt()); + MiniData spriv = new MiniData(hashdata); + zSingleKeys[i] = new SingleKey(spriv); + zMMRset.addLeafNode(zSingleKeys[i].getPublicKey()); + } + + zMMRset.finalizeSet(); + + MiniData zDataToSign = MiniData.getRandomData(256); + + MiniData zCurrentPublicKey = zSingleKeys[0].getPublicKey(); + MiniData zCurrentSignature = zSingleKeys[0].sign(zDataToSign); + MiniData zCurrentProof = zMMRset.getProof(new MiniNumber(0)).getChainSHAProof(); + + MultiSig zSig = new MultiSig(zCurrentPublicKey, zCurrentProof, zCurrentSignature); + + Proof chainproof = new Proof(); + chainproof.setData(zCurrentPublicKey); + chainproof.setProof(zCurrentProof); + MiniData zRootKey = chainproof.getFinalHash(); + + assertTrue(zCurrentPublicKey.isEqual(zSig.getPublicKey())); + assertTrue(zCurrentSignature.isEqual(zSig.getSignature())); + assertTrue(zCurrentProof.isEqual(zSig.getProofChain())); + assertFalse(zSig.hasChildSignature()); + assertNull(zSig.getChildSignature()); + assertTrue(zRootKey.isEqual(zSig.getRootKey())); + + } + } + + @Test + public void test() { + } + + @Test + public void testJSONConversion() { + MiniData zPrivateSeed = MiniData.getRandomData(32); + MiniNumber zKeysPerLevel = MultiKey.DEFAULT_KEYS_PER_LEVEL; + MiniNumber zLevel = MultiKey.DEFAULT_LEVELS; + MiniNumber zBitLength = new MiniNumber(zPrivateSeed.getLength() * 8); + SingleKey[] zSingleKeys = new SingleKey[zKeysPerLevel.getAsInt()]; + MMRSet zMMRset = new MMRSet(null, zBitLength.getAsInt()); + + for (int i = 0; i < zKeysPerLevel.getAsInt(); i++) { + MiniData numberdata = new MiniData(BaseConverter.numberToHex(i)); + MiniData newdata = numberdata.concat(zPrivateSeed); + byte[] hashdata = Crypto.getInstance().hashData(newdata.getData(), zBitLength.getAsInt()); + MiniData spriv = new MiniData(hashdata); + zSingleKeys[i] = new SingleKey(spriv); + zMMRset.addLeafNode(zSingleKeys[i].getPublicKey()); + } + + zMMRset.finalizeSet(); + + MiniData zDataToSign = MiniData.getRandomData(256); + + MiniData zCurrentPublicKey = zSingleKeys[0].getPublicKey(); + MiniData zCurrentSignature = zSingleKeys[0].sign(zDataToSign); + MiniData zCurrentProof = zMMRset.getProof(new MiniNumber(0)).getChainSHAProof(); + + MultiSig zSig = new MultiSig(zCurrentPublicKey, zCurrentProof, zCurrentSignature); + + JSONObject json = zSig.toJSON(); + + assertTrue("JSON object should contain publickey key", json.containsKey("publickey")); + assertTrue("JSON object should contain proof key", json.containsKey("proof")); + assertTrue("JSON object should contain signature key", json.containsKey("signature")); + assertTrue("JSON object should contain childsig key", json.containsKey("childsig")); + } + + @Test + public void testToString() { + MiniData zPrivateSeed = MiniData.getRandomData(32); + MiniNumber zKeysPerLevel = MultiKey.DEFAULT_KEYS_PER_LEVEL; + MiniNumber zLevel = MultiKey.DEFAULT_LEVELS; + MiniNumber zBitLength = new MiniNumber(zPrivateSeed.getLength() * 8); + SingleKey[] zSingleKeys = new SingleKey[zKeysPerLevel.getAsInt()]; + MMRSet zMMRset = new MMRSet(null, zBitLength.getAsInt()); + + for (int i = 0; i < zKeysPerLevel.getAsInt(); i++) { + MiniData numberdata = new MiniData(BaseConverter.numberToHex(i)); + MiniData newdata = numberdata.concat(zPrivateSeed); + byte[] hashdata = Crypto.getInstance().hashData(newdata.getData(), zBitLength.getAsInt()); + MiniData spriv = new MiniData(hashdata); + zSingleKeys[i] = new SingleKey(spriv); + zMMRset.addLeafNode(zSingleKeys[i].getPublicKey()); + } + + zMMRset.finalizeSet(); + + MiniData zDataToSign = MiniData.getRandomData(256); + + MiniData zCurrentPublicKey = zSingleKeys[0].getPublicKey(); + MiniData zCurrentSignature = zSingleKeys[0].sign(zDataToSign); + MiniData zCurrentProof = zMMRset.getProof(new MiniNumber(0)).getChainSHAProof(); + + MultiSig zSig = new MultiSig(zCurrentPublicKey, zCurrentProof, zCurrentSignature); + + String exp_s = zSig.toJSON().toString(); + String obj_s = zSig.toString(); + assertEquals("should be equal ", exp_s, obj_s); + } +} diff --git a/test/org/minima/tests/objects/keys/SingleKeyTests.java b/test/org/minima/tests/objects/keys/SingleKeyTests.java new file mode 100644 index 000000000..cf6db0454 --- /dev/null +++ b/test/org/minima/tests/objects/keys/SingleKeyTests.java @@ -0,0 +1,69 @@ +package org.minima.tests.objects.keys; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.fail; + +import org.junit.Test; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import java.io.InputStream; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import org.minima.objects.Magic; +import org.minima.objects.base.MiniData; +import org.minima.objects.base.MiniNumber; +import org.minima.objects.keys.SingleKey; +import org.minima.utils.json.JSONObject; + +public class SingleKeyTests { + + @Test + public void testConstructors() { + { + SingleKey sk = new SingleKey(); + assertThrows(NullPointerException.class, () -> { // uninitialized members + MiniNumber.ONE.isEqual(sk.getLevel()); + }); + } + + { + MiniData RndMD = MiniData.getRandomData(32); + SingleKey sk = new SingleKey(RndMD); + + assertTrue(MiniNumber.ONE.isEqual(sk.getLevel())); + assertTrue(MiniNumber.ONE.isEqual(sk.getMaxUses())); + assertTrue(MiniNumber.ONE.isEqual(sk.getTotalAllowedUses())); + assertTrue(MiniNumber.ZERO.isEqual(sk.getUses())); + assertTrue(sk.getBitLength() == 256); + } + } + + @Test + public void testSignAndVerification() { + MiniData RndMD = MiniData.getRandomData(32); + SingleKey sk = new SingleKey(RndMD); + + { + MiniData DataToSign = MiniData.getRandomData(256); + MiniData Signature = sk.sign(DataToSign); + assertTrue(sk.verify(DataToSign, Signature)); + } + { + // Multiple signing allowed, regardless of max use + MiniData DataToSign = MiniData.getRandomData(256); + MiniData Signature = sk.sign(DataToSign); + assertTrue(sk.verify(DataToSign, Signature)); + } + } + +} diff --git a/test/org/minima/tests/objects/ProofTests.java b/test/org/minima/tests/objects/proofs/ProofTests.java similarity index 60% rename from test/org/minima/tests/objects/ProofTests.java rename to test/org/minima/tests/objects/proofs/ProofTests.java index ccd1d58e8..f10cec9ce 100644 --- a/test/org/minima/tests/objects/ProofTests.java +++ b/test/org/minima/tests/objects/proofs/ProofTests.java @@ -1,8 +1,4 @@ -package org.minima.tests.objects; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; +package org.minima.tests.objects.proofs; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; @@ -16,6 +12,9 @@ import org.minima.objects.base.MiniData; import org.minima.objects.base.MiniNumber; import org.minima.objects.proofs.Proof; +import org.minima.objects.proofs.Proof.ProofChunk; + +import static org.junit.Assert.*; public class ProofTests { @@ -58,6 +57,27 @@ public void testProof() throws Exception { System.out.println("Final hash values - " + p.getFinalHash()); System.out.println("Proof json values - " + p.toJSON()); + assertEquals(160, Proof.getChainSHABits("0x05")); + assertEquals(192, Proof.getChainSHABits("0x06")); + assertEquals(224, Proof.getChainSHABits("0x07")); + assertEquals(256, Proof.getChainSHABits("0x08")); + assertEquals(288, Proof.getChainSHABits("0x09")); + assertEquals(320, Proof.getChainSHABits("0x0A")); + assertEquals(384, Proof.getChainSHABits("0x0C")); + assertEquals(416, Proof.getChainSHABits("0x0D")); + assertEquals(448, Proof.getChainSHABits("0x0E")); + assertEquals(480, Proof.getChainSHABits("0x0F")); + assertEquals(512, Proof.getChainSHABits("0x10")); + + assertThrows(Exception.class, () -> { + Proof.getChainSHABits("0x04"); + }); + assertThrows(Exception.class, () -> { + Proof.getChainSHABits("0x0B"); + }); + assertThrows(Exception.class, () -> { + Proof.getChainSHABits("0x11"); + }); } @Test @@ -97,4 +117,52 @@ public void testStaticReadAndWriteDataStream() { assertTrue(" there should not be an IOException", false); } } + + @Test + public void testReadAndWriteDataStreamProofChunk() { + { + try { + Proof p = new Proof(); + Proof.ProofChunk pc = p.new ProofChunk(new MiniByte(8), MiniData.getRandomData(32), MiniNumber.ONE); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + pc.writeDataStream(dos); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + Proof p1 = new Proof(); + Proof.ProofChunk pc1 = p.new ProofChunk(); + + pc1.readDataStream(dis); + + } catch (Exception e) { + fail(); + } + } + { + try { + Proof p = new Proof(); + Proof.ProofChunk pc = p.new ProofChunk(new MiniByte(8), MiniData.getRandomData(32), MiniNumber.ZERO); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + + pc.writeDataStream(dos); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + + Proof p1 = new Proof(); + Proof.ProofChunk pc1 = p.new ProofChunk(); + + pc1.readDataStream(dis); + + } catch (Exception e) { + fail(); + } + } + } } diff --git a/test/org/minima/tests/objects/ScriptProofTests.java b/test/org/minima/tests/objects/proofs/ScriptProofTests.java similarity index 58% rename from test/org/minima/tests/objects/ScriptProofTests.java rename to test/org/minima/tests/objects/proofs/ScriptProofTests.java index bca314eab..6ad0fb18a 100644 --- a/test/org/minima/tests/objects/ScriptProofTests.java +++ b/test/org/minima/tests/objects/proofs/ScriptProofTests.java @@ -1,4 +1,4 @@ -package org.minima.tests.objects; +package org.minima.tests.objects.proofs; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; @@ -8,6 +8,7 @@ import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.InputStream; +import static org.junit.Assert.fail; import org.junit.Test; import org.minima.objects.base.MiniData; @@ -17,25 +18,33 @@ public class ScriptProofTests { @Test public void testScriptProof() { - String str = "test-string"; - // MiniData proofValue = new MiniData("0xffffffffffffffffffffffffff"); - MiniData j = new MiniData("0xED300A3D6C12BCFC24BB919C1F15E07F26A3A0C0"); - MiniData n = new MiniData("0xFFFF"); - String proofString = j.toString(); - ScriptProof sp; - ScriptProof sp2; - try { - sp = new ScriptProof(str, 160); - // sp2 = new ScriptProof(str, str); - System.out.println("ScriptProof value json - " + sp.toJSON()); - System.out.println("ScriptProof value json - " + sp.getScript()); - // System.out.println("ScriptProof value json - " + sp2.toJSON()); + { + String str = "test-string"; + // MiniData proofValue = new MiniData("0xffffffffffffffffffffffffff"); + MiniData j = new MiniData("0xED300A3D6C12BCFC24BB919C1F15E07F26A3A0C0"); + MiniData n = new MiniData("0xFFFF"); + String proofString = j.toString(); + ScriptProof sp; + ScriptProof sp2; + try { + sp = new ScriptProof(str, 160); + // sp2 = new ScriptProof(str, str); + System.out.println("ScriptProof value json - " + sp.toJSON()); + System.out.println("ScriptProof value json - " + sp.getScript()); + // System.out.println("ScriptProof value json - " + sp2.toJSON()); - } catch (Exception e) { - System.out.println("Exception: " + e.toString() + " msg=" + e.getMessage()); - assertTrue(" there should not be an Exception", false); + } catch (Exception e) { + System.out.println("Exception: " + e.toString() + " msg=" + e.getMessage()); + assertTrue(" there should not be an Exception", false); + } + } + { + try { + ScriptProof sp = new ScriptProof("RETURN TRUE", "0x10"); + } catch (Exception e) { + fail(); + } } - } @Test diff --git a/test/org/minima/tests/objects/SignatureProofTests.java b/test/org/minima/tests/objects/proofs/SignatureProofTests.java similarity index 97% rename from test/org/minima/tests/objects/SignatureProofTests.java rename to test/org/minima/tests/objects/proofs/SignatureProofTests.java index 0924645d4..395b83af0 100644 --- a/test/org/minima/tests/objects/SignatureProofTests.java +++ b/test/org/minima/tests/objects/proofs/SignatureProofTests.java @@ -1,4 +1,4 @@ -package org.minima.tests.objects; +package org.minima.tests.objects.proofs; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; diff --git a/test/org/minima/tests/objects/proofs/TokenProofTests.java b/test/org/minima/tests/objects/proofs/TokenProofTests.java new file mode 100644 index 000000000..0dfaea903 --- /dev/null +++ b/test/org/minima/tests/objects/proofs/TokenProofTests.java @@ -0,0 +1,165 @@ +package org.minima.tests.objects.proofs; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.math.BigDecimal; +import static org.junit.Assert.assertThrows; + +import org.junit.Test; +import org.minima.objects.base.MiniData; +import org.minima.objects.base.MiniNumber; +import org.minima.objects.base.MiniString; +import org.minima.objects.proofs.TokenProof; +import org.minima.utils.json.JSONObject; + +public class TokenProofTests { + + @Test + public void testTokenProof() { + MiniString name = new MiniString("token-name"); + MiniString script = new MiniString("FFFF"); + MiniData coinId = new MiniData("0xffff"); + MiniNumber twelve = MiniNumber.TWELVE; + TokenProof t = new TokenProof(coinId, twelve, twelve, name, script); + assertNotNull(t); + assertEquals("Should be equal ", twelve, t.getAmount()); + System.out.println("amount value " + t.getAmount()); + assertEquals("Should be equal ", name, t.getName()); + System.out.println("name value " + t.getName()); + System.out.println("script value " + script + " " + t.getTokenScript()); + // assertTrue("should be equal", t.getTokenScript().equals(script)); + // assertEquals("Should be equal ",script, t.getTokenScript()); + System.out.println("tokenscript value " + t.getTokenScript()); + System.out.println("coin id value " + t.getCoinID()); + System.out.println("token id value " + t.getTokenID()); + assertEquals("Should be equal ", twelve, t.getScale()); + System.out.println("scale value " + t.getScale()); +// System.out.println("scale factor value " + t.getScaleFactor()); + System.out.println("Json value " + t.toJSON()); + + { + TokenProof tp = new TokenProof(MiniData.getRandomData(16), MiniNumber.FOUR, new MiniNumber(10000), new MiniString("TokenName"), new MiniString("RETURN TRUE")); + assertEquals("1", tp.getScaledMinimaAmount(new MiniNumber(10000)).toString()); + assertEquals("10", tp.getScaledMinimaAmount(new MiniNumber(100000)).toString()); + assertEquals("100", tp.getScaledMinimaAmount(new MiniNumber(1000000)).toString()); + + assertEquals("TokenName", tp.getShowName()); + } + { + TokenProof tp = new TokenProof(MiniData.getRandomData(16), MiniNumber.FOUR, new MiniNumber(10000), new MiniString("{\"name\": \"TokenName\"}"), new MiniString("RETURN TRUE")); + assertEquals("TokenName", tp.getShowName()); + } + { + TokenProof tp = new TokenProof(MiniData.getRandomData(16), MiniNumber.FOUR, new MiniNumber(10000), new MiniString("{'name': 'TokenName'}"), new MiniString("RETURN TRUE")); + assertEquals("{'name': 'TokenName'}", tp.getShowName()); // Does not parse name with single quotes + } + { + TokenProof tp = new TokenProof(MiniData.getRandomData(16), MiniNumber.FOUR, new MiniNumber(10000), new MiniString("{\"name1\": \"TokenName\"}"), new MiniString("RETURN TRUE")); + assertThrows(Exception.class, () -> { + assertEquals("{\"name1\": \"TokenName\"}", tp.getShowName()); // Throws NullPointerexception on invalid string + }); + } + + } + + @Test + public void testStaticReadAndWriteDataStream() { + try { + MiniString name = new MiniString("token-name"); + MiniString script = new MiniString("FFFF"); + MiniData coinId = new MiniData("0xffff"); + MiniNumber twelve = MiniNumber.TWELVE; + TokenProof t = new TokenProof(coinId, twelve, twelve, name, script); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(bos); + t.writeDataStream(dos); + + InputStream inputStream = new ByteArrayInputStream(bos.toByteArray()); + DataInputStream dis = new DataInputStream(inputStream); + TokenProof.ReadFromStream(dis); + System.out.println("Proof json values in read and write stream - " + t.toJSON()); + + assertNotNull(t); + } catch (final IOException e) { + System.out.println("IOException: " + e.toString() + " msg=" + e.getMessage()); + assertTrue(" there should not be an IOException", false); + } + } + + @Test + public void testJSONConversion() { + { + TokenProof tp = new TokenProof(MiniData.getRandomData(16), MiniNumber.FOUR, new MiniNumber(10000), new MiniString("TokenName"), new MiniString("RETURN TRUE")); + + JSONObject json = tp.toJSON(); + + assertTrue("JSON object should contain tokenid key", json.containsKey("tokenid")); + assertTrue("JSON object should contain description key", json.containsKey("description")); + assertTrue("JSON object should contain icon key", json.containsKey("icon")); + assertTrue("JSON object should contain proof key", json.containsKey("proof")); + assertTrue("JSON object should contain total key", json.containsKey("total")); + assertTrue("JSON object should contain decimals key", json.containsKey("decimals")); + assertTrue("JSON object should contain script key", json.containsKey("script")); + assertTrue("JSON object should contain coinid key", json.containsKey("coinid")); + assertTrue("JSON object should contain totalamount key", json.containsKey("totalamount")); + assertTrue("JSON object should contain scale key", json.containsKey("scale")); + } + { + TokenProof tp = new TokenProof(MiniData.getRandomData(16), MiniNumber.FOUR, new MiniNumber(10000), new MiniString("{\"name\": \"TokenName\"}"), new MiniString("RETURN TRUE")); + + JSONObject json = tp.toJSON(); + + assertTrue("JSON object should contain tokenid key", json.containsKey("tokenid")); + assertTrue("JSON object should contain description key", json.containsKey("description")); + assertTrue("JSON object should contain icon key", json.containsKey("icon")); + assertTrue("JSON object should contain proof key", json.containsKey("proof")); + assertTrue("JSON object should contain total key", json.containsKey("total")); + assertTrue("JSON object should contain decimals key", json.containsKey("decimals")); + assertTrue("JSON object should contain script key", json.containsKey("script")); + assertTrue("JSON object should contain coinid key", json.containsKey("coinid")); + assertTrue("JSON object should contain totalamount key", json.containsKey("totalamount")); + assertTrue("JSON object should contain scale key", json.containsKey("scale")); + } + { + TokenProof tp = new TokenProof(MiniData.getRandomData(16), MiniNumber.FOUR, new MiniNumber(10000), new MiniString("{\"name\": \"TokenName\", \"description\": \"Description\", \"icon\": \"Icon\", \"proof\": \"Proof\"}"), new MiniString("RETURN TRUE")); + + JSONObject json = tp.toJSON(); + + assertTrue("JSON object should contain tokenid key", json.containsKey("tokenid")); + assertTrue("JSON object should contain description key", json.containsKey("description")); + assertTrue("JSON object should contain icon key", json.containsKey("icon")); + assertTrue("JSON object should contain proof key", json.containsKey("proof")); + assertTrue("JSON object should contain total key", json.containsKey("total")); + assertTrue("JSON object should contain decimals key", json.containsKey("decimals")); + assertTrue("JSON object should contain script key", json.containsKey("script")); + assertTrue("JSON object should contain coinid key", json.containsKey("coinid")); + assertTrue("JSON object should contain totalamount key", json.containsKey("totalamount")); + assertTrue("JSON object should contain scale key", json.containsKey("scale")); + } + { + TokenProof tp = new TokenProof(MiniData.getRandomData(16), MiniNumber.FOUR, new MiniNumber(10000), new MiniString("{'name': 'TokenName'}"), new MiniString("RETURN TRUE")); + + JSONObject json = tp.toJSON(); + + assertTrue("JSON object should contain tokenid key", json.containsKey("tokenid")); + assertTrue("JSON object should contain description key", json.containsKey("description")); + assertTrue("JSON object should contain icon key", json.containsKey("icon")); + assertTrue("JSON object should contain proof key", json.containsKey("proof")); + assertTrue("JSON object should contain total key", json.containsKey("total")); + assertTrue("JSON object should contain decimals key", json.containsKey("decimals")); + assertTrue("JSON object should contain script key", json.containsKey("script")); + assertTrue("JSON object should contain coinid key", json.containsKey("coinid")); + assertTrue("JSON object should contain totalamount key", json.containsKey("totalamount")); + assertTrue("JSON object should contain scale key", json.containsKey("scale")); + } + } +}