1 files changed, 159 insertions, 0 deletions
diff --git a/examples/scala-js/test-suite/src/test/scala/scala/scalajs/testsuite/compiler/LongTest.scala b/examples/scala-js/test-suite/src/test/scala/scala/scalajs/testsuite/compiler/LongTest.scala
new file mode 100644
index 0000000..01d6f6e
--- /dev/null
+++ b/examples/scala-js/test-suite/src/test/scala/scala/scalajs/testsuite/compiler/LongTest.scala
@@ -0,0 +1,159 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___      __ ____  Scala.js Test Suite        **
+**    / __/ __// _ | / /  / _ | __ / // __/  (c) 2013, LAMP/EPFL        **
+**  __\ \/ /__/ __ |/ /__/ __ |/_// /_\ \    http://scala-js.org/       **
+** /____/\___/_/ |_/____/_/ | |__/ /____/                               **
+**                          |/____/                                     **
+\*                                                                      */
+package scala.scalajs.testsuite.compiler
+
+import scala.scalajs.js
+
+import org.scalajs.jasminetest.JasmineTest
+
+/**
+ * tests the compiler re-patching of native longs to
+ * scala.scalajs.runtime.Long
+ * see scala.scalajs.testsuite.jsinterop.RuntimeLongTest
+ * for a test of the implementation itself
+ */
+object LongTest extends JasmineTest {
+
+  describe("JavaScript 64-bit long compatibility") {
+    it("should correctly handle literals") {
+      expect(5L + 100L == 105L).toBeTruthy
+      expect(2147483649L + 2L == 2147483651L).toBeTruthy
+      expect(-2147483648L * 4 == -8589934592L).toBeTruthy
+      expect(4503599627370510L * (-4) == -18014398509482040L).toBeTruthy
+    }
+
+    it("should correctly dispatch unary ops on Longs") {
+      val x = 10L
+      expect(-x == -10L).toBeTruthy
+      val y = 5L
+      expect(-y == -5L).toBeTruthy
+      expect(+y == 5L).toBeTruthy
+      expect(~y == -6L).toBeTruthy
+    }
+
+    it("should correctly dispatch binary ops on Longs") {
+      expect(5L * 5F == 25F).toBeTruthy
+      expect(5L % 4F == 1F).toBeTruthy
+      expect(5F * 4L == 20F).toBeTruthy
+    }
+
+    it("should support shifts with Longs - #622") {
+      def l(x: Long): Long = x
+      def i(x: Int): Int = x
+
+      expect(l(-7L) >>> 100L == 268435455L).toBeTruthy
+      expect(l(-7L) >> 100L == -1L).toBeTruthy
+      expect(l(-7L) >> 100 == -1L).toBeTruthy
+      expect(l(-7L) >>> 100 == 268435455).toBeTruthy
+      expect(l(-7L) << 100L == -481036337152L).toBeTruthy
+      expect(l(-7L) << 100 == -481036337152L).toBeTruthy
+      expect(l(7L) << 100L == 481036337152L).toBeTruthy
+      expect(l(8L) << 100L == 549755813888L).toBeTruthy
+      expect(l(-7L) >>> 4 == 1152921504606846975L).toBeTruthy
+
+      expect(i(7) << 100).toEqual(112)
+      expect(i(-7) >> 100).toEqual(-1)
+      expect(i(-7) >>> 100).toEqual(268435455)
+      expect(i(-65) >> 100).toEqual(-5)
+      expect(i(-65) >> 4).toEqual(-5)
+    }
+
+    it("primitives should convert to Long") {
+      // Byte
+      expect(112.toByte.toLong == 112L).toBeTruthy
+      // Short
+      expect((-10).toShort.toLong == -10L).toBeTruthy
+      // Char
+      expect('A'.toLong == 65L).toBeTruthy
+      // Int
+      expect(5.toLong == 5L).toBeTruthy
+      // Long
+      expect(10L.toLong == 10L).toBeTruthy
+      // Float
+      expect(100000.6f.toLong == 100000L).toBeTruthy
+      // Double
+      expect(100000.6.toLong == 100000L).toBeTruthy
+    }
+
+    it("should support hashCode()") {
+      expect(0L         .hashCode()).toEqual(0)
+      expect(55L        .hashCode()).toEqual(55)
+      expect((-12L)     .hashCode()).toEqual(11)
+      expect(10006548L  .hashCode()).toEqual(10006548)
+      expect((-1098748L).hashCode()).toEqual(1098747)
+
+      expect(613354684553L       .hashCode()).toEqual(-825638905)
+      expect(9863155567412L      .hashCode()).toEqual(1910653900)
+      expect(3632147899696541255L.hashCode()).toEqual(1735398658)
+      expect(7632147899696541255L.hashCode()).toEqual(-1689438124)
+    }
+
+    it("should support ##") {
+      expect(0L         .##).toEqual(0)
+      expect(55L        .##).toEqual(55)
+      expect((-12L)     .##).toEqual(-12)
+      expect(10006548L  .##).toEqual(10006548)
+      expect((-1098748L).##).toEqual(-1098748)
+
+      expect(9863155567412L      .##).toEqual(1910653900)
+      expect(3632147899696541255L.##).toEqual(1735398658)
+
+      // These two (correctly) give different results on 2.10 and 2.11
+      //expect(613354684553L       .##).toEqual(-825638905)  // xx06 on 2.10
+      //expect(7632147899696541255L.##).toEqual(-1689438124) // xx25 on 2.10
+    }
+
+    it("should correctly concat to string") {
+      val x = 20L
+      expect("asdf" + 5L + x + "hello").toEqual("asdf520hello")
+      expect(x + "hello").toEqual("20hello")
+    }
+
+    it("string should convert to Long") {
+      expect("45678901234567890".toLong == 45678901234567890L).toBeTruthy
+    }
+
+    it("should convert from and to js.prim.Number") {
+      val x = 5: js.prim.Number
+      expect((5L: js.prim.Number) == x).toBeTruthy
+      expect(x.toLong == 5L).toBeTruthy
+    }
+
+    it("should correctly implement is/asInstanceOf Longs") {
+      val dyn:  Any  = 5L
+      val stat: Long = 5L
+
+      expect(stat.asInstanceOf[Long]).toEqual(5L)
+      // models current scala behavior. See SI-1448
+      expect(stat.asInstanceOf[Int]).toEqual(5)
+
+      expect(stat.isInstanceOf[Long]).toBeTruthy
+      expect(stat.isInstanceOf[Int]).toBeFalsy
+
+      expect(dyn.asInstanceOf[Long]).toEqual(5L)
+
+      expect(dyn.isInstanceOf[Long]).toBeTruthy
+      expect(dyn.isInstanceOf[Int]).toBeFalsy
+    }
+
+    when("compliant-asinstanceof").
+    it("should correctly implement asInstanceOf Longs (negative)") {
+      val dyn: Any = 5L
+
+      expect(() => dyn.asInstanceOf[Int]).toThrow
+    }
+
+    it("should correctly compare to other numeric types") {
+      expect(5L == 5).toBeTruthy
+      expect(5 == 5L).toBeTruthy
+      expect(4 == 5l).toBeFalsy
+      expect('A' == 65L).toBeTruthy
+    }
+  }
+
+}