From 2c4b142503bd2d871e6818b5cab8c38627d9e4a0 Mon Sep 17 00:00:00 2001 From: Haoyi Li Date: Wed, 26 Nov 2014 00:45:31 -0800 Subject: Squashed 'examples/scala-js/' content from commit 47311ba git-subtree-dir: examples/scala-js git-subtree-split: 47311ba693f949f204f27ea9475bb63425fbd4f3 --- .../scalajs/testsuite/compiler/LongTest.scala | 159 +++++++++++++++++++++ 1 file changed, 159 insertions(+) create mode 100644 test-suite/src/test/scala/scala/scalajs/testsuite/compiler/LongTest.scala (limited to 'test-suite/src/test/scala/scala/scalajs/testsuite/compiler/LongTest.scala') diff --git a/test-suite/src/test/scala/scala/scalajs/testsuite/compiler/LongTest.scala b/test-suite/src/test/scala/scala/scalajs/testsuite/compiler/LongTest.scala new file mode 100644 index 0000000..01d6f6e --- /dev/null +++ b/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 + } + } + +} -- cgit v1.2.3