diff options
Diffstat (limited to 'javalib-ex-test-suite/src/test/scala/scala/scalajs/testsuite/javalibex/DataInputStreamTest.scala')
| -rw-r--r-- | javalib-ex-test-suite/src/test/scala/scala/scalajs/testsuite/javalibex/DataInputStreamTest.scala | 338 |
1 files changed, 338 insertions, 0 deletions
diff --git a/javalib-ex-test-suite/src/test/scala/scala/scalajs/testsuite/javalibex/DataInputStreamTest.scala b/javalib-ex-test-suite/src/test/scala/scala/scalajs/testsuite/javalibex/DataInputStreamTest.scala new file mode 100644 index 0000000..61ec560 --- /dev/null +++ b/javalib-ex-test-suite/src/test/scala/scala/scalajs/testsuite/javalibex/DataInputStreamTest.scala @@ -0,0 +1,338 @@ +package scala.scalajs.testsuite.javalibex + +import java.io._ + +import org.scalajs.jasminetest.JasmineTest + +import scala.scalajs.js.typedarray._ +import scala.scalajs.js.JSConverters._ + +object DataInputStreamTest extends JasmineTest { + + def tests(name: String)(inFromBytes: Seq[Byte] => InputStream) { + def newStream(data: Int*) = + new DataInputStream(inFromBytes(data.map(_.toByte))) + + when("typedarray"). + describe(name) { + + it("should provide `readBoolean`") { + val data = Seq(0x00, 0x01, 0xF1, 0x00, 0x01) + val stream = newStream(data: _*) + + for (d <- data) + expect(stream.readBoolean()).toBe(d != 0) + + expect(() => stream.readBoolean()).toThrow // EOF + } + + it("should provide `readByte`") { + val data = Seq(0x00, 0x01, 0xF1, 0x7D, 0x35) + val stream = newStream(data: _*) + + for (d <- data) + expect(stream.readByte()).toBe(d.toByte) + + expect(() => stream.readBoolean()).toThrow // EOF + } + + it("should provide `readChar`") { + val stream = newStream( + 0x00, 0x48, // H + 0x00, 0xF6, // ö + 0x00, 0x6C, // l + 0x00, 0x6C, // l + 0x00, 0xF6, // ö + 0x00, 0x20, // [space] + 0x00, 0x57, // W + 0x01, 0x03, // ă + 0x00, 0x72, // r + 0x02, 0x34, // ȴ + 0x01, 0x11, // đ + 0x56 // dangling + ) + var res = "" + + for (i <- 1 to 11) + res += stream.readChar() + + expect(res).toEqual("Höllö Wărȴđ") + + expect(() => stream.readChar()).toThrow // Dangling + EOF + } + + it("should provide `readDouble`") { + val stream = newStream( + 0x3f, 0xe6, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, + 0x41, 0x15, 0x19, 0x20, 0x45, 0x8d, 0x9b, 0x5f, + 0xc0, 0xab, 0x20, 0x22, 0x75, 0x25, 0x46, 0x0b, + 0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xc0, 0x1c, 0x0d, 0xca, 0x65, 0xea, 0x3f, 0xa4, + 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x01 // dangling + ) + + expect(stream.readDouble()).toBe(0.7) + expect(stream.readDouble()).toBe(345672.067923) + expect(stream.readDouble()).toBe(-3472.0673) + expect(stream.readDouble().isNaN).toBe(true) + expect(stream.readDouble()).toBe(Double.PositiveInfinity) + expect(stream.readDouble()).toBe(-7.0134674) + expect(stream.readDouble()).toBe(Double.NegativeInfinity) + expect(stream.readDouble()).toBe(0) + expect(() => stream.readDouble()).toThrow + } + + it("should provide `readFloat`") { + val stream = newStream( + 0xbf, 0x80, 0x00, 0x00, + 0x45, 0x8e, 0x9c, 0x83, + 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x7f, 0xc0, 0x00, 0x00, + 0x7f, 0x80, 0x00, 0x00, + 0xbb, 0x03, 0x12, 0x6f, + 0xff, 0x80, 0x00, 0x00, + 0xff // dangling + ) + + expect(stream.readFloat()).toBeCloseTo(-1.0f, 6) + expect(stream.readFloat()).toBeCloseTo(4563.564f, 6) + expect(stream.readFloat()).toBeCloseTo(-0.0f, 6) + expect(stream.readFloat()).toBeCloseTo(0.0f, 6) + expect(stream.readFloat().isNaN).toBe(true) + expect(stream.readFloat()).toBe(Float.PositiveInfinity) + expect(stream.readFloat()).toBeCloseTo(-0.002f, 6) + expect(stream.readFloat()).toBe(Float.NegativeInfinity) + expect(() => stream.readDouble()).toThrow + } + + it("should provide `readInt`") { + val stream = newStream( + 0x00, 0x00, 0x00, 0x00, + 0x7f, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfc, + 0x00, 0x00, 0x00, 0x53, + 0x00, 0x00, 0x89, 0xa2, + 0xff, 0xfe, 0x82, 0xfd, + 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01) + + expect(stream.readInt()).toBe(0) + expect(stream.readInt()).toBe(Int.MaxValue) + expect(stream.readInt()).toBe(-4) + expect(stream.readInt()).toBe(83) + expect(stream.readInt()).toBe(35234) + expect(stream.readInt()).toBe(-97539) + expect(stream.readInt()).toBe(Int.MinValue) + expect(stream.readInt()).toBe(1) + expect(() => stream.readDouble()).toThrow + } + + it("should provide `readLong`") { + val stream = newStream( + 0x00, 0x01, 0xf0, 0xec, 0x59, 0x0c, 0x70, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0x10, 0xd5, 0x5e, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x79, 0x24, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2f) + + expect(stream.readLong() == 546372873646234L).toBeTruthy + expect(stream.readLong() == -32451234L).toBeTruthy + expect(stream.readLong() == Long.MaxValue).toBeTruthy + expect(stream.readLong() == 0L).toBeTruthy + expect(stream.readLong() == -1L).toBeTruthy + expect(stream.readLong() == Long.MinValue).toBeTruthy + expect(stream.readLong() == -34524L).toBeTruthy + expect(stream.readLong() == 47L).toBeTruthy + expect(() => stream.readDouble()).toThrow + } + + it("should provide `readShort`") { + val stream = newStream( + 0x01, 0xc5, + 0xff, 0xd5, + 0x7f, 0xff, + 0x18, 0xb0, + 0x00, 0x00, + 0x80, 0x00, + 0xfe, 0xa6, + 0x00, 0x22, + 0x01 // dangling + ) + + expect(stream.readShort()).toBe(453) + expect(stream.readShort()).toBe(-43) + expect(stream.readShort()).toBe(Short.MaxValue) + expect(stream.readShort()).toBe(6320) + expect(stream.readShort()).toBe(0) + expect(stream.readShort()).toBe(Short.MinValue) + expect(stream.readShort()).toBe(-346) + expect(stream.readShort()).toBe(34) + expect(() => stream.readDouble()).toThrow + } + + it("should provide `readUnsignedByte`") { + val data = Seq(0x00, 0x01, 0xF1, 0x7D, 0x35) + val stream = newStream(data: _*) + + for (d <- data) + expect(stream.readUnsignedByte()).toBe(d) + + expect(() => stream.readBoolean()).toThrow // EOF + } + + it("should provide `readUnsignedShort`") { + val stream = newStream( + 0xfe, 0x4c, + 0x00, 0x00, + 0x18, 0xee, + 0x0d, 0xed, + 0x00, 0x2b, + 0x01, 0xce, + 0x01, 0x56, + 0x64, 0x2b, + 0x01 // dangling + ) + + expect(stream.readUnsignedShort()).toBe(65100) + expect(stream.readUnsignedShort()).toBe(0) + expect(stream.readUnsignedShort()).toBe(6382) + expect(stream.readUnsignedShort()).toBe(3565) + expect(stream.readUnsignedShort()).toBe(43) + expect(stream.readUnsignedShort()).toBe(462) + expect(stream.readUnsignedShort()).toBe(342) + expect(stream.readUnsignedShort()).toBe(25643) + expect(() => stream.readDouble()).toThrow + } + + it("should provide `readFully` (1 arg & 3 arg)") { + val stream = newStream(-100 to 99: _*) + val buf = new Array[Byte](50) + + stream.readFully(buf) + expect(buf.toJSArray).toEqual((-100 to -51).toJSArray) + + expect(() => stream.readFully(null)).toThrow + + stream.readFully(buf, 40, 10) + expect(buf.toJSArray).toEqual(((-100 to -61) ++ (-50 to -41)).toJSArray) + + expect(() => stream.readFully(buf, 70, 1)).toThrow + expect(() => stream.readFully(buf, 10, 100)).toThrow + expect(() => stream.readFully(buf, -1, 2)).toThrow + expect(() => stream.readFully(buf, 0, -1)).toThrow + + stream.readFully(buf, 0, 50) + expect(buf.toJSArray).toEqual((-40 to 9).toJSArray) + + stream.readFully(buf, 0, 50) + expect(buf.toJSArray).toEqual((10 to 59).toJSArray) + + expect(() => stream.readFully(buf)).toThrow + } + + it("should provide `readFully` for bursty streams") { + class BurstyStream(length: Int, burst: Int) extends InputStream { + private var i: Int = 0 + def read(): Int = if (i < length) { i += 1; i } else -1 + override def read(buf: Array[Byte], off: Int, reqLen: Int): Int = { + val len = Math.min(Math.min(reqLen, burst), length - i) + if (reqLen == 0) 0 + else if (len == 0) -1 + else { + var j: Int = 0 + while (j < len) { + buf(off+j) = read().toByte + j += 1 + } + len + } + } + } + + val stream = new DataInputStream(new BurstyStream(100, 5)) + val buf = new Array[Byte](50) + + stream.readFully(buf) + expect(buf.toJSArray).toEqual((1 to 50).toJSArray) + + stream.readFully(buf, 40, 10) + expect(buf.toJSArray).toEqual(((1 to 40) ++ (51 to 60)).toJSArray) + + expect(() => stream.readFully(buf)).toThrow + } + + it("should provide `readUTF`") { + val stream = newStream( + 0x00, 0x10, 0x48, 0xc3, 0xb6, 0x6c, 0x6c, 0xc3, + 0xb6, 0x20, 0x57, 0xc4, 0x83, 0x72, 0xc8, 0xb4, + 0xc4, 0x91, 0x00, 0x0d, 0x70, 0x6f, 0x6f, 0x20, + 0x2d, 0x3e, 0x20, 0xed, 0xa0, 0xbd, 0xed, 0xb2, + 0xa9, 0x00, 0x03, 0xe6, 0x84, 0x9b) + + expect(stream.readUTF).toEqual("Höllö Wărȴđ") + expect(stream.readUTF).toEqual("poo -> 💩") + expect(stream.readUTF).toEqual("愛") + + val badStream = newStream(0x00, 0x01, 0xC0, 0x82) + expect(() => badStream.readUTF).toThrow + } + + it("should provide `readLine`") { + val stream = newStream( + "Hello World\nUNIX\nWindows\r\nMac (old)\rStuff".map(_.toInt): _*) + + expect(stream.readLine()).toEqual("Hello World") + expect(stream.readLine()).toEqual("UNIX") + expect(stream.readLine()).toEqual("Windows") + expect(stream.readLine()).toEqual("Mac (old)") + expect(stream.readLine()).toEqual("Stuff") + expect(stream.readLine()).toBe(null) + } + + it("should allow marking even when `readLine` has to push back") { + val stream = newStream( + "Hello World\nUNIX\nWindows\r\nMac (old)\rStuff".map(_.toInt): _*) + + expect(stream.readLine()).toEqual("Hello World") + stream.mark(1000) + expect(stream.readLine()).toEqual("UNIX") + stream.reset() + expect(stream.readLine()).toEqual("UNIX") + expect(stream.readLine()).toEqual("Windows") + expect(stream.readLine()).toEqual("Mac (old)") + stream.mark(1000) + expect(stream.readLine()).toEqual("Stuff") + stream.reset() + expect(stream.readLine()).toEqual("Stuff") + expect(stream.readLine()).toBe(null) + } + + } + + } + + tests("java.io.DataInputStream - generic case")(bytes => + new ByteArrayInputStream(bytes.toArray)) + + tests("java.io.DataInputStream - ArrayBufferInputStream case")(bytes => + new ArrayBufferInputStream(new Int8Array(bytes.toJSArray).buffer)) + + tests("java.io.DataInputStream - partially consumed ArrayBufferInputStream case") { bytes => + val addBytes = Seq[Byte](0, 0, 0, 0) + val allBytes = addBytes ++ bytes + val in = new ArrayBufferInputStream( + new Int8Array(allBytes.toJSArray).buffer) + + for (_ <- addBytes) in.read() + + in + } + +} |