7 files changed, 366 insertions, 0 deletions
diff --git a/tests/disabled/run/t5293.scala b/tests/disabled/run/t5293.scala
new file mode 100644
index 000000000..8a99989c5
--- /dev/null
+++ b/tests/disabled/run/t5293.scala
@@ -0,0 +1,83 @@
+
+
+
+import scala.collection.JavaConverters._
+
+
+
+object Test extends dotty.runtime.LegacyApp {
+
+  def bench(label: String)(body: => Unit): Long = {
+    val start = System.nanoTime
+
+    0.until(10).foreach(_ => body)
+
+    val end = System.nanoTime
+
+    //println("%s: %s ms".format(label, (end - start) / 1000.0 / 1000.0))
+
+    end - start
+  }
+
+  def benchJava(values: java.util.Collection[Int]) = {
+    bench("Java Set") {
+      val set = new java.util.HashSet[Int]
+
+      set.addAll(values)
+    }
+  }
+
+  def benchScala(values: Iterable[Int]) = {
+    bench("Scala Set") {
+      val set = new scala.collection.mutable.HashSet[Int]
+
+      set ++= values
+    }
+  }
+
+  def benchScalaSorted(values: Iterable[Int]) = {
+    bench("Scala Set sorted") {
+      val set = new scala.collection.mutable.HashSet[Int]
+
+      set ++= values.toArray.sorted
+    }
+  }
+
+  def benchScalaPar(values: Iterable[Int]) = {
+    bench("Scala ParSet") {
+      val set = new scala.collection.parallel.mutable.ParHashSet[Int] map { x => x }
+
+      set ++= values
+    }
+  }
+
+  val values = 0 until 50000
+  val set = scala.collection.mutable.HashSet.empty[Int]
+
+  set ++= values
+
+  // warmup
+  for (x <- 0 until 5) {
+    benchJava(set.asJava)
+    benchScala(set)
+    benchScalaPar(set)
+    benchJava(set.asJava)
+    benchScala(set)
+    benchScalaPar(set)
+  }
+
+  val javaset = benchJava(set.asJava)
+  val scalaset = benchScala(set)
+  val scalaparset = benchScalaPar(set)
+
+  assert(scalaset < (javaset * 8), "scalaset: " + scalaset + " vs. javaset: " + javaset)
+  assert(scalaparset < (javaset * 8), "scalaparset: " + scalaparset + " vs. javaset: " + javaset)
+}
+
+
+
+
+
+
+
+
diff --git a/tests/disabled/scalac-dependent/WeakHashSetTest.scala b/tests/disabled/scalac-dependent/WeakHashSetTest.scala
new file mode 100644
index 000000000..8bcb95091
--- /dev/null
+++ b/tests/disabled/scalac-dependent/WeakHashSetTest.scala
@@ -0,0 +1,174 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    val test = scala.reflect.internal.util.WeakHashSetTest
+    test.checkEmpty
+    test.checkPlusEquals
+    test.checkPlusEqualsCollisions
+    test.checkRehashing
+    test.checkRehashCollisions
+    test.checkFindOrUpdate
+    test.checkMinusEquals
+    test.checkMinusEqualsCollisions
+    test.checkClear
+    test.checkIterator
+    test.checkIteratorCollisions
+
+    // This test is commented out because it relies on gc behavior which isn't reliable enough in an automated environment
+    // test.checkRemoveUnreferencedObjects
+  }
+}
+
+// put the main test object in the same package as WeakHashSet because
+// it uses the package private "diagnostics" method
+package scala.reflect.internal.util {
+
+  object WeakHashSetTest {
+    // a class guaranteed to provide hash collisions
+    case class Collider(x : String) extends Comparable[Collider] with Serializable {
+      override def hashCode = 0
+      def compareTo(y : Collider) = this.x compareTo y.x
+    }
+
+    // basic emptiness check
+    def checkEmpty: Unit = {
+      val hs = new WeakHashSet[String]()
+      assert(hs.size == 0)
+      hs.diagnostics.fullyValidate
+    }
+
+    // make sure += works
+    def checkPlusEquals: Unit = {
+      val hs = new WeakHashSet[String]()
+      val elements = List("hello", "goodbye")
+      elements foreach (hs += _)
+      assert(hs.size == 2)
+      assert(hs contains "hello")
+      assert(hs contains "goodbye")
+      hs.diagnostics.fullyValidate
+    }
+
+    // make sure += works when there are collisions
+    def checkPlusEqualsCollisions: Unit = {
+      val hs = new WeakHashSet[Collider]()
+      val elements = List("hello", "goodbye") map Collider
+      elements foreach (hs += _)
+      assert(hs.size == 2)
+      assert(hs contains Collider("hello"))
+      assert(hs contains Collider("goodbye"))
+      hs.diagnostics.fullyValidate
+    }
+
+    // add a large number of elements to force rehashing and then validate
+    def checkRehashing: Unit = {
+      val size = 200
+      val hs = new WeakHashSet[String]()
+      val elements = (0 until size).toList map ("a" + _)
+      elements foreach (hs += _)
+      elements foreach {i => assert(hs contains i)}
+      hs.diagnostics.fullyValidate
+    }
+
+    // make sure rehashing works properly when the set is rehashed
+    def checkRehashCollisions: Unit = {
+      val size = 200
+      val hs = new WeakHashSet[Collider]()
+      val elements = (0 until size).toList map {x => Collider("a" + x)}
+      elements foreach (hs += _)
+      elements foreach {i => assert(hs contains i)}
+      hs.diagnostics.fullyValidate
+    }
+
+    // test that unreferenced objects are removed
+    // not run in an automated environment because gc behavior can't be relied on
+    def checkRemoveUnreferencedObjects: Unit = {
+      val size = 200
+      val hs = new WeakHashSet[Collider]()
+      val elements = (0 until size).toList map {x => Collider("a" + x)}
+      elements foreach (hs += _)
+      // don't throw the following into a retained collection so gc
+      // can remove them
+      for (i <- 0 until size) {
+        hs += Collider("b" + i)
+      }
+      System.gc()
+      Thread.sleep(1000)
+      assert(hs.size == 200)
+      elements foreach {i => assert(hs contains i)}
+      for (i <- 0 until size) {
+        assert(!(hs contains Collider("b" + i)))
+      }
+      hs.diagnostics.fullyValidate
+    }
+
+    // make sure findOrUpdate returns the originally entered element
+    def checkFindOrUpdate: Unit = {
+      val size = 200
+      val hs = new WeakHashSet[Collider]()
+      val elements = (0 until size).toList map {x => Collider("a" + x)}
+      elements foreach {x => assert(hs findEntryOrUpdate x eq x)}
+      for (i <- 0 until size) {
+        // when we do a lookup the result should be the same reference we
+        // original put in
+        assert(hs findEntryOrUpdate(Collider("a" + i)) eq elements(i))
+      }
+      hs.diagnostics.fullyValidate
+    }
+
+    // check -= functionality
+    def checkMinusEquals: Unit = {
+      val hs = new WeakHashSet[String]()
+      val elements = List("hello", "goodbye")
+      elements foreach (hs += _)
+      hs -= "goodbye"
+      assert(hs.size == 1)
+      assert(hs contains "hello")
+      assert(!(hs contains "goodbye"))
+      hs.diagnostics.fullyValidate
+    }
+
+    // check -= when there are collisions
+    def checkMinusEqualsCollisions: Unit = {
+      val hs = new WeakHashSet[Collider]
+      val elements = List(Collider("hello"), Collider("goodbye"))
+      elements foreach (hs += _)
+      hs -= Collider("goodbye")
+      assert(hs.size == 1)
+      assert(hs contains Collider("hello"))
+      assert(!(hs contains Collider("goodbye")))
+      hs -= Collider("hello")
+      assert(hs.size == 0)
+      assert(!(hs contains Collider("hello")))
+      hs.diagnostics.fullyValidate
+    }
+
+    // check that the clear method actually cleans everything
+    def checkClear: Unit = {
+      val size = 200
+      val hs = new WeakHashSet[String]()
+      val elements = (0 until size).toList map ("a" + _)
+      elements foreach (hs += _)
+      hs.clear()
+      assert(hs.size == 0)
+      elements foreach {i => assert(!(hs contains i))}
+      hs.diagnostics.fullyValidate
+    }
+
+    // check that the iterator covers all the contents
+    def checkIterator: Unit = {
+      val hs = new WeakHashSet[String]()
+      val elements = (0 until 20).toList map ("a" + _)
+      elements foreach (hs += _)
+      assert(elements.iterator.toList.sorted == elements.sorted)
+      hs.diagnostics.fullyValidate
+    }
+
+    // check that the iterator covers all the contents even when there is a collision
+    def checkIteratorCollisions: Unit = {
+      val hs = new WeakHashSet[Collider]
+      val elements = (0 until 20).toList map {x => Collider("a" + x)}
+      elements foreach (hs += _)
+      assert(elements.iterator.toList.sorted == elements.sorted)
+      hs.diagnostics.fullyValidate
+    }
+  }
+}
diff --git a/tests/disabled/scalac-dependent/shortClass.scala b/tests/disabled/scalac-dependent/shortClass.scala
new file mode 100644
index 000000000..c5c2043f4
--- /dev/null
+++ b/tests/disabled/scalac-dependent/shortClass.scala
@@ -0,0 +1,26 @@
+import scala.reflect.internal.util._
+
+package bippity {
+  trait DingDongBippy
+
+  package bop {
+    class Foo {
+      class Bar
+      object Bar
+    }
+  }
+}
+
+object Test {
+  import bippity._
+  import bop._
+
+  def printSanitized(x: String) = println(x.filterNot(_.isDigit))
+
+  def main(args: Array[String]): Unit = {
+    val f = new Foo
+    val instances = List(f, new f.Bar, f.Bar, new Foo with DingDongBippy, new f.Bar with DingDongBippy)
+    instances map (_.getClass.getName) foreach printSanitized
+    instances map shortClassOfInstance foreach printSanitized
+  }
+}
diff --git a/tests/disabled/scalac-dependent/showraw_nosymbol.scala b/tests/disabled/scalac-dependent/showraw_nosymbol.scala
new file mode 100644
index 000000000..191647583
--- /dev/null
+++ b/tests/disabled/scalac-dependent/showraw_nosymbol.scala
@@ -0,0 +1,5 @@
+import scala.reflect.runtime.universe._
+
+object Test extends dotty.runtime.LegacyApp {
+  println(showRaw(NoSymbol))
+}
diff --git a/tests/disabled/scalac-dependent/sm-interpolator.scala b/tests/disabled/scalac-dependent/sm-interpolator.scala
new file mode 100644
index 000000000..e4bec7afb
--- /dev/null
+++ b/tests/disabled/scalac-dependent/sm-interpolator.scala
@@ -0,0 +1,41 @@
+object Test extends dotty.runtime.LegacyApp {
+  import scala.reflect.internal.util.StringContextStripMarginOps
+  def check(actual: Any, expected: Any) = if (actual != expected) sys.error(s"\nexpected:\n$expected\n\nactual:\n$actual")
+
+  val bar = "|\n ||"
+
+  check(
+    sm"""|ab
+         |de
+         |${bar} | ${1}""",
+      "ab\nde\n|\n || | 1")
+
+  check(
+    sm"|",
+      "")
+
+  check(
+    sm"${0}",
+      "0")
+
+  check(
+    sm"${0}",
+    "0")
+
+  check(
+    sm"""${0}|${1}
+     |""",
+      "0|1\n")
+
+  check(
+    sm"""   ||""",
+      "|")
+
+  check(
+    sm""" ${" "} ||""",
+      "   ||")
+
+  check(
+      sm"\n",
+     raw"\n".stripMargin)
+}
diff --git a/tests/disabled/scalac-dependent/structural.scala b/tests/disabled/scalac-dependent/structural.scala
new file mode 100644
index 000000000..0f18f4579
--- /dev/null
+++ b/tests/disabled/scalac-dependent/structural.scala
@@ -0,0 +1,25 @@
+case class Record(elems: (String, Any)*) extends Selectable {
+  def selectDynamic(name: String): Any = elems.find(_._1 == name).get._2
+}
+
+object Test {
+  import scala.reflect.Selectable.reflectiveSelectable
+
+  def f(closeable: { def close(): Unit }) =
+    closeable.close()
+
+  type RN = Record { val name: String; val age: Int }
+
+  def g(r: RN) = r.name
+
+  val rr: RN = Record("name" -> "Bob", "age" -> 42).asInstanceOf[RN]
+
+  def main(args: Array[String]): Unit = {
+    f(new java.io.PrintStream("foo"))
+    assert(g(rr) == "Bob")
+
+    val s: { def concat(s: String): String } = "abc"
+    assert(s.concat("def") == "abcdef")
+  }
+}
+
diff --git a/tests/disabled/scalac-dependent/t6732.scala b/tests/disabled/scalac-dependent/t6732.scala
new file mode 100644
index 000000000..ff0f0494d
--- /dev/null
+++ b/tests/disabled/scalac-dependent/t6732.scala
@@ -0,0 +1,12 @@
+import scala.reflect.runtime.universe._
+import definitions._
+
+object Test extends dotty.runtime.LegacyApp {
+  def test(sym: Symbol): Unit = {
+    println(s"${showRaw(sym, printKinds = true)}: ${sym.isModule}, ${sym.isModuleClass}, ${sym.isPackage}, ${sym.isPackageClass}")
+  }
+  test(ScalaPackage)
+  test(ScalaPackageClass)
+  test(ListModule)
+  test(ListModule.moduleClass)
+}