1 files changed, 287 insertions, 0 deletions
diff --git a/examples/scala-js/test-suite/src/test/scala/scala/scalajs/testsuite/compiler/RegressionTest.scala b/examples/scala-js/test-suite/src/test/scala/scala/scalajs/testsuite/compiler/RegressionTest.scala
new file mode 100644
index 0000000..19cceb2
--- /dev/null
+++ b/examples/scala-js/test-suite/src/test/scala/scala/scalajs/testsuite/compiler/RegressionTest.scala
@@ -0,0 +1,287 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___      __ ____  Scala.js Test Suite        **
+**    / __/ __// _ | / /  / _ | __ / // __/  (c) 2013, LAMP/EPFL        **
+**  __\ \/ /__/ __ |/ /__/ __ |/_// /_\ \    http://scala-js.org/       **
+** /____/\___/_/ |_/____/_/ | |__/ /____/                               **
+**                          |/____/                                     **
+\*                                                                      */
+package scala.scalajs.testsuite.compiler
+
+import scala.annotation.tailrec
+
+import scala.scalajs.js
+import org.scalajs.jasminetest.JasmineTest
+
+object RegressionTest extends JasmineTest {
+
+  class Bug218Foo[T](val x: T) extends AnyVal
+
+  describe("Scala.js compiler regression tests") {
+
+    it("Wrong division conversion (7 / 2.0) - #18") {
+      val div = 7 / 2.0
+      expect(div).toEqual(3.5)
+      expect(div.getClass.getName).toEqual("double")
+
+      val mod = 7 % 2.0
+      expect(mod).toEqual(1.0)
+      expect(mod.getClass.getName).toEqual("double")
+    }
+
+    it("js.prim.String + js.prim.String is ambiguous - #20") {
+      val a: js.prim.String = "a"
+      val b: js.prim.String = "b"
+      val c: js.prim.String = a + b
+      expect(c).toEqual("ab")
+    }
+
+    it("Abort with some pattern match guards - #22") {
+      object PatternMatchGuards {
+        def go(f: Int => Int) = f(1)
+        def main(): Unit = {
+          go {
+            case x if false => x
+          }
+        }
+      }
+      // Nothing to check
+    }
+
+    it("Bad encoding for characters spanning 2 UTF-16 chars - #23") {
+      val str = "A∀\uD835\uDCAB"
+      var s: String = ""
+      for (c <- str) {
+        val code: Int = c
+        s = s + code + " "
+      }
+      expect(s).toEqual("65 8704 55349 56491 ")
+    }
+
+    it("String concatenation with null - #26") {
+      val x: Object = null
+      expect(x + "check").toEqual("nullcheck")
+    }
+
+    class Bug66A(s: String, e: Object) {
+      def this(e: Object) = this("", e)
+      def this(s: String) = this(s, "")
+    }
+    class Bug66B(s: String, e: Object) extends Bug66A(s)
+
+    it("should emit static calls when forwarding to another constructor - #66") {
+      new Bug66B("", "")
+    }
+
+    it("should not swallow Unit expressions when converting to js.prim.Undefined - #83") {
+      var effectHappened = false
+      def doEffect(): Unit = effectHappened = true
+      def f(): js.prim.Undefined = doEffect()
+      f()
+      expect(effectHappened).toBeTruthy
+    }
+
+    it("should correctly call subSequence on non-string CharSequences - #55") {
+      val arr: CharSequence = Array('a','b','c','d')
+      val ss = arr.subSequence(2,3)
+      expect(ss.length()).toEqual(1)
+      expect(ss.charAt(0)).toEqual('c')
+    }
+
+    it("should correctly concat primitive values to strings - #113") {
+      expect(4 + "foo").toEqual("4foo")
+      expect('a' + "foo").toEqual("afoo")
+    }
+
+    it("should resolve overloads on scala.Function.apply when converting to js.Function - #125") {
+      class Fct extends Function1[Int,Any] {
+        def apply(n: Int) = n
+      }
+
+      val scalaFunction = new Fct
+      val jsFunction: js.Any = scalaFunction
+      val thisFunction: js.ThisFunction = scalaFunction
+    }
+
+    it("should correctly dispatch calls on private functions - #165") {
+      class A {
+        private def x = 1
+        def value = x
+      }
+      class B extends A {
+        private def x = 2
+      }
+      expect(new B().value).toEqual(1)
+    }
+
+    it("should correctly mangle JavaScript reserved identifiers - #153") {
+      // Class name
+      class break {
+        // class variable
+        var continue = 1
+        // method name
+        def switch = {
+          // local name
+          val default = 2
+          default
+        }
+      }
+      trait Foo {
+        // static member (through mixin)
+        def function = 3
+      }
+
+      val x = new break with Foo
+      expect(x.continue).toEqual(1)
+      expect(x.switch).toEqual(2)
+      expect(x.function).toEqual(3)
+    }
+
+    it("should correctly mangle identifiers starting with a digit - #153") {
+      // Class name
+      class `0` {
+        // class variable
+        var `1` = 1
+        // method name
+        def `2` = {
+          // local name
+          val `22` = 2
+          `22`
+        }
+      }
+      trait Foo {
+        // static member (through mixin)
+        def `3` = 3
+      }
+
+      val x = new `0` with Foo
+      expect(x.`1`).toEqual(1)
+      expect(x.`2`).toEqual(2)
+      expect(x.`3`).toEqual(3)
+    }
+
+    it("should reserve `eval` and `arguments` - #743") {
+      val eval = 5
+      expect(eval).toEqual(5)
+      val arguments = "hello"
+      expect(arguments).toEqual("hello")
+    }
+
+    it("should support class literals for existential value types - #218") {
+      expect(scala.reflect.classTag[Bug218Foo[_]].toString).toEqual(
+          "scala.scalajs.testsuite.compiler.RegressionTest$Bug218Foo")
+    }
+
+    it("should support Buffer - #268") {
+      val a = scala.collection.mutable.Buffer.empty[Int]
+      a.insert(0, 0)
+      a.remove(0)
+      for (i <- 0 to 10) {
+        a.insert(a.length / 2, i)
+      }
+      expect(a.mkString(", ")).toEqual("1, 3, 5, 7, 9, 10, 8, 6, 4, 2, 0")
+    }
+
+    it("should not call equals when comparing with a literal null - #362") {
+      class A { override def equals(x: Any) = !(this == null) }
+
+      val x = new A
+      val y = new A
+
+      // If the null comparisons actually call equals, the following two will
+      // cause infinite recursion
+      expect(x == y).toBeTruthy
+      expect(y == x).toBeTruthy
+    }
+
+    it("should unbox null to the zero of types - #674") {
+      class Box[A] {
+        var value: A = _
+      }
+      def zero[A]: A = new Box[A].value
+
+      /* Note: the same shape of test for Unit does not work, but it seems to
+       * be a problem in scalac because it does not work on the JVM either.
+       */
+
+      val bool = zero[Boolean]
+      expect((bool: Any).isInstanceOf[Boolean]).toBeTruthy
+      expect(bool == false).toBeTruthy
+
+      val char = zero[Char]
+      expect((char: Any).isInstanceOf[Char]).toBeTruthy
+      expect(char == '\u0000').toBeTruthy
+
+      val byte = zero[Byte]
+      expect((byte: Any).isInstanceOf[Byte]).toBeTruthy
+      expect(byte == 0.toByte).toBeTruthy
+
+      val short = zero[Short]
+      expect((short: Any).isInstanceOf[Short]).toBeTruthy
+      expect(short == 0.toShort).toBeTruthy
+
+      val int = zero[Int]
+      expect((int: Any).isInstanceOf[Int]).toBeTruthy
+      expect(int == 0).toBeTruthy
+
+      val long = zero[Long]
+      expect((long: Any).isInstanceOf[Long]).toBeTruthy
+      expect(long == 0L).toBeTruthy
+
+      val float = zero[Float]
+      expect((float: Any).isInstanceOf[Float]).toBeTruthy
+      expect(float == 0.0f).toBeTruthy
+
+      val double = zero[Double]
+      expect((double: Any).isInstanceOf[Double]).toBeTruthy
+      expect(double == 0.0).toBeTruthy
+
+      val ref = zero[AnyRef]
+      expect(ref == null).toBeTruthy
+    }
+
+    it("Param defs in tailrec methods should be considered mutable - #825") {
+      @tailrec
+      def foo(x: Int, y: Int): Unit = {
+        if (x < y) foo(y, x)
+        else {
+          expect(x).toEqual(4)
+          expect(y).toEqual(2)
+        }
+      }
+      foo(2, 4)
+    }
+
+    it("null.synchronized should throw - #874") {
+      expect(() => null.synchronized(5)).toThrow
+    }
+
+    it("x.synchronized should preserve side-effects of x") {
+      var c = 0
+      def x = { c += 1; this }
+      expect(x.synchronized(5)).toEqual(5)
+      expect(c).toEqual(1)
+    }
+
+    it("IR checker should allow Apply/Select on NullType and NothingType - #1123") {
+      def giveMeANull(): Null = null
+      expect(() => (giveMeANull(): StringBuilder).append(5)).toThrow
+      expect(() => (giveMeANull(): scala.runtime.IntRef).elem).toThrow
+
+      def giveMeANothing(): Nothing = sys.error("boom")
+      expect(() => (giveMeANothing(): StringBuilder).append(5)).toThrow
+      expect(() => (giveMeANothing(): scala.runtime.IntRef).elem).toThrow
+    }
+
+    it("should not put bad flags on caseaccessor export forwarders - #1191") {
+      // This test used to choke patmat
+
+      @scala.scalajs.js.annotation.JSExportAll
+      case class T(one: Int, two: Int)
+
+      val T(a, b) = T(1, 2)
+
+      expect(a).toEqual(1)
+      expect(b).toEqual(2)
+    }
+  }
+}