status-im
/
ethereumj-personal
mirror of https://github.com/status-im/ethereumj-personal.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Updated tests from develop branch.

This commit is contained in:
Adrian Tiberius 2015-06-01 21:15:05 +02:00
parent 4b75601caa
commit 5f8e8fe91d
62 changed files with 22547 additions and 18007 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
ethereumj-core/src/test/java/org/ethereum/TestContext.java Normal file
View File

@ -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 id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
*/
@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;
}

88
ethereumj-core/src/test/java/org/ethereum/blockstore/InMemoryBlockStoreTest.java Normal file
View File

@ -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<String> 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<byte[]> 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);
}
}

23
ethereumj-core/src/test/java/org/ethereum/core/AccountStateTest.java Normal file
View File

@ -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()));
}
}

113
ethereumj-core/src/test/java/org/ethereum/core/BlockTest.java Normal file
View File

@ -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<AccountState> 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<String> 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()));
}
}

52
ethereumj-core/src/test/java/org/ethereum/core/BloomTest.java Normal file
View File

@ -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
}
}

93
ethereumj-core/src/test/java/org/ethereum/core/ImportTest.java Normal file
View File

@ -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<String> 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()));
}
}

70
ethereumj-core/src/test/java/org/ethereum/core/LogInfoTest.java Normal file
View File

@ -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);
}
}

126
ethereumj-core/src/test/java/org/ethereum/core/StateTest.java Normal file
View File

@ -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;
}
}

41
ethereumj-core/src/test/java/org/ethereum/core/TransactionReceiptTest.java Normal file
View File

@ -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);
}
}

304
ethereumj-core/src/test/java/org/ethereum/core/TransactionTest.java Normal file
View File

@ -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<LogInfo> logs = new ArrayList<>();
logs.add(logInfo1);
TransactionReceipt receipt = new TransactionReceipt(stateRoot, gasUsed, bloom, logs);
assertEquals(data,
Hex.toHexString(receipt.getEncoded()));
}
}

352
ethereumj-core/src/test/java/org/ethereum/crypto/CryptoTest.java Normal file
View File

@ -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));
}
}

53
ethereumj-core/src/test/java/org/ethereum/crypto/ECIESCoderTest.java Normal file
View File

@ -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));
}
}

144
ethereumj-core/src/test/java/org/ethereum/crypto/ECIESTest.java Normal file
View File

@ -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;
}
}

297
ethereumj-core/src/test/java/org/ethereum/crypto/ECKeyTest.java Normal file
View File

@ -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<ListenableFuture<ECKey.ECDSASignature>> 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<ECDSASignature>() {
@Override
public ECKey.ECDSASignature call() throws Exception {
return key.doSign(hash);
}
}));
}
List<ECKey.ECDSASignature> 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));
}
}

82
ethereumj-core/src/test/java/org/ethereum/datasource/AbstractRedisTest.java Normal file
View File

@ -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;
}
}

70
ethereumj-core/src/test/java/org/ethereum/datasource/RedisDataSourceTest.java Normal file
View File

@ -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();
}
}

130
ethereumj-core/src/test/java/org/ethereum/datasource/RedisStorageTest.java Normal file
View File

@ -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<Pojo> 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<Transaction> 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<Transaction> 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);
}
}

143
ethereumj-core/src/test/java/org/ethereum/db/ByteArrayWrapperTest.java Normal file
View File

@ -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<byte[]> 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");
}
}
}

557
ethereumj-core/src/test/java/org/ethereum/db/RepositoryTest.java Normal file
View File

@ -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));
}
}

65
ethereumj-core/src/test/java/org/ethereum/db/TrackDatabaseTest.java Normal file
View File

@ -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");
}
}
}

24
ethereumj-core/src/test/java/org/ethereum/di/components/TestEthereumComponent.java Normal file
View File

@ -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();
}

160
ethereumj-core/src/test/java/org/ethereum/di/modules/TestEthereumModule.java Normal file
View File

@ -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<PeerClient> 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<EthereumChannelInitializer> ethereumChannelInitializerProvider) {
return new PeerClient(listener, channelManager, ethereumChannelInitializerProvider);
}
@Provides
MessageQueue provideMessageQueue(EthereumListener listener) {
return new MessageQueue(listener);
}
@Provides
WorkerThread provideWorkerThread(Provider<DiscoveryChannel> discoveryChannelProvider) {
return new WorkerThread(discoveryChannelProvider);
}
@Provides
String provideRemoteId() {
return SystemProperties.CONFIG.activePeerNodeid();
}
}

112
ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubBlockTest.java Normal file
View File

@ -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<String> 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<String> 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<String> 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<String> 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<String> 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);
}
}

40
ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubCryptoTest.java Normal file
View File

@ -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<String , CryptoTestCase> testSuite =
mapper.readValue(json, type);
for (String key : testSuite.keySet()){
System.out.println("executing: " + key);
testSuite.get(key).execute();
}
}
}

237
ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubJSONTestSuite.java Normal file
View File

@ -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. <br/>
*
* @see <a href="https://github.com/ethereum/tests/">https://github.com/ethereum/tests/</a>
*/
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<TestCase> 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<String> result = runner.runTestCase(testCase);
Assert.assertTrue(result.isEmpty());
return;
}
}
}
protected static void runGitHubJsonVMTest(String json) throws ParseException {
Set<String> excluded = new HashSet<>();
runGitHubJsonVMTest(json, excluded);
}
protected static void runGitHubJsonVMTest(String json, Set<String> 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<TestCase> 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<String> 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<String> 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<String> excluded) throws ParseException, IOException {
Assume.assumeFalse("Online test is not available", json.equals(""));
BlockTestSuite testSuite = new BlockTestSuite(json);
Set<String> 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<String> 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<String> 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<String>());
}
public static void runStateTest(String jsonSuite, String testName) throws IOException {
StateTestSuite stateTestSuite = new StateTestSuite(jsonSuite);
Map<String, StateTestCase> 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<String> 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<String> excluded) throws IOException {
StateTestSuite stateTestSuite = new StateTestSuite(jsonSuite);
Map<String, StateTestCase> testCases = stateTestSuite.getTestCases();
Map<String, Boolean> summary = new HashMap<>();
for (String testCase : testCases.keySet()) {
if ( excluded.contains(testCase))
logger.info(" [X] " + testCase);
else
logger.info(" " + testCase);
}
Set<String> 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<String> 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);
}
}

176
ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubStateTest.java Normal file
View File

@ -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<String> excluded = new HashSet<>();
String json = JSONReader.loadJSONFromCommit("StateTests/stExample.json", shacommit);
GitHubJSONTestSuite.runStateTest(json, excluded);
}
@Test
public void stCallCreateCallCodeTest() throws ParseException, IOException {
Set<String> 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<String> excluded = new HashSet<>();
String json = JSONReader.loadJSONFromCommit("StateTests/stInitCodeTest.json", shacommit);
GitHubJSONTestSuite.runStateTest(json, excluded);
}
@Test
public void stLogTests() throws ParseException, IOException {
Set<String> excluded = new HashSet<>();
String json = JSONReader.loadJSONFromCommit("StateTests/stLogTests.json", shacommit);
GitHubJSONTestSuite.runStateTest(json, excluded);
}
@Test
public void stPreCompiledContracts() throws ParseException, IOException {
Set<String> excluded = new HashSet<>();
String json = JSONReader.loadJSONFromCommit("StateTests/stPreCompiledContracts.json", shacommit);
GitHubJSONTestSuite.runStateTest(json, excluded);
}
@Test
public void stMemoryStressTest() throws ParseException, IOException {
Set<String> 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<String> excluded = new HashSet<>();
GitHubJSONTestSuite.runStateTest(json, excluded);
}
@Ignore
@Test
public void stQuadraticComplexityTest() throws ParseException, IOException {
Set<String> excluded = new HashSet<>();
String json = JSONReader.loadJSONFromCommit("StateTests/stQuadraticComplexityTest.json", shacommit);
GitHubJSONTestSuite.runStateTest(json, excluded);
}
@Ignore
@Test
public void stSolidityTest() throws ParseException, IOException {
Set<String> 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<String> excluded = new HashSet<>();
String json = JSONReader.loadJSONFromCommit("StateTests/stRecursiveCreate.json", shacommit);
GitHubJSONTestSuite.runStateTest(json, excluded);
}
@Test
public void stRefundTest() throws ParseException, IOException {
Set<String> excluded = new HashSet<>();
String json = JSONReader.loadJSONFromCommit("StateTests/stRefundTest.json", shacommit);
GitHubJSONTestSuite.runStateTest(json, excluded);
}
@Test
public void stSpecialTest() throws ParseException, IOException {
Set<String> 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<String> 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<String> 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<String> fileNames = getFileNamesForTreeSha(sha);
List<String> 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);
}
}
}
}

168
ethereumj-core/src/test/java/org/ethereum/jsontestsuite/GitHubVMTest.java Normal file
View File

@ -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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> fileNames = getFileNamesForTreeSha(sha);
List<String> 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);
}
}
}

51
ethereumj-core/src/test/java/org/ethereum/net/BlockHashesMessageTest.java Normal file
View File

File diff suppressed because one or more lines are too long

52
ethereumj-core/src/test/java/org/ethereum/net/BlocksMessageTest.java Normal file
View File

@ -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<Block> 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()));
}
}

94
ethereumj-core/src/test/java/org/ethereum/net/DisconnectMessageTest.java Normal file
View File

@ -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);
}
}
}

36
ethereumj-core/src/test/java/org/ethereum/net/GetBlockHashesMessageTest.java Normal file
View File

@ -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());
}
}

41
ethereumj-core/src/test/java/org/ethereum/net/GetBlocksMessageTest.java Normal file
View File

@ -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());
}
}

94
ethereumj-core/src/test/java/org/ethereum/net/HelloMessageTest.java Normal file
View File

@ -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<Capability> 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<Capability> 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());
}
}

31
ethereumj-core/src/test/java/org/ethereum/net/NewBlockMessageTest.java Normal file
View File

@ -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);
}
}

60
ethereumj-core/src/test/java/org/ethereum/net/PeerTest.java Normal file
View File

@ -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<Capability> 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());
}
}

36
ethereumj-core/src/test/java/org/ethereum/net/PingPongMessageTest.java Normal file
View File

@ -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());
}
}

37
ethereumj-core/src/test/java/org/ethereum/net/StatusMessageTest.java Normal file
View File

@ -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()));
}
}

200
ethereumj-core/src/test/java/org/ethereum/net/TransactionsMessageTest.java Normal file
View File

@ -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<Transaction> 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<Transaction> txs = new HashSet<>(Arrays.asList(tx));
TransactionsMessage transactionsMessage = new TransactionsMessage(txs);
assertEquals(EthMessageCodes.TRANSACTIONS, transactionsMessage.getCommand());
assertEquals(expected, Hex.toHexString(transactionsMessage.getEncoded()));
}
}

44
ethereumj-core/src/test/java/org/ethereum/net/rlpx/EncryptionHandshakeTest.java Normal file
View File

@ -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);
}
}

249
ethereumj-core/src/test/java/org/ethereum/net/rlpx/RLPXTest.java Normal file
View File

@ -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<Node> 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()));
}
}

92
ethereumj-core/src/test/java/org/ethereum/net/rlpx/RlpxConnectionTest.java Normal file
View File

@ -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);
}
}

150
ethereumj-core/src/test/java/org/ethereum/net/wire/AdaptiveMessageIdsTest.java Normal file
View File

@ -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<Capability> 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<Capability> 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());
}
}

59
ethereumj-core/src/test/java/org/ethereum/serpent/MachineCompileTest.java Normal file
View File

@ -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);
}
}

1330
ethereumj-core/src/test/java/org/ethereum/serpent/SerpentCompileTest.java Normal file
View File

File diff suppressed because it is too large Load Diff

1032
ethereumj-core/src/test/java/org/ethereum/trie/TrieTest.java Normal file
View File

File diff suppressed because it is too large Load Diff

328
ethereumj-core/src/test/java/org/ethereum/util/ByteUtilTest.java Normal file
View File

@ -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<Integer> 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);
}
}

87
ethereumj-core/src/test/java/org/ethereum/util/CompactEncoderTest.java Normal file
View File

@ -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));
}
}

87
ethereumj-core/src/test/java/org/ethereum/util/HashUtilTest.java Normal file
View File

@ -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);
}
}

983
ethereumj-core/src/test/java/org/ethereum/util/RLPTest.java Normal file
View File

File diff suppressed because one or more lines are too long

59
ethereumj-core/src/test/java/org/ethereum/util/RlpTestData.java Normal file
View File

@ -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}};
}

90
ethereumj-core/src/test/java/org/ethereum/util/UtilsTest.java Normal file
View File

@ -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);
}
}

61
ethereumj-core/src/test/java/org/ethereum/util/ValueTest.java Normal file
View File

@ -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()));
}
}

322
ethereumj-core/src/test/java/org/ethereum/vm/DataWordTest.java Normal file
View File

@ -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;
}
}

424
ethereumj-core/src/test/java/org/ethereum/vm/MemoryTest.java Normal file
View File

@ -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());
}
}

100
ethereumj-core/src/test/java/org/ethereum/vm/PrecompiledContractTest.java Normal file
View File

@ -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));
}
}

336
ethereumj-core/src/test/java/org/ethereum/vm/ProgramMemoryTest.java Normal file
View File

@ -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());
}
}

664
ethereumj-core/src/test/java/org/ethereum/vm/VMComplexTest.java Normal file
View File

@ -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());
}
}

564
ethereumj-core/src/test/java/org/ethereum/vm/VMCustomTest.java Normal file
View File

@ -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
*/

2899
ethereumj-core/src/test/java/org/ethereum/vm/VMTest.java Normal file
View File

File diff suppressed because it is too large Load Diff

242
ethereumj-core/src/test/resources/blockload/scenario1.dmp
View File

File diff suppressed because one or more lines are too long

9803
ethereumj-core/src/test/resources/blockload/scenario2.dmp
View File

File diff suppressed because it is too large Load Diff

16005
ethereumj-core/src/test/resources/blockstore/load.dmp
View File

File diff suppressed because it is too large Load Diff