UTBotJava/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestInvokeInstrumentation.kt at b3cc0bf443a3b7cc40aa1b403cb4a38448adb920 · UnitTestBot/UTBotJava · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
package org.utbot.examples

import com.jetbrains.rd.util.reactive.RdFault
import org.utbot.examples.samples.ClassWithSameMethodNames
import org.utbot.examples.samples.ExampleClass
import org.utbot.examples.samples.staticenvironment.StaticExampleClass
import org.utbot.instrumentation.ConcreteExecutor
import org.utbot.instrumentation.execute
import org.utbot.instrumentation.instrumentation.InvokeInstrumentation
import org.utbot.instrumentation.util.ChildProcessError
import kotlin.reflect.full.declaredMembers
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertInstanceOf
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows

class TestInvokeInstrumentation {
    lateinit var utContext: AutoCloseable

    @Test
    fun testCatchTargetException() {
        ConcreteExecutor(
            InvokeInstrumentation(),
            ExampleClass::class.java.protectionDomain.codeSource.location.path
        ).use {

            val testObject = ExampleClass()

            val res = it.execute(ExampleClass::kek2, arrayOf(testObject, 123))

            assertTrue(res.exceptionOrNull() is ArrayIndexOutOfBoundsException)
        }
    }

    @Test
    fun testWrongArgumentsException() {
        ConcreteExecutor(
            InvokeInstrumentation(),
            ExampleClass::class.java.protectionDomain.codeSource.location.path
        ).use {
            val testObject = ExampleClass()
            val exc = assertThrows<ChildProcessError> {
                it.execute(
                    ExampleClass::bar,
                    arrayOf(testObject, 1, 2, 3)
                )
            }
            assertInstanceOf(
                RdFault::class.java,
                exc.cause!!
            )
            assertTrue((exc.cause as RdFault).reasonTypeFqn == "IllegalArgumentException")
        }
    }

    @Test
    fun testSameResult() {
        ConcreteExecutor(
            InvokeInstrumentation(),
            ExampleClass::class.java.protectionDomain.codeSource.location.path
        ).use {
            val testObject = ExampleClass()

            val res1 = it.execute(ExampleClass::dependsOnFieldReturn, arrayOf(testObject))
            assertEquals(2, res1.getOrNull())

            val res2 = it.execute(ExampleClass::dependsOnFieldReturn, arrayOf(testObject))
            assertEquals(2, res2.getOrNull())
        }
    }

    @Test
    fun testEmptyMethod() {
        ConcreteExecutor(
            InvokeInstrumentation(),
            ExampleClass::class.java.protectionDomain.codeSource.location.path
        ).use {
            val testObject = ExampleClass()

            val res = it.execute(ExampleClass::emptyMethod, arrayOf(testObject))

            assertEquals(Unit::class, res.getOrNull()!!::class)
        }
    }

    @Test
    fun testStaticMethodCall() {
        ConcreteExecutor(
            InvokeInstrumentation(),
            StaticExampleClass::class.java.protectionDomain.codeSource.location.path
        ).use {
            val res1 = it.execute(StaticExampleClass::inc, arrayOf())
            assertEquals(0, res1.getOrNull())

            val res2 = it.execute(
                StaticExampleClass::plus,
                arrayOf(5)
            )

            assertEquals(0, res2.getOrNull())
        }
    }

    @Test
    fun testNullableMethod() {
        ConcreteExecutor(
            InvokeInstrumentation(),
            StaticExampleClass::class.java.protectionDomain.codeSource.location.path
        ).use {
            val res1 = it.execute(
                StaticExampleClass::canBeNull,
                arrayOf(10,
                "123")
            )
            assertEquals("123", res1.getOrNull())

            val res2 = it.execute(
                StaticExampleClass::canBeNull,
                arrayOf(0,
                "kek")
            )

            assertEquals(null, res2.getOrNull())

            val res3 = it.execute(
                StaticExampleClass::canBeNull,
                arrayOf(1,
                null)
            )

            assertEquals(null, res3.getOrNull())
        }
    }

    @Test
    fun testDifferentSignaturesButSameMethodNames() {
        ConcreteExecutor(
            InvokeInstrumentation(),
            ClassWithSameMethodNames::class.java.protectionDomain.codeSource.location.path
        ).use {
            val clazz = ClassWithSameMethodNames::class

            val sumVararg = clazz.declaredMembers.first { it.parameters.size == 1 }
            val sum2 = clazz.declaredMembers.first { it.parameters.size == 2 }
            val sum3 = clazz.declaredMembers.first { it.parameters.size == 3 }

            val resVararg = it.execute(sumVararg, arrayOf(intArrayOf(1, 2, 3, 4, 5)))
            assertEquals(Result.success(15), resVararg)

            val resSum2 = it.execute(sum2, arrayOf(1, 5))
            assertEquals(Result.success(8), resSum2)

            val resSum3 = it.execute(sum3, arrayOf(1, 5, 4))
            assertEquals(Result.success(13), resSum3)
        }
    }
}