diff --git a/ethereumj-core/src/test/java/org/ethereum/TestContext.java b/ethereumj-core/src/test/java/org/ethereum/TestContext.java
new file mode 100644
index 00000000..eda1c0bb
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/TestContext.java
@@ -0,0 +1,92 @@
+package org.ethereum;
+
+import org.ethereum.config.SystemProperties;
+import org.ethereum.facade.Ethereum;
+import org.hibernate.SessionFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.jdbc.datasource.DriverManagerDataSource;
+import org.springframework.orm.hibernate4.LocalSessionFactoryBuilder;
+
+import java.sql.SQLException;
+import java.util.Properties;
+
+/**
+ * @author Roman Mandeleil
+ * @since 16.11.2014
+ */
+public class TestContext {
+
+ private static final Logger logger = LoggerFactory.getLogger("test");
+
+
+ @Bean
+ public SessionFactory sessionFactory() throws SQLException {
+
+ logger.info("loading context");
+
+ LocalSessionFactoryBuilder builder =
+ new LocalSessionFactoryBuilder(dataSource());
+ builder.scanPackages("org.ethereum.db")
+ .addProperties(getHibernateProperties());
+
+ return builder.buildSessionFactory();
+ }
+
+ private Properties getHibernateProperties() {
+
+ Properties prop = new Properties();
+
+ if (SystemProperties.CONFIG.databaseReset())
+ prop.put("hibernate.hbm2ddl.auto", "create");
+
+ prop.put("hibernate.format_sql", "true");
+
+ // todo: useful but annoying consider define by system.properties
+// prop.put("hibernate.show_sql", "true");
+ prop.put("hibernate.dialect",
+ "org.hibernate.dialect.HSQLDialect");
+
+ prop.put("hibernate.connection.autocommit",
+ "true");
+
+ return prop;
+ }
+
+
+/*
+
+
+
+*/
+
+
+ @Bean(name = "dataSource")
+ public DriverManagerDataSource dataSource() {
+
+ logger.info("Connecting to the block store");
+
+ System.setProperty("hsqldb.reconfig_logging", "false");
+
+ String url =
+ String.format("jdbc:hsqldb:file:./%s/blockchain/blockchain.db;" +
+ "create=%s;hsqldb.default_table_type=cached",
+
+ SystemProperties.CONFIG.databaseDir(),
+ SystemProperties.CONFIG.databaseReset());
+
+ DriverManagerDataSource ds = new DriverManagerDataSource();
+ ds.setDriverClassName("org.hsqldb.jdbcDriver");
+ ds.setUrl(url);
+ ds.setUsername("sa");
+
+ return ds;
+ }
+
+
+ @Autowired
+ Ethereum eth;
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/blockstore/InMemoryBlockStoreTest.java b/ethereumj-core/src/test/java/org/ethereum/blockstore/InMemoryBlockStoreTest.java
new file mode 100644
index 00000000..f645cfd7
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/blockstore/InMemoryBlockStoreTest.java
@@ -0,0 +1,88 @@
+package org.ethereum.blockstore;
+
+import org.ethereum.core.Block;
+import org.ethereum.db.InMemoryBlockStore;
+import org.junit.Before;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spongycastle.util.encoders.Hex;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+/**
+ * @author: Roman Mandeleil
+ * Created on: 30/01/2015 11:04
+ */
+
+public class InMemoryBlockStoreTest {
+
+ private static final Logger logger = LoggerFactory.getLogger("test");
+ private InMemoryBlockStore blockStore;
+
+ @Before
+ public void setup() throws URISyntaxException, IOException {
+
+ blockStore = new InMemoryBlockStore();
+ URL scenario1 = ClassLoader
+ .getSystemResource("blockstore/load.dmp");
+
+ File file = new File(scenario1.toURI());
+ List strData = Files.readAllLines(file.toPath(), StandardCharsets.UTF_8);
+
+ for (String blockRLP : strData) {
+ Block block = new Block(
+ Hex.decode(blockRLP));
+ logger.trace("adding block.hash: [{}] block.number: [{}]",
+ block.getShortHash(),
+ block.getNumber());
+ blockStore.saveBlock(block, null);
+ }
+ }
+
+ @Test
+ public void testSaving8003Blocks() {
+
+ Block bestBlock = blockStore.getBestBlock();
+ Long bestIndex = blockStore.getBestBlock().getNumber();
+ Long firstIndex = bestIndex - InMemoryBlockStore.MAX_BLOCKS;
+
+ assertTrue(bestIndex == 8003);
+ assertTrue(firstIndex == 7003);
+
+ assertTrue(blockStore.getBlockByNumber(7000) == null);
+ assertTrue(blockStore.getBlockByNumber(8004) == null);
+
+ Block byHashBlock = blockStore.getBlockByHash(bestBlock.getHash());
+ assertTrue(bestBlock.getNumber() == byHashBlock.getNumber());
+
+ byte[] hashFor7500 = blockStore.getBlockByNumber(7500).getHash();
+ Block block7500 = blockStore.getBlockByHash(hashFor7500);
+ assertTrue(block7500.getNumber() == 7500);
+ }
+
+ @Test
+ public void testListOfHashes(){
+
+ Block block = blockStore.getBlockByNumber(7500);
+ byte[] hash = block.getHash();
+
+ List hashes = blockStore.getListOfHashesStartFrom(hash, 700);
+
+ byte[] lastHash = hashes.get(hashes.size() - 1);
+
+ assertEquals(Hex.toHexString(blockStore.getBestBlock().getHash()),
+ Hex.toHexString(lastHash));
+
+ assertTrue(hashes.size() == 504);
+ }
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/core/AccountStateTest.java b/ethereumj-core/src/test/java/org/ethereum/core/AccountStateTest.java
new file mode 100644
index 00000000..65b7e345
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/core/AccountStateTest.java
@@ -0,0 +1,23 @@
+package org.ethereum.core;
+
+import org.junit.Test;
+
+import org.spongycastle.util.encoders.Hex;
+
+import java.math.BigInteger;
+
+import static org.junit.Assert.assertEquals;
+
+public class AccountStateTest {
+
+ @Test
+ public void testGetEncoded() {
+ String expected = "f85e809"
+ + "a0100000000000000000000000000000000000000000000000000"
+ + "a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"
+ + "a0c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470";
+ AccountState acct = new AccountState(BigInteger.ZERO, BigInteger.valueOf(2).pow(200));
+ assertEquals(expected, Hex.toHexString(acct.getEncoded()));
+ }
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/core/BlockTest.java b/ethereumj-core/src/test/java/org/ethereum/core/BlockTest.java
new file mode 100644
index 00000000..a75966f3
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/core/BlockTest.java
@@ -0,0 +1,113 @@
+package org.ethereum.core;
+
+import org.ethereum.trie.SecureTrie;
+import org.ethereum.trie.Trie;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spongycastle.util.encoders.Hex;
+
+import java.math.BigInteger;
+import java.util.Collection;
+import java.util.Set;
+
+import static org.junit.Assert.*;
+
+
+public class BlockTest {
+
+ private static final Logger logger = LoggerFactory.getLogger("test");
+
+
+ // https://github.com/ethereum/tests/blob/71d80bd63aaf7cee523b6ca9d12a131698d41e98/BasicTests/genesishashestest.json
+ private String GENESIS_RLP = "f901f8f901f3a00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a09178d0f23c965d81f0834a4c72c6253ce6830f4022b1359aaebfc1ecba442d4ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302000080832fefd8808080a0000000000000000000000000000000000000000000000000000000000000000088000000000000002ac0c0";
+ private String GENESIS_HASH = "fd4af92a79c7fc2fd8bf0d342f2e832e1d4f485c85b9152d2039e03bc604fdca";
+ private String GENESIS_STATE_ROOT = "9178d0f23c965d81f0834a4c72c6253ce6830f4022b1359aaebfc1ecba442d4e";
+
+
+
+ static String TEST_GENESIS =
+ "{" +
+ "'0000000000000000000000000000000000000001': { 'wei': '1' }" +
+ "'0000000000000000000000000000000000000002': { 'wei': '1' }" +
+ "'0000000000000000000000000000000000000003': { 'wei': '1' }" +
+ "'0000000000000000000000000000000000000004': { 'wei': '1' }" +
+ "'dbdbdb2cbd23b783741e8d7fcf51e459b497e4a6': { 'wei': '1606938044258990275541962092341162602522202993782792835301376' }" +
+ "'e6716f9544a56c530d868e4bfbacb172315bdead': { 'wei': '1606938044258990275541962092341162602522202993782792835301376' }" +
+ "'b9c015918bdaba24b4ff057a92a3873d6eb201be': { 'wei': '1606938044258990275541962092341162602522202993782792835301376' }" +
+ "'1a26338f0d905e295fccb71fa9ea849ffa12aaf4': { 'wei': '1606938044258990275541962092341162602522202993782792835301376' }" +
+ "'2ef47100e0787b915105fd5e3f4ff6752079d5cb': { 'wei': '1606938044258990275541962092341162602522202993782792835301376' }" +
+ "'cd2a3d9f938e13cd947ec05abc7fe734df8dd826': { 'wei': '1606938044258990275541962092341162602522202993782792835301376' }" +
+ "'6c386a4b26f73c802f34673f7248bb118f97424a': { 'wei': '1606938044258990275541962092341162602522202993782792835301376' }" +
+ "'e4157b34ea9615cfbde6b4fda419828124b70c78': { 'wei': '1606938044258990275541962092341162602522202993782792835301376' }" +
+ "}";
+
+ static {
+ TEST_GENESIS = TEST_GENESIS.replace("'", "\"");
+ }
+
+
+
+ @Test
+ public void testGenesisFromRLP() {
+ // from RLP encoding
+ byte[] genesisBytes = Hex.decode(GENESIS_RLP);
+ Block genesisFromRLP = new Block(genesisBytes);
+ Block genesis = Genesis.getInstance();
+ assertEquals(Hex.toHexString(genesis.getHash()), Hex.toHexString(genesisFromRLP.getHash()));
+ assertEquals(Hex.toHexString(genesis.getParentHash()), Hex.toHexString(genesisFromRLP.getParentHash()));
+ assertEquals(Hex.toHexString(genesis.getStateRoot()), Hex.toHexString(genesisFromRLP.getStateRoot()));
+ }
+
+
+ @Test
+ public void testGenesisFromNew() {
+ Block genesis = Genesis.getInstance();
+ logger.info(genesis.toString());
+
+ logger.info("genesis hash: [{}]", Hex.toHexString(genesis.getHash()));
+ logger.info("genesis rlp: [{}]", Hex.toHexString(genesis.getEncoded()));
+
+ assertEquals(GENESIS_HASH, Hex.toHexString(genesis.getHash()));
+ assertEquals(GENESIS_RLP, Hex.toHexString(genesis.getEncoded()));
+ }
+
+ @Test
+ public void testGenesisPremineData() {
+ Genesis genesis = (Genesis) Genesis.getInstance();
+ Collection accounts = genesis.getPremine().values();
+ assertTrue(accounts.size() == 12);
+ }
+
+
+ @Test
+ public void testPremineFromJSON() throws ParseException {
+
+ JSONParser parser = new JSONParser();
+ JSONObject genesisMap = (JSONObject) parser.parse(TEST_GENESIS);
+
+ Set keys = genesisMap.keySet();
+
+ Trie state = new SecureTrie(null);
+
+ for (String key : keys) {
+
+ JSONObject val = (JSONObject) genesisMap.get(key);
+ String denom = (String) val.keySet().toArray()[0];
+ String value = (String) val.values().toArray()[0];
+
+ BigInteger wei = Denomination.valueOf(denom.toUpperCase()).value().multiply(new BigInteger(value));
+
+ AccountState acctState = new AccountState(BigInteger.ZERO, wei);
+ state.update(Hex.decode(key), acctState.getEncoded());
+ }
+
+ logger.info("root: " + Hex.toHexString(state.getRootHash()));
+ assertEquals(GENESIS_STATE_ROOT, Hex.toHexString(state.getRootHash()));
+ }
+
+
+}
\ No newline at end of file
diff --git a/ethereumj-core/src/test/java/org/ethereum/core/BloomTest.java b/ethereumj-core/src/test/java/org/ethereum/core/BloomTest.java
new file mode 100644
index 00000000..aaa024ca
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/core/BloomTest.java
@@ -0,0 +1,52 @@
+package org.ethereum.core;
+
+import org.ethereum.crypto.HashUtil;
+import org.junit.Assert;
+import org.junit.Test;
+import org.spongycastle.util.encoders.Hex;
+
+/**
+ * @author Roman Mandeleil
+ * @since 20.11.2014
+ */
+public class BloomTest {
+
+
+ @Test /// based on http://bit.ly/1MtXxFg
+ public void test1(){
+
+ byte[] address = Hex.decode("095e7baea6a6c7c4c2dfeb977efac326af552d87");
+ Bloom addressBloom = Bloom.create(HashUtil.sha3(address));
+
+ byte[] topic = Hex.decode("0000000000000000000000000000000000000000000000000000000000000000");
+ Bloom topicBloom = Bloom.create(HashUtil.sha3(topic));
+
+ Bloom totalBloom = new Bloom();
+ totalBloom.or(addressBloom);
+ totalBloom.or(topicBloom);
+
+
+ Assert.assertEquals(
+ "00000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000040000000000000000000000000000000000000000000000000000000",
+ totalBloom.toString()
+ );
+ }
+
+
+ @Test
+ public void test2() {
+ // todo: more testing
+ }
+
+ @Test
+ public void test3() {
+ // todo: more testing
+ }
+
+
+ @Test
+ public void test4() {
+ // todo: more testing
+ }
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/core/ImportTest.java b/ethereumj-core/src/test/java/org/ethereum/core/ImportTest.java
new file mode 100644
index 00000000..09b13e04
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/core/ImportTest.java
@@ -0,0 +1,93 @@
+package org.ethereum.core;
+
+
+import org.ethereum.config.SystemProperties;
+import org.ethereum.db.BlockStore;
+import org.ethereum.db.InMemoryBlockStore;
+import org.ethereum.manager.WorldManager;
+import org.hibernate.SessionFactory;
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spongycastle.util.encoders.Hex;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.ethereum.TestContext;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(loader = AnnotationConfigContextLoader.class)
+public class ImportTest {
+
+ private static final Logger logger = LoggerFactory.getLogger("test");
+
+ @Configuration
+ @ComponentScan(basePackages = "org.ethereum")
+ static class ContextConfiguration extends TestContext {
+ static {
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + ImportTest.class);
+ SystemProperties.CONFIG.setDatabaseReset(true);
+ }
+
+ @Bean
+ @Transactional(propagation = Propagation.SUPPORTS)
+ public BlockStore blockStore(SessionFactory sessionFactory){
+ return new InMemoryBlockStore();
+ }
+ }
+
+ @Autowired
+ WorldManager worldManager;
+
+ @After
+ public void close(){
+ worldManager.close();
+ }
+
+
+ @Test
+ public void testScenario1() throws URISyntaxException, IOException {
+
+ logger.error("Started");
+
+ BlockchainImpl blockchain = (BlockchainImpl) worldManager.getBlockchain();
+
+ URL scenario1 = ClassLoader
+ .getSystemResource("blockload/scenario1.dmp");
+
+ File file = new File(scenario1.toURI());
+ List strData = Files.readAllLines(file.toPath(), StandardCharsets.UTF_8);
+
+ byte[] root = Genesis.getInstance().getStateRoot();
+ for (String blockRLP : strData) {
+ Block block = new Block(
+ Hex.decode(blockRLP));
+ logger.info("sending block.hash: {}", Hex.toHexString(block.getHash()));
+ blockchain.tryToConnect(block);
+ root = block.getStateRoot();
+ }
+
+ logger.info("asserting root state is: {}", Hex.toHexString(root));
+ assertEquals(Hex.toHexString(root),
+ Hex.toHexString(worldManager.getRepository().getRoot()));
+ }
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/core/LogInfoTest.java b/ethereumj-core/src/test/java/org/ethereum/core/LogInfoTest.java
new file mode 100644
index 00000000..6884ea90
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/core/LogInfoTest.java
@@ -0,0 +1,70 @@
+package org.ethereum.core;
+
+import org.ethereum.vm.LogInfo;
+
+import org.junit.Test;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.spongycastle.util.encoders.Hex;
+
+import org.junit.Ignore;
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author Roman Mandeleil
+ * @since 05.12.2014
+ */
+public class LogInfoTest {
+
+ private static final Logger logger = LoggerFactory.getLogger("test");
+
+ @Test // rlp decode
+ public void test_1() {
+
+ // LogInfo{address=d5ccd26ba09ce1d85148b5081fa3ed77949417be, topics=[000000000000000000000000459d3a7595df9eba241365f4676803586d7d199c 436f696e73000000000000000000000000000000000000000000000000000000 ], data=}
+ byte[] rlp = Hex.decode("f85a94d5ccd26ba09ce1d85148b5081fa3ed77949417bef842a0000000000000000000000000459d3a7595df9eba241365f4676803586d7d199ca0436f696e7300000000000000000000000000000000000000000000000000000080");
+ LogInfo logInfo = new LogInfo(rlp);
+
+ assertEquals("d5ccd26ba09ce1d85148b5081fa3ed77949417be",
+ Hex.toHexString(logInfo.getAddress()));
+ assertEquals("", Hex.toHexString(logInfo.getData()));
+
+ assertEquals("000000000000000000000000459d3a7595df9eba241365f4676803586d7d199c",
+ logInfo.getTopics().get(0).toString());
+ assertEquals("436f696e73000000000000000000000000000000000000000000000000000000",
+ logInfo.getTopics().get(1).toString());
+
+ logger.info("{}", logInfo);
+ }
+
+ @Test // rlp decode
+ public void test_2() {
+
+ LogInfo log = new LogInfo(Hex.decode("d5ccd26ba09ce1d85148b5081fa3ed77949417be"), null, null);
+ assertEquals("d794d5ccd26ba09ce1d85148b5081fa3ed77949417bec080", Hex.toHexString(log.getEncoded()));
+
+ logger.info("{}", log);
+ }
+
+ @Ignore //TODO #POC9
+ @Test // rlp decode
+ public void test_3() {
+
+ // LogInfo{address=f2b1a404bcb6112a0ff2c4197cb02f3de40018b3, topics=[5a360139cff27713da0fe18a2100048a7ce1b7700c953a82bc3ff011437c8c2a 588d7ddcc06c14843ea68e690dfd4ec91ba09a8ada15c5b7fa6fead9c8befe4b ], data=}
+ byte[] rlp = Hex.decode("f85a94f2b1a404bcb6112a0ff2c4197cb02f3de40018b3f842a05a360139cff27713da0fe18a2100048a7ce1b7700c953a82bc3ff011437c8c2aa0588d7ddcc06c14843ea68e690dfd4ec91ba09a8ada15c5b7fa6fead9c8befe4b80");
+ LogInfo logInfo = new LogInfo(rlp);
+
+ assertEquals("f2b1a404bcb6112a0ff2c4197cb02f3de40018b3",
+ Hex.toHexString(logInfo.getAddress()));
+
+ assertEquals("00800000000000000010000000000000000000000000002000000000000000000012000000100000000050000020000000000000000000000000000000000000",
+ logInfo.getBloom().toString());
+
+ assertEquals("f85a94f2b1a404bcb6112a0ff2c4197cb02f3de40018b3f842a05a360139cff27713da0fe18a2100048a7ce1b7700c953a82bc3ff011437c8c2aa0588d7ddcc06c14843ea68e690dfd4ec91ba09a8ada15c5b7fa6fead9c8befe4b80",
+ Hex.toHexString(logInfo.getEncoded()));
+
+ logger.info("{}", logInfo);
+ }
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/core/StateTest.java b/ethereumj-core/src/test/java/org/ethereum/core/StateTest.java
new file mode 100644
index 00000000..de5db4db
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/core/StateTest.java
@@ -0,0 +1,126 @@
+package org.ethereum.core;
+
+
+import org.ethereum.crypto.HashUtil;
+import org.ethereum.datasource.HashMapDB;
+import org.ethereum.db.ByteArrayWrapper;
+import org.ethereum.trie.Trie;
+import org.ethereum.trie.TrieImpl;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.spongycastle.util.encoders.Hex;
+
+import java.math.BigInteger;
+
+import static org.junit.Assert.assertEquals;
+
+
+public class StateTest {
+
+ private static final String GENESIS_STATE_ROOT = "7e204dc9cfb7acdf062ff0b8052f7fcb0b7e6593754773967932ce458d134af3";
+
+ private static final Logger logger = LoggerFactory.getLogger("test");
+
+
+ @Ignore //TODO #POC9
+ @Test
+ public void testGenesisAccounts() {
+ Trie trie = generateGenesisState();
+ assertEquals(GENESIS_STATE_ROOT, Hex.toHexString(trie.getRootHash()));
+ }
+
+
+ @Ignore
+ @Test // calc state after applying first tx on genesis
+ public void test2() {
+
+ // explanation:
+ // 0) create genesis
+ // 1) apply cost of tx to cd2a3d9f938e13cd947ec05abc7fe734df8dd826
+ // 2) create AccountState for 77045e71a7a2c50903d88e564cd72fab11e82051
+ // 3) minner gets the gas + coinbase ==> 6260000000000000 + 1500000000000000000
+ // 4) calc the root
+
+ Trie trie = generateGenesisState();
+ String expected = "c12b4d771fbcc0d56ec106f8d465d24b9d4c36d60275bbafa7d69694d6708660";
+
+ // Get and update sender in world state
+ byte[] cowAddress = Hex.decode("cd2a3d9f938e13cd947ec05abc7fe734df8dd826");
+ byte[] rlpEncodedState = trie.get(cowAddress);
+ AccountState account_1 = new AccountState(rlpEncodedState);
+ account_1.addToBalance(new BigInteger("-6260000000001000"));
+ account_1.incrementNonce();
+ trie.update(cowAddress, account_1.getEncoded());
+
+ // Add contract to world state
+ byte[] codeData = Hex.decode("61778e600054");
+ AccountState account_2 = new AccountState(BigInteger.ZERO, BigInteger.valueOf(1000));
+ account_2.setCodeHash(HashUtil.sha3(codeData));
+ byte[] contractAddress = Hex.decode("77045e71a7a2c50903d88e564cd72fab11e82051"); // generated based on sender + nonce
+ trie.update(contractAddress, account_2.getEncoded());
+
+// this is saved in the db
+// trie.update(HashUtil.sha3(codeData), codeData);
+
+ // Update miner in world state
+ byte[] minerAddress = Hex.decode("4c5f4d519dff3c16f0d54b6866e256fbbbc1a600");
+ AccountState account_3 = new AccountState(BigInteger.ZERO, new BigInteger("1506260000000000000"));
+ trie.update(minerAddress, account_3.getEncoded());
+
+ assertEquals(expected, Hex.toHexString(trie.getRootHash()));
+
+
+ /* *** GROSS DATA ***
+
+ BlockData [
+ hash=22cf863ab836a6f5c29389d2e77f4792a3b3b52908c98ed14b1cbe91491a3e36
+ parentHash=77ef4fdaf389dca53236bcf7f72698e154eab2828f86fbc4fc6cd9225d285c89
+ unclesHash=1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347
+ coinbase=4c5f4d519dff3c16f0d54b6866e256fbbbc1a600
+ stateHash=69c21ff84a5af0b53b11c61110a16d6ad43dad37b3eb29ae8e88c936eb06456a
+ txTrieHash=a77691cf47bec9021d3f027fc8ef2d51b758b600a79967154354b8e37108896f
+ difficulty=3ff000
+ number=1
+ minGasPrice=10000000000000
+ gasLimit=999023
+ gasUsed=626
+ timestamp=1401979976 (2014.06.05 15:52:56)
+ extraData=null
+ nonce=0000000000000000000000000000000000000000000000005d439960040e4505
+
+ TransactionReceipt[
+ TransactionData [ hash=1ee6fa3149a5e9c09b54009eb6e108aaa7ecd79483d57eedcf2dff93a1505588 nonce=null,
+ gasPrice=09184e72a000, gas=03e8, receiveAddress=0000000000000000000000000000000000000000, value=03e8,
+ data=60016000546006601160003960066000f261778e600054, signatureV=27,
+ signatureR=2b379f22050e3554c3fa5423d9040bb28dcc7f905300db4e67c03bcf9b27003c,
+ signatureS=59f47793e050974e6b5fca2848b19925637b883a012693b54d712f1c4f74def5
+ ]
+ , postTxState=7fa5bd00f6e03b5a5718560f1e25179b227167585a3c3da06a48f554365fb527
+ , cumulativeGas=0272]
+ ]
+
+ +++ 4c5f4d519dff3c16f0d54b6866e256fbbbc1a600:
+ +++ 77045e71a7a2c50903d88e564cd72fab11e82051: $[61,77,8e,60,0,54] ([])
+ * cd2a3d9f938e13cd947ec05abc7fe734df8dd826: #1 1606938044258990275541962092341162602522202987522792835300376 (-6260000000001000)
+ */
+
+ assertEquals(expected, Hex.toHexString(trie.getRootHash()));
+ }
+
+ private Trie generateGenesisState() {
+
+ Trie trie = new TrieImpl(new HashMapDB());
+ Genesis genesis = (Genesis)Genesis.getInstance();
+ for (ByteArrayWrapper key : genesis.getPremine().keySet()) {
+ trie.update(key.getData(), genesis.getPremine().get(key).getEncoded());
+ }
+
+ return trie;
+ }
+}
+
diff --git a/ethereumj-core/src/test/java/org/ethereum/core/TransactionReceiptTest.java b/ethereumj-core/src/test/java/org/ethereum/core/TransactionReceiptTest.java
new file mode 100644
index 00000000..a7e72e5d
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/core/TransactionReceiptTest.java
@@ -0,0 +1,41 @@
+package org.ethereum.core;
+
+import org.junit.Test;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.spongycastle.util.encoders.Hex;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author Roman Mandeleil
+ * @since 05.12.2014
+ */
+public class TransactionReceiptTest {
+
+ private static final Logger logger = LoggerFactory.getLogger("test");
+
+
+ @Test // rlp decode
+ public void test_1() {
+
+ byte[] rlp = Hex.decode("f8c4a0966265cc49fa1f10f0445f035258d116563931022a3570a640af5d73a214a8da822b6fb84000000010000000010000000000008000000000000000000000000000000000000000000000000000000000020000000000000014000000000400000000000440f85cf85a94d5ccd26ba09ce1d85148b5081fa3ed77949417bef842a0000000000000000000000000459d3a7595df9eba241365f4676803586d7d199ca0436f696e7300000000000000000000000000000000000000000000000000000080");
+ TransactionReceipt txReceipt = new TransactionReceipt(rlp);
+
+ assertEquals(1, txReceipt.getLogInfoList().size());
+
+ assertEquals("966265cc49fa1f10f0445f035258d116563931022a3570a640af5d73a214a8da",
+ Hex.toHexString(txReceipt.getPostTxState()));
+
+ assertEquals("2b6f",
+ Hex.toHexString(txReceipt.getCumulativeGas()));
+
+ assertEquals("00000010000000010000000000008000000000000000000000000000000000000000000000000000000000020000000000000014000000000400000000000440",
+ Hex.toHexString(txReceipt.getBloomFilter().getData()));
+
+ logger.info("{}", txReceipt);
+ }
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/core/TransactionTest.java b/ethereumj-core/src/test/java/org/ethereum/core/TransactionTest.java
new file mode 100644
index 00000000..eee557fe
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/core/TransactionTest.java
@@ -0,0 +1,304 @@
+package org.ethereum.core;
+
+import org.ethereum.crypto.ECKey;
+import org.ethereum.crypto.ECKey.MissingPrivateKeyException;
+import org.ethereum.crypto.HashUtil;
+import org.ethereum.vm.LogInfo;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import org.spongycastle.util.BigIntegers;
+import org.spongycastle.util.encoders.Hex;
+
+import java.io.IOException;
+
+import java.math.BigInteger;
+
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.security.NoSuchProviderException;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+@Ignore
+public class TransactionTest {
+
+
+ @Test /* sign transaction https://tools.ietf.org/html/rfc6979 */
+ public void test1() throws NoSuchProviderException, NoSuchAlgorithmException, InvalidKeyException, IOException {
+
+ //python taken exact data
+ String txRLPRawData = "a9e880872386f26fc1000085e8d4a510008203e89413978aee95f38490e9769c39b2773ed763d9cd5f80";
+ // String txRLPRawData = "f82804881bc16d674ec8000094cd2a3d9f938e13cd947ec05abc7fe734df8dd8268609184e72a0006480";
+
+ byte[] cowPrivKey = Hex.decode("c85ef7d79691fe79573b1a7064c19c1a9819ebdbd1faaab1a8ec92344438aaf4");
+ ECKey key = ECKey.fromPrivate(cowPrivKey);
+
+ byte[] data = Hex.decode(txRLPRawData);
+
+ // step 1: serialize + RLP encode
+ // step 2: hash = sha3(step1)
+ byte[] txHash = HashUtil.sha3(data);
+
+ String signature = key.doSign(txHash).toBase64();
+ System.out.println(signature);
+ }
+
+ @Test /* achieve public key of the sender */
+ public void test2() throws Exception {
+
+ // cat --> 79b08ad8787060333663d19704909ee7b1903e58
+ // cow --> cd2a3d9f938e13cd947ec05abc7fe734df8dd826
+
+ BigInteger value = new BigInteger("1000000000000000000000");
+
+ byte[] privKey = HashUtil.sha3("cat".getBytes());
+ ECKey ecKey = ECKey.fromPrivate(privKey);
+
+ byte[] senderPrivKey = HashUtil.sha3("cow".getBytes());
+
+ byte[] gasPrice = Hex.decode("09184e72a000");
+ byte[] gas = Hex.decode("4255");
+
+ // Tn (nonce); Tp(pgas); Tg(gaslimi); Tt(value); Tv(value); Ti(sender); Tw; Tr; Ts
+ Transaction tx = new Transaction(null, gasPrice, gas, ecKey.getAddress(),
+ value.toByteArray(),
+ null);
+
+ tx.sign(senderPrivKey);
+
+ System.out.println("v\t\t\t: " + Hex.toHexString(new byte[]{tx.getSignature().v}));
+ System.out.println("r\t\t\t: " + Hex.toHexString(BigIntegers.asUnsignedByteArray(tx.getSignature().r)));
+ System.out.println("s\t\t\t: " + Hex.toHexString(BigIntegers.asUnsignedByteArray(tx.getSignature().s)));
+
+ System.out.println("RLP encoded tx\t\t: " + Hex.toHexString(tx.getEncoded()));
+
+ // retrieve the signer/sender of the transaction
+ ECKey key = ECKey.signatureToKey(tx.getHash(), tx.getSignature().toBase64());
+
+ System.out.println("Tx unsigned RLP\t\t: " + Hex.toHexString(tx.getEncodedRaw()));
+ System.out.println("Tx signed RLP\t\t: " + Hex.toHexString(tx.getEncoded()));
+
+ System.out.println("Signature public key\t: " + Hex.toHexString(key.getPubKey()));
+ System.out.println("Sender is\t\t: " + Hex.toHexString(key.getAddress()));
+
+ assertEquals("cd2a3d9f938e13cd947ec05abc7fe734df8dd826",
+ Hex.toHexString(key.getAddress()));
+
+ System.out.println(tx.toString());
+ }
+
+
+ @Test /* achieve public key of the sender nonce: 01 */
+ public void test3() throws Exception {
+
+ // cat --> 79b08ad8787060333663d19704909ee7b1903e58
+ // cow --> cd2a3d9f938e13cd947ec05abc7fe734df8dd826
+
+ ECKey ecKey = ECKey.fromPrivate(HashUtil.sha3("cat".getBytes()));
+ byte[] senderPrivKey = HashUtil.sha3("cow".getBytes());
+
+ byte[] nonce = {0x01};
+ byte[] gasPrice = Hex.decode("09184e72a000");
+ byte[] gasLimit = Hex.decode("4255");
+ BigInteger value = new BigInteger("1000000000000000000000000");
+
+ Transaction tx = new Transaction(nonce, gasPrice, gasLimit,
+ ecKey.getAddress(), value.toByteArray(), null);
+
+ tx.sign(senderPrivKey);
+
+ System.out.println("v\t\t\t: " + Hex.toHexString(new byte[]{tx.getSignature().v}));
+ System.out.println("r\t\t\t: " + Hex.toHexString(BigIntegers.asUnsignedByteArray(tx.getSignature().r)));
+ System.out.println("s\t\t\t: " + Hex.toHexString(BigIntegers.asUnsignedByteArray(tx.getSignature().s)));
+
+ System.out.println("RLP encoded tx\t\t: " + Hex.toHexString(tx.getEncoded()));
+
+ // retrieve the signer/sender of the transaction
+ ECKey key = ECKey.signatureToKey(tx.getHash(), tx.getSignature().toBase64());
+
+ System.out.println("Tx unsigned RLP\t\t: " + Hex.toHexString(tx.getEncodedRaw()));
+ System.out.println("Tx signed RLP\t\t: " + Hex.toHexString(tx.getEncoded()));
+
+ System.out.println("Signature public key\t: " + Hex.toHexString(key.getPubKey()));
+ System.out.println("Sender is\t\t: " + Hex.toHexString(key.getAddress()));
+
+ assertEquals("cd2a3d9f938e13cd947ec05abc7fe734df8dd826",
+ Hex.toHexString(key.getAddress()));
+ }
+
+ // Testdata from: https://github.com/ethereum/tests/blob/master/txtest.json
+ String RLP_ENCODED_RAW_TX = "e88085e8d4a510008227109413978aee95f38490e9769c39b2773ed763d9cd5f872386f26fc1000080";
+ String RLP_ENCODED_UNSIGNED_TX = "eb8085e8d4a510008227109413978aee95f38490e9769c39b2773ed763d9cd5f872386f26fc1000080808080";
+ String HASH_TX = "328ea6d24659dec48adea1aced9a136e5ebdf40258db30d1b1d97ed2b74be34e";
+ String RLP_ENCODED_SIGNED_TX = "f86b8085e8d4a510008227109413978aee95f38490e9769c39b2773ed763d9cd5f872386f26fc10000801ba0eab47c1a49bf2fe5d40e01d313900e19ca485867d462fe06e139e3a536c6d4f4a014a569d327dcda4b29f74f93c0e9729d2f49ad726e703f9cd90dbb0fbf6649f1";
+ String KEY = "c85ef7d79691fe79573b1a7064c19c1a9819ebdbd1faaab1a8ec92344438aaf4";
+ byte[] testNonce = Hex.decode("");
+ byte[] testGasPrice = BigIntegers.asUnsignedByteArray(BigInteger.valueOf(1000000000000L));
+ byte[] testGasLimit = BigIntegers.asUnsignedByteArray(BigInteger.valueOf(10000));
+ byte[] testReceiveAddress = Hex.decode("13978aee95f38490e9769c39b2773ed763d9cd5f");
+ byte[] testValue = BigIntegers.asUnsignedByteArray(BigInteger.valueOf(10000000000000000L));
+ byte[] testData = Hex.decode("");
+ byte[] testInit = Hex.decode("");
+
+ @Test
+ public void testTransactionFromSignedRLP() throws Exception {
+ Transaction txSigned = new Transaction(Hex.decode(RLP_ENCODED_SIGNED_TX));
+
+ assertEquals(HASH_TX, Hex.toHexString(txSigned.getHash()));
+ assertEquals(RLP_ENCODED_SIGNED_TX, Hex.toHexString(txSigned.getEncoded()));
+
+ assertEquals(BigInteger.ZERO, new BigInteger(1, txSigned.getNonce()));
+ assertEquals(new BigInteger(1, testGasPrice), new BigInteger(1, txSigned.getGasPrice()));
+ assertEquals(new BigInteger(1, testGasLimit), new BigInteger(1, txSigned.getGasLimit()));
+ assertEquals(Hex.toHexString(testReceiveAddress), Hex.toHexString(txSigned.getReceiveAddress()));
+ assertEquals(new BigInteger(1, testValue), new BigInteger(1, txSigned.getValue()));
+ assertNull(txSigned.getData());
+ assertEquals(27, txSigned.getSignature().v);
+ assertEquals("eab47c1a49bf2fe5d40e01d313900e19ca485867d462fe06e139e3a536c6d4f4", Hex.toHexString(BigIntegers.asUnsignedByteArray(txSigned.getSignature().r)));
+ assertEquals("14a569d327dcda4b29f74f93c0e9729d2f49ad726e703f9cd90dbb0fbf6649f1", Hex.toHexString(BigIntegers.asUnsignedByteArray(txSigned.getSignature().s)));
+ }
+
+ @Test
+ public void testTransactionFromUnsignedRLP() throws Exception {
+ Transaction txUnsigned = new Transaction(Hex.decode(RLP_ENCODED_UNSIGNED_TX));
+
+ assertEquals(HASH_TX, Hex.toHexString(txUnsigned.getHash()));
+ assertEquals(RLP_ENCODED_UNSIGNED_TX, Hex.toHexString(txUnsigned.getEncoded()));
+ txUnsigned.sign(Hex.decode(KEY));
+ assertEquals(RLP_ENCODED_SIGNED_TX, Hex.toHexString(txUnsigned.getEncoded()));
+
+ assertEquals(BigInteger.ZERO, new BigInteger(1, txUnsigned.getNonce()));
+ assertEquals(new BigInteger(1, testGasPrice), new BigInteger(1, txUnsigned.getGasPrice()));
+ assertEquals(new BigInteger(1, testGasLimit), new BigInteger(1, txUnsigned.getGasLimit()));
+ assertEquals(Hex.toHexString(testReceiveAddress), Hex.toHexString(txUnsigned.getReceiveAddress()));
+ assertEquals(new BigInteger(1, testValue), new BigInteger(1, txUnsigned.getValue()));
+ assertNull(txUnsigned.getData());
+ assertEquals(27, txUnsigned.getSignature().v);
+ assertEquals("eab47c1a49bf2fe5d40e01d313900e19ca485867d462fe06e139e3a536c6d4f4", Hex.toHexString(BigIntegers.asUnsignedByteArray(txUnsigned.getSignature().r)));
+ assertEquals("14a569d327dcda4b29f74f93c0e9729d2f49ad726e703f9cd90dbb0fbf6649f1", Hex.toHexString(BigIntegers.asUnsignedByteArray(txUnsigned.getSignature().s)));
+ }
+
+ @Test
+ public void testTransactionFromNew1() throws MissingPrivateKeyException {
+ Transaction txNew = new Transaction(testNonce, testGasPrice, testGasLimit, testReceiveAddress, testValue, testData);
+
+ assertEquals("", Hex.toHexString(txNew.getNonce()));
+ assertEquals(new BigInteger(1, testGasPrice), new BigInteger(1, txNew.getGasPrice()));
+ assertEquals(new BigInteger(1, testGasLimit), new BigInteger(1, txNew.getGasLimit()));
+ assertEquals(Hex.toHexString(testReceiveAddress), Hex.toHexString(txNew.getReceiveAddress()));
+ assertEquals(new BigInteger(1, testValue), new BigInteger(1, txNew.getValue()));
+ assertEquals("", Hex.toHexString(txNew.getData()));
+ assertNull(txNew.getSignature());
+
+ assertEquals(RLP_ENCODED_RAW_TX, Hex.toHexString(txNew.getEncodedRaw()));
+ assertEquals(HASH_TX, Hex.toHexString(txNew.getHash()));
+ assertEquals(RLP_ENCODED_UNSIGNED_TX, Hex.toHexString(txNew.getEncoded()));
+ txNew.sign(Hex.decode(KEY));
+ assertEquals(RLP_ENCODED_SIGNED_TX, Hex.toHexString(txNew.getEncoded()));
+
+ assertEquals(27, txNew.getSignature().v);
+ assertEquals("eab47c1a49bf2fe5d40e01d313900e19ca485867d462fe06e139e3a536c6d4f4", Hex.toHexString(BigIntegers.asUnsignedByteArray(txNew.getSignature().r)));
+ assertEquals("14a569d327dcda4b29f74f93c0e9729d2f49ad726e703f9cd90dbb0fbf6649f1", Hex.toHexString(BigIntegers.asUnsignedByteArray(txNew.getSignature().s)));
+ }
+
+ @Test
+ public void testTransactionFromNew2() throws MissingPrivateKeyException {
+ byte[] privKeyBytes = Hex.decode("c85ef7d79691fe79573b1a7064c19c1a9819ebdbd1faaab1a8ec92344438aaf4");
+
+ String RLP_TX_UNSIGNED = "eb8085e8d4a510008227109413978aee95f38490e9769c39b2773ed763d9cd5f872386f26fc1000080808080";
+ String RLP_TX_SIGNED = "f86b8085e8d4a510008227109413978aee95f38490e9769c39b2773ed763d9cd5f872386f26fc10000801ba0eab47c1a49bf2fe5d40e01d313900e19ca485867d462fe06e139e3a536c6d4f4a014a569d327dcda4b29f74f93c0e9729d2f49ad726e703f9cd90dbb0fbf6649f1";
+ String HASH_TX_UNSIGNED = "328ea6d24659dec48adea1aced9a136e5ebdf40258db30d1b1d97ed2b74be34e";
+
+ byte[] nonce = BigIntegers.asUnsignedByteArray(BigInteger.ZERO);
+ byte[] gasPrice = Hex.decode("e8d4a51000"); // 1000000000000
+ byte[] gas = Hex.decode("2710"); // 10000
+ byte[] recieveAddress = Hex.decode("13978aee95f38490e9769c39b2773ed763d9cd5f");
+ byte[] value = Hex.decode("2386f26fc10000"); //10000000000000000"
+ byte[] data = new byte[0];
+
+ Transaction tx = new Transaction(nonce, gasPrice, gas, recieveAddress, value, data);
+
+ // Testing unsigned
+ String encodedUnsigned = Hex.toHexString(tx.getEncoded());
+ assertEquals(RLP_TX_UNSIGNED, encodedUnsigned);
+ assertEquals(HASH_TX_UNSIGNED, Hex.toHexString(tx.getHash()));
+
+ // Testing signed
+ tx.sign(privKeyBytes);
+ String encodedSigned = Hex.toHexString(tx.getEncoded());
+ assertEquals(RLP_TX_SIGNED, encodedSigned);
+ assertEquals(HASH_TX_UNSIGNED, Hex.toHexString(tx.getHash()));
+ }
+
+ @Test
+ public void testTransactionCreateContract() {
+
+// String rlp =
+// "f89f808609184e72a0008203e8808203e8b84b4560005444602054600f60056002600a02010b0d630000001d596002602054630000003b5860066000530860056006600202010a0d6300000036596004604054630000003b5860056060541ca0ddc901d83110ea50bc40803f42083afea1bbd420548f6392a679af8e24b21345a06620b3b512bea5f0a272703e8d6933177c23afc79516fd0ca4a204aa6e34c7e9";
+
+ byte[] senderPrivKey = HashUtil.sha3("cow".getBytes());
+
+ byte[] nonce = BigIntegers.asUnsignedByteArray(BigInteger.ZERO);
+ byte[] gasPrice = Hex.decode("09184e72a000"); // 10000000000000
+ byte[] gas = Hex.decode("03e8"); // 1000
+ byte[] recieveAddress = null;
+ byte[] endowment = Hex.decode("03e8"); //10000000000000000"
+ byte[] init = Hex.decode
+ ("4560005444602054600f60056002600a02010b0d630000001d596002602054630000003b5860066000530860056006600202010a0d6300000036596004604054630000003b586005606054");
+
+
+ Transaction tx1 = new Transaction(nonce, gasPrice, gas,
+ recieveAddress, endowment, init);
+ tx1.sign(senderPrivKey);
+
+ byte[] payload = tx1.getEncoded();
+
+
+ System.out.println(Hex.toHexString(payload));
+ Transaction tx2 = new Transaction(payload);
+// tx2.getSender();
+
+ String plainTx1 = Hex.toHexString(tx1.getEncodedRaw());
+ String plainTx2 = Hex.toHexString(tx2.getEncodedRaw());
+
+// Transaction tx = new Transaction(Hex.decode(rlp));
+
+ System.out.println("tx1.hash: " + Hex.toHexString(tx1.getHash()));
+ System.out.println("tx2.hash: " + Hex.toHexString(tx2.getHash()));
+ System.out.println();
+ System.out.println("plainTx1: " + plainTx1);
+ System.out.println("plainTx2: " + plainTx2);
+
+ System.out.println(Hex.toHexString(tx2.getSender()));
+ }
+
+
+ @Test
+ public void encodeReceiptTest() {
+
+ String data = "f90244a0f5ff3fbd159773816a7c707a9b8cb6bb778b934a8f6466c7830ed970498f4b688301e848b902000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000dbda94cd2a3d9f938e13cd947ec05abc7fe734df8dd826c083a1a1a1";
+
+ byte[] stateRoot = Hex.decode("f5ff3fbd159773816a7c707a9b8cb6bb778b934a8f6466c7830ed970498f4b68");
+ byte[] gasUsed = Hex.decode("01E848");
+ Bloom bloom = new Bloom(Hex.decode("0000000000000000800000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
+
+ LogInfo logInfo1 = new LogInfo(
+ Hex.decode("cd2a3d9f938e13cd947ec05abc7fe734df8dd826"),
+ null,
+ Hex.decode("a1a1a1")
+ );
+
+ List logs = new ArrayList<>();
+ logs.add(logInfo1);
+
+ TransactionReceipt receipt = new TransactionReceipt(stateRoot, gasUsed, bloom, logs);
+
+ assertEquals(data,
+ Hex.toHexString(receipt.getEncoded()));
+ }
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/crypto/CryptoTest.java b/ethereumj-core/src/test/java/org/ethereum/crypto/CryptoTest.java
new file mode 100644
index 00000000..e0435664
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/crypto/CryptoTest.java
@@ -0,0 +1,352 @@
+package org.ethereum.crypto;
+
+import org.ethereum.util.Utils;
+
+import org.junit.Test;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spongycastle.crypto.AsymmetricCipherKeyPair;
+import org.spongycastle.crypto.BufferedBlockCipher;
+import org.spongycastle.crypto.KeyEncoder;
+import org.spongycastle.crypto.KeyGenerationParameters;
+import org.spongycastle.crypto.agreement.ECDHBasicAgreement;
+import org.spongycastle.crypto.digests.SHA256Digest;
+import org.spongycastle.crypto.engines.AESFastEngine;
+import org.spongycastle.crypto.engines.IESEngine;
+import org.spongycastle.crypto.generators.ECKeyPairGenerator;
+import org.spongycastle.crypto.generators.EphemeralKeyPairGenerator;
+import org.spongycastle.crypto.generators.KDF2BytesGenerator;
+import org.spongycastle.crypto.macs.HMac;
+import org.spongycastle.crypto.modes.SICBlockCipher;
+import org.spongycastle.crypto.params.*;
+import org.spongycastle.crypto.parsers.ECIESPublicKeyParser;
+import org.spongycastle.util.encoders.Hex;
+
+import java.math.BigInteger;
+import java.security.SecureRandom;
+
+import static org.ethereum.crypto.HashUtil.sha3;
+import static org.junit.Assert.assertEquals;
+
+public class CryptoTest {
+
+ private static final Logger log = LoggerFactory.getLogger("test");
+
+
+ @Test
+ public void test1() {
+
+ byte[] result = HashUtil.sha3("horse".getBytes());
+
+ assertEquals("c87f65ff3f271bf5dc8643484f66b200109caffe4bf98c4cb393dc35740b28c0",
+ Hex.toHexString(result));
+
+ result = HashUtil.sha3("cow".getBytes());
+
+ assertEquals("c85ef7d79691fe79573b1a7064c19c1a9819ebdbd1faaab1a8ec92344438aaf4",
+ Hex.toHexString(result));
+ }
+
+ @Test
+ public void test3() {
+ BigInteger privKey = new BigInteger("cd244b3015703ddf545595da06ada5516628c5feadbf49dc66049c4b370cc5d8", 16);
+ byte[] addr = ECKey.fromPrivate(privKey).getAddress();
+ assertEquals("89b44e4d3c81ede05d0f5de8d1a68f754d73d997", Hex.toHexString(addr));
+ }
+
+
+ @Test
+ public void test4() {
+ byte[] cowBytes = HashUtil.sha3("cow".getBytes());
+ byte[] addr = ECKey.fromPrivate(cowBytes).getAddress();
+ assertEquals("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826", Hex.toHexString(addr).toUpperCase());
+ }
+
+ @Test
+ public void test5() {
+ byte[] horseBytes = HashUtil.sha3("horse".getBytes());
+ byte[] addr = ECKey.fromPrivate(horseBytes).getAddress();
+ assertEquals("13978AEE95F38490E9769C39B2773ED763D9CD5F", Hex.toHexString(addr).toUpperCase());
+ }
+
+ @Test /* performance test */
+ public void test6() {
+
+ long firstTime = System.currentTimeMillis();
+ System.out.println(firstTime);
+ for (int i = 0; i < 1000; ++i) {
+
+ byte[] horseBytes = HashUtil.sha3("horse".getBytes());
+ byte[] addr = ECKey.fromPrivate(horseBytes).getAddress();
+ assertEquals("13978AEE95F38490E9769C39B2773ED763D9CD5F", Hex.toHexString(addr).toUpperCase());
+ }
+ long secondTime = System.currentTimeMillis();
+ System.out.println(secondTime);
+ System.out.println(secondTime - firstTime + " millisec");
+ // 1) result: ~52 address calculation every second
+ }
+
+ @Test /* real tx hash calc */
+ public void test7() {
+
+ String txRaw = "F89D80809400000000000000000000000000000000000000008609184E72A000822710B3606956330C0D630000003359366000530A0D630000003359602060005301356000533557604060005301600054630000000C5884336069571CA07F6EB94576346488C6253197BDE6A7E59DDC36F2773672C849402AA9C402C3C4A06D254E662BF7450DD8D835160CBB053463FED0B53F2CDD7F3EA8731919C8E8CC";
+ byte[] txHashB = HashUtil.sha3(Hex.decode(txRaw));
+ String txHash = Hex.toHexString(txHashB);
+ assertEquals("4b7d9670a92bf120d5b43400543b69304a14d767cf836a7f6abff4edde092895", txHash);
+ }
+
+ @Test /* real block hash calc */
+ public void test8() {
+
+ String blockRaw = "F885F8818080A01DCC4DE8DEC75D7AAB85B567B6CCD41AD312451B948A7413F0A142FD40D49347940000000000000000000000000000000000000000A0BCDDD284BF396739C224DBA0411566C891C32115FEB998A3E2B4E61F3F35582AA01DCC4DE8DEC75D7AAB85B567B6CCD41AD312451B948A7413F0A142FD40D4934783800000808080C0C0";
+
+ byte[] blockHashB = HashUtil.sha3(Hex.decode(blockRaw));
+ String blockHash = Hex.toHexString(blockHashB);
+ System.out.println(blockHash);
+ }
+
+ @Test
+ public void test9() {
+ // TODO: https://tools.ietf.org/html/rfc6979#section-2.2
+ // TODO: https://github.com/bcgit/bc-java/blob/master/core/src/main/java/org/bouncycastle/crypto/signers/ECDSASigner.java
+
+ System.out.println(new BigInteger(Hex.decode("3913517ebd3c0c65000000")));
+ System.out.println(Utils.getValueShortString(new BigInteger("69000000000000000000000000")));
+ }
+
+ @Test
+ public void test10() {
+ BigInteger privKey = new BigInteger("74ef8a796480dda87b4bc550b94c408ad386af0f65926a392136286784d63858", 16);
+ byte[] addr = ECKey.fromPrivate(privKey).getAddress();
+ assertEquals("ba73facb4f8291f09f27f90fe1213537b910065e", Hex.toHexString(addr));
+ }
+
+
+ @Test // basic encryption/decryption
+ public void test11() throws Throwable {
+
+ byte[] keyBytes = sha3("...".getBytes());
+ log.info("key: {}", Hex.toHexString(keyBytes));
+ byte[] ivBytes = new byte[16];
+ byte[] payload = Hex.decode("22400891000000000000000000000000");
+
+ KeyParameter key = new KeyParameter(keyBytes);
+ ParametersWithIV params = new ParametersWithIV(key, new byte[16]);
+
+ AESFastEngine engine = new AESFastEngine();
+ SICBlockCipher ctrEngine = new SICBlockCipher(engine);
+
+ ctrEngine.init(true, params);
+
+ byte[] cipher = new byte[16];
+ ctrEngine.processBlock(payload, 0, cipher, 0);
+
+ log.info("cipher: {}", Hex.toHexString(cipher));
+
+
+ byte[] output = new byte[cipher.length];
+ ctrEngine.init(false, params);
+ ctrEngine.processBlock(cipher, 0, output, 0);
+
+ assertEquals(Hex.toHexString(output), Hex.toHexString(payload));
+ log.info("original: {}", Hex.toHexString(payload));
+ }
+
+ @Test // big packet encryption
+ public void test12() throws Throwable {
+
+ AESFastEngine engine = new AESFastEngine();
+ SICBlockCipher ctrEngine = new SICBlockCipher(engine);
+
+ byte[] keyBytes = Hex.decode("a4627abc2a3c25315bff732cb22bc128f203912dd2a840f31e66efb27a47d2b1");
+ byte[] ivBytes = new byte[16];
+ byte[] payload = Hex.decode("0109efc76519b683d543db9d0991bcde99cc9a3d14b1d0ecb8e9f1f66f31558593d746eaa112891b04ef7126e1dce17c9ac92ebf39e010f0028b8ec699f56f5d0c0d00");
+ byte[] cipherText = Hex.decode("f9fab4e9dd9fc3e5d0d0d16da254a2ac24df81c076e3214e2c57da80a46e6ae4752f4b547889fa692b0997d74f36bb7c047100ba71045cb72cfafcc7f9a251762cdf8f");
+
+ KeyParameter key = new KeyParameter(keyBytes);
+ ParametersWithIV params = new ParametersWithIV(key, ivBytes);
+
+ ctrEngine.init(true, params);
+
+ byte[] in = payload;
+ byte[] out = new byte[in.length];
+
+ int i = 0;
+
+ while(i < in.length){
+ ctrEngine.processBlock(in, i, out, i);
+ i += engine.getBlockSize();
+ if (in.length - i < engine.getBlockSize())
+ break;
+ }
+
+ // process left bytes
+ if (in.length - i > 0){
+ byte[] tmpBlock = new byte[16];
+ System.arraycopy(in, i, tmpBlock, 0, in.length - i);
+ ctrEngine.processBlock(tmpBlock, 0, tmpBlock, 0);
+ System.arraycopy(tmpBlock, 0, out, i, in.length - i);
+ }
+
+ log.info("cipher: {}", Hex.toHexString(out));
+
+ assertEquals(Hex.toHexString(cipherText), Hex.toHexString(out));
+ }
+
+ @Test // cpp keys demystified
+ public void test13() throws Throwable {
+
+// us.secret() a4627abc2a3c25315bff732cb22bc128f203912dd2a840f31e66efb27a47d2b1
+// us.public() caa3d5086b31529bb00207eabf244a0a6c54d807d2ac0ec1f3b1bdde0dbf8130c115b1eaf62ce0f8062bcf70c0fefbc97cec79e7faffcc844a149a17fcd7bada
+// us.address() 47d8cb63a7965d98b547b9f0333a654b60ffa190
+
+
+ ECKey key = ECKey.fromPrivate(Hex.decode("a4627abc2a3c25315bff732cb22bc128f203912dd2a840f31e66efb27a47d2b1"));
+
+ String address = Hex.toHexString(key.getAddress());
+ String pubkey = Hex.toHexString(key.getPubKeyPoint().getXCoord().getEncoded()) + // X cord
+ Hex.toHexString(key.getPubKeyPoint().getYCoord().getEncoded()); // Y cord
+
+ log.info("address: " + address);
+ log.info("pubkey: " + pubkey);
+
+ assertEquals("47d8cb63a7965d98b547b9f0333a654b60ffa190", address);
+ assertEquals("caa3d5086b31529bb00207eabf244a0a6c54d807d2ac0ec1f3b1bdde0dbf8130c115b1eaf62ce0f8062bcf70c0fefbc97cec79e7faffcc844a149a17fcd7bada", pubkey);
+ }
+
+
+
+ @Test // ECIES_AES128_SHA256 + No Ephemeral Key + IV(all zeroes)
+ public void test14() throws Throwable{
+
+ AESFastEngine aesFastEngine = new AESFastEngine();
+
+ IESEngine iesEngine = new IESEngine(
+ new ECDHBasicAgreement(),
+ new KDF2BytesGenerator(new SHA256Digest()),
+ new HMac(new SHA256Digest()),
+ new BufferedBlockCipher(new SICBlockCipher(aesFastEngine)));
+
+
+ byte[] d = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
+ byte[] e = new byte[] { 8, 7, 6, 5, 4, 3, 2, 1 };
+
+ IESParameters p = new IESWithCipherParameters(d, e, 64, 128);
+ ParametersWithIV parametersWithIV = new ParametersWithIV(p, new byte[16]);
+
+ ECKeyPairGenerator eGen = new ECKeyPairGenerator();
+ KeyGenerationParameters gParam = new ECKeyGenerationParameters(ECKey.CURVE, new SecureRandom());
+
+ eGen.init(gParam);
+
+
+ AsymmetricCipherKeyPair p1 = eGen.generateKeyPair();
+ AsymmetricCipherKeyPair p2 = eGen.generateKeyPair();
+
+
+ ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(ECKey.CURVE, new SecureRandom());
+ ECKeyPairGenerator generator = new ECKeyPairGenerator();
+ generator.init(keygenParams);
+
+ ECKeyPairGenerator gen = new ECKeyPairGenerator();
+ gen.init(new ECKeyGenerationParameters(ECKey.CURVE, new SecureRandom()));
+
+ iesEngine.init(true, p1.getPrivate(), p2.getPublic(), parametersWithIV);
+
+ byte[] message = Hex.decode("010101");
+ log.info("payload: {}", Hex.toHexString(message));
+
+
+ byte[] cipher = iesEngine.processBlock(message, 0, message.length);
+ log.info("cipher: {}", Hex.toHexString(cipher));
+
+
+ IESEngine decryptorIES_Engine = new IESEngine(
+ new ECDHBasicAgreement(),
+ new KDF2BytesGenerator (new SHA256Digest()),
+ new HMac(new SHA256Digest()),
+ new BufferedBlockCipher(new SICBlockCipher(aesFastEngine)));
+
+ decryptorIES_Engine.init(false, p2.getPrivate(), p1.getPublic(), parametersWithIV);
+
+ byte[] orig = decryptorIES_Engine.processBlock(cipher, 0, cipher.length);
+
+ log.info("orig: " + Hex.toHexString(orig));
+ }
+
+
+ @Test // ECIES_AES128_SHA256 + Ephemeral Key + IV(all zeroes)
+ public void test15() throws Throwable{
+
+
+ byte[] privKey = Hex.decode("a4627abc2a3c25315bff732cb22bc128f203912dd2a840f31e66efb27a47d2b1");
+
+ ECKey ecKey = ECKey.fromPrivate(privKey);
+
+ ECPrivateKeyParameters ecPrivKey = new ECPrivateKeyParameters(ecKey.getPrivKey(), ECKey.CURVE);
+ ECPublicKeyParameters ecPubKey = new ECPublicKeyParameters(ecKey.getPubKeyPoint(), ECKey.CURVE);
+
+ AsymmetricCipherKeyPair myKey = new AsymmetricCipherKeyPair(ecPubKey, ecPrivKey);
+
+
+ AESFastEngine aesFastEngine = new AESFastEngine();
+
+ IESEngine iesEngine = new IESEngine(
+ new ECDHBasicAgreement(),
+ new KDF2BytesGenerator(new SHA256Digest()),
+ new HMac(new SHA256Digest()),
+ new BufferedBlockCipher(new SICBlockCipher(aesFastEngine)));
+
+
+ byte[] d = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
+ byte[] e = new byte[] { 8, 7, 6, 5, 4, 3, 2, 1 };
+
+ IESParameters p = new IESWithCipherParameters(d, e, 64, 128);
+ ParametersWithIV parametersWithIV = new ParametersWithIV(p, new byte[16]);
+
+ ECKeyPairGenerator eGen = new ECKeyPairGenerator();
+ KeyGenerationParameters gParam = new ECKeyGenerationParameters(ECKey.CURVE, new SecureRandom());
+
+ eGen.init(gParam);
+
+ ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(ECKey.CURVE, new SecureRandom());
+ ECKeyPairGenerator generator = new ECKeyPairGenerator();
+ generator.init(keygenParams);
+
+ EphemeralKeyPairGenerator kGen = new EphemeralKeyPairGenerator(generator, new KeyEncoder()
+ {
+ public byte[] getEncoded(AsymmetricKeyParameter keyParameter)
+ {
+ return ((ECPublicKeyParameters)keyParameter).getQ().getEncoded();
+ }
+ });
+
+
+ ECKeyPairGenerator gen = new ECKeyPairGenerator();
+ gen.init(new ECKeyGenerationParameters(ECKey.CURVE, new SecureRandom()));
+
+ iesEngine.init(myKey.getPublic(), parametersWithIV, kGen);
+
+ byte[] message = Hex.decode("010101");
+ log.info("payload: {}", Hex.toHexString(message));
+
+
+ byte[] cipher = iesEngine.processBlock(message, 0, message.length);
+ log.info("cipher: {}", Hex.toHexString(cipher));
+
+
+ IESEngine decryptorIES_Engine = new IESEngine(
+ new ECDHBasicAgreement(),
+ new KDF2BytesGenerator (new SHA256Digest()),
+ new HMac(new SHA256Digest()),
+ new BufferedBlockCipher(new SICBlockCipher(aesFastEngine)));
+
+ decryptorIES_Engine.init(myKey.getPrivate(), parametersWithIV, new ECIESPublicKeyParser(ECKey.CURVE));
+
+ byte[] orig = decryptorIES_Engine.processBlock(cipher, 0, cipher.length);
+
+ log.info("orig: " + Hex.toHexString(orig));
+ }
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/crypto/ECIESCoderTest.java b/ethereumj-core/src/test/java/org/ethereum/crypto/ECIESCoderTest.java
new file mode 100644
index 00000000..69f1e7a6
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/crypto/ECIESCoderTest.java
@@ -0,0 +1,53 @@
+package org.ethereum.crypto;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.spongycastle.math.ec.ECPoint;
+import org.spongycastle.util.encoders.Hex;
+
+import java.math.BigInteger;
+
+public class ECIESCoderTest {
+
+
+ @Test // decrypt cpp data
+ public void test1(){
+ BigInteger privKey = new BigInteger("5e173f6ac3c669587538e7727cf19b782a4f2fda07c1eaa662c593e5e85e3051", 16);
+ byte[] cipher = Hex.decode("049934a7b2d7f9af8fd9db941d9da281ac9381b5740e1f64f7092f3588d4f87f5ce55191a6653e5e80c1c5dd538169aa123e70dc6ffc5af1827e546c0e958e42dad355bcc1fcb9cdf2cf47ff524d2ad98cbf275e661bf4cf00960e74b5956b799771334f426df007350b46049adb21a6e78ab1408d5e6ccde6fb5e69f0f4c92bb9c725c02f99fa72b9cdc8dd53cff089e0e73317f61cc5abf6152513cb7d833f09d2851603919bf0fbe44d79a09245c6e8338eb502083dc84b846f2fee1cc310d2cc8b1b9334728f97220bb799376233e113");
+
+ byte[] payload = new byte[0];
+ try {
+ payload = ECIESCoder.decrypt(privKey, cipher);
+ } catch (Throwable e) {e.printStackTrace();}
+
+ Assert.assertEquals("802b052f8b066640bba94a4fc39d63815c377fced6fcb84d27f791c9921ddf3e9bf0108e298f490812847109cbd778fae393e80323fd643209841a3b7f110397f37ec61d84cea03dcc5e8385db93248584e8af4b4d1c832d8c7453c0089687a700",
+ Hex.toHexString(payload));
+ }
+
+
+ @Test // encrypt decrypt round trip
+ public void test2(){
+
+ BigInteger privKey = new BigInteger("5e173f6ac3c669587538e7727cf19b782a4f2fda07c1eaa662c593e5e85e3051", 16);
+
+ byte[] payload = Hex.decode("1122334455");
+
+ ECKey ecKey = ECKey.fromPrivate(privKey);
+ ECPoint pubKeyPoint = ecKey.getPubKeyPoint();
+
+ byte[] cipher = new byte[0];
+ try {
+ cipher = ECIESCoder.encrypt(pubKeyPoint, payload);
+ } catch (Throwable e) {e.printStackTrace();}
+
+ System.out.println(Hex.toHexString(cipher));
+
+ byte[] decrypted_payload = new byte[0];
+ try {
+ decrypted_payload = ECIESCoder.decrypt(privKey, cipher);
+ } catch (Throwable e) {e.printStackTrace();}
+
+ System.out.println(Hex.toHexString(decrypted_payload));
+ }
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/crypto/ECIESTest.java b/ethereumj-core/src/test/java/org/ethereum/crypto/ECIESTest.java
new file mode 100644
index 00000000..bf9b9679
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/crypto/ECIESTest.java
@@ -0,0 +1,144 @@
+package org.ethereum.crypto;
+
+import org.ethereum.ConcatKDFBytesGenerator;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spongycastle.asn1.sec.SECNamedCurves;
+import org.spongycastle.asn1.x9.X9ECParameters;
+import org.spongycastle.crypto.*;
+import org.spongycastle.crypto.agreement.ECDHBasicAgreement;
+import org.spongycastle.crypto.digests.SHA256Digest;
+import org.spongycastle.crypto.engines.AESFastEngine;
+import org.spongycastle.crypto.generators.ECKeyPairGenerator;
+import org.spongycastle.crypto.macs.HMac;
+import org.spongycastle.crypto.modes.SICBlockCipher;
+import org.spongycastle.crypto.params.*;
+import org.spongycastle.math.ec.ECPoint;
+import org.spongycastle.util.encoders.Hex;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.math.BigInteger;
+import java.security.SecureRandom;
+import java.security.Security;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class ECIESTest {
+ public static final int KEY_SIZE = 128;
+ static Logger log = LoggerFactory.getLogger("test");
+ private static ECDomainParameters curve;
+ private static final String CIPHERTEXT1 = "042a851331790adacf6e64fcb19d0872fcdf1285a899a12cdc897da941816b0ea6485402aaf6c2e0a5d98ae3af1b05c68b307d1e0eb7a426a46f1617ba5b94f90b606eee3b5e9d2b527a9ee52cfa377bcd118b9390ed27ffe7d48e8155004375cae209012c3e057bb13a478a64a201d79ad4ae83";
+ private static final X9ECParameters IES_CURVE_PARAM = SECNamedCurves.getByName("secp256r1");
+ private static final BigInteger PRIVATE_KEY1 = new BigInteger("51134539186617376248226283012294527978458758538121566045626095875284492680246");
+
+ private static ECPoint pub(BigInteger d) {
+ return curve.getG().multiply(d);
+ }
+
+ @BeforeClass
+ public static void beforeAll() {
+ if (Security.getProvider("SC") == null)
+ Security.insertProviderAt(new org.spongycastle.jce.provider.BouncyCastleProvider(), 1);
+ curve = new ECDomainParameters(IES_CURVE_PARAM.getCurve(), IES_CURVE_PARAM.getG(), IES_CURVE_PARAM.getN(), IES_CURVE_PARAM.getH());
+ }
+
+ @Test
+ public void testKDF() {
+ ConcatKDFBytesGenerator kdf = new ConcatKDFBytesGenerator(new SHA256Digest());
+ kdf.init(new KDFParameters("Hello".getBytes(), new byte[0]));
+ byte[] bytes = new byte[2];
+ kdf.generateBytes(bytes, 0, bytes.length);
+ assertArrayEquals(new byte[]{-66, -89}, bytes);
+ }
+
+ @Test
+ public void testDecryptTestVector() throws IOException, InvalidCipherTextException {
+ ECPoint pub1 = pub(PRIVATE_KEY1);
+ byte[] ciphertext = Hex.decode(CIPHERTEXT1);
+ byte[] plaintext = decrypt(PRIVATE_KEY1, ciphertext);
+ assertArrayEquals(new byte[]{1,1,1}, plaintext);
+ }
+
+ @Test
+ public void testRoundTrip() throws InvalidCipherTextException, IOException {
+ ECPoint pub1 = pub(PRIVATE_KEY1);
+ byte[] plaintext = "Hello world".getBytes();
+ byte[] ciphertext = encrypt(pub1, plaintext);
+ byte[] plaintext1 = decrypt(PRIVATE_KEY1, ciphertext);
+ assertArrayEquals(plaintext, plaintext1);
+ }
+
+ public static byte[] decrypt(BigInteger prv, byte[] cipher) throws InvalidCipherTextException, IOException {
+ ByteArrayInputStream is = new ByteArrayInputStream(cipher);
+ byte[] ephemBytes = new byte[2*((curve.getCurve().getFieldSize()+7)/8) + 1];
+ is.read(ephemBytes);
+ ECPoint ephem = curve.getCurve().decodePoint(ephemBytes);
+ byte[] IV = new byte[KEY_SIZE /8];
+ is.read(IV);
+ byte[] cipherBody = new byte[is.available()];
+ is.read(cipherBody);
+
+ EthereumIESEngine iesEngine = makeIESEngine(false, ephem, prv, IV);
+
+ byte[] message = iesEngine.processBlock(cipherBody, 0, cipherBody.length);
+ return message;
+ }
+
+ public static byte[] encrypt(ECPoint toPub, byte[] plaintext) throws InvalidCipherTextException, IOException {
+
+ ECKeyPairGenerator eGen = new ECKeyPairGenerator();
+ SecureRandom random = new SecureRandom();
+ KeyGenerationParameters gParam = new ECKeyGenerationParameters(curve, random);
+
+ eGen.init(gParam);
+
+ byte[] IV = new byte[KEY_SIZE/8];
+ new SecureRandom().nextBytes(IV);
+
+ AsymmetricCipherKeyPair ephemPair = eGen.generateKeyPair();
+ BigInteger prv = ((ECPrivateKeyParameters)ephemPair.getPrivate()).getD();
+ ECPoint pub = ((ECPublicKeyParameters)ephemPair.getPublic()).getQ();
+ EthereumIESEngine iesEngine = makeIESEngine(true, toPub, prv, IV);
+
+
+ ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(curve, random);
+ ECKeyPairGenerator generator = new ECKeyPairGenerator();
+ generator.init(keygenParams);
+
+ ECKeyPairGenerator gen = new ECKeyPairGenerator();
+ gen.init(new ECKeyGenerationParameters(ECKey.CURVE, random));
+
+ byte[] cipher = iesEngine.processBlock(plaintext, 0, plaintext.length);
+ ByteArrayOutputStream bos = new ByteArrayOutputStream();
+ bos.write(pub.getEncoded(false));
+ bos.write(IV);
+ bos.write(cipher);
+ return bos.toByteArray();
+ }
+
+ private static EthereumIESEngine makeIESEngine(boolean isEncrypt, ECPoint pub, BigInteger prv, byte[] IV) {
+ AESFastEngine aesFastEngine = new AESFastEngine();
+
+ EthereumIESEngine iesEngine = new EthereumIESEngine(
+ new ECDHBasicAgreement(),
+ new ConcatKDFBytesGenerator(new SHA256Digest()),
+ new HMac(new SHA256Digest()),
+ new SHA256Digest(),
+ new BufferedBlockCipher(new SICBlockCipher(aesFastEngine)));
+
+
+ byte[] d = new byte[] {};
+ byte[] e = new byte[] {};
+
+ IESParameters p = new IESWithCipherParameters(d, e, KEY_SIZE, KEY_SIZE);
+ ParametersWithIV parametersWithIV = new ParametersWithIV(p, IV);
+
+ iesEngine.init(isEncrypt, new ECPrivateKeyParameters(prv, curve), new ECPublicKeyParameters(pub, curve), parametersWithIV);
+ return iesEngine;
+ }
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/crypto/ECKeyTest.java b/ethereumj-core/src/test/java/org/ethereum/crypto/ECKeyTest.java
new file mode 100644
index 00000000..b0cb3c93
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/crypto/ECKeyTest.java
@@ -0,0 +1,297 @@
+package org.ethereum.crypto;
+
+import org.ethereum.core.Transaction;
+import org.ethereum.crypto.ECKey.ECDSASignature;
+
+import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.spongycastle.util.encoders.Hex;
+
+import java.io.IOException;
+
+import java.math.BigInteger;
+
+import java.security.SignatureException;
+
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executors;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.junit.Assert.*;
+
+public class ECKeyTest {
+ private static final Logger log = LoggerFactory.getLogger(ECKeyTest.class);
+
+ private String privString = "3ecb44df2159c26e0f995712d4f39b6f6e499b40749b1cf1246c37f9516cb6a4";
+ private BigInteger privateKey = new BigInteger(Hex.decode(privString));
+
+ private String pubString = "0497466f2b32bc3bb76d4741ae51cd1d8578b48d3f1e68da206d47321aec267ce78549b514e4453d74ef11b0cd5e4e4c364effddac8b51bcfc8de80682f952896f";
+ private String compressedPubString = "0397466f2b32bc3bb76d4741ae51cd1d8578b48d3f1e68da206d47321aec267ce7";
+ private byte[] pubKey = Hex.decode(pubString);
+ private byte[] compressedPubKey = Hex.decode(compressedPubString);
+ private String address = "8a40bfaa73256b60764c1bf40675a99083efb075";
+
+ private String exampleMessage = new String("This is an example of a signed message.");
+ private String sigBase64 = "HD5AsBr4wuH6UU9tXuSJhUvgfGayfwoY0cKT03sFUjnpQsupHznd/3mCIRfLuNHlRCVGdAyHecdyM8IVZMtc1I8=";
+
+ @Test
+ public void testHashCode() {
+ Assert.assertEquals(1866897155, ECKey.fromPrivate(privateKey).hashCode());
+ }
+
+ @Test
+ public void testECKey() {
+ ECKey key = new ECKey();
+ assertTrue(key.isPubKeyCanonical());
+ assertNotNull(key.getPubKey());
+ assertNotNull(key.getPrivKeyBytes());
+ log.debug(Hex.toHexString(key.getPrivKeyBytes()) + " :Generated privkey");
+ log.debug(Hex.toHexString(key.getPubKey()) + " :Generated pubkey");
+ }
+
+ @Test
+ public void testFromPrivateKey() {
+ ECKey key = ECKey.fromPrivate(privateKey).decompress();
+ assertTrue(key.isPubKeyCanonical());
+ assertTrue(key.hasPrivKey());
+ assertArrayEquals(pubKey, key.getPubKey());
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testPrivatePublicKeyBytesNoArg() {
+ new ECKey(null, null);
+ fail("Expecting an IllegalArgumentException for using only null-parameters");
+ }
+
+ @Test
+ public void testIsPubKeyOnly() {
+ ECKey key = ECKey.fromPublicOnly(pubKey);
+ assertTrue(key.isPubKeyCanonical());
+ assertTrue(key.isPubKeyOnly());
+ assertArrayEquals(key.getPubKey(), pubKey);
+ }
+
+
+ @Test
+ public void testPublicKeyFromPrivate() {
+ byte[] pubFromPriv = ECKey.publicKeyFromPrivate(privateKey, false);
+ assertArrayEquals(pubKey, pubFromPriv);
+ }
+
+ @Test
+ public void testPublicKeyFromPrivateCompressed() {
+ byte[] pubFromPriv = ECKey.publicKeyFromPrivate(privateKey, true);
+ assertArrayEquals(compressedPubKey, pubFromPriv);
+ }
+
+ @Test
+ public void testGetAddress() {
+ ECKey key = ECKey.fromPublicOnly(pubKey);
+ assertArrayEquals(Hex.decode(address), key.getAddress());
+ }
+
+ @Test
+ public void testToString() {
+ ECKey key = ECKey.fromPrivate(BigInteger.TEN); // An example private key.
+ assertEquals("pub:04a0434d9e47f3c86235477c7b1ae6ae5d3442d49b1943c2b752a68e2a47e247c7893aba425419bc27a3b6c7e693a24c696f794c2ed877a1593cbee53b037368d7", key.toString());
+ }
+
+ @Test
+ public void testEthereumSign() throws IOException {
+ // TODO: Understand why key must be decompressed for this to work
+ ECKey key = ECKey.fromPrivate(privateKey).decompress();
+ System.out.println("Secret\t: " + Hex.toHexString(key.getPrivKeyBytes()));
+ System.out.println("Pubkey\t: " + Hex.toHexString(key.getPubKey()));
+ System.out.println("Data\t: " + exampleMessage);
+ byte[] messageHash = HashUtil.sha3(exampleMessage.getBytes());
+ ECDSASignature signature = key.sign(messageHash);
+ String output = signature.toBase64();
+ System.out.println("Signtr\t: " + output + " (Base64, length: " + output.length() + ")");
+ assertEquals(sigBase64, output);
+ }
+
+ @Test
+ public void testVerifySignature1() {
+ ECKey key = ECKey.fromPublicOnly(pubKey);
+ BigInteger r = new BigInteger("28157690258821599598544026901946453245423343069728565040002908283498585537001");
+ BigInteger s = new BigInteger("30212485197630673222315826773656074299979444367665131281281249560925428307087");
+ ECDSASignature sig = ECDSASignature.fromComponents(r.toByteArray(), s.toByteArray(), (byte) 28);
+ key.verify(HashUtil.sha3(exampleMessage.getBytes()), sig);
+ }
+
+ @Test
+ public void testVerifySignature2() {
+ BigInteger r = new BigInteger("c52c114d4f5a3ba904a9b3036e5e118fe0dbb987fe3955da20f2cd8f6c21ab9c", 16);
+ BigInteger s = new BigInteger("6ba4c2874299a55ad947dbc98a25ee895aabf6b625c26c435e84bfd70edf2f69", 16);
+ ECDSASignature sig = ECDSASignature.fromComponents(r.toByteArray(), s.toByteArray(), (byte) 0x1b);
+ byte[] rawtx = Hex.decode("f82804881bc16d674ec8000094cd2a3d9f938e13cd947ec05abc7fe734df8dd8268609184e72a0006480");
+ try {
+ ECKey key = ECKey.signatureToKey(HashUtil.sha3(rawtx), sig.toBase64());
+ System.out.println("Signature public key\t: " + Hex.toHexString(key.getPubKey()));
+ System.out.println("Sender is\t\t: " + Hex.toHexString(key.getAddress()));
+ assertEquals("cd2a3d9f938e13cd947ec05abc7fe734df8dd826", Hex.toHexString(key.getAddress()));
+ key.verify(HashUtil.sha3(rawtx), sig);
+ } catch (SignatureException e) {
+ fail();
+ }
+ }
+
+ @Test
+ public void testVerifySignature3() throws SignatureException {
+
+ byte[] rawtx = Hex.decode("f86e80893635c9adc5dea000008609184e72a00082109f9479b08ad8787060333663d19704909ee7b1903e58801ba0899b92d0c76cbf18df24394996beef19c050baa9823b4a9828cd9b260c97112ea0c9e62eb4cf0a9d95ca35c8830afac567619d6b3ebee841a3c8be61d35acd8049");
+
+ Transaction tx = new Transaction(rawtx);
+ ECKey key = ECKey.signatureToKey(HashUtil.sha3(rawtx), tx.getSignature().toBase64());
+
+ System.out.println("Signature public key\t: " + Hex.toHexString(key.getPubKey()));
+ System.out.println("Sender is\t\t: " + Hex.toHexString(key.getAddress()));
+
+ // sender: CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826
+ // todo: add test assertion when the sign/verify part actually works.
+ }
+
+
+ @Test
+ public void testSValue() throws Exception {
+ // Check that we never generate an S value that is larger than half the curve order. This avoids a malleability
+ // issue that can allow someone to change a transaction [hash] without invalidating the signature.
+ final int ITERATIONS = 10;
+ ListeningExecutorService executor = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(ITERATIONS));
+ List> sigFutures = Lists.newArrayList();
+ final ECKey key = new ECKey();
+ for (byte i = 0; i < ITERATIONS; i++) {
+ final byte[] hash = HashUtil.sha3(new byte[]{i});
+ sigFutures.add(executor.submit(new Callable() {
+ @Override
+ public ECKey.ECDSASignature call() throws Exception {
+ return key.doSign(hash);
+ }
+ }));
+ }
+ List sigs = Futures.allAsList(sigFutures).get();
+ for (ECKey.ECDSASignature signature : sigs) {
+ assertTrue(signature.s.compareTo(ECKey.HALF_CURVE_ORDER) <= 0);
+ }
+ final ECKey.ECDSASignature duplicate = new ECKey.ECDSASignature(sigs.get(0).r, sigs.get(0).s);
+ assertEquals(sigs.get(0), duplicate);
+ assertEquals(sigs.get(0).hashCode(), duplicate.hashCode());
+ }
+
+ @Test
+ public void testSignVerify() {
+ ECKey key = ECKey.fromPrivate(privateKey);
+ String message = new String("This is an example of a signed message.");
+ ECDSASignature output = key.doSign(message.getBytes());
+ assertTrue(key.verify(message.getBytes(), output));
+ }
+
+ @Test
+ public void testIsPubKeyCanonicalCorect() {
+ // Test correct prefix 4, right length 65
+ byte[] canonicalPubkey1 = new byte[65];
+ canonicalPubkey1[0] = 0x04;
+ assertTrue(ECKey.isPubKeyCanonical(canonicalPubkey1));
+ // Test correct prefix 2, right length 33
+ byte[] canonicalPubkey2 = new byte[33];
+ canonicalPubkey2[0] = 0x02;
+ assertTrue(ECKey.isPubKeyCanonical(canonicalPubkey2));
+ // Test correct prefix 3, right length 33
+ byte[] canonicalPubkey3 = new byte[33];
+ canonicalPubkey3[0] = 0x03;
+ assertTrue(ECKey.isPubKeyCanonical(canonicalPubkey3));
+ }
+
+ @Test
+ public void testIsPubKeyCanonicalWrongLength() {
+ // Test correct prefix 4, but wrong length !65
+ byte[] nonCanonicalPubkey1 = new byte[64];
+ nonCanonicalPubkey1[0] = 0x04;
+ assertFalse(ECKey.isPubKeyCanonical(nonCanonicalPubkey1));
+ // Test correct prefix 2, but wrong length !33
+ byte[] nonCanonicalPubkey2 = new byte[32];
+ nonCanonicalPubkey2[0] = 0x02;
+ assertFalse(ECKey.isPubKeyCanonical(nonCanonicalPubkey2));
+ // Test correct prefix 3, but wrong length !33
+ byte[] nonCanonicalPubkey3 = new byte[32];
+ nonCanonicalPubkey3[0] = 0x03;
+ assertFalse(ECKey.isPubKeyCanonical(nonCanonicalPubkey3));
+ }
+
+ @Test
+ public void testIsPubKeyCanonicalWrongPrefix() {
+ // Test wrong prefix 4, right length 65
+ byte[] nonCanonicalPubkey4 = new byte[65];
+ assertFalse(ECKey.isPubKeyCanonical(nonCanonicalPubkey4));
+ // Test wrong prefix 2, right length 33
+ byte[] nonCanonicalPubkey5 = new byte[33];
+ assertFalse(ECKey.isPubKeyCanonical(nonCanonicalPubkey5));
+ // Test wrong prefix 3, right length 33
+ byte[] nonCanonicalPubkey6 = new byte[33];
+ assertFalse(ECKey.isPubKeyCanonical(nonCanonicalPubkey6));
+ }
+
+ @Test
+ public void keyRecovery() throws Exception {
+ ECKey key = new ECKey();
+ String message = "Hello World!";
+ byte[] hash = HashUtil.sha256(message.getBytes());
+ ECKey.ECDSASignature sig = key.doSign(hash);
+ key = ECKey.fromPublicOnly(key.getPubKeyPoint());
+ boolean found = false;
+ for (int i = 0; i < 4; i++) {
+ ECKey key2 = ECKey.recoverFromSignature(i, sig, hash, true);
+ checkNotNull(key2);
+ if (key.equals(key2)) {
+ found = true;
+ break;
+ }
+ }
+ assertTrue(found);
+ }
+
+ @Test
+ public void testSignedMessageToKey() throws SignatureException {
+ byte[] messageHash = HashUtil.sha3(exampleMessage.getBytes());
+ ECKey key = ECKey.signatureToKey(messageHash, sigBase64);
+ assertNotNull(key);
+ assertArrayEquals(pubKey, key.getPubKey());
+ }
+
+ @Test
+ public void testGetPrivKeyBytes() {
+ ECKey key = new ECKey();
+ assertNotNull(key.getPrivKeyBytes());
+ assertEquals(32, key.getPrivKeyBytes().length);
+ }
+
+ @Test
+ public void testEqualsObject() {
+ ECKey key0 = new ECKey();
+ ECKey key1 = ECKey.fromPrivate(privateKey);
+ ECKey key2 = ECKey.fromPrivate(privateKey);
+
+ assertFalse(key0.equals(key1));
+ assertTrue(key1.equals(key1));
+ assertTrue(key1.equals(key2));
+ }
+
+
+ @Test
+ public void decryptAECSIC(){
+ ECKey key = ECKey.fromPrivate(Hex.decode("abb51256c1324a1350598653f46aa3ad693ac3cf5d05f36eba3f495a1f51590f"));
+ byte[] payload = key.decryptAES(Hex.decode("84a727bc81fa4b13947dc9728b88fd08"));
+ System.out.println(Hex.toHexString(payload));
+ }
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/datasource/AbstractRedisTest.java b/ethereumj-core/src/test/java/org/ethereum/datasource/AbstractRedisTest.java
new file mode 100644
index 00000000..8adc7ea4
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/datasource/AbstractRedisTest.java
@@ -0,0 +1,82 @@
+package org.ethereum.datasource;
+
+import org.ethereum.config.SystemProperties;
+import org.ethereum.datasource.redis.RedisConnection;
+import org.ethereum.db.BlockStore;
+import org.ethereum.db.InMemoryBlockStore;
+import org.ethereum.manager.WorldManager;
+import org.hibernate.SessionFactory;
+import org.junit.After;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import redis.clients.jedis.Jedis;
+import org.ethereum.TestContext;
+
+import java.net.URI;
+
+import static org.junit.Assert.assertFalse;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(loader = AnnotationConfigContextLoader.class)
+public abstract class AbstractRedisTest {
+
+ @Configuration
+ @ComponentScan(basePackages = "org.ethereum")
+ static class ContextConfiguration extends TestContext {
+ static {
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + "RedisAll");
+ SystemProperties.CONFIG.setDatabaseReset(true);
+ }
+
+ @Bean
+ @Transactional(propagation = Propagation.SUPPORTS)
+ public BlockStore blockStore(SessionFactory sessionFactory){
+ return new InMemoryBlockStore();
+ }
+ }
+
+ @Autowired
+ private RedisConnection redisConnection;
+
+ @Autowired
+ WorldManager worldManager;
+
+ @After
+ public void close(){
+ worldManager.close();
+ }
+
+
+ private Boolean connected;
+
+ protected RedisConnection getRedisConnection() {
+ return redisConnection;
+ }
+
+ protected Boolean isConnected() {
+ if (connected == null) {
+ String url = System.getenv(RedisConnection.REDISCLOUD_URL);
+ try {
+ Jedis jedis = new Jedis(new URI(url));
+ connected = jedis.ping().equals("PONG");
+ jedis.close();
+ } catch (Exception e) {
+ connected = false;
+ System.out.printf("Cannot connect to '%s' Redis cloud.\n", url);
+ }
+
+ assertFalse(connected ^ redisConnection.isAvailable());
+ }
+
+ return connected;
+ }
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/datasource/RedisDataSourceTest.java b/ethereumj-core/src/test/java/org/ethereum/datasource/RedisDataSourceTest.java
new file mode 100644
index 00000000..6d86abd3
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/datasource/RedisDataSourceTest.java
@@ -0,0 +1,70 @@
+package org.ethereum.datasource;
+
+import org.ethereum.datasource.redis.RedisDataSource;
+import org.junit.Assert;
+import org.junit.Test;
+import org.spongycastle.util.encoders.Hex;
+
+/**
+ * @author Roman Mandeleil
+ */
+public class RedisDataSourceTest extends AbstractRedisTest {
+
+
+
+ @Test
+ public void testSet1() {
+ if (!isConnected()) return;
+
+ KeyValueDataSource dataSource = createDataSource("test-state");
+ try {
+ byte[] key = Hex.decode("a1a2a3");
+ byte[] val = Hex.decode("b1b2b3");
+
+ dataSource.put(key, val);
+ byte[] val2 = dataSource.get(key);
+
+ Assert.assertEquals(Hex.toHexString(val), Hex.toHexString(val2));
+ } finally {
+ clear(dataSource);
+ }
+ }
+
+ @Test
+ public void testSet2() {
+ if (!isConnected()) return;
+
+ KeyValueDataSource states = createDataSource("test-state");
+ KeyValueDataSource details = createDataSource("test-details");
+
+ try {
+ byte[] key = Hex.decode("a1a2a3");
+ byte[] val1 = Hex.decode("b1b2b3");
+ byte[] val2 = Hex.decode("c1c2c3");
+
+ states.put(key, val1);
+ details.put(key, val2);
+
+ byte[] res1 = states.get(key);
+ byte[] res2 = details.get(key);
+
+ Assert.assertEquals(Hex.toHexString(val1), Hex.toHexString(res1));
+ Assert.assertEquals(Hex.toHexString(val2), Hex.toHexString(res2));
+ } finally {
+ clear(states);
+ clear(details);
+ }
+ }
+
+ private KeyValueDataSource createDataSource(String name) {
+ KeyValueDataSource result = getRedisConnection().createDataSource(name);
+ result.setName(name);
+ result.init();
+ return result;
+ }
+
+ private void clear(KeyValueDataSource dataSource) {
+ ((RedisDataSource) dataSource).clear();
+ }
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/datasource/RedisStorageTest.java b/ethereumj-core/src/test/java/org/ethereum/datasource/RedisStorageTest.java
new file mode 100644
index 00000000..0fcb4b9d
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/datasource/RedisStorageTest.java
@@ -0,0 +1,130 @@
+package org.ethereum.datasource;
+
+import org.ethereum.core.Transaction;
+import org.ethereum.crypto.ECKey;
+import org.ethereum.crypto.HashUtil;
+import org.junit.Test;
+import org.spongycastle.util.encoders.Hex;
+
+import java.math.BigInteger;
+import java.util.Set;
+
+import static java.util.Arrays.asList;
+import static org.junit.Assert.*;
+
+public class RedisStorageTest extends AbstractRedisTest {
+
+ @Test
+ public void testRedisSet() {
+ if (!isConnected()) return;
+
+ Pojo elephant = Pojo.create(5L, "elephant");
+ Pojo lion = Pojo.create(5L, "lion");
+
+ Set ranch = getRedisConnection().createSetFor(Pojo.class, "ranch");
+ Pojo chicken = Pojo.create(1L, "chicken");
+ Pojo cow = Pojo.create(2L, "cow");
+ Pojo puppy = Pojo.create(3L, "puppy");
+ Pojo kitten = Pojo.create(4L, "kitten");
+
+ assertTrue(ranch.add(chicken));
+ assertFalse(ranch.add(chicken));
+ assertTrue(ranch.contains(chicken));
+ assertEquals(1, ranch.size());
+
+ Pojo next = ranch.iterator().next();
+ assertNotNull(next);
+ assertEquals(chicken, next);
+
+ assertTrue(ranch.addAll(asList(cow, puppy, kitten)));
+ assertEquals(4, ranch.size());
+ assertFalse(ranch.isEmpty());
+ assertFalse(ranch.remove(elephant));
+ assertFalse(ranch.removeAll(asList(cow, lion, elephant)));
+ assertEquals(3, ranch.size());
+
+ assertTrue(ranch.retainAll(asList(kitten, puppy)));
+ assertEquals(2, ranch.size());
+
+ ranch.clear();
+ assertEquals(0, ranch.size());
+ assertTrue(ranch.isEmpty());
+ }
+
+ @Test
+ public void testSeveralSetsWithOneName() {
+ if (!isConnected()) return;
+
+ final String name = "testTransactions";
+ Set transactions = getRedisConnection().createTransactionSet(name);
+ transactions.add(createTransaction("09184e72a000", "4255", "1000000000000000000000", "cat"));
+ transactions.add(createTransaction("09184e72a000", "4255", "1000000000000000000000", "dog"));
+ transactions.add(createTransaction("09184e72a000", "4255", "1000000000000000000000", "rabbit"));
+
+ Set transactions1 = getRedisConnection().createTransactionSet(name);
+ transactions1.add(createTransaction("09184e72a000", "4255", "1000000000000000000000", "duck"));
+ transactions1.add(createTransaction("09184e72a000", "4255", "1000000000000000000000", "chicken"));
+ transactions1.add(createTransaction("09184e72a000", "4255", "1000000000000000000000", "cow"));
+
+ assertEquals(6, transactions1.size());
+ transactions.clear();
+ assertTrue(transactions1.isEmpty());
+ }
+
+ private static class Pojo {
+ private Long id;
+ private String name;
+
+ public Long getId() {
+ return id;
+ }
+
+ public void setId(Long id) {
+ this.id = id;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public static Pojo create(long id, String name) {
+ Pojo result = new Pojo();
+ result.setId(id);
+ result.setName(name);
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == null || !getClass().isInstance(obj)) return false;
+ if (this == obj) return true;
+
+ Pojo another = (Pojo) obj;
+ return (another.getId() == getId()) && another.getName().equals(getName());
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 17;
+
+ hashCode += ((getId() == null) ? 0 : getId().hashCode()) * 31;
+ hashCode += ((getName() == null) ? 0 : getName().hashCode()) * 31;
+
+ return hashCode;
+ }
+ }
+
+ public static Transaction createTransaction(String gasPrice, String gas, String val, String secret) {
+
+ ECKey ecKey = ECKey.fromPrivate(HashUtil.sha3(secret.getBytes()));
+
+ // Tn (nonce); Tp(pgas); Tg(gaslimi); Tt(value); Tv(value); Ti(sender); Tw; Tr; Ts
+ return new Transaction(null, Hex.decode(gasPrice), Hex.decode(gas), ecKey.getAddress(),
+ new BigInteger(val).toByteArray(),
+ null);
+ }
+}
\ No newline at end of file
diff --git a/ethereumj-core/src/test/java/org/ethereum/db/ByteArrayWrapperTest.java b/ethereumj-core/src/test/java/org/ethereum/db/ByteArrayWrapperTest.java
new file mode 100644
index 00000000..812b66be
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/db/ByteArrayWrapperTest.java
@@ -0,0 +1,143 @@
+package org.ethereum.db;
+
+import org.ethereum.util.FastByteComparisons;
+
+import com.google.common.primitives.UnsignedBytes;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import org.spongycastle.util.encoders.Hex;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+import static org.junit.Assert.*;
+
+public class ByteArrayWrapperTest {
+
+ static ByteArrayWrapper wrapper1;
+ static ByteArrayWrapper wrapper2;
+ static ByteArrayWrapper wrapper3;
+ static ByteArrayWrapper wrapper4;
+
+ @BeforeClass
+ public static void loadByteArrays() {
+
+ String block = "f9072df8d3a077ef4fdaf389dca53236bcf7f72698e154eab2828f86fbc4fc6c"
+ + "d9225d285c89a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0"
+ + "a142fd40d493479476f5eabe4b342ee56b8ceba6ab2a770c3e2198e7a0faa0ca"
+ + "43105f667dceb168eb4e0cdc98ef28a9da5c381edef70d843207601719a06785"
+ + "f3860460b2aa29122698e83a5151b270e82532c1663e89e3df8c5445b8ca833f"
+ + "f000018609184e72a000830f3e6f8227d2845387c58f80a00000000000000000"
+ + "0000000000000000000000000000000094148d7738f78c04f90654f8c6f8a080"
+ + "8609184e72a00082271094000000000000000000000000000000000000000080"
+ + "b83a33604557602a5160106000396000f200604556330e0f602a59366000530a"
+ + "0f602a596020600053013560005335576040600053016000546009581ca033a6"
+ + "bfa5eb2f4b63f1b98bed9a987d096d32e56deecb050367c84955508f5365a015"
+ + "034e7574ec073f0c448aac1d9f844387610dfef5342834b6825fbc35df5913a0"
+ + "ee258e73d41ada73d8d6071ba7d236fbbe24fcfb9627fbd4310e24ffd87b961a"
+ + "8203e9f90194f9016d018609184e72a000822710940000000000000000000000"
+ + "00000000000000000080b901067f4e616d655265670000000000000000000000"
+ + "00000000000000000000000000003057307f4e616d6552656700000000000000"
+ + "000000000000000000000000000000000000577f436f6e666967000000000000"
+ + "000000000000000000000000000000000000000073ccdeac59d35627b7de0933"
+ + "2e819d5159e7bb72505773ccdeac59d35627b7de09332e819d5159e7bb72507f"
+ + "436f6e6669670000000000000000000000000000000000000000000000000000"
+ + "57336045576041516100c56000396000f20036602259604556330e0f600f5933"
+ + "ff33560f601e5960003356576000335700604158600035560f602b590033560f"
+ + "603659600033565733600035576000353357001ca0f3c527e484ea5546189979"
+ + "c767b69aa9f1ad5a6f4b6077d4bccf5142723a67c9a069a4a29a2a315102fcd0"
+ + "822d39ad696a6d7988c993bb2b911cc2a78bb8902d91a01ebe4782ea3ed224cc"
+ + "bb777f5de9ee7b5bbb282ac08f7fa0ef95d3d1c1c6d1a1820ef7f8ccf8a60286"
+ + "09184e72a00082271094ccdeac59d35627b7de09332e819d5159e7bb725080b8"
+ + "4000000000000000000000000000000000000000000000000000000000000000"
+ + "000000000000000000000000002d0aceee7e5ab874e22ccf8d1a649f59106d74"
+ + "e81ba095ad45bf574c080e4d72da2cfd3dbe06cc814c1c662b5f74561f13e1e7"
+ + "5058f2a057745a3db5482bccb5db462922b074f4b79244c4b1fa811ed094d728"
+ + "e7b6da92a08599ea5d6cb6b9ad3311f0d82a3337125e05f4a82b9b0556cb3776"
+ + "a6e1a02f8782132df8abf885038609184e72a000822710942d0aceee7e5ab874"
+ + "e22ccf8d1a649f59106d74e880a0476176000000000000000000000000000000"
+ + "00000000000000000000000000001ca09b5fdabd54ebc284249d2d2df6d43875"
+ + "cb86c52bd2bac196d4f064c8ade054f2a07b33f5c8b277a408ec38d2457441d2"
+ + "af32e55681c8ecb28eef3d2a152e8db5a9a0227a67fceb1bf4ddd31a7047e24b"
+ + "e93c947ab3b539471555bb3509ed6e393c8e82178df90277f90250048609184e"
+ + "72a0008246dd94000000000000000000000000000000000000000080b901e961"
+ + "010033577f476176436f696e0000000000000000000000000000000000000000"
+ + "000000000060005460006000600760006000732d0aceee7e5ab874e22ccf8d1a"
+ + "649f59106d74e860645c03f150436000576000600157620f424060025761017d"
+ + "5161006c6000396000f2006020360e0f61013f59602060006000374360205460"
+ + "0056600054602056602054437f6e000000000000000000000000000000000000"
+ + "00000000000000000000000000560e0f0f61008059437f6e0000000000000000"
+ + "0000000000000000000000000000000000000000000000576000602054610400"
+ + "60005304600053036000547f6400000000000000000000000000000000000000"
+ + "0000000000000000000000005660016000030460406000200a0f61013e596001"
+ + "60205301602054600a6020530b0f6100f45961040060005304600053017f6400"
+ + "0000000000000000000000000000000000000000000000000000000000005760"
+ + "20537f6900000000000000000000000000000000000000000000000000000000"
+ + "000000576000537f640000000000000000000000000000000000000000000000"
+ + "000000000000000057006040360e0f0f61014a59003356604054600035566060"
+ + "546020356080546080536040530a0f6101695900608053604053033357608053"
+ + "60605301600035571ba0190fc7ab634dc497fe1656fde523a4c26926d51a93db"
+ + "2ba37af8e83c3741225da066ae0ec1217b0ca698a5369d4881e1c4cbde56af99"
+ + "31ebf9281580a23b659c08a051f947cb2315d0259f55848c630caa10cd91d6e4"
+ + "4ff8bad7758c65b25e2191308227d2c0";
+
+ byte[] test1 = Hex.decode(block);
+ byte[] test2 = Hex.decode(block);
+ byte[] test3 = Hex.decode("4ff8bad7758c65b25e2191308227d2c0");
+ byte[] test4 = Hex.decode("");
+
+ wrapper1 = new ByteArrayWrapper(test1);
+ wrapper2 = new ByteArrayWrapper(test2);
+ wrapper3 = new ByteArrayWrapper(test3);
+ wrapper4 = new ByteArrayWrapper(test4);
+ }
+
+ @Test
+ public void testEqualsObject() {
+ assertTrue(wrapper1.equals(wrapper2));
+ assertFalse(wrapper1.equals(wrapper3));
+ assertFalse(wrapper1.equals(wrapper4));
+ assertFalse(wrapper1.equals(null));
+ assertFalse(wrapper2.equals(wrapper3));
+ }
+
+ @Test
+ public void testCompareTo() {
+ assertTrue(wrapper1.compareTo(wrapper2) == 0);
+ assertTrue(wrapper1.compareTo(wrapper3) > 1);
+ assertTrue(wrapper1.compareTo(wrapper4) > 1);
+ assertTrue(wrapper2.compareTo(wrapper3) > 1);
+ }
+
+ @Test
+ public void testEqualsPerformance() {
+ boolean testEnabled = false;
+
+ if (testEnabled) {
+ final int ITERATIONS = 10000000;
+ long start1 = System.currentTimeMillis();
+ for (int i = 0; i < ITERATIONS; i++) {
+ Comparator comparator = UnsignedBytes
+ .lexicographicalComparator();
+
+ comparator.compare(wrapper1.getData(),
+ wrapper2.getData());
+ }
+ System.out.println(System.currentTimeMillis() - start1 + "ms");
+
+ long start2 = System.currentTimeMillis();
+ for (int i = 0; i < ITERATIONS; i++) {
+ Arrays.equals(wrapper1.getData(), wrapper2.getData());
+ }
+ System.out.println(System.currentTimeMillis() - start2 + "ms");
+
+ long start3 = System.currentTimeMillis();
+ for (int i = 0; i < ITERATIONS; i++) {
+ FastByteComparisons.compareTo(wrapper1.getData(), 0, wrapper1.getData().length, wrapper2.getData(), 0, wrapper1.getData().length);
+ }
+ System.out.println(System.currentTimeMillis() - start3 + "ms");
+ }
+ }
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/db/RepositoryTest.java b/ethereumj-core/src/test/java/org/ethereum/db/RepositoryTest.java
new file mode 100644
index 00000000..70050a3c
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/db/RepositoryTest.java
@@ -0,0 +1,557 @@
+package org.ethereum.db;
+
+import org.ethereum.config.SystemProperties;
+import org.ethereum.core.Genesis;
+import org.ethereum.crypto.HashUtil;
+
+import org.ethereum.datasource.LevelDbDataSource;
+import org.ethereum.facade.Repository;
+import org.ethereum.vm.DataWord;
+
+import org.junit.Assert;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import org.spongycastle.util.encoders.Hex;
+
+import java.math.BigInteger;
+
+import static org.junit.Assert.*;
+
+/**
+ * @author Roman Mandeleil
+ * @since 17.11.2014
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class RepositoryTest {
+
+
+ @Test
+ public void test1() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repository = new RepositoryImpl(new LevelDbDataSource(), new LevelDbDataSource());
+
+ byte[] cow = Hex.decode("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826");
+ byte[] horse = Hex.decode("13978AEE95F38490E9769C39B2773ED763D9CD5F");
+
+ repository.increaseNonce(cow);
+ repository.increaseNonce(horse);
+
+ assertEquals(BigInteger.ONE, repository.getNonce(cow));
+ assertEquals(BigInteger.ONE, repository.getNonce(horse));
+
+ repository.close();
+ }
+
+
+ @Test
+ public void test2() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repository = new RepositoryImpl(new LevelDbDataSource(), new LevelDbDataSource());
+
+ byte[] cow = Hex.decode("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826");
+ byte[] horse = Hex.decode("13978AEE95F38490E9769C39B2773ED763D9CD5F");
+
+ repository.addBalance(cow, BigInteger.TEN);
+ repository.addBalance(horse, BigInteger.ONE);
+
+ assertEquals(BigInteger.TEN, repository.getBalance(cow));
+ assertEquals(BigInteger.ONE, repository.getBalance(horse));
+
+ repository.close();
+ }
+
+
+ @Test
+ public void test3() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repository = new RepositoryImpl(new LevelDbDataSource(), new LevelDbDataSource());
+
+ byte[] cow = Hex.decode("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826");
+ byte[] horse = Hex.decode("13978AEE95F38490E9769C39B2773ED763D9CD5F");
+
+ byte[] cowCode = Hex.decode("A1A2A3");
+ byte[] horseCode = Hex.decode("B1B2B3");
+
+ repository.saveCode(cow, cowCode);
+ repository.saveCode(horse, horseCode);
+
+ assertArrayEquals(cowCode, repository.getCode(cow));
+ assertArrayEquals(horseCode, repository.getCode(horse));
+
+ repository.close();
+ }
+
+ @Test
+ public void test4() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repository = new RepositoryImpl(new LevelDbDataSource(), new LevelDbDataSource());
+
+ byte[] cow = Hex.decode("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826");
+ byte[] horse = Hex.decode("13978AEE95F38490E9769C39B2773ED763D9CD5F");
+
+ byte[] cowKey = Hex.decode("A1A2A3");
+ byte[] cowValue = Hex.decode("A4A5A6");
+
+ byte[] horseKey = Hex.decode("B1B2B3");
+ byte[] horseValue = Hex.decode("B4B5B6");
+
+ repository.addStorageRow(cow, new DataWord(cowKey), new DataWord(cowValue));
+ repository.addStorageRow(horse, new DataWord(horseKey), new DataWord(horseValue));
+
+ assertEquals(new DataWord(cowValue), repository.getStorageValue(cow, new DataWord(cowKey)));
+ assertEquals(new DataWord(horseValue), repository.getStorageValue(horse, new DataWord(horseKey)));
+
+ repository.close();
+ }
+
+
+ @Test
+ public void test5() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repository = new RepositoryImpl(new LevelDbDataSource(), new LevelDbDataSource());
+ Repository track = repository.startTracking();
+
+ byte[] cow = Hex.decode("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826");
+ byte[] horse = Hex.decode("13978AEE95F38490E9769C39B2773ED763D9CD5F");
+
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+
+ track.increaseNonce(horse);
+
+ track.commit();
+
+ assertEquals(BigInteger.TEN, repository.getNonce(cow));
+ assertEquals(BigInteger.ONE, repository.getNonce(horse));
+
+ repository.close();
+ }
+
+ @Test
+ public void test6() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repository = new RepositoryImpl(new LevelDbDataSource(), new LevelDbDataSource());
+ Repository track = repository.startTracking();
+
+ byte[] cow = Hex.decode("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826");
+ byte[] horse = Hex.decode("13978AEE95F38490E9769C39B2773ED763D9CD5F");
+
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+ track.increaseNonce(cow);
+
+ track.increaseNonce(horse);
+
+ assertEquals(BigInteger.TEN, track.getNonce(cow));
+ assertEquals(BigInteger.ONE, track.getNonce(horse));
+
+ track.rollback();
+
+ assertEquals(BigInteger.ZERO, repository.getNonce(cow));
+ assertEquals(BigInteger.ZERO, repository.getNonce(horse));
+
+ repository.close();
+ }
+
+ @Test
+ public void test7() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repository = new RepositoryImpl(new LevelDbDataSource(), new LevelDbDataSource());
+ Repository track = repository.startTracking();
+
+ byte[] cow = Hex.decode("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826");
+ byte[] horse = Hex.decode("13978AEE95F38490E9769C39B2773ED763D9CD5F");
+
+ track.addBalance(cow, BigInteger.TEN);
+ track.addBalance(horse, BigInteger.ONE);
+
+ assertEquals(BigInteger.TEN, track.getBalance(cow));
+ assertEquals(BigInteger.ONE, track.getBalance(horse));
+
+ track.commit();
+
+ assertEquals(BigInteger.TEN, repository.getBalance(cow));
+ assertEquals(BigInteger.ONE, repository.getBalance(horse));
+
+ repository.close();
+ }
+
+
+ @Test
+ public void test8() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repository = new RepositoryImpl(new LevelDbDataSource(), new LevelDbDataSource());
+ Repository track = repository.startTracking();
+
+ byte[] cow = Hex.decode("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826");
+ byte[] horse = Hex.decode("13978AEE95F38490E9769C39B2773ED763D9CD5F");
+
+ track.addBalance(cow, BigInteger.TEN);
+ track.addBalance(horse, BigInteger.ONE);
+
+ assertEquals(BigInteger.TEN, track.getBalance(cow));
+ assertEquals(BigInteger.ONE, track.getBalance(horse));
+
+ track.rollback();
+
+ assertEquals(BigInteger.ZERO, repository.getBalance(cow));
+ assertEquals(BigInteger.ZERO, repository.getBalance(horse));
+
+ repository.close();
+ }
+
+ @Test
+ public void test9() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repository = new RepositoryImpl(new LevelDbDataSource(), new LevelDbDataSource());
+ Repository track = repository.startTracking();
+
+ byte[] cow = Hex.decode("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826");
+ byte[] horse = Hex.decode("13978AEE95F38490E9769C39B2773ED763D9CD5F");
+
+ DataWord cowKey = new DataWord(Hex.decode("A1A2A3"));
+ DataWord cowValue = new DataWord(Hex.decode("A4A5A6"));
+
+ DataWord horseKey = new DataWord(Hex.decode("B1B2B3"));
+ DataWord horseValue = new DataWord(Hex.decode("B4B5B6"));
+
+ track.addStorageRow(cow, cowKey, cowValue);
+ track.addStorageRow(horse, horseKey, horseValue);
+
+ assertEquals(cowValue, track.getStorageValue(cow, cowKey));
+ assertEquals(horseValue, track.getStorageValue(horse, horseKey));
+
+ track.commit();
+
+ assertEquals(cowValue, repository.getStorageValue(cow, cowKey));
+ assertEquals(horseValue, repository.getStorageValue(horse, horseKey));
+
+ repository.close();
+ }
+
+ @Test
+ public void test10() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repository = new RepositoryImpl(new LevelDbDataSource(), new LevelDbDataSource());
+ Repository track = repository.startTracking();
+
+ byte[] cow = Hex.decode("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826");
+ byte[] horse = Hex.decode("13978AEE95F38490E9769C39B2773ED763D9CD5F");
+
+ DataWord cowKey = new DataWord(Hex.decode("A1A2A3"));
+ DataWord cowValue = new DataWord(Hex.decode("A4A5A6"));
+
+ DataWord horseKey = new DataWord(Hex.decode("B1B2B3"));
+ DataWord horseValue = new DataWord(Hex.decode("B4B5B6"));
+
+ track.addStorageRow(cow, cowKey, cowValue);
+ track.addStorageRow(horse, horseKey, horseValue);
+
+ assertEquals(cowValue, track.getStorageValue(cow, cowKey));
+ assertEquals(horseValue, track.getStorageValue(horse, horseKey));
+
+ track.rollback();
+
+ assertEquals(null, repository.getStorageValue(cow, cowKey));
+ assertEquals(null, repository.getStorageValue(horse, horseKey));
+
+ repository.close();
+ }
+
+
+ @Test
+ public void test11() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repository = new RepositoryImpl(new LevelDbDataSource(), new LevelDbDataSource());
+ Repository track = repository.startTracking();
+
+ byte[] cow = Hex.decode("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826");
+ byte[] horse = Hex.decode("13978AEE95F38490E9769C39B2773ED763D9CD5F");
+
+ byte[] cowCode = Hex.decode("A1A2A3");
+ byte[] horseCode = Hex.decode("B1B2B3");
+
+ track.saveCode(cow, cowCode);
+ track.saveCode(horse, horseCode);
+
+ assertArrayEquals(cowCode, track.getCode(cow));
+ assertArrayEquals(horseCode, track.getCode(horse));
+
+ track.commit();
+
+ assertArrayEquals(cowCode, repository.getCode(cow));
+ assertArrayEquals(horseCode, repository.getCode(horse));
+
+ repository.close();
+ }
+
+
+ @Test
+ public void test12() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repository = new RepositoryImpl(new LevelDbDataSource(), new LevelDbDataSource());
+ Repository track = repository.startTracking();
+
+ byte[] cow = Hex.decode("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826");
+ byte[] horse = Hex.decode("13978AEE95F38490E9769C39B2773ED763D9CD5F");
+
+ byte[] cowCode = Hex.decode("A1A2A3");
+ byte[] horseCode = Hex.decode("B1B2B3");
+
+ track.saveCode(cow, cowCode);
+ track.saveCode(horse, horseCode);
+
+ assertArrayEquals(cowCode, track.getCode(cow));
+ assertArrayEquals(horseCode, track.getCode(horse));
+
+ track.rollback();
+
+ assertArrayEquals(null, repository.getCode(cow));
+ assertArrayEquals(null, repository.getCode(horse));
+
+ repository.close();
+ }
+
+ @Test // Let's upload genesis pre-mine just like in the real world
+ public void test13() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repository = new RepositoryImpl(new LevelDbDataSource(), new LevelDbDataSource());
+ Repository track = repository.startTracking();
+
+ Genesis genesis = (Genesis)Genesis.getInstance();
+ for (ByteArrayWrapper key : genesis.getPremine().keySet()) {
+ repository.createAccount(key.getData());
+ repository.addBalance(key.getData(), genesis.getPremine().get(key).getBalance());
+ }
+
+ track.commit();
+
+ assertArrayEquals(Genesis.getInstance().getStateRoot(), repository.getRoot());
+
+ repository.close();
+ }
+
+
+ @Test
+ public void test14() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repository = new RepositoryImpl(new LevelDbDataSource(), new LevelDbDataSource());
+
+ byte[] cow = Hex.decode("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826");
+ byte[] horse = Hex.decode("13978AEE95F38490E9769C39B2773ED763D9CD5F");
+ final BigInteger ELEVEN = BigInteger.TEN.add(BigInteger.ONE);
+
+
+ // changes level_1
+ Repository track1 = repository.startTracking();
+ track1.addBalance(cow, BigInteger.TEN);
+ track1.addBalance(horse, BigInteger.ONE);
+
+ assertEquals(BigInteger.TEN, track1.getBalance(cow));
+ assertEquals(BigInteger.ONE, track1.getBalance(horse));
+
+
+ // changes level_2
+ Repository track2 = track1.startTracking();
+ track2.addBalance(cow, BigInteger.ONE);
+ track2.addBalance(horse, BigInteger.TEN);
+
+ assertEquals(ELEVEN, track2.getBalance(cow));
+ assertEquals(ELEVEN, track2.getBalance(horse));
+
+ track2.commit();
+ track1.commit();
+
+ assertEquals(ELEVEN, repository.getBalance(cow));
+ assertEquals(ELEVEN, repository.getBalance(horse));
+
+ repository.close();
+ }
+
+
+ @Test
+ public void test15() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repository = new RepositoryImpl(new LevelDbDataSource(), new LevelDbDataSource());
+
+ byte[] cow = Hex.decode("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826");
+ byte[] horse = Hex.decode("13978AEE95F38490E9769C39B2773ED763D9CD5F");
+ final BigInteger ELEVEN = BigInteger.TEN.add(BigInteger.ONE);
+
+
+ // changes level_1
+ Repository track1 = repository.startTracking();
+ track1.addBalance(cow, BigInteger.TEN);
+ track1.addBalance(horse, BigInteger.ONE);
+
+ assertEquals(BigInteger.TEN, track1.getBalance(cow));
+ assertEquals(BigInteger.ONE, track1.getBalance(horse));
+
+ // changes level_2
+ Repository track2 = track1.startTracking();
+ track2.addBalance(cow, BigInteger.ONE);
+ track2.addBalance(horse, BigInteger.TEN);
+
+ assertEquals(ELEVEN, track2.getBalance(cow));
+ assertEquals(ELEVEN, track2.getBalance(horse));
+
+ track2.rollback();
+ track1.commit();
+
+ assertEquals(BigInteger.TEN, repository.getBalance(cow));
+ assertEquals(BigInteger.ONE, repository.getBalance(horse));
+
+ repository.close();
+ }
+
+
+ @Test
+ public void test16() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repository = new RepositoryImpl(new LevelDbDataSource(), new LevelDbDataSource());
+
+ byte[] cow = Hex.decode("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826");
+ byte[] horse = Hex.decode("13978AEE95F38490E9769C39B2773ED763D9CD5F");
+
+ byte[] cowKey1 = "key-c-1".getBytes();
+ byte[] cowValue1 = "val-c-1".getBytes();
+
+ byte[] horseKey1 = "key-h-1".getBytes();
+ byte[] horseValue1 = "val-h-1".getBytes();
+
+ byte[] cowKey2 = "key-c-2".getBytes();
+ byte[] cowValue2 = "val-c-2".getBytes();
+
+ byte[] horseKey2 = "key-h-2".getBytes();
+ byte[] horseValue2 = "val-h-2".getBytes();
+
+ // changes level_1
+ Repository track1 = repository.startTracking();
+ track1.addStorageRow(cow, new DataWord(cowKey1), new DataWord(cowValue1));
+ track1.addStorageRow(horse, new DataWord(horseKey1), new DataWord(horseValue1));
+
+ assertEquals(new DataWord(cowValue1), track1.getStorageValue(cow, new DataWord(cowKey1)));
+ assertEquals(new DataWord(horseValue1), track1.getStorageValue(horse, new DataWord(horseKey1)));
+
+ // changes level_2
+ Repository track2 = track1.startTracking();
+ track2.addStorageRow(cow, new DataWord(cowKey2), new DataWord(cowValue2));
+ track2.addStorageRow(horse, new DataWord(horseKey2), new DataWord(horseValue2));
+
+ assertEquals(new DataWord(cowValue1), track2.getStorageValue(cow, new DataWord(cowKey1)));
+ assertEquals(new DataWord(horseValue1), track2.getStorageValue(horse, new DataWord(horseKey1)));
+
+ assertEquals(new DataWord(cowValue2), track2.getStorageValue(cow, new DataWord(cowKey2)));
+ assertEquals(new DataWord(horseValue2), track2.getStorageValue(horse, new DataWord(horseKey2)));
+
+ track2.commit();
+ // leaving level_2
+
+ assertEquals(new DataWord(cowValue1), track1.getStorageValue(cow, new DataWord(cowKey1)));
+ assertEquals(new DataWord(horseValue1), track1.getStorageValue(horse, new DataWord(horseKey1)));
+
+ assertEquals(new DataWord(cowValue2), track1.getStorageValue(cow, new DataWord(cowKey2)));
+ assertEquals(new DataWord(horseValue2), track1.getStorageValue(horse, new DataWord(horseKey2)));
+
+
+ track1.commit();
+ // leaving level_1
+
+ assertEquals(new DataWord(cowValue1), repository.getStorageValue(cow, new DataWord(cowKey1)));
+ assertEquals(new DataWord(horseValue1), repository.getStorageValue(horse, new DataWord(horseKey1)));
+
+ assertEquals(new DataWord(cowValue2), repository.getStorageValue(cow, new DataWord(cowKey2)));
+ assertEquals(new DataWord(horseValue2), repository.getStorageValue(horse, new DataWord(horseKey2)));
+
+ repository.close();
+ }
+
+
+ @Test
+ public void test17() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repository = new RepositoryImpl(new LevelDbDataSource(), new LevelDbDataSource());
+
+ byte[] cow = Hex.decode("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826");
+
+ byte[] cowKey1 = "key-c-1".getBytes();
+ byte[] cowValue1 = "val-c-1".getBytes();
+
+ // changes level_1
+ Repository track1 = repository.startTracking();
+
+ // changes level_2
+ Repository track2 = track1.startTracking();
+ track2.addStorageRow(cow, new DataWord(cowKey1), new DataWord(cowValue1));
+ assertEquals(new DataWord(cowValue1), track2.getStorageValue(cow, new DataWord(cowKey1)));
+ track2.rollback();
+ // leaving level_2
+
+ track1.commit();
+ // leaving level_1
+
+ Assert.assertEquals(Hex.toHexString(HashUtil.EMPTY_TRIE_HASH), Hex.toHexString(repository.getRoot()));
+ repository.close();
+ }
+
+ @Test
+ public void test18() {
+
+ SystemProperties.CONFIG.setDataBaseDir("test_db/" + RepositoryTest.class);
+ Repository repoTrack = new RepositoryTrack(); // dummy
+ Repository repoTrack2 = repoTrack.startTracking(); //track
+
+ byte[] cow = Hex.decode("CD2A3D9F938E13CD947EC05ABC7FE734DF8DD826");
+ byte[] horse = Hex.decode("13978AEE95F38490E9769C39B2773ED763D9CD5F");
+ byte[] pig = Hex.decode("F0B8C9D84DD2B877E0B952130B73E218106FEC04");
+ byte[] precompiled = Hex.decode("0000000000000000000000000000000000000002");
+
+ byte[] cowCode = Hex.decode("A1A2A3");
+ byte[] horseCode = Hex.decode("B1B2B3");
+
+ repoTrack.saveCode(cow, cowCode);
+ repoTrack.saveCode(horse, horseCode);
+
+ repoTrack.delete(horse);
+
+ assertEquals(true, repoTrack2.isExist(cow));
+ assertEquals(false, repoTrack2.isExist(horse));
+ assertEquals(false, repoTrack2.isExist(pig));
+ assertEquals(false, repoTrack2.isExist(precompiled));
+ }
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/db/TrackDatabaseTest.java b/ethereumj-core/src/test/java/org/ethereum/db/TrackDatabaseTest.java
new file mode 100644
index 00000000..5b8f4476
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/db/TrackDatabaseTest.java
@@ -0,0 +1,65 @@
+package org.ethereum.db;
+
+import org.ethereum.datasource.KeyValueDataSource;
+import org.ethereum.datasource.LevelDbDataSource;
+
+import org.iq80.leveldb.Options;
+
+import org.junit.AfterClass;
+import org.junit.Test;
+
+import org.spongycastle.util.encoders.Hex;
+
+import java.io.File;
+import java.io.IOException;
+
+import static org.iq80.leveldb.impl.Iq80DBFactory.factory;
+import static org.junit.Assert.*;
+
+/**
+ * @author Roman Mandeleil
+ * @since 11.06.2014
+ */
+public class TrackDatabaseTest {
+
+ @Test
+ public void test1() {
+
+ KeyValueDataSource keyValueDataSource = new LevelDbDataSource("temp");
+ keyValueDataSource.init();
+
+ DatabaseImpl db1 = new DatabaseImpl(keyValueDataSource);
+ TrackDatabase trackDatabase1 = new TrackDatabase(db1);
+
+ trackDatabase1.put(Hex.decode("abcdef"), Hex.decode("abcdef"));
+ byte[] value = trackDatabase1.get(Hex.decode("abcdef"));
+ assertEquals("abcdef", Hex.toHexString(value));
+
+ trackDatabase1.startTrack();
+ trackDatabase1.put(Hex.decode("abcdef"), Hex.decode("ffffff"));
+ value = trackDatabase1.get(Hex.decode("abcdef"));
+ assertEquals("ffffff", Hex.toHexString(value));
+
+ trackDatabase1.rollbackTrack();
+ value = trackDatabase1.get(Hex.decode("abcdef"));
+ assertEquals("abcdef", Hex.toHexString(value));
+
+ trackDatabase1.startTrack();
+ trackDatabase1.put(Hex.decode("abcdef"), Hex.decode("ffffff"));
+ trackDatabase1.commitTrack();
+ value = trackDatabase1.get(Hex.decode("abcdef"));
+ assertEquals("ffffff", Hex.toHexString(value));
+
+ db1.close();
+ }
+
+ @AfterClass
+ public static void destroyDB() {
+ try {
+ Options options = new Options();
+ factory.destroy(new File("temp"), options);
+ } catch (IOException e) {
+ fail("Destroying temp-db failed");
+ }
+ }
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/di/components/TestEthereumComponent.java b/ethereumj-core/src/test/java/org/ethereum/di/components/TestEthereumComponent.java
new file mode 100644
index 00000000..ef004c4e
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/di/components/TestEthereumComponent.java
@@ -0,0 +1,24 @@
+package org.ethereum.di.components;
+
+import org.ethereum.di.modules.EthereumModule;
+import org.ethereum.facade.Ethereum;
+import org.ethereum.listener.EthereumListener;
+import org.ethereum.manager.WorldManager;
+import org.ethereum.net.server.ChannelManager;
+
+import javax.inject.Singleton;
+
+import dagger.Component;
+
+@Singleton
+@Component(modules = EthereumModule.class)
+public interface TestEthereumComponent {
+
+ void inject(ChannelManager channelManager);
+ void inject(WorldManager worldManager);
+
+ Ethereum ethereum();
+ EthereumListener listener();
+ ChannelManager channelManager();
+ WorldManager worldManager();
+}
\ No newline at end of file
diff --git a/ethereumj-core/src/test/java/org/ethereum/di/modules/TestEthereumModule.java b/ethereumj-core/src/test/java/org/ethereum/di/modules/TestEthereumModule.java
new file mode 100644
index 00000000..1b7365b8
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/di/modules/TestEthereumModule.java
@@ -0,0 +1,160 @@
+package org.ethereum.di.modules;
+
+import org.ethereum.config.SystemProperties;
+import org.ethereum.core.BlockchainImpl;
+import org.ethereum.core.Wallet;
+import org.ethereum.datasource.LevelDbDataSource;
+import org.ethereum.db.BlockStore;
+import org.ethereum.db.InMemoryBlockStore;
+import org.ethereum.db.RepositoryImpl;
+import org.ethereum.facade.Blockchain;
+import org.ethereum.facade.Ethereum;
+import org.ethereum.facade.EthereumImpl;
+import org.ethereum.facade.Repository;
+import org.ethereum.listener.CompositeEthereumListener;
+import org.ethereum.listener.EthereumListener;
+import org.ethereum.manager.AdminInfo;
+import org.ethereum.manager.BlockLoader;
+import org.ethereum.manager.WorldManager;
+import org.ethereum.net.MessageQueue;
+import org.ethereum.net.client.PeerClient;
+import org.ethereum.net.eth.EthHandler;
+import org.ethereum.net.p2p.P2pHandler;
+import org.ethereum.net.peerdiscovery.DiscoveryChannel;
+import org.ethereum.net.peerdiscovery.PeerDiscovery;
+import org.ethereum.net.peerdiscovery.WorkerThread;
+import org.ethereum.net.server.ChannelManager;
+import org.ethereum.net.server.EthereumChannelInitializer;
+import org.ethereum.net.shh.ShhHandler;
+import org.ethereum.net.wire.MessageCodec;
+import org.ethereum.vm.ProgramInvokeFactory;
+import org.ethereum.vm.ProgramInvokeFactoryImpl;
+
+import javax.inject.Provider;
+import javax.inject.Singleton;
+
+import dagger.Module;
+import dagger.Provides;
+
+@Module
+public class TestEthereumModule {
+
+ public TestEthereumModule() {
+
+ }
+
+ @Provides
+ @Singleton
+ Ethereum provideEthereum(WorldManager worldManager, AdminInfo adminInfo, ChannelManager channelManager,
+ BlockLoader blockLoader, Provider peerClientProvider, EthereumListener listener) {
+ return new EthereumImpl(worldManager, adminInfo, channelManager, blockLoader, peerClientProvider, listener);
+ }
+
+ @Provides
+ @Singleton
+ WorldManager provideWorldManager(Blockchain blockchain, Repository repository, Wallet wallet, PeerDiscovery peerDiscovery
+ ,BlockStore blockStore, ChannelManager channelManager, AdminInfo adminInfo, EthereumListener listener) {
+ return new WorldManager(blockchain, repository, wallet, peerDiscovery, blockStore, channelManager, adminInfo, listener);
+ }
+
+ @Provides
+ @Singleton
+ Blockchain provideBlockchain(BlockStore blockStore, Repository repository,
+ Wallet wallet, AdminInfo adminInfo,
+ EthereumListener listener, ChannelManager channelManager) {
+ return new BlockchainImpl(blockStore, repository, wallet, adminInfo, listener, channelManager);
+ }
+
+ @Provides
+ @Singleton
+ BlockStore provideBlockStore() {
+ return new InMemoryBlockStore();
+ }
+
+ @Provides
+ @Singleton
+ Repository provideRepository() {
+ LevelDbDataSource detailsDS = new LevelDbDataSource();
+ LevelDbDataSource stateDS = new LevelDbDataSource();
+ return new RepositoryImpl(detailsDS, stateDS);
+ }
+
+ @Provides
+ @Singleton
+ AdminInfo provideAdminInfo() {
+ return new AdminInfo();
+ }
+
+ @Provides
+ @Singleton
+ EthereumListener provideEthereumListener() {
+ return new CompositeEthereumListener();
+ }
+
+ @Provides
+ @Singleton
+ PeerDiscovery providePeerDiscovery() {
+ return new PeerDiscovery();
+ }
+
+ @Provides
+ @Singleton
+ ChannelManager provideChannelManager(EthereumListener listener) {
+ return new ChannelManager(listener);
+ }
+
+ @Provides
+ @Singleton
+ BlockLoader provideBlockLoader(Blockchain blockchain) {
+ return new BlockLoader(blockchain);
+ }
+
+ @Provides
+ @Singleton
+ ProgramInvokeFactory provideProgramInvokeFactory() {
+ return new ProgramInvokeFactoryImpl();
+ }
+
+ @Provides
+ EthHandler provideEthHandler(Blockchain blockchain, EthereumListener listener, Wallet wallet) {
+ return new EthHandler(blockchain, listener, wallet);
+ }
+
+ @Provides
+ ShhHandler provideShhHandler(EthereumListener listener) {
+ return new ShhHandler(listener);
+ }
+
+ @Provides
+ P2pHandler provideP2pHandler(PeerDiscovery peerDiscovery, EthereumListener listener) {
+ return new P2pHandler(peerDiscovery, listener);
+ }
+
+ @Provides
+ MessageCodec provideMessageCodec(EthereumListener listener) {
+ return new MessageCodec(listener);
+ }
+
+ @Provides
+ PeerClient providePeerClient(EthereumListener listener, ChannelManager channelManager,
+ Provider ethereumChannelInitializerProvider) {
+ return new PeerClient(listener, channelManager, ethereumChannelInitializerProvider);
+ }
+
+ @Provides
+ MessageQueue provideMessageQueue(EthereumListener listener) {
+ return new MessageQueue(listener);
+ }
+
+ @Provides
+ WorkerThread provideWorkerThread(Provider discoveryChannelProvider) {
+ return new WorkerThread(discoveryChannelProvider);
+ }
+
+ @Provides
+ String provideRemoteId() {
+ return SystemProperties.CONFIG.activePeerNodeid();
+ }
+
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubBlockTest.java b/ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubBlockTest.java
new file mode 100644
index 00000000..39f47b66
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubBlockTest.java
@@ -0,0 +1,112 @@
+package org.ethereum.jsontestsuite;
+
+import org.json.simple.parser.ParseException;
+import org.junit.FixMethodOrder;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import java.io.IOException;
+import java.util.Set;
+import java.util.HashSet;
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class GitHubBlockTest {
+
+ //SHACOMMIT of tested commit, ethereum/tests.git
+ public String shacommit = "d2ba02fe0507da205e3d17d79612ae15282b35a2";
+
+ @Ignore
+ @Test
+ public void runSingleTest() throws ParseException, IOException {
+ String json = JSONReader.loadJSONFromCommit("BlockTests/bcUncleTest.json", shacommit);
+ GitHubJSONTestSuite.runGitHubJsonSingleBlockTest(json, "oneUncleGeneration7");
+ }
+
+
+ @Ignore
+ @Test
+ public void runBCBlockChainTest() throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("BlockTests/bcInvalidHeaderTest.json", shacommit);
+ //TODO fix via blockchain rollbacks
+ excluded.add("wrongGasUsed");
+ excluded.add("wrongStateRoot");
+ //TODO need to make sure the checks match the cpp
+ //excluded.add("wrongParentHash");
+ //excluded.add("wrongTimestamp");
+ //TODO need to add some way to roll back repository from BlockChain.add()
+ excluded.add("wrongReceiptTrie");
+ excluded.add("log1_wrongBloom");
+
+ GitHubJSONTestSuite.runGitHubJsonBlockTest(json,excluded);
+ }
+
+ @Ignore
+ @Test
+ public void runBCInvalidRLPTest() throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("BlockTests/bcInvalidRLPTest.json", shacommit);
+ excluded.add("BLOCK_stateRoot_GivenAsList");
+ excluded.add("BLOCK_difficulty_GivenAsList");
+ excluded.add("BLOCK_mixHash_TooShort");
+ excluded.add("BLOCK__RandomByteAtRLP_8");
+ excluded.add("BLOCK__RandomByteAtRLP_9");
+ excluded.add("BLOCK__RandomByteAtRLP_7");
+ excluded.add("BLOCK__RandomByteAtRLP_6");
+ excluded.add("BLOCK__RandomByteAtRLP_5");
+ excluded.add("BLOCK__RandomByteAtRLP_4");
+ excluded.add("BLOCK_stateRoot_TooShort");
+ excluded.add("BLOCK_gasUsed_TooLarge");
+ excluded.add("BLOCK_stateRoot_TooLarge");
+ excluded.add("BLOCK_receiptTrie_Prefixed0000");
+ excluded.add("BLOCK_transactionsTrie_TooLarge");
+ excluded.add("TRANSCT_gasLimit_Prefixed0000");
+ excluded.add("TRANSCT_gasLimit_GivenAsList");
+ excluded.add("TRANSCT_svalue_TooLarge");
+ excluded.add("TRANSCT_svalue_TooShort");
+ excluded.add("TRANSCT_svalue_GivenAsList");
+ excluded.add("TRANSCT__RandomByteAtTheEnd");
+ //GitHubJSONTestSuite.runGitHubJsonBlockTest(json, excluded);
+ GitHubJSONTestSuite.runGitHubJsonSingleBlockTest(json, "TRANSCT__RandomByteAtTheEnd");
+ }
+
+ @Ignore
+ @Test
+ public void runBCJSAPITest() throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("BlockTests/bcJS_API_Test.json", shacommit);
+ excluded.add("JS_API_Tests");
+ GitHubJSONTestSuite.runGitHubJsonBlockTest(json, excluded);
+ }
+
+ //@Ignore
+ @Test
+ public void runBCUncleHeaderValidityTest() throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("BlockTests/bcUncleHeaderValiditiy.json", shacommit);
+ //TODO need to make sure these are not passing on accident
+ //excluded.add("timestampTooLow");
+ //excluded.add("timestampTooHigh");
+ //excluded.add("wrongParentHash");
+ GitHubJSONTestSuite.runGitHubJsonBlockTest(json, excluded);
+ }
+
+ //@Ignore
+ @Test
+ public void runBCUncleTest() throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("BlockTests/bcUncleTest.json", shacommit);
+ GitHubJSONTestSuite.runGitHubJsonBlockTest(json, excluded);
+ }
+
+ //@Ignore
+ @Test
+ public void runBCValidBlockTest() throws ParseException, IOException {
+ String json = JSONReader.loadJSONFromCommit("BlockTests/bcValidBlockTest.json", shacommit);
+ GitHubJSONTestSuite.runGitHubJsonBlockTest(json);
+ }
+
+
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubCryptoTest.java b/ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubCryptoTest.java
new file mode 100644
index 00000000..aa6018ca
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubCryptoTest.java
@@ -0,0 +1,40 @@
+package org.ethereum.jsontestsuite;
+
+import org.codehaus.jackson.map.ObjectMapper;
+import org.codehaus.jackson.type.JavaType;
+import org.json.simple.parser.ParseException;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import java.io.IOException;
+import java.util.HashMap;
+
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class GitHubCryptoTest {
+
+
+ @Test
+ public void testAllInCryptoSute() throws ParseException, IOException {
+
+ String json = JSONReader.loadJSON("BasicTests/crypto.json");
+
+ ObjectMapper mapper = new ObjectMapper();
+ JavaType type = mapper.getTypeFactory().
+ constructMapType(HashMap.class, String.class, CryptoTestCase.class);
+
+
+ HashMap testSuite =
+ mapper.readValue(json, type);
+
+ for (String key : testSuite.keySet()){
+
+ System.out.println("executing: " + key);
+ testSuite.get(key).execute();
+
+ }
+ }
+
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubJSONTestSuite.java b/ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubJSONTestSuite.java
new file mode 100644
index 00000000..91379a24
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubJSONTestSuite.java
@@ -0,0 +1,237 @@
+package org.ethereum.jsontestsuite;
+
+import org.ethereum.jsontestsuite.runners.StateTestRunner;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+
+import org.junit.Assert;
+import org.junit.Assume;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.*;
+
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Test file specific for tests maintained in the GitHub repository
+ * by the Ethereum DEV team.
+ *
+ * @see https://github.com/ethereum/tests/
+ */
+public class GitHubJSONTestSuite {
+
+ private static Logger logger = LoggerFactory.getLogger("TCK-Test");
+
+
+ protected static void runGitHubJsonVMTest(String json, String testName) throws ParseException {
+ Assume.assumeFalse("Online test is not available", json.equals(""));
+
+ JSONParser parser = new JSONParser();
+ JSONObject testSuiteObj = (JSONObject) parser.parse(json);
+
+ TestSuite testSuite = new TestSuite(testSuiteObj);
+ Iterator testIterator = testSuite.iterator();
+
+ for (TestCase testCase : testSuite.getAllTests()) {
+
+ String prefix = " ";
+ if (testName.equals(testCase.getName())) prefix = " => ";
+
+ logger.info(prefix + testCase.getName());
+ }
+
+ while (testIterator.hasNext()) {
+
+ TestCase testCase = testIterator.next();
+ if (testName.equals((testCase.getName()))) {
+ TestRunner runner = new TestRunner();
+ List result = runner.runTestCase(testCase);
+ Assert.assertTrue(result.isEmpty());
+ return;
+ }
+ }
+ }
+
+ protected static void runGitHubJsonVMTest(String json) throws ParseException {
+ Set excluded = new HashSet<>();
+ runGitHubJsonVMTest(json, excluded);
+ }
+
+
+ protected static void runGitHubJsonVMTest(String json, Set excluded) throws ParseException {
+ Assume.assumeFalse("Online test is not available", json.equals(""));
+
+ JSONParser parser = new JSONParser();
+ JSONObject testSuiteObj = (JSONObject) parser.parse(json);
+
+ TestSuite testSuite = new TestSuite(testSuiteObj);
+ Iterator testIterator = testSuite.iterator();
+
+ for (TestCase testCase : testSuite.getAllTests()) {
+
+ String prefix = " ";
+ if (excluded.contains(testCase.getName())) prefix = "[X] ";
+
+ logger.info(prefix + testCase.getName());
+ }
+
+
+ while (testIterator.hasNext()) {
+
+ TestCase testCase = testIterator.next();
+ if (excluded.contains(testCase.getName()))
+ continue;
+
+ TestRunner runner = new TestRunner();
+ List result = runner.runTestCase(testCase);
+ Assert.assertTrue(result.isEmpty());
+ }
+ }
+
+
+ protected static void runGitHubJsonSingleBlockTest(String json, String testName) throws ParseException, IOException {
+
+ BlockTestSuite testSuite = new BlockTestSuite(json);
+ Set testCollection = testSuite.getTestCases().keySet();
+
+ for (String testCase : testCollection) {
+ if (testCase.equals(testName))
+ logger.info(" => " + testCase);
+ else
+ logger.info(" " + testCase);
+ }
+
+ runSingleBlockTest(testSuite, testName);
+ }
+
+
+ protected static void runGitHubJsonBlockTest(String json, Set excluded) throws ParseException, IOException {
+ Assume.assumeFalse("Online test is not available", json.equals(""));
+
+ BlockTestSuite testSuite = new BlockTestSuite(json);
+ Set testCollection = testSuite.getTestCases().keySet();
+
+ for (String testName : testCollection) {
+
+ if ( excluded.contains(testName)) {
+ logger.info(" Not running: " + testName);
+ continue;
+ }
+
+ runSingleBlockTest(testSuite, testName);
+ }
+ }
+
+ protected static void runGitHubJsonBlockTest(String json) throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ runGitHubJsonBlockTest(json, excluded);
+ }
+
+ private static void runSingleBlockTest(BlockTestSuite testSuite, String testName){
+
+ BlockTestCase blockTestCase = testSuite.getTestCases().get(testName);
+ TestRunner runner = new TestRunner();
+
+ logger.info("\n\n ***************** Running test: {} ***************************** \n\n", testName);
+ List result = runner.runTestCase(blockTestCase);
+
+ if (!result.isEmpty())
+ for (String single : result)
+ logger.info(single);
+
+ Assert.assertTrue(result.isEmpty());
+ logger.info(" \n\n *********************** Passed: " + testName + " ************************** \n\n");
+
+ }
+
+
+ public static void runStateTest(String jsonSuite) throws IOException {
+ runStateTest(jsonSuite, new HashSet());
+ }
+
+
+ public static void runStateTest(String jsonSuite, String testName) throws IOException {
+
+ StateTestSuite stateTestSuite = new StateTestSuite(jsonSuite);
+ Map testCases = stateTestSuite.getTestCases();
+
+ for (String testCase : testCases.keySet()) {
+ if (testCase.equals(testName))
+ logger.info(" => " + testCase);
+ else
+ logger.info(" " + testCase);
+ }
+
+ StateTestCase testCase = testCases.get(testName);
+ if (testCase != null){
+ String output = String.format("* running: %s *", testName);
+ String line = output.replaceAll(".", "*");
+
+ logger.info(line);
+ logger.info(output);
+ logger.info(line);
+ List fails = StateTestRunner.run(testCases.get(testName));
+
+ Assert.assertTrue(fails.size() == 0);
+
+ } else {
+ logger.error("Sorry test case doesn't exist: {}", testName);
+ }
+ }
+
+ public static void runStateTest(String jsonSuite, Set excluded) throws IOException {
+
+ StateTestSuite stateTestSuite = new StateTestSuite(jsonSuite);
+ Map testCases = stateTestSuite.getTestCases();
+ Map summary = new HashMap<>();
+
+
+ for (String testCase : testCases.keySet()) {
+ if ( excluded.contains(testCase))
+ logger.info(" [X] " + testCase);
+ else
+ logger.info(" " + testCase);
+ }
+
+ Set testNames = stateTestSuite.getTestCases().keySet();
+ for (String testName : testNames){
+
+ if (excluded.contains(testName)) continue;
+ String output = String.format("* running: %s *", testName);
+ String line = output.replaceAll(".", "*");
+
+ logger.info(line);
+ logger.info(output);
+ logger.info(line);
+
+ List result = StateTestRunner.run(testCases.get(testName));
+ if (!result.isEmpty())
+ summary.put(testName, false);
+ else
+ summary.put(testName, true);
+ }
+
+ logger.info("Summary: ");
+ logger.info("=========");
+
+ int fails = 0; int pass = 0;
+ for (String key : summary.keySet()){
+
+ if (summary.get(key)) ++pass; else ++fails;
+ String sumTest = String.format("%-60s:^%s", key, (summary.get(key) ? "PASS" : "FAIL")).
+ replace(' ', '.').
+ replace("^", " ");
+ logger.info(sumTest);
+ }
+
+ logger.info(" - Total: Pass: {}, Failed: {} - ", pass, fails);
+
+ Assert.assertTrue(fails == 0);
+ }
+
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubStateTest.java b/ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubStateTest.java
new file mode 100644
index 00000000..500a5181
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubStateTest.java
@@ -0,0 +1,176 @@
+package org.ethereum.jsontestsuite;
+
+import org.json.simple.parser.ParseException;
+
+import org.junit.FixMethodOrder;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.ethereum.jsontestsuite.JSONReader.getFileNamesForTreeSha;
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class GitHubStateTest {
+
+ //SHACOMMIT of tested commit, ethereum/tests.git
+ public String shacommit = "d2ba02fe0507da205e3d17d79612ae15282b35a2";
+
+
+ @Ignore
+ @Test // this method is mostly for hands-on convenient testing
+ public void stSingleTest() throws ParseException, IOException {
+ String json = JSONReader.loadJSONFromCommit("StateTests/stMemoryTest.json", shacommit);
+ GitHubJSONTestSuite.runStateTest(json, "stackLimitPush32_1025");
+ }
+
+ @Test
+ public void stExample() throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("StateTests/stExample.json", shacommit);
+ GitHubJSONTestSuite.runStateTest(json, excluded);
+ }
+
+ @Test
+ public void stCallCreateCallCodeTest() throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ excluded.add("createJS_ExampleContract"); //FIXME Bug on CPP testrunner, storage/SSTORE
+ excluded.add("Callcode1024OOG");
+ excluded.add("Call1024OOG");
+ excluded.add("callcodeWithHighValue");
+ excluded.add("callWithHighValue");
+ String json = JSONReader.loadJSONFromCommit("StateTests/stCallCreateCallCodeTest.json", shacommit);
+ GitHubJSONTestSuite.runStateTest(json, excluded);
+ }
+
+ @Test
+ public void stInitCodeTest() throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("StateTests/stInitCodeTest.json", shacommit);
+ GitHubJSONTestSuite.runStateTest(json, excluded);
+ }
+
+ @Test
+ public void stLogTests() throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("StateTests/stLogTests.json", shacommit);
+ GitHubJSONTestSuite.runStateTest(json, excluded);
+ }
+
+ @Test
+ public void stPreCompiledContracts() throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("StateTests/stPreCompiledContracts.json", shacommit);
+ GitHubJSONTestSuite.runStateTest(json, excluded);
+ }
+
+ @Test
+ public void stMemoryStressTest() throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ excluded.add("mload32bitBound_return2");//FIXME memorySave must support long
+ excluded.add("mload32bitBound_return"); //FIXME memorySave must support long
+ excluded.add("mload32bitBound_Msize"); //FIXME memoryChunk must support long
+ String json = JSONReader.loadJSONFromCommit("StateTests/stMemoryStressTest.json", shacommit);
+ GitHubJSONTestSuite.runStateTest(json, excluded);
+ }
+
+ @Test
+ public void stMemoryTest() throws ParseException, IOException {
+ String json = JSONReader.loadJSONFromCommit("StateTests/stMemoryTest.json", shacommit);
+ Set excluded = new HashSet<>();
+ GitHubJSONTestSuite.runStateTest(json, excluded);
+ }
+
+ @Ignore
+ @Test
+ public void stQuadraticComplexityTest() throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("StateTests/stQuadraticComplexityTest.json", shacommit);
+ GitHubJSONTestSuite.runStateTest(json, excluded);
+ }
+
+ @Ignore
+ @Test
+ public void stSolidityTest() throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ excluded.add("TestBlockAndTransactionProperties"); //TODO proper BigInt block support needed
+ String json = JSONReader.loadJSONFromCommit("StateTests/stSolidityTest.json", shacommit);
+ GitHubJSONTestSuite.runStateTest(json, excluded);
+ }
+
+ @Test
+ public void stRecursiveCreate() throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("StateTests/stRecursiveCreate.json", shacommit);
+ GitHubJSONTestSuite.runStateTest(json, excluded);
+ }
+
+ @Test
+ public void stRefundTest() throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("StateTests/stRefundTest.json", shacommit);
+ GitHubJSONTestSuite.runStateTest(json, excluded);
+ }
+
+ @Test
+ public void stSpecialTest() throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("StateTests/stSpecialTest.json", shacommit);
+ GitHubJSONTestSuite.runStateTest(json, excluded);
+ }
+
+ @Test
+ public void stBlockHashTest() throws ParseException, IOException {
+ String json = JSONReader.loadJSONFromCommit("StateTests/stBlockHashTest.json", shacommit);
+ GitHubJSONTestSuite.runStateTest(json);
+ }
+
+ //@Ignore
+ @Test
+ public void stSystemOperationsTest() throws IOException {
+ Set excluded = new HashSet<>();
+ excluded.add("CallRecursiveBomb0_OOG_atMaxCallDepth"); //FIXME hitting VM limits
+ excluded.add("Call10"); //FIXME gaslimit as biginteger
+ excluded.add("createNameRegistratorZeroMem2"); // FIXME: Heap ???
+ String json = JSONReader.loadJSONFromCommit("StateTests/stSystemOperationsTest.json", shacommit);
+ GitHubJSONTestSuite.runStateTest(json, excluded);
+ }
+
+ @Test
+ public void stTransactionTest() throws ParseException, IOException {
+ Set excluded = new HashSet<>();
+ excluded.add("OverflowGasRequire"); //FIXME wont work until we use gaslimit as long
+ excluded.add("EmptyTransaction2"); // Buggy testcase
+ excluded.add("TransactionSendingToEmpty");
+ String json = JSONReader.loadJSONFromCommit("StateTests/stTransactionTest.json", shacommit);
+ GitHubJSONTestSuite.runStateTest(json, excluded);
+ }
+
+ @Test // testing full suite
+ public void testRandomStateGitHub() throws ParseException, IOException {
+
+ String sha = "99db6f4f5fea3aa5cfbe8436feba8e213d06d1e8";
+ List fileNames = getFileNamesForTreeSha(sha);
+ List includedFiles =
+ Arrays.asList(
+ "st201504081841JAVA.json",
+ "st201504081842JAVA.json",
+ "st201504081843JAVA.json"
+ );
+
+ for (String fileName : fileNames) {
+ if (includedFiles.contains(fileName)) {
+ System.out.println("Running: " + fileName);
+ String json = JSONReader.loadJSON("StateTests//RandomTests/" + fileName);
+ GitHubJSONTestSuite.runStateTest(json);
+ }
+ }
+
+ }
+}
+
diff --git a/ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubVMTest.java b/ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubVMTest.java
new file mode 100644
index 00000000..82e73f02
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubVMTest.java
@@ -0,0 +1,168 @@
+package org.ethereum.jsontestsuite;
+
+import org.json.simple.parser.ParseException;
+import org.junit.FixMethodOrder;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import static org.ethereum.jsontestsuite.JSONReader.getFileNamesForTreeSha;
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class GitHubVMTest {
+
+ //SHACOMMIT of tested commit, ethereum/tests.git
+ //Last known good commit: 5af1002b96f34cd2c9252c1a6636826d47411ccd
+ public String shacommit = "5af1002b96f34cd2c9252c1a6636826d47411ccd";
+
+ //@Ignore
+ @Test
+ public void runSingle() throws ParseException {
+ String json = JSONReader.loadJSONFromCommit("VMTests/vmEnvironmentalInfoTest.json", shacommit);
+ GitHubJSONTestSuite.runGitHubJsonVMTest(json, "balance0");
+ }
+
+ //@Ignore
+ @Test
+ public void testArithmeticFromGitHub() throws ParseException {
+ Set excluded = new HashSet<>();
+ // TODO: these are excluded due to bad wrapping behavior in ADDMOD/DataWord.add
+ excluded.add("addmod1_overflowDiff");
+ excluded.add("addmod1_overflow3");
+ excluded.add("addmodBigIntCast");
+ String json = JSONReader.loadJSONFromCommit("VMTests/vmArithmeticTest.json", shacommit);
+ //String json = JSONReader.getTestBlobForTreeSha(shacommit, "vmArithmeticTest.json");
+ GitHubJSONTestSuite.runGitHubJsonVMTest(json, excluded);
+ }
+
+ //@Ignore
+ @Test // testing full suite
+ public void testBitwiseLogicOperationFromGitHub() throws ParseException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("VMTests/vmBitwiseLogicOperationTest.json", shacommit);
+ GitHubJSONTestSuite.runGitHubJsonVMTest(json, excluded);
+ }
+
+ //@Ignore
+ @Test // testing full suite
+ public void testBlockInfoFromGitHub() throws ParseException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("VMTests/vmBlockInfoTest.json", shacommit);
+ GitHubJSONTestSuite.runGitHubJsonVMTest(json, excluded);
+ }
+
+ @Ignore
+ @Test // testing full suite
+ public void testEnvironmentalInfoFromGitHub() throws ParseException {
+ Set excluded = new HashSet<>();
+ excluded.add("env1");
+ String json = JSONReader.loadJSONFromCommit("VMTests/vmEnvironmentalInfoTest.json", shacommit);
+ GitHubJSONTestSuite.runGitHubJsonVMTest(json, excluded);
+ }
+
+ //@Ignore
+ @Test // testing full suite
+ public void testIOandFlowOperationsFromGitHub() throws ParseException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("VMTests/vmIOandFlowOperationsTest.json", shacommit);
+ GitHubJSONTestSuite.runGitHubJsonVMTest(json, excluded);
+ }
+
+ @Ignore //FIXME - 60M - need new fast downloader
+ @Test
+ public void testvmInputLimitsTest1FromGitHub() throws ParseException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("VMTests/vmInputLimits1.json", shacommit);
+ GitHubJSONTestSuite.runGitHubJsonVMTest(json, excluded);
+ }
+
+ @Ignore //FIXME - 50M - need to handle large filesizes
+ @Test
+ public void testvmInputLimitsTest2FromGitHub() throws ParseException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("VMTests/vmInputLimits2.json", shacommit);
+ GitHubJSONTestSuite.runGitHubJsonVMTest(json, excluded);
+ }
+
+ @Ignore //FIXME - 20M - possibly provide percentage indicator
+ @Test
+ public void testvmInputLimitsLightTestFromGitHub() throws ParseException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("VMTests/vmInputLimitsLight.json", shacommit);
+ GitHubJSONTestSuite.runGitHubJsonVMTest(json, excluded);
+ }
+
+ //@Ignore
+ @Test // testing full suite
+ public void testVMLogGitHub() throws ParseException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("VMTests/vmLogTest.json", shacommit);
+ GitHubJSONTestSuite.runGitHubJsonVMTest(json, excluded);
+ }
+
+ @Ignore
+ @Test // testing full suite
+ public void testPerformanceFromGitHub() throws ParseException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("VMTests/vmPerformanceTest.json", shacommit);
+ GitHubJSONTestSuite.runGitHubJsonVMTest(json, excluded);
+ }
+
+ //@Ignore
+ @Test // testing full suite
+ public void testPushDupSwapFromGitHub() throws ParseException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("VMTests/vmPushDupSwapTest.json", shacommit);
+ GitHubJSONTestSuite.runGitHubJsonVMTest(json, excluded);
+ }
+
+ //@Ignore
+ @Test // testing full suite
+ public void testShaFromGitHub() throws ParseException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("VMTests/vmSha3Test.json", shacommit);
+ GitHubJSONTestSuite.runGitHubJsonVMTest(json, excluded);
+ }
+
+ //@Ignore
+ @Test // testing full suite
+ public void testvmSystemOperationsTestGitHub() throws ParseException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("VMTests/vmSystemOperationsTest.json", shacommit);
+ GitHubJSONTestSuite.runGitHubJsonVMTest(json, excluded);
+ }
+
+ //@Ignore
+ @Test // testing full suite
+ public void testVMGitHub() throws ParseException {
+ Set excluded = new HashSet<>();
+ String json = JSONReader.loadJSONFromCommit("VMTests/vmtests.json", shacommit);
+ GitHubJSONTestSuite.runGitHubJsonVMTest(json, excluded);
+ }
+
+ //@Ignore
+ @Test // testing full suite
+ public void testRandomVMGitHub() throws ParseException {
+
+ String sha = "c5eafb85390eee59b838a93ae31bc16a5fd4f7b1";
+ List fileNames = getFileNamesForTreeSha(sha);
+ List excludedFiles =
+ Arrays.asList(
+ ""
+ );
+
+ for (String fileName : fileNames) {
+
+ if (excludedFiles.contains(fileName)) continue;
+ System.out.println("Running: " + fileName);
+ String json = JSONReader.loadJSON("VMTests//RandomTests/" + fileName);
+ GitHubJSONTestSuite.runGitHubJsonVMTest(json);
+ }
+
+ }
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/net/BlockHashesMessageTest.java b/ethereumj-core/src/test/java/org/ethereum/net/BlockHashesMessageTest.java
new file mode 100644
index 00000000..45ff90a9
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/net/BlockHashesMessageTest.java
@@ -0,0 +1,51 @@
+package org.ethereum.net;
+
+import org.ethereum.net.eth.BlockHashesMessage;
+import org.ethereum.net.eth.EthMessageCodes;
+
+import org.junit.Test;
+
+import org.spongycastle.util.encoders.Hex;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class BlockHashesMessageTest {
+
+ /* BLOCK_HASHES_MESSAGE */
+
+ @Test /* BlockHashesMessage 1 from network */
+ public void test_1() {
+
+ String blockHashesMessageRaw = "f9108114a04ee6424d776b3f59affc20bc2de59e67f36e22cc07897ff8df152242c921716ba07d2fe4df0dbbc9011da2b3bf177f0c6b7e71a11c509035c5d751efa5cf9b4817a0e32d9ac70a95a5084447143cba713ceae2cae614e79817bf76fc081480509912a07167d51e20b6bdd1457101b81300519f9eeb741008ba45ff9682912b96cc3231a05dc40186092d08fdb83e938774b318ce598ed3b44f2b0382cd8991d912135a08a08b7036a775a190094c4eb994a0e7a2f89ffa59d1f3461bd1de104f37aa0098eca0b0301705ba576e32d9e47fc5983fa49ba5e8f00e3e2d0a7e1b281a9625445ff5a033124a8da5113edff6afe4fb5efece3741895a7fba3d1c167586f4c3374f1d78a03c1aa5542d3fdafbd7b03c2085bcc940343f26b9711f8a215c4ea3f84364472fa0c959599f529ac1f085c4f9aadc0a17aad1c61311b0ad6b4e3f4a12eb3f93ad76a0eb26c71de8706185a717e21753b6e47e2d4b34e00e034f64b6c76f2de3af7f75a0e679e8b274cca37c2e449b993eb2228d062a78b4406f9323fa48fa182de640f3a0df26cd027609ad25739a041b3d9d81705b4fa73c86f6df04b836984e8b4c8489a0cfaad0dba4a266e9ccbf7474079647a4ac659d93f071091c90d454c1af48ae25a06f5232f5058b5b70fcd28070dfe716a6327b899d639cff2106b9907978c6dc7ca0ba3266b0a3877b4a81e8f6dd6c36aeb587a1a14acd10976d3ed6f686a35d8c13a08014d1ff07221b83a1996e6b80546310d430589f7cd6a9137e16f14c3a49e855a0dfce9bc6e8947b440f03a86f37ae639a4446ed27d8f56f9c7c1b00e9fc120aa2a03cfd099c3e1c974284477f6366b242372833ff6f618b4fd94d9cefb9912eaee4a085c4ac37b8a8d466dc66870838ccdec34a5df6f6548bf6c06cbb645f6980491ea0f3085b2449501113981af5274706a9dfea891fb28a6228375ba2cd28970d37fda0a63e45fcc5050d52a0eaee0a0c118e1b94c8ee6f2312e01f143f27fd360aee67a0c51c71816bf7c79475a7ebc1f1dcd6137e0950c4db57d7b947372751c114b6bea05e66b8849b5a2e90d98663c0428ca7c7483fbe8bcd1ae77f9dfd91fccb7a66ffa008a1e472e019b8f5b3b899ad1185c0fe953ee336ae3fe807cceca5e47728bcdda04700e66f3a96965ab08a7760f0ac9f15f4a282cfc09a50dce09e573e27054a3aa0c820e85e4b5bbf8f19f44e00b9ac43bbc2148f599b48c1257088616cf1909d50a0201bd78f79fded601eaa4b7484b079bf5e6214ee25b633988008ffbc2ff6fe86a033cb48d0197a0dfddd1ad4623df688784bbba4ada03a80ac560cf4f92d3eaf7fa053f100fa3088a48c17dba35efcf96a4c02a15a136d16c9b32bafff5771e969f2a0ab3db92acb1f5552c90d65efb93ba505d7390db6cfe2ddd7768282931b9d0e64a0e6cec0ca20da89288461e69d6e5eaaf466cc15feab145206a0f9e19783aab0b5a0c6bff7771c8d4d59dfe39abbc980b0e21fc68295961a0804139f10ce827e7f2da02bb1ce267a1fb3757daeebfc8ecac8ad417b66fa6a5211d3fc1cf2f6f401a048a06393a130996fce7024030531869d66ad4ed0264bc6efc34ebc246e9b739baf14a013ca792bb72a8f6f641af3d9c7ba4739181b6fbffecea9319fa3afe9185fe996a03330c6e385b275391ed715867746c8fb9eb7b6b939e9a2ca561593e54148618ba00accdcad654f4a9fdefd7a69cabc47e02a60840b93890a70b4e378189933264aa0a0e507ee34150a0cb777254a6fb5fc658d19f03fe00be84d6c2fb92eff1bf008a0319e9bc452c23f7dae6368729a6f6ce7c557a3f4c8c031902a84d07a0ad7279aa0b46e49cbe43a01deef74bb03727987822678f840f665251c4fe060c4d43cef99a0c6c820d402c873b50adc53582195f97ba4dcea02c4aac1f37680c1c5b786d3a1a070740ab0275db1cb4f06d1e7320984b3ad708dfbd999879e5bde12cda5641583a0b537199eabbf6aaa120ab4c3cbeed02311f2e2e7158b5f3a239147522d1c001aa0bdeaf137c59ee9985dcbae18410a223bd0cc061659ae76c85bff34c3831f4181a079a4d2a87b47f848524378abc99dd6b205ee19af316c8f3769f6ad870745845fa037dc76bdad66f0fb907b3244eb64c4193e3d84b4c81c0c2e006ad57866db0d48a071aaa649a631f724f95e71dd78dd97b69ab93d75082042944b76333c51bc6e85a0a22b3c6eb1b43fc1ffa79a6ff78255074cff4db7d3bbafae7ae13c3b493eeb5aa06426f3bc465d89db7fee576b1f97c97f13744dfa33561ece7e0d38bbcd34e9f0a0ff62c6aa7567b262f31fbcc794ac46bd96504ccb8f98451ea034b8aa434c6bcca06b942d48699b609829f1ecc89db076d59faec6664af3dc2b13da46d40daa9763a05f325608455045794b77a5fd8f2ed12e7cda40df2d8aeeec7e5a517b455a8157a0c054b8bd53545d78206de7fa0c8e206997d9c68f435fe06c3057f9545ba196f0a08ad94a4c53c397f3c63bffdcd790486c3f7588d155d6d86e0ff08907c7f7f682a0c3d9f991dac6c0e3ba032b6da7bc0cdc38c8c76e95a12c4f86326d09a2d69754a01b1cba8bdcbbbf02b9b876194713dfaf941f3f03bfc4a91746187e001edbb20ea0ec32df0dc1ce371c866d817f90497e620efb59b1baabe1e90f00e28fb57e1823a0d3a29747ed5cfed3467687eb63adc28bc646a5c66f610f55bb840c8e59f8b360a010bcf47b3c6c09b919db63b8e054458fad45f1dd8ca8cfda9759e5c53d90b0eba0075a78486d263b530834e88572a5e750658e263c1e3a3dc5801039101ece5ae9a0119b8487dc9ba0a2e95cb0dde90c26a70b48611baed1c9cca5ec73c161e8c98fa032c248078737a2f8542e70edf44854f87544b540a47c55292a0c718c57fa4578a0f38d4b93d2edc95ed526dc7f65d01bddbfb1e3e14f9a870bc3b23b164db62b24a030649acc70269c05316bfa3c20452ea21cff552c1e4da38e3fdde05371027660a000db5540f1ffd4d21aa351c511806e675cc3348604322c34e28970f9060e8d9fa06be5873726f8a76871141255c1332f4b1fb11906a5ab352ac1c8f262f2a0a817a0ae40366642d2f4d6b19e61978e84a27170648315bf93772bd9771f55abd61bbba0b8e6e8cb6008ae9a73a8d6b6d04e25d24e87b2f6f20a6714e59032550e37e213a0db0272777c2a5b49a89852bc5858bb531a7b37d08f72a4a5a9d109a40788d8c6a0d6fef3c812213467205f47f3edece2d74908e8cab599a5e42425520ad6b002e3a084856e32b9e8a0a4db75b4586ae492528f427fc814c2086340d942d24a1eb3bda0121bf2d712eb87605253775a4f93cd125e3c714388c74a4a5a321a43b8fe912aa0e13b4ddd63b6bd4abfff393463c62f298238d118c134328eee255b7fc191227ea01e278eab5967765720e5b791684a9dbe3d8d46e39c5dd615de92f02419a70fcda0a26ad0b4c36c77e619fe3100b9a44447c9d16a7db1780014cf6f409ee73145d7a0d113188b5bd282b9e9fd8e58df4431725ef85098db0bc845ed3a44132cc597efa0d303b816fbfcabe1c2eb6507ed886f6c35fa423d02ba0c5b38e268dafb38231aa017786974a83c2513e69451ae7a0bfed75f4fe09b194ae979a467e6f615bc08f1a07bde7299bbae3ff0178eae928f465070a88db0df33c4c3de53c681b8eaf17f1aa0d0c0e668f5bd6bd36b727688ba6212128390400ae3f00b42be3c2b587db24b75a0ee437f296d523f07de580979e598e522a05c0025ea8f79c7fbdbee0b679c3382a01cb65eaf5a15bd573d26fb4100208dd9389f87c1151bf46f77e6df8e3a113638a05c707c3a379ef1e2587dd0c60b252e8eb62992f0e6f3c2d7a964f0c6e9fbc3cda05ba3646ffacb6cf0cd648b4d471105291a217b23e118581f02ecd0b73fdb4691a0c102b0807c0f495eea1fa1000b9eedb2f692ab7e71c9dd47e83792e4153d3145a0ee15b8a5ef01c5fcfa73f29028b5310268302bcdf1a1a58a30d3027f375e08fda0d44965bf82d2c77e3e92d1c0e1091f87858c5e1b11b61db46feb57ebd7c046c5a04f34602a1e223e5e1325d3f55e0d8c10c0cacfdf490eb909c105876d62cb6912a0fbdc0438cd3cb503bff3f206cea3a02728ca7abd1b3316c5c1ed5cd59a79cc1ba00f628b7c8c50137b0c78ef962f6e6ee299b6600caa1dcd492c162041e2cfa893a0d9bb3e9b92d2246f00d2f28b544c9cd8c187d31d8a9f3d96a4368df575156d0ea0fa7159b9b87ea9943d12f4003e49c90b436a0654bb6ce6bcc979a7decc45ee1ca095052c3e80bedc1cb11aa0944fef5bcdc0e270fac53f8a416e7bad469e8cbbf6a0b83edf3de91030ee463552f8297d190b11068f5419d77c34e7e461f09443be35a0e4f4c4a3041e89f801e366aa6816e951d90d95ac87764fe1fe9bca9b224fb34da0796a235e7afb0160ed5a13a59649ac3ca5fda480a416741f8e9f6d6bf047d59aa041171c6698700a5f8519250d560053e4cc0696d9c878f3bc2aae47bd80918baea0c2918de602864702d9cb82ec306ff3167c687847caa0cabf707bb7691d9cd35da092c31980bd54614ce7b942d22c99200c2348b78d830ecc07775f4d72994df6b7a095f5cdbc3780f2214fc646c00cba5207c57c710ec01d3ab1c99b57d2985ae110a0b3cb73c4db8f9804456053c56ca19b0c7192a01e0b9df8d2438511fc36392be5a005e6f2ff464bbbac673aa2265b2e539e1de710cb5fa478ceda3f86572d4f22c2a0142bbc3c5165103b52b03d3ac7649d27f28f8d23244203f2dad6ac0f86c23288a06ee55fe32ec8b5832c099e83d802e24bc7b2d8255c9e4cdbcb28b190f06643eda0d119d6a03a7f77fd5af0804e1d0a1cd7e4b22b39b8554811fa014949db2791fca00fcd650300dc9383c6a3c4530e63cc29e28c8a773950faf2b886d805a1075ba3a0d4d65579b429665f8eece57164610cddde236e67d4a3a8e9ab518d19b4a5d6f4a07f3db2b8df96ff63907ac11dcca8f499bbb9a1e1ed021d13c6c29d1ef3337439a0ed254029ceb98dea0a11967a0dbf50b84d262f0397a7bcaac7c95fd52090af9fa0a879c624e761b93047c76db45ef4f2408075d5cd6190bd281b4efe1f034726a5a0a07e9452ebb9ef9f56e9e05d434ae452ee9972bc7f7ff9c729117608953b146fa0ee672fc517fb4c9a957ec3a8ded2a2fd89b80c398f393e29b1e98102e8f61053a0b61db41a25bbaa6acbb468b20a0085a74edcafefd8b0d78d8ee095387d0198efa0d612101516e4cdedbd21345b4caf48f96e82233f4f361bb3f96d77925fa667ada077dc1f4a8b062581425106878839c7e210abe2b38735bb9d7db8011204327d0ca0e152b9b0ab7499bee9bdfb14c3c3dc84072669506765959b3da1f6169e4ed458a0455408387e6c5b029b0d51f7d617a4d1dc4895fa6eda09455cc2ee62c08d907ea01fb1a00145067c01d2ac77f32edede63eb8b70a4308126dd505ce7b131dff013a064254a100bc90a6976fe0c41a91f1dc4a989a849b27299a88c3c327ed2b0bf96a08b13c687cb586af34da7b53329dd884fb6f903b2dd783cf6e72643ffb0331d6da011566138aa5f1ae4634bb3157557b57ac05d0c6eaa7f3f5e7cfaadfc77f34743a09aa82ceca9faba8fd1f3d00c4da529320e90dc141d70995cb52bfafdb92873d1a0ad3ec8c67e9a836420a3de77ade645f064ae1b642272014879e18ea6c56bbcfaa077f6a32b87b81d0ff453906c5098c0146190413cb0d3d4a505af2db3402df19ba0c99fb3ba58b9d24a7e07bcfe1a4de27e0563fbbf6d1c85b77f9f70c61e302f5ca03b5380620a07d1b4f0050a832a8865e58a8625df072c10bb6963a73fbc3fb649a05a29c29b6d492235af1d7978813502bea84bd1c79209374c50cd634e1fd501f7";
+
+ byte[] payload = Hex.decode(blockHashesMessageRaw);
+ BlockHashesMessage blockHashesMessage = new BlockHashesMessage(payload);
+ System.out.println(blockHashesMessage);
+
+ assertEquals(EthMessageCodes.BLOCK_HASHES, blockHashesMessage.getCommand());
+ assertEquals(128, blockHashesMessage.getBlockHashes().size());
+ // TODO maybe also assert values for individual hashes
+ assertEquals(null, blockHashesMessage.getAnswerMessage());
+ }
+
+ @Test /* BlockHashesMessage 2 from new */
+ public void test_2() {
+ List blockHashes = Arrays.asList(
+ Hex.decode("4ee6424d776b3f59affc20bc2de59e67f36e22cc07897ff8df152242c921716b"),
+ Hex.decode("7d2fe4df0dbbc9011da2b3bf177f0c6b7e71a11c509035c5d751efa5cf9b4817")
+ );
+ BlockHashesMessage blockHashesMessage = new BlockHashesMessage(blockHashes);
+ System.out.println(blockHashesMessage);
+
+ String expected = "f84304a04ee6424d776b3f59affc20bc2de59e67f36e22cc07897ff8df152242c921716ba07d2fe4df0dbbc9011da2b3bf177f0c6b7e71a11c509035c5d751efa5cf9b4817";
+ assertEquals(expected, Hex.toHexString(blockHashesMessage.getEncoded()));
+
+ assertEquals(EthMessageCodes.BLOCK_HASHES, blockHashesMessage.getCommand());
+ assertEquals(2, blockHashesMessage.getBlockHashes().size());
+ // TODO maybe also assert values for individual hashes
+ assertEquals(null, blockHashesMessage.getAnswerMessage());
+ }
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/net/BlocksMessageTest.java b/ethereumj-core/src/test/java/org/ethereum/net/BlocksMessageTest.java
new file mode 100644
index 00000000..98fcb3ca
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/net/BlocksMessageTest.java
@@ -0,0 +1,52 @@
+package org.ethereum.net;
+
+import org.ethereum.core.Block;
+import org.ethereum.net.eth.BlocksMessage;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.spongycastle.util.encoders.Hex;
+
+import java.io.File;
+import java.io.IOException;
+
+import java.net.URISyntaxException;
+import java.net.URL;
+
+import java.nio.file.Files;
+
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+@Ignore
+public class BlocksMessageTest {
+
+ private static final Logger logger = LoggerFactory.getLogger("test");
+
+ /* BLOCKS */
+
+ @Test
+ public void test_1() {
+
+ byte[] payload = Hex.decode("f901fff901fcf901f7a0fbce9f78142b5d76c2787d89d574136573f62dce21dd7bcf27c7c68ab407ccc3a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d493479415caa04a9407a2f242b2859005a379655bfb9b11a0689e7e862856d619e32ec5d949711164b447e0df7e55f4570d9fa27f33ca31a2a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000830201c008832fefd880845504456b80a05b0400eac058e0243754f4149f14e5c84cef1c33a79d83e21c80f590b953fd60881b4ef00c7a4dae1fc0c0");
+
+ BlocksMessage blocksMessage = new BlocksMessage(payload);
+ List list = blocksMessage.getBlocks();
+ logger.info(blocksMessage.toString());
+
+ Block block = list.get(0);
+ assertEquals(0, block.getTransactionsList().size());
+ assertEquals(8, block.getNumber());
+ assertEquals("2bff4626b9854e88c72ccc5b47621a0a4e47ef5d97e1fa7c00560f7cd57543c5",
+ Hex.toHexString(block.getHash()));
+ assertEquals("689e7e862856d619e32ec5d949711164b447e0df7e55f4570d9fa27f33ca31a2",
+ Hex.toHexString(block.getStateRoot()));
+ }
+
+}
+
diff --git a/ethereumj-core/src/test/java/org/ethereum/net/DisconnectMessageTest.java b/ethereumj-core/src/test/java/org/ethereum/net/DisconnectMessageTest.java
new file mode 100644
index 00000000..6972eb25
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/net/DisconnectMessageTest.java
@@ -0,0 +1,94 @@
+package org.ethereum.net;
+
+import org.ethereum.net.message.ReasonCode;
+import org.ethereum.net.p2p.DisconnectMessage;
+
+import org.junit.Test;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spongycastle.util.encoders.Hex;
+
+import static org.junit.Assert.*;
+
+public class DisconnectMessageTest {
+
+ private static final Logger logger = LoggerFactory.getLogger("test");
+
+ /* DISCONNECT_MESSAGE */
+
+ @Test /* DisconnectMessage 1 - Requested */
+ public void test_1() {
+
+ byte[] payload = Hex.decode("C100");
+ DisconnectMessage disconnectMessage = new DisconnectMessage(payload);
+
+ logger.trace("{}" + disconnectMessage);
+ assertEquals(disconnectMessage.getReason(), ReasonCode.REQUESTED);
+ }
+
+ @Test /* DisconnectMessage 2 - TCP Error */
+ public void test_2() {
+
+ byte[] payload = Hex.decode("C101");
+ DisconnectMessage disconnectMessage = new DisconnectMessage(payload);
+
+ logger.trace("{}" + disconnectMessage);
+ assertEquals(disconnectMessage.getReason(), ReasonCode.TCP_ERROR);
+ }
+
+ @Test /* DisconnectMessage 2 - from constructor */
+ public void test_3() {
+
+ DisconnectMessage disconnectMessage = new DisconnectMessage(ReasonCode.NULL_IDENTITY);
+
+ logger.trace("{}" + disconnectMessage);
+
+ String expected = "c107";
+ assertEquals(expected, Hex.toHexString(disconnectMessage.getEncoded()));
+
+ assertEquals(ReasonCode.NULL_IDENTITY, disconnectMessage.getReason());
+ }
+
+ @Test //handling boundary-high
+ public void test_4() {
+
+ byte[] payload = Hex.decode("C180");
+
+ DisconnectMessage disconnectMessage = new DisconnectMessage(payload);
+ logger.trace("{}" + disconnectMessage);
+
+ assertEquals(disconnectMessage.getReason(), ReasonCode.REQUESTED); //high numbers are zeroed
+ }
+
+ @Test //handling boundary-low minus 1 (error)
+ public void test_6() {
+
+ String disconnectMessageRaw = "C19999";
+ byte[] payload = Hex.decode(disconnectMessageRaw);
+
+ try {
+ DisconnectMessage disconnectMessage = new DisconnectMessage(payload);
+ disconnectMessage.toString(); //throws exception
+ assertTrue("Valid raw encoding for disconnectMessage", false);
+ } catch (RuntimeException e) {
+ assertTrue("Invalid raw encoding for disconnectMessage", true);
+ }
+ }
+
+ @Test //handling boundary-high plus 1 (error)
+ public void test_7() {
+
+ String disconnectMessageRaw = "C28081";
+ byte[] payload = Hex.decode(disconnectMessageRaw);
+
+ try {
+ DisconnectMessage disconnectMessage = new DisconnectMessage(payload);
+ disconnectMessage.toString(); //throws exception
+ assertTrue("Valid raw encoding for disconnectMessage", false);
+ } catch (RuntimeException e) {
+ assertTrue("Invalid raw encoding for disconnectMessage", true);
+ }
+ }
+}
+
diff --git a/ethereumj-core/src/test/java/org/ethereum/net/GetBlockHashesMessageTest.java b/ethereumj-core/src/test/java/org/ethereum/net/GetBlockHashesMessageTest.java
new file mode 100644
index 00000000..4a1bc950
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/net/GetBlockHashesMessageTest.java
@@ -0,0 +1,36 @@
+package org.ethereum.net;
+
+import org.ethereum.net.eth.BlockHashesMessage;
+import org.ethereum.net.eth.EthMessageCodes;
+import org.ethereum.net.eth.GetBlockHashesMessage;
+
+import org.junit.Test;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spongycastle.util.encoders.Hex;
+
+import static org.junit.Assert.assertEquals;
+
+public class GetBlockHashesMessageTest {
+
+ /* BLOCK_HASHES_MESSAGE */
+ private static final Logger logger = LoggerFactory.getLogger("test");
+
+
+ @Test /* BlockHashesMessage 1 from network */
+ public void test_1() {
+ String blockHashesMessageRaw = "e4a05ad1c9caeade4cdf5798e796dc87939231d9c76c20a6a33fea6dab8e9d6dd009820100";
+
+ byte[] payload = Hex.decode(blockHashesMessageRaw);
+ GetBlockHashesMessage getBlockHashesMessage = new GetBlockHashesMessage(payload);
+ System.out.println(getBlockHashesMessage);
+
+ assertEquals(EthMessageCodes.GET_BLOCK_HASHES, getBlockHashesMessage.getCommand());
+ assertEquals("5ad1c9caeade4cdf5798e796dc87939231d9c76c20a6a33fea6dab8e9d6dd009", Hex.toHexString(getBlockHashesMessage.getBestHash()));
+ assertEquals(256, getBlockHashesMessage.getMaxBlocks());
+ assertEquals(BlockHashesMessage.class, getBlockHashesMessage.getAnswerMessage());
+ }
+
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/net/GetBlocksMessageTest.java b/ethereumj-core/src/test/java/org/ethereum/net/GetBlocksMessageTest.java
new file mode 100644
index 00000000..07ccc710
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/net/GetBlocksMessageTest.java
@@ -0,0 +1,41 @@
+package org.ethereum.net;
+
+import org.ethereum.net.eth.BlocksMessage;
+import org.ethereum.net.eth.EthMessageCodes;
+import org.ethereum.net.eth.GetBlocksMessage;
+
+import org.junit.Test;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spongycastle.util.encoders.Hex;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class GetBlocksMessageTest {
+
+ /* GET_BLOCKS */
+ private static final Logger logger = LoggerFactory.getLogger("test");
+
+
+ @Test /* GetBlocks message parsing */
+ public void test_1() {
+
+ byte[] payload = Hex.decode("f8a5a0497dcbd12fa99ced7b27cda6611f64eb13ab50e20260eec5ee6b7190e7206d54a00959bdfba5e54fcc9370e86b7996fbe32a277bab65c31a0102226f83c4d3e0f2a001a333c156485880776e929e84c26c9778c1e9b4dcb5cd3bff8ad0aeff385df0a0690e13595c9e8e4fa9a621dfed6ad828a6e8e591479af6897c979a83daf73084a0b20f253d2b62609e932c13f3bca59a22913ea5b1e532d8a707976997461ec143");
+ GetBlocksMessage getBlocksMessage = new GetBlocksMessage(payload);
+ System.out.println(getBlocksMessage);
+
+ assertEquals(EthMessageCodes.GET_BLOCKS, getBlocksMessage.getCommand());
+ assertEquals(5, getBlocksMessage.getBlockHashes().size());
+ String hash1 = "497dcbd12fa99ced7b27cda6611f64eb13ab50e20260eec5ee6b7190e7206d54";
+ String hash4 = "b20f253d2b62609e932c13f3bca59a22913ea5b1e532d8a707976997461ec143";
+ assertEquals(hash1, Hex.toHexString(getBlocksMessage.getBlockHashes().get(0)));
+ assertEquals(hash4, Hex.toHexString(getBlocksMessage.getBlockHashes().get(4)));
+
+ assertEquals(BlocksMessage.class, getBlocksMessage.getAnswerMessage());
+ }
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/net/HelloMessageTest.java b/ethereumj-core/src/test/java/org/ethereum/net/HelloMessageTest.java
new file mode 100644
index 00000000..0ce6c031
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/net/HelloMessageTest.java
@@ -0,0 +1,94 @@
+package org.ethereum.net;
+
+import org.ethereum.net.client.Capability;
+import org.ethereum.net.eth.EthHandler;
+import org.ethereum.net.p2p.HelloMessage;
+import org.ethereum.net.p2p.P2pHandler;
+import org.ethereum.net.p2p.P2pMessageCodes;
+import org.ethereum.net.shh.ShhHandler;
+
+import org.junit.Test;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.spongycastle.util.encoders.Hex;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class HelloMessageTest {
+
+ /* HELLO_MESSAGE */
+ private static final Logger logger = LoggerFactory.getLogger("test");
+
+ //Parsing from raw bytes
+ @Test
+ public void test1() {
+ String helloMessageRaw = "f87902a5457468657265756d282b2b292f76302e372e392f52656c656173652f4c696e75782f672b2bccc58365746827c583736868018203e0b8401fbf1e41f08078918c9f7b6734594ee56d7f538614f602c71194db0a1af5a77f9b86eb14669fe7a8a46a2dd1b7d070b94e463f4ecd5b337c8b4d31bbf8dd5646";
+
+ byte[] payload = Hex.decode(helloMessageRaw);
+ HelloMessage helloMessage = new HelloMessage(payload);
+ logger.info(helloMessage.toString());
+
+ assertEquals(P2pMessageCodes.HELLO, helloMessage.getCommand());
+ assertEquals(2, helloMessage.getP2PVersion());
+ assertEquals("Ethereum(++)/v0.7.9/Release/Linux/g++", helloMessage.getClientId());
+ assertEquals(2, helloMessage.getCapabilities().size());
+ assertEquals(992, helloMessage.getListenPort());
+ assertEquals(
+ "1fbf1e41f08078918c9f7b6734594ee56d7f538614f602c71194db0a1af5a77f9b86eb14669fe7a8a46a2dd1b7d070b94e463f4ecd5b337c8b4d31bbf8dd5646",
+ helloMessage.getPeerId());
+ }
+
+ //Instantiate from constructor
+ @Test
+ public void test2() {
+
+ //Init
+ byte version = 2;
+ String clientStr = "Ethereum(++)/v0.7.9/Release/Linux/g++";
+ List capabilities = Arrays.asList(
+ new Capability(Capability.ETH, EthHandler.VERSION),
+ new Capability(Capability.SHH, ShhHandler.VERSION),
+ new Capability(Capability.P2P, P2pHandler.VERSION));
+ int listenPort = 992;
+ String peerId = "1fbf1e41f08078918c9f7b6734594ee56d7f538614f602c71194db0a1af5a";
+
+ HelloMessage helloMessage = new HelloMessage(version, clientStr, capabilities, listenPort, peerId);
+ logger.info(helloMessage.toString());
+
+ assertEquals(P2pMessageCodes.HELLO, helloMessage.getCommand());
+ assertEquals(version, helloMessage.getP2PVersion());
+ assertEquals(clientStr, helloMessage.getClientId());
+ assertEquals(3, helloMessage.getCapabilities().size());
+ assertEquals(listenPort, helloMessage.getListenPort());
+ assertEquals(peerId, helloMessage.getPeerId());
+ }
+
+ //Fail test
+ @Test
+ public void test3() {
+ //Init
+ byte version = -1; //invalid version
+ String clientStr = ""; //null id
+ List capabilities = Arrays.asList(
+ new Capability(null, (byte) 0),
+ new Capability(null, (byte) 0),
+ null, //null here causes NullPointerException when using toString
+ new Capability(null, (byte) 0)); //encoding null capabilities
+ int listenPort = 99999; //invalid port
+ String peerId = ""; //null id
+
+ HelloMessage helloMessage = new HelloMessage(version, clientStr, capabilities, listenPort, peerId);
+
+ assertEquals(P2pMessageCodes.HELLO, helloMessage.getCommand());
+ assertEquals(version, helloMessage.getP2PVersion());
+ assertEquals(clientStr, helloMessage.getClientId());
+ assertEquals(4, helloMessage.getCapabilities().size());
+ assertEquals(listenPort, helloMessage.getListenPort());
+ assertEquals(peerId, helloMessage.getPeerId());
+ }
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/net/NewBlockMessageTest.java b/ethereumj-core/src/test/java/org/ethereum/net/NewBlockMessageTest.java
new file mode 100644
index 00000000..e768d5e5
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/net/NewBlockMessageTest.java
@@ -0,0 +1,31 @@
+package org.ethereum.net;
+
+import org.ethereum.core.Block;
+import org.ethereum.net.eth.NewBlockMessage;
+
+import org.junit.Test;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.junit.Ignore;
+import org.spongycastle.util.encoders.Hex;
+
+public class NewBlockMessageTest {
+
+ private static final Logger logger = LoggerFactory.getLogger("test");
+
+
+ /* NEW_BLOCK */
+
+ @Test
+ public void test_1() {
+
+ byte[] payload = Hex.decode("f90144f9013Bf90136a0d8faffbc4c4213d35db9007de41cece45d95db7fd6c0f129e158baa888c48eefa01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794baedba0480e1b882b606cd302d8c4f5701cabac7a0c7d4565fb7b3d98e54a0dec8b76f8c001a784a5689954ce0aedcc1bbe8d13095a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b8400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000083063477825fc88609184e72a0008301e8488084543ffee680a00de0b9d4a0f0c23546d31f1f70db00d25cf6a7af79365b4e058e4a6a3b69527bc0c0850177ddbebe");
+
+ NewBlockMessage newBlockMessage = new NewBlockMessage(payload);
+ logger.trace("{}", newBlockMessage);
+ }
+
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/net/PeerTest.java b/ethereumj-core/src/test/java/org/ethereum/net/PeerTest.java
new file mode 100644
index 00000000..def5fbfb
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/net/PeerTest.java
@@ -0,0 +1,60 @@
+package org.ethereum.net;
+
+import org.ethereum.net.client.Capability;
+import org.ethereum.net.p2p.Peer;
+
+import org.junit.Test;
+
+import org.spongycastle.util.encoders.Hex;
+
+import java.net.InetAddress;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class PeerTest {
+
+ /* PEER */
+
+ @Test
+ public void testPeer() {
+
+ //Init
+ InetAddress address = InetAddress.getLoopbackAddress();
+ List capabilities = new ArrayList<>();
+ int port = 1010;
+ String peerId = "1010";
+ Peer peerCopy = new Peer(address, port, peerId);
+
+ //Peer
+ Peer peer = new Peer(address, port, peerId);
+
+ //getAddress
+ assertEquals("127.0.0.1", peer.getAddress().getHostAddress());
+
+ //getPort
+ assertEquals(port, peer.getPort());
+
+ //getPeerId
+ assertEquals(peerId, peer.getPeerId());
+
+ //getCapabilities
+ assertEquals(capabilities, peer.getCapabilities());
+
+ //getEncoded
+ assertEquals("CC847F0000018203F2821010C0", Hex.toHexString(peer.getEncoded()).toUpperCase());
+
+ //toString
+ assertEquals("[ip=" + address.getHostAddress() + " port=" + Integer.toString(port) + " peerId=" + peerId + "]", peer.toString());
+
+ //equals
+ assertEquals(true, peer.equals(peerCopy));
+ assertEquals(false, peer.equals(null));
+
+ //hashCode
+ assertEquals(-1, peer.hashCode());
+ }
+}
+
diff --git a/ethereumj-core/src/test/java/org/ethereum/net/PingPongMessageTest.java b/ethereumj-core/src/test/java/org/ethereum/net/PingPongMessageTest.java
new file mode 100644
index 00000000..7f516aef
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/net/PingPongMessageTest.java
@@ -0,0 +1,36 @@
+package org.ethereum.net;
+
+import org.ethereum.net.p2p.P2pMessageCodes;
+import org.ethereum.net.p2p.PingMessage;
+import org.ethereum.net.p2p.PongMessage;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class PingPongMessageTest {
+
+ /* PING_MESSAGE & PONG_MESSAGE */
+
+ @Test /* PingMessage */
+ public void testPing() {
+
+ PingMessage pingMessage = new PingMessage();
+ System.out.println(pingMessage);
+
+ assertEquals(PongMessage.class, pingMessage.getAnswerMessage());
+
+ assertEquals(P2pMessageCodes.PING, pingMessage.getCommand());
+ }
+
+ @Test /* PongMessage */
+ public void testPong() {
+
+ PongMessage pongMessage = new PongMessage();
+ System.out.println(pongMessage);
+
+ assertEquals(P2pMessageCodes.PONG, pongMessage.getCommand());
+ assertEquals(null, pongMessage.getAnswerMessage());
+ }
+}
+
diff --git a/ethereumj-core/src/test/java/org/ethereum/net/StatusMessageTest.java b/ethereumj-core/src/test/java/org/ethereum/net/StatusMessageTest.java
new file mode 100644
index 00000000..23325547
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/net/StatusMessageTest.java
@@ -0,0 +1,37 @@
+package org.ethereum.net;
+
+import org.ethereum.net.eth.StatusMessage;
+
+import org.junit.Test;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.spongycastle.util.encoders.Hex;
+
+import java.math.BigInteger;
+
+import static org.junit.Assert.assertEquals;
+
+public class StatusMessageTest {
+
+ /* STATUS_MESSAGE */
+ private static final Logger logger = LoggerFactory.getLogger("test");
+
+ @Test
+ public void test1() {
+
+ byte[] payload = Hex.decode("f84927808425c60144a0832056d3c93ff2739ace7199952e5365aa29f18805be05634c4db125c5340216a0955f36d073ccb026b78ab3424c15cf966a7563aa270413859f78702b9e8e22cb");
+ StatusMessage statusMessage = new StatusMessage(payload);
+
+ logger.info(statusMessage.toString());
+
+ assertEquals(39, statusMessage.getProtocolVersion());
+ assertEquals("25c60144",
+ Hex.toHexString(statusMessage.getTotalDifficulty()));
+ assertEquals("832056d3c93ff2739ace7199952e5365aa29f18805be05634c4db125c5340216",
+ Hex.toHexString(statusMessage.getBestHash()));
+ }
+
+}
+
diff --git a/ethereumj-core/src/test/java/org/ethereum/net/TransactionsMessageTest.java b/ethereumj-core/src/test/java/org/ethereum/net/TransactionsMessageTest.java
new file mode 100644
index 00000000..c9070af0
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/net/TransactionsMessageTest.java
@@ -0,0 +1,200 @@
+package org.ethereum.net;
+
+import org.ethereum.core.Transaction;
+import org.ethereum.crypto.ECKey;
+import org.ethereum.crypto.HashUtil;
+import org.ethereum.net.eth.EthMessageCodes;
+import org.ethereum.net.eth.GetTransactionsMessage;
+import org.ethereum.net.eth.TransactionsMessage;
+import org.ethereum.util.ByteUtil;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import org.spongycastle.util.encoders.Hex;
+
+import java.math.BigInteger;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import static org.junit.Assert.*;
+
+public class TransactionsMessageTest {
+
+ /* GET_TRANSACTIONS */
+
+ @Test /* GetTransactions message 1 */
+ public void testGetTransactions() {
+
+ GetTransactionsMessage getTransactionsMessage = new GetTransactionsMessage();
+ System.out.println(getTransactionsMessage);
+
+ assertEquals(EthMessageCodes.GET_TRANSACTIONS, getTransactionsMessage.getCommand());
+ assertEquals(TransactionsMessage.class, getTransactionsMessage.getAnswerMessage());
+ }
+
+ /* TRANSACTIONS */
+
+ @Ignore
+ @Test /* Transactions message 1 */
+ public void test_1() {
+
+ String txsPacketRaw = "f86e12f86b04648609184e72a00094cd2a3d9f938e13cd947ec05abc7fe734df8dd826"
+ + "881bc16d674ec80000801ba05c89ebf2b77eeab88251e553f6f9d53badc1d800"
+ + "bbac02d830801c2aa94a4c9fa00b7907532b1f29c79942b75fff98822293bf5f"
+ + "daa3653a8d9f424c6a3265f06c";
+
+ byte[] payload = Hex.decode(txsPacketRaw);
+
+ TransactionsMessage transactionsMessage = new TransactionsMessage(payload);
+ System.out.println(transactionsMessage);
+
+ assertEquals(EthMessageCodes.TRANSACTIONS, transactionsMessage.getCommand());
+ assertEquals(1, transactionsMessage.getTransactions().size());
+
+ Transaction tx = transactionsMessage.getTransactions().iterator().next();
+
+ assertEquals("5d2aee0490a9228024158433d650335116b4af5a30b8abb10e9b7f9f7e090fd8", Hex.toHexString(tx.getHash()));
+ assertEquals("04", Hex.toHexString(tx.getNonce()));
+ assertEquals("1bc16d674ec80000", Hex.toHexString(tx.getValue()));
+ assertEquals("cd2a3d9f938e13cd947ec05abc7fe734df8dd826", Hex.toHexString(tx.getReceiveAddress()));
+ assertEquals("64", Hex.toHexString(tx.getGasPrice()));
+ assertEquals("09184e72a000", Hex.toHexString(tx.getGasLimit()));
+ assertEquals("", ByteUtil.toHexString(tx.getData()));
+
+ assertEquals("1b", Hex.toHexString(new byte[]{tx.getSignature().v}));
+ assertEquals("5c89ebf2b77eeab88251e553f6f9d53badc1d800bbac02d830801c2aa94a4c9f", Hex.toHexString(tx.getSignature().r.toByteArray()));
+ assertEquals("0b7907532b1f29c79942b75fff98822293bf5fdaa3653a8d9f424c6a3265f06c", Hex.toHexString(tx.getSignature().s.toByteArray()));
+ }
+
+ @Ignore
+ @Test /* Transactions message 2 */
+ public void test_2() {
+
+ String txsPacketRaw = "f9025012f89d8080940000000000000000000000000000000000000000860918"
+ + "4e72a000822710b3606956330c0d630000003359366000530a0d630000003359"
+ + "602060005301356000533557604060005301600054630000000c588433606957"
+ + "1ca07f6eb94576346488c6253197bde6a7e59ddc36f2773672c849402aa9c402"
+ + "c3c4a06d254e662bf7450dd8d835160cbb053463fed0b53f2cdd7f3ea8731919"
+ + "c8e8ccf901050180940000000000000000000000000000000000000000860918"
+ + "4e72a000822710b85336630000002e59606956330c0d63000000155933ff3356"
+ + "0d63000000275960003356576000335700630000005358600035560d63000000"
+ + "3a590033560d63000000485960003356573360003557600035335700b84a7f4e"
+ + "616d655265670000000000000000000000000000000000000000000000000030"
+ + "57307f4e616d6552656700000000000000000000000000000000000000000000"
+ + "00000057336069571ba04af15a0ec494aeac5b243c8a2690833faa74c0f73db1"
+ + "f439d521c49c381513e9a05802e64939be5a1f9d4d614038fbd5479538c48795"
+ + "614ef9c551477ecbdb49d2f8a6028094ccdeac59d35627b7de09332e819d5159"
+ + "e7bb72508609184e72a000822710b84000000000000000000000000000000000"
+ + "000000000000000000000000000000000000000000000000000000002d0aceee"
+ + "7e5ab874e22ccf8d1a649f59106d74e81ba0d05887574456c6de8f7a0d172342"
+ + "c2cbdd4cf7afe15d9dbb8b75b748ba6791c9a01e87172a861f6c37b5a9e3a5d0"
+ + "d7393152a7fbe41530e5bb8ac8f35433e5931b";
+
+ byte[] payload = Hex.decode(txsPacketRaw);
+
+ TransactionsMessage transactionsMessage = new TransactionsMessage(payload);
+ System.out.println(transactionsMessage);
+
+ assertEquals(EthMessageCodes.TRANSACTIONS, transactionsMessage.getCommand());
+
+ assertEquals(3, transactionsMessage.getTransactions().size());
+
+ Iterator txIter = transactionsMessage.getTransactions().iterator();
+ Transaction tx1 = txIter.next();
+ txIter.next(); // skip one
+ Transaction tx3 = txIter.next();
+
+ assertEquals("1b9d9456293cbcbc2f28a0fdc67028128ea571b033fb0e21d0ee00bcd6167e5d",
+ Hex.toHexString(tx3.getHash()));
+
+ assertEquals("00",
+ Hex.toHexString(tx3.getNonce()));
+
+ assertEquals("2710",
+ Hex.toHexString(tx3.getValue()));
+
+ assertEquals("09184e72a000",
+ Hex.toHexString(tx3.getReceiveAddress()));
+
+ assertNull(tx3.getGasPrice());
+
+ assertEquals("0000000000000000000000000000000000000000",
+ Hex.toHexString(tx3.getGasLimit()));
+
+ assertEquals("606956330c0d630000003359366000530a0d630000003359602060005301356000533557604060005301600054630000000c58",
+ Hex.toHexString(tx3.getData()));
+
+ assertEquals("33",
+ Hex.toHexString(new byte[]{tx3.getSignature().v}));
+
+ assertEquals("1c",
+ Hex.toHexString(tx3.getSignature().r.toByteArray()));
+
+ assertEquals("7f6eb94576346488c6253197bde6a7e59ddc36f2773672c849402aa9c402c3c4",
+ Hex.toHexString(tx3.getSignature().s.toByteArray()));
+
+ // Transaction #2
+
+ assertEquals("dde9543921850f41ca88e5401322cd7651c78a1e4deebd5ee385af8ac343f0ad",
+ Hex.toHexString(tx1.getHash()));
+
+ assertEquals("02",
+ Hex.toHexString(tx1.getNonce()));
+
+ assertEquals("2710",
+ Hex.toHexString(tx1.getValue()));
+
+ assertEquals("09184e72a000",
+ Hex.toHexString(tx1.getReceiveAddress()));
+
+ assertNull(tx1.getGasPrice());
+
+ assertEquals("ccdeac59d35627b7de09332e819d5159e7bb7250",
+ Hex.toHexString(tx1.getGasLimit()));
+
+ assertEquals
+ ("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000002d0aceee7e5ab874e22ccf8d1a649f59106d74e8",
+ Hex.toHexString(tx1.getData()));
+
+ assertEquals("1b",
+ Hex.toHexString(new byte[]{tx1.getSignature().v}));
+
+ assertEquals("00d05887574456c6de8f7a0d172342c2cbdd4cf7afe15d9dbb8b75b748ba6791c9",
+ Hex.toHexString(tx1.getSignature().r.toByteArray()));
+
+ assertEquals("1e87172a861f6c37b5a9e3a5d0d7393152a7fbe41530e5bb8ac8f35433e5931b",
+ Hex.toHexString(tx1.getSignature().s.toByteArray()));
+ }
+
+ @Test /* Transactions msg encode */
+ public void test_3() throws Exception {
+
+ String expected =
+ "f87302f870808b00d3c21bcecceda10000009479b08ad8787060333663d19704909ee7b1903e588609184e72a000824255801ca00f410a70e42b2c9854a8421d32c87c370a2b9fff0a27f9f031bb4443681d73b5a018a7dc4c4f9dee9f3dc35cb96ca15859aa27e219a8e4a8547be6bd3206979858";
+
+ BigInteger value = new BigInteger("1000000000000000000000000");
+
+ byte[] privKey = HashUtil.sha3("cat".getBytes());
+ ECKey ecKey = ECKey.fromPrivate(privKey);
+
+ byte[] gasPrice = Hex.decode("09184e72a000");
+ byte[] gas = Hex.decode("4255");
+
+ Transaction tx = new Transaction(null, value.toByteArray(),
+ ecKey.getAddress(), gasPrice, gas, null);
+
+ tx.sign(privKey);
+ tx.getEncoded();
+
+ Set txs = new HashSet<>(Arrays.asList(tx));
+ TransactionsMessage transactionsMessage = new TransactionsMessage(txs);
+
+ assertEquals(EthMessageCodes.TRANSACTIONS, transactionsMessage.getCommand());
+ assertEquals(expected, Hex.toHexString(transactionsMessage.getEncoded()));
+ }
+}
+
diff --git a/ethereumj-core/src/test/java/org/ethereum/net/rlpx/EncryptionHandshakeTest.java b/ethereumj-core/src/test/java/org/ethereum/net/rlpx/EncryptionHandshakeTest.java
new file mode 100644
index 00000000..8561a9ff
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/net/rlpx/EncryptionHandshakeTest.java
@@ -0,0 +1,44 @@
+package org.ethereum.net.rlpx;
+
+import org.ethereum.crypto.ECKey;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Created by android on 4/8/15.
+ */
+public class EncryptionHandshakeTest {
+ private ECKey myKey;
+ private ECKey remoteKey;
+ private EncryptionHandshake initiator;
+
+ @Before
+ public void setUp() {
+ remoteKey = new ECKey().decompress();
+ myKey = new ECKey().decompress();
+ initiator = new EncryptionHandshake(remoteKey.getPubKeyPoint());
+ }
+
+ @Test
+ public void testCreateAuthInitiate() throws Exception {
+ AuthInitiateMessage message = initiator.createAuthInitiate(new byte[32], myKey);
+ int expectedLength = 65+32+64+32+1;
+ byte[] buffer = message.encode();
+ assertEquals(expectedLength, buffer.length);
+ }
+
+ @Test
+ public void testAgreement() throws Exception {
+ EncryptionHandshake responder = new EncryptionHandshake();
+ AuthInitiateMessage initiate = initiator.createAuthInitiate(null, myKey);
+ byte[] initiatePacket = initiator.encryptAuthMessage(initiate);
+ byte[] responsePacket = responder.handleAuthInitiate(initiatePacket, remoteKey);
+ initiator.handleAuthResponse(myKey, initiatePacket, responsePacket);
+ assertArrayEquals(initiator.getSecrets().aes, responder.getSecrets().aes);
+ assertArrayEquals(initiator.getSecrets().mac, responder.getSecrets().mac);
+ assertArrayEquals(initiator.getSecrets().token, responder.getSecrets().token);
+ }
+}
\ No newline at end of file
diff --git a/ethereumj-core/src/test/java/org/ethereum/net/rlpx/RLPXTest.java b/ethereumj-core/src/test/java/org/ethereum/net/rlpx/RLPXTest.java
new file mode 100644
index 00000000..9f7b348c
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/net/rlpx/RLPXTest.java
@@ -0,0 +1,249 @@
+package org.ethereum.net.rlpx;
+
+import org.ethereum.crypto.ECKey;
+import org.ethereum.net.rlpx.*;
+import org.ethereum.util.RLP;
+import org.ethereum.util.RLPList;
+import org.junit.Assert;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.slf4j.LoggerFactory;
+import org.spongycastle.util.encoders.Hex;
+
+import java.math.BigInteger;
+import java.nio.charset.Charset;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Ignore;
+import static org.ethereum.crypto.HashUtil.sha3;
+import static org.ethereum.util.ByteUtil.merge;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class RLPXTest {
+
+ private static final org.slf4j.Logger logger = LoggerFactory.getLogger("test");
+
+ @Test // ping test
+ public void test1() {
+
+ String ip = "85.65.19.231";
+ int port = 30303;
+ ECKey key = ECKey.fromPrivate(BigInteger.TEN);
+
+ Message ping = PingMessage.create(ip, port, key);
+ logger.info("{}", ping);
+
+ byte[] wire = ping.getPacket();
+ PingMessage ping2 = (PingMessage) Message.decode(wire);
+ logger.info("{}", ping2);
+
+ assertEquals(ping.toString(), ping2.toString());
+
+ String key2 = ping2.getKey().toString();
+ assertEquals(key.toString(), key2.toString());
+ }
+
+ @Ignore
+ @Test // pong test
+ public void test2() {
+
+ byte[] token = sha3("+++".getBytes(Charset.forName("UTF-8")));
+ ECKey key = ECKey.fromPrivate(BigInteger.TEN);
+
+ Message pong = PongMessage.create(token, key);
+ logger.info("{}", pong);
+
+ byte[] wire = pong.getPacket();
+ PongMessage pong2 = (PongMessage) Message.decode(wire);
+ logger.info("{}", pong);
+
+ assertEquals(pong.toString(), pong2.toString());
+
+ String key2 = pong2.getKey().toString();
+ assertEquals(key.toString(), key2.toString());
+ }
+
+ @Test // neighbors message
+ public void test3() {
+
+ String ip = "85.65.19.231";
+ int port = 30303;
+
+ byte[] part1 = sha3("007".getBytes(Charset.forName("UTF-8")));
+ byte[] part2 = sha3("007".getBytes(Charset.forName("UTF-8")));
+ byte[] id = merge(part1, part2);
+
+ Node node = new Node(id, ip, port);
+
+ List nodes = Arrays.asList(node);
+ ECKey key = ECKey.fromPrivate(BigInteger.TEN);
+
+ Message neighbors = NeighborsMessage.create(nodes, key);
+ logger.info("{}", neighbors);
+
+ byte[] wire = neighbors.getPacket();
+ NeighborsMessage neighbors2 = (NeighborsMessage) Message.decode(wire);
+ logger.info("{}", neighbors2);
+
+ assertEquals(neighbors.toString(), neighbors2.toString());
+
+ String key2 = neighbors2.getKey().toString();
+ assertEquals(key.toString(), key2.toString());
+ }
+
+ @Ignore
+ @Test // find node message
+ public void test4() {
+
+ byte[] id = sha3("+++".getBytes(Charset.forName("UTF-8")));
+ ECKey key = ECKey.fromPrivate(BigInteger.TEN);
+
+ Message findNode = FindNodeMessage.create(id, key);
+ logger.info("{}", findNode);
+
+ byte[] wire = findNode.getPacket();
+ FindNodeMessage findNode2 = (FindNodeMessage) Message.decode(wire);
+ logger.info("{}", findNode2);
+
+ assertEquals(findNode.toString(), findNode2.toString());
+
+ String key2 = findNode2.getKey().toString();
+ assertEquals(key.toString(), key2.toString());
+ }
+
+
+ @Test(expected = Error.class)// failure on MDC
+ public void test5() {
+
+ byte[] id = sha3("+++".getBytes(Charset.forName("UTF-8")));
+ ECKey key = ECKey.fromPrivate(BigInteger.TEN);
+
+ Message findNode = FindNodeMessage.create(id, key);
+ logger.info("{}", findNode);
+
+ byte[] wire = findNode.getPacket();
+ wire[64] = 0;
+
+ FindNodeMessage findNode2 = (FindNodeMessage) Message.decode(wire);
+ logger.info("{}", findNode2);
+
+ assertEquals(findNode.toString(), findNode2.toString());
+ }
+
+
+ @Test
+ public void test6() {
+
+ byte[] id_1 = sha3("+++".getBytes(Charset.forName("UTF-8")));
+ String host_1 = "85.65.19.231";
+ int port_1 = 30303;
+
+ Node node_1 = new Node(id_1, host_1 , port_1);
+ Node node_2 = new Node(node_1.getRLP());
+
+ byte[] id_2 = node_2.getId();
+ String host_2 = node_2.getHost();
+ int port_2 = node_2.getPort();
+
+ assertEquals(Hex.toHexString(id_1), Hex.toHexString(id_2));
+ assertEquals(host_1, host_2);
+ assertTrue(port_1 == port_2);
+ }
+
+
+
+ @Test // Neighbors parse data
+ public void test7() {
+
+ byte[] wire =
+ Hex.decode("d5106e888eeca1e0b4a93bf17c325f912b43ca4176a000966619aa6a96ac9d5a60e66c73ed5629c13d4d0c806a3127379541e8d90d7fcb52c33c5e36557ad92dfed9619fcd3b92e42683aed89bd3c6eef6b59bd0237c36d83ebb0075a59903f50104f90200f901f8f8528c38352e36352e31392e32333182f310b840aeb2dd107edd996adf1bbf835fb3f9a11aabb7ed3dfef84c7a3c8767482bff522906a11e8cddee969153bf5944e64e37943db509bb4cc714c217f20483802ec0f8528c38352e36352e31392e32333182e5b4b840b70cdf8f23024a65afbf12110ca06fa5c37bd9fe4f6234a0120cdaaf16e8bb96d090d0164c316aaa18158d346e9b0a29ad9bfa0404ab4ee9906adfbacb01c21bf8528c38352e36352e31392e32333182df38b840ed8e01b5f5468f32de23a7524af1b35605ffd7cdb79af4eacd522c94f8ed849bb81dfed4992c179caeef0952ecad2d868503164a434c300356b369a33c159289f8528c38352e36352e31392e32333182df38b840136996f11c2c80f231987fc4f0cbd061cb021c63afaf5dd879e7c851a57be8d023af14bc201be81588ecab7971693b3f689a4854df74ad2e2334e88ae76aa122f8528c38352e36352e31392e32333182f303b840742eac32e1e2343b89c03a20fc051854ea6a3ff28ca918d1994fe1e32d6d77ab63352131db3ed0e7d6cc057d859c114b102f49052daee3d1c5f5fdaab972e655f8528c38352e36352e31392e32333182f310b8407d9e1f9ceb66fc21787b830554d604f933be203be9366710fb33355975e874a72b87837cf28b1b9ae171826b64e3c5d178326cbf71f89b3dec614816a1a40ce38454f6b578");
+
+ NeighborsMessage msg1 = (NeighborsMessage) NeighborsMessage.decode(wire);
+
+ ECKey key = ECKey.fromPrivate(BigInteger.TEN);
+ NeighborsMessage msg2 = (NeighborsMessage) NeighborsMessage.create(msg1.getNodes(), key);
+
+ NeighborsMessage msg3 = (NeighborsMessage) NeighborsMessage.decode(msg2.getPacket());
+
+ for (int i = 0; i < msg1.getNodes().size(); ++i) {
+
+ Node node_1 = msg1.getNodes().get(i);
+ Node node_3 = msg3.getNodes().get(i);
+
+ assertEquals(node_1.toString(), node_3.toString());
+ }
+
+ System.out.println(msg1);
+
+ }
+
+
+ @Test // FindNodeMessage parse data
+ public void test8() {
+
+ byte[] wire =
+ Hex.decode("3770d98825a42cb69edf70ffdf8d6d2b28a8c5499a7e3350e4a42c94652339cac3f8e9c3b5a181c8dd13e491ad9229f6a8bd018d786e1fb9e5264f43bbd6ce93af9bc85b468dee651bcd518561f83cb166da7aef7e506057dc2fbb2ea582bcc00003f847b84083fba54f6bb80ce31f6d5d1ec0a9a2e4685bc185115b01da6dcb70cd13116a6bd08b86ffe60b7d7ea56c6498848e3741113f8e70b9f0d12dbfe895680d03fd658454f6e772");
+
+ FindNodeMessage msg1 = (FindNodeMessage) FindNodeMessage.decode(wire);
+
+ ECKey key = ECKey.fromPrivate(BigInteger.TEN);
+ FindNodeMessage msg2 = FindNodeMessage.create(msg1.getTarget(), key);
+
+ FindNodeMessage msg3 = (FindNodeMessage) FindNodeMessage.decode(msg2.getPacket());
+
+ Assert.assertEquals(Hex.toHexString(msg1.getTarget()), Hex.toHexString(msg3.getTarget()));
+ }
+
+ @Ignore //TODO #POC9
+ @Test // Ping parse data
+ public void test9() {
+// wire: 4c62e1b75f4003ef77032006a142bbf31772936a1e5098566b28a04a5c71c73f1f2c9f539a85458c50a554de12da9d7e69fb2507f7c0788885508d385bbe7a9538fa675712aa1eaad29902bb46eee4531d00a10fd81179e4151929f60fec4dc50001ce87302e302e302e30808454f8483c
+// PingMessage: {mdc=4c62e1b75f4003ef77032006a142bbf31772936a1e5098566b28a04a5c71c73f, signature=1f2c9f539a85458c50a554de12da9d7e69fb2507f7c0788885508d385bbe7a9538fa675712aa1eaad29902bb46eee4531d00a10fd81179e4151929f60fec4dc500, type=01, data=ce87302e302e302e30808454f8483c}
+
+ byte[] wire =
+ Hex.decode("4c62e1b75f4003ef77032006a142bbf31772936a1e5098566b28a04a5c71c73f1f2c9f539a85458c50a554de12da9d7e69fb2507f7c0788885508d385bbe7a9538fa675712aa1eaad29902bb46eee4531d00a10fd81179e4151929f60fec4dc50001ce87302e302e302e30808454f8483c");
+
+ PingMessage msg1 = (PingMessage)Message.decode(wire);
+
+ ECKey key = ECKey.fromPrivate(BigInteger.TEN);
+ PingMessage msg2 = PingMessage.create(msg1.getHost(), msg1.getPort(), key);
+ PingMessage msg3 = (PingMessage)Message.decode(msg2.getPacket());
+
+ assertEquals(msg1.getHost(), msg3.getHost());
+ }
+
+
+ @Test // Pong parse data
+ public void test10(){
+// wire: 84db9bf6a1f7a3444f4d4946155da16c63a51abdd6822ac683d8243f260b99b265601b769acebfe3c76ddeb6e83e924f2bac2beca0c802ff0745d349bd58bc6662d62d38c2a3bb3e167a333d7d099496ebd35e096c5c1ee1587e9bd11f20e3d80002e6a079d49bdba3a7acfc9a2881d768d1aa246c2486ab166f0305a863bd47c5d21e0e8454f8483c
+// PongMessage: {mdc=84db9bf6a1f7a3444f4d4946155da16c63a51abdd6822ac683d8243f260b99b2, signature=65601b769acebfe3c76ddeb6e83e924f2bac2beca0c802ff0745d349bd58bc6662d62d38c2a3bb3e167a333d7d099496ebd35e096c5c1ee1587e9bd11f20e3d800, type=02, data=e6a079d49bdba3a7acfc9a2881d768d1aa246c2486ab166f0305a863bd47c5d21e0e8454f8483c}
+
+ byte[] wire =
+ Hex.decode("84db9bf6a1f7a3444f4d4946155da16c63a51abdd6822ac683d8243f260b99b265601b769acebfe3c76ddeb6e83e924f2bac2beca0c802ff0745d349bd58bc6662d62d38c2a3bb3e167a333d7d099496ebd35e096c5c1ee1587e9bd11f20e3d80002e6a079d49bdba3a7acfc9a2881d768d1aa246c2486ab166f0305a863bd47c5d21e0e8454f8483c");
+
+ PongMessage msg1 = (PongMessage)Message.decode(wire);
+
+ ECKey key = ECKey.fromPrivate(BigInteger.TEN);
+ PongMessage msg2 = PongMessage.create(msg1.getToken(), key);
+
+ PongMessage msg3 = (PongMessage)Message.decode(msg2.getPacket());
+ assertEquals( Hex.toHexString(msg1.getToken()), Hex.toHexString(msg3.getToken()));
+ }
+
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
diff --git a/ethereumj-core/src/test/java/org/ethereum/net/rlpx/RlpxConnectionTest.java b/ethereumj-core/src/test/java/org/ethereum/net/rlpx/RlpxConnectionTest.java
new file mode 100644
index 00000000..3aed3377
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/net/rlpx/RlpxConnectionTest.java
@@ -0,0 +1,92 @@
+package org.ethereum.net.rlpx;
+
+import com.google.common.collect.Lists;
+import org.ethereum.crypto.ECKey;
+import org.ethereum.net.client.Capability;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.*;
+import java.security.SecureRandom;
+
+import static org.junit.Assert.*;
+
+/**
+ * Created by devrandom on 2015-04-11.
+ */
+public class RlpxConnectionTest {
+ private FrameCodec iCodec;
+ private FrameCodec rCodec;
+ private EncryptionHandshake initiator;
+ private EncryptionHandshake responder;
+ private HandshakeMessage iMessage;
+ private PipedInputStream to;
+ private PipedOutputStream toOut;
+ private PipedInputStream from;
+ private PipedOutputStream fromOut;
+
+ @Before
+ public void setUp() throws IOException {
+ ECKey remoteKey = new ECKey().decompress();
+ ECKey myKey = new ECKey().decompress();
+ initiator = new EncryptionHandshake(remoteKey.getPubKeyPoint());
+ responder = new EncryptionHandshake();
+ AuthInitiateMessage initiate = initiator.createAuthInitiate(null, myKey);
+ byte[] initiatePacket = initiator.encryptAuthMessage(initiate);
+ byte[] responsePacket = responder.handleAuthInitiate(initiatePacket, remoteKey);
+ initiator.handleAuthResponse(myKey, initiatePacket, responsePacket);
+ to = new PipedInputStream(1024*1024);
+ toOut = new PipedOutputStream(to);
+ from = new PipedInputStream(1024*1024);
+ fromOut = new PipedOutputStream(from);
+ iCodec = new FrameCodec(initiator.getSecrets());
+ rCodec = new FrameCodec(responder.getSecrets());
+ byte[] nodeId = {1, 2, 3, 4};
+ iMessage = new HandshakeMessage(
+ 123,
+ "abcd",
+ Lists.newArrayList(
+ new Capability("zz", (byte) 1),
+ new Capability("yy", (byte) 3)
+ ),
+ 3333,
+ nodeId
+ );
+ }
+
+ @Test
+ public void testFrame() throws Exception {
+ byte[] payload = new byte[123];
+ new SecureRandom().nextBytes(payload);
+ FrameCodec.Frame frame = new FrameCodec.Frame(12345, 123, new ByteArrayInputStream(payload));
+ iCodec.writeFrame(frame, toOut);
+ FrameCodec.Frame frame1 = rCodec.readFrame(new DataInputStream(to));
+ byte[] payload1 = new byte[frame1.size];
+ assertEquals(frame.size, frame1.size);
+ frame1.payload.read(payload1);
+ assertArrayEquals(payload, payload1);
+ assertEquals(frame.type, frame1.type);
+ }
+
+ @Test
+ public void testMessageEncoding() throws IOException {
+ byte[] wire = iMessage.encode();
+ HandshakeMessage message1 = HandshakeMessage.parse(wire);
+ assertEquals(123, message1.version);
+ assertEquals("abcd", message1.name);
+ assertEquals(3333, message1.listenPort);
+ assertArrayEquals(message1.nodeId, message1.nodeId);
+ assertEquals(iMessage.caps, message1.caps);
+ }
+
+ @Test
+ public void testHandshake() throws IOException {
+ RlpxConnection iConn = new RlpxConnection(initiator.getSecrets(), from, toOut);
+ RlpxConnection rConn = new RlpxConnection(responder.getSecrets(), to, fromOut);
+ iConn.sendProtocolHandshake(iMessage);
+ rConn.handleNextMessage();
+ HandshakeMessage receivedMessage = rConn.getHandshakeMessage();
+ assertNotNull(receivedMessage);
+ assertArrayEquals(iMessage.nodeId, receivedMessage.nodeId);
+ }
+}
\ No newline at end of file
diff --git a/ethereumj-core/src/test/java/org/ethereum/net/wire/AdaptiveMessageIdsTest.java b/ethereumj-core/src/test/java/org/ethereum/net/wire/AdaptiveMessageIdsTest.java
new file mode 100644
index 00000000..f12fa886
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/net/wire/AdaptiveMessageIdsTest.java
@@ -0,0 +1,150 @@
+package org.ethereum.net.wire;
+
+import org.ethereum.net.client.Capability;
+import org.ethereum.net.eth.EthHandler;
+import org.ethereum.net.eth.EthMessageCodes;
+import org.ethereum.net.p2p.P2pHandler;
+import org.ethereum.net.p2p.P2pMessageCodes;
+import org.ethereum.net.shh.ShhHandler;
+import org.ethereum.net.shh.ShhMessageCodes;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @author Roman Mandeleil
+ * @since 15.10.2014
+ */
+public class AdaptiveMessageIdsTest {
+
+ @Before
+ public void setUp() {
+ EthMessageCodes.setOffset((byte) 0x00);
+ ShhMessageCodes.setOffset((byte) 0x00);
+ }
+
+ @After
+ public void tearDown() {
+ EthMessageCodes.setOffset((byte) 0x00);
+ ShhMessageCodes.setOffset((byte) 0x00);
+ }
+
+ @Test
+ public void test1() {
+
+ Assert.assertEquals(7, P2pMessageCodes.values().length);
+
+ Assert.assertEquals(0, P2pMessageCodes.HELLO.asByte());
+ Assert.assertEquals(1, P2pMessageCodes.DISCONNECT.asByte());
+ Assert.assertEquals(2, P2pMessageCodes.PING.asByte());
+ Assert.assertEquals(3, P2pMessageCodes.PONG.asByte());
+ Assert.assertEquals(4, P2pMessageCodes.GET_PEERS.asByte());
+ Assert.assertEquals(5, P2pMessageCodes.PEERS.asByte());
+ Assert.assertEquals(15, P2pMessageCodes.USER.asByte());
+ }
+
+ @Test
+ public void test2() {
+
+ Assert.assertEquals(9, EthMessageCodes.values().length);
+
+ Assert.assertEquals(0, EthMessageCodes.STATUS.asByte());
+ Assert.assertEquals(1, EthMessageCodes.GET_TRANSACTIONS.asByte());
+ Assert.assertEquals(2, EthMessageCodes.TRANSACTIONS.asByte());
+ Assert.assertEquals(3, EthMessageCodes.GET_BLOCK_HASHES.asByte());
+ Assert.assertEquals(4, EthMessageCodes.BLOCK_HASHES.asByte());
+ Assert.assertEquals(5, EthMessageCodes.GET_BLOCKS.asByte());
+ Assert.assertEquals(6, EthMessageCodes.BLOCKS.asByte());
+ Assert.assertEquals(7, EthMessageCodes.NEW_BLOCK.asByte());
+ Assert.assertEquals(8, EthMessageCodes.PACKET_COUNT.asByte());
+
+ EthMessageCodes.setOffset((byte) 0x10);
+ Assert.assertEquals(0x10 + 0, EthMessageCodes.STATUS.asByte());
+ Assert.assertEquals(0x10 + 1, EthMessageCodes.GET_TRANSACTIONS.asByte());
+ Assert.assertEquals(0x10 + 2, EthMessageCodes.TRANSACTIONS.asByte());
+ Assert.assertEquals(0x10 + 3, EthMessageCodes.GET_BLOCK_HASHES.asByte());
+ Assert.assertEquals(0x10 + 4, EthMessageCodes.BLOCK_HASHES.asByte());
+ Assert.assertEquals(0x10 + 5, EthMessageCodes.GET_BLOCKS.asByte());
+ Assert.assertEquals(0x10 + 6, EthMessageCodes.BLOCKS.asByte());
+ Assert.assertEquals(0x10 + 7, EthMessageCodes.NEW_BLOCK.asByte());
+ Assert.assertEquals(0x10 + 8, EthMessageCodes.PACKET_COUNT.asByte());
+ }
+
+ @Test
+ public void test3() {
+
+ Assert.assertEquals(5, ShhMessageCodes.values().length);
+
+ Assert.assertEquals(0, ShhMessageCodes.STATUS.asByte());
+ Assert.assertEquals(1, ShhMessageCodes.MESSAGE.asByte());
+ Assert.assertEquals(2, ShhMessageCodes.ADD_FILTER.asByte());
+ Assert.assertEquals(3, ShhMessageCodes.REMOVE_FILTER.asByte());
+ Assert.assertEquals(4, ShhMessageCodes.PACKET_COUNT.asByte());
+
+ ShhMessageCodes.setOffset((byte) 0x20);
+ Assert.assertEquals(0x20 + 0, ShhMessageCodes.STATUS.asByte());
+ Assert.assertEquals(0x20 + 1, ShhMessageCodes.MESSAGE.asByte());
+ Assert.assertEquals(0x20 + 2, ShhMessageCodes.ADD_FILTER.asByte());
+ Assert.assertEquals(0x20 + 3, ShhMessageCodes.REMOVE_FILTER.asByte());
+ Assert.assertEquals(0x20 + 4, ShhMessageCodes.PACKET_COUNT.asByte());
+ }
+
+ @Test
+ public void test4() {
+
+ P2pHandler p2pHandler = new P2pHandler();
+
+ List capabilities = Arrays.asList(
+ new Capability(Capability.ETH, EthHandler.VERSION),
+ new Capability(Capability.SHH, ShhHandler.VERSION));
+ p2pHandler.adaptMessageIds(capabilities);
+
+ Assert.assertEquals(0x10 + 0, EthMessageCodes.STATUS.asByte());
+ Assert.assertEquals(0x10 + 1, EthMessageCodes.GET_TRANSACTIONS.asByte());
+ Assert.assertEquals(0x10 + 2, EthMessageCodes.TRANSACTIONS.asByte());
+ Assert.assertEquals(0x10 + 3, EthMessageCodes.GET_BLOCK_HASHES.asByte());
+ Assert.assertEquals(0x10 + 4, EthMessageCodes.BLOCK_HASHES.asByte());
+ Assert.assertEquals(0x10 + 5, EthMessageCodes.GET_BLOCKS.asByte());
+ Assert.assertEquals(0x10 + 6, EthMessageCodes.BLOCKS.asByte());
+ Assert.assertEquals(0x10 + 7, EthMessageCodes.NEW_BLOCK.asByte());
+ Assert.assertEquals(0x10 + 8, EthMessageCodes.PACKET_COUNT.asByte());
+
+ Assert.assertEquals(0x19 + 0, ShhMessageCodes.STATUS.asByte());
+ Assert.assertEquals(0x19 + 1, ShhMessageCodes.MESSAGE.asByte());
+ Assert.assertEquals(0x19 + 2, ShhMessageCodes.ADD_FILTER.asByte());
+ Assert.assertEquals(0x19 + 3, ShhMessageCodes.REMOVE_FILTER.asByte());
+ Assert.assertEquals(0x19 + 4, ShhMessageCodes.PACKET_COUNT.asByte());
+ }
+
+ @Test // Capabilities should be read in alphabetical order
+ public void test5() {
+
+ P2pHandler p2pHandler = new P2pHandler();
+
+ List capabilities = Arrays.asList(
+ new Capability(Capability.SHH, ShhHandler.VERSION),
+ new Capability(Capability.ETH, EthHandler.VERSION));
+ p2pHandler.adaptMessageIds(capabilities);
+
+ Assert.assertEquals(0x10 + 0, EthMessageCodes.STATUS.asByte());
+ Assert.assertEquals(0x10 + 1, EthMessageCodes.GET_TRANSACTIONS.asByte());
+ Assert.assertEquals(0x10 + 2, EthMessageCodes.TRANSACTIONS.asByte());
+ Assert.assertEquals(0x10 + 3, EthMessageCodes.GET_BLOCK_HASHES.asByte());
+ Assert.assertEquals(0x10 + 4, EthMessageCodes.BLOCK_HASHES.asByte());
+ Assert.assertEquals(0x10 + 5, EthMessageCodes.GET_BLOCKS.asByte());
+ Assert.assertEquals(0x10 + 6, EthMessageCodes.BLOCKS.asByte());
+ Assert.assertEquals(0x10 + 7, EthMessageCodes.NEW_BLOCK.asByte());
+ Assert.assertEquals(0x10 + 8, EthMessageCodes.PACKET_COUNT.asByte());
+
+ Assert.assertEquals(0x19 + 0, ShhMessageCodes.STATUS.asByte());
+ Assert.assertEquals(0x19 + 1, ShhMessageCodes.MESSAGE.asByte());
+ Assert.assertEquals(0x19 + 2, ShhMessageCodes.ADD_FILTER.asByte());
+ Assert.assertEquals(0x19 + 3, ShhMessageCodes.REMOVE_FILTER.asByte());
+ Assert.assertEquals(0x19 + 4, ShhMessageCodes.PACKET_COUNT.asByte());
+ }
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/serpent/MachineCompileTest.java b/ethereumj-core/src/test/java/org/ethereum/serpent/MachineCompileTest.java
new file mode 100644
index 00000000..38fdcbb4
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/serpent/MachineCompileTest.java
@@ -0,0 +1,59 @@
+package org.ethereum.serpent;
+
+import org.ethereum.serpent.SerpentCompiler;
+
+import org.junit.Test;
+
+import org.spongycastle.util.encoders.Hex;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author Roman Mandeleil
+ * @since 28.05.2014
+ */
+public class MachineCompileTest {
+
+ @Test // very simple contract
+ public void test1() {
+
+ String code = "a=2";
+ String expected = "6005600c60003960056000f36002600052";
+ String asm = SerpentCompiler.compile(code);
+ byte[] machineCode = SerpentCompiler.compileAssemblyToMachine(asm);
+ byte[] vmReadyCode = SerpentCompiler.encodeMachineCodeForVMRun(machineCode, null);
+
+ String result = Hex.toHexString(vmReadyCode);
+ assertEquals(expected, result);
+ }
+
+ @Test // contract for 256 bytes (len 2 bytes)
+ public void test2() {
+
+ String code = "a=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\na=2\n[asm PUSH10 asm]";
+ String expected = "610100600e6000396101006000f360026000526002600052600260005260026000526002600052600260005260026000526002600052600260005260026000526002600052600260005260026000526002600052600260005260026000526002600052600260005260026000526002600052600260005260026000526002600052600260005260026000526002600052600260005260026000526002600052600260005260026000526002600052600260005260026000526002600052600260005260026000526002600052600260005260026000526002600052600260005260026000526002600052600260005260026000526002600052600260005260026000526002600052600260005269";
+ String asm = SerpentCompiler.compile(code);
+ byte[] machineCode = SerpentCompiler.compileAssemblyToMachine(asm);
+ byte[] vmReadyCode = SerpentCompiler.encodeMachineCodeForVMRun(machineCode, null);
+
+ String result = Hex.toHexString(vmReadyCode);
+
+ assertEquals(expected, result);
+ }
+
+ @Test // contract for if jump
+ public void test3() {
+
+ String code = "a=2\n" +
+ "if a>0:\n" +
+ " b = 3\n" +
+ "else: \n" +
+ " c = 4";
+// String expected = "610100600e6000396101006000f260026000546002600054600260005460026000546002600054600260005460026000546002600054600260005460026000546002600054600260005460026000546002600054600260005460026000546002600054600260005460026000546002600054600260005460026000546002600054600260005460026000546002600054600260005460026000546002600054600260005460026000546002600054600260005460026000546002600054600260005460026000546002600054600260005460026000546002600054600260005460026000546002600054600260005460026000546002600054600260005460026000546002600054600260005469";
+ String asm = SerpentCompiler.compile(code);
+ byte[] machineCode = SerpentCompiler.compileAssemblyToMachine(asm);
+ byte[] vmReadyCode = SerpentCompiler.encodeMachineCodeForVMRun(machineCode, null);
+
+ System.out.println(asm);
+ }
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/serpent/SerpentCompileTest.java b/ethereumj-core/src/test/java/org/ethereum/serpent/SerpentCompileTest.java
new file mode 100644
index 00000000..aef025ec
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/serpent/SerpentCompileTest.java
@@ -0,0 +1,1330 @@
+package org.ethereum.serpent;
+
+import org.ethereum.serpent.ParserUtils;
+import org.ethereum.serpent.SerpentCompiler;
+import org.ethereum.serpent.SerpentLexer;
+import org.ethereum.serpent.SerpentParser;
+import org.ethereum.serpent.SerpentToAssemblyCompiler;
+
+import org.antlr.v4.runtime.tree.ParseTree;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * @author Roman Mandeleil
+ * @since 13.05.14
+ */
+public class SerpentCompileTest {
+
+ @Test // assign test 1
+ public void test1() {
+
+ String code = "a=2";
+ String expected = "2 0 MSTORE";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // assign test 2
+ public void test2() {
+
+ String code = "a=2\n" +
+ "b=6";
+ String expected = "2 0 MSTORE 6 32 MSTORE";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // assign test 3
+ public void test3() {
+
+ String code = "a=2\n" +
+ "b=6\n" +
+ "c=b";
+ String expected = "2 0 MSTORE 6 32 MSTORE 32 MLOAD 64 MSTORE";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // assign test 4
+ public void test4() {
+
+ String code = "a=2\n" +
+ "b=6\n" +
+ "c=b\n" +
+ "a=c";
+ String expected = "2 0 MSTORE 6 32 MSTORE 32 MLOAD 64 MSTORE 64 MLOAD 0 MSTORE";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test(expected = SerpentToAssemblyCompiler.UnassignVarException.class) // assign test 5
+ public void test5() {
+
+ String code = "a=2\n" +
+ "b=6\n" +
+ "c=b\n" +
+ "a=c\n" +
+ "a=d";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ new SerpentToAssemblyCompiler().visit(tree);
+ fail("No exception was thrown");
+ }
+
+ @Test // expression test 1
+ public void test6() {
+
+ String code = "a = 2 * 2";
+ String expected = "2 2 MUL 0 MSTORE";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // expression test 2
+ public void test7() {
+
+ String code = "a = 2 * 2 xor 2 * 2";
+ String expected = "2 2 MUL 2 2 MUL XOR 0 MSTORE";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // expression test 3
+ public void test8() {
+
+ String code = "a = 2 | 2 xor 2 * 2";
+ String expected = "2 2 MUL 2 XOR 2 OR 0 MSTORE";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // expression test 4
+ public void test9() {
+
+ String code = "a = (2 | 2) xor (2 * 2)";
+ String expected = "2 2 MUL 2 2 OR XOR 0 MSTORE";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // expression test 5
+ public void test10() {
+
+ String code = "a = !(2 | 2 xor 2 * 2)";
+ String expected = "2 2 MUL 2 XOR 2 OR NOT 0 MSTORE";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // expression test 6
+ public void test11() {
+
+ String code = "a = 2 + 2 * 2 + 2";
+ String expected = "2 2 2 MUL 2 ADD ADD 0 MSTORE";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // expression test 7
+ public void test12() {
+
+ String code = "a = 2 / 1 * 2 + 2";
+ String expected = "2 2 1 2 DIV MUL ADD 0 MSTORE";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // expression test 8
+ public void test13() {
+
+ String code = "a = 2 - 0x1a * 5 + 0xA";
+ String expected = "10 5 26 MUL 2 SUB ADD 0 MSTORE";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // expression test 9
+ public void test14() {
+
+ String code = "a = 1 > 2 > 3 > 4";
+ String expected = "4 3 2 1 GT GT GT 0 MSTORE";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // expression test 10
+ public void test15() {
+
+ String code = "a = !( 1 + 2 * 9 | 8 == 2)";
+ String expected = "2 8 EQ 9 2 MUL 1 ADD OR NOT 0 MSTORE";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // if elif else test 1
+ public void test16() {
+
+ String code = "if 1>2: \n" +
+ " a=2";
+ String expected = "2 1 GT NOT REF_1 JUMPI 2 0 MSTORE REF_0 JUMP LABEL_1 LABEL_0";
+
+ /**
+
+ 2 1 GT NOT REF_1 JUMPI
+ 2 0 MSTORE
+ REF_0 JUMP
+ LABEL_1 LABEL_0
+
+ */
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class, SerpentParser.class,
+ code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // if elif else test 2
+ public void test17() {
+
+ String code = "if 10 > 2 + 5: \n" +
+ " a=2";
+ String expected = "5 2 ADD 10 GT NOT REF_1 JUMPI 2 0 MSTORE REF_0 JUMP LABEL_1 LABEL_0";
+
+ /**
+
+ 5 2 ADD 10 GT NOT REF_1 JUMPI
+ 2 0 MSTORE
+ REF_0 JUMP
+ LABEL_1 LABEL_0
+
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // if elif else test 3
+ public void test18() {
+
+ String code = "if 10 > 2 + 5: \n" +
+ " a=2\n" +
+ "else: \n" +
+ " c=3\n";
+ String expected = "5 2 ADD 10 GT NOT REF_1 JUMPI 2 0 MSTORE REF_0 JUMP LABEL_1 3 32 MSTORE LABEL_0";
+
+ /**
+ 5 2 ADD 10 GT NOT REF_1 JUMPI
+ 2 0 MSTORE
+ REF_0 JUMP
+ LABEL_1
+ 3 32 MSTORE
+ LABEL_0
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // if elif else test 4
+ public void test19() {
+
+ String code = "if 10 > 2 + 5: \n" +
+ " a=2\n" +
+ "else: \n" +
+ " c=123\n" +
+ " d=0xFFAA";
+ String expected = "5 2 ADD 10 GT NOT REF_1 JUMPI 2 0 MSTORE REF_0 JUMP LABEL_1 123 32 MSTORE 65450 64 MSTORE LABEL_0";
+
+ /**
+ 5 2 ADD 10 GT NOT REF_1 JUMPI
+ 2 0 MSTORE
+ REF_0 JUMP
+ LABEL_1
+ 123 32 MSTORE
+ 65450 64 MSTORE
+ LABEL_0
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // if elif else test 5
+ public void test20() {
+
+ String code = "if 10 > 2 + 5: \n" +
+ " a=2\n" +
+ "elif 2*2==4: \n" +
+ " a=3\n" +
+ "else: \n" +
+ " c=123\n" +
+ " d=0xFFAA";
+ String expected = "5 2 ADD 10 GT NOT REF_1 JUMPI 2 0 MSTORE REF_0 JUMP LABEL_1 4 2 2 MUL EQ NOT REF_2 JUMPI 3 0 MSTORE REF_0 JUMP LABEL_2 123 32 MSTORE 65450 64 MSTORE LABEL_0";
+
+ /**
+ 5 2 ADD 10 GT NOT REF_1 JUMPI
+ 2 0 MSTORE
+ REF_0 JUMP
+ LABEL_1
+ 4 2 2 MUL EQ NOT REF_2 JUMPI
+ 3 0 MSTORE
+ REF_0 JUMP
+ LABEL_2
+ 123 32 MSTORE
+ 65450 64 MSTORE
+ LABEL_0
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // if elif else test 6
+ public void test21() {
+
+ String code = "if 10 < 2 + 5: \n" +
+ " a=2\n" +
+ "elif 2*2==4: \n" +
+ " a=3\n" +
+ "elif 2*2+10==40: \n" +
+ " a=3\n" +
+ " a=9\n" +
+ " a=21\n" +
+ "else: \n" +
+ " c=123\n" +
+ " d=0xFFAA";
+ String expected = "5 2 ADD 10 LT NOT REF_1 JUMPI 2 0 MSTORE REF_0 JUMP LABEL_1 4 2 2 MUL EQ NOT REF_2 JUMPI 3 0 MSTORE REF_0 JUMP LABEL_2 40 10 2 2 MUL ADD EQ NOT REF_3 JUMPI 3 0 MSTORE 9 0 MSTORE 21 0 MSTORE REF_0 JUMP LABEL_3 123 32 MSTORE 65450 64 MSTORE LABEL_0";
+
+ /**
+
+ 5 2 ADD 10 LT NOT REF_1 JUMPI
+ 2 0 MSTORE
+ REF_0 JUMP
+ LABEL_1
+ 4 2 2 MUL EQ NOT REF_2 JUMPI
+ 3 0 MSTORE
+ REF_0 JUMP
+ LABEL_2
+ 40 10 2 2 MUL ADD EQ NOT REF_3 JUMPI
+ 3 0 MSTORE
+ 9 0 MSTORE
+ 21 0 MSTORE
+ REF_0 JUMP
+ LABEL_3
+ 123 32 MSTORE
+ 65450 64 MSTORE
+ LABEL_0
+
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // if elif else test 7
+ public void test22() {
+
+ String code = "if 10 > 2 + 5: \n" +
+ " a=2\n" +
+ "elif 2*2==4: \n" +
+ " a=3\n" +
+ " if a==3:\n" +
+ " q=123\n" +
+ "elif 2*2+10==40: \n" +
+ " a=3\n" +
+ " a=9\n" +
+ " a=21\n" +
+ "else: \n" +
+ " c=123\n" +
+ " d=0xFFAA";
+ String expected = "5 2 ADD 10 GT NOT REF_1 JUMPI 2 0 MSTORE REF_0 JUMP LABEL_1 4 2 2 MUL EQ NOT REF_2 JUMPI 3 0 MSTORE 3 0 MLOAD EQ NOT REF_4 JUMPI 123 32 MSTORE REF_3 JUMP LABEL_4 LABEL_3 REF_0 JUMP LABEL_2 40 10 2 2 MUL ADD EQ NOT REF_5 JUMPI 3 0 MSTORE 9 0 MSTORE 21 0 MSTORE REF_0 JUMP LABEL_5 123 64 MSTORE 65450 96 MSTORE LABEL_0";
+
+ /**
+ 5 2 ADD 10 GT NOT REF_1 JUMPI
+ 2 0 MSTORE
+ REF_0 JUMP
+ LABEL_1
+ 4 2 2 MUL EQ NOT REF_2 JUMPI
+ 3 0 MSTORE
+ 3 0 MLOAD EQ NOT REF_4 JUMPI
+ 123 32 MSTORE
+ REF_3 JUMP
+ LABEL_4
+ LABEL_3
+ REF_0
+ JUMP LABEL_2
+ 40 10 2 2 MUL ADD EQ NOT REF_5 JUMPI
+ 3 0 MSTORE
+ 9 0 MSTORE
+ 21 0 MSTORE
+ REF_0 JUMP
+ LABEL_5
+ 123 64 MSTORE
+ 65450 96 MSTORE
+ LABEL_0
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // if elif else test 8
+ public void test23() {
+
+ String code = "if (10 >= 2 + 5) && (2 * 7 > 96): \n" +
+ " a=2\n" +
+ "elif 2*2==4: \n" +
+ " a=3\n" +
+ " if a==3:\n" +
+ " q=123\n" +
+ "elif 2*2+10==40: \n" +
+ " a=3\n" +
+ " a=9\n" +
+ " a=21\n" +
+ "else: \n" +
+ " c=123\n" +
+ " d=0xFFAA";
+ String expected = "96 7 2 MUL GT 5 2 ADD 10 LT NOT NOT NOT MUL NOT REF_1 JUMPI 2 0 MSTORE REF_0 JUMP LABEL_1 4 2 2 MUL EQ NOT REF_2 JUMPI 3 0 MSTORE 3 0 MLOAD EQ NOT REF_4 JUMPI 123 32 MSTORE REF_3 JUMP LABEL_4 LABEL_3 REF_0 JUMP LABEL_2 40 10 2 2 MUL ADD EQ NOT REF_5 JUMPI 3 0 MSTORE 9 0 MSTORE 21 0 MSTORE REF_0 JUMP LABEL_5 123 64 MSTORE 65450 96 MSTORE LABEL_0";
+
+ /**
+ 96 7 2 MUL GT 5 2 ADD 10 LT NOT NOT NOT MUL NOT REF_1 JUMPI
+ 2 0 MSTORE
+ REF_0 JUMP
+ LABEL_1
+ 4 2 2 MUL EQ NOT REF_2 JUMPI
+ 3 0 MSTORE
+ 3 0 MLOAD EQ NOT REF_4 JUMPI
+ 123 32 MSTORE
+ REF_3 JUMP
+ LABEL_4
+ LABEL_3
+ REF_0 JUMP
+ LABEL_2
+ 40 10 2 2 MUL ADD EQ NOT REF_5 JUMPI
+ 3 0 MSTORE
+ 9 0 MSTORE
+ 21 0 MSTORE
+ REF_0 JUMP
+ LABEL_5
+ 123 64 MSTORE
+ 65450 96 MSTORE
+ LABEL_0
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // if elif else test 9
+ public void test24() {
+
+ String code = "a = 20\n" +
+ "b = 40\n" +
+ "if a == 20: \n" +
+ " a = 30\n" +
+ "if b == 40: \n" +
+ " b = 50\n";
+ String expected = "20 0 MSTORE 40 32 MSTORE 20 0 MLOAD EQ NOT REF_1 JUMPI 30 0 MSTORE REF_0 JUMP LABEL_1 LABEL_0 40 32 MLOAD EQ NOT REF_3 JUMPI 50 32 MSTORE REF_2 JUMP LABEL_3 LABEL_2";
+
+ /**
+
+ 20 0 MSTORE
+ 40 32 MSTORE
+ 20 0 MLOAD EQ NOT REF_1 JUMPI
+ 30 0 MSTORE REF_0 JUMP
+ LABEL_1
+ LABEL_0
+ 40 32 MLOAD EQ NOT REF_3 JUMPI
+ 50 32 MSTORE
+ REF_2 JUMP
+ LABEL_3 LABEL_2
+
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // if elif else test 10
+ public void test25() {
+
+ String code = "a = 20\n" +
+ "b = 40\n" +
+ "if a == 20: \n" +
+ " a = 30\n" +
+ "a = 70\n" +
+ "if b == 40: \n" +
+ " b = 50\n";
+ String expected = "20 0 MSTORE 40 32 MSTORE 20 0 MLOAD EQ NOT REF_1 JUMPI 30 0 MSTORE REF_0 JUMP LABEL_1 LABEL_0 70 0 MSTORE 40 32 MLOAD EQ NOT REF_3 JUMPI 50 32 MSTORE REF_2 JUMP LABEL_3 LABEL_2";
+
+ /**
+
+ 20 0 MSTORE
+ 40 32 MSTORE
+ 20 0 MLOAD EQ NOT REF_1 JUMPI
+ 30 0 MSTORE
+ REF_0 JUMP
+ LABEL_1
+ LABEL_0
+ 70 0 MSTORE
+ 40 32 MLOAD EQ NOT REF_3 JUMPI
+ 50 32 MSTORE
+ REF_2 JUMP
+ LABEL_3 LABEL_2
+
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // if elif else test 11
+ public void test26() {
+
+ String code = "if 2>1: \n" +
+ " if 3>2: \n" +
+ " if 4>3:\n" +
+ " if 5>4:\n" +
+ " a = 10\n";
+ String expected = "1 2 GT NOT REF_7 JUMPI 2 3 GT NOT REF_6 JUMPI 3 4 GT NOT REF_5 JUMPI 4 5 GT NOT REF_4 JUMPI 10 0 MSTORE REF_3 JUMP LABEL_4 LABEL_3 REF_2 JUMP LABEL_5 LABEL_2 REF_1 JUMP LABEL_6 LABEL_1 REF_0 JUMP LABEL_7 LABEL_0";
+
+ /**
+
+ 1 2 GT NOT REF_7 JUMPI
+ 2 3 GT NOT REF_6 JUMPI
+ 3 4 GT NOT REF_5 JUMPI
+ 4 5 GT NOT REF_4 JUMPI
+ 10 0 MSTORE
+ REF_3 JUMP
+ LABEL_4 LABEL_3 REF_2 JUMP LABEL_5 LABEL_2 REF_1 JUMP LABEL_6 LABEL_1 REF_0 JUMP LABEL_7 LABEL_0
+
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // if elif else test 12
+ public void test27() {
+
+ String code = "if 2>1: \n" +
+ " if 3>2: \n" +
+ " if 4>3:\n" +
+ " if 5>4:\n" +
+ " a = 10\n";
+ String expected = "1 2 GT NOT REF_7 JUMPI 2 3 GT NOT REF_6 JUMPI 3 4 GT NOT REF_5 JUMPI 4 5 GT NOT REF_4 JUMPI 10 0 MSTORE REF_3 JUMP LABEL_4 LABEL_3 REF_2 JUMP LABEL_5 LABEL_2 REF_1 JUMP LABEL_6 LABEL_1 REF_0 JUMP LABEL_7 LABEL_0";
+
+ /**
+
+ 1 2 GT NOT REF_7 JUMPI
+ 2 3 GT NOT REF_6 JUMPI
+ 3 4 GT NOT REF_5 JUMPI
+ 4 5 GT NOT REF_4 JUMPI
+ 10 0 MSTORE
+ REF_3 JUMP
+ LABEL_4 LABEL_3 REF_2 JUMP LABEL_5 LABEL_2 REF_1 JUMP LABEL_6 LABEL_1 REF_0 JUMP LABEL_7 LABEL_0
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // if elif else test 13
+ public void test28() {
+
+ String code = "if 2>1: \n" +
+ " if 3>2: \n" +
+ " if 4>3:\n" +
+ " if 5>4:\n" +
+ " a = 10\n" +
+ " else:\n" +
+ " b = 20\n";
+ String expected = "1 2 GT NOT REF_7 JUMPI 2 3 GT NOT REF_6 JUMPI 3 4 GT NOT REF_5 JUMPI 4 5 GT NOT REF_4 JUMPI 10 0 MSTORE REF_3 JUMP LABEL_4 20 32 MSTORE LABEL_3 REF_2 JUMP LABEL_5 LABEL_2 REF_1 JUMP LABEL_6 LABEL_1 REF_0 JUMP LABEL_7 LABEL_0";
+
+ /**
+
+ 1 2 GT NOT REF_7 JUMPI
+ 2 3 GT NOT REF_6 JUMPI
+ 3 4 GT NOT REF_5 JUMPI
+ 4 5 GT NOT REF_4 JUMPI
+ 10 0 MSTORE
+ REF_3 JUMP
+ LABEL_4
+ 20 32 MSTORE
+ LABEL_3 REF_2 JUMP LABEL_5 LABEL_2 REF_1 JUMP LABEL_6 LABEL_1 REF_0 JUMP LABEL_7 LABEL_0
+
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test(expected = ParserUtils.AntlrParseException.class) // if elif else test 14
+ public void test29() {
+
+ String code = " if 2>4: \n" +
+ " a=20 \n" +
+ " \n" +
+ " \n";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+
+ parser.parse();
+ fail("Should be indent error thrown");
+ }
+
+ @Test(expected = ParserUtils.AntlrParseException.class) // if elif else test 15
+ public void test30() {
+
+ String code = "if 2>4: \n" +
+ " a=20 \n" +
+ " else: \n" +
+ " a=40 \n";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+
+ parser.parse();
+ fail("Should be indent error thrown");
+ }
+
+ @Test(expected = ParserUtils.AntlrParseException.class) // if elif else test 16
+ public void test31() {
+
+ String code = "if 2>4: \n" +
+ " a=20 \n" +
+ " elif 2<9: \n" +
+ " a=40 \n" +
+ "else: \n" +
+ " a=40 \n";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+
+ parser.parse();
+ fail("Should be indent error thrown");
+ }
+
+ @Test // if elif else test 17
+ public void test32() {
+
+ String code = "if 2*2==4: \n" +
+ " if 3*3==9: \n" +
+ " if 4*4==16: \n" +
+ " a=20 \n" +
+ " else: \n" +
+ " b=20 \n";
+ String expected = "4 2 2 MUL EQ NOT REF_5 JUMPI 9 3 3 MUL EQ NOT REF_4 JUMPI 16 4 4 MUL EQ NOT REF_3 JUMPI 20 0 MSTORE REF_2 JUMP LABEL_3 LABEL_2 REF_1 JUMP LABEL_4 20 32 MSTORE LABEL_1 REF_0 JUMP LABEL_5 LABEL_0";
+
+ /**
+
+ 4 2 2 MUL EQ NOT REF_5 JUMPI
+ 9 3 3 MUL EQ NOT REF_4 JUMPI
+ 16 4 4 MUL EQ NOT REF_3 JUMPI
+ 20 0 MSTORE
+ REF_2 JUMP
+ LABEL_3 LABEL_2 REF_1 JUMP LABEL_4
+ 20 32 MSTORE
+ LABEL_1 REF_0 JUMP LABEL_5 LABEL_0
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test(expected = ParserUtils.AntlrParseException.class) // if elif else test 18
+ public void test33() {
+
+ String code = "if 2*2==4: \n" +
+ " if 3*3==9: \n" +
+ " if 4*4==16: \n" +
+ " a=20 \n" +
+ " else: \n" +
+ " \n";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+
+ parser.parse();
+ fail("Should be indent error thrown");
+ }
+
+ @Test // if elif else test 19
+ public void test34() {
+
+ String code = "if 2>1: \n" +
+ " if 3>2: \n" +
+ " if 4>3: \n" +
+ " if 5>4: \n" +
+ " a = 10\n" +
+ " else: \n" +
+ " b = 20\n" +
+ " elif 2*2 != 4: \n" +
+ " a = 15\n";
+ String expected = "1 2 GT NOT REF_8 JUMPI 2 3 GT NOT REF_7 JUMPI 3 4 GT NOT REF_5 JUMPI 4 5 GT NOT REF_4 JUMPI 10 0 MSTORE REF_3 JUMP LABEL_4 20 32 MSTORE LABEL_3 REF_2 JUMP LABEL_5 4 2 2 MUL EQ NOT NOT REF_6 JUMPI 15 0 MSTORE REF_2 JUMP LABEL_6 LABEL_2 REF_1 JUMP LABEL_7 LABEL_1 REF_0 JUMP LABEL_8 LABEL_0";
+
+ /**
+
+ 1 2 GT NOT REF_8 JUMPI
+ 2 3 GT NOT REF_7 JUMPI
+ 3 4 GT NOT REF_5 JUMPI
+ 4 5 GT NOT REF_4 JUMPI
+ 10 0 MSTORE
+ REF_3 JUMP
+ LABEL_4
+ 20 32 MSTORE
+ LABEL_3 REF_2 JUMP
+ LABEL_5
+ 4 2 2 MUL EQ NOT NOT REF_6 JUMPI
+ 15 0 MSTORE
+ REF_2 JUMP LABEL_6 LABEL_2 REF_1 JUMP LABEL_7 LABEL_1 REF_0 JUMP LABEL_8 LABEL_0
+
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // if elif else test 20
+ public void test35() {
+
+ String code = "if 2>1: \n" +
+ " a=20 \n" +
+ "elif 5<1: \n" +
+ " a=30 \n" +
+ "elif 6>6: \n" +
+ " a=40 \n" +
+ "else: \n" +
+ " a=50 \n";
+
+ String expected = "1 2 GT NOT REF_1 JUMPI 20 0 MSTORE REF_0 JUMP LABEL_1 1 5 LT NOT REF_2 JUMPI 30 0 MSTORE REF_0 JUMP LABEL_2 6 6 GT NOT REF_3 JUMPI 40 0 MSTORE REF_0 JUMP LABEL_3 50 0 MSTORE LABEL_0";
+
+ /**
+
+ 1 2 GT NOT REF_1 JUMPI
+ 20 0 MSTORE
+ REF_0 JUMP
+ LABEL_1
+ 1 5 LT NOT REF_2 JUMPI
+ 30 0 MSTORE
+ REF_0 JUMP
+ LABEL_2
+ 6 6 GT NOT REF_3 JUMPI
+ 40 0 MSTORE
+ REF_0 JUMP
+ LABEL_3
+ 50 0 MSTORE
+ LABEL_0
+
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // while test 1
+ public void test36() {
+
+ String code = "a = 20 \n" +
+ "while a>0: \n" +
+ " a = a - 1 \n";
+
+ String expected = "20 0 MSTORE LABEL_0 0 0 MLOAD GT NOT REF_1 JUMPI 1 0 MLOAD SUB 0 MSTORE REF_0 JUMP LABEL_1";
+
+ /**
+
+ 20 0 MSTORE
+ LABEL_0
+ 0 0 MLOAD GT EQ NOT REF_1 JUMPI
+ 1 0 MLOAD SUB 0 MSTORE
+ REF_0 JUMP
+ LABEL_1
+
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // while test 2
+ public void test37() {
+
+ String code = "x = 248 \n" +
+ "while x > 1: \n" +
+ " if (x % 2) == 0: \n" +
+ " x = x / 2 \n" +
+ " else: \n " +
+ " x = 3 * x + 1 \n";
+
+ String expected = "248 0 MSTORE LABEL_0 1 0 MLOAD GT NOT REF_1 JUMPI 0 2 0 MLOAD MOD EQ NOT REF_3 JUMPI 2 0 MLOAD DIV 0 MSTORE REF_2 JUMP LABEL_3 1 0 MLOAD 3 MUL ADD 0 MSTORE LABEL_2 REF_0 JUMP LABEL_1";
+
+ /**
+
+ 248 0 MSTORE
+ LABEL_0
+ 1 0 MLOAD GT NOT REF_1 JUMPI
+ 0 2 0 MLOAD MOD EQ NOT REF_3 JUMPI
+ 2 0 MLOAD DIV 0 MSTORE
+ REF_2 JUMP
+ LABEL_3
+ 1 0 MLOAD 3 MUL ADD 0 MSTORE
+ LABEL_2
+
+ REF_0 JUMP
+ LABEL_1
+
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // while test 3
+ public void test38() {
+
+ String code = "x = 0xFF \n" +
+ "while x > 1: \n" +
+ " if (x % 2) == 0: \n" +
+ " x = x / 2 \n" +
+ "x = x +2 \n" +
+ "x = 3 * x + 1 \n";
+
+ String expected = "255 0 MSTORE LABEL_0 1 0 MLOAD GT NOT REF_1 JUMPI 0 2 0 MLOAD MOD EQ NOT REF_3 JUMPI 2 0 MLOAD DIV 0 MSTORE REF_2 JUMP LABEL_3 LABEL_2 REF_0 JUMP LABEL_1 2 0 MLOAD ADD 0 MSTORE 1 0 MLOAD 3 MUL ADD 0 MSTORE";
+
+ /**
+
+ 255 0 MSTORE
+ LABEL_0
+ 1 0 MLOAD GT EQ NOT REF_1 JUMPI
+ 0 2 0 MLOAD MOD EQ NOT REF_3 JUMPI
+ 2 0 MLOAD DIV 0 MSTORE REF_2 JUMP
+ LABEL_3 LABEL_2
+ REF_0 JUMP
+ LABEL_1
+ 2 0 MLOAD ADD 0 MSTORE
+ 1 0 MLOAD 3 MUL ADD 0 MSTORE
+
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test(expected = ParserUtils.AntlrParseException.class) // while test 4
+ public void test39() {
+
+ String code = "x = 0xFF\n" +
+ "while x > 1:\n" +
+ "x = x +2\n" +
+ "x = 3 * x + 1";
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+
+ parser.parse();
+ fail("Should be indent error thrown");
+ }
+
+ @Test // while test 5
+ public void test40() {
+
+ String code = "x = 0xFF\n" +
+ "while (x > 1) && (x > 2) && (x > 3) && (2 <9):\n" +
+ " x = x -2\n";
+
+ String expected = "255 0 MSTORE LABEL_0 9 2 LT 3 0 MLOAD GT 2 0 MLOAD GT 1 0 MLOAD GT NOT NOT MUL NOT NOT MUL NOT NOT MUL NOT REF_1 JUMPI 2 0 MLOAD SUB 0 MSTORE REF_0 JUMP LABEL_1";
+
+ /**
+
+ 255 0 MSTORE
+ LABEL_0
+ 9 2 LT 3 0 MLOAD GT 2 0 MLOAD GT 1 0 MLOAD GT NOT NOT MUL NOT NOT MUL NOT NOT MUL EQ NOT REF_1 JUMPI
+ 2 0 MLOAD SUB 0 MSTORE
+ REF_0 JUMP
+ LABEL_1
+
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // special functions test 1
+ public void test41() {
+
+ String code = "a = msg.datasize\n" +
+ "b = msg.sender\n" +
+ "c = msg.value\n" +
+ "d = tx.gasprice\n" +
+ "e = tx.origin\n" +
+ "f = tx.gas\n" +
+ "g = contract.balance\n" +
+ "h = block.prevhash\n" +
+ "i = block.coinbase\n" +
+ "j = block.timestamp\n" +
+ "k = block.number\n" +
+ "l = block.difficulty\n" +
+ "m = block.gaslimit\n";
+
+ String expected = "32 CALLDATASIZE DIV 0 MSTORE CALLER 32 MSTORE CALLVALUE 64 MSTORE GASPRICE 96 MSTORE ORIGIN 128 MSTORE GAS 160 MSTORE BALANCE 192 MSTORE PREVHASH 224 MSTORE COINBASE 256 MSTORE TIMESTAMP 288 MSTORE NUMBER 320 MSTORE DIFFICULTY 352 MSTORE GASLIMIT 384 MSTORE";
+
+ /**
+
+ 32 CALLDATASIZE DIV 0 MSTORE
+ CALLER 32 MSTORE
+ CALLVALUE 64 MSTORE
+ GASPRICE 96 MSTORE
+ ORIGIN 128 MSTORE
+ GAS 160 MSTORE
+ BALANCE 192 MSTORE
+ PREVHASH 224 MSTORE
+ COINBASE 256 MSTORE
+ TIMESTAMP 288 MSTORE
+ NUMBER 320 MSTORE
+ DIFFICULTY 352 MSTORE
+ GASLIMIT 384 MSTORE
+
+ */
+
+ SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
+ SerpentParser.class, code);
+ ParseTree tree = parser.parse();
+
+ String result = new SerpentToAssemblyCompiler().visit(tree);
+ result = result.replaceAll("\\s+", " ");
+ result = result.trim();
+
+ assertEquals(expected, result);
+ }
+
+ @Test // compile to machine code 1
+ public void test42() {
+
+ String code = "x = 256 \n" +
+ "while x > 1: \n" +
+ " if (x % 2) == 0: \n" +
+ " x = x / 2 \n" +
+ " else: \n " +
+ " x = 3 * x + 1 \n";
+
+ String expected = "97 1 0 96 0 84 96 1 96 0 83 11 12 13 99 0 0 0 53 89 96 0 96 2 96 0 83 6 12 13 99 0 0 0 39 89 96 2 96 0 83 4 96 0 84 99 0 0 0 51 88 96 1 96 0 83 96 3 2 1 96 0 84 99 0 0 0 6 88";
+
+ String asmResult = SerpentCompiler.compile(code);
+ byte[] machineCode = SerpentCompiler.compileAssemblyToMachine(asmResult);
+
+ }
+
+ @Test // test init/code blocks 1
+ public void test43() {
+ String code = "init:\n" +
+ " a = 2\n" +
+ "code:\n" +
+ " b=msg.data[1]\n" +
+ " stop\n";
+
+ String expected = "[init 2 0 MSTORE init] [code 1 32 MUL CALLDATALOAD 0 MSTORE STOP code]";
+ String asmResult = SerpentCompiler.compileFullNotion(code);
+ assertEquals(expected, asmResult);
+ }
+
+ @Test // test arrays 1 simple create
+ public void test45() {
+ String code = "c = 2\n" +
+ "d = 3\n" +
+ "a = [11, 22, 33]";
+ String expected = "0 63 MSTORE8 2 0 MSTORE 3 32 MSTORE MSIZE 32 ADD MSIZE DUP 32 ADD 11 SWAP MSTORE DUP 64 ADD 22 SWAP MSTORE DUP 96 ADD 33 SWAP MSTORE 128 SWAP MSTORE";
+
+ String asmResult = SerpentCompiler.compile(code);
+ assertEquals(expected, asmResult);
+ }
+
+ @Test // test arrays 2 simple set
+ public void test46() {
+ String code = "a = [11, 22, 33]\n" +
+ "a[ 2 ] = 3";
+ String expected = "MSIZE 32 ADD MSIZE DUP 32 ADD 11 SWAP MSTORE DUP 64 ADD 22 SWAP MSTORE DUP 96 ADD 33 SWAP MSTORE 128 SWAP MSTORE 3 32 2 MUL 32 ADD 0 ADD 0 ADD MSTORE";
+
+ String asmResult = SerpentCompiler.compile(code);
+ assertEquals(expected, asmResult);
+ }
+
+ @Test // test arrays 3 simple
+ public void test46_1() {
+ String code = "a = [11, 22, 33]\n";
+ String expected = "MSIZE 32 ADD MSIZE DUP 32 ADD 11 SWAP MSTORE DUP 64 ADD 22 SWAP MSTORE DUP 96 ADD 33 SWAP MSTORE 128 SWAP MSTORE";
+
+ String asmResult = SerpentCompiler.compile(code);
+ assertEquals(expected, asmResult);
+ }
+
+ @Test // test arrays 3 complicated set after 2 arrays
+ public void test47() {
+ String code = "a = [2, 4, 6]\n" +
+ "b = [12, 14]\n" +
+ "c = [22, 24, 25]\n" +
+ "c[ 0 ] = 3";
+ String expected = "MSIZE 32 ADD MSIZE DUP 32 ADD 2 SWAP MSTORE DUP 64 ADD 4 SWAP MSTORE DUP 96 ADD 6 SWAP MSTORE 128 SWAP MSTORE MSIZE 32 ADD MSIZE DUP 32 ADD 12 SWAP MSTORE DUP 64 ADD 14 SWAP MSTORE 96 SWAP MSTORE MSIZE 32 ADD MSIZE DUP 32 ADD 22 SWAP MSTORE DUP 64 ADD 24 SWAP MSTORE DUP 96 ADD 25 SWAP MSTORE 128 SWAP MSTORE 3 32 0 MUL 32 ADD 224 ADD 0 ADD MSTORE";
+
+ String asmResult = SerpentCompiler.compile(code);
+ assertEquals(expected, asmResult);
+ }
+
+ @Test // test arrays 4 simple set
+ public void test48() {
+ String code = "b = 1\n" +
+ "c = 2\n" +
+ "a = [11, 22, 33]\n" +
+ "a[ 2 ] = 3";
+ String expected = "0 63 MSTORE8 1 0 MSTORE 2 32 MSTORE MSIZE 32 ADD MSIZE DUP 32 ADD 11 SWAP MSTORE DUP 64 ADD 22 SWAP MSTORE DUP 96 ADD 33 SWAP MSTORE 128 SWAP MSTORE 3 32 2 MUL 32 ADD 0 ADD 64 ADD MSTORE";
+
+ String asmResult = SerpentCompiler.compile(code);
+ assertEquals(expected, asmResult);
+ }
+
+ @Test // test arrays 5 simple retrieve value
+ public void test49() {
+ String code = "c = [5]\n" +
+ "a = [11, 22, 33]\n" +
+ "b = a [0]";
+ String expected = "0 31 MSTORE8 MSIZE 32 ADD MSIZE DUP 32 ADD 5 SWAP MSTORE 64 SWAP MSTORE MSIZE 32 ADD MSIZE DUP 32 ADD 11 SWAP MSTORE DUP 64 ADD 22 SWAP MSTORE DUP 96 ADD 33 SWAP MSTORE 128 SWAP MSTORE 32 0 MUL 96 ADD 32 ADD MLOAD 0 MSTORE";
+
+ String asmResult = SerpentCompiler.compile(code);
+ assertEquals(expected, asmResult);
+ }
+
+ @Test // test msg(gas, to , val, [arr_in], in_len, out_len), and out access
+ public void test50() {
+ String code = "\n" +
+ "a = msg(1, 2, 3, [11, 22, 33], 3, 6) \n" +
+ "b = a[0]\n";
+ String expected = "0 31 MSTORE8 224 MSIZE 224 MSIZE MSTORE 0 192 MSIZE ADD MSTORE8 96 MSIZE 32 ADD MSIZE DUP 32 ADD 11 SWAP MSTORE DUP 64 ADD 22 SWAP MSTORE DUP 96 ADD 33 SWAP MSTORE 128 SWAP MSTORE 3 2 1 CALL 32 0 MUL 160 ADD 32 ADD MLOAD 0 MSTORE";
+
+ String asmResult = SerpentCompiler.compile(code);
+ assertEquals(expected, asmResult);
+ }
+
+ @Test // test create(gas, mem_start , mem_size)
+ public void test51() {
+ String code = "\n" +
+ "create(100, 0, 32) \n";
+ String expected = "32 0 100 CREATE";
+
+ String asmResult = SerpentCompiler.compile(code);
+ assertEquals(expected, asmResult);
+ }
+
+/*
+ TODO: more to implement
+
+# *) a = msg.data
+# 0) sha();
+# 3) x = sha3(v)
+# 4) x = byte(y,z)
+# 5) v = getch(x,i)
+# 6) setch(x,i,v)
+
+
+# 7) a=array(30)
+# 8) x = bytes(n)
+
+ */
+
+ /**
+ * TODO: a = msg(gas, to , value, in_ptr, in_len, out_ptr, out_len) testing
+ *
+ * TODO: return(1) testing
+ * TODO: return (1,2) testing
+ * TODO: msg.data testing
+ * TODO: send(1, 2, 3)
+ *
+ * TODO: contract.storage get/set testing
+ * TODO: [asm asm] testing
+ * TODO: suicide(1) testing
+ * TODO: stop testing
+ */
+
+ /**
+ TODO: add this namecoin sample to the testing
+ if !(contract.storage[msg.data[0]]):
+ contract.storage[msg.data[0]] = msg.data[1]
+ return(1)
+ else:
+ return(0)
+ */
+
+/*
+ TODO: add this curency creation sample for testing
+ "if msg.datasize == 1:\n" +
+ " addr = msg.data[0]\n" +
+ " return(contract.storage[addr])\n" +
+ "else:\n" +
+ " from = msg.sender\n" +
+ " fromvalue = contract.storage[from]\n" +
+ " to = msg.data[0]\n" +
+ " value = msg.data[1]\n" +
+ " if fromvalue >= value:\n" +
+ " contract.storage[from] = fromvalue - value\n" +
+ " contract.storage[to] = contract.storage[to] + value\n" +
+ " return(1)\n" +
+ " else:\n" +
+ " return(0)" +
+*/
+
+// MSTORE DUP DUP MSOTRE8 FUCK I AM LOST FUCK SWAP DUP SWAP DUP DUP
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/trie/TrieTest.java b/ethereumj-core/src/test/java/org/ethereum/trie/TrieTest.java
new file mode 100644
index 00000000..2c87a8ac
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/trie/TrieTest.java
@@ -0,0 +1,1032 @@
+package org.ethereum.trie;
+
+import org.ethereum.core.AccountState;
+import org.ethereum.datasource.KeyValueDataSource;
+import org.ethereum.datasource.LevelDbDataSource;
+import org.ethereum.datasource.HashMapDB;
+import org.ethereum.db.DatabaseImpl;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spongycastle.util.encoders.Hex;
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.Pipeline;
+
+import java.io.File;
+import java.io.IOException;
+import java.math.BigInteger;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.*;
+
+import static org.ethereum.crypto.HashUtil.EMPTY_TRIE_HASH;
+import static org.ethereum.crypto.SHA3Helper.sha3;
+import static org.junit.Assert.*;
+
+public class TrieTest {
+
+ private static final Logger logger = LoggerFactory.getLogger("test");
+
+ private static String LONG_STRING = "1234567890abcdefghijklmnopqrstuvwxxzABCEFGHIJKLMNOPQRSTUVWXYZ";
+ private static String ROOT_HASH_EMPTY = Hex.toHexString(EMPTY_TRIE_HASH);
+
+ private static String c = "c";
+ private static String ca = "ca";
+ private static String cat = "cat";
+ private static String dog = "dog";
+ private static String doge = "doge";
+ private static String test = "test";
+ private static String dude = "dude";
+
+ private HashMapDB mockDb = new HashMapDB();
+ private HashMapDB mockDb_2 = new HashMapDB();
+
+// ROOT: [ '\x16', A ]
+// A: [ '', '', '', '', B, '', '', '', C, '', '', '', '', '', '', '', '' ]
+// B: [ '\x00\x6f', D ]
+// D: [ '', '', '', '', '', '', E, '', '', '', '', '', '', '', '', '', 'verb' ]
+// E: [ '\x17', F ]
+// F: [ '', '', '', '', '', '', G, '', '', '', '', '', '', '', '', '', 'puppy' ]
+// G: [ '\x35', 'coin' ]
+// C: [ '\x20\x6f\x72\x73\x65', 'stallion' ]
+
+ @After
+ public void closeMockDb() throws IOException {
+ mockDb.close();
+ mockDb_2.close();
+ }
+
+ @Test
+ public void testEmptyKey() {
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update("", dog);
+ assertEquals(dog, new String(trie.get("")));
+ }
+
+ @Test
+ public void testInsertShortString() {
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update(cat, dog);
+ assertEquals(dog, new String(trie.get(cat)));
+ }
+
+ @Test
+ public void testInsertLongString() {
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update(cat, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(cat)));
+ }
+
+ @Test
+ public void testInsertMultipleItems1() {
+ TrieImpl trie = new TrieImpl(mockDb);
+ trie.update(ca, dude);
+ assertEquals(dude, new String(trie.get(ca)));
+
+ trie.update(cat, dog);
+ assertEquals(dog, new String(trie.get(cat)));
+
+ trie.update(dog, test);
+ assertEquals(test, new String(trie.get(dog)));
+
+ trie.update(doge, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(doge)));
+
+ trie.update(test, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(test)));
+
+ // Test if everything is still there
+ assertEquals(dude, new String(trie.get(ca)));
+ assertEquals(dog, new String(trie.get(cat)));
+ assertEquals(test, new String(trie.get(dog)));
+ assertEquals(LONG_STRING, new String(trie.get(doge)));
+ assertEquals(LONG_STRING, new String(trie.get(test)));
+ }
+
+ @Test
+ public void testInsertMultipleItems2() {
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update(cat, dog);
+ assertEquals(dog, new String(trie.get(cat)));
+
+ trie.update(ca, dude);
+ assertEquals(dude, new String(trie.get(ca)));
+
+ trie.update(doge, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(doge)));
+
+ trie.update(dog, test);
+ assertEquals(test, new String(trie.get(dog)));
+
+ trie.update(test, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(test)));
+
+ // Test if everything is still there
+ assertEquals(dog, new String(trie.get(cat)));
+ assertEquals(dude, new String(trie.get(ca)));
+ assertEquals(LONG_STRING, new String(trie.get(doge)));
+ assertEquals(test, new String(trie.get(dog)));
+ assertEquals(LONG_STRING, new String(trie.get(test)));
+ }
+
+ @Test
+ public void testUpdateShortToShortString() {
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update(cat, dog);
+ assertEquals(dog, new String(trie.get(cat)));
+
+ trie.update(cat, dog + "1");
+ assertEquals(dog + "1", new String(trie.get(cat)));
+ }
+
+ @Test
+ public void testUpdateLongToLongString() {
+ TrieImpl trie = new TrieImpl(mockDb);
+ trie.update(cat, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(cat)));
+ trie.update(cat, LONG_STRING + "1");
+ assertEquals(LONG_STRING + "1", new String(trie.get(cat)));
+ }
+
+ @Test
+ public void testUpdateShortToLongString() {
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update(cat, dog);
+ assertEquals(dog, new String(trie.get(cat)));
+
+ trie.update(cat, LONG_STRING + "1");
+ assertEquals(LONG_STRING + "1", new String(trie.get(cat)));
+ }
+
+ @Test
+ public void testUpdateLongToShortString() {
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update(cat, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(cat)));
+
+ trie.update(cat, dog + "1");
+ assertEquals(dog + "1", new String(trie.get(cat)));
+ }
+
+ @Test
+ public void testDeleteShortString1() {
+ String ROOT_HASH_BEFORE = "a9539c810cc2e8fa20785bdd78ec36cc1dab4b41f0d531e80a5e5fd25c3037ee";
+ String ROOT_HASH_AFTER = "fc5120b4a711bca1f5bb54769525b11b3fb9a8d6ac0b8bf08cbb248770521758";
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update(cat, dog);
+ assertEquals(dog, new String(trie.get(cat)));
+
+ trie.update(ca, dude);
+ assertEquals(dude, new String(trie.get(ca)));
+ assertEquals(ROOT_HASH_BEFORE, Hex.toHexString(trie.getRootHash()));
+
+ trie.delete(ca);
+ assertEquals("", new String(trie.get(ca)));
+ assertEquals(ROOT_HASH_AFTER, Hex.toHexString(trie.getRootHash()));
+ }
+
+ @Test
+ public void testDeleteShortString2() {
+ String ROOT_HASH_BEFORE = "a9539c810cc2e8fa20785bdd78ec36cc1dab4b41f0d531e80a5e5fd25c3037ee";
+ String ROOT_HASH_AFTER = "b25e1b5be78dbadf6c4e817c6d170bbb47e9916f8f6cc4607c5f3819ce98497b";
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update(ca, dude);
+ assertEquals(dude, new String(trie.get(ca)));
+
+ trie.update(cat, dog);
+ assertEquals(dog, new String(trie.get(cat)));
+ assertEquals(ROOT_HASH_BEFORE, Hex.toHexString(trie.getRootHash()));
+
+ trie.delete(cat);
+ assertEquals("", new String(trie.get(cat)));
+ assertEquals(ROOT_HASH_AFTER, Hex.toHexString(trie.getRootHash()));
+ }
+
+ @Test
+ public void testDeleteShortString3() {
+ String ROOT_HASH_BEFORE = "778ab82a7e8236ea2ff7bb9cfa46688e7241c1fd445bf2941416881a6ee192eb";
+ String ROOT_HASH_AFTER = "05875807b8f3e735188d2479add82f96dee4db5aff00dc63f07a7e27d0deab65";
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update(cat, dude);
+ assertEquals(dude, new String(trie.get(cat)));
+
+ trie.update(dog, test);
+ assertEquals(test, new String(trie.get(dog)));
+ assertEquals(ROOT_HASH_BEFORE, Hex.toHexString(trie.getRootHash()));
+
+ trie.delete(dog);
+ assertEquals("", new String(trie.get(dog)));
+ assertEquals(ROOT_HASH_AFTER, Hex.toHexString(trie.getRootHash()));
+ }
+
+ @Test
+ public void testDeleteLongString1() {
+ String ROOT_HASH_BEFORE = "318961a1c8f3724286e8e80d312352f01450bc4892c165cc7614e1c2e5a0012a";
+ String ROOT_HASH_AFTER = "63356ecf33b083e244122fca7a9b128cc7620d438d5d62e4f8b5168f1fb0527b";
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update(cat, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(cat)));
+
+ trie.update(dog, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(dog)));
+ assertEquals(ROOT_HASH_BEFORE, Hex.toHexString(trie.getRootHash()));
+
+ trie.delete(dog);
+ assertEquals("", new String(trie.get(dog)));
+ assertEquals(ROOT_HASH_AFTER, Hex.toHexString(trie.getRootHash()));
+ }
+
+ @Test
+ public void testDeleteLongString2() {
+ String ROOT_HASH_BEFORE = "e020de34ca26f8d373ff2c0a8ac3a4cb9032bfa7a194c68330b7ac3584a1d388";
+ String ROOT_HASH_AFTER = "334511f0c4897677b782d13a6fa1e58e18de6b24879d57ced430bad5ac831cb2";
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update(ca, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(ca)));
+
+ trie.update(cat, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(cat)));
+ assertEquals(ROOT_HASH_BEFORE, Hex.toHexString(trie.getRootHash()));
+
+ trie.delete(cat);
+ assertEquals("", new String(trie.get(cat)));
+ assertEquals(ROOT_HASH_AFTER, Hex.toHexString(trie.getRootHash()));
+ }
+
+ @Test
+ public void testDeleteLongString3() {
+ String ROOT_HASH_BEFORE = "e020de34ca26f8d373ff2c0a8ac3a4cb9032bfa7a194c68330b7ac3584a1d388";
+ String ROOT_HASH_AFTER = "63356ecf33b083e244122fca7a9b128cc7620d438d5d62e4f8b5168f1fb0527b";
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update(cat, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(cat)));
+
+ trie.update(ca, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(ca)));
+ assertEquals(ROOT_HASH_BEFORE, Hex.toHexString(trie.getRootHash()));
+
+ trie.delete(ca);
+ assertEquals("", new String(trie.get(ca)));
+ assertEquals(ROOT_HASH_AFTER, Hex.toHexString(trie.getRootHash()));
+ }
+
+ @Test
+ public void testDeleteCompletellyDiferentItems() {
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ String val_1 = "2a";
+ String val_2 = "09";
+ String val_3 = "a9";
+
+ trie.update(Hex.decode(val_1), Hex.decode(val_1));
+ trie.update(Hex.decode(val_2), Hex.decode(val_2));
+
+ String root1 = Hex.toHexString(trie.getRootHash());
+
+ trie.update(Hex.decode(val_3), Hex.decode(val_3));
+ trie.delete(Hex.decode(val_3));
+ String root1_ = Hex.toHexString(trie.getRootHash());
+
+ Assert.assertEquals(root1, root1_);
+ }
+
+
+ @Test
+ public void testDeleteMultipleItems1() {
+ String ROOT_HASH_BEFORE = "3a784eddf1936515f0313b073f99e3bd65c38689021d24855f62a9601ea41717";
+ String ROOT_HASH_AFTER1 = "60a2e75cfa153c4af2783bd6cb48fd6bed84c6381bc2c8f02792c046b46c0653";
+ String ROOT_HASH_AFTER2 = "a84739b4762ddf15e3acc4e6957e5ab2bbfaaef00fe9d436a7369c6f058ec90d";
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update(cat, dog);
+ assertEquals(dog, new String(trie.get(cat)));
+
+ trie.update(ca, dude);
+ assertEquals(dude, new String(trie.get(ca)));
+
+ trie.update(doge, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(doge)));
+
+ trie.update(dog, test);
+ assertEquals(test, new String(trie.get(dog)));
+
+ trie.update(test, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(test)));
+ assertEquals(ROOT_HASH_BEFORE, Hex.toHexString(trie.getRootHash()));
+
+ trie.delete(dog);
+ assertEquals("", new String(trie.get(dog)));
+ assertEquals(ROOT_HASH_AFTER1, Hex.toHexString(trie.getRootHash()));
+
+ trie.delete(test);
+ assertEquals("", new String(trie.get(test)));
+ assertEquals(ROOT_HASH_AFTER2, Hex.toHexString(trie.getRootHash()));
+ }
+
+ @Test
+ public void testDeleteMultipleItems2() {
+ String ROOT_HASH_BEFORE = "cf1ed2b6c4b6558f70ef0ecf76bfbee96af785cb5d5e7bfc37f9804ad8d0fb56";
+ String ROOT_HASH_AFTER1 = "f586af4a476ba853fca8cea1fbde27cd17d537d18f64269fe09b02aa7fe55a9e";
+ String ROOT_HASH_AFTER2 = "c59fdc16a80b11cc2f7a8b107bb0c954c0d8059e49c760ec3660eea64053ac91";
+
+ TrieImpl trie = new TrieImpl(mockDb);
+ trie.update(c, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(c)));
+
+ trie.update(ca, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(ca)));
+
+ trie.update(cat, LONG_STRING);
+ assertEquals(LONG_STRING, new String(trie.get(cat)));
+ assertEquals(ROOT_HASH_BEFORE, Hex.toHexString(trie.getRootHash()));
+
+ trie.delete(ca);
+ assertEquals("", new String(trie.get(ca)));
+ assertEquals(ROOT_HASH_AFTER1, Hex.toHexString(trie.getRootHash()));
+
+ trie.delete(cat);
+ assertEquals("", new String(trie.get(cat)));
+ assertEquals(ROOT_HASH_AFTER2, Hex.toHexString(trie.getRootHash()));
+ }
+
+ @Test
+ public void testDeleteAll() {
+ String ROOT_HASH_BEFORE = "a84739b4762ddf15e3acc4e6957e5ab2bbfaaef00fe9d436a7369c6f058ec90d";
+ TrieImpl trie = new TrieImpl(mockDb);
+ assertEquals(ROOT_HASH_EMPTY, Hex.toHexString(trie.getRootHash()));
+
+ trie.update(ca, dude);
+ trie.update(cat, dog);
+ trie.update(doge, LONG_STRING);
+ assertEquals(ROOT_HASH_BEFORE, Hex.toHexString(trie.getRootHash()));
+
+ trie.delete(ca);
+ trie.delete(cat);
+ trie.delete(doge);
+ assertEquals(ROOT_HASH_EMPTY, Hex.toHexString(trie.getRootHash()));
+ }
+
+ @Test
+ public void testTrieEquals() {
+ TrieImpl trie1 = new TrieImpl(mockDb);
+ TrieImpl trie2 = new TrieImpl(mockDb);
+
+ trie1.update(doge, LONG_STRING);
+ trie2.update(doge, LONG_STRING);
+ assertTrue("Expected tries to be equal", trie1.equals(trie2));
+ assertEquals(Hex.toHexString(trie1.getRootHash()), Hex.toHexString(trie2.getRootHash()));
+
+ trie1.update(dog, LONG_STRING);
+ trie2.update(cat, LONG_STRING);
+ assertFalse("Expected tries not to be equal", trie1.equals(trie2));
+ assertNotEquals(Hex.toHexString(trie1.getRootHash()), Hex.toHexString(trie2.getRootHash()));
+ }
+
+ @Ignore
+ @Test
+ public void testTrieSync() {
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update(dog, LONG_STRING);
+ assertEquals("Expected no data in database", mockDb.getAddedItems(), 0);
+
+ trie.sync();
+ assertNotEquals("Expected data to be persisted", mockDb.getAddedItems(), 0);
+ }
+
+ @Ignore
+ @Test
+ public void TestTrieDirtyTracking() {
+ TrieImpl trie = new TrieImpl(mockDb);
+ trie.update(dog, LONG_STRING);
+ assertTrue("Expected trie to be dirty", trie.getCache().isDirty());
+
+ trie.sync();
+ assertFalse("Expected trie not to be dirty", trie.getCache().isDirty());
+
+ trie.update(test, LONG_STRING);
+ trie.getCache().undo();
+ assertFalse("Expected trie not to be dirty", trie.getCache().isDirty());
+ }
+
+ @Test
+ public void TestTrieReset() {
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update(cat, LONG_STRING);
+ assertNotEquals("Expected cached nodes", 0, trie.getCache().getNodes().size());
+
+ trie.getCache().undo();
+
+ assertEquals("Expected no nodes after undo", 0, trie.getCache().getNodes().size());
+ }
+
+ @Test
+ public void testTrieCopy() {
+ TrieImpl trie = new TrieImpl(mockDb);
+ trie.update("doe", "reindeer");
+ TrieImpl trie2 = trie.copy();
+ assertNotEquals(trie.hashCode(), trie2.hashCode()); // avoid possibility that its just a reference copy
+ assertEquals(Hex.toHexString(trie.getRootHash()), Hex.toHexString(trie2.getRootHash()));
+ assertTrue(trie.equals(trie2));
+ }
+
+ @Test
+ public void testTrieUndo() {
+ TrieImpl trie = new TrieImpl(mockDb);
+ trie.update("doe", "reindeer");
+ assertEquals("11a0327cfcc5b7689b6b6d727e1f5f8846c1137caaa9fc871ba31b7cce1b703e", Hex.toHexString(trie.getRootHash()));
+ trie.sync();
+
+ trie.update("dog", "puppy");
+ assertEquals("05ae693aac2107336a79309e0c60b24a7aac6aa3edecaef593921500d33c63c4", Hex.toHexString(trie.getRootHash()));
+
+ trie.undo();
+ assertEquals("11a0327cfcc5b7689b6b6d727e1f5f8846c1137caaa9fc871ba31b7cce1b703e", Hex.toHexString(trie.getRootHash()));
+ }
+
+ // Using tests from: https://github.com/ethereum/tests/blob/master/trietest.json
+
+ @Test
+ public void testSingleItem() {
+ TrieImpl trie = new TrieImpl(mockDb);
+ trie.update("A", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+
+ assertEquals("d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab", Hex.toHexString(trie.getRootHash()));
+ }
+
+ @Test
+ public void testDogs() {
+ TrieImpl trie = new TrieImpl(mockDb);
+ trie.update("doe", "reindeer");
+ assertEquals("11a0327cfcc5b7689b6b6d727e1f5f8846c1137caaa9fc871ba31b7cce1b703e", Hex.toHexString(trie.getRootHash()));
+
+ trie.update("dog", "puppy");
+ assertEquals("05ae693aac2107336a79309e0c60b24a7aac6aa3edecaef593921500d33c63c4", Hex.toHexString(trie.getRootHash()));
+
+ trie.update("dogglesworth", "cat");
+ assertEquals("8aad789dff2f538bca5d8ea56e8abe10f4c7ba3a5dea95fea4cd6e7c3a1168d3", Hex.toHexString(trie.getRootHash()));
+ }
+
+ @Test
+ public void testPuppy() {
+ TrieImpl trie = new TrieImpl(mockDb);
+ trie.update("do", "verb");
+ trie.update("doge", "coin");
+ trie.update("horse", "stallion");
+ trie.update("dog", "puppy");
+
+ assertEquals("5991bb8c6514148a29db676a14ac506cd2cd5775ace63c30a4fe457715e9ac84", Hex.toHexString(trie.getRootHash()));
+ }
+
+ @Test
+ public void testEmptyValues() {
+ TrieImpl trie = new TrieImpl(mockDb);
+ trie.update("do", "verb");
+ trie.update("ether", "wookiedoo");
+ trie.update("horse", "stallion");
+ trie.update("shaman", "horse");
+ trie.update("doge", "coin");
+ trie.update("ether", "");
+ trie.update("dog", "puppy");
+ trie.update("shaman", "");
+
+ assertEquals("5991bb8c6514148a29db676a14ac506cd2cd5775ace63c30a4fe457715e9ac84", Hex.toHexString(trie.getRootHash()));
+ }
+
+ @Test
+ public void testFoo() {
+ TrieImpl trie = new TrieImpl(mockDb);
+ trie.update("foo", "bar");
+ trie.update("food", "bat");
+ trie.update("food", "bass");
+
+ assertEquals("17beaa1648bafa633cda809c90c04af50fc8aed3cb40d16efbddee6fdf63c4c3", Hex.toHexString(trie.getRootHash()));
+ }
+
+ @Test
+ public void testSmallValues() {
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update("be", "e");
+ trie.update("dog", "puppy");
+ trie.update("bed", "d");
+ assertEquals("3f67c7a47520f79faa29255d2d3c084a7a6df0453116ed7232ff10277a8be68b", Hex.toHexString(trie.getRootHash()));
+ }
+
+ @Test
+ public void testTesty() {
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update("test", "test");
+ assertEquals("85d106d4edff3b7a4889e91251d0a87d7c17a1dda648ebdba8c6060825be23b8", Hex.toHexString(trie.getRootHash()));
+
+ trie.update("te", "testy");
+ assertEquals("8452568af70d8d140f58d941338542f645fcca50094b20f3c3d8c3df49337928", Hex.toHexString(trie.getRootHash()));
+ }
+
+ private final String randomDictionary = "spinneries, archipenko, prepotency, herniotomy, preexpress, relaxative, insolvably, debonnaire, apophysate, virtuality, cavalryman, utilizable, diagenesis, vitascopic, governessy, abranchial, cyanogenic, gratulated, signalment, predicable, subquality, crystalize, prosaicism, oenologist, repressive, impanelled, cockneyism, bordelaise, compigne, konstantin, predicated, unsublimed, hydrophane, phycomyces, capitalise, slippingly, untithable, unburnable, deoxidizer, misteacher, precorrect, disclaimer, solidified, neuraxitis, caravaning, betelgeuse, underprice, uninclosed, acrogynous, reirrigate, dazzlingly, chaffiness, corybantes, intumesced, intentness, superexert, abstrusely, astounding, pilgrimage, posttarsal, prayerless, nomologist, semibelted, frithstool, unstinging, ecalcarate, amputating, megascopic, graphalloy, platteland, adjacently, mingrelian, valentinus, appendical, unaccurate, coriaceous, waterworks, sympathize, doorkeeper, overguilty, flaggingly, admonitory, aeriferous, normocytic, parnellism, catafalque, odontiasis, apprentice, adulterous, mechanisma, wilderness, undivorced, reinterred, effleurage, pretrochal, phytogenic, swirlingly, herbarized, unresolved, classifier, diosmosing, microphage, consecrate, astarboard, predefying, predriving, lettergram, ungranular, overdozing, conferring, unfavorite, peacockish, coinciding, erythraeum, freeholder, zygophoric, imbitterer, centroidal, appendixes, grayfishes, enological, indiscreet, broadcloth, divulgated, anglophobe, stoopingly, bibliophil, laryngitis, separatist, estivating, bellarmine, greasiness, typhlology, xanthation, mortifying, endeavorer, aviatrices, unequalise, metastatic, leftwinger, apologizer, quatrefoil, nonfouling, bitartrate, outchiding, undeported, poussetted, haemolysis, asantehene, montgomery, unjoinable, cedarhurst, unfastener, nonvacuums, beauregard, animalized, polyphides, cannizzaro, gelatinoid, apologised, unscripted, tracheidal, subdiscoid, gravelling, variegated, interabang, inoperable, immortelle, laestrygon, duplicatus, proscience, deoxidised, manfulness, channelize, nondefense, ectomorphy, unimpelled, headwaiter, hexaemeric, derivation, prelexical, limitarian, nonionized, prorefugee, invariably, patronizer, paraplegia, redivision, occupative, unfaceable, hypomnesia, psalterium, doctorfish, gentlefolk, overrefine, heptastich, desirously, clarabelle, uneuphonic, autotelism, firewarden, timberjack, fumigation, drainpipes, spathulate, novelvelle, bicorporal, grisliness, unhesitant, supergiant, unpatented, womanpower, toastiness, multichord, paramnesia, undertrick, contrarily, neurogenic, gunmanship, settlement, brookville, gradualism, unossified, villanovan, ecospecies, organising, buckhannon, prefulfill, johnsonese, unforegone, unwrathful, dunderhead, erceldoune, unwadeable, refunction, understuff, swaggering, freckliest, telemachus, groundsill, outslidden, bolsheviks, recognizer, hemangioma, tarantella, muhammedan, talebearer, relocation, preemption, chachalaca, septuagint, ubiquitous, plexiglass, humoresque, biliverdin, tetraploid, capitoline, summerwood, undilating, undetested, meningitic, petrolatum, phytotoxic, adiphenine, flashlight, protectory, inwreathed, rawishness, tendrillar, hastefully, bananaquit, anarthrous, unbedimmed, herborized, decenniums, deprecated, karyotypic, squalidity, pomiferous, petroglyph, actinomere, peninsular, trigonally, androgenic, resistance, unassuming, frithstool, documental, eunuchised, interphone, thymbraeus, confirmand, expurgated, vegetation, myographic, plasmagene, spindrying, unlackeyed, foreknower, mythically, albescence, rebudgeted, implicitly, unmonastic, torricelli, mortarless, labialized, phenacaine, radiometry, sluggishly, understood, wiretapper, jacobitely, unbetrayed, stadholder, directress, emissaries, corelation, sensualize, uncurbable, permillage, tentacular, thriftless, demoralize, preimagine, iconoclast, acrobatism, firewarden, transpired, bluethroat, wanderjahr, groundable, pedestrian, unulcerous, preearthly, freelanced, sculleries, avengingly, visigothic, preharmony, bressummer, acceptable, unfoolable, predivider, overseeing, arcosolium, piriformis, needlecord, homebodies, sulphation, phantasmic, unsensible, unpackaged, isopiestic, cytophagic, butterlike, frizzliest, winklehawk, necrophile, mesothorax, cuchulainn, unrentable, untangible, unshifting, unfeasible, poetastric, extermined, gaillardia, nonpendent, harborside, pigsticker, infanthood, underrower, easterling, jockeyship, housebreak, horologium, undepicted, dysacousma, incurrable, editorship, unrelented, peritricha, interchaff, frothiness, underplant, proafrican, squareness, enigmatise, reconciled, nonnumeral, nonevident, hamantasch, victualing, watercolor, schrdinger, understand, butlerlike, hemiglobin, yankeeland";
+
+ @Test
+ public void testMasiveUpdate() {
+ boolean massiveUpdateTestEnabled = false;
+
+ if (massiveUpdateTestEnabled) {
+ List randomWords = Arrays.asList(randomDictionary.split(","));
+ HashMap testerMap = new HashMap<>();
+
+ TrieImpl trie = new TrieImpl(mockDb);
+ Random generator = new Random();
+
+ // Random insertion
+ for (int i = 0; i < 100000; ++i) {
+
+ int randomIndex1 = generator.nextInt(randomWords.size());
+ int randomIndex2 = generator.nextInt(randomWords.size());
+
+ String word1 = randomWords.get(randomIndex1).trim();
+ String word2 = randomWords.get(randomIndex2).trim();
+
+ trie.update(word1, word2);
+ testerMap.put(word1, word2);
+ }
+
+ int half = testerMap.size() / 2;
+ for (int r = 0; r < half; ++r) {
+
+ int randomIndex = generator.nextInt(randomWords.size());
+ String word1 = randomWords.get(randomIndex).trim();
+
+ testerMap.remove(word1);
+ trie.delete(word1);
+ }
+
+ trie.cleanCache();
+ trie.sync();
+
+ // Assert the result now
+ Iterator keys = testerMap.keySet().iterator();
+ while (keys.hasNext()) {
+
+ String mapWord1 = keys.next();
+ String mapWord2 = testerMap.get(mapWord1);
+ String treeWord2 = new String(trie.get(mapWord1));
+
+ Assert.assertEquals(mapWord2, treeWord2);
+ }
+ }
+ }
+
+
+ @Ignore
+ @Test
+ public void reddisTest() throws URISyntaxException, IOException {
+
+ URL massiveUpload_1 = ClassLoader
+ .getSystemResource("trie/massive-upload.dmp");
+
+ File file = new File(massiveUpload_1.toURI());
+ List strData = Files.readAllLines(file.toPath(), StandardCharsets.UTF_8);
+ String dbName = "state";
+
+ long startTime = System.currentTimeMillis();
+
+ Jedis jedis = new Jedis("localhost");
+ jedis.flushAll();
+ Pipeline pipeline = jedis.pipelined();
+ Set keys = jedis.keys("*");
+ System.out.println("before: all " + keys.size());
+
+ for (String aStrData : strData) {
+ String[] keyVal = aStrData.split("=");
+
+ if (keyVal[0].equals("*"))
+ pipeline.del(keyVal[1].getBytes());
+ else
+ pipeline.set(keyVal[0].getBytes(), keyVal[1].getBytes());
+ }
+
+ pipeline.sync();
+ keys = jedis.keys("*");
+ System.out.println("all " + keys.size());
+ for (String key : keys)
+ System.out.println(key + " -> " + jedis.get(key));
+
+
+ System.out.println("time: " + (System.currentTimeMillis() - startTime));
+ }
+
+
+ @Ignore
+ @Test
+ public void testMasiveDetermenisticUpdate() throws IOException, URISyntaxException {
+
+ // should be root: cfd77c0fcb037adefce1f4e2eb94381456a4746379d2896bb8f309c620436d30
+
+ URL massiveUpload_1 = ClassLoader
+ .getSystemResource("trie/massive-upload.dmp");
+
+ File file = new File(massiveUpload_1.toURI());
+ List strData = Files.readAllLines(file.toPath(), StandardCharsets.UTF_8);
+
+ // *** Part - 1 ***
+ // 1. load the data from massive-upload.dmp
+ // which includes deletes/upadtes (5000 operations)
+ TrieImpl trieSingle = new TrieImpl(mockDb_2);
+ for (String aStrData : strData) {
+
+ String[] keyVal = aStrData.split("=");
+
+ if (keyVal[0].equals("*"))
+ trieSingle.delete(keyVal[1].trim());
+ else
+ trieSingle.update(keyVal[0].trim(), keyVal[1].trim());
+ }
+
+
+ System.out.println("root_1: => " + Hex.toHexString(trieSingle.getRootHash()));
+
+ // *** Part - 2 ***
+ // pre. we use the same data from massive-upload.dmp
+ // which includes deletes/upadtes (100000 operations)
+ // 1. part of the data loaded
+ // 2. the trie cache sync to the db
+ // 3. the rest of the data loaded with part of the trie not in the cache
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ for (int i = 0; i < 2000; ++i) {
+
+ String[] keyVal = strData.get(i).split("=");
+
+ if (keyVal[0].equals("*"))
+ trie.delete(keyVal[1].trim());
+ else
+ trie.update(keyVal[0].trim(), keyVal[1].trim());
+ }
+
+ trie.cleanCache();
+ trie.sync();
+
+ TrieImpl trie2 = new TrieImpl(mockDb, trie.getRootHash());
+
+ for (int i = 2000; i < strData.size(); ++i) {
+
+ String[] keyVal = strData.get(i).split("=");
+
+ if (keyVal[0].equals("*"))
+ trie2.delete(keyVal[1].trim());
+ else
+ trie2.update(keyVal[0].trim(), keyVal[1].trim());
+ }
+
+ System.out.println("root_2: => " + Hex.toHexString(trie2.getRootHash()));
+
+ assertEquals(trieSingle.getRootHash(), trie2.getRootHash());
+
+ }
+
+ @Test // tests saving keys to the file //
+ public void testMasiveUpdateFromDB() {
+ boolean massiveUpdateFromDBEnabled = false;
+
+ if (massiveUpdateFromDBEnabled) {
+ List randomWords = Arrays.asList(randomDictionary.split(","));
+ Map testerMap = new HashMap<>();
+
+ TrieImpl trie = new TrieImpl(mockDb);
+ Random generator = new Random();
+
+ // Random insertion
+ for (int i = 0; i < 50000; ++i) {
+
+ int randomIndex1 = generator.nextInt(randomWords.size());
+ int randomIndex2 = generator.nextInt(randomWords.size());
+
+ String word1 = randomWords.get(randomIndex1).trim();
+ String word2 = randomWords.get(randomIndex2).trim();
+
+ trie.update(word1, word2);
+ testerMap.put(word1, word2);
+ }
+
+ trie.cleanCache();
+ trie.sync();
+
+ // Assert the result now
+ Iterator keys = testerMap.keySet().iterator();
+ while (keys.hasNext()) {
+
+ String mapWord1 = keys.next();
+ String mapWord2 = testerMap.get(mapWord1);
+ String treeWord2 = new String(trie.get(mapWord1));
+
+ Assert.assertEquals(mapWord2, treeWord2);
+ }
+
+ TrieImpl trie2 = new TrieImpl(mockDb, trie.getRootHash());
+
+ // Assert the result now
+ keys = testerMap.keySet().iterator();
+ while (keys.hasNext()) {
+
+ String mapWord1 = keys.next();
+ String mapWord2 = testerMap.get(mapWord1);
+ String treeWord2 = new String(trie2.get(mapWord1));
+
+ Assert.assertEquals(mapWord2, treeWord2);
+ }
+ }
+ }
+
+
+ @Test
+ public void testRollbackTrie() throws URISyntaxException, IOException {
+
+ TrieImpl trieSingle = new TrieImpl(mockDb);
+
+ URL massiveUpload_1 = ClassLoader
+ .getSystemResource("trie/massive-upload.dmp");
+
+ File file = new File(massiveUpload_1.toURI());
+ List strData = Files.readAllLines(file.toPath(), StandardCharsets.UTF_8);
+
+ List roots = new ArrayList<>();
+ Map trieDumps = new HashMap<>();
+
+ for (int i = 0; i < 100; ++i) {
+
+ String[] keyVal = strData.get(i).split("=");
+
+ if (keyVal[0].equals("*"))
+ trieSingle.delete(keyVal[1].trim());
+ else
+ trieSingle.update(keyVal[0].trim(), keyVal[1].trim());
+
+ byte[] hash = trieSingle.getRootHash();
+ roots.add(hash);
+
+ String key = Hex.toHexString(hash);
+ String dump = trieSingle.getTrieDump();
+ trieDumps.put(key, dump);
+ }
+
+ // compare all 100 rollback dumps and
+ // the originaly saved dumps
+ for (int i = 1; i < roots.size(); ++i) {
+
+ byte[] root = roots.get(i);
+ logger.info("rollback over root : {}", Hex.toHexString(root));
+
+ trieSingle.setRoot(root);
+ String currDump = trieSingle.getTrieDump();
+ String originDump = trieDumps.get(Hex.toHexString(root));
+// System.out.println(currDump);
+ Assert.assertEquals(currDump, originDump);
+ }
+
+ }
+
+
+ @Ignore
+ @Test
+ public void testGetFromRootNode() {
+ TrieImpl trie1 = new TrieImpl(mockDb);
+ trie1.update(cat, LONG_STRING);
+ trie1.sync();
+ TrieImpl trie2 = new TrieImpl(mockDb, trie1.getRootHash());
+ assertEquals(LONG_STRING, new String(trie2.get(cat)));
+ }
+
+
+/*
+ 0x7645b9fbf1b51e6b980801fafe6bbc22d2ebe218 0x517eaccda568f3fa24915fed8add49d3b743b3764c0bc495b19a47c54dbc3d62 0x 0x1
+ 0x0000000000000000000000000000000000000000000000000000000000000010 0x947e70f9460402290a3e487dae01f610a1a8218fda
+ 0x0000000000000000000000000000000000000000000000000000000000000014 0x40
+ 0x0000000000000000000000000000000000000000000000000000000000000016 0x94412e0c4f0102f3f0ac63f0a125bce36ca75d4e0d
+ 0x0000000000000000000000000000000000000000000000000000000000000017 0x01
+*/
+
+ @Test
+ public void storageHashCalc_1() {
+
+ byte[] key1 = Hex.decode("0000000000000000000000000000000000000000000000000000000000000010");
+ byte[] key2 = Hex.decode("0000000000000000000000000000000000000000000000000000000000000014");
+ byte[] key3 = Hex.decode("0000000000000000000000000000000000000000000000000000000000000016");
+ byte[] key4 = Hex.decode("0000000000000000000000000000000000000000000000000000000000000017");
+
+ byte[] val1 = Hex.decode("947e70f9460402290a3e487dae01f610a1a8218fda");
+ byte[] val2 = Hex.decode("40");
+ byte[] val3 = Hex.decode("94412e0c4f0102f3f0ac63f0a125bce36ca75d4e0d");
+ byte[] val4 = Hex.decode("01");
+
+ TrieImpl storage = new TrieImpl(new HashMapDB());
+ storage.update(key1, val1);
+ storage.update(key2, val2);
+ storage.update(key3, val3);
+ storage.update(key4, val4);
+
+ String hash = Hex.toHexString(storage.getRootHash());
+
+ System.out.println(hash);
+ Assert.assertEquals("517eaccda568f3fa24915fed8add49d3b743b3764c0bc495b19a47c54dbc3d62", hash);
+ }
+
+
+ @Test
+ public void testFromDump_1() throws URISyntaxException, IOException, ParseException {
+
+
+ // LOAD: real dump from real state run
+ URL dbDump = ClassLoader
+ .getSystemResource("dbdump/dbdump.json");
+
+ File dbDumpFile = new File(dbDump.toURI());
+ byte[] testData = Files.readAllBytes(dbDumpFile.toPath());
+ String testSrc = new String(testData);
+
+ JSONParser parser = new JSONParser();
+ JSONArray dbDumpJSONArray = (JSONArray) parser.parse(testSrc);
+
+ KeyValueDataSource keyValueDataSource = new LevelDbDataSource("testState");
+ keyValueDataSource.init();
+
+ DatabaseImpl db = new DatabaseImpl(keyValueDataSource);
+
+ for (Object aDbDumpJSONArray : dbDumpJSONArray) {
+
+ JSONObject obj = (JSONObject) aDbDumpJSONArray;
+ byte[] key = Hex.decode(obj.get("key").toString());
+ byte[] val = Hex.decode(obj.get("val").toString());
+
+ db.put(key, val);
+ }
+
+ // TEST: load trie out of this run up to block#33
+ byte[] rootNode = Hex.decode("bb690805d24882bc7ccae6fc0f80ac146274d5b81c6a6e9c882cd9b0a649c9c7");
+ TrieImpl trie = new TrieImpl(db.getDb(), rootNode);
+
+ // first key added in genesis
+ byte[] val1 = trie.get(Hex.decode("51ba59315b3a95761d0863b05ccc7a7f54703d99"));
+ AccountState accountState1 = new AccountState(val1);
+
+ assertEquals(BigInteger.valueOf(2).pow(200), accountState1.getBalance());
+ assertEquals("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", Hex.toHexString(accountState1.getCodeHash()));
+ assertEquals(BigInteger.ZERO, accountState1.getNonce());
+ assertEquals(null, accountState1.getStateRoot());
+
+ // last key added up to block#33
+ byte[] val2 = trie.get(Hex.decode("a39c2067eb45bc878818946d0f05a836b3da44fa"));
+ AccountState accountState2 = new AccountState(val2);
+
+ assertEquals(new BigInteger("1500000000000000000"), accountState2.getBalance());
+ assertEquals("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", Hex.toHexString(accountState2.getCodeHash()));
+ assertEquals(BigInteger.ZERO, accountState2.getNonce());
+ assertEquals(null, accountState2.getStateRoot());
+
+ db.close();
+ }
+
+
+ @Test // update the trie with blog key/val
+ // each time dump the entire trie
+ public void testSample_1() {
+
+ TrieImpl trie = new TrieImpl(mockDb);
+
+ trie.update("dog", "puppy");
+ String dmp = trie.getTrieDump();
+ System.out.println(dmp);
+ System.out.println();
+ Assert.assertEquals("ed6e08740e4a267eca9d4740f71f573e9aabbcc739b16a2fa6c1baed5ec21278", Hex.toHexString(trie.getRootHash()));
+
+ trie.update("do", "verb");
+ dmp = trie.getTrieDump();
+ System.out.println(dmp);
+ System.out.println();
+ Assert.assertEquals("779db3986dd4f38416bfde49750ef7b13c6ecb3e2221620bcad9267e94604d36", Hex.toHexString(trie.getRootHash()));
+
+ trie.update("doggiestan", "aeswome_place");
+ dmp = trie.getTrieDump();
+ System.out.println(dmp);
+ System.out.println();
+ Assert.assertEquals("8bd5544747b4c44d1274aa99a6293065fe319b3230e800203317e4c75a770099", Hex.toHexString(trie.getRootHash()));
+ }
+
+
+ @Test
+ public void testSecureTrie(){
+
+ Trie trie = new SecureTrie(mockDb);
+
+ byte[] k1 = "do".getBytes();
+ byte[] v1 = "verb".getBytes();
+
+ byte[] k2 = "ether".getBytes();
+ byte[] v2 = "wookiedoo".getBytes();
+
+ byte[] k3 = "horse".getBytes();
+ byte[] v3 = "stallion".getBytes();
+
+ byte[] k4 = "shaman".getBytes();
+ byte[] v4 = "horse".getBytes();
+
+ byte[] k5 = "doge".getBytes();
+ byte[] v5 = "coin".getBytes();
+
+ byte[] k6 = "ether".getBytes();
+ byte[] v6 = "".getBytes();
+
+ byte[] k7 = "dog".getBytes();
+ byte[] v7 = "puppy".getBytes();
+
+ byte[] k8 = "shaman".getBytes();
+ byte[] v8 = "".getBytes();
+
+ trie.update(k1, v1);
+ trie.update(k2, v2);
+ trie.update(k3, v3);
+ trie.update(k4, v4);
+ trie.update(k5, v5);
+ trie.update(k6, v6);
+ trie.update(k7, v7);
+ trie.update(k8, v8);
+
+ byte[] root = trie.getRootHash();
+
+ logger.info("root: " + Hex.toHexString(root));
+
+ Assert.assertEquals("29b235a58c3c25ab83010c327d5932bcf05324b7d6b1185e650798034783ca9d",Hex.toHexString(root));
+ }
+
+ @Test
+ public void testFatTrie(){
+
+ FatTrie trie = new FatTrie(mockDb, mockDb_2);
+
+ byte[] k1 = "do".getBytes();
+ byte[] v1 = "verb".getBytes();
+
+ byte[] k2 = "ether".getBytes();
+ byte[] v2 = "wookiedoo".getBytes();
+
+ byte[] k3 = "horse".getBytes();
+ byte[] v3 = "stallion".getBytes();
+
+ byte[] k4 = "shaman".getBytes();
+ byte[] v4 = "horse".getBytes();
+
+ byte[] k5 = "doge".getBytes();
+ byte[] v5 = "coin".getBytes();
+
+ byte[] k6 = "ether".getBytes();
+ byte[] v6 = "".getBytes();
+
+ byte[] k7 = "dog".getBytes();
+ byte[] v7 = "puppy".getBytes();
+
+ byte[] k8 = "shaman".getBytes();
+ byte[] v8 = "".getBytes();
+
+ trie.update(k1, v1);
+ trie.update(k2, v2);
+ trie.update(k3, v3);
+ trie.update(k4, v4);
+ trie.update(k5, v5);
+ trie.update(k6, v6);
+ trie.update(k7, v7);
+ trie.update(k8, v8);
+
+ byte[] root = trie.getRootHash();
+
+ logger.info("root: " + Hex.toHexString(root));
+
+ Assert.assertEquals("29b235a58c3c25ab83010c327d5932bcf05324b7d6b1185e650798034783ca9d", Hex.toHexString(root));
+
+ String origRoot = Hex.toHexString(trie.getOrigTrie().getRootHash());
+ Assert.assertEquals("5991bb8c6514148a29db676a14ac506cd2cd5775ace63c30a4fe457715e9ac84", origRoot);
+ }
+
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/util/ByteUtilTest.java b/ethereumj-core/src/test/java/org/ethereum/util/ByteUtilTest.java
new file mode 100644
index 00000000..f047fd7d
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/util/ByteUtilTest.java
@@ -0,0 +1,328 @@
+package org.ethereum.util;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import org.spongycastle.util.BigIntegers;
+import org.spongycastle.util.encoders.Hex;
+
+import java.math.BigInteger;
+
+import java.nio.ByteBuffer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class ByteUtilTest {
+
+ @Test
+ public void testAppendByte() {
+ byte[] bytes = "tes".getBytes();
+ byte b = 0x74;
+ Assert.assertArrayEquals("test".getBytes(), ByteUtil.appendByte(bytes, b));
+ }
+
+ @Test
+ public void testBigIntegerToBytes() {
+ byte[] expecteds = new byte[]{(byte) 0xff, (byte) 0xec, 0x78};
+ BigInteger b = BigInteger.valueOf(16772216);
+ byte[] actuals = ByteUtil.bigIntegerToBytes(b);
+ assertArrayEquals(expecteds, actuals);
+ }
+
+ @Test
+ public void testBigIntegerToBytesNegative() {
+ byte[] expecteds = new byte[]{(byte) 0xff, 0x0, 0x13, (byte) 0x88};
+ BigInteger b = BigInteger.valueOf(-16772216);
+ byte[] actuals = ByteUtil.bigIntegerToBytes(b);
+ assertArrayEquals(expecteds, actuals);
+ }
+
+ @Test
+ public void testBigIntegerToBytesZero() {
+ byte[] expecteds = new byte[]{0x00};
+ BigInteger b = BigInteger.ZERO;
+ byte[] actuals = ByteUtil.bigIntegerToBytes(b);
+ assertArrayEquals(expecteds, actuals);
+ }
+
+ @Test
+ public void testToHexString() {
+ assertEquals("", ByteUtil.toHexString(null));
+ }
+
+ @Test
+ public void testCalcPacketLength() {
+ byte[] test = new byte[]{0x0f, 0x10, 0x43};
+ byte[] expected = new byte[]{0x00, 0x00, 0x00, 0x03};
+ assertArrayEquals(expected, ByteUtil.calcPacketLength(test));
+ }
+
+ @Test
+ public void testByteArrayToInt() {
+ assertEquals(0, ByteUtil.byteArrayToInt(null));
+ assertEquals(0, ByteUtil.byteArrayToInt(new byte[0]));
+
+// byte[] x = new byte[] { 5,1,7,0,8 };
+// long start = System.currentTimeMillis();
+// for (int i = 0; i < 100000000; i++) {
+// ByteArray.read32bit(x, 0);
+// }
+// long end = System.currentTimeMillis();
+// System.out.println(end - start + "ms");
+//
+// long start1 = System.currentTimeMillis();
+// for (int i = 0; i < 100000000; i++) {
+// new BigInteger(1, x).intValue();
+// }
+// long end1 = System.currentTimeMillis();
+// System.out.println(end1 - start1 + "ms");
+
+ }
+
+ @Test
+ public void testNumBytes() {
+ String test1 = "0";
+ String test2 = "1";
+ String test3 = "1000000000"; //3B9ACA00
+ int expected1 = 1;
+ int expected2 = 1;
+ int expected3 = 4;
+ assertEquals(expected1, ByteUtil.numBytes(test1));
+ assertEquals(expected2, ByteUtil.numBytes(test2));
+ assertEquals(expected3, ByteUtil.numBytes(test3));
+ }
+
+ @Test
+ public void testStripLeadingZeroes() {
+ byte[] test1 = null;
+ byte[] test2 = new byte[]{};
+ byte[] test3 = new byte[]{0x00};
+ byte[] test4 = new byte[]{0x00, 0x01};
+ byte[] test5 = new byte[]{0x00, 0x00, 0x01};
+ byte[] expected1 = null;
+ byte[] expected2 = new byte[]{0};
+ byte[] expected3 = new byte[]{0};
+ byte[] expected4 = new byte[]{0x01};
+ byte[] expected5 = new byte[]{0x01};
+ assertArrayEquals(expected1, ByteUtil.stripLeadingZeroes(test1));
+ assertArrayEquals(expected2, ByteUtil.stripLeadingZeroes(test2));
+ assertArrayEquals(expected3, ByteUtil.stripLeadingZeroes(test3));
+ assertArrayEquals(expected4, ByteUtil.stripLeadingZeroes(test4));
+ assertArrayEquals(expected5, ByteUtil.stripLeadingZeroes(test5));
+ }
+
+ @Test
+ public void testMatchingNibbleLength1() {
+ // a larger than b
+ byte[] a = new byte[]{0x00, 0x01};
+ byte[] b = new byte[]{0x00};
+ int result = ByteUtil.matchingNibbleLength(a, b);
+ assertEquals(1, result);
+ }
+
+ @Test
+ public void testMatchingNibbleLength2() {
+ // b larger than a
+ byte[] a = new byte[]{0x00};
+ byte[] b = new byte[]{0x00, 0x01};
+ int result = ByteUtil.matchingNibbleLength(a, b);
+ assertEquals(1, result);
+ }
+
+ @Test
+ public void testMatchingNibbleLength3() {
+ // a and b the same length equal
+ byte[] a = new byte[]{0x00};
+ byte[] b = new byte[]{0x00};
+ int result = ByteUtil.matchingNibbleLength(a, b);
+ assertEquals(1, result);
+ }
+
+ @Test
+ public void testMatchingNibbleLength4() {
+ // a and b the same length not equal
+ byte[] a = new byte[]{0x01};
+ byte[] b = new byte[]{0x00};
+ int result = ByteUtil.matchingNibbleLength(a, b);
+ assertEquals(0, result);
+ }
+
+ @Test
+ public void testNiceNiblesOutput_1() {
+ byte[] test = {7, 0, 7, 5, 7, 0, 7, 0, 7, 9};
+ String result = "\\x07\\x00\\x07\\x05\\x07\\x00\\x07\\x00\\x07\\x09";
+ assertEquals(result, ByteUtil.nibblesToPrettyString(test));
+ }
+
+ @Test
+ public void testNiceNiblesOutput_2() {
+ byte[] test = {7, 0, 7, 0xf, 7, 0, 0xa, 0, 7, 9};
+ String result = "\\x07\\x00\\x07\\x0f\\x07\\x00\\x0a\\x00\\x07\\x09";
+ assertEquals(result, ByteUtil.nibblesToPrettyString(test));
+ }
+
+ @Test(expected = NullPointerException.class)
+ public void testMatchingNibbleLength5() {
+ // a == null
+ byte[] a = null;
+ byte[] b = new byte[]{0x00};
+ ByteUtil.matchingNibbleLength(a, b);
+ }
+
+ @Test(expected = NullPointerException.class)
+ public void testMatchingNibbleLength6() {
+ // b == null
+ byte[] a = new byte[]{0x00};
+ byte[] b = null;
+ ByteUtil.matchingNibbleLength(a, b);
+ }
+
+ @Test
+ public void testMatchingNibbleLength7() {
+ // a or b is empty
+ byte[] a = new byte[0];
+ byte[] b = new byte[]{0x00};
+ int result = ByteUtil.matchingNibbleLength(a, b);
+ assertEquals(0, result);
+ }
+
+ /**
+ * This test shows the difference between iterating over,
+ * and comparing byte[] vs BigInteger value.
+ *
+ * Results indicate that the former has ~15x better performance.
+ * Therefore this is used in the Miner.mine() method.
+ */
+ @Test
+ public void testIncrementPerformance() {
+ boolean testEnabled = false;
+
+ if (testEnabled) {
+ byte[] counter1 = new byte[4];
+ byte[] max = ByteBuffer.allocate(4).putInt(Integer.MAX_VALUE).array();
+ long start1 = System.currentTimeMillis();
+ while (ByteUtil.increment(counter1)) {
+ if (FastByteComparisons.compareTo(counter1, 0, 4, max, 0, 4) == 0) {
+ break;
+ }
+ }
+ System.out.println(System.currentTimeMillis() - start1 + "ms to reach: " + Hex.toHexString(counter1));
+
+ BigInteger counter2 = BigInteger.ZERO;
+ long start2 = System.currentTimeMillis();
+ while (true) {
+ if (counter2.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) == 0) {
+ break;
+ }
+ counter2 = counter2.add(BigInteger.ONE);
+ }
+ System.out.println(System.currentTimeMillis() - start2 + "ms to reach: " + Hex.toHexString(BigIntegers.asUnsignedByteArray(4, counter2)));
+ }
+ }
+
+
+ @Test
+ public void firstNonZeroByte_1() {
+
+ byte[] data = Hex.decode("0000000000000000000000000000000000000000000000000000000000000000");
+ int result = ByteUtil.firstNonZeroByte(data);
+
+ assertEquals(-1, result);
+ }
+
+ @Test
+ public void firstNonZeroByte_2() {
+
+ byte[] data = Hex.decode("0000000000000000000000000000000000000000000000000000000000332211");
+ int result = ByteUtil.firstNonZeroByte(data);
+
+ assertEquals(29, result);
+ }
+
+ @Test
+ public void firstNonZeroByte_3() {
+
+ byte[] data = Hex.decode("2211009988776655443322110099887766554433221100998877665544332211");
+ int result = ByteUtil.firstNonZeroByte(data);
+
+ assertEquals(0, result);
+ }
+
+ @Test
+ public void setBitTest() {
+ /*
+ Set on
+ */
+ byte[] data = ByteBuffer.allocate(4).putInt(0).array();
+ int posBit = 24;
+ int expected = 16777216;
+ int result = -1;
+ byte[] ret = ByteUtil.setBit(data, posBit, 1);
+ result = ByteUtil.byteArrayToInt(ret);
+ assertTrue(expected == result);
+
+ posBit = 25;
+ expected = 50331648;
+ ret = ByteUtil.setBit(data, posBit, 1);
+ result = ByteUtil.byteArrayToInt(ret);
+ assertTrue(expected == result);
+
+ posBit = 2;
+ expected = 50331652;
+ ret = ByteUtil.setBit(data, posBit, 1);
+ result = ByteUtil.byteArrayToInt(ret);
+ assertTrue(expected == result);
+
+ /*
+ Set off
+ */
+ posBit = 24;
+ expected = 33554436;
+ ret = ByteUtil.setBit(data, posBit, 0);
+ result = ByteUtil.byteArrayToInt(ret);
+ assertTrue(expected == result);
+
+ posBit = 25;
+ expected = 4;
+ ret = ByteUtil.setBit(data, posBit, 0);
+ result = ByteUtil.byteArrayToInt(ret);
+ assertTrue(expected == result);
+
+ posBit = 2;
+ expected = 0;
+ ret = ByteUtil.setBit(data, posBit, 0);
+ result = ByteUtil.byteArrayToInt(ret);
+ assertTrue(expected == result);
+ }
+
+ @Test
+ public void getBitTest() {
+ byte[] data = ByteBuffer.allocate(4).putInt(0).array();
+ ByteUtil.setBit(data, 24, 1);
+ ByteUtil.setBit(data, 25, 1);
+ ByteUtil.setBit(data, 2, 1);
+
+ List found = new ArrayList<>();
+ for (int i = 0; i < (data.length * 8); i++) {
+ int res = ByteUtil.getBit(data, i);
+ if (res == 1)
+ if (i != 24 && i != 25 && i != 2)
+ assertTrue(false);
+ else
+ found.add(i);
+ else {
+ if (i == 24 || i == 25 || i == 2)
+ assertTrue(false);
+ }
+ }
+
+ if (found.size() != 3)
+ assertTrue(false);
+ assertTrue(found.get(0) == 2);
+ assertTrue(found.get(1) == 24);
+ assertTrue(found.get(2) == 25);
+ }
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/util/CompactEncoderTest.java b/ethereumj-core/src/test/java/org/ethereum/util/CompactEncoderTest.java
new file mode 100644
index 00000000..c388dd9c
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/util/CompactEncoderTest.java
@@ -0,0 +1,87 @@
+package org.ethereum.util;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class CompactEncoderTest {
+
+ private final static byte T = 16; // terminator
+
+ @Test
+ public void testCompactEncodeOddCompact() {
+ byte[] test = new byte[]{1, 2, 3, 4, 5};
+ byte[] expectedData = new byte[]{0x11, 0x23, 0x45};
+ assertArrayEquals("odd compact encode fail", expectedData, CompactEncoder.packNibbles(test));
+ }
+
+ @Test
+ public void testCompactEncodeEvenCompact() {
+ byte[] test = new byte[]{0, 1, 2, 3, 4, 5};
+ byte[] expectedData = new byte[]{0x00, 0x01, 0x23, 0x45};
+ assertArrayEquals("even compact encode fail", expectedData, CompactEncoder.packNibbles(test));
+ }
+
+ @Test
+ public void testCompactEncodeEvenTerminated() {
+ byte[] test = new byte[]{0, 15, 1, 12, 11, 8, T};
+ byte[] expectedData = new byte[]{0x20, 0x0f, 0x1c, (byte) 0xb8};
+ assertArrayEquals("even terminated compact encode fail", expectedData, CompactEncoder.packNibbles(test));
+ }
+
+ @Test
+ public void testCompactEncodeOddTerminated() {
+ byte[] test = new byte[]{15, 1, 12, 11, 8, T};
+ byte[] expectedData = new byte[]{0x3f, 0x1c, (byte) 0xb8};
+ assertArrayEquals("odd terminated compact encode fail", expectedData, CompactEncoder.packNibbles(test));
+ }
+
+ @Test
+ public void testCompactDecodeOddCompact() {
+ byte[] test = new byte[]{0x11, 0x23, 0x45};
+ byte[] expected = new byte[]{1, 2, 3, 4, 5};
+ assertArrayEquals("odd compact decode fail", expected, CompactEncoder.unpackToNibbles(test));
+ }
+
+ @Test
+ public void testCompactDecodeEvenCompact() {
+ byte[] test = new byte[]{0x00, 0x01, 0x23, 0x45};
+ byte[] expected = new byte[]{0, 1, 2, 3, 4, 5};
+ assertArrayEquals("even compact decode fail", expected, CompactEncoder.unpackToNibbles(test));
+ }
+
+ @Test
+ public void testCompactDecodeEvenTerminated() {
+ byte[] test = new byte[]{0x20, 0x0f, 0x1c, (byte) 0xb8};
+ byte[] expected = new byte[]{0, 15, 1, 12, 11, 8, T};
+ assertArrayEquals("even terminated compact decode fail", expected, CompactEncoder.unpackToNibbles(test));
+ }
+
+ @Test
+ public void testCompactDecodeOddTerminated() {
+ byte[] test = new byte[]{0x3f, 0x1c, (byte) 0xb8};
+ byte[] expected = new byte[]{15, 1, 12, 11, 8, T};
+ assertArrayEquals("odd terminated compact decode fail", expected, CompactEncoder.unpackToNibbles(test));
+ }
+
+ @Test
+ public void testCompactHexEncode_1() {
+ byte[] test = "stallion".getBytes();
+ byte[] result = new byte[]{7, 3, 7, 4, 6, 1, 6, 12, 6, 12, 6, 9, 6, 15, 6, 14, T};
+ assertArrayEquals(result, CompactEncoder.binToNibbles(test));
+ }
+
+ @Test
+ public void testCompactHexEncode_2() {
+ byte[] test = "verb".getBytes();
+ byte[] result = new byte[]{7, 6, 6, 5, 7, 2, 6, 2, T};
+ assertArrayEquals(result, CompactEncoder.binToNibbles(test));
+ }
+
+ @Test
+ public void testCompactHexEncode_3() {
+ byte[] test = "puppy".getBytes();
+ byte[] result = new byte[]{7, 0, 7, 5, 7, 0, 7, 0, 7, 9, T};
+ assertArrayEquals(result, CompactEncoder.binToNibbles(test));
+ }
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/util/HashUtilTest.java b/ethereumj-core/src/test/java/org/ethereum/util/HashUtilTest.java
new file mode 100644
index 00000000..628ffa51
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/util/HashUtilTest.java
@@ -0,0 +1,87 @@
+package org.ethereum.util;
+
+import org.ethereum.crypto.HashUtil;
+
+import org.junit.Test;
+
+import org.spongycastle.util.encoders.Hex;
+
+import static org.junit.Assert.assertEquals;
+
+public class HashUtilTest {
+
+ @Test
+ public void testSha256_EmptyString() {
+ String expected1 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+ String result1 = Hex.toHexString(HashUtil.sha256(new byte[0]));
+ assertEquals(expected1, result1);
+ }
+
+ @Test
+ public void testSha256_Test() {
+ String expected2 = "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08";
+ String result2 = Hex.toHexString(HashUtil.sha256("test".getBytes()));
+ assertEquals(expected2, result2);
+ }
+
+ @Test
+ public void testSha256_Multiple() {
+ String expected1 = "1b4f0e9851971998e732078544c96b36c3d01cedf7caa332359d6f1d83567014";
+ String result1 = Hex.toHexString(HashUtil.sha256("test1".getBytes()));
+ assertEquals(expected1, result1);
+
+ String expected2 = "60303ae22b998861bce3b28f33eec1be758a213c86c93c076dbe9f558c11c752";
+ String result2 = Hex.toHexString(HashUtil.sha256("test2".getBytes()));
+ assertEquals(expected2, result2);
+ }
+
+ @Test
+ public void testSha3_EmptyString() {
+ String expected1 = "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470";
+ String result1 = Hex.toHexString(HashUtil.sha3(new byte[0]));
+ assertEquals(expected1, result1);
+ }
+
+ @Test
+ public void testSha3_Test() {
+ String expected2 = "9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658";
+ String result2 = Hex.toHexString(HashUtil.sha3("test".getBytes()));
+ assertEquals(expected2, result2);
+ }
+
+ @Test
+ public void testSha3_Multiple() {
+ String expected1 = "6d255fc3390ee6b41191da315958b7d6a1e5b17904cc7683558f98acc57977b4";
+ String result1 = Hex.toHexString(HashUtil.sha3("test1".getBytes()));
+ assertEquals(expected1, result1);
+
+ String expected2 = "4da432f1ecd4c0ac028ebde3a3f78510a21d54087b161590a63080d33b702b8d";
+ String result2 = Hex.toHexString(HashUtil.sha3("test2".getBytes()));
+ assertEquals(expected2, result2);
+ }
+
+ @Test
+ public void testRIPEMD160_EmptyString() {
+ String expected1 = "9c1185a5c5e9fc54612808977ee8f548b2258d31";
+ String result1 = Hex.toHexString(HashUtil.ripemd160(new byte[0]));
+ assertEquals(expected1, result1);
+ }
+
+ @Test
+ public void testRIPEMD160_Test() {
+ String expected2 = "5e52fee47e6b070565f74372468cdc699de89107";
+ String result2 = Hex.toHexString(HashUtil.ripemd160("test".getBytes()));
+ assertEquals(expected2, result2);
+ }
+
+ @Test
+ public void testRIPEMD160_Multiple() {
+ String expected1 = "9295fac879006ff44812e43b83b515a06c2950aa";
+ String result1 = Hex.toHexString(HashUtil.ripemd160("test1".getBytes()));
+ assertEquals(expected1, result1);
+
+ String expected2 = "80b85ebf641abccdd26e327c5782353137a0a0af";
+ String result2 = Hex.toHexString(HashUtil.ripemd160("test2".getBytes()));
+ assertEquals(expected2, result2);
+ }
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/util/RLPTest.java b/ethereumj-core/src/test/java/org/ethereum/util/RLPTest.java
new file mode 100644
index 00000000..48cffab6
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/util/RLPTest.java
@@ -0,0 +1,983 @@
+package org.ethereum.util;
+
+import org.ethereum.crypto.HashUtil;
+
+import com.cedarsoftware.util.DeepEquals;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import org.spongycastle.util.encoders.Hex;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+
+import java.math.BigInteger;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.Queue;
+
+import static org.ethereum.util.ByteUtil.byteArrayToInt;
+import static org.junit.Assert.*;
+import static org.ethereum.util.RlpTestData.*;
+
+public class RLPTest {
+
+ @Test
+ public void test1() throws UnknownHostException {
+
+ String peersPacket = "F8 4E 11 F8 4B C5 36 81 " +
+ "CC 0A 29 82 76 5F B8 40 D8 D6 0C 25 80 FA 79 5C " +
+ "FC 03 13 EF DE BA 86 9D 21 94 E7 9E 7C B2 B5 22 " +
+ "F7 82 FF A0 39 2C BB AB 8D 1B AC 30 12 08 B1 37 " +
+ "E0 DE 49 98 33 4F 3B CF 73 FA 11 7E F2 13 F8 74 " +
+ "17 08 9F EA F8 4C 21 B0";
+
+ byte[] payload = Hex.decode(peersPacket);
+
+ byte[] ip = RLP.decodeIP4Bytes(payload, 5);
+
+ assertEquals(InetAddress.getByAddress(ip).toString(), ("/54.204.10.41"));
+ }
+
+ @Test
+ public void test2() throws UnknownHostException {
+
+ String peersPacket = "F8 4E 11 F8 4B C5 36 81 " +
+ "CC 0A 29 82 76 5F B8 40 D8 D6 0C 25 80 FA 79 5C " +
+ "FC 03 13 EF DE BA 86 9D 21 94 E7 9E 7C B2 B5 22 " +
+ "F7 82 FF A0 39 2C BB AB 8D 1B AC 30 12 08 B1 37 " +
+ "E0 DE 49 98 33 4F 3B CF 73 FA 11 7E F2 13 F8 74 " +
+ "17 08 9F EA F8 4C 21 B0";
+
+ byte[] payload = Hex.decode(peersPacket);
+ int oneInt = RLP.decodeInt(payload, 11);
+
+ assertEquals(oneInt, 30303);
+ }
+
+ @Test
+ public void test3() throws UnknownHostException {
+
+ String peersPacket = "F8 9A 11 F8 4B C5 36 81 " +
+ "CC 0A 29 82 76 5F B8 40 D8 D6 0C 25 80 FA 79 5C " +
+ "FC 03 13 EF DE BA 86 9D 21 94 E7 9E 7C B2 B5 22 " +
+ "F7 82 FF A0 39 2C BB AB 8D 1B AC 30 12 08 B1 37 " +
+ "E0 DE 49 98 33 4F 3B CF 73 FA 11 7E F2 13 F8 74 " +
+ "17 08 9F EA F8 4C 21 B0 F8 4A C4 36 02 0A 29 " +
+ "82 76 5F B8 40 D8 D6 0C 25 80 FA 79 5C FC 03 13 " +
+ "EF DE BA 86 9D 21 94 E7 9E 7C B2 B5 22 F7 82 FF " +
+ "A0 39 2C BB AB 8D 1B AC 30 12 08 B1 37 E0 DE 49 " +
+ "98 33 4F 3B CF 73 FA 11 7E F2 13 F8 74 17 08 9F " +
+ "EA F8 4C 21 B0 ";
+
+ byte[] payload = Hex.decode(peersPacket);
+
+ int nextIndex = 5;
+ byte[] ip = RLP.decodeIP4Bytes(payload, nextIndex);
+ assertEquals("/54.204.10.41", InetAddress.getByAddress(ip).toString());
+
+ nextIndex = RLP.getNextElementIndex(payload, nextIndex);
+ int port = RLP.decodeInt(payload, nextIndex);
+ assertEquals(30303, port);
+
+ nextIndex = RLP.getNextElementIndex(payload, nextIndex);
+ BigInteger peerId = RLP.decodeBigInteger(payload, nextIndex);
+
+ BigInteger expectedPeerId =
+ new BigInteger("9650128800487972697726795438087510101805200020100629942070155319087371611597658887860952245483247188023303607186148645071838189546969115967896446355306572");
+ assertEquals(expectedPeerId, peerId);
+
+ nextIndex = RLP.getNextElementIndex(payload, nextIndex);
+ nextIndex = RLP.getFirstListElement(payload, nextIndex);
+ ip = RLP.decodeIP4Bytes(payload, nextIndex);
+ assertEquals("/54.2.10.41", InetAddress.getByAddress(ip).toString());
+
+ nextIndex = RLP.getNextElementIndex(payload, nextIndex);
+ port = RLP.decodeInt(payload, nextIndex);
+ assertEquals(30303, port);
+
+ nextIndex = RLP.getNextElementIndex(payload, nextIndex);
+ peerId = RLP.decodeBigInteger(payload, nextIndex);
+
+ expectedPeerId =
+ new BigInteger("9650128800487972697726795438087510101805200020100629942070155319087371611597658887860952245483247188023303607186148645071838189546969115967896446355306572");
+
+ assertEquals(expectedPeerId, peerId);
+
+ nextIndex = RLP.getNextElementIndex(payload, nextIndex);
+ nextIndex = RLP.getFirstListElement(payload, nextIndex);
+ assertEquals(-1, nextIndex);
+ }
+
+ @Test
+ /** encode byte */
+ public void test4() {
+
+ byte[] expected = {(byte) 0x80};
+ byte[] data = RLP.encodeByte((byte) 0);
+ assertArrayEquals(expected, data);
+
+ byte[] expected2 = {(byte) 0x78};
+ data = RLP.encodeByte((byte) 120);
+ assertArrayEquals(expected2, data);
+
+ byte[] expected3 = {(byte) 0x81, (byte) 0x7F};
+ data = RLP.encodeByte((byte) 127);
+ assertArrayEquals(expected3, data);
+ }
+
+ @Test
+ /** encode short */
+ public void test5() {
+
+ byte[] expected = {(byte) 0x80};
+ byte[] data = RLP.encodeShort((byte) 0);
+ assertArrayEquals(expected, data);
+
+ byte[] expected2 = {(byte) 0x78};
+ data = RLP.encodeShort((byte) 120);
+ assertArrayEquals(expected2, data);
+
+ byte[] expected3 = {(byte) 0x81, (byte) 0x7F};
+ data = RLP.encodeShort((byte) 127);
+ assertArrayEquals(expected3, data);
+
+ byte[] expected4 = {(byte) 0x82, (byte) 0x76, (byte) 0x5F};
+ data = RLP.encodeShort((short) 30303);
+ assertArrayEquals(expected4, data);
+
+ byte[] expected5 = {(byte) 0x82, (byte) 0x4E, (byte) 0xEA};
+ data = RLP.encodeShort((short) 20202);
+ assertArrayEquals(expected5, data);
+ }
+
+ @Test
+ /** encode int */
+ public void testEncodeInt() {
+
+ byte[] expected = {(byte) 0x80};
+ byte[] data = RLP.encodeInt(0);
+ assertArrayEquals(expected, data);
+
+ byte[] expected2 = {(byte) 0x78};
+ data = RLP.encodeInt(120);
+ assertArrayEquals(expected2, data);
+
+ byte[] expected3 = {(byte) 0x81, (byte) 0x7F};
+ data = RLP.encodeInt(127);
+ assertArrayEquals(expected3, data);
+
+ byte[] expected4 = {(byte) 0x82, (byte) 0x76, (byte) 0x5F};
+ data = RLP.encodeInt(30303);
+ assertArrayEquals(expected4, data);
+
+ byte[] expected5 = {(byte) 0x82, (byte) 0x4E, (byte) 0xEA};
+ data = RLP.encodeInt(20202);
+ assertArrayEquals(expected5, data);
+
+ byte[] expected6 = {(byte) 0x83, 1, 0, 0};
+ data = RLP.encodeInt(65536);
+ assertArrayEquals(expected6, data);
+
+ byte[] expected7 = {(byte) 0x80};
+ data = RLP.encodeInt(Integer.MIN_VALUE);
+ assertArrayEquals(expected7, data);
+
+ byte[] expected8 = {(byte) 0x84, (byte) 0x7F, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF};
+ data = RLP.encodeInt(Integer.MAX_VALUE);
+ assertArrayEquals(expected8, data);
+ }
+
+ @Test
+ /** encode BigInteger */
+ public void test6() {
+
+ byte[] expected = new byte[]{(byte) 0x80};
+ byte[] data = RLP.encodeBigInteger(BigInteger.ZERO);
+ assertArrayEquals(expected, data);
+ }
+
+ @Test
+ /** encode string */
+ public void test7() {
+
+ byte[] data = RLP.encodeString("");
+ assertArrayEquals(new byte[]{(byte) 0x80}, data);
+
+ byte[] expected = {(byte) 0x90, (byte) 0x45, (byte) 0x74, (byte) 0x68, (byte) 0x65, (byte) 0x72, (byte) 0x65,
+ (byte) 0x75, (byte) 0x6D, (byte) 0x4A, (byte) 0x20, (byte) 0x43, (byte) 0x6C,
+ (byte) 0x69, (byte) 0x65, (byte) 0x6E, (byte) 0x74};
+
+ String test = "EthereumJ Client";
+ data = RLP.encodeString(test);
+
+ assertArrayEquals(expected, data);
+
+ String test2 = "Ethereum(++)/ZeroGox/v0.5.0/ncurses/Linux/g++";
+
+ byte[] expected2 = {(byte) 0xAD, (byte) 0x45, (byte) 0x74, (byte) 0x68, (byte) 0x65, (byte) 0x72, (byte) 0x65,
+ (byte) 0x75, (byte) 0x6D, (byte) 0x28, (byte) 0x2B, (byte) 0x2B, (byte) 0x29, (byte) 0x2F,
+ (byte) 0x5A, (byte) 0x65, (byte) 0x72, (byte) 0x6F, (byte) 0x47, (byte) 0x6F, (byte) 0x78,
+ (byte) 0x2F, (byte) 0x76, (byte) 0x30, (byte) 0x2E, (byte) 0x35, (byte) 0x2E, (byte) 0x30,
+ (byte) 0x2F, (byte) 0x6E, (byte) 0x63, (byte) 0x75, (byte) 0x72, (byte) 0x73, (byte) 0x65,
+ (byte) 0x73, (byte) 0x2F, (byte) 0x4C, (byte) 0x69, (byte) 0x6E, (byte) 0x75, (byte) 0x78,
+ (byte) 0x2F, (byte) 0x67, (byte) 0x2B, (byte) 0x2B};
+
+ data = RLP.encodeString(test2);
+ assertArrayEquals(expected2, data);
+
+ String test3 = "Ethereum(++)/ZeroGox/v0.5.0/ncurses/Linux/g++Ethereum(++)/ZeroGox/v0.5.0/ncurses/Linux/g++";
+
+ byte[] expected3 = {(byte) 0xB8, (byte) 0x5A,
+ (byte) 0x45, (byte) 0x74, (byte) 0x68, (byte) 0x65, (byte) 0x72, (byte) 0x65,
+ (byte) 0x75, (byte) 0x6D, (byte) 0x28, (byte) 0x2B, (byte) 0x2B, (byte) 0x29, (byte) 0x2F,
+ (byte) 0x5A, (byte) 0x65, (byte) 0x72, (byte) 0x6F, (byte) 0x47, (byte) 0x6F, (byte) 0x78,
+ (byte) 0x2F, (byte) 0x76, (byte) 0x30, (byte) 0x2E, (byte) 0x35, (byte) 0x2E, (byte) 0x30,
+ (byte) 0x2F, (byte) 0x6E, (byte) 0x63, (byte) 0x75, (byte) 0x72, (byte) 0x73, (byte) 0x65,
+ (byte) 0x73, (byte) 0x2F, (byte) 0x4C, (byte) 0x69, (byte) 0x6E, (byte) 0x75, (byte) 0x78,
+ (byte) 0x2F, (byte) 0x67, (byte) 0x2B, (byte) 0x2B,
+
+ (byte) 0x45, (byte) 0x74, (byte) 0x68, (byte) 0x65, (byte) 0x72, (byte) 0x65,
+ (byte) 0x75, (byte) 0x6D, (byte) 0x28, (byte) 0x2B, (byte) 0x2B, (byte) 0x29, (byte) 0x2F,
+ (byte) 0x5A, (byte) 0x65, (byte) 0x72, (byte) 0x6F, (byte) 0x47, (byte) 0x6F, (byte) 0x78,
+ (byte) 0x2F, (byte) 0x76, (byte) 0x30, (byte) 0x2E, (byte) 0x35, (byte) 0x2E, (byte) 0x30,
+ (byte) 0x2F, (byte) 0x6E, (byte) 0x63, (byte) 0x75, (byte) 0x72, (byte) 0x73, (byte) 0x65,
+ (byte) 0x73, (byte) 0x2F, (byte) 0x4C, (byte) 0x69, (byte) 0x6E, (byte) 0x75, (byte) 0x78,
+ (byte) 0x2F, (byte) 0x67, (byte) 0x2B, (byte) 0x2B};
+
+ data = RLP.encodeString(test3);
+ assertArrayEquals(expected3, data);
+ }
+
+ @Test
+ /** encode byte array */
+ public void test8() {
+
+ String byteArr = "ce73660a06626c1b3fda7b18ef7ba3ce17b6bf604f9541d3c6c654b7ae88b239"
+ + "407f659c78f419025d785727ed017b6add21952d7e12007373e321dbc31824ba";
+
+ byte[] byteArray = Hex.decode(byteArr);
+
+ String expected = "b840" + byteArr;
+
+ assertEquals(expected, Hex.toHexString(RLP.encodeElement(byteArray)));
+ }
+
+ @Test
+ /** encode list */
+ public void test9() {
+
+ byte[] actuals = RLP.encodeList();
+ assertArrayEquals(new byte[]{(byte) 0xc0}, actuals);
+ }
+
+ @Test
+ /** encode null value */
+ public void testEncodeElementNull() {
+
+ byte[] actuals = RLP.encodeElement(null);
+ assertArrayEquals(new byte[]{(byte) 0x80}, actuals);
+ }
+
+ @Test
+ /** encode single byte 0x00 */
+ public void testEncodeElementZero() {
+
+ byte[] actuals = RLP.encodeElement(new byte[]{0x00});
+ assertArrayEquals(new byte[]{0x00}, actuals);
+ }
+
+ @Test
+ /** encode single byte 0x01 */
+ public void testEncodeElementOne() {
+
+ byte[] actuals = RLP.encodeElement(new byte[]{0x01});
+ assertArrayEquals(new byte[]{(byte) 0x01}, actuals);
+ }
+
+ @Test
+ /** found bug encode list affects element value,
+ hhh... not really at the end but keep the test */
+ public void test10() {
+
+ /* 2 */
+ byte[] prevHash =
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+ prevHash = RLP.encodeElement(prevHash);
+
+ /* 2 */
+ byte[] uncleList = HashUtil.sha3(RLP.encodeList(new byte[]{}));
+
+ /* 3 */
+ byte[] coinbase =
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00};
+ coinbase = RLP.encodeElement(coinbase);
+
+ byte[] header = RLP.encodeList(
+ prevHash, uncleList, coinbase);
+
+ assertEquals("f856a000000000000000000000000000000000000000000000000000000000000000001dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000",
+ Hex.toHexString(header));
+ }
+
+ @Test
+ public void test11() {
+// 2240089100000070
+ String tx = "F86E12F86B80881BC16D674EC8000094CD2A3D9F938E13CD947EC05ABC7FE734DF8DD8268609184E72A00064801BA0C52C114D4F5A3BA904A9B3036E5E118FE0DBB987FE3955DA20F2CD8F6C21AB9CA06BA4C2874299A55AD947DBC98A25EE895AABF6B625C26C435E84BFD70EDF2F69";
+ byte[] payload = Hex.decode(tx);
+
+ Queue index = new LinkedList<>();
+ RLP.fullTraverse(payload, 0, 0, payload.length, 1, index);
+
+ // TODO: assert lenght overflow while parsing list in RLP
+ }
+
+ @Test
+ public void test12() {
+
+ String tx = "F86E12F86B80881BC16D674EC8000094CD2A3D9F938E13CD947EC05ABC7FE734DF8DD8268609184E72A00064801BA0C52C114D4F5A3BA904A9B3036E5E118FE0DBB987FE3955DA20F2CD8F6C21AB9CA06BA4C2874299A55AD947DBC98A25EE895AABF6B625C26C435E84BFD70EDF2F69";
+ byte[] payload = Hex.decode(tx);
+
+ RLPList rlpList = RLP.decode2(payload);
+
+ RLPList.recursivePrint(rlpList);
+ // TODO: add some asserts in place of just printing the rlpList
+ }
+
+ @Test /* very long peers msg */
+ public void test13() {
+
+ String peers = "f9 14 90 11 f8 4c c6 81 83 68 81 fc 04 82 76 5f b8 40 07 7e 53 7a 8b 36 73 e8 f1 b6 25 db cc " +
+ "90 2e a7 d4 ce d9 40 2e 46 64 e8 73 67 95 12 cc 23 60 69 8e 53 42 56 52 a0 46 24 fc f7 8c db a1 a3 " +
+ "23 30 87 a9 19 a3 4d 11 ae da ce ee b7 d8 33 fc bf 26 f8 4c c6 63 81 e7 58 81 af 82 76 5f b8 40 0a " +
+ "b2 cd e8 3a 09 84 03 dd c2 ea 54 14 74 0d 8a 01 93 e4 49 c9 6e 11 24 19 96 7a bc 62 eb 17 cd ce d7 " +
+ "7a e0 ab 07 5e 04 f7 dd dc d4 3f b9 04 8b e5 32 06 a0 40 62 0b de 26 cb 74 3f a3 12 31 9f f8 4d c7 " +
+ "81 cf 81 db 45 81 9a 82 76 5f b8 40 19 c3 3d a7 03 1c ff 17 7e fa 84 2f aa 3d 31 bd 83 e1 76 4e c6 " +
+ "10 f2 36 94 4a 9f 8a 21 c1 c5 1a 04 f4 7f 6b 5f c3 ef e6 5c af 36 94 43 63 5a fc 58 d8 f5 d4 e2 f1 " +
+ "2a f9 ee ec 3c 6e 30 bf 0a 2b f8 4c c6 44 30 81 ad 81 a3 82 76 5f b8 40 1e 59 c2 82 08 12 94 80 84 " +
+ "97 ae 7a 7e 97 67 98 c4 2b 8b cc e1 3c 9d 8b 0e cf 8a fe cd b5 df d4 ef a8 77 0f c0 d1 f7 de 63 c9 " +
+ "16 40 e7 e8 b4 35 8c 9e 3e d0 f3 d6 c9 86 20 ad 7e a4 24 18 c9 ec f8 4b c5 1f 12 81 9e 48 82 76 5f " +
+ "b8 40 1f 68 c0 75 c1 d8 7b c0 47 65 43 0f df b1 e5 d0 0f 1b 78 4e d6 be 72 1e 4c af f7 be b5 7b 4b " +
+ "21 7b 95 da 19 b5 ec 66 04 58 68 b3 9a ac 2e 08 76 cf 80 f0 b6 8d 0f a2 0b db 90 36 be aa 70 61 ea " +
+ "f8 4c c6 81 bf 81 ea 39 37 82 76 5f b8 40 21 78 0c 55 b4 7d b4 b1 14 67 b5 f5 5b 0b 55 5e 08 87 ce " +
+ "36 fb d9 75 e2 24 b1 c7 0e ac 7a b8 e8 c2 db 37 f0 a4 8b 90 ff dd 5a 37 9a da 99 b6 a0 f6 42 9c 4a " +
+ "53 c2 55 58 19 1a 68 26 36 ae f4 f2 f8 4c c6 44 30 81 ad 81 a3 82 76 5f b8 40 23 15 cb 7c f4 9b 8e " +
+ "ab 21 2c 5a 45 79 0b 50 79 77 39 73 8f 5f 73 34 39 b1 90 11 97 37 ee 8c 09 bc 72 37 94 71 2a a8 2f " +
+ "26 70 bc 58 1a b0 75 7e f2 31 37 ac 0f df 0f 8c 89 65 e7 dd 6b a7 9f 8c f8 4e c8 81 bf 81 b1 81 d1 " +
+ "81 9f 82 76 5f b8 40 24 9a 36 41 e5 a8 d0 8e 41 a5 cf c8 da e1 1f 17 61 25 4f 4f d4 7d 9b 13 33 8d " +
+ "b8 e6 e3 72 9e 6f 2a c9 ec 09 7a 5c 80 96 84 d6 2a 41 e6 df c2 ff f7 2d c3 db d9 7e a2 61 32 bb 97 " +
+ "64 05 65 bb 0c f8 4a c4 55 41 7e 2d 82 76 5f b8 40 2a 38 ea 5d 9a 7e fd 7f ff c0 a8 1d 8e a7 ed 28 " +
+ "31 1c 40 12 bb ab 14 07 c8 da d2 68 51 29 e0 42 17 27 34 a3 28 e8 90 7f 90 54 b8 22 5f e7 70 41 d8 " +
+ "a4 86 a9 79 76 d2 83 72 42 ab 6c 8c 59 05 e4 f8 4c c6 81 83 68 81 fc 04 82 76 5f b8 40 32 4d d9 36 " +
+ "38 4d 8c 0d de fd e0 4b a7 40 29 98 ab bd 63 d7 9c 0b f8 58 6b 3d d2 c7 db f6 c9 1e b8 0a 7b 6d e8 " +
+ "f1 6a 50 04 4f 14 9c 7b 39 aa fb 9c 3a d7 f2 ca a4 03 55 aa b0 98 88 18 6f cc a2 f8 4c c6 44 30 81 " +
+ "ad 81 a3 82 76 5f b8 40 39 42 45 c0 99 16 33 ed 06 0b af b9 64 68 53 d3 44 18 8b 80 4f e3 7e 25 a5 " +
+ "bc ac 44 ed 44 3a 84 a6 8b 3a af 15 5e fe 48 61 e8 4b 4b 51 5f 9a 5d ec db d7 da e9 81 92 d7 a3 20 " +
+ "a7 92 c7 d4 df af f8 4d c7 56 81 b7 81 e7 81 cd 82 76 5f b8 40 39 86 50 f6 7b 22 92 93 9d e3 4c 0e " +
+ "ae b9 14 1f 94 84 a0 fb 17 3f a3 3f 81 a1 f7 31 5d 0e b7 7b de 3a 76 c3 86 36 fa e6 6f a1 4b f2 af " +
+ "df d6 3e 60 ab d4 0e 29 b0 2a 91 4e 65 de 57 89 98 3f d4 f8 4c c6 44 81 b9 81 ea 40 82 76 5f b8 40 " +
+ "3a 15 58 7a 1c 3a da bf 02 91 b3 07 f7 1b 2c 04 d1 98 aa e3 6b 83 49 95 d3 30 5d ff 42 f1 ab 86 f4 " +
+ "83 ae 12 9e 92 03 fb c6 ef 21 87 c8 62 1e dd 18 f6 1d 53 ea a5 b5 87 ff de a4 d9 26 48 90 38 f8 4d " +
+ "c7 81 cf 81 db 45 81 9a 82 76 5f b8 40 3b 14 62 04 0e a7 78 e3 f7 5e 65 ce 24 53 41 8a 66 2e 62 12 " +
+ "c9 f6 5b 02 ea b5 8d 22 b2 87 e4 50 53 bd e5 eb f0 60 96 0c bf a0 d9 dc 85 bf 51 ba 7a a1 f2 ca a2 " +
+ "c1 36 82 d9 32 77 64 1d 60 db eb f8 4c c6 6a 81 a8 0e 81 f9 82 76 5f b8 40 3e cc 97 ab 15 d2 2f 7b " +
+ "9e df 19 c0 4c e3 b6 09 5f a2 50 42 14 00 2b 35 98 9c 6f 81 ee 4b 96 1c c2 a8 99 c4 94 15 c9 14 e3 " +
+ "13 90 83 40 04 7d 1d 3b 25 d7 4f 5b 9c 85 a0 6a fa 26 59 a5 39 99 2e f8 4b c5 2e 04 81 c1 09 82 76 " +
+ "5f b8 40 40 7c 22 00 3f 3b ba a6 cb eb 8e 4b 0a b7 07 30 73 fe ab 85 18 2b 40 55 25 f8 bd 28 32 55 " +
+ "04 3d 71 35 18 f7 47 48 d9 2c 43 fb b9 9e cc 7c 3f ba b9 5d 59 80 06 51 3a a8 e5 9c 48 04 1c 8b 41 " +
+ "c2 f8 4b c5 32 7e 56 81 c2 82 76 5f b8 40 40 8c 93 24 20 3b d8 26 2f ce 65 06 ba 59 dc dd 56 70 89 " +
+ "b0 eb 9a 5b b1 83 47 7b ab bf 61 63 91 4a cd c7 f4 95 f8 96 4d 8a c1 2f e2 40 18 87 b8 cd 8d 97 c0 " +
+ "c9 dc cf ad db b2 0a 3c 31 47 a7 89 f8 4a c4 26 6c 4f 68 82 76 5f b8 40 42 3e 40 04 da 2f a7 50 0b " +
+ "c0 12 c0 67 4a a6 57 15 02 c5 3a a4 d9 1e fa 6e 2b 5c b1 e4 68 c4 62 ca 31 14 a2 e2 eb 09 65 b7 04 " +
+ "4f 9c 95 75 96 5b 47 e4 7a 41 f1 3f 1a dc 03 a2 a4 b3 42 d7 12 8d f8 4b c5 40 81 e7 08 2d 82 76 5f " +
+ "b8 40 42 83 93 75 27 2c 2f 3d ea db 28 08 5d 06 05 5e 35 31 35 c6 c8 d8 96 09 7a 1b c4 80 c4 88 4f " +
+ "d1 60 45 18 cb df 73 1a c1 8f 09 84 b7 f0 21 48 e8 82 90 d1 3c 22 4d 82 46 43 14 e2 b5 96 2e 3f 89 " +
+ "f8 4d c7 32 81 aa 81 d8 81 c8 82 76 5f b8 40 44 cf 19 44 6c a4 65 01 8e 4d e6 c6 0f c0 df 52 9e ba " +
+ "25 02 92 ef 74 41 e1 db 59 84 1c 69 f0 22 f6 09 28 10 c9 a5 a7 f2 74 f2 f9 7c 4b d6 c7 6e ad c0 64 " +
+ "c7 d6 59 7c ae b1 7e d8 7c b2 57 73 5f f8 4b c5 32 81 9c 5a 53 82 76 5f b8 40 46 1c 9b 54 e9 19 53 " +
+ "c5 bb c3 1c 67 12 a9 17 38 2b e6 7d 60 f7 5e b7 f5 06 51 be a3 e5 94 d0 d1 9c 22 29 d8 f6 6a db 3f " +
+ "20 3f 60 00 38 e7 cc 93 4d c9 27 87 fa c4 39 2b 9b fa 7c bc 78 6f d0 5b f8 4b c5 81 86 64 7d 29 82 " +
+ "76 5f b8 40 48 35 3a 00 58 e2 64 48 d9 4e 59 33 6c ca 9d 28 a9 37 41 20 de f7 6c 4b cc fe e1 8b 01 " +
+ "23 e5 91 92 39 3a 2e e3 04 4d 80 e0 ee cb b0 94 76 be 62 fd e1 e8 74 f9 3d 05 ea 5c 4a 9a 45 c0 6e " +
+ "8f e1 f8 4b c5 4e 08 05 81 bb 82 76 5f b8 40 48 e8 95 09 49 d4 c0 0b cd bb e9 39 c5 bf 07 8f 2c bf " +
+ "f1 08 84 af 16 60 b1 c3 22 b9 ca a3 ba 35 7b b4 15 7f c6 b0 03 9a f9 43 8d fe 51 ec 27 8a 47 fc d3 " +
+ "b7 26 fa 0a 08 7d 4c 3c 01 a6 2f 33 5e f8 4a c6 58 45 81 c6 81 c6 07 b8 40 4a 02 55 fa 46 73 fa a3 " +
+ "0f c5 ab fd 3c 55 0b fd bc 0d 3c 97 3d 35 f7 26 46 3a f8 1c 54 a0 32 81 cf ff 22 c5 f5 96 5b 38 ac " +
+ "63 01 52 98 77 57 a3 17 82 47 85 49 c3 6f 7c 84 cb 44 36 ba 79 d6 d9 f8 4b c5 40 81 e7 08 2d 82 76 " +
+ "5f b8 40 4c 75 47 ab 4d 54 1e 10 16 4c d3 74 1f 34 76 ed 19 4b 0a b9 a1 36 df ca c3 94 3f 97 35 8c " +
+ "9b 05 14 14 27 36 ca 2f 17 0f 12 52 29 05 7b 47 32 44 a6 23 0b f5 47 1a d1 68 18 85 24 b2 b5 cd 8b " +
+ "7b f8 4c c6 44 30 81 ad 81 a3 82 76 5f b8 40 4d 5e 48 75 d6 0e b4 ee af b6 b2 a7 d3 93 6e d3 c9 bc " +
+ "58 ac aa de 6a 7f 3c 5f 25 59 8c 20 b3 64 f1 2b ea 2f b1 db 3b 2c 2e f6 47 85 a4 7d 6b 6b 5b 10 34 " +
+ "27 cb ac 0c 88 b1 8f e9 2a 9f 53 93 f8 f8 4b c5 52 0c 81 e3 54 82 76 5f b8 40 4f d8 98 62 75 74 d3 " +
+ "e8 6b 3f 5a 65 c3 ed c2 e5 da 84 53 59 26 e4 a2 88 20 b0 03 8b 19 63 6e 07 db 5e b0 04 d7 91 f8 04 " +
+ "1a 00 6e 33 e1 08 e4 ec 53 54 99 d1 28 d8 d9 c5 ca f6 bb dc 22 04 f7 6a f8 4b c5 81 b4 20 2b 08 82 " +
+ "76 5f b8 40 53 cc f2 5a b5 94 09 ec bb 90 3d 2e c3 a9 aa 2e b3 9d 7c c4 c7 db 7e 6f 68 fd 71 1a 7c " +
+ "eb c6 06 21 6d e7 37 82 6d a4 20 93 e3 e6 52 1e e4 77 0e b2 d6 69 dc 4b f3 54 6c c7 57 c3 40 12 69 " +
+ "6e ae f8 4c c6 6a 81 a8 0e 81 f9 82 76 5f b8 40 54 b3 93 15 69 91 39 87 80 50 2f a8 f4 14 13 79 bc " +
+ "e2 69 31 be 87 ba 8e 0b 74 9b a9 05 a9 e9 76 e5 de 6d 39 c9 8c f0 48 f2 5c 3c bb b8 c7 f3 02 c4 e6 " +
+ "04 ad 5b f7 2c db 06 10 0f 50 0d e3 a6 86 f8 4a c4 4c 67 37 47 82 76 5f b8 40 60 0a 77 fb 14 e7 92 " +
+ "c0 c7 0d c4 ad e3 82 ed 60 43 62 b9 78 b1 9b 94 c4 ed 18 83 38 a1 79 5d 2d b4 5f 7f 22 3b 66 ba eb " +
+ "a3 91 c5 9b 55 88 b4 4e ba f7 1c 7e b3 97 55 c2 72 29 c7 fd e6 41 be ce f8 4b c5 6d 2b 81 9a 42 82 " +
+ "76 5f b8 40 69 dd 44 5f 67 c3 be f3 94 f9 54 9f da e1 62 3d bc 20 88 4a 62 fd 56 16 dd bb 49 f8 4b " +
+ "a8 7e 14 7c b8 a5 0b a9 71 d7 30 c4 62 1d 0e b6 51 33 49 4e 94 fa 5e a2 e6 9c 66 1f 6b 12 e7 ed 2a " +
+ "8d 4e f8 4b c5 18 09 3d 81 9b 82 76 5f b8 40 6b 5d 4c 35 ff d1 f5 a1 98 03 8a 90 83 4d 29 a1 b8 8b " +
+ "e0 d5 ef ca 08 bc 8a 2d 58 81 18 0b 0b 41 6b e0 06 29 aa be 45 0a 50 82 8b 8d 1e e8 2d 98 f5 52 81 " +
+ "87 ee 67 ed 6e 07 3b ce ef cd fb 2b c9 f8 4a c4 55 41 7e 2d 82 76 5f b8 40 6c bb 1e d5 36 dc 38 58 " +
+ "c1 f0 63 42 9b d3 95 2a 5d 32 ef 8e 11 52 6c df e7 2f 41 fe a1 ac e9 60 18 7c 99 75 ab bc 23 78 35 " +
+ "11 c0 0f 26 98 35 47 47 f9 05 aa ac 11 dc d2 b7 47 8b 3e af 32 7a c6 f8 4b c5 40 81 e7 08 2d 82 76 " +
+ "5f b8 40 6e a2 8f 64 ea 1c c3 b6 57 25 44 fd 5b f7 43 b0 ea ab e0 17 f5 14 73 0c 89 7d a3 c7 7f 03 " +
+ "c5 16 f1 e5 f3 1d 79 3b 4b ce 3c aa 1d ed 56 35 6d 20 b2 eb b5 5a 70 66 f4 1c 25 b7 c3 d5 66 14 e0 " +
+ "6b f8 4a c4 55 41 7e 2d 82 76 5f b8 40 72 53 24 08 e8 be 6d 5e 2c 9f 65 0f b9 c9 f9 96 50 cc 1f a0 " +
+ "62 a4 a4 f2 cf e4 e6 ae 69 cd d2 e8 b2 3e d1 4a fe 66 95 5c 23 fa 04 8f 3a 97 6e 3c e8 16 9e 50 5b " +
+ "6a 89 cc 53 d4 fa c2 0c 2a 11 bf f8 4c c6 52 81 d9 48 81 a9 82 76 5f b8 40 7a ee a4 33 60 b9 36 8b " +
+ "30 e7 f4 82 86 61 3f d1 e3 b0 20 7f b7 1f 03 08 d5 04 12 11 44 63 e7 7a b8 30 27 c0 d4 0c ad aa b8 " +
+ "bb f6 12 fc 5b 69 67 fa 1c 40 73 29 d4 7e c6 1f b0 dc 3d a1 08 68 32 f8 4c c6 81 a6 81 93 53 4f 82 " +
+ "76 5f b8 40 7b 3c dd e0 58 d5 b4 5d 8d b2 24 36 60 cf ea 02 e0 74 ec 21 31 14 c2 51 d7 c0 c3 2d 04 " +
+ "03 bb 7a b4 77 13 d2 49 2f f6 c8 81 cf c2 aa c3 f5 2c b2 69 76 8c 89 68 f3 b6 b1 8b ac 97 22 d0 53 " +
+ "31 f6 f8 4c c6 6a 81 a8 0e 81 f9 82 76 5f b8 40 87 ab 58 1b b9 7c 21 2a 2d a7 ef 0d 6e 10 5e 41 b5 " +
+ "5e 4e 42 cb b6 a1 af 9a 76 1a 01 ca 8c 65 06 9a b4 b5 82 7e 32 2c f2 c5 f5 9e 7f 59 2b e2 a8 17 c4 " +
+ "5a b6 41 f5 a9 dd 36 89 63 c7 3f 9e e6 88 f8 4c c6 52 81 d9 48 81 a9 82 76 5f b8 40 8c 66 0d bc 6d " +
+ "3d b0 18 6a d1 0f 05 fd 4f 2f 06 43 77 8e c5 14 e8 45 2a 75 50 c6 30 da 21 17 1a 29 b1 bb 67 c2 e8 " +
+ "e1 01 ea 1d b3 97 43 f3 e7 8c 4d 26 76 a1 3d 15 51 51 21 51 5f c3 8b 04 8f 37 f8 4c c6 63 81 e7 58 " +
+ "81 af 82 76 5f b8 40 94 fe 3d 52 a2 89 4c ed c6 b1 54 24 15 6e b8 73 8a 84 41 dd 74 ba 9c ed 66 64 " +
+ "ed 30 a3 32 a9 5b 57 4d 89 26 2e a3 67 fa 90 0a e9 70 6f b8 1a 40 82 87 bd de f3 a9 dd 9f f4 4e 3a " +
+ "41 bc 09 0f dc f8 4d c7 81 d5 81 81 81 e6 0a 82 76 5f b8 40 95 21 14 f1 10 e8 ac 00 df ea 5f 05 0d " +
+ "95 5e 76 4c 7c ba 8f b2 07 c0 5a 7a a5 ae 84 91 68 64 0a 2b 4e 31 43 91 fc 3a 76 79 5b 38 27 05 54 " +
+ "62 63 9c ff 4a e2 d6 4a b8 0e 95 27 44 28 31 3e 36 6a f8 4c c6 58 45 81 c6 81 c6 82 76 5f b8 40 96 " +
+ "f3 47 b0 96 ed 16 30 f4 74 b9 76 23 e4 5e 8d 47 1b 1d 43 c2 2f 59 96 07 c8 b2 e3 ed 0d 7b 79 05 d8 " +
+ "55 4a d3 99 db d7 39 c7 61 26 40 44 24 d8 db 0d c7 d2 b0 47 c1 a3 28 ae 27 d4 09 06 c5 83 f8 4c c6 " +
+ "81 83 68 81 fc 04 82 76 5f b8 40 9a 22 c8 fb 1b d8 bb d0 2f 0e 74 ed 9d 3d 55 b0 f5 b0 96 72 bc 43 " +
+ "a2 d4 7b 1e d0 42 38 c1 c3 2b 6a 65 74 26 52 5b 15 51 82 36 e9 78 9b 54 6a 4a 07 2a 60 5e 13 73 fe " +
+ "5b 99 6b ae dc 30 35 94 28 f8 4b c5 52 0c 81 e3 54 82 76 5f b8 40 9b 1a 3a 8d 77 1b 3d 94 9c a3 94 " +
+ "a8 8e b5 dc 29 a9 53 b0 2c 81 f0 17 36 1f fc 0a fe 09 ab ce 30 69 17 1a 87 d4 74 52 36 87 fc c9 a9 " +
+ "d3 2c c0 2c fa b4 13 22 56 fe aa bf e0 5f 7a c7 47 19 4e 88 f8 4b c5 42 81 d7 78 1c 82 76 5f b8 40 " +
+ "9f a7 e5 5b 2d 98 f1 d7 44 c7 62 32 e4 fd a2 42 fe 9f d3 d5 74 3d 16 d3 ca d2 e5 48 a0 7c b5 af 06 " +
+ "fe 60 eb ae b8 c6 09 50 28 17 92 34 dc dd d3 cd cf 1f cf e6 ed aa 2a 53 30 7f d1 03 da 4a f0 f8 4a " +
+ "c4 55 41 7e 2d 82 76 5f b8 40 a0 1f 83 4e 9d 1a 61 3c 3c 74 7e 56 1c ac 19 cb 12 d8 79 c1 a5 74 20 " +
+ "a4 9c 23 65 2b 8f 51 28 8c 8b 11 1a a3 88 89 98 b0 5e 32 7f 47 a2 35 c6 a4 a3 77 f8 88 e3 00 5a 2d " +
+ "4b 03 ec b7 26 86 08 d3 f8 4c c6 44 30 81 ad 81 a3 82 7a 51 b8 40 a5 fd 77 c0 d4 32 fb fa 33 17 08 " +
+ "49 14 c2 e8 a8 82 1e 4b a1 dc ba 44 96 1f f7 48 0e 6d b6 08 78 9c ab 62 91 41 63 60 ea 8c dc 26 b0 " +
+ "d2 f0 87 7c 50 e8 9a 70 c1 bc f5 d6 dd 8b 18 2e 0a 9e 37 d3 f8 4d c7 81 88 81 a0 81 98 31 82 76 5f " +
+ "b8 40 ae 31 bd 02 54 ee 7d 10 b8 0f c9 0e 74 ba 06 ba 76 11 87 df 31 38 a9 79 9d e5 82 8d 01 63 52 " +
+ "4c 44 ba c7 d2 a9 b5 c4 1b e5 be 82 89 a1 72 36 1f 0b a9 04 10 c9 4f 57 9b f7 eb d2 8f 18 aa a1 cd " +
+ "f8 4a c4 55 41 7e 2d 82 76 5f b8 40 ba 3d 21 67 72 cd c7 45 58 d2 54 56 24 a2 d6 2d cb cf d2 72 30 " +
+ "57 30 c7 46 43 c7 a7 e8 19 af a6 cd d8 22 23 e2 b5 50 1e b6 d4 ea e5 db f2 1e 55 8c 76 8a ca ec 2c " +
+ "1c a1 0e 74 c4 c8 7a 57 4b 53 f8 4a c4 55 41 7e 2d 82 76 5f b8 40 bd b4 9c 01 87 2d 91 bd 1e a9 90 " +
+ "bd 2e df 16 c4 81 71 a6 06 7f 9a 6f 7f 48 bf b1 94 63 0b 5a e9 03 1b 5d c2 63 f5 9c 66 ad a4 44 cb " +
+ "4e 6f 9d f6 2b 30 17 ce 61 2c ab 7b 53 da 08 d3 56 f7 8d 30 f8 4c c6 63 81 e7 58 81 af 82 76 5f b8 " +
+ "40 c1 2b a9 1f 95 04 4d 78 ee d1 d3 a9 53 5e bd 64 71 52 44 18 13 5e eb 46 ad 5d 5c 6e cc 2f 51 68 " +
+ "b4 ab 3a 06 2b b0 74 2a ea 65 ff ea 76 7f ab 8d cc 21 78 3c b2 9b f3 2e 2c d6 22 22 09 fa 71 fd f8 " +
+ "4c c6 44 30 81 ad 81 a3 82 7a 51 b8 40 c2 e2 69 e6 4a a8 c9 be 2d 41 81 2a 48 af a2 34 6b d4 1a 1a " +
+ "b2 e4 64 62 41 ae 3b 8d 0c cd 41 f2 d6 82 b1 5a 02 5f 75 9c 0d 95 5a 60 71 d4 e8 ea 7d 4d e3 97 d6 " +
+ "e0 52 23 09 20 11 3b 6e b7 4c 09 f8 4a c4 4a 4f 17 77 82 76 5f b8 40 c3 03 b8 3f 6a 16 1f 99 67 36 " +
+ "34 44 80 ae 9d 88 fd c1 d9 c6 75 bf ac a8 88 f7 0f 24 89 72 65 62 82 09 da 53 74 1e 03 c0 f6 59 21 " +
+ "f6 8f 60 2d c9 f3 34 a3 c4 5b cb 92 af 85 44 a6 fb 11 9b d8 87 f8 4b c5 0c 81 fa 61 1a 82 76 5f b8 " +
+ "40 c7 6e 7c 15 7b 77 35 51 11 53 d1 f9 50 81 a1 44 e0 88 a9 89 17 1f 3d 43 2c c5 d8 29 3e ce 9c fa " +
+ "a4 83 c0 32 15 5d 7b 53 65 6a 6e 33 a3 d7 5c d0 62 4e 09 a2 f9 49 c1 56 09 3d ba a8 3f 11 11 f2 f8 " +
+ "4b c5 52 0c 81 e3 54 82 76 5f b8 40 c7 d5 a3 69 1a 59 59 9d e3 33 48 9c bf 8a 47 a7 43 3e 92 c7 27 " +
+ "06 e1 3d 94 ed 21 12 96 d3 5c 97 d8 35 7d 7e 07 b3 85 85 64 d7 26 8e d7 aa 09 7f 37 58 9c 27 77 0f " +
+ "90 dd 0b 07 63 5b e3 f5 33 64 f8 4c c6 4e 09 81 92 81 b2 82 76 5f b8 40 c8 81 97 a8 2b 0a cf 0a 87 " +
+ "24 94 d1 df ac 9d e8 46 da a7 de 08 b2 40 64 7a 96 ba 72 fb e0 8f d5 2b 55 c6 c9 45 14 a4 7e c5 1b " +
+ "a4 9a 97 54 89 eb c9 38 3b 48 f5 e2 40 93 90 68 ce 58 36 ff 24 f1 f8 4b c5 81 b4 20 2b 08 82 76 5f " +
+ "b8 40 c9 e0 39 d8 a8 b9 e4 35 be f2 f4 5f c7 cb 7e 78 87 16 e8 c7 af c1 ba cc 64 e1 24 6d 2a b5 06 " +
+ "d3 60 73 79 2a e6 96 e4 1a d6 ba 0c 8a bd 2e c0 d5 45 b0 75 7f 94 a9 f3 53 82 80 e5 6d b5 f5 d8 ec " +
+ "f8 4b c5 4e 68 81 a3 51 82 76 5f b8 40 ca 27 68 37 02 a8 e9 bf 32 01 65 6f f8 4a 60 d5 b1 dd 81 42 " +
+ "73 99 3c f1 a0 25 b0 54 45 4e 40 d5 30 92 f4 85 18 ee 05 be ad 4f 18 02 1f 4f 54 0c 0b 7c 7d 26 eb " +
+ "a5 0e a4 89 0b 9e 5e 49 a7 6c 5f f8 4a c4 55 41 7e 2d 82 76 5f b8 40 cb 72 be 9e 2e 5d 4a 1f 25 72 " +
+ "96 c7 39 39 10 4e ce 80 31 32 15 26 5a f0 6b c7 ea f4 42 ab ff 4f 0b 48 fc fc 6f 43 f4 df 46 30 c7 " +
+ "12 b5 e7 ef db 75 4a 86 e4 0c f2 02 16 6e b6 9e ea a6 ad 3a 2d f8 4a c4 36 48 1f 37 82 76 5f b8 40 " +
+ "ce 73 66 0a 06 62 6c 1b 3f da 7b 18 ef 7b a3 ce 17 b6 bf 60 4f 95 41 d3 c6 c6 54 b7 ae 88 b2 39 40 " +
+ "7f 65 9c 78 f4 19 02 5d 78 57 27 ed 01 7b 6a dd 21 95 2d 7e 12 00 73 73 e3 21 db c3 18 24 ba f8 4a " +
+ "c4 55 41 7e 2d 82 76 5f b8 40 ce 73 f1 f1 f1 f1 6c 1b 3f da 7b 18 ef 7b a3 ce 17 b6 f1 f1 f1 f1 41 " +
+ "d3 c6 c6 54 b7 ae 88 b2 39 40 7f f1 f1 f1 f1 19 02 5d 78 57 27 ed 01 7b 6a dd 21 f1 f1 f1 f1 00 00 " +
+ "01 e3 21 db c3 18 24 ba f8 4c c6 81 bf 81 ea 39 37 82 76 5f b8 40 d2 30 30 60 35 99 b7 6f 64 0b 8f " +
+ "7c 11 99 12 bb 04 66 e7 ee f3 38 cd 9d e5 67 d2 b6 df ba 81 72 8d b2 e9 8f 29 38 25 bb 00 a9 a6 ac " +
+ "93 66 83 fc 82 c8 bc 38 7a df 3a 4a 5f e1 cc ca dd 1a 74 59 f8 4c c6 6b 81 aa 39 81 f7 82 76 5f b8 " +
+ "40 e0 2b 18 fb a6 b8 87 fb 92 58 46 9c 3a f8 e4 45 cc 9a e2 b5 38 6c ac 5f 60 c4 17 0f 82 20 86 22 " +
+ "4e 38 76 55 5c 74 5a 7e c8 ac 18 1c 7f 97 01 77 6d 94 a7 79 60 4e a1 26 51 de 5f 4a 74 8d 29 e1 f8 " +
+ "4c c6 40 81 e7 0a 81 d0 82 76 5f b8 40 e3 11 15 a7 6f a7 fb 2e fd 3c fa f4 6a d0 0b 05 fc 34 98 e1 " +
+ "ba f1 78 5d ff e6 ca 69 91 3d 25 65 31 d1 80 56 42 35 fd 3d 3c 10 40 9c d1 1f c2 59 cf 7c fd a9 b6 " +
+ "bb 25 33 40 41 2d 82 87 8f 3b d3 f8 4b c5 41 5e 31 81 97 82 76 5f b8 40 e5 e8 d8 c2 d7 62 d2 1c a1 " +
+ "e9 bc ee 8a dc 53 60 0f 2d 89 40 97 54 26 66 d6 b5 f4 1b 23 58 4b 07 f6 09 01 ab 40 9d df 91 e0 cd " +
+ "25 62 da ff f2 cb 0f 22 1e b9 f1 15 6f 78 1a 5d 99 31 a0 2a 2e 07 f8 4a c4 55 41 7e 2d 82 76 5f b8 " +
+ "40 ea 99 2c 13 68 7c 20 e7 90 a9 ff a6 df 8b 1a 16 86 88 e2 a8 87 36 5d 7a 50 21 86 fa 0d 62 20 e8 " +
+ "3e 11 3a 1f e7 7d c0 68 9d 55 ba 2e 8a 83 aa 8e 20 42 18 f4 d8 e7 32 82 5b d7 80 cf 94 ed 5c c3 f8 " +
+ "4b c5 56 7c 52 81 fe 82 76 5f b8 40 f6 15 5f 1a 60 14 3b 7d 9d 5d 1a 44 0d 7d 52 fe 68 09 f6 9e 0c " +
+ "6f 1e 00 24 45 7e 0d 71 dd 88 ad e3 b1 3a aa 94 0c 89 ac 06 10 95 2b 48 bd 83 2c 42 e3 43 a1 3e 61 " +
+ "ff db 06 01 0c ff c3 45 e0 53 f8 4c c6 63 81 e7 58 81 af 82 76 5f b8 40 fa 56 85 61 b7 d5 28 8d f7 " +
+ "a5 06 c9 bc 1c 95 12 ab 39 6e 68 c4 6f 0e 62 c2 1d c1 aa 58 4b 84 4a 8a 7e 94 4f 69 71 30 36 65 fd " +
+ "37 b1 38 d9 a5 f6 37 e6 72 ed b9 89 69 66 4c 4e 7f d1 c4 12 6d ef";
+ byte[] payload = Hex.decode(peers);
+
+ RLPList rlpList = RLP.decode2(payload);
+
+ RLPList.recursivePrint(rlpList);
+ // TODO: add some asserts in place of just printing the rlpList
+ }
+
+ @Test /* very very very long blocks msg */
+ public void test14() {
+
+ String blocksMsg = "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";
+ byte[] payload = Hex.decode(blocksMsg);
+
+ RLPList rlpList = RLP.decode2(payload);
+
+ RLPList.recursivePrint(rlpList);
+ // TODO: add some asserts in place of just printing the rlpList
+ }
+
+ @Test /* hello msg */
+ public void test15() {
+
+ String helloMsg = "f8 91 80 0b 80 b8 46 45 74 68 65 72 65 75 6d 28 2b 2b 29 2f 5a 65 72 6f 47 6f 78 2e 70 72 " +
+ "69 63 6b 6c 79 5f 6d 6f 72 73 65 2f 76 30 2e 34 2e 32 2f 52 65 6c 65 61 73 65 2d 57 69 6e 33 32 2f " +
+ "57 69 6e 64 6f 77 73 2f 56 53 32 30 31 33 07 82 76 5f b8 40 ea 99 2c 13 68 7c 20 e7 90 a9 ff a6 df " +
+ "8b 1a 16 86 88 e2 a8 87 36 5d 7a 50 21 86 fa 0d 62 20 e8 3e 11 3a 1f e7 7d c0 68 9d 55 ba 2e 8a 83 " +
+ "aa 8e 20 42 18 f4 d8 e7 32 82 5b d7 80 cf 94 ed 5c c3";
+ byte[] payload = Hex.decode(helloMsg);
+
+ RLPList rlpList = RLP.decode2(payload);
+
+ RLPList.recursivePrint(rlpList);
+ // TODO: add some asserts in place of just printing the rlpList
+ }
+
+ /************************************
+ * Test data from: https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-RLP
+ *
+ * Using assertEquals(String, String) instead of assertArrayEquals to see the actual content when the test fails.
+ */
+ @Test(expected = RuntimeException.class)
+ public void testEncodeNull() {
+ RLP.encode(null);
+ }
+
+ @Test
+ public void testEncodeEmptyString() {
+ String test = "";
+ String expected = "80";
+ byte[] encoderesult = RLP.encode(test);
+ assertEquals(expected, Hex.toHexString(encoderesult));
+
+ String decodeResult = (String) RLP.decode(encoderesult, 0).getDecoded();
+ assertEquals(test, decodeResult);
+ }
+
+ @Test
+ public void testEncodeShortString() {
+ String test = "dog";
+ String expected = "83646f67";
+ byte[] encoderesult = RLP.encode(test);
+ assertEquals(expected, Hex.toHexString(encoderesult));
+
+ byte[] decodeResult = (byte[]) RLP.decode(encoderesult, 0).getDecoded();
+ assertEquals(test, bytesToAscii(decodeResult));
+ }
+
+ @Test
+ public void testEncodeSingleCharacter() {
+ String test = "d";
+ String expected = "64";
+ byte[] encoderesult = RLP.encode(test);
+ assertEquals(expected, Hex.toHexString(encoderesult));
+
+ byte[] decodeResult = (byte[]) RLP.decode(encoderesult, 0).getDecoded();
+ assertEquals(test, bytesToAscii(decodeResult));
+ }
+
+ @Test
+ public void testEncodeLongString() {
+ String test = "Lorem ipsum dolor sit amet, consectetur adipisicing elit"; // length = 56
+ String expected = "b8384c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e7365637465747572206164697069736963696e6720656c6974";
+ byte[] encoderesult = RLP.encode(test);
+ assertEquals(expected, Hex.toHexString(encoderesult));
+
+ byte[] decodeResult = (byte[]) RLP.decode(encoderesult, 0).getDecoded();
+ assertEquals(test, bytesToAscii(decodeResult));
+ }
+
+ @Test
+ public void testEncodeZero() {
+ Integer test = 0;
+ String expected = "80";
+ byte[] encoderesult = RLP.encode(test);
+ assertEquals(expected, Hex.toHexString(encoderesult));
+
+ String decodeResult = (String) RLP.decode(encoderesult, 0).getDecoded();
+ assertEquals("", decodeResult);
+ }
+
+ @Test
+ public void testEncodeSmallInteger() {
+ Integer test = 15;
+ String expected = "0f";
+ byte[] encoderesult = RLP.encode(test);
+ assertEquals(expected, Hex.toHexString(encoderesult));
+
+ byte[] decodeResult = (byte[]) RLP.decode(encoderesult, 0).getDecoded();
+ int result = byteArrayToInt(decodeResult);
+ assertEquals(test, Integer.valueOf(result));
+ }
+
+ @Test
+ public void testEncodeMediumInteger() {
+ Integer test = 1000;
+ String expected = "8203e8";
+ byte[] encoderesult = RLP.encode(test);
+ assertEquals(expected, Hex.toHexString(encoderesult));
+
+ byte[] decodeResult = (byte[]) RLP.decode(encoderesult, 0).getDecoded();
+ int result = byteArrayToInt(decodeResult);
+ assertEquals(test, Integer.valueOf(result));
+
+ test = 1024;
+ expected = "820400";
+ encoderesult = RLP.encode(test);
+ assertEquals(expected, Hex.toHexString(encoderesult));
+
+ decodeResult = (byte[]) RLP.decode(encoderesult, 0).getDecoded();
+ result = byteArrayToInt(decodeResult);
+ assertEquals(test, Integer.valueOf(result));
+ }
+
+ @Test
+ public void testEncodeBigInteger() {
+ BigInteger test = new BigInteger("100102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", 16);
+ String expected = "a0100102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f";
+ byte[] encoderesult = RLP.encode(test);
+ assertEquals(expected, Hex.toHexString(encoderesult));
+
+ byte[] decodeResult = (byte[]) RLP.decode(encoderesult, 0).getDecoded();
+ assertEquals(test, new BigInteger(1, decodeResult));
+ }
+
+ @Test
+ public void TestEncodeEmptyList() {
+ Object[] test = new Object[0];
+ String expected = "c0";
+ byte[] encoderesult = RLP.encode(test);
+ assertEquals(expected, Hex.toHexString(encoderesult));
+
+ Object[] decodeResult = (Object[]) RLP.decode(encoderesult, 0).getDecoded();
+ assertTrue(decodeResult.length == 0);
+ }
+
+ @Test
+ public void testEncodeShortStringList() {
+ String[] test = new String[]{"cat", "dog"};
+ String expected = "c88363617483646f67";
+ byte[] encoderesult = RLP.encode(test);
+ assertEquals(expected, Hex.toHexString(encoderesult));
+
+ Object[] decodeResult = (Object[]) RLP.decode(encoderesult, 0).getDecoded();
+ assertEquals("cat", bytesToAscii((byte[]) decodeResult[0]));
+ assertEquals("dog", bytesToAscii((byte[]) decodeResult[1]));
+
+ test = new String[]{"dog", "god", "cat"};
+ expected = "cc83646f6783676f6483636174";
+ encoderesult = RLP.encode(test);
+ assertEquals(expected, Hex.toHexString(encoderesult));
+
+ decodeResult = (Object[]) RLP.decode(encoderesult, 0).getDecoded();
+ assertEquals("dog", bytesToAscii((byte[]) decodeResult[0]));
+ assertEquals("god", bytesToAscii((byte[]) decodeResult[1]));
+ assertEquals("cat", bytesToAscii((byte[]) decodeResult[2]));
+ }
+
+ @Test
+ public void testEncodeLongStringList() {
+ String element1 = "cat";
+ String element2 = "Lorem ipsum dolor sit amet, consectetur adipisicing elit";
+ String[] test = new String[]{element1, element2};
+ String expected = "f83e83636174b8384c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e7365637465747572206164697069736963696e6720656c6974";
+ byte[] encoderesult = RLP.encode(test);
+ assertEquals(expected, Hex.toHexString(encoderesult));
+
+ Object[] decodeResult = (Object[]) RLP.decode(encoderesult, 0).getDecoded();
+ assertEquals(element1, bytesToAscii((byte[]) decodeResult[0]));
+ assertEquals(element2, bytesToAscii((byte[]) decodeResult[1]));
+ }
+
+ //multilist:
+ //in: [ 1, ["cat"], "dog", [ 2 ] ],
+ //out: "cc01c48363617483646f67c102"
+ //in: [ [ ["cat"], ["dog"] ], [ [1] [2] ], [] ],
+ //out: "cdc88363617483646f67c20102c0"
+ @Test
+ public void testEncodeMultiList() {
+ Object[] test = new Object[]{1, new Object[]{"cat"}, "dog", new Object[]{2}};
+ String expected = "cc01c48363617483646f67c102";
+ byte[] encoderesult = RLP.encode(test);
+ assertEquals(expected, Hex.toHexString(encoderesult));
+
+ Object[] decodeResult = (Object[]) RLP.decode(encoderesult, 0).getDecoded();
+ assertEquals(1, byteArrayToInt((byte[]) decodeResult[0]));
+ assertEquals("cat", bytesToAscii(((byte[]) ((Object[]) decodeResult[1])[0])));
+ assertEquals("dog", bytesToAscii((byte[]) decodeResult[2]));
+ assertEquals(2, byteArrayToInt(((byte[]) ((Object[]) decodeResult[3])[0])));
+
+ test = new Object[]{new Object[]{"cat", "dog"}, new Object[]{1, 2}, new Object[]{}};
+ expected = "cdc88363617483646f67c20102c0";
+ encoderesult = RLP.encode(test);
+ assertEquals(expected, Hex.toHexString(encoderesult));
+
+ decodeResult = (Object[]) RLP.decode(encoderesult, 0).getDecoded();
+ assertEquals("cat", bytesToAscii(((byte[]) ((Object[]) decodeResult[0])[0])));
+ assertEquals("dog", bytesToAscii(((byte[]) ((Object[]) decodeResult[0])[1])));
+ assertEquals(1, byteArrayToInt(((byte[]) ((Object[]) decodeResult[1])[0])));
+ assertEquals(2, byteArrayToInt(((byte[]) ((Object[]) decodeResult[1])[1])));
+ assertTrue((((Object[]) decodeResult[2]).length == 0));
+ }
+
+ @Test
+ public void testEncodeEmptyListOfList() {
+ // list = [ [ [], [] ], [] ],
+ Object[] test = new Object[]{new Object[]{new Object[]{}, new Object[]{}}, new Object[]{}};
+ String expected = "c4c2c0c0c0";
+ byte[] encoderesult = RLP.encode(test);
+ assertEquals(expected, Hex.toHexString(encoderesult));
+
+ Object[] decodeResult = (Object[]) RLP.decode(encoderesult, 0).getDecoded();
+ assertTrue(decodeResult.length == 2);
+ assertTrue(((Object[]) (decodeResult[0])).length == 2);
+ assertTrue(((Object[]) (decodeResult[1])).length == 0);
+ assertTrue(((Object[]) ((Object[]) (decodeResult[0]))[0]).length == 0);
+ assertTrue(((Object[]) ((Object[]) (decodeResult[0]))[1]).length == 0);
+ }
+
+ //The set theoretical representation of two
+ @Test
+ public void testEncodeRepOfTwoListOfList() {
+ //list: [ [], [[]], [ [], [[]] ] ]
+ Object[] test = new Object[]{new Object[]{}, new Object[]{new Object[]{}}, new Object[]{new Object[]{}, new Object[]{new Object[]{}}}};
+ String expected = "c7c0c1c0c3c0c1c0";
+ byte[] encoderesult = RLP.encode(test);
+ assertEquals(expected, Hex.toHexString(encoderesult));
+
+ Object[] decodeResult = (Object[]) RLP.decode(encoderesult, 0).getDecoded();
+ assertTrue(decodeResult.length == 3);
+ assertTrue(((Object[]) (decodeResult[0])).length == 0);
+ assertTrue(((Object[]) (decodeResult[1])).length == 1);
+ assertTrue(((Object[]) (decodeResult[2])).length == 2);
+ assertTrue(((Object[]) ((Object[]) (decodeResult[1]))[0]).length == 0);
+ assertTrue(((Object[]) ((Object[]) (decodeResult[2]))[0]).length == 0);
+ assertTrue(((Object[]) ((Object[]) (decodeResult[2]))[1]).length == 1);
+ assertTrue(((Object[]) ((Object[]) ((Object[]) (decodeResult[2]))[1])[0]).length == 0);
+ }
+
+ @Test
+ public void testRlpEncode() {
+
+ assertEquals(result01, Hex.toHexString(RLP.encode(test01)));
+ assertEquals(result02, Hex.toHexString(RLP.encode(test02)));
+ assertEquals(result03, Hex.toHexString(RLP.encode(test03)));
+ assertEquals(result04, Hex.toHexString(RLP.encode(test04)));
+ assertEquals(result05, Hex.toHexString(RLP.encode(test05)));
+ assertEquals(result06, Hex.toHexString(RLP.encode(test06)));
+ assertEquals(result07, Hex.toHexString(RLP.encode(test07)));
+ assertEquals(result08, Hex.toHexString(RLP.encode(test08)));
+ assertEquals(result09, Hex.toHexString(RLP.encode(test09)));
+ assertEquals(result10, Hex.toHexString(RLP.encode(test10)));
+ assertEquals(result11, Hex.toHexString(RLP.encode(test11)));
+ assertEquals(result12, Hex.toHexString(RLP.encode(test12)));
+ assertEquals(result13, Hex.toHexString(RLP.encode(test13)));
+ assertEquals(result14, Hex.toHexString(RLP.encode(test14)));
+ assertEquals(result15, Hex.toHexString(RLP.encode(test15)));
+ assertEquals(result16, Hex.toHexString(RLP.encode(test16)));
+ }
+
+ @Test
+ public void testRlpDecode() {
+ int pos = 0;
+ String emptyString;
+ byte[] decodedData;
+ Object[] decodedList;
+
+ emptyString = (String) RLP.decode(Hex.decode(result01), pos).getDecoded();
+ assertEquals("", emptyString);
+
+ emptyString = (String) RLP.decode(Hex.decode(result02), pos).getDecoded();
+ assertEquals(test02, emptyString);
+
+ decodedData = (byte[]) RLP.decode(Hex.decode(result03), pos).getDecoded();
+ assertEquals(test03, bytesToAscii(decodedData));
+
+ decodedData = (byte[]) RLP.decode(Hex.decode(result04), pos).getDecoded();
+ assertEquals(test04, bytesToAscii(decodedData));
+
+ decodedData = (byte[]) RLP.decode(Hex.decode(result05), pos).getDecoded();
+ assertEquals(test05, bytesToAscii(decodedData));
+
+ decodedList = (Object[]) RLP.decode(Hex.decode(result06), pos).getDecoded();
+ assertEquals(test06[0], bytesToAscii((byte[]) decodedList[0]));
+ assertEquals(test06[1], bytesToAscii((byte[]) decodedList[1]));
+
+ decodedList = (Object[]) RLP.decode(Hex.decode(result07), pos).getDecoded();
+ assertEquals(test07[0], bytesToAscii((byte[]) decodedList[0]));
+ assertEquals(test07[1], bytesToAscii((byte[]) decodedList[1]));
+ assertEquals(test07[2], bytesToAscii((byte[]) decodedList[2]));
+
+ // 1
+ decodedData = (byte[]) RLP.decode(Hex.decode(result08), pos).getDecoded();
+ assertEquals(test08, byteArrayToInt(decodedData));
+
+ // 10
+ decodedData = (byte[]) RLP.decode(Hex.decode(result09), pos).getDecoded();
+ assertEquals(test09, byteArrayToInt(decodedData));
+
+ // 100
+ decodedData = (byte[]) RLP.decode(Hex.decode(result10), pos).getDecoded();
+ assertEquals(test10, byteArrayToInt(decodedData));
+
+ // 1000
+ decodedData = (byte[]) RLP.decode(Hex.decode(result11), pos).getDecoded();
+ assertEquals(test11, byteArrayToInt(decodedData));
+
+ decodedData = (byte[]) RLP.decode(Hex.decode(result12), pos).getDecoded();
+ assertTrue(test12.compareTo(new BigInteger(1, decodedData)) == 0);
+
+ decodedData = (byte[]) RLP.decode(Hex.decode(result13), pos).getDecoded();
+ assertTrue(test13.compareTo(new BigInteger(1, decodedData)) == 0);
+
+ // Need to test with different expected value, because decoding doesn't recognize types
+ Object testObject1 = RLP.decode(Hex.decode(result14), pos).getDecoded();
+ assertTrue(DeepEquals.deepEquals(expected14, testObject1));
+
+ Object testObject2 = RLP.decode(Hex.decode(result15), pos).getDecoded();
+ assertTrue(DeepEquals.deepEquals(test15, testObject2));
+
+ // Need to test with different expected value, because decoding doesn't recognize types
+ Object testObject3 = RLP.decode(Hex.decode(result16), pos).getDecoded();
+ assertTrue(DeepEquals.deepEquals(expected16, testObject3));
+ }
+
+ @Test
+ public void testEncodeLength() {
+
+ // length < 56
+ int length = 1;
+ int offset = 128;
+ byte[] encodedLength = RLP.encodeLength(length, offset);
+ String expected = "81";
+ assertEquals(expected, Hex.toHexString(encodedLength));
+
+ // 56 > length < 2^64
+ length = 56;
+ offset = 192;
+ encodedLength = RLP.encodeLength(length, offset);
+ expected = "f838";
+ assertEquals(expected, Hex.toHexString(encodedLength));
+ }
+
+ @Test
+ @Ignore
+ public void unsupportedLength() {
+
+ int length = 56;
+ int offset = 192;
+ byte[] encodedLength;
+
+ // length > 2^64
+ // TODO: Fix this test - when casting double to int, information gets lost since 'int' is max (2^31)-1
+ double maxLength = Math.pow(256, 8);
+
+ try {
+ encodedLength = RLP.encodeLength((int) maxLength, offset);
+ System.out.println("length: " + length + ", offset: " + offset + ", encoded: " + Arrays.toString(encodedLength));
+
+ fail("Expecting RuntimeException: 'Input too long'");
+ } catch (RuntimeException e) {
+ // Success!
+ }
+
+ }
+
+ // Code from: http://stackoverflow.com/a/4785776/459349
+ private String bytesToAscii(byte[] b) {
+ String hex = Hex.toHexString(b);
+ StringBuilder output = new StringBuilder();
+ for (int i = 0; i < hex.length(); i += 2) {
+ String str = hex.substring(i, i + 2);
+ output.append((char) Integer.parseInt(str, 16));
+ }
+ return output.toString();
+ }
+
+ @Test
+ public void performanceDecode() throws IOException {
+ boolean performanceEnabled = false;
+
+ if (performanceEnabled) {
+ String blockRaw = "f8cbf8c7a00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a02f4399b08efe68945c1cf90ffe85bbe3ce978959da753f9e649f034015b8817da00000000000000000000000000000000000000000000000000000000000000000834000008080830f4240808080a004994f67dc55b09e814ab7ffc8df3686b4afb2bb53e60eae97ef043fe03fb829c0c0";
+ byte[] payload = Hex.decode(blockRaw);
+
+ final int ITERATIONS = 10000000;
+ RLPList list = null;
+ DecodeResult result = null;
+ System.out.println("Starting " + ITERATIONS + " decoding iterations...");
+
+ long start1 = System.currentTimeMillis();
+ for (int i = 0; i < ITERATIONS; i++) {
+ result = RLP.decode(payload, 0);
+ }
+ long end1 = System.currentTimeMillis();
+
+ long start2 = System.currentTimeMillis();
+ for (int i = 0; i < ITERATIONS; i++) {
+ list = RLP.decode2(payload);
+ }
+ long end2 = System.currentTimeMillis();
+
+ System.out.println("Result RLP.decode()\t: " + (end1 - start1) + "ms and\t " + determineSize(result) + " bytes for each resulting object list");
+ System.out.println("Result RLP.decode2()\t: " + (end2 - start2) + "ms and\t " + determineSize(list) + " bytes for each resulting object list");
+ } else {
+ System.out.println("Performance test for RLP.decode() disabled");
+ }
+ }
+
+ private int determineSize(Serializable ser) throws IOException {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ ObjectOutputStream oos = new ObjectOutputStream(baos);
+ oos.writeObject(ser);
+ oos.close();
+ return baos.size();
+ }
+
+
+ @Test // found this with a bug - nice to keep
+ public void encodeEdgeShortList() {
+
+ String expectedOutput = "f7c0c0b4600160003556601359506301000000600035040f6018590060005660805460016080530160005760003560805760203560003557";
+
+ byte[] rlpKeysList = Hex.decode("c0");
+ byte[] rlpValuesList = Hex.decode("c0");
+ byte[] rlpCode = Hex.decode("b4600160003556601359506301000000600035040f6018590060005660805460016080530160005760003560805760203560003557");
+ byte[] output = RLP.encodeList(rlpKeysList, rlpValuesList, rlpCode);
+
+ assertEquals(expectedOutput, Hex.toHexString(output));
+ }
+
+
+ @Test
+ public void encodeBigIntegerEdge_1() {
+
+ BigInteger integer = new BigInteger("80", 10);
+ byte[] encodedData = RLP.encodeBigInteger(integer);
+ System.out.println(Hex.toHexString(encodedData));
+ }
+
+
+}
\ No newline at end of file
diff --git a/ethereumj-core/src/test/java/org/ethereum/util/RlpTestData.java b/ethereumj-core/src/test/java/org/ethereum/util/RlpTestData.java
new file mode 100644
index 00000000..3e02a8f6
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/util/RlpTestData.java
@@ -0,0 +1,59 @@
+package org.ethereum.util;
+
+import java.math.BigInteger;
+
+public class RlpTestData {
+
+ /***********************************
+ * https://github.com/ethereum/tests/blob/master/rlptest.txt
+ */
+ public static int test01 = 0;
+ public static String result01 = "80";
+
+ public static String test02 = "";
+ public static String result02 = "80";
+
+ public static String test03 = "d";
+ public static String result03 = "64";
+
+ public static String test04 = "cat";
+ public static String result04 = "83636174";
+
+ public static String test05 = "dog";
+ public static String result05 = "83646f67";
+
+ public static String[] test06 = new String[]{"cat", "dog"};
+ public static String result06 = "c88363617483646f67";
+
+ public static String[] test07 = new String[]{"dog", "god", "cat"};
+ public static String result07 = "cc83646f6783676f6483636174";
+
+ public static int test08 = 1;
+ public static String result08 = "01";
+
+ public static int test09 = 10;
+ public static String result09 = "0a";
+
+ public static int test10 = 100;
+ public static String result10 = "64";
+
+ public static int test11 = 1000;
+ public static String result11 = "8203e8";
+
+ public static BigInteger test12 = new BigInteger("115792089237316195423570985008687907853269984665640564039457584007913129639935");
+ public static String result12 = "a0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
+
+ public static BigInteger test13 = new BigInteger("115792089237316195423570985008687907853269984665640564039457584007913129639936");
+ public static String result13 = "a1010000000000000000000000000000000000000000000000000000000000000000";
+
+ public static Object[] test14 = new Object[]{1, 2, new Object[]{}};
+ public static String result14 = "c30102c0";
+ public static Object[] expected14 = new Object[]{new byte[]{1}, new byte[]{2}, new Object[]{}};
+
+ public static Object[] test15 = new Object[]{new Object[]{new Object[]{}, new Object[]{}}, new Object[]{}};
+ public static String result15 = "c4c2c0c0c0";
+
+ public static Object[] test16 = new Object[]{"zw", new Object[]{4}, "wz"};
+ public static String result16 = "c8827a77c10482777a";
+ public static Object[] expected16 = new Object[]{new byte[]{122, 119}, new Object[]{new byte[]{4}}, new byte[]{119, 122}};
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/util/UtilsTest.java b/ethereumj-core/src/test/java/org/ethereum/util/UtilsTest.java
new file mode 100644
index 00000000..adf90756
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/util/UtilsTest.java
@@ -0,0 +1,90 @@
+package org.ethereum.util;
+
+import org.junit.Test;
+
+import org.spongycastle.util.Arrays;
+import org.spongycastle.util.encoders.Hex;
+
+import java.math.BigInteger;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author Roman Mandeleil
+ * @since 17.05.14
+ */
+public class UtilsTest {
+
+ @Test
+ public void testGetValueShortString1() {
+
+ String expected = "123·(10^24)";
+ String result = Utils.getValueShortString(new BigInteger("123456789123445654363653463"));
+
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void testGetValueShortString2() {
+
+ String expected = "123·(10^3)";
+ String result = Utils.getValueShortString(new BigInteger("123456"));
+
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void testGetValueShortString3() {
+
+ String expected = "1·(10^3)";
+ String result = Utils.getValueShortString(new BigInteger("1234"));
+
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void testGetValueShortString4() {
+
+ String expected = "123·(10^0)";
+ String result = Utils.getValueShortString(new BigInteger("123"));
+
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void testGetValueShortString5() {
+
+ byte[] decimal = Hex.decode("3913517ebd3c0c65000000");
+ String expected = "69·(10^24)";
+ String result = Utils.getValueShortString(new BigInteger(decimal));
+
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void testAddressStringToBytes() {
+ // valid address
+ String HexStr = "6c386a4b26f73c802f34673f7248bb118f97424a";
+ byte[] expected = Hex.decode(HexStr);
+ byte[] result = Utils.addressStringToBytes(HexStr);
+ assertEquals(Arrays.areEqual(expected, result), true);
+
+ // invalid address, we removed the last char so it cannot decode
+ HexStr = "6c386a4b26f73c802f34673f7248bb118f97424";
+ expected = null;
+ result = Utils.addressStringToBytes(HexStr);
+ assertEquals(expected, result);
+
+ // invalid address, longer than 20 bytes
+ HexStr = new String(Hex.encode("I am longer than 20 bytes, i promise".getBytes()));
+ expected = null;
+ result = Utils.addressStringToBytes(HexStr);
+ assertEquals(expected, result);
+
+ // invalid address, shorter than 20 bytes
+ HexStr = new String(Hex.encode("I am short".getBytes()));
+ expected = null;
+ result = Utils.addressStringToBytes(HexStr);
+ assertEquals(expected, result);
+ }
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/util/ValueTest.java b/ethereumj-core/src/test/java/org/ethereum/util/ValueTest.java
new file mode 100644
index 00000000..1547c4ba
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/util/ValueTest.java
@@ -0,0 +1,61 @@
+package org.ethereum.util;
+
+import org.junit.Test;
+
+import org.spongycastle.util.encoders.Hex;
+
+import java.math.BigInteger;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.*;
+
+public class ValueTest {
+
+ @Test
+ public void testCmp() {
+ Value val1 = new Value("hello");
+ Value val2 = new Value("world");
+
+ assertFalse("Expected values not to be equal", val1.cmp(val2));
+
+ Value val3 = new Value("hello");
+ Value val4 = new Value("hello");
+
+ assertTrue("Expected values to be equal", val3.cmp(val4));
+ }
+
+ @Test
+ public void testTypes() {
+ Value str = new Value("str");
+ assertEquals(str.asString(), "str");
+
+ Value num = new Value(1);
+ assertEquals(num.asInt(), 1);
+
+ Value inter = new Value(new Object[]{1});
+ Object[] interExp = new Object[]{1};
+ assertTrue(new Value(inter.asObj()).cmp(new Value(interExp)));
+
+ Value byt = new Value(new byte[]{1, 2, 3, 4});
+ byte[] bytExp = new byte[]{1, 2, 3, 4};
+ assertTrue(Arrays.equals(byt.asBytes(), bytExp));
+
+ Value bigInt = new Value(BigInteger.valueOf(10));
+ BigInteger bigExp = BigInteger.valueOf(10);
+ assertEquals(bigInt.asBigInt(), bigExp);
+ }
+
+
+ @Test
+ public void longListRLPBug_1() {
+
+ String testRlp = "f7808080d387206f72726563748a626574656c676575736580d387207870726573738a70726564696361626c658080808080808080808080";
+
+ Value val = Value.fromRlpEncoded(Hex.decode(testRlp));
+
+ assertEquals(testRlp, Hex.toHexString(val.encode()));
+ }
+
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/vm/DataWordTest.java b/ethereumj-core/src/test/java/org/ethereum/vm/DataWordTest.java
new file mode 100644
index 00000000..f5292eeb
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/vm/DataWordTest.java
@@ -0,0 +1,322 @@
+package org.ethereum.vm;
+
+import org.junit.Test;
+
+import org.spongycastle.util.encoders.Hex;
+
+import java.math.BigInteger;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class DataWordTest {
+
+ @Test
+ public void testAddPerformance() {
+ boolean enabled = false;
+
+ if (enabled) {
+ byte[] one = new byte[]{0x01, 0x31, 0x54, 0x41, 0x01, 0x31, 0x54,
+ 0x41, 0x01, 0x31, 0x54, 0x41, 0x01, 0x31, 0x54, 0x41, 0x01,
+ 0x31, 0x54, 0x41, 0x01, 0x31, 0x54, 0x41, 0x01, 0x31, 0x54,
+ 0x41, 0x01, 0x31, 0x54, 0x41}; // Random value
+
+ int ITERATIONS = 10000000;
+
+ long now1 = System.currentTimeMillis();
+ for (int i = 0; i < ITERATIONS; i++) {
+ DataWord x = new DataWord(one);
+ x.add(x);
+ }
+ System.out.println("Add1: " + (System.currentTimeMillis() - now1) + "ms");
+
+ long now2 = System.currentTimeMillis();
+ for (int i = 0; i < ITERATIONS; i++) {
+ DataWord x = new DataWord(one);
+ x.add2(x);
+ }
+ System.out.println("Add2: " + (System.currentTimeMillis() - now2) + "ms");
+ } else {
+ System.out.println("ADD performance test is disabled.");
+ }
+ }
+
+ @Test
+ public void testAdd2() {
+ byte[] two = new byte[32];
+ two[31] = (byte) 0xff; // 0x000000000000000000000000000000000000000000000000000000000000ff
+
+ DataWord x = new DataWord(two);
+ x.add(new DataWord(two));
+ System.out.println(Hex.toHexString(x.getData()));
+
+ DataWord y = new DataWord(two);
+ y.add2(new DataWord(two));
+ System.out.println(Hex.toHexString(y.getData()));
+ }
+
+ @Test
+ public void testAdd3() {
+ byte[] three = new byte[32];
+ for (int i = 0; i < three.length; i++) {
+ three[i] = (byte) 0xff;
+ }
+
+ DataWord x = new DataWord(three);
+ x.add(new DataWord(three));
+ assertEquals(32, x.getData().length);
+ System.out.println(Hex.toHexString(x.getData()));
+
+ // FAIL
+// DataWord y = new DataWord(three);
+// y.add2(new DataWord(three));
+// System.out.println(Hex.toHexString(y.getData()));
+ }
+
+ @Test
+ public void testMod() {
+ String expected = "000000000000000000000000000000000000000000000000000000000000001a";
+
+ byte[] one = new byte[32];
+ one[31] = 0x1e; // 0x000000000000000000000000000000000000000000000000000000000000001e
+
+ byte[] two = new byte[32];
+ for (int i = 0; i < two.length; i++) {
+ two[i] = (byte) 0xff;
+ }
+ two[31] = 0x56; // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff56
+
+ DataWord x = new DataWord(one);// System.out.println(x.value());
+ DataWord y = new DataWord(two);// System.out.println(y.value());
+ y.mod(x);
+ assertEquals(32, y.getData().length);
+ assertEquals(expected, Hex.toHexString(y.getData()));
+ }
+
+ @Test
+ public void testMul() {
+ byte[] one = new byte[32];
+ one[31] = 0x1; // 0x0000000000000000000000000000000000000000000000000000000000000001
+
+ byte[] two = new byte[32];
+ two[11] = 0x1; // 0x0000000000000000000000010000000000000000000000000000000000000000
+
+ DataWord x = new DataWord(one);// System.out.println(x.value());
+ DataWord y = new DataWord(two);// System.out.println(y.value());
+ x.mul(y);
+ assertEquals(32, y.getData().length);
+ assertEquals("0000000000000000000000010000000000000000000000000000000000000000", Hex.toHexString(y.getData()));
+ }
+
+ @Test
+ public void testMulOverflow() {
+
+ byte[] one = new byte[32];
+ one[30] = 0x1; // 0x0000000000000000000000000000000000000000000000000000000000000100
+
+ byte[] two = new byte[32];
+ two[0] = 0x1; // 0x1000000000000000000000000000000000000000000000000000000000000000
+
+ DataWord x = new DataWord(one);// System.out.println(x.value());
+ DataWord y = new DataWord(two);// System.out.println(y.value());
+ x.mul(y);
+ assertEquals(32, y.getData().length);
+ assertEquals("0100000000000000000000000000000000000000000000000000000000000000", Hex.toHexString(y.getData()));
+ }
+
+ @Test
+ public void testDiv() {
+ byte[] one = new byte[32];
+ one[30] = 0x01;
+ one[31] = 0x2c; // 0x000000000000000000000000000000000000000000000000000000000000012c
+
+ byte[] two = new byte[32];
+ two[31] = 0x0f; // 0x000000000000000000000000000000000000000000000000000000000000000f
+
+ DataWord x = new DataWord(one);
+ DataWord y = new DataWord(two);
+ x.div(y);
+
+ assertEquals(32, x.getData().length);
+ assertEquals("0000000000000000000000000000000000000000000000000000000000000014", Hex.toHexString(x.getData()));
+ }
+
+ @Test
+ public void testDivZero() {
+ byte[] one = new byte[32];
+ one[30] = 0x05; // 0x0000000000000000000000000000000000000000000000000000000000000500
+
+ byte[] two = new byte[32];
+
+ DataWord x = new DataWord(one);
+ DataWord y = new DataWord(two);
+ x.div(y);
+
+ assertEquals(32, x.getData().length);
+ assertTrue(x.isZero());
+ }
+
+ @Test
+ public void testSDivNegative() {
+
+ // one is -300 as 256-bit signed integer:
+ byte[] one = Hex.decode("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed4");
+
+ byte[] two = new byte[32];
+ two[31] = 0x0f;
+
+ DataWord x = new DataWord(one);
+ DataWord y = new DataWord(two);
+ x.sDiv(y);
+
+ assertEquals(32, x.getData().length);
+ assertEquals("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec", x.toString());
+ }
+
+ @Test
+ public void testPow() {
+
+ BigInteger x = BigInteger.valueOf(Integer.MAX_VALUE);
+ BigInteger y = BigInteger.valueOf(1000);
+
+ BigInteger result1 = x.modPow(x, y);
+ BigInteger result2 = pow(x, y);
+ System.out.println(result1);
+ System.out.println(result2);
+ }
+
+ @Test
+ public void testSignExtend1() {
+
+ DataWord x = new DataWord(Hex.decode("f2"));
+ byte k = 0;
+ String expected = "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff2";
+
+ x.signExtend(k);
+ System.out.println(x.toString());
+ assertEquals(expected, x.toString());
+ }
+
+ @Test
+ public void testSignExtend2() {
+ DataWord x = new DataWord(Hex.decode("f2"));
+ byte k = 1;
+ String expected = "00000000000000000000000000000000000000000000000000000000000000f2";
+
+ x.signExtend(k);
+ System.out.println(x.toString());
+ assertEquals(expected, x.toString());
+ }
+
+ @Test
+ public void testSignExtend3() {
+
+ byte k = 1;
+ DataWord x = new DataWord(Hex.decode("0f00ab"));
+ String expected = "00000000000000000000000000000000000000000000000000000000000000ab";
+
+ x.signExtend(k);
+ System.out.println(x.toString());
+ assertEquals(expected, x.toString());
+ }
+
+ @Test
+ public void testSignExtend4() {
+
+ byte k = 1;
+ DataWord x = new DataWord(Hex.decode("ffff"));
+ String expected = "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
+
+ x.signExtend(k);
+ System.out.println(x.toString());
+ assertEquals(expected, x.toString());
+ }
+
+ @Test
+ public void testSignExtend5() {
+
+ byte k = 3;
+ DataWord x = new DataWord(Hex.decode("ffffffff"));
+ String expected = "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
+
+ x.signExtend(k);
+ System.out.println(x.toString());
+ assertEquals(expected, x.toString());
+ }
+
+ @Test
+ public void testSignExtend6() {
+
+ byte k = 3;
+ DataWord x = new DataWord(Hex.decode("ab02345678"));
+ String expected = "0000000000000000000000000000000000000000000000000000000002345678";
+
+ x.signExtend(k);
+ System.out.println(x.toString());
+ assertEquals(expected, x.toString());
+ }
+
+ @Test
+ public void testSignExtend7() {
+
+ byte k = 3;
+ DataWord x = new DataWord(Hex.decode("ab82345678"));
+ String expected = "ffffffffffffffffffffffffffffffffffffffffffffffffffffffff82345678";
+
+ x.signExtend(k);
+ System.out.println(x.toString());
+ assertEquals(expected, x.toString());
+ }
+
+ @Test
+ public void testSignExtend8() {
+
+ byte k = 30;
+ DataWord x = new DataWord(Hex.decode("ff34567882345678823456788234567882345678823456788234567882345678"));
+ String expected = "0034567882345678823456788234567882345678823456788234567882345678";
+
+ x.signExtend(k);
+ System.out.println(x.toString());
+ assertEquals(expected, x.toString());
+ }
+
+ @Test(expected = IndexOutOfBoundsException.class)
+ public void testSignExtendException1() {
+
+ byte k = -1;
+ DataWord x = new DataWord();
+
+ x.signExtend(k); // should throw an exception
+ }
+
+ @Test(expected = IndexOutOfBoundsException.class)
+ public void testSignExtendException2() {
+
+ byte k = 32;
+ DataWord x = new DataWord();
+
+ x.signExtend(k); // should throw an exception
+ }
+
+ public static BigInteger pow(BigInteger x, BigInteger y) {
+ if (y.compareTo(BigInteger.ZERO) < 0)
+ throw new IllegalArgumentException();
+ BigInteger z = x; // z will successively become x^2, x^4, x^8, x^16,
+ // x^32...
+ BigInteger result = BigInteger.ONE;
+ byte[] bytes = y.toByteArray();
+ for (int i = bytes.length - 1; i >= 0; i--) {
+ byte bits = bytes[i];
+ for (int j = 0; j < 8; j++) {
+ if ((bits & 1) != 0)
+ result = result.multiply(z);
+ // short cut out if there are no more bits to handle:
+ if ((bits >>= 1) == 0 && i == 0)
+ return result;
+ z = z.multiply(z);
+ }
+ }
+ return result;
+ }
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/vm/MemoryTest.java b/ethereumj-core/src/test/java/org/ethereum/vm/MemoryTest.java
new file mode 100644
index 00000000..b7cf0a07
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/vm/MemoryTest.java
@@ -0,0 +1,424 @@
+package org.ethereum.vm;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.spongycastle.util.encoders.Hex;
+
+import java.util.Arrays;
+
+import static java.lang.Math.ceil;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+public class MemoryTest {
+
+ private static final int WORD_SIZE = 32;
+ private static final int CHUNK_SIZE = 1024;
+
+ @Test
+ public void testExtend() {
+ checkMemoryExtend(0);
+ checkMemoryExtend(1);
+ checkMemoryExtend(WORD_SIZE);
+ checkMemoryExtend(WORD_SIZE * 2);
+ checkMemoryExtend(CHUNK_SIZE - 1);
+ checkMemoryExtend(CHUNK_SIZE);
+ checkMemoryExtend(CHUNK_SIZE + 1);
+ checkMemoryExtend(2000);
+ }
+
+ private static void checkMemoryExtend(int dataSize) {
+ Memory memory = new Memory();
+ memory.extend(0, dataSize);
+ assertEquals(calcSize(dataSize, CHUNK_SIZE), memory.internalSize());
+ assertEquals(calcSize(dataSize, WORD_SIZE), memory.size());
+ }
+
+ private static int calcSize(int dataSize, int chunkSize) {
+ return (int) ceil((double) dataSize / chunkSize) * chunkSize;
+ }
+
+ @Test
+ public void memorySave_1() {
+
+ Memory memoryBuffer = new Memory();
+ byte[] data = {1, 1, 1, 1};
+
+ memoryBuffer.write(0, data);
+
+ Assert.assertTrue(1 == memoryBuffer.getChunks().size());
+
+ byte[] chunk = memoryBuffer.getChunks().get(0);
+ Assert.assertTrue(chunk[0] == 1);
+ Assert.assertTrue(chunk[1] == 1);
+ Assert.assertTrue(chunk[2] == 1);
+ Assert.assertTrue(chunk[3] == 1);
+ Assert.assertTrue(chunk[4] == 0);
+
+ Assert.assertTrue(memoryBuffer.size() == 32);
+ }
+
+ @Test
+ public void memorySave_2() {
+
+ Memory memoryBuffer = new Memory();
+ byte[] data = Hex.decode("0101010101010101010101010101010101010101010101010101010101010101");
+
+ memoryBuffer.write(0, data);
+
+ Assert.assertTrue(1 == memoryBuffer.getChunks().size());
+
+ byte[] chunk = memoryBuffer.getChunks().get(0);
+ Assert.assertTrue(chunk[0] == 1);
+ Assert.assertTrue(chunk[1] == 1);
+
+ Assert.assertTrue(chunk[30] == 1);
+ Assert.assertTrue(chunk[31] == 1);
+ Assert.assertTrue(chunk[32] == 0);
+
+ Assert.assertTrue(memoryBuffer.size() == 32);
+ }
+
+ @Test
+ public void memorySave_3() {
+
+ Memory memoryBuffer = new Memory();
+ byte[] data = Hex.decode("010101010101010101010101010101010101010101010101010101010101010101");
+
+ memoryBuffer.write(0, data);
+
+ Assert.assertTrue(1 == memoryBuffer.getChunks().size());
+
+ byte[] chunk = memoryBuffer.getChunks().get(0);
+ Assert.assertTrue(chunk[0] == 1);
+ Assert.assertTrue(chunk[1] == 1);
+
+ Assert.assertTrue(chunk[30] == 1);
+ Assert.assertTrue(chunk[31] == 1);
+ Assert.assertTrue(chunk[32] == 1);
+ Assert.assertTrue(chunk[33] == 0);
+
+ Assert.assertTrue(memoryBuffer.size() == 64);
+ }
+
+ @Test
+ public void memorySave_4() {
+
+ Memory memoryBuffer = new Memory();
+ byte[] data = new byte[1024];
+ Arrays.fill(data, (byte) 1);
+
+ memoryBuffer.write(0, data);
+
+ Assert.assertTrue(1 == memoryBuffer.getChunks().size());
+
+ byte[] chunk = memoryBuffer.getChunks().get(0);
+ Assert.assertTrue(chunk[0] == 1);
+ Assert.assertTrue(chunk[1] == 1);
+
+ Assert.assertTrue(chunk[1022] == 1);
+ Assert.assertTrue(chunk[1023] == 1);
+
+ Assert.assertTrue(memoryBuffer.size() == 1024);
+ }
+
+ @Test
+ public void memorySave_5() {
+
+ Memory memoryBuffer = new Memory();
+
+ byte[] data = new byte[1025];
+ Arrays.fill(data, (byte) 1);
+
+ memoryBuffer.write(0, data);
+
+ Assert.assertTrue(2 == memoryBuffer.getChunks().size());
+
+ byte[] chunk1 = memoryBuffer.getChunks().get(0);
+ Assert.assertTrue(chunk1[0] == 1);
+ Assert.assertTrue(chunk1[1] == 1);
+
+ Assert.assertTrue(chunk1[1022] == 1);
+ Assert.assertTrue(chunk1[1023] == 1);
+
+ byte[] chunk2 = memoryBuffer.getChunks().get(1);
+ Assert.assertTrue(chunk2[0] == 1);
+ Assert.assertTrue(chunk2[1] == 0);
+
+ Assert.assertTrue(memoryBuffer.size() == 1056);
+ }
+
+ @Test
+ public void memorySave_6() {
+
+ Memory memoryBuffer = new Memory();
+
+ byte[] data1 = new byte[1024];
+ Arrays.fill(data1, (byte) 1);
+
+ byte[] data2 = new byte[1024];
+ Arrays.fill(data2, (byte) 2);
+
+ memoryBuffer.write(0, data1);
+ memoryBuffer.write(1024, data2);
+
+ Assert.assertTrue(2 == memoryBuffer.getChunks().size());
+
+ byte[] chunk1 = memoryBuffer.getChunks().get(0);
+ Assert.assertTrue(chunk1[0] == 1);
+ Assert.assertTrue(chunk1[1] == 1);
+
+ Assert.assertTrue(chunk1[1022] == 1);
+ Assert.assertTrue(chunk1[1023] == 1);
+
+ byte[] chunk2 = memoryBuffer.getChunks().get(1);
+ Assert.assertTrue(chunk2[0] == 2);
+ Assert.assertTrue(chunk2[1] == 2);
+
+ Assert.assertTrue(chunk2[1022] == 2);
+ Assert.assertTrue(chunk2[1023] == 2);
+
+ Assert.assertTrue(memoryBuffer.size() == 2048);
+ }
+
+ @Test
+ public void memorySave_7() {
+
+ Memory memoryBuffer = new Memory();
+
+ byte[] data1 = new byte[1024];
+ Arrays.fill(data1, (byte) 1);
+
+ byte[] data2 = new byte[1024];
+ Arrays.fill(data2, (byte) 2);
+
+ byte[] data3 = new byte[1];
+ Arrays.fill(data3, (byte) 3);
+
+ memoryBuffer.write(0, data1);
+ memoryBuffer.write(1024, data2);
+ memoryBuffer.write(2048, data3);
+
+ Assert.assertTrue(3 == memoryBuffer.getChunks().size());
+
+ byte[] chunk1 = memoryBuffer.getChunks().get(0);
+ Assert.assertTrue(chunk1[0] == 1);
+ Assert.assertTrue(chunk1[1] == 1);
+
+ Assert.assertTrue(chunk1[1022] == 1);
+ Assert.assertTrue(chunk1[1023] == 1);
+
+ byte[] chunk2 = memoryBuffer.getChunks().get(1);
+ Assert.assertTrue(chunk2[0] == 2);
+ Assert.assertTrue(chunk2[1] == 2);
+
+ Assert.assertTrue(chunk2[1022] == 2);
+ Assert.assertTrue(chunk2[1023] == 2);
+
+ byte[] chunk3 = memoryBuffer.getChunks().get(2);
+ Assert.assertTrue(chunk3[0] == 3);
+
+ Assert.assertTrue(memoryBuffer.size() == 2080);
+ }
+
+ @Test
+ public void memorySave_8() {
+
+ Memory memoryBuffer = new Memory();
+
+ byte[] data1 = new byte[128];
+ Arrays.fill(data1, (byte) 1);
+
+ memoryBuffer.extendAndWrite(0, 256, data1);
+
+ int ones = 0; int zeroes = 0;
+ for (int i = 0; i < memoryBuffer.size(); ++i){
+ if (memoryBuffer.readByte(i) == 1) ++ones;
+ if (memoryBuffer.readByte(i) == 0) ++zeroes;
+ }
+
+ Assert.assertTrue(ones == zeroes);
+ Assert.assertTrue(256 == memoryBuffer.size());
+ }
+
+
+
+ @Test
+ public void memoryLoad_1() {
+
+ Memory memoryBuffer = new Memory();
+ DataWord value = memoryBuffer.readWord(100);
+ Assert.assertTrue(value.intValue() == 0);
+ Assert.assertTrue(memoryBuffer.getChunks().size() == 1);
+ Assert.assertTrue(memoryBuffer.size() == 32 * 5);
+ }
+
+ @Test
+ public void memoryLoad_2() {
+
+ Memory memoryBuffer = new Memory();
+ DataWord value = memoryBuffer.readWord(2015);
+ Assert.assertTrue(value.intValue() == 0);
+ Assert.assertTrue(memoryBuffer.getChunks().size() == 2);
+ Assert.assertTrue(memoryBuffer.size() == 2048);
+ }
+
+ @Test
+ public void memoryLoad_3() {
+
+ Memory memoryBuffer = new Memory();
+ DataWord value = memoryBuffer.readWord(2016);
+ Assert.assertTrue(value.intValue() == 0);
+ Assert.assertTrue(memoryBuffer.getChunks().size() == 2);
+ Assert.assertTrue(memoryBuffer.size() == 2048);
+ }
+
+ @Test
+ public void memoryLoad_4() {
+
+ Memory memoryBuffer = new Memory();
+ DataWord value = memoryBuffer.readWord(2017);
+ Assert.assertTrue(value.intValue() == 0);
+ Assert.assertTrue(memoryBuffer.getChunks().size() == 3);
+ Assert.assertTrue(memoryBuffer.size() == 2080);
+ }
+
+ @Test
+ public void memoryLoad_5() {
+
+ Memory memoryBuffer = new Memory();
+
+ byte[] data1 = new byte[1024];
+ Arrays.fill(data1, (byte) 1);
+
+ byte[] data2 = new byte[1024];
+ Arrays.fill(data2, (byte) 2);
+
+ memoryBuffer.write(0, data1);
+ memoryBuffer.write(1024, data2);
+
+ Assert.assertTrue(memoryBuffer.getChunks().size() == 2);
+ Assert.assertTrue(memoryBuffer.size() == 2048);
+
+ DataWord val1 = memoryBuffer.readWord(0x3df);
+ DataWord val2 = memoryBuffer.readWord(0x3e0);
+ DataWord val3 = memoryBuffer.readWord(0x3e1);
+
+ assertArrayEquals(
+ Hex.decode("0101010101010101010101010101010101010101010101010101010101010101"),
+ val1.getData());
+
+ assertArrayEquals(
+ Hex.decode("0101010101010101010101010101010101010101010101010101010101010101"),
+ val2.getData());
+
+ assertArrayEquals(
+ Hex.decode("0101010101010101010101010101010101010101010101010101010101010102"),
+ val3.getData());
+ Assert.assertTrue(memoryBuffer.size() == 2048);
+ }
+
+
+ @Test
+ public void memoryChunk_1(){
+ Memory memoryBuffer = new Memory();
+
+ byte[] data1 = new byte[32];
+ Arrays.fill(data1, (byte) 1);
+
+ byte[] data2 = new byte[32];
+ Arrays.fill(data2, (byte) 2);
+
+ memoryBuffer.write(0, data1);
+ memoryBuffer.write(32, data2);
+
+ byte[] data = memoryBuffer.read(0, 64);
+
+ assertArrayEquals(
+ Hex.decode("0101010101010101010101010101010101010101010101010101010101010101" +
+ "0202020202020202020202020202020202020202020202020202020202020202"),
+ data
+ );
+
+ assertEquals(64, memoryBuffer.size());
+ }
+
+
+ @Test
+ public void memoryChunk_2(){
+ Memory memoryBuffer = new Memory();
+
+ byte[] data1 = new byte[32];
+ Arrays.fill(data1, (byte) 1);
+
+ memoryBuffer.write(0, data1);
+ Assert.assertTrue(32 == memoryBuffer.size());
+
+ byte[] data = memoryBuffer.read(0, 64);
+
+ assertArrayEquals(
+ Hex.decode("0101010101010101010101010101010101010101010101010101010101010101" +
+ "0000000000000000000000000000000000000000000000000000000000000000"),
+ data
+ );
+
+ assertEquals(64, memoryBuffer.size());
+ }
+
+ @Test
+ public void memoryChunk_3(){
+
+ Memory memoryBuffer = new Memory();
+
+ byte[] data1 = new byte[1024];
+ Arrays.fill(data1, (byte) 1);
+
+ byte[] data2 = new byte[1024];
+ Arrays.fill(data2, (byte) 2);
+
+ memoryBuffer.write(0, data1);
+ memoryBuffer.write(1024, data2);
+
+ byte[] data = memoryBuffer.read(0, 2048);
+
+ int ones = 0; int twos = 0;
+ for (int i = 0; i < data.length; ++i){
+ if (data[i] == 1) ++ones;
+ if (data[i] == 2) ++twos;
+ }
+
+ Assert.assertTrue(ones == twos);
+ Assert.assertTrue(2048 == memoryBuffer.size());
+ }
+
+ @Test
+ public void memoryChunk_4(){
+
+ Memory memoryBuffer = new Memory();
+
+ byte[] data1 = new byte[1024];
+ Arrays.fill(data1, (byte) 1);
+
+ byte[] data2 = new byte[1024];
+ Arrays.fill(data2, (byte) 2);
+
+ memoryBuffer.write(0, data1);
+ memoryBuffer.write(1024, data2);
+
+ byte[] data = memoryBuffer.read(0, 2049);
+
+ int ones = 0; int twos = 0; int zero = 0;
+ for (int i = 0; i < data.length; ++i){
+ if (data[i] == 1) ++ones;
+ if (data[i] == 2) ++twos;
+ if (data[i] == 0) ++zero;
+ }
+
+ Assert.assertTrue(zero == 1);
+ Assert.assertTrue(ones == twos);
+ Assert.assertTrue(2080 == memoryBuffer.size());
+ }
+
+
+
+}
\ No newline at end of file
diff --git a/ethereumj-core/src/test/java/org/ethereum/vm/PrecompiledContractTest.java b/ethereumj-core/src/test/java/org/ethereum/vm/PrecompiledContractTest.java
new file mode 100644
index 00000000..a7feeefe
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/vm/PrecompiledContractTest.java
@@ -0,0 +1,100 @@
+package org.ethereum.vm;
+
+import org.ethereum.util.ByteUtil;
+import org.ethereum.vm.PrecompiledContracts.PrecompiledContract;
+
+import org.junit.Test;
+
+import org.spongycastle.util.encoders.Hex;
+
+import static org.junit.Assert.*;
+
+/**
+ * @author Roman Mandeleil
+ */
+public class PrecompiledContractTest {
+
+
+ @Test
+ public void identityTest1() {
+
+ DataWord addr = new DataWord("0000000000000000000000000000000000000000000000000000000000000004");
+ PrecompiledContract contract = PrecompiledContracts.getContractForAddress(addr);
+ byte[] data = Hex.decode("112233445566");
+ byte[] expected = Hex.decode("112233445566");
+
+ byte[] result = contract.execute(data);
+
+ assertArrayEquals(expected, result);
+ }
+
+
+ @Test
+ public void sha256Test1() {
+
+ DataWord addr = new DataWord("0000000000000000000000000000000000000000000000000000000000000002");
+ PrecompiledContract contract = PrecompiledContracts.getContractForAddress(addr);
+ byte[] data = null;
+ String expected = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+
+ byte[] result = contract.execute(data);
+
+ assertEquals(expected, Hex.toHexString(result));
+ }
+
+ @Test
+ public void sha256Test2() {
+
+ DataWord addr = new DataWord("0000000000000000000000000000000000000000000000000000000000000002");
+ PrecompiledContract contract = PrecompiledContracts.getContractForAddress(addr);
+ byte[] data = ByteUtil.EMPTY_BYTE_ARRAY;
+ String expected = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+
+ byte[] result = contract.execute(data);
+
+ assertEquals(expected, Hex.toHexString(result));
+ }
+
+ @Test
+ public void sha256Test3() {
+
+ DataWord addr = new DataWord("0000000000000000000000000000000000000000000000000000000000000002");
+ PrecompiledContract contract = PrecompiledContracts.getContractForAddress(addr);
+ byte[] data = Hex.decode("112233");
+ String expected = "49ee2bf93aac3b1fb4117e59095e07abe555c3383b38d608da37680a406096e8";
+
+ byte[] result = contract.execute(data);
+
+ assertEquals(expected, Hex.toHexString(result));
+ }
+
+
+ @Test
+ public void Ripempd160Test1() {
+
+ DataWord addr = new DataWord("0000000000000000000000000000000000000000000000000000000000000003");
+ PrecompiledContract contract = PrecompiledContracts.getContractForAddress(addr);
+ byte[] data = Hex.decode("0000000000000000000000000000000000000000000000000000000000000001");
+ String expected = "000000000000000000000000ae387fcfeb723c3f5964509af111cf5a67f30661";
+
+ byte[] result = contract.execute(data);
+
+ assertEquals(expected, Hex.toHexString(result));
+ }
+
+ @Test
+ public void ecRecoverTest1() {
+
+ byte[] data = Hex.decode("18c547e4f7b0f325ad1e56f57e26c745b09a3e503d86e00e5255ff7f715d3d1c000000000000000000000000000000000000000000000000000000000000001c73b1693892219d736caba55bdb67216e485557ea6b6af75f37096c9aa6a5a75feeb940b1d03b21e36b0e47e79769f095fe2ab855bd91e3a38756b7d75a9c4549");
+ DataWord addr = new DataWord("0000000000000000000000000000000000000000000000000000000000000001");
+ PrecompiledContract contract = PrecompiledContracts.getContractForAddress(addr);
+ String expected = "000000000000000000000000ae387fcfeb723c3f5964509af111cf5a67f30661";
+
+ byte[] result = contract.execute(data);
+
+ System.out.println(Hex.toHexString(result));
+
+
+ }
+
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/vm/ProgramMemoryTest.java b/ethereumj-core/src/test/java/org/ethereum/vm/ProgramMemoryTest.java
new file mode 100644
index 00000000..a1960dd8
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/vm/ProgramMemoryTest.java
@@ -0,0 +1,336 @@
+package org.ethereum.vm;
+
+import org.ethereum.util.ByteUtil;
+
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.nio.ByteBuffer;
+
+import static org.junit.Assert.*;
+
+public class ProgramMemoryTest {
+
+ ProgramInvokeMockImpl pi = null;
+ Program program;
+ ByteBuffer memory;
+
+ @Before
+ public void createProgram() {
+ program = new Program(ByteUtil.EMPTY_BYTE_ARRAY, pi);
+ }
+
+ @Test
+ public void testGetMemSize() {
+ byte[] memory = new byte[64];
+ program.initMem(memory);
+ assertEquals(64, program.getMemSize());
+ }
+
+ @Test
+ @Ignore
+ public void testMemorySave() {
+ fail("Not yet implemented");
+ }
+
+ @Test
+ @Ignore
+ public void testMemoryLoad() {
+ fail("Not yet implemented");
+ }
+
+ @Test
+ public void testMemoryChunk1() {
+ program.initMem(new byte[64]);
+ int offset = 128;
+ int size = 32;
+ program.memoryChunk(offset, size);
+ assertEquals(160, program.getMemSize());
+ }
+
+ @Test // size 0 doesn't increase memory
+ public void testMemoryChunk2() {
+ program.initMem(new byte[64]);
+ int offset = 96;
+ int size = 0;
+ program.memoryChunk(offset, size);
+ assertEquals(64, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemory1() {
+
+ program.initMem(new byte[64]);
+ int offset = 32;
+ int size = 32;
+ program.allocateMemory(offset, size);
+ assertEquals(64, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemory2() {
+
+ // memory.limit() > offset, == size
+ // memory.limit() < offset + size
+ program.initMem(new byte[64]);
+ int offset = 32;
+ int size = 64;
+ program.allocateMemory(offset, size);
+ assertEquals(96, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemory3() {
+
+ // memory.limit() > offset, > size
+ program.initMem(new byte[64]);
+ int offset = 0;
+ int size = 32;
+ program.allocateMemory(offset, size);
+ assertEquals(64, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemory4() {
+
+ program.initMem(new byte[64]);
+ int offset = 0;
+ int size = 64;
+ program.allocateMemory(offset, size);
+ assertEquals(64, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemory5() {
+
+ program.initMem(new byte[64]);
+ int offset = 0;
+ int size = 0;
+ program.allocateMemory(offset, size);
+ assertEquals(64, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemory6() {
+
+ // memory.limit() == offset, > size
+ program.initMem(new byte[64]);
+ int offset = 64;
+ int size = 32;
+ program.allocateMemory(offset, size);
+ assertEquals(96, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemory7() {
+
+ // memory.limit() == offset - size
+ program.initMem(new byte[64]);
+ int offset = 96;
+ int size = 32;
+ program.allocateMemory(offset, size);
+ assertEquals(128, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemory8() {
+
+ program.initMem(new byte[64]);
+ int offset = 0;
+ int size = 96;
+ program.allocateMemory(offset, size);
+ assertEquals(96, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemory9() {
+
+ // memory.limit() < offset, > size
+ // memory.limit() < offset - size
+ program.initMem(new byte[64]);
+ int offset = 96;
+ int size = 0;
+ program.allocateMemory(offset, size);
+ assertEquals(64, program.getMemSize());
+ }
+
+ /************************************************/
+
+
+ @Test
+ public void testAllocateMemory10() {
+
+ // memory = null, offset > size
+ int offset = 32;
+ int size = 0;
+ program.allocateMemory(offset, size);
+ assertEquals(0, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemory11() {
+
+ // memory = null, offset < size
+ int offset = 0;
+ int size = 32;
+ program.allocateMemory(offset, size);
+ assertEquals(32, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemory12() {
+
+ // memory.limit() < offset, < size
+ program.initMem(new byte[64]);
+ int offset = 64;
+ int size = 96;
+ program.allocateMemory(offset, size);
+ assertEquals(160, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemory13() {
+
+ // memory.limit() > offset, < size
+ program.initMem(new byte[64]);
+ int offset = 32;
+ int size = 128;
+ program.allocateMemory(offset, size);
+ assertEquals(160, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemory14() {
+
+ // memory.limit() < offset, == size
+ program.initMem(new byte[64]);
+ int offset = 96;
+ int size = 64;
+ program.allocateMemory(offset, size);
+ assertEquals(160, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemory15() {
+
+ // memory.limit() == offset, < size
+ program.initMem(new byte[64]);
+ int offset = 64;
+ int size = 96;
+ program.allocateMemory(offset, size);
+ assertEquals(160, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemory16() {
+
+ // memory.limit() == offset, == size
+ // memory.limit() > offset - size
+ program.initMem(new byte[64]);
+ int offset = 64;
+ int size = 64;
+ program.allocateMemory(offset, size);
+ assertEquals(128, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemory17() {
+
+ // memory.limit() > offset + size
+ program.initMem(new byte[96]);
+ int offset = 32;
+ int size = 32;
+ program.allocateMemory(offset, size);
+ assertEquals(96, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemoryUnrounded1() {
+
+ // memory unrounded
+ program.initMem(new byte[64]);
+ int offset = 64;
+ int size = 32;
+ program.allocateMemory(offset, size);
+ assertEquals(96, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemoryUnrounded2() {
+
+ // offset unrounded
+ program.initMem(new byte[64]);
+ int offset = 16;
+ int size = 32;
+ program.allocateMemory(offset, size);
+ assertEquals(64, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemoryUnrounded3() {
+
+ // size unrounded
+ program.initMem(new byte[64]);
+ int offset = 64;
+ int size = 16;
+ program.allocateMemory(offset, size);
+ assertEquals(96, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemoryUnrounded4() {
+
+ // memory + offset unrounded
+ program.initMem(new byte[64]);
+ int offset = 16;
+ int size = 32;
+ program.allocateMemory(offset, size);
+ assertEquals(64, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemoryUnrounded5() {
+
+ // memory + size unrounded
+ program.initMem(new byte[64]);
+ int offset = 32;
+ int size = 16;
+ program.allocateMemory(offset, size);
+ assertEquals(64, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemoryUnrounded6() {
+
+ // offset + size unrounded
+ program.initMem(new byte[32]);
+ int offset = 16;
+ int size = 16;
+ program.allocateMemory(offset, size);
+ assertEquals(32, program.getMemSize());
+ }
+
+ @Test
+ public void testAllocateMemoryUnrounded7() {
+
+ // memory + offset + size unrounded
+ program.initMem(new byte[32]);
+ int offset = 16;
+ int size = 16;
+ program.allocateMemory(offset, size);
+ assertEquals(32, program.getMemSize());
+ }
+
+ @Ignore
+ @Test
+ public void testInitialInsert() {
+
+
+ // todo: fix the array out of bound here
+ int offset = 32;
+ int size = 00;
+ program.memorySave(32, 0, new byte[0]);
+ assertEquals(32, program.getMemSize());
+ }
+}
\ No newline at end of file
diff --git a/ethereumj-core/src/test/java/org/ethereum/vm/VMComplexTest.java b/ethereumj-core/src/test/java/org/ethereum/vm/VMComplexTest.java
new file mode 100644
index 00000000..6aa22537
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/vm/VMComplexTest.java
@@ -0,0 +1,664 @@
+package org.ethereum.vm;
+
+import org.ethereum.core.AccountState;
+import org.ethereum.crypto.HashUtil;
+import org.ethereum.facade.Repository;
+
+import org.junit.FixMethodOrder;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spongycastle.util.encoders.Hex;
+
+import java.math.BigInteger;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author Roman Mandeleil
+ * @since 16.06.2014
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class VMComplexTest {
+
+ private static Logger logger = LoggerFactory.getLogger("TCK-Test");
+
+ @Ignore //TODO #POC9
+ @Test // contract call recursive
+ public void test1() {
+
+ /**
+ * #The code will run
+ * ------------------
+
+ a = contract.storage[999]
+ if a > 0:
+ contract.storage[999] = a - 1
+
+ # call to contract: 77045e71a7a2c50903d88e564cd72fab11e82051
+ send((tx.gas / 10 * 8), 0x77045e71a7a2c50903d88e564cd72fab11e82051, 0)
+ else:
+ stop
+ */
+
+ int expectedGas = 436;
+
+ DataWord key1 = new DataWord(999);
+ DataWord value1 = new DataWord(3);
+
+ // Set contract into Database
+ String callerAddr = "cd2a3d9f938e13cd947ec05abc7fe734df8dd826";
+ String contractAddr = "77045e71a7a2c50903d88e564cd72fab11e82051";
+ String code =
+ "6103e75460005260006000511115630000004c576001600051036103e755600060006000600060007377045e71a7a2c50903d88e564cd72fab11e820516008600a5a0402f1630000004c00565b00";
+
+ byte[] contractAddrB = Hex.decode(contractAddr);
+ byte[] callerAddrB = Hex.decode(callerAddr);
+ byte[] codeB = Hex.decode(code);
+
+ byte[] codeKey = HashUtil.sha3(codeB);
+ AccountState accountState = new AccountState();
+ accountState.setCodeHash(codeKey);
+
+ ProgramInvokeMockImpl pi = new ProgramInvokeMockImpl();
+ pi.setOwnerAddress(contractAddrB);
+ Repository repository = pi.getRepository();
+
+ repository.createAccount(callerAddrB);
+ repository.addBalance(callerAddrB, new BigInteger("100000000000000000000"));
+
+ repository.createAccount(contractAddrB);
+ repository.saveCode(contractAddrB, codeB);
+ repository.addStorageRow(contractAddrB, key1, value1);
+
+ // Play the program
+ VM vm = new VM();
+ Program program = new Program(codeB, pi);
+
+ try {
+ while (!program.isStopped())
+ vm.step(program);
+ } catch (RuntimeException e) {
+ program.setRuntimeFailure(e);
+ }
+
+ System.out.println();
+ System.out.println("============ Results ============");
+
+ BigInteger balance = repository.getBalance(callerAddrB);
+
+ System.out.println("*** Used gas: " + program.getResult().getGasUsed());
+ System.out.println("*** Contract Balance: " + balance);
+
+ // todo: assert caller balance after contract exec
+
+ repository.close();
+ assertEquals(expectedGas, program.getResult().getGasUsed());
+ }
+
+ @Ignore //TODO #POC9
+ @Test // contractB call contractA with data to storage
+ public void test2() {
+
+ /**
+ * #The code will run
+ * ------------------
+
+ contract A: 77045e71a7a2c50903d88e564cd72fab11e82051
+ ---------------
+ a = msg.data[0]
+ b = msg.data[1]
+
+ contract.storage[a]
+ contract.storage[b]
+
+
+ contract B: 83c5541a6c8d2dbad642f385d8d06ca9b6c731ee
+ -----------
+ a = msg((tx.gas / 10 * 8), 0x77045e71a7a2c50903d88e564cd72fab11e82051, 0, [11, 22, 33], 3, 6)
+
+ */
+
+ long expectedVal_1 = 11;
+ long expectedVal_2 = 22;
+
+ // Set contract into Database
+ String callerAddr = "cd2a3d9f938e13cd947ec05abc7fe734df8dd826";
+
+ String contractA_addr = "77045e71a7a2c50903d88e564cd72fab11e82051";
+ String contractB_addr = "83c5541a6c8d2dbad642f385d8d06ca9b6c731ee";
+
+ String code_a = "60006020023560005260016020023560205260005160005560205160015500";
+ String code_b = "6000601f5360e05960e05952600060c05901536060596020015980602001600b9052806040016016905280606001602190526080905260007377045e71a7a2c50903d88e564cd72fab11e820516103e8f1602060000260a00160200151600052";
+
+ byte[] caller_addr_bytes = Hex.decode(callerAddr);
+
+ byte[] contractA_addr_bytes = Hex.decode(contractA_addr);
+ byte[] codeA = Hex.decode(code_a);
+
+ byte[] contractB_addr_bytes = Hex.decode(contractB_addr);
+ byte[] codeB = Hex.decode(code_b);
+
+ ProgramInvokeMockImpl pi = new ProgramInvokeMockImpl();
+ pi.setOwnerAddress(contractB_addr_bytes);
+ Repository repository = pi.getRepository();
+
+ repository.createAccount(contractA_addr_bytes);
+ repository.saveCode(contractA_addr_bytes, codeA);
+
+ repository.createAccount(contractB_addr_bytes);
+ repository.saveCode(contractB_addr_bytes, codeB);
+
+ repository.createAccount(caller_addr_bytes);
+ repository.addBalance(caller_addr_bytes, new BigInteger("100000000000000000000"));
+
+
+ // ****************** //
+ // Play the program //
+ // ****************** //
+ VM vm = new VM();
+ Program program = new Program(codeB, pi);
+
+ try {
+ while (!program.isStopped())
+ vm.step(program);
+ } catch (RuntimeException e) {
+ program.setRuntimeFailure(e);
+ }
+
+
+ System.out.println();
+ System.out.println("============ Results ============");
+
+
+ System.out.println("*** Used gas: " + program.getResult().getGasUsed());
+
+
+ DataWord value_1 = repository.getStorageValue(contractA_addr_bytes, new DataWord(00));
+ DataWord value_2 = repository.getStorageValue(contractA_addr_bytes, new DataWord(01));
+
+
+ repository.close();
+ assertEquals(expectedVal_1, value_1.longValue());
+ assertEquals(expectedVal_2, value_2.longValue());
+
+ // TODO: check that the value pushed after exec is 1
+ }
+
+ @Ignore
+ @Test // contractB call contractA with return expectation
+ public void test3() {
+
+ /**
+ * #The code will run
+ * ------------------
+
+ contract A: 77045e71a7a2c50903d88e564cd72fab11e82051
+ ---------------
+
+ a = 11
+ b = 22
+ c = 33
+ d = 44
+ e = 55
+ f = 66
+
+ [asm 192 0 RETURN asm]
+
+
+
+ contract B: 83c5541a6c8d2dbad642f385d8d06ca9b6c731ee
+ -----------
+ a = msg((tx.gas / 10 * 8), 0x77045e71a7a2c50903d88e564cd72fab11e82051, 0, [11, 22, 33], 3, 6)
+
+ */
+
+ long expectedVal_1 = 11;
+ long expectedVal_2 = 22;
+ long expectedVal_3 = 33;
+ long expectedVal_4 = 44;
+ long expectedVal_5 = 55;
+ long expectedVal_6 = 66;
+
+ // Set contract into Database
+ byte[] caller_addr_bytes = Hex.decode("cd2a3d9f938e13cd947ec05abc7fe734df8dd826");
+
+ byte[] contractA_addr_bytes = Hex.decode("77045e71a7a2c50903d88e564cd72fab11e82051");
+ byte[] contractB_addr_bytes = Hex.decode("83c5541a6c8d2dbad642f385d8d06ca9b6c731ee");
+
+ byte[] codeA = Hex.decode("600b60005260166020526021604052602c6060526037608052604260a05260c06000f2");
+ byte[] codeB = Hex.decode("6000601f5360e05960e05952600060c05901536060596020015980602001600b9052806040016016905280606001602190526080905260007377045e71a7a2c50903d88e564cd72fab11e820516103e8f1602060000260a00160200151600052");
+
+ ProgramInvokeMockImpl pi = new ProgramInvokeMockImpl();
+ pi.setOwnerAddress(contractB_addr_bytes);
+ Repository repository = pi.getRepository();
+ repository.createAccount(contractA_addr_bytes);
+ repository.saveCode(contractA_addr_bytes, codeA);
+
+ repository.createAccount(contractB_addr_bytes);
+ repository.saveCode(contractB_addr_bytes, codeB);
+
+ repository.createAccount(caller_addr_bytes);
+ repository.addBalance(caller_addr_bytes, new BigInteger("100000000000000000000"));
+
+ // ****************** //
+ // Play the program //
+ // ****************** //
+ VM vm = new VM();
+ Program program = new Program(codeB, pi);
+
+ try {
+ while (!program.isStopped())
+ vm.step(program);
+ } catch (RuntimeException e) {
+ program.setRuntimeFailure(e);
+ }
+
+ System.out.println();
+ System.out.println("============ Results ============");
+ System.out.println("*** Used gas: " + program.getResult().getGasUsed());
+
+ DataWord value1 = program.memoryLoad(new DataWord(32));
+ DataWord value2 = program.memoryLoad(new DataWord(64));
+ DataWord value3 = program.memoryLoad(new DataWord(96));
+ DataWord value4 = program.memoryLoad(new DataWord(128));
+ DataWord value5 = program.memoryLoad(new DataWord(160));
+ DataWord value6 = program.memoryLoad(new DataWord(192));
+
+ repository.close();
+
+ assertEquals(expectedVal_1, value1.longValue());
+ assertEquals(expectedVal_2, value2.longValue());
+ assertEquals(expectedVal_3, value3.longValue());
+ assertEquals(expectedVal_4, value4.longValue());
+ assertEquals(expectedVal_5, value5.longValue());
+ assertEquals(expectedVal_6, value6.longValue());
+
+ // TODO: check that the value pushed after exec is 1
+ }
+
+ @Test // CREATE magic
+ public void test4() {
+
+ /**
+ * #The code will run
+ * ------------------
+
+ contract A: 77045e71a7a2c50903d88e564cd72fab11e82051
+ -----------
+
+ a = 0x7f60c860005461012c6020540000000000000000000000000000000000000000
+ b = 0x0060005460206000f20000000000000000000000000000000000000000000000
+ create(100, 0 41)
+
+
+ contract B: (the contract to be created the addr will be defined to: 8e45367623a2865132d9bf875d5cfa31b9a0cd94)
+ -----------
+ a = 200
+ b = 300
+
+ */
+
+ // Set contract into Database
+ byte[] caller_addr_bytes = Hex.decode("cd2a3d9f938e13cd947ec05abc7fe734df8dd826");
+
+ byte[] contractA_addr_bytes = Hex.decode("77045e71a7a2c50903d88e564cd72fab11e82051");
+
+ byte[] codeA = Hex.decode("7f7f60c860005461012c602054000000000000" +
+ "00000000000000000000000000006000547e60" +
+ "005460206000f2000000000000000000000000" +
+ "0000000000000000000000602054602960006064f0");
+
+ ProgramInvokeMockImpl pi = new ProgramInvokeMockImpl();
+ pi.setOwnerAddress(contractA_addr_bytes);
+
+ Repository repository = pi.getRepository();
+
+ repository.createAccount(contractA_addr_bytes);
+ repository.saveCode(contractA_addr_bytes, codeA);
+
+ repository.createAccount(caller_addr_bytes);
+
+ // ****************** //
+ // Play the program //
+ // ****************** //
+ VM vm = new VM();
+ Program program = new Program(codeA, pi);
+
+ try {
+ while (!program.isStopped())
+ vm.step(program);
+ } catch (RuntimeException e) {
+ program.setRuntimeFailure(e);
+ }
+
+ logger.info("============ Results ============");
+
+ System.out.println("*** Used gas: " + program.getResult().getGasUsed());
+ // TODO: check that the value pushed after exec is the new address
+ repository.close();
+ }
+
+ @Test // CALL contract with too much gas
+ @Ignore
+ public void test5() {
+ // TODO CALL contract with gas > gasRemaining && gas > Long.MAX_VALUE
+ }
+
+ @Ignore
+ @Test // contractB call itself with code from contractA
+ public void test6() {
+ /**
+ * #The code will run
+ * ------------------
+
+ contract A: 945304eb96065b2a98b57a48a06ae28d285a71b5
+ ---------------
+
+ PUSH1 0 CALLDATALOAD SLOAD NOT PUSH1 9 JUMPI STOP
+ PUSH1 32 CALLDATALOAD PUSH1 0 CALLDATALOAD SSTORE
+
+ contract B: 0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6
+ -----------
+ { (MSTORE 0 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
+ (MSTORE 32 0xaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa)
+ [[ 0 ]] (CALLSTATELESS 1000000 0x945304eb96065b2a98b57a48a06ae28d285a71b5 23 0 64 64 0)
+ }
+ */
+
+ // Set contract into Database
+ byte[] caller_addr_bytes = Hex.decode("cd1722f3947def4cf144679da39c4c32bdc35681");
+
+ byte[] contractA_addr_bytes = Hex.decode("945304eb96065b2a98b57a48a06ae28d285a71b5");
+ byte[] contractB_addr_bytes = Hex.decode("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6");
+
+ byte[] codeA = Hex.decode("60003554156009570060203560003555");
+ byte[] codeB = Hex.decode("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000527faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020526000604060406000601773945304eb96065b2a98b57a48a06ae28d285a71b5620f4240f3600055");
+
+ ProgramInvokeMockImpl pi = new ProgramInvokeMockImpl();
+ pi.setOwnerAddress(contractB_addr_bytes);
+ pi.setGasLimit(10000000000000l);
+
+ Repository repository = pi.getRepository();
+ repository.createAccount(contractA_addr_bytes);
+ repository.saveCode(contractA_addr_bytes, codeA);
+ repository.addBalance(contractA_addr_bytes, BigInteger.valueOf(23));
+
+ repository.createAccount(contractB_addr_bytes);
+ repository.saveCode(contractB_addr_bytes, codeB);
+ repository.addBalance(contractB_addr_bytes, new BigInteger("1000000000000000000"));
+
+ repository.createAccount(caller_addr_bytes);
+ repository.addBalance(caller_addr_bytes, new BigInteger("100000000000000000000"));
+
+ // ****************** //
+ // Play the program //
+ // ****************** //
+ VM vm = new VM();
+ Program program = new Program(codeB, pi);
+
+ try {
+ while (!program.isStopped())
+ vm.step(program);
+ } catch (RuntimeException e) {
+ program.setRuntimeFailure(e);
+ }
+
+ System.out.println();
+ System.out.println("============ Results ============");
+ System.out.println("*** Used gas: " + program.getResult().getGasUsed());
+
+ DataWord memValue1 = program.memoryLoad(new DataWord(0));
+ DataWord memValue2 = program.memoryLoad(new DataWord(32));
+
+ DataWord storeValue1 = repository.getStorageValue(contractB_addr_bytes, new DataWord(00));
+
+ repository.close();
+
+ assertEquals("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", memValue1.toString());
+ assertEquals("aaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa", memValue2.toString());
+
+ assertEquals("0x1", storeValue1.shortHex());
+
+ // TODO: check that the value pushed after exec is 1
+ }
+
+ //sha3_memSizeQuadraticCost33
+ @Ignore //TODO #POC9
+ @Test // contract call quadratic memory use
+ public void test7() {
+
+ int expectedGas = 357;
+
+ DataWord key1 = new DataWord(999);
+ DataWord value1 = new DataWord(3);
+
+ // Set contract into Database
+ String callerAddr = "cd1722f3947def4cf144679da39c4c32bdc35681";
+ String contractAddr = "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6";
+ String code = "600161040020600055";
+
+ byte[] contractAddrB = Hex.decode(contractAddr);
+ byte[] callerAddrB = Hex.decode(callerAddr);
+ byte[] codeB = Hex.decode(code);
+
+ byte[] codeKey = HashUtil.sha3(codeB);
+ AccountState accountState = new AccountState();
+ accountState.setCodeHash(codeKey);
+
+ ProgramInvokeMockImpl pi = new ProgramInvokeMockImpl();
+ pi.setOwnerAddress(contractAddrB);
+ Repository repository = pi.getRepository();
+
+ repository.createAccount(callerAddrB);
+ repository.addBalance(callerAddrB, new BigInteger("115792089237316195423570985008687907853269984665640564039457584007913129639935"));
+
+ repository.createAccount(contractAddrB);
+ repository.saveCode(contractAddrB, codeB);
+ repository.addStorageRow(contractAddrB, key1, value1);
+
+ // Play the program
+ VM vm = new VM();
+ Program program = new Program(codeB, pi);
+
+ try {
+ while (!program.isStopped())
+ vm.step(program);
+ } catch (RuntimeException e) {
+ program.setRuntimeFailure(e);
+ }
+
+ System.out.println();
+ System.out.println("============ Results ============");
+
+ BigInteger balance = repository.getBalance(callerAddrB);
+
+ System.out.println("*** Used gas: " + program.getResult().getGasUsed());
+ System.out.println("*** Contract Balance: " + balance);
+
+ // todo: assert caller balance after contract exec
+
+ repository.close();
+ assertEquals(expectedGas, program.getResult().getGasUsed());
+ }
+
+ //sha3_memSizeQuadraticCost31
+ @Ignore //TODO #POC9
+ @Test // contract call quadratic memory use
+ public void test8() {
+
+ int expectedGas = 354;
+
+ DataWord key1 = new DataWord(999);
+ DataWord value1 = new DataWord(3);
+
+ // Set contract into Database
+ String callerAddr = "cd1722f3947def4cf144679da39c4c32bdc35681";
+ String contractAddr = "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6";
+ String code = "60016103c020600055";
+
+ byte[] contractAddrB = Hex.decode(contractAddr);
+ byte[] callerAddrB = Hex.decode(callerAddr);
+ byte[] codeB = Hex.decode(code);
+
+ byte[] codeKey = HashUtil.sha3(codeB);
+ AccountState accountState = new AccountState();
+ accountState.setCodeHash(codeKey);
+
+ ProgramInvokeMockImpl pi = new ProgramInvokeMockImpl();
+ pi.setOwnerAddress(contractAddrB);
+ Repository repository = pi.getRepository();
+
+ repository.createAccount(callerAddrB);
+ repository.addBalance(callerAddrB, new BigInteger("115792089237316195423570985008687907853269984665640564039457584007913129639935"));
+
+ repository.createAccount(contractAddrB);
+ repository.saveCode(contractAddrB, codeB);
+ repository.addStorageRow(contractAddrB, key1, value1);
+
+ // Play the program
+ VM vm = new VM();
+ Program program = new Program(codeB, pi);
+
+ try {
+ while (!program.isStopped())
+ vm.step(program);
+ } catch (RuntimeException e) {
+ program.setRuntimeFailure(e);
+ }
+
+ System.out.println();
+ System.out.println("============ Results ============");
+
+ BigInteger balance = repository.getBalance(callerAddrB);
+
+ System.out.println("*** Used gas: " + program.getResult().getGasUsed());
+ System.out.println("*** Contract Balance: " + balance);
+
+ // todo: assert caller balance after contract exec
+
+ repository.close();
+ assertEquals(expectedGas, program.getResult().getGasUsed());
+ }
+
+ //sha3_memSizeQuadraticCost32
+ @Ignore //TODO #POC9
+ @Test // contract call quadratic memory use
+ public void test9() {
+
+ int expectedGas = 356;
+
+ DataWord key1 = new DataWord(9999);
+ DataWord value1 = new DataWord(3);
+
+ // Set contract into Database
+ String callerAddr = "cd1722f3947def4cf144679da39c4c32bdc35681";
+ String contractAddr = "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6";
+ String code = "60016103e020600055";
+
+ byte[] contractAddrB = Hex.decode(contractAddr);
+ byte[] callerAddrB = Hex.decode(callerAddr);
+ byte[] codeB = Hex.decode(code);
+
+ byte[] codeKey = HashUtil.sha3(codeB);
+ AccountState accountState = new AccountState();
+ accountState.setCodeHash(codeKey);
+
+ ProgramInvokeMockImpl pi = new ProgramInvokeMockImpl();
+ pi.setOwnerAddress(contractAddrB);
+ Repository repository = pi.getRepository();
+
+ repository.createAccount(callerAddrB);
+ repository.addBalance(callerAddrB, new BigInteger("115792089237316195423570985008687907853269984665640564039457584007913129639935"));
+
+ repository.createAccount(contractAddrB);
+ repository.saveCode(contractAddrB, codeB);
+ repository.addStorageRow(contractAddrB, key1, value1);
+
+ // Play the program
+ VM vm = new VM();
+ Program program = new Program(codeB, pi);
+
+ try {
+ while (!program.isStopped())
+ vm.step(program);
+ } catch (RuntimeException e) {
+ program.setRuntimeFailure(e);
+ }
+
+ System.out.println();
+ System.out.println("============ Results ============");
+
+ BigInteger balance = repository.getBalance(callerAddrB);
+
+ System.out.println("*** Used gas: " + program.getResult().getGasUsed());
+ System.out.println("*** Contract Balance: " + balance);
+
+ // todo: assert caller balance after contract exec
+
+ repository.close();
+ assertEquals(expectedGas, program.getResult().getGasUsed());
+ }
+
+ //sha3_memSizeQuadraticCost32_zeroSize
+ @Ignore //TODO #POC9
+ @Test // contract call quadratic memory use
+ public void test10() {
+
+ int expectedGas = 313;
+
+ DataWord key1 = new DataWord(999);
+ DataWord value1 = new DataWord(3);
+
+ // Set contract into Database
+ String callerAddr = "cd1722f3947def4cf144679da39c4c32bdc35681";
+ String contractAddr = "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6";
+ String code = "600061040020600055";
+
+ byte[] contractAddrB = Hex.decode(contractAddr);
+ byte[] callerAddrB = Hex.decode(callerAddr);
+ byte[] codeB = Hex.decode(code);
+
+ byte[] codeKey = HashUtil.sha3(codeB);
+ AccountState accountState = new AccountState();
+ accountState.setCodeHash(codeKey);
+
+ ProgramInvokeMockImpl pi = new ProgramInvokeMockImpl();
+ pi.setOwnerAddress(contractAddrB);
+ Repository repository = pi.getRepository();
+
+ repository.createAccount(callerAddrB);
+ repository.addBalance(callerAddrB, new BigInteger("115792089237316195423570985008687907853269984665640564039457584007913129639935"));
+
+ repository.createAccount(contractAddrB);
+ repository.saveCode(contractAddrB, codeB);
+ repository.addStorageRow(contractAddrB, key1, value1);
+
+ // Play the program
+ VM vm = new VM();
+ Program program = new Program(codeB, pi);
+
+ try {
+ while (!program.isStopped())
+ vm.step(program);
+ } catch (RuntimeException e) {
+ program.setRuntimeFailure(e);
+ }
+
+ System.out.println();
+ System.out.println("============ Results ============");
+
+ BigInteger balance = repository.getBalance(callerAddrB);
+
+ System.out.println("*** Used gas: " + program.getResult().getGasUsed());
+ System.out.println("*** Contract Balance: " + balance);
+
+ // todo: assert caller balance after contract exec
+
+ repository.close();
+ assertEquals(expectedGas, program.getResult().getGasUsed());
+ }
+}
diff --git a/ethereumj-core/src/test/java/org/ethereum/vm/VMCustomTest.java b/ethereumj-core/src/test/java/org/ethereum/vm/VMCustomTest.java
new file mode 100644
index 00000000..1343ddcf
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/vm/VMCustomTest.java
@@ -0,0 +1,564 @@
+package org.ethereum.vm;
+
+import org.ethereum.vm.Program.OutOfGasException;
+import org.ethereum.vm.Program.StackTooSmallException;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import org.spongycastle.util.encoders.Hex;
+
+import java.math.BigInteger;
+
+import static org.junit.Assert.*;
+
+/**
+ * @author Roman Mandeleil
+ * @since 01.06.2014
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class VMCustomTest {
+
+ private ProgramInvokeMockImpl invoke;
+ private Program program;
+
+ @Before
+ public void setup() {
+ byte[] ownerAddress = Hex.decode("77045E71A7A2C50903D88E564CD72FAB11E82051");
+ byte[] msgData = Hex.decode("00000000000000000000000000000000000000000000000000000000000000A1" +
+ "00000000000000000000000000000000000000000000000000000000000000B1");
+
+ invoke = new ProgramInvokeMockImpl(msgData);
+ invoke.setOwnerAddress(ownerAddress);
+
+ invoke.getRepository().createAccount(ownerAddress);
+ invoke.getRepository().addBalance(ownerAddress, BigInteger.valueOf(1000L));
+ }
+
+ @After
+ public void tearDown() {
+ invoke.getRepository().close();
+ }
+
+ @Test // CALLDATASIZE OP
+ public void testCALLDATASIZE_1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("36"), invoke);
+ String s_expected_1 = "0000000000000000000000000000000000000000000000000000000000000040";
+
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+
+ @Test // CALLDATALOAD OP
+ public void testCALLDATALOAD_1() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("600035"), invoke);
+ String s_expected_1 = "00000000000000000000000000000000000000000000000000000000000000A1";
+
+ vm.step(program);
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Test // CALLDATALOAD OP
+ public void testCALLDATALOAD_2() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("600235"), invoke);
+ String s_expected_1 = "0000000000000000000000000000000000000000000000000000000000A10000";
+
+ vm.step(program);
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+
+ @Test // CALLDATALOAD OP
+ public void testCALLDATALOAD_3() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("602035"), invoke);
+ String s_expected_1 = "00000000000000000000000000000000000000000000000000000000000000B1";
+
+ vm.step(program);
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+
+ @Test // CALLDATALOAD OP
+ public void testCALLDATALOAD_4() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("602335"), invoke);
+ String s_expected_1 = "00000000000000000000000000000000000000000000000000000000B1000000";
+
+ vm.step(program);
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Test // CALLDATALOAD OP
+ public void testCALLDATALOAD_5() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("603F35"), invoke);
+ String s_expected_1 = "B100000000000000000000000000000000000000000000000000000000000000";
+
+ vm.step(program);
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Test(expected = RuntimeException.class) // CALLDATALOAD OP mal
+ public void testCALLDATALOAD_6() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("35"), invoke);
+ try {
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test // CALLDATACOPY OP
+ public void testCALLDATACOPY_1() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("60206000600037"), invoke);
+ String m_expected = "00000000000000000000000000000000000000000000000000000000000000A1";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(m_expected, Hex.toHexString(program.getMemory()).toUpperCase());
+ }
+
+ @Test // CALLDATACOPY OP
+ public void testCALLDATACOPY_2() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("60406000600037"), invoke);
+ String m_expected = "00000000000000000000000000000000000000000000000000000000000000A1" +
+ "00000000000000000000000000000000000000000000000000000000000000B1";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(m_expected, Hex.toHexString(program.getMemory()).toUpperCase());
+ }
+
+
+ @Test // CALLDATACOPY OP
+ public void testCALLDATACOPY_3() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("60406004600037"), invoke);
+ String m_expected = "000000000000000000000000000000000000000000000000000000A100000000" +
+ "000000000000000000000000000000000000000000000000000000B100000000";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(m_expected, Hex.toHexString(program.getMemory()).toUpperCase());
+ }
+
+
+ @Test // CALLDATACOPY OP
+ public void testCALLDATACOPY_4() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("60406000600437"), invoke);
+ String m_expected = "0000000000000000000000000000000000000000000000000000000000000000" +
+ "000000A100000000000000000000000000000000000000000000000000000000" +
+ "000000B100000000000000000000000000000000000000000000000000000000";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(m_expected, Hex.toHexString(program.getMemory()).toUpperCase());
+ }
+
+ @Test // CALLDATACOPY OP
+ public void testCALLDATACOPY_5() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("60406000600437"), invoke);
+ String m_expected = "0000000000000000000000000000000000000000000000000000000000000000" +
+ "000000A100000000000000000000000000000000000000000000000000000000" +
+ "000000B100000000000000000000000000000000000000000000000000000000";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(m_expected, Hex.toHexString(program.getMemory()).toUpperCase());
+ }
+
+
+ @Test(expected = StackTooSmallException.class) // CALLDATACOPY OP mal
+ public void testCALLDATACOPY_6() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("6040600037"), invoke);
+
+ try {
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test(expected = OutOfGasException.class) // CALLDATACOPY OP mal
+ public void testCALLDATACOPY_7() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("6020600073CC0929EB16730E7C14FEFC63006AC2D794C5795637"), invoke);
+
+ try {
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test // ADDRESS OP
+ public void testADDRESS_1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("30"), invoke);
+ String s_expected_1 = "00000000000000000000000077045E71A7A2C50903D88E564CD72FAB11E82051";
+
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ program.getResult().getRepository().close();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Test // BALANCE OP
+ public void testBALANCE_1() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("3031"), invoke);
+ String s_expected_1 = "00000000000000000000000000000000000000000000000000000000000003E8";
+
+ vm.step(program);
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Test // ORIGIN OP
+ public void testORIGIN_1() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("32"), invoke);
+ String s_expected_1 = "00000000000000000000000013978AEE95F38490E9769C39B2773ED763D9CD5F";
+
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Test // CALLER OP
+ public void testCALLER_1() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("33"), invoke);
+ String s_expected_1 = "000000000000000000000000885F93EED577F2FC341EBB9A5C9B2CE4465D96C4";
+
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Test // CALLVALUE OP
+ public void testCALLVALUE_1() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("34"), invoke);
+ String s_expected_1 = "0000000000000000000000000000000000000000000000000DE0B6B3A7640000";
+
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Test // SHA3 OP
+ public void testSHA3_1() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("60016000536001600020"), invoke);
+ String s_expected_1 = "5FE7F977E71DBA2EA1A68E21057BEEBB9BE2AC30C6410AA38D4F3FBE41DCFFD2";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Test // SHA3 OP
+ public void testSHA3_2() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("6102016000526002601E20"), invoke);
+ String s_expected_1 = "114A3FE82A0219FCC31ABD15617966A125F12B0FD3409105FC83B487A9D82DE4";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Test(expected = StackTooSmallException.class) // SHA3 OP mal
+ public void testSHA3_3() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("610201600052600220"), invoke);
+ try {
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test // BLOCKHASH OP
+ public void testBLOCKHASH_1() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("600140"), invoke);
+ String s_expected_1 = "C89EFDAA54C0F20C7ADF612882DF0950F5A951637E0307CDCB4C672F298B8BC6";
+
+ vm.step(program);
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Test // COINBASE OP
+ public void testCOINBASE_1() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("41"), invoke);
+ String s_expected_1 = "000000000000000000000000E559DE5527492BCB42EC68D07DF0742A98EC3F1E";
+
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Test // TIMESTAMP OP
+ public void testTIMESTAMP_1() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("42"), invoke);
+ String s_expected_1 = "000000000000000000000000000000000000000000000000000000005387FE24";
+
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Test // NUMBER OP
+ public void testNUMBER_1() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("43"), invoke);
+ String s_expected_1 = "0000000000000000000000000000000000000000000000000000000000000021";
+
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Test // DIFFICULTY OP
+ public void testDIFFICULTY_1() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("44"), invoke);
+ String s_expected_1 = "00000000000000000000000000000000000000000000000000000000003ED290";
+
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Test // GASPRICE OP
+ public void testGASPRICE_1() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("3A"), invoke);
+ String s_expected_1 = "000000000000000000000000000000000000000000000000000009184E72A000";
+
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Ignore //TODO #POC9
+ @Test // GAS OP
+ public void testGAS_1() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("5A"), invoke);
+ String s_expected_1 = "00000000000000000000000000000000000000000000000000000000000F423F";
+
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Test // GASLIMIT OP
+ public void testGASLIMIT_1() {
+
+ VM vm = new VM();
+ program =
+ new Program(Hex.decode("45"), invoke);
+ String s_expected_1 = "00000000000000000000000000000000000000000000000000000000000F4240";
+
+ vm.step(program);
+
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+
+ @Test(expected = Program.IllegalOperationException.class) // INVALID OP
+ public void testINVALID_1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("60012F6002"), invoke);
+ String s_expected_1 = "0000000000000000000000000000000000000000000000000000000000000001";
+
+ try {
+ vm.step(program);
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ DataWord item1 = program.stackPop();
+ assertEquals(s_expected_1, Hex.toHexString(item1.getData()).toUpperCase());
+ }
+ }
+
+ /* TEST CASE LIST END */
+
+}
+
+// TODO: add gas expeted and calculated to all test cases
+// TODO: considering: G_TXDATA + G_TRANSACTION
+
+/**
+ * TODO:
+ *
+ * 22) CREATE:
+ * 23) CALL:
+ *
+ *
+ **/
+
+/**
+
+ contract creation (gas usage)
+ -----------------------------
+ G_TRANSACTION = (500)
+ 60016000546006601160003960066000f261778e600054 (115)
+ PUSH1 6001 (1)
+ PUSH1 6000 (1)
+ MSTORE 54 (1 + 1)
+ PUSH1 6006 (1)
+ PUSH1 6011 (1)
+ PUSH1 6000 (1)
+ CODECOPY 39 (1)
+ PUSH1 6006 (1)
+ PUSH1 6000 (1)
+ RETURN f2 (1)
+ 61778e600054
+
+ */
diff --git a/ethereumj-core/src/test/java/org/ethereum/vm/VMTest.java b/ethereumj-core/src/test/java/org/ethereum/vm/VMTest.java
new file mode 100644
index 00000000..aeeceb6d
--- /dev/null
+++ b/ethereumj-core/src/test/java/org/ethereum/vm/VMTest.java
@@ -0,0 +1,2899 @@
+package org.ethereum.vm;
+
+import org.ethereum.facade.Repository;
+import org.ethereum.util.ByteUtil;
+import org.ethereum.vm.Program.BadJumpDestinationException;
+import org.ethereum.vm.Program.StackTooSmallException;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.FixMethodOrder;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import org.spongycastle.util.encoders.Hex;
+
+import java.util.List;
+
+import static org.ethereum.util.ByteUtil.oneByteToHexString;
+import static org.junit.Assert.*;
+
+/**
+ * @author Roman Mandeleil
+ * @since 01.06.2014
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class VMTest {
+
+ private ProgramInvokeMockImpl invoke;
+ private Program program;
+
+ @Before
+ public void setup() {
+ invoke = new ProgramInvokeMockImpl();
+ }
+
+ @After
+ public void tearDown() {
+ invoke.getRepository().close();
+ }
+
+ @Test // PUSH1 OP
+ public void testPUSH1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("60A0"), invoke);
+ String expected = "00000000000000000000000000000000000000000000000000000000000000A0";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH2 OP
+ public void testPUSH2() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("61A0B0"), invoke);
+ String expected = "000000000000000000000000000000000000000000000000000000000000A0B0";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH3 OP
+ public void testPUSH3() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("62A0B0C0"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000A0B0C0";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH4 OP
+ public void testPUSH4() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("63A0B0C0D0"), invoke);
+ String expected = "00000000000000000000000000000000000000000000000000000000A0B0C0D0";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH5 OP
+ public void testPUSH5() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("64A0B0C0D0E0"), invoke);
+ String expected = "000000000000000000000000000000000000000000000000000000A0B0C0D0E0";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH6 OP
+ public void testPUSH6() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("65A0B0C0D0E0F0"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000A0B0C0D0E0F0";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH7 OP
+ public void testPUSH7() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("66A0B0C0D0E0F0A1"), invoke);
+ String expected = "00000000000000000000000000000000000000000000000000A0B0C0D0E0F0A1";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH8 OP
+ public void testPUSH8() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("67A0B0C0D0E0F0A1B1"), invoke);
+ String expected = "000000000000000000000000000000000000000000000000A0B0C0D0E0F0A1B1";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH9 OP
+ public void testPUSH9() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("68A0B0C0D0E0F0A1B1C1"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000A0B0C0D0E0F0A1B1C1";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+
+ @Test // PUSH10 OP
+ public void testPUSH10() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("69A0B0C0D0E0F0A1B1C1D1"), invoke);
+ String expected = "00000000000000000000000000000000000000000000A0B0C0D0E0F0A1B1C1D1";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH11 OP
+ public void testPUSH11() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("6AA0B0C0D0E0F0A1B1C1D1E1"), invoke);
+ String expected = "000000000000000000000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH12 OP
+ public void testPUSH12() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("6BA0B0C0D0E0F0A1B1C1D1E1F1"), invoke);
+ String expected = "0000000000000000000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH13 OP
+ public void testPUSH13() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("6CA0B0C0D0E0F0A1B1C1D1E1F1A2"), invoke);
+ String expected = "00000000000000000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH14 OP
+ public void testPUSH14() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("6DA0B0C0D0E0F0A1B1C1D1E1F1A2B2"), invoke);
+ String expected = "000000000000000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH15 OP
+ public void testPUSH15() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("6EA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2"), invoke);
+ String expected = "0000000000000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH16 OP
+ public void testPUSH16() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("6FA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2"), invoke);
+ String expected = "00000000000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH17 OP
+ public void testPUSH17() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("70A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2"), invoke);
+ String expected = "000000000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH18 OP
+ public void testPUSH18() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("71A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2"), invoke);
+ String expected = "0000000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH19 OP
+ public void testPUSH19() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("72A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3"), invoke);
+ String expected = "00000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH20 OP
+ public void testPUSH20() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("73A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3"), invoke);
+ String expected = "000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH21 OP
+ public void testPUSH21() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("74A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3"), invoke);
+ String expected = "0000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH22 OP
+ public void testPUSH22() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("75A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3"), invoke);
+ String expected = "00000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH23 OP
+ public void testPUSH23() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("76A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3"), invoke);
+ String expected = "000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH24 OP
+ public void testPUSH24() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("77A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3"), invoke);
+ String expected = "0000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH25 OP
+ public void testPUSH25() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("78A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4"), invoke);
+ String expected = "00000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH26 OP
+ public void testPUSH26() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("79A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4"), invoke);
+ String expected = "000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH27 OP
+ public void testPUSH27() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("7AA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4"), invoke);
+ String expected = "0000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH28 OP
+ public void testPUSH28() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("7BA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4"), invoke);
+ String expected = "00000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH29 OP
+ public void testPUSH29() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("7CA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4"), invoke);
+ String expected = "000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH30 OP
+ public void testPUSH30() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("7DA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4F4"), invoke);
+ String expected = "0000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4F4";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH31 OP
+ public void testPUSH31() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("7EA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4F4A1"), invoke);
+ String expected = "00A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4F4A1";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSH32 OP
+ public void testPUSH32() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("7FA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4F4A1B1"), invoke);
+ String expected = "A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4F4A1B1";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSHN OP not enough data
+ public void testPUSHN_1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("61AA"), invoke);
+ String expected = "000000000000000000000000000000000000000000000000000000000000AA00";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertTrue(program.isStopped());
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // PUSHN OP not enough data
+ public void testPUSHN_2() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("7fAABB"), invoke);
+ String expected = "AABB000000000000000000000000000000000000000000000000000000000000";
+
+ program.fullTrace();
+ vm.step(program);
+
+ assertTrue(program.isStopped());
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // AND OP
+ public void testAND_1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("600A600A16"), invoke);
+ String expected = "000000000000000000000000000000000000000000000000000000000000000A";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // AND OP
+ public void testAND_2() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("60C0600A16"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000000";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test(expected = RuntimeException.class) // AND OP mal data
+ public void testAND_3() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("60C016"), invoke);
+ try {
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test // OR OP
+ public void testOR_1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("60F0600F17"), invoke);
+ String expected = "00000000000000000000000000000000000000000000000000000000000000FF";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // OR OP
+ public void testOR_2() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("60C3603C17"), invoke);
+ String expected = "00000000000000000000000000000000000000000000000000000000000000FF";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test(expected = RuntimeException.class) // OR OP mal data
+ public void testOR_3() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("60C017"), invoke);
+ try {
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test // XOR OP
+ public void testXOR_1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("60FF60FF18"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000000";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // XOR OP
+ public void testXOR_2() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("600F60F018"), invoke);
+ String expected = "00000000000000000000000000000000000000000000000000000000000000FF";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+
+ @Test(expected = RuntimeException.class) // XOR OP mal data
+ public void testXOR_3() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("60C018"), invoke);
+ try {
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test // BYTE OP
+ public void testBYTE_1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("65AABBCCDDEEFF601E1A"), invoke);
+ String expected = "00000000000000000000000000000000000000000000000000000000000000EE";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // BYTE OP
+ public void testBYTE_2() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("65AABBCCDDEEFF60201A"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000000";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // BYTE OP
+ public void testBYTE_3() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("65AABBCCDDEE3A601F1A"), invoke);
+ String expected = "000000000000000000000000000000000000000000000000000000000000003A";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+
+ @Test(expected = StackTooSmallException.class) // BYTE OP mal data
+ public void testBYTE_4() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("65AABBCCDDEE3A1A"), invoke);
+ try {
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test // ISZERO OP
+ public void testISZERO_1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("600015"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000001";
+
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // ISZERO OP
+ public void testISZERO_2() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("602A15"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000000";
+
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test(expected = StackTooSmallException.class) // ISZERO OP mal data
+ public void testISZERO_3() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("15"), invoke);
+ try {
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test // EQ OP
+ public void testEQ_1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("602A602A14"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000001";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // EQ OP
+ public void testEQ_2() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("622A3B4C622A3B4C14"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000001";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // EQ OP
+ public void testEQ_3() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("622A3B5C622A3B4C14"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000000";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test(expected = StackTooSmallException.class) // EQ OP mal data
+ public void testEQ_4() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("622A3B4C14"), invoke);
+ try {
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test // GT OP
+ public void testGT_1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("6001600211"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000001";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // GT OP
+ public void testGT_2() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("6001610F0011"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000001";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // GT OP
+ public void testGT_3() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("6301020304610F0011"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000000";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test(expected = StackTooSmallException.class) // GT OP mal data
+ public void testGT_4() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("622A3B4C11"), invoke);
+ try {
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test // SGT OP
+ public void testSGT_1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("6001600213"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000001";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // SGT OP
+ public void testSGT_2() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("7F000000000000000000000000000000000000000000000000000000000000001E" + // 30
+ "7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56" + // -170
+ "13"), invoke);
+
+ String expected = "0000000000000000000000000000000000000000000000000000000000000000";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // SGT OP
+ public void testSGT_3() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56" + // -170
+ "7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF57" + // -169
+ "13"), invoke);
+
+ String expected = "0000000000000000000000000000000000000000000000000000000000000001";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test(expected = StackTooSmallException.class) // SGT OP mal
+ public void testSGT_4() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56" + // -170
+ "13"), invoke);
+ try {
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test // LT OP
+ public void testLT_1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("6001600210"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000000";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // LT OP
+ public void testLT_2() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("6001610F0010"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000000";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // LT OP
+ public void testLT_3() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("6301020304610F0010"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000001";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test(expected = StackTooSmallException.class) // LT OP mal data
+ public void testLT_4() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("622A3B4C10"), invoke);
+ try {
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test // SLT OP
+ public void testSLT_1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("6001600212"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000000";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // SLT OP
+ public void testSLT_2() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("7F000000000000000000000000000000000000000000000000000000000000001E" + // 30
+ "7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56" + // -170
+ "12"), invoke);
+
+ String expected = "0000000000000000000000000000000000000000000000000000000000000001";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // SLT OP
+ public void testSLT_3() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56" + // -170
+ "7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF57" + // -169
+ "12"), invoke);
+
+ String expected = "0000000000000000000000000000000000000000000000000000000000000000";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test(expected = StackTooSmallException.class) // SLT OP mal
+ public void testSLT_4() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56" + // -170
+ "12"), invoke);
+ try {
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test // NOT OP
+ public void testNOT_1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("600119"), invoke);
+ String expected = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE";
+
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // NOT OP
+ public void testNOT_2() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("61A00319"), invoke);
+ String expected = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5FFC";
+
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // NOT OP
+ public void testNOT_3() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("61000019"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000000";
+
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test(expected = StackTooSmallException.class) // BNOT OP
+ public void testBNOT_4() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("1a"), invoke);
+ try {
+ vm.step(program);
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test // POP OP
+ public void testPOP_1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("61000060016200000250"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000001";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test // POP OP
+ public void testPOP_2() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("6100006001620000025050"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000000";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getStack().peek().getData()).toUpperCase());
+ }
+
+ @Test(expected = StackTooSmallException.class) // POP OP mal data
+ public void testPOP_3() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("61000060016200000250505050"), invoke);
+ try {
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test // DUP1...DUP16 OP
+ public void testDUPS() {
+ for (int i = 1; i < 17; i++) {
+ testDUPN_1(i);
+ }
+ }
+
+ /**
+ * Generic test function for DUP1-16
+ *
+ * @param n in DUPn
+ */
+ private void testDUPN_1(int n) {
+
+ VM vm = new VM();
+ byte operation = (byte) (OpCode.DUP1.val() + n - 1);
+ String programCode = "";
+ for (int i = 0; i < n; i++) {
+ programCode += "60" + (12 + i);
+ }
+ program = new Program(ByteUtil.appendByte(Hex.decode(programCode.getBytes()), operation), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000000012";
+ int expectedLen = n + 1;
+
+ for (int i = 0; i < expectedLen; i++) {
+ vm.step(program);
+ }
+
+ assertEquals(expectedLen, program.getStack().toArray().length);
+ assertEquals(expected, Hex.toHexString(program.stackPop().getData()).toUpperCase());
+ for (int i = 0; i < expectedLen - 2; i++) {
+ assertNotEquals(expected, Hex.toHexString(program.stackPop().getData()).toUpperCase());
+ }
+ assertEquals(expected, Hex.toHexString(program.stackPop().getData()).toUpperCase());
+ }
+
+ @Test(expected = StackTooSmallException.class) // DUPN OP mal data
+ public void testDUPN_2() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("80"), invoke);
+ try {
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test // SWAP1...SWAP16 OP
+ public void testSWAPS() {
+ for (int i = 1; i < 17; ++i) {
+ testSWAPN_1(i);
+ }
+ }
+
+ /**
+ * Generic test function for SWAP1-16
+ *
+ * @param n in SWAPn
+ */
+ private void testSWAPN_1(int n) {
+
+ VM vm = new VM();
+ byte operation = (byte) (OpCode.SWAP1.val() + n - 1);
+
+ String programCode = "";
+ String top = new DataWord(0x10 + n).toString();
+ for (int i = n; i > -1; --i) {
+ programCode += "60" + oneByteToHexString((byte) (0x10 + i));
+
+ }
+
+ programCode += Hex.toHexString(new byte[]{ (byte)(OpCode.SWAP1.val() + n - 1) });
+
+ program = new Program(ByteUtil.appendByte(Hex.decode(programCode), operation), invoke);
+
+ for (int i = 0; i < n + 2; ++i) {
+ vm.step(program);
+ }
+
+ assertEquals(n + 1, program.getStack().toArray().length);
+ assertEquals(top, Hex.toHexString(program.stackPop().getData()));
+ }
+
+ @Test(expected = StackTooSmallException.class) // SWAPN OP mal data
+ public void testSWAPN_2() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("90"), invoke);
+
+ try {
+ vm.step(program);
+ } finally {
+ assertTrue(program.isStopped());
+ }
+ }
+
+ @Test // MSTORE OP
+ public void testMSTORE_1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("611234600052"), invoke);
+ String expected = "0000000000000000000000000000000000000000000000000000000000001234";
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ assertEquals(expected, Hex.toHexString(program.getMemory()));
+ }
+
+
+ @Test // LOG0 OP
+ public void tesLog0() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("61123460005260206000A0"), invoke);
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ List logInfoList = program.getResult().getLogInfoList();
+ LogInfo logInfo = logInfoList.get(0);
+
+ assertEquals("cd2a3d9f938e13cd947ec05abc7fe734df8dd826", Hex.toHexString(logInfo.getAddress()));
+ assertEquals(0, logInfo.getTopics().size());
+ assertEquals("0000000000000000000000000000000000000000000000000000000000001234", Hex.toHexString(logInfo
+ .getData()));
+ }
+
+ @Test // LOG1 OP
+ public void tesLog1() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("61123460005261999960206000A1"), invoke);
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ List logInfoList = program.getResult().getLogInfoList();
+ LogInfo logInfo = logInfoList.get(0);
+
+ assertEquals("cd2a3d9f938e13cd947ec05abc7fe734df8dd826", Hex.toHexString(logInfo.getAddress()));
+ assertEquals(1, logInfo.getTopics().size());
+ assertEquals("0000000000000000000000000000000000000000000000000000000000001234", Hex.toHexString(logInfo
+ .getData()));
+ }
+
+ @Test // LOG2 OP
+ public void tesLog2() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("61123460005261999961666660206000A2"), invoke);
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ List logInfoList = program.getResult().getLogInfoList();
+ LogInfo logInfo = logInfoList.get(0);
+
+ assertEquals("cd2a3d9f938e13cd947ec05abc7fe734df8dd826", Hex.toHexString(logInfo.getAddress()));
+ assertEquals(2, logInfo.getTopics().size());
+ assertEquals("0000000000000000000000000000000000000000000000000000000000001234", Hex.toHexString(logInfo
+ .getData()));
+ }
+
+ @Test // LOG3 OP
+ public void tesLog3() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("61123460005261999961666661333360206000A3"), invoke);
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ List logInfoList = program.getResult().getLogInfoList();
+ LogInfo logInfo = logInfoList.get(0);
+
+ assertEquals("cd2a3d9f938e13cd947ec05abc7fe734df8dd826", Hex.toHexString(logInfo.getAddress()));
+ assertEquals(3, logInfo.getTopics().size());
+ assertEquals("0000000000000000000000000000000000000000000000000000000000001234", Hex.toHexString(logInfo
+ .getData()));
+ }
+
+
+ @Test // LOG4 OP
+ public void tesLog4() {
+
+ VM vm = new VM();
+ program = new Program(Hex.decode("61123460005261999961666661333361555560206000A4"), invoke);
+
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+ vm.step(program);
+
+ List