kaze/orx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace kluent with kotlin.test (#361)

Browse Source
This commit is contained in:
Abe Pazos
2025-07-07 16:23:15 +02:00
committed by GitHub
parent 771e348631
commit 8323054519
19 changed files with 187 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
orx-expression-evaluator/build.gradle.kts
View File

@@ -47,11 +47,6 @@ kotlin {
implementation(project(":orx-jvm:orx-gui"))
}
}
val jvmTest by getting {
dependencies {
implementation(libs.kluent)
}
}
}
}

17
orx-expression-evaluator/src/jvmTest/kotlin/TestCompiledExpression.kt
View File

@@ -1,33 +1,32 @@
import org.amshove.kluent.invoking
import org.amshove.kluent.`should throw`
import org.amshove.kluent.shouldBeEqualTo
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows
import org.openrndr.extra.expressions.ExpressionException
import org.openrndr.extra.expressions.compileExpression
import kotlin.test.assertEquals
class TestCompiledExpression {
@Test
fun `a simple compiled expression`() {
val expression = "someValue"
val function = compileExpression(expression, constants = mutableMapOf("someValue" to 5.0))
function().shouldBeEqualTo(5.0)
assertEquals(5.0, function())
}
@Test
fun `a compiled expression with updated context`() {
val expression = "someValue"
val context = mutableMapOf("someValue" to 5.0)
val context = mutableMapOf("someValue" to 5.0)
val function = compileExpression(expression, constants = context)
function().shouldBeEqualTo(5.0)
assertEquals(5.0, function())
context["someValue"] = 6.0
function().shouldBeEqualTo(6.0)
assertEquals(6.0, function())
}
@Test
fun `an erroneous compiled expression`() {
val expression = "1bork"
invoking {
assertThrows<ExpressionException> {
compileExpression(expression, constants = mutableMapOf("someValue" to 5.0))
} `should throw` ExpressionException::class
}
}
}

16
orx-expression-evaluator/src/jvmTest/kotlin/TestCompiledFunctions.kt
View File

@@ -1,29 +1,29 @@
import org.amshove.kluent.invoking
import org.amshove.kluent.`should throw`
import org.amshove.kluent.shouldBeEqualTo
import org.junit.jupiter.api.Test
import org.openrndr.extra.expressions.*
import org.openrndr.extra.expressions.compileFunction1
import org.openrndr.extra.expressions.compileFunction2
import org.openrndr.extra.expressions.compileFunction3
import kotlin.test.assertEquals
class TestCompiledFunctions {
@Test
fun `a simple compiled function1`() {
val expression = "t"
val function = compileFunction1(expression, "t")
function(-5.0).shouldBeEqualTo(-5.0)
function(5.0).shouldBeEqualTo(5.0)
assertEquals(-5.0, function(-5.0))
assertEquals(5.0, function(5.0))
}
@Test
fun `a simple compiled function2`() {
val expression = "x + y"
val function = compileFunction2(expression, "x", "y")
function(1.0, 2.0).shouldBeEqualTo(3.0)
assertEquals(3.0, function(1.0, 2.0))
}
@Test
fun `a simple compiled function3`() {
val expression = "x + y + z"
val function = compileFunction3(expression, "x", "y", "z")
function(1.0, 2.0, 3.0).shouldBeEqualTo(6.0)
assertEquals(6.0, function(1.0, 2.0, 3.0))
}
}

5
orx-expression-evaluator/src/jvmTest/kotlin/TestExpressionDelegates.kt
View File

@@ -1,6 +1,6 @@
import org.amshove.kluent.shouldBeEqualTo
import org.openrndr.extra.expressions.watchingExpression1
import kotlin.test.Test
import kotlin.test.assertEquals
class TestExpressionDelegates {
@@ -10,7 +10,6 @@ class TestExpressionDelegates {
var expression = "x * x"
val function1 by watchingExpression1(::expression, "x")
}
state.function1(5.0).shouldBeEqualTo(25.0)
assertEquals(25.0, state.function1(5.0))
}
}

32
orx-expression-evaluator/src/jvmTest/kotlin/TestExpressionErrors.kt
View File

@@ -1,45 +1,51 @@
import org.amshove.kluent.`should throw`
import org.amshove.kluent.`with message`
import org.amshove.kluent.invoking
import org.junit.jupiter.api.assertThrows
import org.openrndr.extra.expressions.ExpressionException
import org.openrndr.extra.expressions.evaluateExpression
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
class TestExpressionErrors {
@Test
fun `an expression with non-sensible writing`() {
val expression = ")("
invoking {
assertThrows<ExpressionException> {
evaluateExpression(expression)
} `should throw` ExpressionException::class
}
}
@Test
fun `an expression trying to reassign a number`() {
val expression = "3 = 5"
invoking {
assertThrows<ExpressionException> {
evaluateExpression(expression)
} `should throw` ExpressionException::class
}
}
@Test
fun `an expression that uses non-existing functions`() {
val expression = "notExisting(5)"
invoking {
val exception = assertFailsWith<ExpressionException> {
evaluateExpression(expression)
} `should throw` ExpressionException::class `with message` "error in evaluation of 'notExisting(5)': unresolved function: 'notExisting(x0)'"
}
assertEquals(
"error in evaluation of 'notExisting(5)': unresolved function: 'notExisting(x0)'",
exception.message
)
}
@Test
fun `an expression that uses non-existing variables`() {
val expression = "notExisting + 4"
invoking {
val exception = assertFailsWith<ExpressionException> {
evaluateExpression(expression)
} `should throw` ExpressionException::class `with message` "error in evaluation of 'notExisting+4': unresolved value: 'notExisting'. available values: {}"
}
assertEquals(
"error in evaluation of 'notExisting+4': unresolved value: 'notExisting'. available values: {}",
exception.message
)
}
}

126
orx-expression-evaluator/src/jvmTest/kotlin/TestExpressions.kt
View File

@@ -1,22 +1,23 @@
import org.amshove.kluent.shouldBeEqualTo
import org.amshove.kluent.shouldBeNear
import org.openrndr.extra.expressions.FunctionExtensions
import org.openrndr.extra.expressions.evaluateExpression
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertNotNull
class TestExpressions {
@Test
fun `a value reference`() {
val expression = "someValue"
val result = evaluateExpression(expression, constants= mapOf("someValue" to 5.0))
result?.shouldBeEqualTo(5.0)
val result = evaluateExpression(expression, constants = mapOf("someValue" to 5.0))
assertEquals(5.0, result)
}
@Test
fun `a backticked value reference`() {
val expression = "`some-value`"
val result = evaluateExpression(expression, constants= mapOf("some-value" to 5.0))
result?.shouldBeEqualTo(5.0)
val result = evaluateExpression(expression, constants = mapOf("some-value" to 5.0))
assertEquals(5.0, result)
}
@@ -24,111 +25,174 @@ class TestExpressions {
fun `a function call`() {
val expression = "sqrt(4.0)"
val result = evaluateExpression(expression)
result?.shouldBeNear(2.0, 10E-6)
assertNotNull(result)
assertEquals(2.0, result, 10E-6)
}
@Test
fun `a function call with the name in backticks`() {
val expression = "`sqrt`(4.0)"
val result = evaluateExpression(expression)
result?.shouldBeNear(2.0, 10E-6)
assertNotNull(result)
assertEquals(2.0, result, 10E-6)
}
@Test
fun `two function calls`() {
val expression = "sqrt(4.0) * sqrt(4.0)"
val result = evaluateExpression(expression)
result?.shouldBeNear(4.0, 10E-6)
assertNotNull(result)
assertEquals(4.0, result, 10E-6)
}
@Test
fun `two argument max function call`() {
val expression = "max(0.0, 4.0)"
val result = evaluateExpression(expression)
result?.shouldBeNear(4.0, 10E-6)
assertNotNull(result)
assertEquals(4.0, result, 10E-6)
}
@Test
fun `two argument min function call`() {
val expression = "min(8.0, 4.0)"
val result = evaluateExpression(expression)
result?.shouldBeNear(4.0, 10E-6)
assertNotNull(result)
assertEquals(4.0, result, 10E-6)
}
@Test
fun `three argument function call`() {
val expression = "mix(8.0, 4.0, 0.5)"
val result = evaluateExpression(expression)
result?.shouldBeNear(6.0, 10E-6)
assertNotNull(result)
assertEquals(6.0, result, 10E-6)
}
@Test
fun `five argument function call`() {
val expression = "map(0.0, 1.0, 0.0, 8.0, 0.5)"
val result = evaluateExpression(expression)
result?.shouldBeNear(4.0, 10E-6)
assertNotNull(result)
assertEquals(4.0, result, 10E-6)
}
@Test
fun `two argument function call, where argument order matters`() {
val expression = "pow(2.0, 3.0)"
val result = evaluateExpression(expression)
result?.shouldBeNear(8.0, 10E-6)
assertNotNull(result)
assertEquals(8.0, result, 10E-6)
}
@Test
fun `nested function call`() {
val expression = "sqrt(min(8.0, 4.0))"
val result = evaluateExpression(expression)
result?.shouldBeNear(2.0, 10E-6)
assertNotNull(result)
assertEquals(2.0, result, 10E-6)
}
@Test
fun `extension function0 call`() {
val expression = "extension()"
val result = evaluateExpression(expression, functions = FunctionExtensions(functions0 = mapOf("extension" to { 2.0 })))
result?.shouldBeNear(2.0, 10E-6)
val result = evaluateExpression(
expression,
functions = FunctionExtensions(
functions0 = mapOf("extension" to { 2.0 })
)
)
assertNotNull(result)
assertEquals(2.0, result, 10E-6)
}
@Test
fun `extension function1 call`(){
fun `extension function1 call`() {
val expression = "extension(1.0)"
val result = evaluateExpression(expression, functions = FunctionExtensions(functions1 = mapOf("extension" to { x -> x * 2.0 })))
result?.shouldBeNear(2.0, 10E-6)
val result = evaluateExpression(
expression,
functions = FunctionExtensions(
functions1 = mapOf("extension" to { x ->
x * 2.0
})
)
)
assertNotNull(result)
assertEquals(2.0, result, 10E-6)
}
@Test
fun `extension function1 call with dashed name in backticks`(){
fun `extension function1 call with dashed name in backticks`() {
val expression = "`extension-function`(1.0)"
val result = evaluateExpression(expression, functions = FunctionExtensions(functions1 = mapOf("extension-function" to { x -> x * 2.0 })))
result?.shouldBeNear(2.0, 10E-6)
val result = evaluateExpression(
expression,
functions = FunctionExtensions(
functions1 = mapOf("extension-function" to { x ->
x * 2.0
})
)
)
assertNotNull(result)
assertEquals(2.0, result, 10E-6)
}
@Test
fun `extension function2 call`() {
val expression = "extension(1.0, 1.0)"
val result = evaluateExpression(expression, functions = FunctionExtensions(functions2 = mapOf("extension" to { x, y -> x + y })))
result?.shouldBeNear(2.0, 10E-6)
val result = evaluateExpression(
expression,
functions = FunctionExtensions(
functions2 = mapOf("extension" to { x, y ->
x + y
})
)
)
assertNotNull(result)
assertEquals(2.0, result, 10E-6)
}
@Test
fun `extension function3 call`() {
val expression = "extension(1.0, 1.0, 1.0)"
val result = evaluateExpression(expression, functions = FunctionExtensions(functions3 = mapOf("extension" to { x, y, z -> x + y + z})))
result?.shouldBeNear(3.0, 10E-6)
val result = evaluateExpression(
expression,
functions = FunctionExtensions(
functions3 = mapOf("extension" to { x, y, z ->
x + y + z
})
)
)
assertNotNull(result)
assertEquals(3.0, result, 10E-6)
}
@Test
fun `extension function4 call`() {
val expression = "extension(1.0, 1.0, 1.0, 1.0)"
val result = evaluateExpression(expression, functions = FunctionExtensions(functions4 = mapOf("extension" to { x, y, z, w -> x + y + z + w})))
result?.shouldBeNear(4.0, 10E-6)
val result = evaluateExpression(
expression,
functions = FunctionExtensions(
functions4 = mapOf("extension" to { x, y, z, w ->
x + y + z + w
})
)
)
assertNotNull(result)
assertEquals(4.0, result, 10E-6)
}
@Test
fun `extension function5 call`() {
val expression = "extension(1.0, 1.0, 1.0, 1.0, 1.0)"
val result = evaluateExpression(expression, functions = FunctionExtensions(functions5 = mapOf("extension" to { x, y, z, w, u -> x + y + z + w + u})))
result?.shouldBeNear(5.0, 10E-6)
val result = evaluateExpression(
expression,
functions = FunctionExtensions(
functions5 = mapOf("extension" to { x, y, z, w, u ->
x + y + z + w + u
})
)
)
assertNotNull(result)
assertEquals(5.0, result, 10E-6)
}
}

27
orx-expression-evaluator/src/jvmTest/kotlin/TestOperators.kt
View File

@@ -1,53 +1,62 @@
import org.amshove.kluent.shouldBeNear
import org.openrndr.extra.expressions.evaluateExpression
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertNotNull
class TestOperators {
@Test
fun `an addition operation`() {
val result = evaluateExpression("1 + 2")
result?.shouldBeNear(3.0, 10E-6)
assertNotNull(result)
assertEquals(3.0, result, 10E-6)
}
@Test
fun `a subtraction operation`() {
val result = evaluateExpression("1 - 2")
result?.shouldBeNear(-1.0, 10E-6)
assertNotNull(result)
assertEquals(-1.0, result, 10E-6)
}
@Test
fun `a modulus operation`() {
val result = evaluateExpression("4 % 2")
result?.shouldBeNear(0.0, 10E-6)
assertNotNull(result)
assertEquals(0.0, result, 10E-6)
}
@Test
fun `a multiplication operation`() {
val result = evaluateExpression("4 * 2")
result?.shouldBeNear(8.0, 10E-6)
assertNotNull(result)
assertEquals(8.0, result, 10E-6)
}
@Test
fun `a division operation`() {
val result = evaluateExpression("4 / 2")
result?.shouldBeNear(2.0, 10E-6)
assertNotNull(result)
assertEquals(2.0, result, 10E-6)
}
@Test
fun `a multiplication and addition operation`() {
val result = evaluateExpression("4 * 2 + 1")
result?.shouldBeNear(9.0, 10E-6)
assertNotNull(result)
assertEquals(9.0, result, 10E-6)
}
@Test
fun `an addition and multiplication`() {
val result = evaluateExpression("4 + 2 * 3")
result?.shouldBeNear(10.0, 10E-6)
assertNotNull(result)
assertEquals(10.0, result, 10E-6)
}
@Test
fun `unary minus`() {
val result = evaluateExpression("-4.0")
result?.shouldBeNear(-4.0, 10E-6)
assertNotNull(result)
assertEquals(-4.0, result, 10E-6)
}
}