Skip to content

Commit ace748c

Browse files
Benson0224Benson0224
authored
Merge pull request tronprotocol#3818 from vivian-kang/develop
Add some unit test cases
2 parents 08b19c2 + 89cbd73 commit ace748c

4 files changed

Lines changed: 304 additions & 24 deletions

File tree

‎framework/src/test/java/org/tron/core/TransactionCapsuleTest.java‎

Lines changed: 0 additions & 23 deletions
This file was deleted.

‎framework/src/test/java/org/tron/core/actuator/vm/ProgramTraceListenerTest.java‎

Lines changed: 180 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,180 @@
1+
package org.tron.core.actuator.vm;
2+
3+
import java.io.File;
4+
import java.lang.reflect.Field;
5+
import java.util.List;
6+
import java.util.Map;
7+
import lombok.extern.slf4j.Slf4j;
8+
import org.junit.AfterClass;
9+
import org.junit.Assert;
10+
import org.junit.BeforeClass;
11+
import org.junit.Test;
12+
import org.tron.common.runtime.vm.DataWord;
13+
import org.tron.common.utils.FileUtil;
14+
import org.tron.core.Constant;
15+
import org.tron.core.config.args.Args;
16+
import org.tron.core.db.TransactionStoreTest;
17+
import org.tron.core.vm.trace.OpActions;
18+
import org.tron.core.vm.trace.OpActions.Action;
19+
import org.tron.core.vm.trace.ProgramTraceListener;
20+
21+
@Slf4j(topic = "VM")
22+
public class ProgramTraceListenerTest {
23+
private static final String dbPath = "output_programTraceListener_test";
24+
25+
private static final int WORD_SIZE = 32;
26+
private ProgramTraceListener traceListener;
27+
private ProgramTraceListener disableTraceListener;
28+
private DataWord stackWord = new DataWord(1);
29+
private DataWord storageWordKey = new DataWord(2);
30+
private DataWord storageWordValue = new DataWord(3);
31+
32+
@BeforeClass
33+
public static void init() {
34+
Args.setParam(new String[]{"--output-directory", dbPath, "--debug"}, Constant.TEST_CONF);
35+
36+
}
37+
38+
@AfterClass
39+
public static void destroy() {
40+
Args.clearParam();
41+
FileUtil.deleteDir(new File(dbPath));
42+
}
43+
44+
private void invokeProgramTraceListener(ProgramTraceListener traceListener) {
45+
traceListener.onMemoryExtend(WORD_SIZE);
46+
traceListener.onMemoryWrite(10000, TransactionStoreTest.randomBytes(WORD_SIZE), WORD_SIZE);
47+
48+
traceListener.onStackPush(stackWord);
49+
traceListener.onStackSwap(10000, 20000);
50+
traceListener.onStackPop();
51+
52+
traceListener.onStoragePut(storageWordKey, storageWordValue);
53+
traceListener.onStorageClear();
54+
}
55+
56+
private void validateProgramTraceListener() {
57+
Field field;
58+
OpActions opActions;
59+
try {
60+
field = traceListener.getClass().getDeclaredField("actions");
61+
field.setAccessible(true);
62+
opActions = (OpActions) field.get(traceListener);
63+
List<Action> memory = opActions.getMemory();
64+
List<Action> stack = opActions.getStack();
65+
List<Action> storage = opActions.getStorage();
66+
Assert.assertEquals(2, memory.size());
67+
Assert.assertEquals(3, stack.size());
68+
Assert.assertEquals(2, storage.size());
69+
70+
Map<String, Object> params;
71+
for (Action memoryAction : memory) {
72+
73+
params = memoryAction.getParams();
74+
switch (memoryAction.getName()) {
75+
case extend:
76+
Assert.assertEquals(1, params.size());
77+
Assert.assertTrue(params.containsKey("delta"));
78+
Assert.assertEquals(Integer.toString(WORD_SIZE), params.get("delta"));
79+
break;
80+
case write:
81+
Assert.assertEquals(2, params.size());
82+
Assert.assertEquals(Integer.toString(10000), params.get("address"));
83+
break;
84+
default:
85+
break;
86+
}
87+
}
88+
for (Action stackAction : stack) {
89+
params = stackAction.getParams();
90+
switch (stackAction.getName()) {
91+
case push:
92+
Assert.assertEquals(1, params.size());
93+
Assert.assertEquals(stackWord.toString(), params.get("value"));
94+
break;
95+
case swap:
96+
Assert.assertEquals(2, params.size());
97+
Assert.assertEquals(Integer.toString(10000), params.get("from"));
98+
Assert.assertEquals(Integer.toString(20000), params.get("to"));
99+
break;
100+
case pop:
101+
Assert.assertEquals(null, params);
102+
break;
103+
default:
104+
break;
105+
}
106+
}
107+
108+
for (Action storageAction : storage) {
109+
params = storageAction.getParams();
110+
switch (storageAction.getName()) {
111+
case put:
112+
Assert.assertEquals(2, params.size());
113+
Assert.assertEquals(storageWordKey.toString(), params.get("key"));
114+
Assert.assertEquals(storageWordValue.toString(), params.get("value"));
115+
break;
116+
case clear:
117+
Assert.assertEquals(null, params);
118+
break;
119+
default:
120+
break;
121+
}
122+
}
123+
} catch (NoSuchFieldException e) {
124+
logger.info(e.getMessage());
125+
Assert.assertFalse(e instanceof NoSuchFieldException);
126+
} catch (IllegalAccessException e) {
127+
logger.info(e.getMessage());
128+
Assert.assertFalse(e instanceof IllegalAccessException);
129+
}
130+
131+
132+
traceListener.resetActions();
133+
134+
try {
135+
field = traceListener.getClass().getDeclaredField("actions");
136+
field.setAccessible(true);
137+
opActions = (OpActions) field.get(traceListener);
138+
Assert.assertEquals(0, opActions.getMemory().size());
139+
Assert.assertEquals(0, opActions.getStack().size());
140+
Assert.assertEquals(0, opActions.getStorage().size());
141+
} catch (NoSuchFieldException e) {
142+
logger.info(e.getMessage());
143+
Assert.assertFalse(e instanceof NoSuchFieldException);
144+
} catch (IllegalAccessException e) {
145+
logger.info(e.getMessage());
146+
Assert.assertFalse(e instanceof IllegalAccessException);
147+
}
148+
}
149+
150+
public void validateDisableTraceListener() {
151+
try {
152+
Field field = disableTraceListener.getClass().getDeclaredField("actions");
153+
field.setAccessible(true);
154+
OpActions opActions = (OpActions) field.get(disableTraceListener);
155+
Assert.assertEquals(0, opActions.getMemory().size());
156+
Assert.assertEquals(0, opActions.getStorage().size());
157+
Assert.assertEquals(0, opActions.getStack().size());
158+
} catch (NoSuchFieldException e) {
159+
logger.info(e.getMessage());
160+
Assert.assertFalse(e instanceof NoSuchFieldException);
161+
} catch (IllegalAccessException e) {
162+
logger.info(e.getMessage());
163+
Assert.assertFalse(e instanceof IllegalAccessException);
164+
}
165+
}
166+
167+
168+
@Test
169+
public void programTraceListenerTest() {
170+
traceListener = new ProgramTraceListener(true);
171+
disableTraceListener = new ProgramTraceListener(false);
172+
173+
invokeProgramTraceListener(traceListener);
174+
invokeProgramTraceListener(disableTraceListener);
175+
176+
validateProgramTraceListener();
177+
validateDisableTraceListener();
178+
}
179+
180+
}

‎framework/src/test/java/org/tron/core/actuator/vm/ProgramTraceTest.java‎

Lines changed: 66 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,66 @@
1+
package org.tron.core.actuator.vm;
2+
3+
import java.io.File;
4+
import java.math.BigInteger;
5+
import java.util.List;
6+
import org.junit.AfterClass;
7+
import org.junit.Assert;
8+
import org.junit.BeforeClass;
9+
import org.junit.Test;
10+
import org.tron.common.runtime.vm.DataWord;
11+
import org.tron.common.utils.FileUtil;
12+
import org.tron.core.Constant;
13+
import org.tron.core.config.args.Args;
14+
import org.tron.core.vm.OpCode;
15+
import org.tron.core.vm.trace.Op;
16+
import org.tron.core.vm.trace.OpActions;
17+
import org.tron.core.vm.trace.ProgramTrace;
18+
19+
public class ProgramTraceTest {
20+
private static final String dbPath = "output_programTrace_test";
21+
22+
@BeforeClass
23+
public static void init() {
24+
Args.setParam(new String[]{"--output-directory", dbPath, "--debug"}, Constant.TEST_CONF);
25+
}
26+
27+
@AfterClass
28+
public static void destroy() {
29+
Args.clearParam();
30+
FileUtil.deleteDir(new File(dbPath));
31+
}
32+
33+
@Test
34+
public void programTraceTest() {
35+
36+
ProgramTrace programTrace = new ProgramTrace();
37+
ProgramTrace anotherProgramTrace = new ProgramTrace();
38+
DataWord energyDataWord = new DataWord(4);
39+
OpActions opActions = new OpActions();
40+
byte addOpCode = OpCode.ADD.val();
41+
byte subOpCode = OpCode.SUB.val();
42+
programTrace.addOp(addOpCode, 2, 3, energyDataWord, opActions);
43+
anotherProgramTrace.addOp(subOpCode, 5, 6, energyDataWord, opActions);
44+
45+
programTrace.merge(anotherProgramTrace);
46+
47+
List<Op> ops = programTrace.getOps();
48+
Assert.assertFalse(ops.isEmpty());
49+
Assert.assertEquals(2, ops.size());
50+
for (Op op : ops) {
51+
if (op.getCode() == OpCode.ADD) {
52+
Assert.assertEquals(3, op.getDeep());
53+
Assert.assertEquals(2, op.getPc());
54+
Assert.assertEquals(BigInteger.valueOf(4), op.getEnergy());
55+
} else if (op.getCode() == OpCode.SUB) {
56+
Assert.assertEquals(6, op.getDeep());
57+
Assert.assertEquals(5, op.getPc());
58+
Assert.assertEquals(BigInteger.valueOf(4), op.getEnergy());
59+
} else {
60+
Assert.fail("Invalid op code");
61+
}
62+
}
63+
}
64+
65+
66+
}

‎framework/src/test/java/org/tron/core/capsule/VotesCapsuleTest.java‎

Lines changed: 58 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,64 @@
11
package org.tron.core.capsule;
22

3+
import com.google.protobuf.ByteString;
4+
import java.io.File;
5+
import java.util.ArrayList;
6+
import java.util.List;
7+
import lombok.extern.slf4j.Slf4j;
8+
import org.junit.AfterClass;
9+
import org.junit.BeforeClass;
10+
import org.junit.Test;
11+
import org.testng.Assert;
12+
import org.tron.common.utils.FileUtil;
13+
import org.tron.common.utils.StringUtil;
14+
import org.tron.core.Constant;
15+
import org.tron.core.Wallet;
16+
import org.tron.core.config.args.Args;
17+
import org.tron.core.db.TransactionStoreTest;
18+
import org.tron.protos.Protocol.Vote;
19+
20+
21+
@Slf4j
322
public class VotesCapsuleTest {
423

524
private static String dbPath = "output_votesCapsule_test";
6-
// TODO:add unittest
25+
private static final String OWNER_ADDRESS;
26+
private static List<Vote> oldVotes;
27+
28+
static {
29+
OWNER_ADDRESS = Wallet.getAddressPreFixString() + "03702350064AD5C1A8AA6B4D74B051199CFF8EA7";
30+
oldVotes = new ArrayList<Vote>();
31+
}
32+
33+
@BeforeClass
34+
public static void init() {
35+
Args.setParam(new String[]{"--output-directory", dbPath, "--debug"}, Constant.TEST_CONF);
36+
37+
}
38+
39+
@AfterClass
40+
public static void destroy() {
41+
Args.clearParam();
42+
FileUtil.deleteDir(new File(dbPath));
43+
}
44+
45+
@Test
46+
public void votesCapsuleTest() {
47+
ByteString address = StringUtil.hexString2ByteString(OWNER_ADDRESS);
48+
VotesCapsule votesCapsule = new VotesCapsule(address, oldVotes);
49+
50+
votesCapsule.addOldVotes(ByteString.copyFrom(TransactionStoreTest.randomBytes(32)), 10);
51+
votesCapsule.addOldVotes(ByteString.copyFrom(TransactionStoreTest.randomBytes(32)), 5);
52+
Assert.assertEquals(votesCapsule.getOldVotes().size(), 2);
53+
54+
votesCapsule.addNewVotes(ByteString.copyFrom(TransactionStoreTest.randomBytes(32)), 6);
55+
Assert.assertEquals(votesCapsule.getNewVotes().size(), 1);
56+
57+
votesCapsule.clearNewVotes();
58+
Assert.assertTrue(votesCapsule.getNewVotes().isEmpty());
59+
60+
votesCapsule.clearOldVotes();
61+
Assert.assertTrue(votesCapsule.getOldVotes().isEmpty());
62+
63+
}
764
}

0 commit comments

Comments
 (0)