Add IDE tests

Author: nicolasstucki

.drone.yml

@@ -36,11 +36,18 @@ pipeline:
       - cp -R . /tmp/3/ && cd /tmp/3/
       - ./project/scripts/sbt dotty-optimised/test
 
-  test_sbt:
+  test_ide:
     group: test
     image: lampepfl/dotty:2018-01-17
     commands:
       - cp -R . /tmp/4/ && cd /tmp/4/
+      - ./project/scripts/sbt dotty-language-server/test:run
+
+  test_sbt:
+    group: test
+    image: lampepfl/dotty:2017-11-17
+    commands:
+      - cp -R . /tmp/5/ && cd /tmp/5/
       - ./project/scripts/sbt sbt-dotty/scripted
     when:
       # sbt scripted tests are slow and don't run on PRs

compiler/src/dotty/tools/dotc/util/DiffUtil.scala

@@ -59,6 +59,13 @@ object DiffUtil {
     (fnd, exp, totalChange.toDouble / (expected.length + found.length))
   }
 
+  def mkColoredLineDiff(expected: Seq[String], actual: Seq[String]): String = {
+    val expectedSize = DiffUtil.EOF.length max expected.map(_.length).max
+    actual.padTo(expected.length, "").zip(expected.padTo(actual.length, "")).map { case (act, exp) =>
+      mkColoredLineDiff(exp, act, expectedSize)
+    }.mkString("\n")
+  }
+
   def mkColoredLineDiff(expected: String, actual: String, expectedSize: Int): String = {
     lazy val diff = {
       val tokens = splitTokens(expected, Nil).toArray

compiler/test/dotty/tools/vulpix/ParallelTesting.scala

@@ -613,10 +613,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
 
           if (outputLines.length != checkLines.length || !linesMatch) {
             // Print diff to files and summary:
-            val expectedSize = DiffUtil.EOF.length max checkLines.map(_.length).max
-            val diff = outputLines.padTo(checkLines.length, "").zip(checkLines.padTo(outputLines.length, "")).map { case (act, exp) =>
-              DiffUtil.mkColoredLineDiff(exp, act, expectedSize)
-            }.mkString("\n")
+            val diff = DiffUtil.mkColoredLineDiff(checkLines, outputLines)
 
             val msg =
               s"""|Output from '$sourceTitle' did not match check file.

language-server/test/dotty/tools/languageserver/CompletionTest.scala

@@ -0,0 +1,13 @@
+package dotty.tools.languageserver
+
+import org.junit.Test
+
+import dotty.tools.languageserver.util.Code._
+
+class CompletionTest {
+
+  @Test def competion0: Unit = {
+    code"class Foo { val xyz: Int = 0; def y: Int = xy$m1 }".withSource
+      .completion(m1, List(("xyz", "Field", "Int")))
+  }
+}

language-server/test/dotty/tools/languageserver/DefinitionTest.scala

@@ -0,0 +1,39 @@
+package dotty.tools.languageserver
+
+import org.junit.Test
+
+import dotty.tools.languageserver.util.Code._
+
+class DefinitionTest {
+
+  @Test def classDefinitionNotFound0: Unit =
+    code"class Foo { new ${m1}Bar$m2 }".withSource.definition(m1 to m2, None)
+
+  @Test def classDefinition0: Unit = {
+    withSources(
+      code"class ${m1}Foo$m2 { new Foo }",
+      code"class Bar { val foo: ${m3}Foo$m4 = new ${m5}Foo$m6 }"
+    ) .definition(m1 to m2, Some(m1 to m2))
+      .definition(m3 to m4, Some(m1 to m2))
+      .definition(m5 to m6, Some(m1 to m2))
+  }
+
+  @Test def valDefinition0: Unit = {
+    withSources(
+      code"class Foo { val ${m1}x$m2 = 0; ${m3}x$m4 }",
+      code"class Bar { val foo = new Foo; foo.${m5}x$m6 }"
+    ) .definition(m1 to m2, Some(m1 to m2))
+      .definition(m3 to m4, Some(m1 to m2))
+      .definition(m5 to m6, Some(m1 to m2))
+  }
+
+  @Test def defDefinition0: Unit = {
+    withSources(
+      code"class Foo { def ${m1}x$m2 = 0; ${m3}x$m4 }",
+      code"class Bar { val foo = new Foo; foo.${m5}x$m6 }"
+    ) .definition(m1 to m2, Some(m1 to m2))
+      .definition(m3 to m4, Some(m1 to m2))
+      .definition(m5 to m6, Some(m1 to m2))
+  }
+
+}

language-server/test/dotty/tools/languageserver/DocumentSymbolTest.scala

@@ -0,0 +1,23 @@
+package dotty.tools.languageserver
+
+import org.junit.Test
+
+import dotty.tools.languageserver.util.Code._
+
+class DocumentSymbolTest {
+
+  @Test def documentSymbol0: Unit =
+    code"class ${m1}Foo$m2".withSource.documentSymbol(m1, (m1 to m2).symInfo("Foo", "Class"))
+
+  @Test def documentSymbol1: Unit =
+    code"class ${m1}Foo$m2; class ${m3}Bar$m4".withSource
+      .documentSymbol(m1, (m1 to m2).symInfo("Foo", "Class"), (m3 to m4).symInfo("Bar", "Class"))
+
+  @Test def documentSymbol3: Unit = {
+    withSources(
+      code"class ${m1}Foo$m2",
+      code"class ${m3}Bar$m4"
+    ) .documentSymbol(m1, (m1 to m2).symInfo("Foo", "Class"))
+      .documentSymbol(m3, (m3 to m4).symInfo("Bar", "Class"))
+  }
+}

language-server/test/dotty/tools/languageserver/HighlightTest.scala

@@ -0,0 +1,22 @@
+package dotty.tools.languageserver
+
+import org.junit.Test
+
+import dotty.tools.languageserver.util.Code._
+
+class HighlightTest {
+
+  @Test def valHighlight0: Unit = {
+    val xDef = (m1 to m2).withCode("x")
+    code"class X { val $xDef = 9 }".withSource
+      .highlight(xDef.range, (xDef.range, "Read"))
+  }
+
+  @Test def valHighlight1: Unit = {
+    val xDef = (m1 to m2).withCode("x")
+    val xRef = (m3 to m4).withCode("x")
+    code"class X { val $xDef = 9; $xRef}".withSource
+      .highlight(xRef.range, (xDef.range, "Read"), (xRef.range, "Read"))
+  }
+
+}

language-server/test/dotty/tools/languageserver/HoverTest.scala

@@ -0,0 +1,74 @@
+package dotty.tools.languageserver
+
+import org.junit.Test
+
+import dotty.tools.languageserver.util.Code._
+
+class HoverTest {
+
+  @Test def hoverOnWhiteSpace0: Unit =
+    code"$m1 $m2".withSource.hover(m1 to m2, "")
+
+  @Test def hoverOnClass0: Unit = {
+    code"""$m1 ${m2}class Foo $m3 $m4""".withSource
+      .hover(m1 to m2, "")
+      .hover(m2 to m3, "Foo")
+      .hover(m3 to m4, "")
+  }
+
+  @Test def hoverOnClass1: Unit = {
+    code"""$m1 ${m2}class Foo { } $m3 $m4""".withSource
+      .hover(m1 to m2, "")
+      .hover(m2 to m3, "Foo")
+      .hover(m3 to m4, "")
+  }
+
+  @Test def hoverOnValDef0: Unit = {
+    code"""class Foo {
+          |  ${m1}val x = ${m2}8$m3; ${m4}x$m5
+          |}""".withSource
+      .hover(m1 to m2, "Int")
+      .hover(m2 to m3, "Int(8)")
+      .hover(m4 to m5, "Int")
+  }
+
+  @Test def hoverOnValDef1: Unit = {
+    code"""class Foo {
+          |  ${m1}final val x = 8$m2; ${m3}x$m4
+          |}""".withSource
+      .hover(m1 to m2, "Int(8)")
+      .hover(m3 to m4, "Int(8)")
+  }
+
+  @Test def hoverOnDefDef0: Unit = {
+    code"""class Foo {
+          |  ${m1}def x = ${m2}8$m3; ${m4}x$m5
+          |}""".withSource
+      .hover(m1 to m2, "Int")
+      .hover(m2 to m3, "Int(8)")
+      .hover(m4 to m5, "Int")
+  }
+
+  @Test def hoverMissingRef0: Unit = {
+    code"""class Foo {
+          |  ${m1}x$m2
+          |}""".withSource
+      .hover(m1 to m2, "<error not found: x>")
+  }
+
+  @Test def hoverFun0: Unit = {
+    code"""class Foo {
+          |  def x: String = $m1"abc"$m2
+          |  ${m3}x$m4
+          |
+          |  def y(): Int = 9
+          |  ${m5}y($m6)$m7
+          |}
+        """.withSource
+      .hover(m1 to m2, "String(\"abc\")")
+      .hover(m3 to m4, "String")
+      .hover(m5 to m6, "(): Int")
+      .hover(m6 to m7, "Int")
+  }
+
+}

language-server/test/dotty/tools/languageserver/Main.scala

@@ -0,0 +1,63 @@
+package dotty.tools.languageserver
+
+import org.junit.Test
+
+import java.lang.reflect.InvocationTargetException
+
+// TODO remove this and use JUnit to run the tests
+object Main {
+  def main(args: Array[String]): Unit = {
+    var testsFailed = 0
+    for (clazz <- testsClasses) {
+      val t0 = System.currentTimeMillis()
+      var passed = 0
+      var failed = 0
+      println(s"Starting tests in ${clazz.getSimpleName}")
+      for (method <- clazz.getMethods.sortBy(_.getName)) {
+        if (method.getAnnotation(classOf[Test]) ne null) {
+          print(s"Testing $clazz.${method.getName} ")
+          try {
+            method.invoke(clazz.getConstructor().newInstance())
+            println(Console.GREEN + "passed" + Console.RESET)
+            passed += 1
+          } catch {
+            case ex: InvocationTargetException =>
+              ex.getCause match {
+                case ex1: AssertionError =>
+                  println(Console.RED + "failed" + Console.RESET)
+                  System.err.println(s"${method.getName} failed with")
+                  ex1.printStackTrace()
+                  failed += 1
+                case _ => throw ex.getCause
+              }
+          }
+        }
+      }
+
+      val time = (System.currentTimeMillis() - t0).toDouble / 1000
+
+      if (failed == 0) {
+        println(s"${Console.GREEN}Passed all $passed tests${Console.RESET} in ${time}s")
+      } else {
+        testsFailed += 1
+        System.err.println(s"Passed $passed, ${Console.RED}failed $failed${Console.RESET}, total ${passed + failed} in ${time}s")
+      }
+      println()
+    }
+    if (testsFailed != 0) {
+      System.err.println(s"Failed $testsFailed tests")
+      System.exit(1)
+    }
+  }
+
+  private def testsClasses = List(
+    classOf[HighlightTest],
+    classOf[CompletionTest],
+    classOf[DefinitionTest],
+    classOf[HoverTest],
+    classOf[ReferencesTest],
+    classOf[RenameTest],
+    classOf[DocumentSymbolTest],
+    classOf[SymbolTest],
+  )
+}

language-server/test/dotty/tools/languageserver/ReferencesTest.scala

@@ -0,0 +1,22 @@
+package dotty.tools.languageserver
+
+import org.junit.Test
+
+import dotty.tools.languageserver.util.Code._
+
+class ReferencesTest {
+
+  @Test def valNoReferences0: Unit =
+    code"class X { val ${m1}x$m2 = 9 }".withSource.references(m1 to m2, Nil)
+
+  @Test def valReferences0: Unit = {
+    code"class X { val ${m1}x$m2 = 9; ${m3}x$m4; ${m5}x$m6 }".withSource
+      .references(m1 to m2, List(m3 to m4, m5 to m6))
+  }
+
+  @Test def valReferences1: Unit = {
+    code"class X { val ${m1}x$m2 = 9; ${m3}x$m4; ${m5}x$m6 }".withSource
+      .references(m1 to m2, List(m1 to m2, m3 to m4, m5 to m6), withDecl = true)
+  }
+
+}

language-server/test/dotty/tools/languageserver/RenameTest.scala

@@ -0,0 +1,30 @@
+package dotty.tools.languageserver
+
+import org.junit.Test
+
+import dotty.tools.languageserver.util.Code._
+import dotty.tools.languageserver.util.embedded.CodeMarker
+
+class RenameTest {
+
+  @Test def rename0: Unit = {
+    def testRenameFrom(m: CodeMarker) =
+      code"class ${m1}Foo$m2 { new ${m3}Foo$m4 }".withSource.rename(m, "Bar", List(m1 to m2, m3 to m4))
+    testRenameFrom(m1)
+    testRenameFrom(m3)
+  }
+
+
+  @Test def rename1: Unit = {
+    def testRenameFrom(m: CodeMarker) =
+      withSources(
+        code"class ${m1}Foo$m2 { new ${m3}Foo$m4 }",
+        code"class Bar { new ${m5}Foo$m6 }"
+      ).rename(m, "Bar", List(m1 to m2, m3 to m4, m5 to m6))
+
+    testRenameFrom(m1)
+    testRenameFrom(m3)
+    testRenameFrom(m5)
+  }
+
+}

language-server/test/dotty/tools/languageserver/SymbolTest.scala

@@ -0,0 +1,27 @@
+package dotty.tools.languageserver
+
+import org.junit.Test
+
+import dotty.tools.languageserver.util.Code._
+
+class SymbolTest {
+
+//  @Test def symbol0: Unit =
+//    code"class ${m1}Foo$m2".withSource.symbol("Foo", ("Foo", "Class", m1 to m2))
+
+  @Test def symbol1: Unit = {
+    val Foo = (m1 to m2).withCode("Foo")
+    val Bar = (m3 to m4).withCode("Bar")
+    val fooFoo = (m5 to m6).withCode("Foo")
+    withSources(
+      code"class $Foo",
+      code"class $Bar",
+      code"""package foo
+            |class $fooFoo {
+            |  class Bar
+            |}
+          """
+    ) .symbol("Foo", Foo.range.symInfo("Foo", "Class"), fooFoo.range.symInfo("Foo", "Class", "foo"))
+      .symbol("Bar", Bar.range.symInfo("Bar", "Class"))
+  }
+}