diff options
author | Felix Mulder <felix.mulder@gmail.com> | 2017-04-05 19:20:44 +0200 |
---|---|---|
committer | Felix Mulder <felix.mulder@gmail.com> | 2017-04-12 11:31:14 +0200 |
commit | 0ee99771cf12c059f79ef0b9eb7b6e2bd09da942 (patch) | |
tree | f8083d38eb4207810691ced61617deb9bc5608cd /tests/disabled | |
parent | 95732a3576feb477fda74d11907878b808c9bc66 (diff) | |
download | dotty-0ee99771cf12c059f79ef0b9eb7b6e2bd09da942.tar.gz dotty-0ee99771cf12c059f79ef0b9eb7b6e2bd09da942.tar.bz2 dotty-0ee99771cf12c059f79ef0b9eb7b6e2bd09da942.zip |
Disable scalac internals tests
Diffstat (limited to 'tests/disabled')
-rw-r--r-- | tests/disabled/scalac-dependent/WeakHashSetTest.scala | 174 | ||||
-rw-r--r-- | tests/disabled/scalac-dependent/shortClass.scala | 26 | ||||
-rw-r--r-- | tests/disabled/scalac-dependent/showraw_nosymbol.scala | 5 | ||||
-rw-r--r-- | tests/disabled/scalac-dependent/sm-interpolator.scala | 41 | ||||
-rw-r--r-- | tests/disabled/scalac-dependent/structural.scala | 25 | ||||
-rw-r--r-- | tests/disabled/scalac-dependent/t6732.scala | 12 |
6 files changed, 283 insertions, 0 deletions
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) +} |