use service loading to detect the kunit asserter if its on the classpath

libraries/kotlin-jdbc/kotlin-jdbc.iml

@@ -6,6 +6,7 @@
     <content url="file://$MODULE_DIR$">
       <sourceFolder url="file://$MODULE_DIR$/src/main/kotlin" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/src/test/kotlin" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/src/main/resources" isTestSource="false" />
       <excludeFolder url="file://$MODULE_DIR$/target" />
     </content>
     <orderEntry type="inheritedJdk" />

libraries/kunit/src/main/resources/META-INF/services/kotlin.test.Asserter

@@ -0,0 +1 @@
+org.jetbrains.kotlin.test.junit.JUnitAsserter

libraries/stdlib/pom.xml

@@ -14,6 +14,12 @@
     <artifactId>stdlib</artifactId>
 
     <dependencies>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kunit</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>

libraries/stdlib/src/test/Test.kt

@@ -7,28 +7,33 @@ import java.util.ServiceLoader
 
 private var _asserter: Asserter? = null
 
-fun asserter(): Asserter {
-    if (_asserter == null) {
-        /* TODO
-        val loader = ServiceLoader.load(javaClass<Asserter>)
-        for (a in loader) {
-            if (a != null) {
-                _asserter = a
-                break
-            }
-        }
-        */
+public var asserter: Asserter
+    get() {
         if (_asserter == null) {
-            _asserter = DefaultAsserter()
+            val klass = javaClass<Asserter>()
+            val loader = ServiceLoader.load(klass)
+            for (a in loader) {
+                if (a != null) {
+                    _asserter = a
+                    break
+                }
+            }
+            if (_asserter == null) {
+                _asserter = DefaultAsserter()
+            }
+            //debug("using asserter $_asserter")
         }
+        return _asserter.sure()
+    }
+
+    set(value) {
+        _asserter = value
     }
-    return _asserter.sure()
-}
 
 /** Asserts that the given block returns true */
 inline fun assertTrue(message: String, block: ()-> Boolean) {
     val actual = block()
-    asserter().assertTrue(message, actual)
+    asserter.assertTrue(message, actual)
 }
 
 /** Asserts that the given block returns true */
@@ -54,22 +59,22 @@ inline fun assertFalse(actual: Boolean, message: String = "") {
 
 /** Asserts that the expected value is equal to the actual value, with an optional message */
 inline fun assertEquals(expected: Any?, actual: Any?, message: String = "") {
-    asserter().assertEquals(message, expected, actual)
+    asserter.assertEquals(message, expected, actual)
 }
 
 /** Asserts that the expression is not null, with an optional message */
 inline fun assertNotNull(actual: Any?, message: String = "") {
-    asserter().assertNotNull(message, actual)
+    asserter.assertNotNull(message, actual)
 }
 
 /** Asserts that the expression is null, with an optional message */
 inline fun assertNull(actual: Any?, message: String = "") {
-    asserter().assertNull(message, actual)
+    asserter.assertNull(message, actual)
 }
 
 /** Marks a test as having failed if this point in the execution path is reached, with an optional message */
 inline fun fail(message: String = "") {
-    asserter().fail(message)
+    asserter.fail(message)
 }
 
 /** Asserts that given function block returns the given expected value */
@@ -87,7 +92,7 @@ inline fun <T> expect(expected: T, message: String, block: ()-> T) {
 fun fails(block: ()-> Unit): Throwable? {
     try {
         block()
-        asserter().fail("Expected an exception to be thrown")
+        asserter.fail("Expected an exception to be thrown")
         return null
     } catch (e: Throwable) {
         println("Caught excepted exception: $e")
@@ -99,7 +104,7 @@ fun fails(block: ()-> Unit): Throwable? {
 fun <T: Throwable> failsWith(block: ()-> Unit) {
     try {
         block()
-        asserter().fail("Expected an exception to be thrown")
+        asserter.fail("Expected an exception to be thrown")
     } catch (e: T) {
         println("Caught excepted exception: $e")
         // OK