Evgeny Gerashchenko
147 lines
3.5 KiB
Kotlin
147 lines
3.5 KiB
Kotlin
package kotlinhack.test
|
|
|
|
import junit.framework.*
|
|
|
|
import kotlin.io.*
|
|
import kotlin.util.*
|
|
import java.util.*
|
|
|
|
import org.junit.*
|
|
import org.junit.runner.*
|
|
import org.junit.runner.notification.*
|
|
|
|
class TestBuilt<T>(name: String, val builder: TestBuilder<T>, val test: TestBuilt<T>.() -> Unit) : TestCase(name) {
|
|
private var myState: T? = null
|
|
|
|
var state : T
|
|
get() = myState!!
|
|
set(newState: T) { myState = newState }
|
|
|
|
override fun countTestCases(): Int = 1
|
|
|
|
override fun setUp() = this.(builder.setUp)()
|
|
|
|
override fun tearDown() = this.(builder.tearDown)()
|
|
|
|
override fun runTest() = this.(test)()
|
|
}
|
|
|
|
open class TestBuilder<T>(name: String) {
|
|
val mySuite : TestSuite = TestSuite(name)
|
|
|
|
public var setUp : TestBuilt<T>.() -> Unit = {}
|
|
|
|
public var tearDown : TestBuilt<T>.() -> Unit = {}
|
|
|
|
fun String.minus(test: TestBuilt<T>.() -> Unit) {
|
|
mySuite.addTest(TestBuilt<T>(this, this@TestBuilder, test))
|
|
}
|
|
}
|
|
|
|
private val currentTestBuilder = ThreadLocal<TestSuite> ()
|
|
|
|
private fun <T> testSuite(builder: TestBuilder<T>, description: TestBuilder<T>.() -> Unit) : TestSuite? {
|
|
val currentTestSuite = currentTestBuilder.get()
|
|
currentTestBuilder.set(builder.mySuite)
|
|
try {
|
|
builder.(description)()
|
|
return if(currentTestSuite != null) {
|
|
currentTestSuite.addTest(builder.mySuite)
|
|
null
|
|
}
|
|
else {
|
|
builder.mySuite
|
|
}
|
|
}
|
|
finally {
|
|
currentTestBuilder.set(currentTestSuite)
|
|
}
|
|
}
|
|
|
|
fun <T> testSuite(name: String, description: TestBuilder<T>.() -> Unit) : TestSuite? =
|
|
testSuite(TestBuilder<T>(name), description)
|
|
|
|
fun assertNot(message: String, block: ()-> Boolean) {
|
|
Assert.assertTrue(message, block())
|
|
}
|
|
|
|
fun assertNot(block: ()-> Boolean) = assertNot(block.toString(), block)
|
|
|
|
fun assertTrue(actual: Boolean, message: String = "") {
|
|
return assertEquals(true, actual, message)
|
|
}
|
|
|
|
fun assertFalse(actual: Boolean, message: String = "") {
|
|
return assertEquals(false, actual, message)
|
|
}
|
|
|
|
fun assertEquals(expected: Any?, actual: Any?, message: String = "") {
|
|
Assert.assertEquals(message, expected, actual)
|
|
}
|
|
|
|
fun assertNotNull(actual: Any?, message: String = "") {
|
|
Assert.assertNotNull(message, actual)
|
|
}
|
|
|
|
fun assertNull(actual: Any?, message: String = "") {
|
|
Assert.assertNull(message, actual)
|
|
}
|
|
|
|
fun fail(message: String = "") {
|
|
Assert.fail(message)
|
|
}
|
|
|
|
fun <T> expect(expected: T, block: ()-> T) {
|
|
expect(expected, block.toString(), block)
|
|
}
|
|
|
|
fun <T> expect(expected: T, message: String, block: ()-> T) {
|
|
val actual = block()
|
|
assertEquals(expected, actual, message)
|
|
}
|
|
|
|
fun fails(block: ()-> Any) {
|
|
try {
|
|
block()
|
|
Assert.fail("Expected an exception to be thrown")
|
|
} catch (e: Exception) {
|
|
println("Caught excepted exception: $e")
|
|
// OK
|
|
}
|
|
}
|
|
|
|
fun <T: Exception> failsWith(block: ()-> Any) {
|
|
try {
|
|
block()
|
|
Assert.fail("Expected an exception to be thrown")
|
|
} catch (e: T) {
|
|
println("Caught excepted exception: $e")
|
|
// OK
|
|
}
|
|
}
|
|
|
|
fun todo(block: ()-> Any) {
|
|
println("TODO at " + (Exception() as java.lang.Throwable).getStackTrace()?.get(1) + " for " + block)
|
|
}
|
|
|
|
/*
|
|
TODO we could maybe create our own test runner for JUnit
|
|
to avoid a runtime dependency on JUnit for running tests?
|
|
|
|
class KotlinTestRunner() : Runner() {
|
|
|
|
override fun getDescription(): Description? {
|
|
return null
|
|
}
|
|
|
|
override fun run(notifier: RunNotifier?) {
|
|
println("About to run a test case on ${this}")
|
|
}
|
|
}
|
|
*/
|
|
|
|
// TODO no annotations yet?
|
|
//@RunWith(KotlinTestRunner)
|
|
abstract class TestSupport() : TestCase() {
|
|
}
|