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
}
}
