Initial project import

tools/v/vlib/encoding/binary/stream_test.v

@@ -0,0 +1,132 @@
+module binary
+
+import io
+
+struct ChunkedReader {
+	data  []u8
+	chunk int = 1
+mut:
+	offset int
+}
+
+fn (mut r ChunkedReader) read(mut buf []u8) !int {
+	if r.offset >= r.data.len {
+		return io.Eof{}
+	}
+	mut n := if r.chunk > 0 && r.chunk < buf.len { r.chunk } else { buf.len }
+	remaining := r.data.len - r.offset
+	if remaining < n {
+		n = remaining
+	}
+	copy(mut buf[..n], r.data[r.offset..r.offset + n])
+	r.offset += n
+	return n
+}
+
+struct ChunkedWriter {
+	chunk int = 1
+mut:
+	data []u8
+}
+
+fn (mut w ChunkedWriter) write(buf []u8) !int {
+	if buf.len == 0 {
+		return 0
+	}
+	n := if w.chunk > 0 && w.chunk < buf.len { w.chunk } else { buf.len }
+	w.data << buf[..n]
+	return n
+}
+
+struct Packet {
+	flag    bool
+	count   u16
+	values  [2]u32
+	sample  f32
+	trailer [3]u8
+}
+
+struct UnsupportedPacket {
+	name string
+}
+
+fn test_stream_write_and_read_struct() {
+	packet := Packet{
+		flag:    true
+		count:   0x1234
+		values:  [u32(0x11223344), 0x55667788]!
+		sample:  f32(12.5)
+		trailer: [u8(1), 2, 3]!
+	}
+	mut writer := ChunkedWriter{
+		chunk: 3
+	}
+	write(mut writer, big_endian, packet)!
+	assert size(packet) == writer.data.len
+
+	mut reader := ChunkedReader{
+		data:  writer.data.clone()
+		chunk: 2
+	}
+	mut decoded := Packet{}
+	read(mut reader, big_endian, mut decoded)!
+	assert decoded == packet
+}
+
+fn test_stream_read_and_write_slice() {
+	values := [u16(0x0102), 0x0304, 0x0506]
+	mut writer := ChunkedWriter{
+		chunk: 2
+	}
+	write(mut writer, little_endian, values)!
+	assert size(values) == 6
+
+	mut reader := ChunkedReader{
+		data:  writer.data.clone()
+		chunk: 1
+	}
+	mut decoded := []u16{len: values.len}
+	read(mut reader, little_endian, mut decoded)!
+	assert decoded == values
+}
+
+fn test_stream_read_and_write_bytes() {
+	bytes := [u8(9), 8, 7, 6, 5]
+	mut writer := ChunkedWriter{
+		chunk: 4
+	}
+	write(mut writer, little_endian, bytes)!
+
+	mut reader := ChunkedReader{
+		data:  writer.data.clone()
+		chunk: 2
+	}
+	mut decoded := []u8{len: bytes.len}
+	read(mut reader, little_endian, mut decoded)!
+	assert decoded == bytes
+}
+
+fn test_stream_short_read_returns_eof() {
+	mut reader := ChunkedReader{
+		data:  [u8(1), 2]
+		chunk: 1
+	}
+	mut value := u32(0)
+	if _ := read(mut reader, little_endian, mut value) {
+		assert false
+	} else {
+		assert err is io.Eof
+	}
+}
+
+fn test_stream_reports_unsupported_types() {
+	assert size('hello') == -1
+	assert size(UnsupportedPacket{}) == -1
+
+	mut writer := ChunkedWriter{}
+	if _ := write(mut writer, little_endian, 'hello') {
+		assert false
+	} else {
+		assert err.msg() == 'binary.write: unsupported type string'
+	}
+}