Close #8

3 files changed, 158 insertions, 27 deletions

diff --git a/src/main/kotlin/thedarkcolour/kotlinforforge/eventbus/KotlinEventBus.kt b/src/main/kotlin/thedarkcolour/kotlinforforge/eventbus/KotlinEventBus.kt
index c35c4e9..3f3fb66 100644
--- a/src/main/kotlin/thedarkcolour/kotlinforforge/eventbus/KotlinEventBus.kt
+++ b/src/main/kotlin/thedarkcolour/kotlinforforge/eventbus/KotlinEventBus.kt
@@ -18,6 +18,9 @@ import java.util.function.Consumer
 
 /** @since 1.2.0
  * Fixes [addListener] and [addGenericListener] for Kotlin KCallable.
+ *
+ * @param builder The BusBuilder used to configure this event bus
+ * @param synthetic Whether this event bus is just a wrapper for another bus
  */
 public open class KotlinEventBus(builder: BusBuilder, synthetic: Boolean = false) : IEventBus, IEventExceptionHandler {
     @Suppress("LeakingThis")
@@ -305,26 +308,24 @@ public open class KotlinEventBus(builder: BusBuilder, synthetic: Boolean = false
      */
     private fun reflectKotlinSAM(consumer: Consumer<*>): Class<*>? {
         val clazz = consumer.javaClass
+        val forgeType = TypeResolver.resolveRawArgument(Consumer::class.java, consumer.javaClass)
 
-        when {
-            clazz.simpleName.contains("$\$Lambda$") -> {
-                return TypeResolver.resolveRawArgument(Consumer::class.java, consumer.javaClass)
-            }
-            clazz.simpleName.contains("\$sam$") -> {
-                try {
-                    val functionField = clazz.getDeclaredField("function")
-                    functionField.isAccessible = true
-                    val function = functionField[consumer]
-
-                    // Function should have two type parameters (parameter type and return type)
-                    return TypeResolver.resolveRawArguments(kotlin.jvm.functions.Function1::class.java, function.javaClass)[0]
-                } catch (e: NoSuchFieldException) {
-                    // Kotlin SAM interfaces compile to classes with a "function" field
-                    LOGGER.log(Level.FATAL, "Tried to register invalid Kotlin SAM interface: Missing 'function' field")
-                    throw e
-                }
+        if (clazz.simpleName.contains("\$sam$")) {
+            try {
+                val functionField = clazz.getDeclaredField("function")
+                functionField.isAccessible = true
+                val function = functionField[consumer]
+
+                // Function should have two type parameters (parameter type and return type)
+                return TypeResolver.resolveRawArguments(kotlin.jvm.functions.Function1::class.java, function.javaClass)[0]
+            } catch (e: NoSuchFieldException) {
+                // Kotlin SAM interfaces compile to classes with a "function" field
+                LOGGER.log(Level.FATAL, "Tried to register invalid Kotlin SAM interface: Missing 'function' field")
+                throw e
             }
-            else -> return null
+        } else {
+            // Kotlin 1.4 seems to have fixed some of its lambda problems
+            return forgeType
         }
     }
 
diff --git a/src/main/kotlin/thedarkcolour/kotlinforforge/test/TestMod.kt b/src/main/kotlin/thedarkcolour/kotlinforforge/test/TestMod.kt
new file mode 100644
index 0000000..01de386
--- /dev/null
+++ b/src/main/kotlin/thedarkcolour/kotlinforforge/test/TestMod.kt
@@ -0,0 +1,128 @@
+package thedarkcolour.kotlinforforge.test
+
+import net.minecraftforge.eventbus.api.BusBuilder
+import net.minecraftforge.eventbus.api.Event
+import net.minecraftforge.eventbus.api.EventPriority
+import net.minecraftforge.eventbus.api.GenericEvent
+import org.junit.Assert.assertTrue
+import thedarkcolour.kotlinforforge.eventbus.KotlinEventBus
+import java.util.function.Consumer
+
+/**
+ * Uncomment the `@Mod` annotation and uncomment the entry in mods.toml to run the test mod
+ */
+//@Mod("test_mod")
+public class TestMod {
+
+    init {
+        val l = arrayListOf<Throwable>()
+
+        try {
+            testAddListenerBridge()
+        } catch (t: Throwable) {
+            l.add(t)
+        }
+        try {
+            testFunctionReference()
+        } catch (t: Throwable) {
+            l.add(t)
+        }
+        try {
+            testGenericListeners()
+        } catch (t: Throwable) {
+            l.add(t)
+        }
+
+        l.forEach { throwable ->
+            throwable.printStackTrace()
+        }
+
+        if (l.isNotEmpty()) {
+            throw RuntimeException("Test mod did not pass")
+        }
+    }
+
+    // Test event class
+    public open class TestEvent(public var value: String) : Event()
+
+    /**
+     * Tests the new bridge lambdas introduced in Kotlin 1.4.
+     */
+    private fun testAddListenerBridge() {
+        val bus = KotlinEventBus(BusBuilder.builder())
+
+        // Make sure the type checker works properly in Kotlin 1.4
+        bus.addListener<TestEvent> { event ->
+            event.value = "Foo"
+        }
+
+        // Check that the event posts for added listeners
+        val event = TestEvent("Bar")
+        bus.post(event)
+        assertTrue(event.value == "Foo")
+    }
+
+    // Test function for function references
+    private fun exampleFunction(event: TestEvent) {
+        event.value = "Foo"
+    }
+
+    /**
+     * Test that function references work properly in [KotlinEventBus.addListener].
+     */
+    private fun testFunctionReference() {
+        val bus = KotlinEventBus(BusBuilder.builder())
+        val event = TestEvent("Bar")
+
+        bus.addListener(::exampleFunction)
+        bus.post(event)
+        assertTrue(event.value == "Foo")
+    }
+
+    // generic event
+    public class TestGenericEvent<T>(type: Class<T>, internal var value: T) : GenericEvent<T>(type)
+
+    // test the function references here as well
+    private fun functionReference(event: TestGenericEvent<String>) {
+        event.value = "Far"
+    }
+
+    // Consumer class
+    public class EventConsumer : Consumer<TestGenericEvent<String>> {
+        override fun accept(t: TestGenericEvent<String>) {
+            t.value = "Jar"
+        }
+    }
+
+    /**
+     * Test that [KotlinEventBus.addGenericListener] respects the generic type
+     * of an event fired on the [KotlinEventBus] instance.
+     */
+    public fun testGenericListeners() {
+        // event bus
+        val bus = KotlinEventBus(BusBuilder.builder())
+
+        @Suppress("JoinDeclarationAndAssignment")
+        var fooEvent: TestGenericEvent<String>
+
+        // test fooEvent
+        fooEvent = TestGenericEvent(String::class.java, "Foo")
+        bus.addGenericListener(priority = EventPriority.HIGHEST) { e: TestGenericEvent<String> ->
+            e.value = "Bar"
+        }
+        bus.post(fooEvent)
+        assertTrue(fooEvent.value == "Bar")
+
+        // test consumer subclass
+        fooEvent = TestGenericEvent(String::class.java, "Foo")
+        bus.addGenericListener(priority = EventPriority.HIGH, EventConsumer())
+        bus.post(fooEvent)
+        assertTrue(fooEvent.value == "Jar")
+
+        // test barEvent for function references
+        fooEvent = TestGenericEvent(String::class.java, "Foo")
+        bus.addGenericListener(priority = EventPriority.NORMAL, ::functionReference)
+        bus.post(fooEvent)
+        assertTrue(fooEvent.value == "Far")
+    }
+}
\ No newline at end of file
diff --git a/src/main/resources/META-INF/mods.toml b/src/main/resources/META-INF/mods.toml
index 27b9220..e0174e8 100644
--- a/src/main/resources/META-INF/mods.toml
+++ b/src/main/resources/META-INF/mods.toml
@@ -1,13 +1,7 @@
 modLoader="kotlinforforge" # IModLanguageProvider
-loaderVersion="[1.4,)" # IModLanguageProvider version
+loaderVersion="[1.6,)" # IModLanguageProvider version
 license="GPL v3.0"
 
-issueTrackerURL="https://github.com/thedarkcolour/KotlinForForge/issues" # Issues page
-
-description='''
-Kotlin for Forge. Allows mods to use the Kotlin programming language.
-'''
-
 # A dependency - use the . to indicate dependency for a specific modid. Dependencies are optional.
 [[dependencies.kotlinforforge]] #optional
     modId="forge" #mandatory
@@ -29,9 +23,17 @@ Kotlin for Forge. Allows mods to use the Kotlin programming language.
 # --------------------------------------------------------- #
 # --------------------------------------------------------- #
 
+# UNCOMMENT THIS TO RUN TEST MOD
+# [[mods]]
+# modId="test_mod"
+
 [[mods]] #mandatory
 displayName="Kotlin for Forge" # Name of mod
 modId="kotlinforforge" # Modid
-version="1.4.0" # Version of kotlinforforge
+version="1.6.2" # Version of kotlinforforge
 authors="TheDarkColour" # Author
-credits="Herobrine knows all." # Credits
\ No newline at end of file
+credits="Herobrine knows all." # Credits
+description='''
+Kotlin for Forge. Allows mods to use the Kotlin programming language.
+'''
+issueTrackerURL="https://github.com/thedarkcolour/KotlinForForge/issues" # Issues page
\ No newline at end of file