Merge pull request #32 from fwcd/jdk11-support

Support JDK 11+

Author: fwcd

.vscode/launch.json

@@ -14,6 +14,13 @@
 			"name": "Debug KotlinDebugAdapter",
 			"projectRoot": "${workspaceFolder}/adapter",
 			"mainClass": "org.javacs.ktda.KDAMainKt"
+		},
+		{
+			"type": "kotlin",
+			"request": "launch",
+			"name": "Debug Sample Workspace",
+			"projectRoot": "${workspaceFolder}/adapter/src/test/resources/sample-workspace",
+			"mainClass": "sample.workspace.AppKt"
 		}
 	]
 }

adapter/build.gradle

@@ -29,6 +29,7 @@ dependencies {
 	// The Java Debug Interface classes (com.sun.jdi.*)
 	implementation files("${System.properties['java.home']}/../lib/tools.jar")
 	testImplementation 'junit:junit:4.12'
+	testImplementation 'org.hamcrest:hamcrest-all:1.3'
 }
 
 task fixFilePermissions(type: Exec) {

adapter/src/main/kotlin/org/javacs/ktda/jdi/launch/JDILauncher.kt

@@ -74,7 +74,8 @@ class JDILauncher(
 		?: throw KotlinDAException("Could not find an attaching connector (for a new debuggee VM)")
 
 	private fun createLaunchConnector(): LaunchingConnector = vmManager.launchingConnectors()
-		.firstOrNull() // TODO: Investigate whether this connector works fine on JDK 10+
+		// Workaround for JDK 11+ where the first launcher (RawCommandLineLauncher) does not properly support args
+		.let { it.find { it.javaClass.name == "com.sun.tools.jdi.SunCommandLineLauncher" } ?: it.firstOrNull() }
 		?: throw KotlinDAException("Could not find a launching connector (for a new debuggee VM)")
 
 	private fun sourcesRootsOf(projectRoot: Path): Set<Path> = projectRoot.resolve("src")

adapter/src/test/kotlin/org/javacs/ktda/DebugAdapterTestFixture.kt

@@ -0,0 +1,69 @@
+package org.javacs.ktda
+
+import java.nio.file.Path
+import java.nio.file.Paths
+import org.eclipse.lsp4j.debug.ConfigurationDoneArguments
+import org.eclipse.lsp4j.debug.InitializeRequestArguments
+import org.eclipse.lsp4j.debug.DisconnectArguments
+import org.eclipse.lsp4j.debug.OutputEventArguments
+import org.eclipse.lsp4j.debug.services.IDebugProtocolClient
+import org.javacs.ktda.adapter.KotlinDebugAdapter
+import org.javacs.ktda.jdi.launch.JDILauncher
+import org.junit.After
+import org.junit.Assert.assertThat
+import org.junit.Before
+import org.hamcrest.Matchers.equalTo
+
+abstract class DebugAdapterTestFixture(
+    relativeWorkspaceRoot: String,
+    private val mainClass: String
+) : IDebugProtocolClient {
+    val absoluteWorkspaceRoot: Path = Paths.get(DebugAdapterTestFixture::class.java.getResource("/Anchor.txt").toURI()).parent.resolve(relativeWorkspaceRoot)
+    lateinit var debugAdapter: KotlinDebugAdapter
+    
+    @Before fun startDebugAdapter() {
+        // Build the project first
+        val process = ProcessBuilder("./gradlew", "assemble")
+            .directory(absoluteWorkspaceRoot.toFile())
+            .inheritIO()
+            .start()
+        process.waitFor()
+        assertThat(process.exitValue(), equalTo(0))
+        
+        debugAdapter = JDILauncher()
+            .let(::KotlinDebugAdapter)
+            .also {
+                it.connect(this)
+                val configDone = it.configurationDone(ConfigurationDoneArguments())
+                it.initialize(InitializeRequestArguments().apply {
+                    adapterID = "test-debug-adapter"
+                    linesStartAt1 = true
+                    columnsStartAt1 = true
+                }).join()
+                // Slightly hacky workaround to ensure someone is
+                // waiting on the ConfigurationDoneResponse. See
+                // KotlinDebugAdapter.kt:performInitialization for
+                // details.
+                Thread {
+                    configDone.join()
+                }.start()
+            }
+    }
+    
+    fun launch() {
+        println("Launching...")
+        debugAdapter.launch(mapOf(
+            "projectRoot" to absoluteWorkspaceRoot.toString(),
+            "mainClass" to mainClass
+        )).join()
+        println("Launched")
+    }
+
+    @After fun closeDebugAdapter() {
+        debugAdapter.disconnect(DisconnectArguments()).join()
+    }
+
+    override fun output(args: OutputEventArguments) {
+        println(args.output)
+    }
+}

adapter/src/test/kotlin/org/javacs/ktda/SampleWorkspaceTest.kt

@@ -0,0 +1,84 @@
+package org.javacs.ktda
+
+import org.eclipse.lsp4j.debug.ScopesArguments
+import org.eclipse.lsp4j.debug.SetBreakpointsArguments
+import org.eclipse.lsp4j.debug.Source
+import org.eclipse.lsp4j.debug.SourceBreakpoint
+import org.eclipse.lsp4j.debug.StackFrame
+import org.eclipse.lsp4j.debug.StackTraceArguments
+import org.eclipse.lsp4j.debug.StoppedEventArguments
+import org.eclipse.lsp4j.debug.VariablesArguments
+import org.junit.Assert.assertThat
+import org.junit.Test
+import org.hamcrest.Matchers.containsInAnyOrder
+import org.hamcrest.Matchers.equalTo
+import org.hamcrest.Matchers.hasItem
+import org.hamcrest.Matchers.nullValue
+import org.hamcrest.Matchers.not
+import java.util.concurrent.CountDownLatch
+
+/**
+ * Tests a very basic debugging scenario
+ * using a sample application.
+ */
+class SampleWorkspaceTest : DebugAdapterTestFixture("sample-workspace", "sample.workspace.AppKt") {
+    private val latch = CountDownLatch(1)
+    private var asyncException: Throwable? = null
+
+    @Test fun testBreakpointsAndVariables() {
+        debugAdapter.setBreakpoints(SetBreakpointsArguments().apply {
+            source = Source().apply {
+                name = "App.kt"
+                path = absoluteWorkspaceRoot
+                    .resolve("src")
+                    .resolve("main")
+                    .resolve("kotlin")
+                    .resolve("sample")
+                    .resolve("workspace")
+                    .resolve("App.kt")
+                    .toString()
+            }
+            breakpoints = arrayOf(SourceBreakpoint().apply {
+                line = 8
+            })
+        }).join()
+
+        launch()
+        latch.await() // Wait for the breakpoint event to finish
+        asyncException?.let { throw it }
+    }
+
+    override fun stopped(args: StoppedEventArguments) {
+        try {
+            assertThat(args.reason, equalTo("breakpoint"))
+
+            // Query information about the debuggee's current state
+            val stackTrace = debugAdapter.stackTrace(StackTraceArguments().apply {
+                threadId = args.threadId
+            }).join()
+            val locals = stackTrace.stackFrames.asSequence().flatMap {
+                debugAdapter.scopes(ScopesArguments().apply {
+                    frameId = it.id
+                }).join().scopes.asSequence().flatMap {
+                    debugAdapter.variables(VariablesArguments().apply {
+                        variablesReference = it.variablesReference
+                    }).join().variables.asSequence()
+                }
+            }.toList()
+            val receiver = locals.find { it.name == "this" }
+            
+            assertThat(locals.map { Pair(it.name, it.value) }, hasItem(Pair("local", "123")))
+            assertThat(receiver, not(nullValue()))
+
+            val members = debugAdapter.variables(VariablesArguments().apply {
+                variablesReference = receiver!!.variablesReference
+            }).join().variables
+
+            assertThat(members.map { Pair(it.name, it.value) }, containsInAnyOrder(Pair("member", "\"test\"")))
+        } catch (e: Throwable) {
+            asyncException = e
+        } finally {
+            latch.countDown()
+        }
+    }
+}

adapter/src/test/resources/Anchor.txt

@@ -0,0 +1 @@
+Anchor for finding the test/resources directory.

adapter/src/test/resources/sample-workspace/.gitattributes

@@ -0,0 +1,6 @@
+#
+# https://help.github.com/articles/dealing-with-line-endings/
+#
+# These are explicitly windows files and should use crlf
+*.bat           text eol=crlf
+

adapter/src/test/resources/sample-workspace/build.gradle

@@ -0,0 +1,20 @@
+plugins {
+    id 'org.jetbrains.kotlin.jvm' version '1.3.71'
+    id 'application'
+}
+
+repositories {
+    jcenter()
+}
+
+dependencies {
+    // Align versions of all Kotlin components
+    implementation platform('org.jetbrains.kotlin:kotlin-bom')
+    // Use the Kotlin JDK 8 standard library.
+    implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'
+}
+
+application {
+    // Define the main class for the application.
+    mainClassName = 'sample.workspace.AppKt'
+}

adapter/src/test/resources/sample-workspace/gradle/wrapper/gradle-wrapper.jar

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.4.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists