Skip to content

Commit a21a686

Browse files
viktoriia-fominaviktoriia-fomina
authored
Add utbot-instrumentation-tests tests closes #86 (#87)
1 parent 018df4a commit a21a686

18 files changed

+2235
-0
lines changed

‎utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestConstructors.kt

Lines changed: 141 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,141 @@
1+
package org.utbot.examples
2+
3+
import org.utbot.examples.samples.ClassWithMultipleConstructors
4+
import org.utbot.examples.samples.ClassWithSameMethodNames
5+
import org.utbot.framework.plugin.api.util.signature
6+
import org.utbot.instrumentation.ConcreteExecutor
7+
import org.utbot.instrumentation.execute
8+
import org.utbot.instrumentation.instrumentation.InvokeInstrumentation
9+
import org.utbot.instrumentation.instrumentation.coverage.CoverageInstrumentation
10+
import org.utbot.instrumentation.instrumentation.coverage.collectCoverage
11+
import org.utbot.instrumentation.instrumentation.et.ExecutionTraceInstrumentation
12+
import org.utbot.instrumentation.instrumentation.et.convert
13+
import org.utbot.instrumentation.instrumentation.et.function
14+
import org.utbot.instrumentation.instrumentation.et.invoke
15+
import org.utbot.instrumentation.instrumentation.et.pass
16+
import org.utbot.instrumentation.instrumentation.et.ret
17+
import org.utbot.instrumentation.withInstrumentation
18+
import org.junit.jupiter.api.Assertions.assertEquals
19+
import org.junit.jupiter.api.Assertions.assertFalse
20+
import org.junit.jupiter.api.Assertions.assertTrue
21+
import org.junit.jupiter.api.Test
22+
23+
class TestConstructors {
24+
lateinit var utContext: AutoCloseable
25+
26+
private val CLASSPATH = ClassWithSameMethodNames::class.java.protectionDomain.codeSource.location.path
27+
28+
@Test
29+
fun testDefaultConstructor() {
30+
ConcreteExecutor(
31+
InvokeInstrumentation(),
32+
CLASSPATH
33+
).use { executor ->
34+
val constructors = ClassWithMultipleConstructors::class.constructors
35+
val constr = constructors.first { it.parameters.isEmpty() }
36+
val res = executor.execute(constr, arrayOf())
37+
val checkClass = ClassWithMultipleConstructors()
38+
assertEquals(checkClass, res.getOrNull())
39+
assertFalse(checkClass === res.getOrNull())
40+
}
41+
}
42+
43+
@Test
44+
fun testIntConstructors() {
45+
ConcreteExecutor(
46+
InvokeInstrumentation(),
47+
CLASSPATH
48+
).use { executor ->
49+
val constructors = ClassWithMultipleConstructors::class.constructors
50+
51+
val constrI = constructors.first { it.signature == "<init>(I)V" }
52+
val resI = executor.execute(constrI, arrayOf(1))
53+
assertEquals(ClassWithMultipleConstructors(1), resI.getOrNull())
54+
55+
val constrII = constructors.first { it.signature == "<init>(II)V" }
56+
val resII = executor.execute(constrII, arrayOf(1, 2))
57+
assertEquals(ClassWithMultipleConstructors(3), resII.getOrNull())
58+
59+
val constrIII = constructors.first { it.signature == "<init>(III)V" }
60+
val resIII = executor.execute(constrIII, arrayOf(1, 2, 3))
61+
assertEquals(ClassWithMultipleConstructors(6), resIII.getOrNull())
62+
}
63+
}
64+
65+
@Test
66+
fun testStringConstructors() {
67+
withInstrumentation(
68+
InvokeInstrumentation(),
69+
CLASSPATH
70+
) { executor ->
71+
val constructors = ClassWithMultipleConstructors::class.constructors
72+
73+
val constrSS = constructors.first { it.parameters.size == 2 && it.signature != "<init>(II)V" }
74+
val resSS = executor.execute(constrSS, arrayOf("100", "23"))
75+
assertEquals(ClassWithMultipleConstructors(123), resSS.getOrNull())
76+
77+
val constrS = constructors.first { it.parameters.size == 1 && it.signature != "<init>(I)V" }
78+
val resS1 = executor.execute(constrS, arrayOf("one"))
79+
assertEquals(ClassWithMultipleConstructors(1), resS1.getOrNull())
80+
81+
val resS2 = executor.execute(constrS, arrayOf("kek"))
82+
assertEquals(ClassWithMultipleConstructors(-1), resS2.getOrNull())
83+
}
84+
}
85+
86+
@Test
87+
fun testCoverageConstructor() {
88+
withInstrumentation(
89+
CoverageInstrumentation,
90+
CLASSPATH
91+
) { executor ->
92+
val constructors = ClassWithMultipleConstructors::class.constructors
93+
94+
val constrIII = constructors.first { it.signature == "<init>(III)V" }
95+
executor.execute(constrIII, arrayOf(1, 2, 3))
96+
97+
val coverage = executor.collectCoverage(ClassWithMultipleConstructors::class.java)
98+
val method2instr = coverage.methodToInstrRange
99+
assertTrue(method2instr["<init>()V"]!!.minus(coverage.visitedInstrs).isEmpty())
100+
assertTrue(method2instr["<init>(I)V"]!!.minus(coverage.visitedInstrs).isEmpty())
101+
assertTrue(method2instr["<init>(II)V"]!!.minus(coverage.visitedInstrs).isEmpty())
102+
assertTrue(method2instr["<init>(III)V"]!!.minus(coverage.visitedInstrs).toList() == (36..40).toList())
103+
}
104+
}
105+
106+
@Test
107+
fun testExecutionTraceConstructor() {
108+
withInstrumentation(
109+
ExecutionTraceInstrumentation(),
110+
CLASSPATH
111+
) { executor ->
112+
val constructors = ClassWithMultipleConstructors::class.constructors
113+
114+
val constrIII = constructors.first { it.signature == "<init>(III)V" }
115+
val trace = executor.execute(constrIII, arrayOf(1, 2, 3))
116+
117+
assertEquals(
118+
function("<init>(III)V") {
119+
pass()
120+
invoke("<init>(II)V") {
121+
pass()
122+
invoke("<init>(I)V") {
123+
pass()
124+
invoke("<init>()V") {
125+
pass()
126+
ret()
127+
}
128+
pass()
129+
ret()
130+
}
131+
pass()
132+
ret()
133+
}
134+
pass()
135+
ret()
136+
},
137+
convert(trace)
138+
)
139+
}
140+
}
141+
}

‎utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestCoverageInstrumentation.kt

Lines changed: 196 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,196 @@
1+
package org.utbot.examples
2+
3+
import org.utbot.examples.samples.ExampleClass
4+
import org.utbot.examples.statics.substitution.StaticSubstitution
5+
import org.utbot.examples.statics.substitution.StaticSubstitutionExamples
6+
import org.utbot.framework.plugin.api.util.fieldId
7+
import org.utbot.framework.plugin.api.util.signature
8+
import org.utbot.instrumentation.ConcreteExecutor
9+
import org.utbot.instrumentation.execute
10+
import org.utbot.instrumentation.instrumentation.coverage.CoverageInstrumentation
11+
import org.utbot.instrumentation.instrumentation.coverage.collectCoverage
12+
import org.utbot.instrumentation.util.ChildProcessError
13+
import org.utbot.instrumentation.util.StaticEnvironment
14+
import org.junit.jupiter.api.Assertions.assertEquals
15+
import org.junit.jupiter.api.Assertions.assertInstanceOf
16+
import org.junit.jupiter.api.Assertions.assertTrue
17+
import org.junit.jupiter.api.Test
18+
import org.junit.jupiter.api.assertThrows
19+
20+
class TestCoverageInstrumentation {
21+
lateinit var utContext: AutoCloseable
22+
23+
@Test
24+
fun testCatchTargetException() {
25+
ConcreteExecutor(
26+
CoverageInstrumentation,
27+
ExampleClass::class.java.protectionDomain.codeSource.location.path
28+
).use {
29+
val testObject = ExampleClass()
30+
31+
val res = it.execute(ExampleClass::kek2, arrayOf(testObject, 123))
32+
val coverageInfo = it.collectCoverage(ExampleClass::class.java)
33+
34+
assertEquals(5, coverageInfo.visitedInstrs.size)
35+
assertEquals(50..55, coverageInfo.methodToInstrRange[ExampleClass::kek2.signature])
36+
assertTrue(res.exceptionOrNull() is ArrayIndexOutOfBoundsException)
37+
}
38+
}
39+
40+
@Test
41+
fun testIfBranches() {
42+
ConcreteExecutor(
43+
CoverageInstrumentation,
44+
ExampleClass::class.java.protectionDomain.codeSource.location.path
45+
).use {
46+
val testObject = ExampleClass()
47+
48+
it.execute(ExampleClass::bar, arrayOf(testObject, 2))
49+
val coverageInfo1 = it.collectCoverage(ExampleClass::class.java)
50+
51+
assertEquals(21, coverageInfo1.visitedInstrs.size)
52+
assertEquals(13..49, coverageInfo1.methodToInstrRange[ExampleClass::bar.signature])
53+
54+
it.execute(ExampleClass::bar, arrayOf(testObject, 0))
55+
val coverageInfo2 = it.collectCoverage(ExampleClass::class.java)
56+
57+
assertEquals(20, coverageInfo2.visitedInstrs.size)
58+
assertEquals(13..49, coverageInfo2.methodToInstrRange[ExampleClass::bar.signature])
59+
}
60+
}
61+
62+
@Test
63+
fun testWrongArgumentsException() {
64+
ConcreteExecutor(
65+
CoverageInstrumentation,
66+
ExampleClass::class.java.protectionDomain.codeSource.location.path
67+
).use {
68+
val testObject = ExampleClass()
69+
val exc = assertThrows<ChildProcessError> {
70+
it.execute(
71+
ExampleClass::bar,
72+
arrayOf(testObject, 1, 2, 3)
73+
)
74+
}
75+
76+
assertInstanceOf(
77+
IllegalArgumentException::class.java,
78+
exc.cause!!
79+
)
80+
}
81+
}
82+
83+
84+
@Test
85+
fun testMultipleRunsInsideCoverage() {
86+
ConcreteExecutor(
87+
CoverageInstrumentation,
88+
ExampleClass::class.java.protectionDomain.codeSource.location.path
89+
).use {
90+
val testObject = ExampleClass()
91+
val exc = assertThrows<ChildProcessError> {
92+
it.execute(
93+
ExampleClass::bar,
94+
arrayOf(testObject, 1, 2, 3)
95+
)
96+
}
97+
98+
assertInstanceOf(
99+
IllegalArgumentException::class.java,
100+
exc.cause!!
101+
)
102+
103+
it.execute(ExampleClass::bar, arrayOf(testObject, 2))
104+
val coverageInfo1 = it.collectCoverage(ExampleClass::class.java)
105+
106+
assertEquals(21, coverageInfo1.visitedInstrs.size)
107+
assertEquals(13..49, coverageInfo1.methodToInstrRange[ExampleClass::bar.signature])
108+
109+
it.execute(ExampleClass::bar, arrayOf(testObject, 0))
110+
val coverageInfo2 = it.collectCoverage(ExampleClass::class.java)
111+
112+
assertEquals(20, coverageInfo2.visitedInstrs.size)
113+
assertEquals(13..49, coverageInfo2.methodToInstrRange[ExampleClass::bar.signature])
114+
}
115+
}
116+
117+
118+
@Test
119+
fun testSameResult() {
120+
ConcreteExecutor(
121+
CoverageInstrumentation,
122+
ExampleClass::class.java.protectionDomain.codeSource.location.path
123+
).use {
124+
val testObject = ExampleClass()
125+
126+
it.execute(ExampleClass::dependsOnField, arrayOf(testObject))
127+
val coverageInfo1 = it.collectCoverage(ExampleClass::class.java)
128+
129+
assertEquals(19, coverageInfo1.visitedInstrs.size)
130+
assertEquals(99..124, coverageInfo1.methodToInstrRange[ExampleClass::dependsOnField.signature])
131+
132+
it.execute(ExampleClass::dependsOnField, arrayOf(testObject))
133+
val coverageInfo2 = it.collectCoverage(ExampleClass::class.java)
134+
135+
assertEquals(19, coverageInfo2.visitedInstrs.size)
136+
assertEquals(99..124, coverageInfo2.methodToInstrRange[ExampleClass::dependsOnField.signature])
137+
}
138+
}
139+
140+
@Test
141+
fun testResult() {
142+
ConcreteExecutor(
143+
CoverageInstrumentation,
144+
ExampleClass::class.java.protectionDomain.codeSource.location.path
145+
).use {
146+
val testObject = ExampleClass()
147+
148+
val res = it.execute(ExampleClass::foo, arrayOf(testObject, 3))
149+
val coverageInfo = it.collectCoverage(ExampleClass::class.java)
150+
151+
assertEquals(1, res.getOrNull())
152+
assertEquals(35, coverageInfo.visitedInstrs.size)
153+
assertEquals(56..98, coverageInfo.methodToInstrRange[ExampleClass::foo.signature])
154+
}
155+
}
156+
157+
@Test
158+
fun testEmptyMethod() {
159+
ConcreteExecutor(
160+
CoverageInstrumentation,
161+
ExampleClass::class.java.protectionDomain.codeSource.location.path
162+
).use {
163+
val testObject = ExampleClass()
164+
165+
val res = it.execute(ExampleClass::emptyMethod, arrayOf(testObject))
166+
val coverageInfo = it.collectCoverage(ExampleClass::class.java)
167+
168+
assertEquals(Unit::class, res.getOrNull()!!::class)
169+
assertEquals(1, coverageInfo.visitedInstrs.size)
170+
}
171+
}
172+
173+
@Test
174+
fun testTernaryOperator() {
175+
ConcreteExecutor(
176+
CoverageInstrumentation,
177+
StaticSubstitutionExamples::class.java.protectionDomain.codeSource.location.path
178+
).use {
179+
val testObject = StaticSubstitutionExamples()
180+
181+
val emptyStaticEnvironment = StaticEnvironment()
182+
183+
val res1 = it.execute(StaticSubstitutionExamples::lessThanZero, arrayOf(testObject), parameters = emptyStaticEnvironment)
184+
185+
val staticEnvironment = StaticEnvironment(
186+
StaticSubstitution::mutableValue.fieldId to -1
187+
)
188+
val res2 = it.execute(StaticSubstitutionExamples::lessThanZero, arrayOf(testObject), parameters = staticEnvironment)
189+
val coverageInfo = it.collectCoverage(StaticSubstitutionExamples::class.java)
190+
191+
assertEquals(res1.getOrNull(), 5)
192+
assertEquals(res2.getOrNull(), 0)
193+
assertEquals(coverageInfo.visitedInstrs, (3..10).toList())
194+
}
195+
}
196+
}

0 commit comments

Comments
 (0)