Merge commit '2c4b142503bd2d871e6818b5cab8c38627d9e4a0' as 'examples/scala-js'

1 files changed, 388 insertions, 0 deletions

diff --git a/examples/scala-js/test-suite/src/test/scala/scala/scalajs/testsuite/niobuffer/CharBufferTest.scala b/examples/scala-js/test-suite/src/test/scala/scala/scalajs/testsuite/niobuffer/CharBufferTest.scala
new file mode 100644
index 0000000..b13c478
--- /dev/null
+++ b/examples/scala-js/test-suite/src/test/scala/scala/scalajs/testsuite/niobuffer/CharBufferTest.scala
@@ -0,0 +1,388 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___      __ ____  Scala.js Test Suite        **
+**    / __/ __// _ | / /  / _ | __ / // __/  (c) 2013, LAMP/EPFL        **
+**  __\ \/ /__/ __ |/ /__/ __ |/_// /_\ \    http://scala-js.org/       **
+** /____/\___/_/ |_/____/_/ | |__/ /____/                               **
+**                          |/____/                                     **
+\*                                                                      */
+package scala.scalajs.testsuite.niobuffer
+
+import java.nio._
+
+import scala.scalajs.js
+import js.JSConverters._
+
+object CharBufferTest extends BaseBufferTest {
+  trait Factory extends BaseFactory {
+    type BufferType = CharBuffer
+
+    def withContent(capacity: Int, content: Char*): CharBuffer =
+      withContent(0, capacity, capacity, content: _*)
+
+    def withContent(pos: Int, limit: Int, capacity: Int,
+        content: Char*): CharBuffer = {
+      val buf = allocBuffer(pos, limit, capacity)
+      buf.put(content.toArray)
+      buf.position(pos)
+      buf
+    }
+  }
+
+  def zeros(n: Int): String =
+    "\u0000"*n
+
+  def charRange(start: Int, end: Int): Array[Char] =
+    (start until end).map(_.toChar).toArray
+
+  def defineTests(factory: Factory): Unit = {
+    import factory._
+
+    commonTests(factory)
+
+    it("absolute get()") {
+      val buf = withContent(10, charRange(0, 10): _*)
+      expect(buf.get(0)).toEqual(0)
+      expect(buf.position()).toEqual(0)
+      expect(buf.get(3)).toEqual(3)
+      expect(buf.position()).toEqual(0)
+
+      expect(() => buf.get(-1)).toThrow
+      expect(() => buf.get(15)).toThrow
+
+      buf.limit(4)
+      expect(() => buf.get(5)).toThrow
+    }
+
+
+    if (!createsReadOnly) {
+      it("absolute put()") {
+        val buf = allocBuffer(10)
+        buf.put(5, 42)
+        expect(buf.position()).toEqual(0)
+        buf.put(3, 2)
+        expect(buf.get(3)).toEqual(2)
+        expect(buf.get(5)).toEqual(42)
+        expect(buf.get(7)).toEqual(0)
+
+        expect(() => buf.put(-1, 2)).toThrow
+        expect(() => buf.put(14, 9)).toThrow
+
+        buf.limit(4)
+        expect(() => buf.put(4, 1)).toThrow
+      }
+    } else {
+      it("absolute put() - read-only") {
+        val buf = allocBuffer(10)
+        expect(() => buf.put(2, 1)).toThrow
+        expect(buf.get(2)).toEqual(0)
+        expect(buf.position()).toEqual(0)
+
+        expect(() => buf.put(-2, 1)).toThrow
+        expect(() => buf.put(12, 1)).toThrow
+      }
+    }
+
+    it("relative get()") {
+      val buf = withContent(10, charRange(0, 10): _*)
+      expect(buf.get()).toEqual(0)
+      expect(buf.position()).toEqual(1)
+      buf.position(3)
+      expect(buf.get()).toEqual(3)
+      expect(buf.position()).toEqual(4)
+
+      buf.limit(4)
+      expect(() => buf.get()).toThrow
+    }
+
+    if (!createsReadOnly) {
+      it("relative put()") {
+        val buf = allocBuffer(10)
+        buf.put(5.toChar)
+        expect(buf.position()).toEqual(1)
+        expect(buf.get(0)).toEqual(5)
+
+        buf.position(3)
+        buf.put(36.toChar)
+        expect(buf.position()).toEqual(4)
+        expect(buf.get(3)).toEqual(36)
+
+        buf.position(10)
+        expect(() => buf.put(3.toChar)).toThrow
+      }
+    } else {
+      it("relative put() - read-only") {
+        val buf = allocBuffer(10)
+        expect(() => buf.put(5.toChar)).toThrow
+        expect(buf.position()).toEqual(0)
+        expect(buf.get(0)).toEqual(0)
+
+        buf.position(10)
+        expect(() => buf.put(3.toChar)).toThrow
+      }
+    }
+
+    it("relative bulk get()") {
+      val buf = withContent(10, charRange(0, 10): _*)
+      val a = new Array[Char](4)
+      buf.get(a)
+      expect(a.map(_.toInt).toJSArray).toEqual(js.Array(0, 1, 2, 3))
+      expect(buf.position()).toEqual(4)
+
+      buf.position(6)
+      buf.get(a, 1, 2)
+      expect(a.map(_.toInt).toJSArray).toEqual(js.Array(0, 6, 7, 3))
+      expect(buf.position()).toEqual(8)
+
+      expect(() => buf.get(a)).toThrow
+      expect(buf.position()).toEqual(8)
+      expect(a.map(_.toInt).toJSArray).toEqual(js.Array(0, 6, 7, 3))
+    }
+
+    if (!createsReadOnly) {
+      it("relative bulk put()") {
+        val buf = allocBuffer(10)
+        buf.put(Array[Char](6, 7, 12))
+        expect((0 to 3).map(buf.get(_).toInt).toJSArray).toEqual(js.Array(6, 7, 12, 0))
+        expect(buf.position()).toEqual(3)
+
+        buf.position(2)
+        buf.put(Array[Char](44, 55, 66, 77, 88), 2, 2)
+        expect((0 to 4).map(buf.get(_).toInt).toJSArray).toEqual(js.Array(6, 7, 66, 77, 0))
+        expect(buf.position()).toEqual(4)
+
+        expect(() => buf.put(Array.fill[Char](10)(0))).toThrow
+        expect(buf.position()).toEqual(4)
+        expect((0 to 4).map(buf.get(_).toInt).toJSArray).toEqual(js.Array(6, 7, 66, 77, 0))
+      }
+    } else {
+      it("relative bulk put() - read-only") {
+        val buf = allocBuffer(10)
+        expect(() => buf.put(Array[Char](6, 7, 12))).toThrow
+        expect(buf.position()).toEqual(0)
+        expect(buf.get(0)).toEqual(0)
+
+        buf.position(8)
+        expect(() => buf.put(Array[Char](6, 7, 12))).toThrow
+        expect(buf.position()).toEqual(8)
+        expect(buf.get(8)).toEqual(0)
+      }
+    }
+
+    if (!createsReadOnly) {
+      it("compact()") {
+        val buf = withContent(10, charRange(0, 10): _*)
+        buf.position(6)
+        buf.mark()
+
+        buf.compact()
+        expect(buf.position()).toEqual(4)
+        expect(buf.limit()).toEqual(10)
+        expect(() => buf.reset()).toThrow
+
+        for (i <- 0 until 4)
+          expect(buf.get(i).toInt).toEqual(i + 6)
+      }
+    } else {
+      it("compact() - read-only") {
+        val buf = allocBuffer(10)
+        expect(() => buf.compact()).toThrow
+      }
+    }
+
+    it("slice()" + (if (createsReadOnly) " - read-only" else "")) {
+      val buf1 = withContent(10, charRange(0, 10): _*)
+      buf1.position(3)
+      buf1.limit(7)
+      buf1.mark()
+      val buf2 = buf1.slice()
+      expect(buf2.position()).toEqual(0)
+      expect(buf2.limit()).toEqual(4)
+      expect(buf2.capacity()).toEqual(4)
+      expect(() => buf2.reset()).toThrow
+      expect(buf2.get(1)).toEqual(4)
+
+      buf2.position(2)
+      expect(buf1.position()).toEqual(3)
+
+      if (!createsReadOnly) {
+        buf2.put(89.toChar)
+        expect(buf1.get(5)).toEqual(89)
+        expect(buf2.position()).toEqual(3)
+        expect(buf1.position()).toEqual(3)
+      }
+
+      expect(() => buf2.limit(5)).toThrow
+      expect(buf2.limit()).toEqual(4)
+
+      buf2.limit(3)
+      expect(buf1.limit()).toEqual(7)
+
+      if (!createsReadOnly) {
+        buf1.put(3, 23)
+        expect(buf2.get(0)).toEqual(23)
+      }
+    }
+
+    it("duplicate()" + (if (createsReadOnly) " - read-only" else "")) {
+      val buf1 = withContent(10, charRange(0, 10): _*)
+      buf1.position(3)
+      buf1.limit(7)
+      buf1.mark()
+      val buf2 = buf1.duplicate()
+      expect(buf2.position()).toEqual(3)
+      expect(buf2.limit()).toEqual(7)
+      expect(buf2.capacity()).toEqual(10)
+      expect(buf2.get(4)).toEqual(4)
+
+      buf2.position(4)
+      expect(buf1.position()).toEqual(3)
+      expect(buf2.position()).toEqual(4)
+
+      buf2.reset()
+      expect(buf2.position()).toEqual(3)
+      buf2.position(4)
+
+      if (!createsReadOnly) {
+        buf2.put(89.toChar)
+        expect(buf1.get(4)).toEqual(89)
+        expect(buf2.position()).toEqual(5)
+        expect(buf1.position()).toEqual(3)
+      }
+
+      buf2.limit(5)
+      expect(buf1.limit()).toEqual(7)
+
+      if (!createsReadOnly) {
+        buf1.put(6, 23)
+        buf2.limit(10)
+        expect(buf2.get(6)).toEqual(23)
+      }
+    }
+  }
+
+  describe("Allocated CharBuffer") {
+    defineTests(new Factory {
+      def allocBuffer(capacity: Int): CharBuffer =
+        CharBuffer.allocate(capacity)
+    })
+  }
+
+  class WrappedCharBufferFactory extends Factory {
+    def allocBuffer(capacity: Int): CharBuffer =
+      CharBuffer.wrap(new Array[Char](capacity))
+
+    override def allocBuffer(pos: Int, limit: Int, capacity: Int): CharBuffer =
+      CharBuffer.wrap(new Array[Char](capacity), pos, limit-pos)
+
+    override def withContent(pos: Int, limit: Int, capacity: Int,
+        content: Char*): CharBuffer = {
+      val after = capacity - (pos + content.size)
+      CharBuffer.wrap(
+          (Seq.fill(pos)(0.toChar) ++ content ++ Seq.fill(after)(0.toChar)).toArray,
+          pos, limit-pos)
+    }
+  }
+
+  describe("Wrapped CharBuffer") {
+    defineTests(new WrappedCharBufferFactory)
+  }
+
+  describe("Read-only wrapped CharBuffer") {
+    defineTests(new WrappedCharBufferFactory {
+      override val createsReadOnly = true
+
+      override def allocBuffer(capacity: Int): CharBuffer =
+        super.allocBuffer(capacity).asReadOnlyBuffer()
+
+      override def allocBuffer(pos: Int, limit: Int, capacity: Int): CharBuffer =
+        super.allocBuffer(pos, limit, capacity).asReadOnlyBuffer()
+
+      override def withContent(pos: Int, limit: Int, capacity: Int,
+          content: Char*): CharBuffer =
+        super.withContent(pos, limit, capacity, content: _*).asReadOnlyBuffer()
+    })
+  }
+
+  describe("CharBuffer wrapping a CharSequence") {
+    defineTests(new Factory {
+      override val createsReadOnly = true
+
+      def allocBuffer(capacity: Int): CharBuffer = {
+        if (capacity < 0)
+          throw new IllegalArgumentException
+        CharBuffer.wrap(zeros(capacity))
+      }
+
+      override def allocBuffer(pos: Int, limit: Int, capacity: Int): CharBuffer = {
+        if (capacity < 0)
+          throw new IllegalArgumentException
+        CharBuffer.wrap(zeros(capacity), pos, limit-pos)
+      }
+
+      override def withContent(pos: Int, limit: Int, capacity: Int,
+          content: Char*): CharBuffer = {
+        val after = capacity - (pos + content.size)
+        CharBuffer.wrap(
+            zeros(pos) + content.mkString + zeros(after),
+            pos, limit-pos)
+      }
+    })
+  }
+
+  describe("Sliced CharBuffer") {
+    defineTests(new Factory {
+      def allocBuffer(capacity: Int): CharBuffer = {
+        if (capacity < 0)
+          throw new IllegalArgumentException
+        val buf = CharBuffer.allocate(capacity+25)
+        buf.position(17)
+        buf.limit(17+capacity)
+        buf.slice()
+      }
+
+      override def withContent(pos: Int, limit: Int, capacity: Int,
+          content: Char*): CharBuffer = {
+        if (!(0 <= pos && pos <= limit && limit <= capacity))
+          throw new IllegalArgumentException
+        val buf = CharBuffer.allocate(capacity+25)
+        buf.position(9+pos)
+        buf.put(content.toArray)
+        buf.position(9)
+        buf.limit(9+capacity)
+        val buf2 = buf.slice()
+        buf2.position(pos)
+        buf2.limit(limit)
+        buf2
+      }
+    })
+  }
+
+  describe("Sliced CharBuffer wrapping a CharSequence") {
+    defineTests(new Factory {
+      override val createsReadOnly = true
+
+      def allocBuffer(capacity: Int): CharBuffer = {
+        if (capacity < 0)
+          throw new IllegalArgumentException
+        val buf = CharBuffer.wrap(zeros(capacity+25))
+        buf.position(17)
+        buf.limit(17+capacity)
+        buf.slice()
+      }
+
+      override def withContent(pos: Int, limit: Int, capacity: Int,
+          content: Char*): CharBuffer = {
+        if (!(0 <= pos && pos <= limit && limit <= capacity))
+          throw new IllegalArgumentException
+        val after = (25+capacity) - (9+pos+content.size)
+        val buf = CharBuffer.wrap(zeros(9+pos) + content.mkString + zeros(after))
+        buf.position(9)
+        buf.limit(9+capacity)
+        val buf2 = buf.slice()
+        buf2.position(pos)
+        buf2.limit(limit)
+        buf2
+      }
+    })
+  }
+}