diff options
author | Haoyi Li <haoyi@haoyi-mbp.corp.dropbox.com> | 2014-11-26 00:45:31 -0800 |
---|---|---|
committer | Haoyi Li <haoyi@haoyi-mbp.corp.dropbox.com> | 2014-11-26 00:45:31 -0800 |
commit | 2c4b142503bd2d871e6818b5cab8c38627d9e4a0 (patch) | |
tree | 6ba33d2980a1a7a1286100202a695c6631bd240e /test-suite/src/test/scala/scala/scalajs/testsuite/compiler/RegressionTest.scala | |
download | hands-on-scala-js-2c4b142503bd2d871e6818b5cab8c38627d9e4a0.tar.gz hands-on-scala-js-2c4b142503bd2d871e6818b5cab8c38627d9e4a0.tar.bz2 hands-on-scala-js-2c4b142503bd2d871e6818b5cab8c38627d9e4a0.zip |
Squashed 'examples/scala-js/' content from commit 47311ba
git-subtree-dir: examples/scala-js
git-subtree-split: 47311ba693f949f204f27ea9475bb63425fbd4f3
Diffstat (limited to 'test-suite/src/test/scala/scala/scalajs/testsuite/compiler/RegressionTest.scala')
-rw-r--r-- | test-suite/src/test/scala/scala/scalajs/testsuite/compiler/RegressionTest.scala | 287 |
1 files changed, 287 insertions, 0 deletions
diff --git a/test-suite/src/test/scala/scala/scalajs/testsuite/compiler/RegressionTest.scala b/test-suite/src/test/scala/scala/scalajs/testsuite/compiler/RegressionTest.scala new file mode 100644 index 0000000..19cceb2 --- /dev/null +++ b/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) + } + } +} |