From c175194f6481c457eb87f53e54b73f0a25b5a0d4 Mon Sep 17 00:00:00 2001 From: liukai Date: Mon, 28 Aug 2023 16:18:47 +0800 Subject: [PATCH 1/2] test(case): fix code style --- .../tron/core/db/AccountAssetStoreTest.java | 139 ++++++++++++++++++ .../org/tron/core/db/AssetIssueStoreTest.java | 91 ++++++++++++ .../tron/core/db/AssetIssueV2StoreTest.java | 92 ++++++++++++ .../org/tron/core/db/ContractStoreTest.java | 102 +++++++++++++ .../core/db/DelegatedResourceStoreTest.java | 72 +++++++++ .../org/tron/core/db/DelegationStoreTest.java | 72 +++++++++ 6 files changed, 568 insertions(+) create mode 100644 framework/src/test/java/org/tron/core/db/AccountAssetStoreTest.java create mode 100644 framework/src/test/java/org/tron/core/db/AssetIssueStoreTest.java create mode 100644 framework/src/test/java/org/tron/core/db/AssetIssueV2StoreTest.java create mode 100644 framework/src/test/java/org/tron/core/db/ContractStoreTest.java create mode 100644 framework/src/test/java/org/tron/core/db/DelegatedResourceStoreTest.java create mode 100644 framework/src/test/java/org/tron/core/db/DelegationStoreTest.java diff --git a/framework/src/test/java/org/tron/core/db/AccountAssetStoreTest.java b/framework/src/test/java/org/tron/core/db/AccountAssetStoreTest.java new file mode 100644 index 00000000000..df670fb55ad --- /dev/null +++ b/framework/src/test/java/org/tron/core/db/AccountAssetStoreTest.java @@ -0,0 +1,139 @@ +package org.tron.core.db; + +import com.google.common.primitives.Longs; +import com.google.protobuf.ByteString; + +import java.util.Map; +import javax.annotation.Resource; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.tron.common.BaseTest; +import org.tron.common.utils.ByteArray; +import org.tron.core.Constant; +import org.tron.core.Wallet; +import org.tron.core.capsule.AccountCapsule; +import org.tron.core.capsule.AssetIssueCapsule; +import org.tron.core.config.args.Args; +import org.tron.core.store.AccountAssetStore; +import org.tron.core.store.AccountStore; +import org.tron.protos.Protocol; +import org.tron.protos.contract.AssetIssueContractOuterClass; + +public class AccountAssetStoreTest extends BaseTest { + + private static final byte[] ASSET_KEY = "20000".getBytes(); + private static AccountCapsule ownerCapsule; + + private static String OWNER_ADDRESS = Wallet.getAddressPreFixString() + + "abd4b9367799eaa3197fecb144eb71de1e049abc"; + private static final long TOTAL_SUPPLY = 1000_000_000L; + private static final int TRX_NUM = 10; + private static final int NUM = 1; + private static final long START_TIME = 1; + private static final long END_TIME = 2; + private static final int VOTE_SCORE = 2; + private static final String DESCRIPTION = "TRX"; + private static final String URL = "https://tron.network"; + + @Resource + private AccountAssetStore accountAssetStore; + + @Resource + private AccountStore accountStore; + + static { + dbPath = "db_AccountAssetStore_test"; + Args.setParam( + new String[]{ + "--output-directory", dbPath, + }, + Constant.TEST_CONF + ); + } + + @Before + public void init() { + accountAssetStore.put(ASSET_KEY, Longs.toByteArray(200L)); + + ownerCapsule = + new AccountCapsule( + ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS)), + ByteString.copyFromUtf8("owner"), + Protocol.AccountType.AssetIssue); + } + + + private long createAsset(String tokenName) { + long id = chainBaseManager.getDynamicPropertiesStore().getTokenIdNum() + 1; + chainBaseManager.getDynamicPropertiesStore().saveTokenIdNum(id); + AssetIssueContractOuterClass.AssetIssueContract assetIssueContract = + AssetIssueContractOuterClass.AssetIssueContract.newBuilder() + .setOwnerAddress(ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS))) + .setName(ByteString.copyFrom(ByteArray.fromString(tokenName))) + .setId(Long.toString(id)) + .setTotalSupply(TOTAL_SUPPLY) + .setTrxNum(TRX_NUM) + .setNum(NUM) + .setStartTime(START_TIME) + .setEndTime(END_TIME) + .setVoteScore(VOTE_SCORE) + .setDescription(ByteString.copyFrom(ByteArray.fromString(DESCRIPTION))) + .setUrl(ByteString.copyFrom(ByteArray.fromString(URL))) + .build(); + AssetIssueCapsule assetIssueCapsule = new AssetIssueCapsule(assetIssueContract); + chainBaseManager.getAssetIssueV2Store() + .put(assetIssueCapsule.createDbV2Key(), assetIssueCapsule); + try { + ownerCapsule.addAssetV2(ByteArray.fromString(String.valueOf(id)), TOTAL_SUPPLY); + } catch (Exception e) { + e.printStackTrace(); + } + accountStore.put(ownerCapsule.getAddress().toByteArray(), ownerCapsule); + return id; + } + + @Test + public void testPut() { + byte[] key = "10000".getBytes(); + accountAssetStore.put(key, Longs.toByteArray(100L)); + byte[] bytes = accountAssetStore.get(key); + Assert.assertEquals(100L, Longs.fromByteArray(bytes)); + } + + @Test + public void testGet() { + byte[] bytes = accountAssetStore.get(ASSET_KEY); + Assert.assertEquals(200L, Longs.fromByteArray(bytes)); + } + + @Test + public void testGetAccountAssets() { + long assetKey = createAsset("testToken1"); + AccountCapsule accountCapsule = accountStore.get(ownerCapsule.getAddress().toByteArray()); + long assetValue = accountCapsule.getAssetV2(String.valueOf(assetKey)); + Assert.assertEquals(assetValue, TOTAL_SUPPLY); + } + + @Test + public void testGetAllAssets() { + long assetKey1 = createAsset("testToken1"); + long assetKey2 = createAsset("testToken2"); + AccountCapsule accountCapsule = accountStore.get(ownerCapsule.getAddress().toByteArray()); + + Map allAssets = accountAssetStore.getAllAssets(accountCapsule.getInstance()); + Long assetValue1 = allAssets.get(String.valueOf(assetKey1)); + Assert.assertNotNull(assetValue1); + + Long assetV1 = accountCapsule.getAssetV2(String.valueOf(assetKey1)); + Assert.assertEquals(assetValue1, assetV1); + + Long assetValue2 = allAssets.get(String.valueOf(assetKey2)); + Assert.assertNotNull(assetValue2); + + Long assetV2 = accountCapsule.getAssetV2(String.valueOf(assetKey2)); + Assert.assertEquals(assetValue1, assetV2); + } + +} diff --git a/framework/src/test/java/org/tron/core/db/AssetIssueStoreTest.java b/framework/src/test/java/org/tron/core/db/AssetIssueStoreTest.java new file mode 100644 index 00000000000..8e448c246e2 --- /dev/null +++ b/framework/src/test/java/org/tron/core/db/AssetIssueStoreTest.java @@ -0,0 +1,91 @@ +package org.tron.core.db; + +import com.google.protobuf.ByteString; +import javax.annotation.Resource; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.tron.common.BaseTest; +import org.tron.common.utils.ByteArray; +import org.tron.core.Constant; +import org.tron.core.capsule.AssetIssueCapsule; +import org.tron.core.config.args.Args; +import org.tron.core.store.AssetIssueStore; +import org.tron.protos.contract.AssetIssueContractOuterClass; + +public class AssetIssueStoreTest extends BaseTest { + + private static final String NAME = "test-asset"; + private static final long TOTAL_SUPPLY = 10000L; + private static final int TRX_NUM = 10000; + private static final int NUM = 100000; + private static final String DESCRIPTION = "myCoin"; + private static final String URL = "tron.network"; + + @Resource + private AssetIssueStore assetIssueStore; + + static { + dbPath = "db_AssetIssueStoreTest_test"; + Args.setParam( + new String[]{ + "--output-directory", dbPath, + }, + Constant.TEST_CONF + ); + } + + @Before + public void init() { + long id = dbManager.getDynamicPropertiesStore().getTokenIdNum() + 1; + AssetIssueCapsule assetIssueCapsule = createAssetIssue(id, NAME); + assetIssueStore.put(assetIssueCapsule.createDbKey(), assetIssueCapsule); + } + + private AssetIssueCapsule createAssetIssue(long id, String name) { + dbManager.getDynamicPropertiesStore().saveTokenIdNum(id); + AssetIssueContractOuterClass.AssetIssueContract assetIssueContract = + AssetIssueContractOuterClass.AssetIssueContract.newBuilder() + .setName(ByteString.copyFrom(ByteArray.fromString(name))).setId(Long.toString(id)) + .setTotalSupply(TOTAL_SUPPLY) + .setTrxNum(TRX_NUM).setNum(NUM).setStartTime(1).setEndTime(100).setVoteScore(2) + .setDescription(ByteString.copyFrom(ByteArray.fromString(DESCRIPTION))) + .setUrl(ByteString.copyFrom(ByteArray.fromString(URL))).build(); + AssetIssueCapsule assetIssueCapsule = new AssetIssueCapsule(assetIssueContract); + return assetIssueCapsule; + } + + @Test + public void testPut() { + long id = dbManager.getDynamicPropertiesStore().getTokenIdNum() + 1; + String issueName = "test-asset2"; + AssetIssueCapsule assetIssueCapsule = createAssetIssue(id, issueName); + assetIssueStore.put(assetIssueCapsule.createDbKey(), assetIssueCapsule); + AssetIssueCapsule assetIssueCapsule1 = assetIssueStore.get(ByteArray.fromString(issueName)); + + Assert.assertNotNull(assetIssueCapsule1); + Assert.assertEquals(issueName, new String(assetIssueCapsule1.getName().toByteArray())); + } + + @Test + public void testGet() { + AssetIssueCapsule assetIssueCapsule = assetIssueStore.get(ByteArray.fromString(NAME)); + Assert.assertNotNull(assetIssueCapsule); + Assert.assertEquals(NAME, new String(assetIssueCapsule.getName().toByteArray())); + Assert.assertEquals(TOTAL_SUPPLY, assetIssueCapsule.getInstance().getTotalSupply()); + } + + @Test + public void testDelete() { + long id = dbManager.getDynamicPropertiesStore().getTokenIdNum() + 1; + String issueName = "test-asset-delete"; + AssetIssueCapsule assetIssueCapsule = createAssetIssue(id, issueName); + assetIssueStore.put(assetIssueCapsule.createDbKey(), assetIssueCapsule); + AssetIssueCapsule assetIssueCapsule1 = assetIssueStore.get(ByteArray.fromString(issueName)); + Assert.assertNotNull(assetIssueCapsule1); + assetIssueStore.delete(assetIssueCapsule1.createDbKey()); + AssetIssueCapsule assetIssueCapsule2 = assetIssueStore.get(ByteArray.fromString(issueName)); + Assert.assertNull(assetIssueCapsule2); + + } +} diff --git a/framework/src/test/java/org/tron/core/db/AssetIssueV2StoreTest.java b/framework/src/test/java/org/tron/core/db/AssetIssueV2StoreTest.java new file mode 100644 index 00000000000..c24706fcc40 --- /dev/null +++ b/framework/src/test/java/org/tron/core/db/AssetIssueV2StoreTest.java @@ -0,0 +1,92 @@ +package org.tron.core.db; + +import com.google.protobuf.ByteString; +import javax.annotation.Resource; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.tron.common.BaseTest; +import org.tron.core.Constant; +import org.tron.core.capsule.AssetIssueCapsule; +import org.tron.core.config.args.Args; +import org.tron.core.store.AssetIssueV2Store; +import org.tron.protos.contract.AssetIssueContractOuterClass; + + +public class AssetIssueV2StoreTest extends BaseTest { + + static { + dbPath = "db_AssetIssueV2StoreTest_test"; + Args.setParam( + new String[]{ + "--output-directory", dbPath, + }, + Constant.TEST_CONF + ); + } + + private AssetIssueCapsule assetIssueCapsule; + + @Resource + private AssetIssueV2Store assetIssueV2Store; + + @Before + public void init() { + String firstTokenId = "abc"; + assetIssueCapsule = + new AssetIssueCapsule( + AssetIssueContractOuterClass.AssetIssueContract.newBuilder() + .setName(ByteString.copyFrom(firstTokenId.getBytes())) + .build()); + assetIssueCapsule.setId(String.valueOf(1L)); + assetIssueV2Store + .put(assetIssueCapsule.createDbV2Key(), assetIssueCapsule); + } + + @Test + public void testPut() { + String firstTokenId = "efg"; + assetIssueCapsule = + new AssetIssueCapsule( + AssetIssueContractOuterClass.AssetIssueContract.newBuilder() + .setName(ByteString.copyFrom(firstTokenId.getBytes())) + .build()); + assetIssueCapsule.setId(String.valueOf(2L)); + assetIssueV2Store + .put(assetIssueCapsule.createDbV2Key(), assetIssueCapsule); + AssetIssueCapsule assetIssueCapsule = + assetIssueV2Store.get(this.assetIssueCapsule.createDbV2Key()); + Assert.assertNotNull(assetIssueCapsule); + String assetName = new String(assetIssueCapsule.getName().toByteArray()); + Assert.assertEquals(firstTokenId, assetName); + } + + @Test + public void testGet() { + AssetIssueCapsule assetIssueCapsule1 = assetIssueV2Store.get(assetIssueCapsule.createDbV2Key()); + Assert.assertNotNull(assetIssueCapsule1); + String assetName = new String(assetIssueCapsule1.getName().toByteArray()); + Assert.assertEquals("abc", assetName); + } + + @Test + public void testDelete() { + String firstTokenId = "hij"; + assetIssueCapsule = + new AssetIssueCapsule( + AssetIssueContractOuterClass.AssetIssueContract.newBuilder() + .setName(ByteString.copyFrom(firstTokenId.getBytes())) + .build()); + assetIssueCapsule.setId(String.valueOf(2L)); + assetIssueV2Store + .put(assetIssueCapsule.createDbV2Key(), assetIssueCapsule); + AssetIssueCapsule assetIssueCapsule = + assetIssueV2Store.get(this.assetIssueCapsule.createDbV2Key()); + Assert.assertNotNull(assetIssueCapsule); + + assetIssueV2Store.delete(assetIssueCapsule.createDbV2Key()); + AssetIssueCapsule assetIssueCapsule1 = + assetIssueV2Store.get(this.assetIssueCapsule.createDbV2Key()); + Assert.assertNull(assetIssueCapsule1); + } +} diff --git a/framework/src/test/java/org/tron/core/db/ContractStoreTest.java b/framework/src/test/java/org/tron/core/db/ContractStoreTest.java new file mode 100644 index 00000000000..6b461c02bfe --- /dev/null +++ b/framework/src/test/java/org/tron/core/db/ContractStoreTest.java @@ -0,0 +1,102 @@ +package org.tron.core.db; + +import com.google.protobuf.ByteString; +import javax.annotation.Resource; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.tron.common.BaseTest; +import org.tron.common.utils.ByteArray; +import org.tron.core.Constant; +import org.tron.core.Wallet; +import org.tron.core.capsule.ContractCapsule; +import org.tron.core.config.args.Args; +import org.tron.core.store.ContractStore; +import org.tron.protos.contract.SmartContractOuterClass; + +public class ContractStoreTest extends BaseTest { + + private static final String SMART_CONTRACT_NAME = "smart_contract_test"; + private static final String CONTRACT_ADDRESS = "111111"; + private static final long SOURCE_ENERGY_LIMIT = 10L; + private static String OWNER_ADDRESS; + + static { + dbPath = "db_ContractStoreTest_test"; + Args.setParam( + new String[]{ + "--output-directory", dbPath, + }, + Constant.TEST_CONF + ); + } + + @Resource + private ContractStore contractStore; + + @Before + public void init() { + SmartContractOuterClass.SmartContract.Builder contract = + createContract(CONTRACT_ADDRESS, SMART_CONTRACT_NAME); + contractStore.put( + ByteArray.fromHexString(CONTRACT_ADDRESS), + new ContractCapsule(contract.build())); + } + + private SmartContractOuterClass.SmartContract.Builder createContract( + String contractAddress, String contractName) { + OWNER_ADDRESS = + Wallet.getAddressPreFixString() + "abd4b9367799eaa3197fecb144eb71de1e049abc"; + SmartContractOuterClass.SmartContract.Builder builder = + SmartContractOuterClass.SmartContract.newBuilder(); + builder.setName(contractName); + builder.setOriginAddress(ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS))); + builder.setContractAddress(ByteString.copyFrom(ByteArray.fromHexString(contractAddress))); + builder.setOriginEnergyLimit(SOURCE_ENERGY_LIMIT); + return builder; + } + + @Test + public void testGet() { + ContractCapsule contractCapsule = contractStore.get(ByteArray.fromHexString(CONTRACT_ADDRESS)); + byte[] originAddressByte = contractCapsule.getOriginAddress(); + String address = ByteArray.toHexString(originAddressByte); + Assert.assertEquals(OWNER_ADDRESS, address); + } + + @Test + public void testPut() { + String contractAddress = "22222222"; + String contractName = "test_contract_name"; + SmartContractOuterClass.SmartContract.Builder contract = + createContract(contractAddress, contractName); + + contractStore.put( + ByteArray.fromHexString(contractAddress), + new ContractCapsule(contract.build())); + + ContractCapsule contractCapsule = contractStore.get(ByteArray.fromHexString(contractAddress)); + Assert.assertNotNull(contractCapsule); + String name = contractCapsule.getInstance().getName(); + Assert.assertEquals(contractName, name); + } + + @Test + public void testDelete() { + String contractAddress = "3333333"; + String contractName = "test_contract_name3333"; + SmartContractOuterClass.SmartContract.Builder contract = + createContract(contractAddress, contractName); + contractStore.put( + ByteArray.fromHexString(contractAddress), + new ContractCapsule(contract.build())); + ContractCapsule contractCapsule = contractStore.get(ByteArray.fromHexString(contractAddress)); + Assert.assertNotNull(contractCapsule); + String name = contractCapsule.getInstance().getName(); + Assert.assertEquals(contractName, name); + + contractStore.delete(ByteArray.fromHexString(contractAddress)); + ContractCapsule contractCapsule2 = contractStore.get(ByteArray.fromHexString(contractAddress)); + Assert.assertNull(contractCapsule2); + } +} diff --git a/framework/src/test/java/org/tron/core/db/DelegatedResourceStoreTest.java b/framework/src/test/java/org/tron/core/db/DelegatedResourceStoreTest.java new file mode 100644 index 00000000000..e10838b12dd --- /dev/null +++ b/framework/src/test/java/org/tron/core/db/DelegatedResourceStoreTest.java @@ -0,0 +1,72 @@ +package org.tron.core.db; + +import com.google.protobuf.ByteString; +import javax.annotation.Resource; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.tron.common.BaseTest; +import org.tron.common.utils.ByteArray; +import org.tron.core.Constant; +import org.tron.core.capsule.DelegatedResourceCapsule; +import org.tron.core.config.args.Args; +import org.tron.core.store.DelegatedResourceStore; + +public class DelegatedResourceStoreTest extends BaseTest { + private static final long BALANCE = 1_000_000; + private static final long EXPIRE_TIME = 1000L; + private static final String OWNER_ADDRESS = "111111111111"; + private static final String RECEIVER_ADDRESS = "222222222222"; + private static DelegatedResourceCapsule delegatedResourceCapsule; + + @Resource + private DelegatedResourceStore delegatedResourceStore; + + static { + dbPath = "db_DelegatedResourceStore_test"; + Args.setParam( + new String[]{ + "--output-directory", dbPath, + }, + Constant.TEST_CONF + ); + } + + @Before + public void init() { + delegatedResourceCapsule = create(OWNER_ADDRESS); + delegatedResourceStore.put(delegatedResourceCapsule.createDbKey(), + delegatedResourceCapsule); + } + + @Test + public void testGet() { + DelegatedResourceCapsule delegatedResource = delegatedResourceStore + .get(delegatedResourceCapsule.createDbKey()); + Assert.assertNotNull(delegatedResource); + Assert.assertEquals(delegatedResourceCapsule.getFrom(), delegatedResource.getFrom()); + } + + @Test + public void testPut() { + DelegatedResourceCapsule delegatedResourceCapsule = create("333333333333"); + byte[] key = delegatedResourceCapsule.createDbKey(); + delegatedResourceStore.put(key, delegatedResourceCapsule); + + DelegatedResourceCapsule delegatedResourceCapsule1 = delegatedResourceStore.get(key); + Assert.assertNotNull(delegatedResourceCapsule1); + Assert.assertEquals(BALANCE, delegatedResourceCapsule1.getFrozenBalanceForEnergy()); + } + + public DelegatedResourceCapsule create(String address) { + byte[] ownerAddress = ByteArray.fromHexString(address); + byte[] receiverAddress = ByteArray.fromHexString(RECEIVER_ADDRESS); + DelegatedResourceCapsule delegatedResourceCapsule = new DelegatedResourceCapsule( + ByteString.copyFrom(ownerAddress), + ByteString.copyFrom(receiverAddress)); + + delegatedResourceCapsule.setFrozenBalanceForEnergy(BALANCE, EXPIRE_TIME); + return delegatedResourceCapsule; + } + +} diff --git a/framework/src/test/java/org/tron/core/db/DelegationStoreTest.java b/framework/src/test/java/org/tron/core/db/DelegationStoreTest.java new file mode 100644 index 00000000000..1bfbbb33660 --- /dev/null +++ b/framework/src/test/java/org/tron/core/db/DelegationStoreTest.java @@ -0,0 +1,72 @@ +package org.tron.core.db; + +import javax.annotation.Resource; +import org.bouncycastle.util.encoders.Hex; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.tron.common.BaseTest; +import org.tron.common.utils.ByteArray; +import org.tron.core.Constant; +import org.tron.core.capsule.BytesCapsule; +import org.tron.core.config.args.Args; +import org.tron.core.store.DelegationStore; + + +public class DelegationStoreTest extends BaseTest { + + private static final String OWNER_ADDRESS = "11111111111"; + private static final long CYCLE = 100; + private static final long VALUE = 10_000_000; + + @Resource + private DelegationStore delegationStore; + + static { + dbPath = "db_DelegationStore_test"; + Args.setParam( + new String[]{ + "--output-directory", dbPath, + }, + Constant.TEST_CONF + ); + } + + @Before + public void init() { + create(); + } + + public void create() { + byte[] key = buildRewardKey(CYCLE, ByteArray.fromHexString(OWNER_ADDRESS)); + delegationStore.put(key, new BytesCapsule(ByteArray + .fromLong(VALUE))); + } + + private byte[] buildRewardKey(long cycle, byte[] address) { + return (cycle + "-" + Hex.toHexString(address) + "-reward").getBytes(); + } + + @Test + public void testGet() { + byte[] key = buildRewardKey(CYCLE, ByteArray.fromHexString(OWNER_ADDRESS)); + BytesCapsule bytesCapsule = delegationStore.get(key); + Assert.assertNotNull(bytesCapsule); + long actualValue = ByteArray.toLong(bytesCapsule.getData()); + Assert.assertEquals(VALUE, actualValue); + } + + @Test + public void testPut() { + long value = 20_000_000; + byte[] key = buildRewardKey(CYCLE, ByteArray.fromHexString("2222222222222")); + delegationStore.put(key, new BytesCapsule(ByteArray + .fromLong(20_000_000))); + + BytesCapsule bytesCapsule = delegationStore.get(key); + Assert.assertNotNull(bytesCapsule); + long actualValue = ByteArray.toLong(bytesCapsule.getData()); + Assert.assertEquals(value, actualValue); + } + +} From 17558c54ed1891cd293fdf17858ddcd2d96db2a9 Mon Sep 17 00:00:00 2001 From: liukai Date: Thu, 7 Sep 2023 21:32:02 +0800 Subject: [PATCH 2/2] test(case): add WitnessScheduleStoreTest test case --- .../core/db/WitnessScheduleStoreTest.java | 106 ++++++++++++++++++ 1 file changed, 106 insertions(+) create mode 100644 framework/src/test/java/org/tron/core/db/WitnessScheduleStoreTest.java diff --git a/framework/src/test/java/org/tron/core/db/WitnessScheduleStoreTest.java b/framework/src/test/java/org/tron/core/db/WitnessScheduleStoreTest.java new file mode 100644 index 00000000000..c12e5fdc413 --- /dev/null +++ b/framework/src/test/java/org/tron/core/db/WitnessScheduleStoreTest.java @@ -0,0 +1,106 @@ +package org.tron.core.db; + +import com.google.protobuf.ByteString; +import java.util.Arrays; +import java.util.List; +import javax.annotation.Resource; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.tron.common.BaseTest; +import org.tron.common.utils.ByteArray; +import org.tron.core.Constant; +import org.tron.core.config.args.Args; +import org.tron.core.store.WitnessScheduleStore; + +public class WitnessScheduleStoreTest extends BaseTest { + + @Resource + private WitnessScheduleStore witnessScheduleStore; + private static final String KEY1 = "41f08012b4881c320eb40b80f1228731898824e09d"; + private static final String KEY2 = "41df309fef25b311e7895562bd9e11aab2a58816d2"; + private static final String KEY3 = "41F8C7ACC4C08CF36CA08FC2A61B1F5A7C8DEA7BEC"; + + private static final String CURRENT_KEY1 = "411D7ABA13EA199A63D1647E58E39C16A9BB9DA689"; + private static final String CURRENT_KEY2 = "410694981B116304ED21E05896FB16A6BC2E91C92C"; + private static final String CURRENT_KEY3 = "411155D10415FAC16A8F4CB2F382CE0E0F0A7E64CC"; + + private static List witnessAddresses; + private static List currentShuffledWitnesses; + + + static { + dbPath = "output-WitnessScheduleStore-test"; + Args.setParam(new String[]{"-d", dbPath}, Constant.TEST_CONF); + } + + @Before + public void init() { + witnessAddresses = Arrays.asList( + getByteString(KEY1), + getByteString(KEY2), + getByteString(KEY3) + ); + + currentShuffledWitnesses = Arrays.asList( + getByteString(CURRENT_KEY1), + getByteString(CURRENT_KEY2), + getByteString(CURRENT_KEY3) + ); + } + + private ByteString getByteString(String address) { + return ByteString.copyFrom( + ByteArray.fromHexString(address)); + } + + @Test + public void tetSaveActiveWitnesses() { + witnessScheduleStore.saveActiveWitnesses(witnessAddresses); + List activeWitnesses = witnessScheduleStore.getActiveWitnesses(); + Assert.assertNotNull(activeWitnesses); + Assert.assertEquals(3, activeWitnesses.size()); + ByteString firstWitness = activeWitnesses.get(0); + Assert.assertEquals(getByteString(KEY1), firstWitness); + } + + @Test + public void testGetActiveWitnesses() { + witnessScheduleStore.saveActiveWitnesses(witnessAddresses); + List activeWitnesses = witnessScheduleStore.getActiveWitnesses(); + Assert.assertNotNull(activeWitnesses); + Assert.assertEquals(3, activeWitnesses.size()); + ByteString firstWitness = activeWitnesses.get(0); + ByteString secondWitness = activeWitnesses.get(1); + ByteString thirdWitness = activeWitnesses.get(2); + Assert.assertEquals(getByteString(KEY1), firstWitness); + Assert.assertEquals(getByteString(KEY2), secondWitness); + Assert.assertEquals(getByteString(KEY3), thirdWitness); + } + + @Test + public void testSaveCurrentShuffledWitnesses() { + witnessScheduleStore.saveCurrentShuffledWitnesses(currentShuffledWitnesses); + List currentWitnesses = witnessScheduleStore.getCurrentShuffledWitnesses(); + Assert.assertNotNull(currentWitnesses); + Assert.assertEquals(3, currentWitnesses.size()); + ByteString firstWitness = currentWitnesses.get(0); + Assert.assertEquals(getByteString(CURRENT_KEY1), firstWitness); + } + + @Test + public void GetCurrentShuffledWitnesses() { + witnessScheduleStore.saveCurrentShuffledWitnesses(currentShuffledWitnesses); + List currentWitnesses = witnessScheduleStore.getCurrentShuffledWitnesses(); + Assert.assertNotNull(currentWitnesses); + Assert.assertEquals(3, currentWitnesses.size()); + ByteString firstWitness = currentWitnesses.get(0); + ByteString secondWitness = currentWitnesses.get(1); + ByteString thirdWitness = currentWitnesses.get(2); + Assert.assertEquals(getByteString(CURRENT_KEY1), firstWitness); + Assert.assertEquals(getByteString(CURRENT_KEY2), secondWitness); + Assert.assertEquals(getByteString(CURRENT_KEY3), thirdWitness); + } + +}