mirror of
https://github.com/vlang/v.git
synced 2025-09-08 23:07:19 -04:00
138 lines
3.2 KiB
V
138 lines
3.2 KiB
V
import io
|
|
import rand
|
|
|
|
fn small_amount() int {
|
|
return int(rand.u8()) + 1
|
|
}
|
|
|
|
struct ArrayWriter {
|
|
pub mut:
|
|
result []u8
|
|
}
|
|
|
|
// implement io.Writer
|
|
fn (mut aw ArrayWriter) write(buf []u8) !int {
|
|
len := buf.len
|
|
mut res := 0
|
|
for i := 0; i < len; i++ {
|
|
aw.result << buf[i]
|
|
res++
|
|
}
|
|
return res
|
|
}
|
|
|
|
// write less than max bytes, returns number of bytes written
|
|
// data is written in chunks.
|
|
fn write_random_data(mut aw ArrayWriter, mut bw io.BufferedWriter, max int) !int {
|
|
less_than_max := max - 255 // guarantee 1 full u8 less than max
|
|
mut total := 0
|
|
for total < less_than_max {
|
|
r := rand.u8()
|
|
d := rand.bytes(r)!
|
|
w := bw.write(d)!
|
|
total += w
|
|
}
|
|
return total
|
|
}
|
|
|
|
fn test_flush() {
|
|
mut aw := ArrayWriter{}
|
|
max := 65536
|
|
mut bw := io.new_buffered_writer(writer: aw, cap: max)!
|
|
|
|
// write less data than buffer capacity, the underlying writer should receive no data.
|
|
written := write_random_data(mut aw, mut bw, 65536)!
|
|
assert written == bw.buffered()
|
|
assert aw.result.len == 0
|
|
|
|
bw.flush()!
|
|
assert aw.result.len == written
|
|
assert bw.buffered() == 0
|
|
assert bw.available() == max
|
|
}
|
|
|
|
fn test_write() {
|
|
mut aw := ArrayWriter{}
|
|
max := 65536
|
|
mut bw := io.new_buffered_writer(writer: aw, cap: max)!
|
|
|
|
// write less data than buffer capacity, the underlying writer should receive no data.
|
|
written := write_random_data(mut aw, mut bw, 65536)!
|
|
|
|
// now exceed buffer capacity by a little
|
|
little := small_amount()
|
|
excess := bw.available() + little
|
|
excess_data := rand.bytes(excess)!
|
|
w := bw.write(excess_data)!
|
|
assert bw.buffered() == little
|
|
assert bw.available() == max - little
|
|
assert aw.result.len == max
|
|
}
|
|
|
|
fn test_write_big() {
|
|
mut aw := ArrayWriter{}
|
|
max := 65536
|
|
mut bw := io.new_buffered_writer(writer: aw, cap: max)!
|
|
|
|
more_than_max := max + small_amount()
|
|
big_source := rand.bytes(more_than_max)!
|
|
w := bw.write(big_source)!
|
|
assert w == more_than_max
|
|
assert bw.buffered() == 0
|
|
assert bw.available() == max
|
|
assert aw.result.len == more_than_max
|
|
}
|
|
|
|
// create_data returns an array with `n` elements plus `\n` as last character.
|
|
fn create_data(n int) []u8 {
|
|
mut res := []u8{}
|
|
for i := 0; i < n; i++ {
|
|
res << `X`
|
|
}
|
|
res << `\n`
|
|
return res
|
|
}
|
|
|
|
fn test_simple_write() {
|
|
mut aw := ArrayWriter{}
|
|
mut bw := io.new_buffered_writer(writer: aw, cap: 10)!
|
|
mut data := create_data(6)
|
|
w1 := bw.write(data)!
|
|
|
|
// add data to buffer, less than cap
|
|
// data is written to buffer, not to underlying writer.
|
|
assert w1 == 7 // 6*x + \n
|
|
assert bw.buffered() == 7
|
|
assert aw.result.len == 0
|
|
|
|
// add more data, exceed cap
|
|
// data is flushed to underlying writer when buffer is full, then more data is written to buffer.
|
|
w2 := bw.write(data)!
|
|
assert w2 == 7
|
|
assert bw.buffered() == 4
|
|
assert aw.result.len == 10
|
|
|
|
// exceed cap immediately
|
|
// all data is written without buffering
|
|
aw.result = []u8{}
|
|
data = create_data(33)
|
|
bw.reset()
|
|
w3 := bw.write(data)!
|
|
assert bw.buffered() == 0
|
|
assert aw.result.len == 34 // 33*x + \n
|
|
}
|
|
|
|
fn test_simple_flush() {
|
|
mut aw := ArrayWriter{}
|
|
mut bw := io.new_buffered_writer(writer: aw, cap: 10)!
|
|
data := create_data(6)
|
|
w := bw.write(data)!
|
|
|
|
assert w == 7 // 6*x + \n
|
|
assert bw.buffered() == 7
|
|
|
|
bw.flush()!
|
|
assert bw.buffered() == 0
|
|
assert aw.result.len == 7
|
|
}
|