aboutsummaryrefslogtreecommitdiff
path: root/tests/run
diff options
context:
space:
mode:
Diffstat (limited to 'tests/run')
-rw-r--r--tests/run/1938-2.scala37
-rw-r--r--tests/run/WeakHashSetTest.scala174
-rw-r--r--tests/run/i2163.scala21
-rw-r--r--tests/run/shortClass.scala26
-rw-r--r--tests/run/showraw_nosymbol.scala5
-rw-r--r--tests/run/sm-interpolator.scala41
-rw-r--r--tests/run/structural.scala25
-rw-r--r--tests/run/t429.scala1
-rw-r--r--tests/run/t5293.scala83
-rw-r--r--tests/run/t5857.scala5
-rw-r--r--tests/run/t6732.scala12
-rw-r--r--tests/run/t9915/C_1.java20
-rw-r--r--tests/run/t9915/Test_2.scala12
13 files changed, 93 insertions, 369 deletions
diff --git a/tests/run/1938-2.scala b/tests/run/1938-2.scala
new file mode 100644
index 000000000..32e4c4518
--- /dev/null
+++ b/tests/run/1938-2.scala
@@ -0,0 +1,37 @@
+object ProdNonEmpty {
+ def _1: Int = 0
+ def _2: String = "???" // Slight variation with scalac: this test passes
+ // with ??? here. I think dotty behavior is fine
+ // according to the spec given that methods involved
+ // in pattern matching should be pure.
+ def isEmpty = false
+ def unapply(s: String): this.type = this
+ def get = this
+}
+
+object ProdEmpty {
+ def _1: Int = ???
+ def _2: String = ???
+ def isEmpty = true
+ def unapply(s: String): this.type = this
+ def get = this
+}
+
+object Test {
+ def main(args: Array[String]): Unit = {
+ "" match {
+ case ProdNonEmpty(0, _) => ()
+ case _ => ???
+ }
+
+ "" match {
+ case ProdNonEmpty(1, _) => ???
+ case _ => ()
+ }
+
+ "" match {
+ case ProdEmpty(_, _) => ???
+ case _ => ()
+ }
+ }
+}
diff --git a/tests/run/WeakHashSetTest.scala b/tests/run/WeakHashSetTest.scala
deleted file mode 100644
index 8bcb95091..000000000
--- a/tests/run/WeakHashSetTest.scala
+++ /dev/null
@@ -1,174 +0,0 @@
-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/run/i2163.scala b/tests/run/i2163.scala
new file mode 100644
index 000000000..952f651e3
--- /dev/null
+++ b/tests/run/i2163.scala
@@ -0,0 +1,21 @@
+class Base(f: Int => Int) {
+ def result = f(3)
+}
+
+class Child(x: Int) extends Base(y => x + y)
+
+class Outer(z: Int) {
+ class Base(f: Int => Int) {
+ def result = f(3)
+ }
+
+ class Child(x: Int) extends Base(y => x + y + z)
+}
+
+object Test {
+ def main(args: Array[String]): Unit = {
+ assert(new Child(4).result == 7)
+ val o = new Outer(2)
+ assert(new o.Child(2).result == 7)
+ }
+}
diff --git a/tests/run/shortClass.scala b/tests/run/shortClass.scala
deleted file mode 100644
index c5c2043f4..000000000
--- a/tests/run/shortClass.scala
+++ /dev/null
@@ -1,26 +0,0 @@
-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/run/showraw_nosymbol.scala b/tests/run/showraw_nosymbol.scala
deleted file mode 100644
index 191647583..000000000
--- a/tests/run/showraw_nosymbol.scala
+++ /dev/null
@@ -1,5 +0,0 @@
-import scala.reflect.runtime.universe._
-
-object Test extends dotty.runtime.LegacyApp {
- println(showRaw(NoSymbol))
-}
diff --git a/tests/run/sm-interpolator.scala b/tests/run/sm-interpolator.scala
deleted file mode 100644
index e4bec7afb..000000000
--- a/tests/run/sm-interpolator.scala
+++ /dev/null
@@ -1,41 +0,0 @@
-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/run/structural.scala b/tests/run/structural.scala
deleted file mode 100644
index 0f18f4579..000000000
--- a/tests/run/structural.scala
+++ /dev/null
@@ -1,25 +0,0 @@
-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/run/t429.scala b/tests/run/t429.scala
index eeed4b080..411d199ee 100644
--- a/tests/run/t429.scala
+++ b/tests/run/t429.scala
@@ -11,5 +11,6 @@ object Test {
}
def main (args: Array[String]): Unit = {
Console.print((new B).y);
+ println()
}
}
diff --git a/tests/run/t5293.scala b/tests/run/t5293.scala
deleted file mode 100644
index 8a99989c5..000000000
--- a/tests/run/t5293.scala
+++ /dev/null
@@ -1,83 +0,0 @@
-
-
-
-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/run/t5857.scala b/tests/run/t5857.scala
index eabf5dc86..fe67a7546 100644
--- a/tests/run/t5857.scala
+++ b/tests/run/t5857.scala
@@ -36,10 +36,9 @@ object Test {
b
}
- // whatever it is, it should be less than, say, 250ms
+ // whatever it is, it should be less than, say, 1000ms
// if `max` involves traversal, it takes over 5 seconds on a 3.2GHz i7 CPU
//println(exectime)
- assert(exectime < 250, exectime)
+ assert(exectime < 1000, exectime)
}
-
}
diff --git a/tests/run/t6732.scala b/tests/run/t6732.scala
deleted file mode 100644
index ff0f0494d..000000000
--- a/tests/run/t6732.scala
+++ /dev/null
@@ -1,12 +0,0 @@
-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)
-}
diff --git a/tests/run/t9915/C_1.java b/tests/run/t9915/C_1.java
new file mode 100644
index 000000000..4269cf74e
--- /dev/null
+++ b/tests/run/t9915/C_1.java
@@ -0,0 +1,20 @@
+/*
+ * javac: -encoding UTF-8
+ */
+public class C_1 {
+ public static final String NULLED = "X\000ABC";
+ public static final String SUPPED = "𐒈𐒝𐒑𐒛𐒐𐒘𐒕𐒖";
+
+ public String nulled() {
+ return C_1.NULLED;
+ }
+ public String supped() {
+ return C_1.SUPPED;
+ }
+ public int nulledSize() {
+ return C_1.NULLED.length();
+ }
+ public int suppedSize() {
+ return C_1.SUPPED.length();
+ }
+}
diff --git a/tests/run/t9915/Test_2.scala b/tests/run/t9915/Test_2.scala
new file mode 100644
index 000000000..afed667cc
--- /dev/null
+++ b/tests/run/t9915/Test_2.scala
@@ -0,0 +1,12 @@
+
+object Test extends App {
+ val c = new C_1
+ assert(c.nulled == "X\u0000ABC") // "X\000ABC"
+ assert(c.supped == "𐒈𐒝𐒑𐒛𐒐𐒘𐒕𐒖")
+
+ assert(C_1.NULLED == "X\u0000ABC") // "X\000ABC"
+ assert(C_1.SUPPED == "𐒈𐒝𐒑𐒛𐒐𐒘𐒕𐒖")
+
+ assert(C_1.NULLED.size == "XYABC".size)
+ assert(C_1.SUPPED.codePointCount(0, C_1.SUPPED.length) == 8)
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-30 01:28:33 +0000