| // Copyright 2015 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package vom |
| |
| // TODO(toddw): Add more exhaustive tests of decbuf SetLimit and fill. |
| |
| import ( |
| "io" |
| "strings" |
| "testing" |
| ) |
| |
| func expectEncbufBytes(t *testing.T, b *encbuf, expect string) { |
| if got, want := b.Len(), len(expect); got != want { |
| t.Errorf("len got %d, want %d", got, want) |
| } |
| if got, want := string(b.Bytes()), expect; got != want { |
| t.Errorf("bytes got %q, want %q", b.Bytes(), expect) |
| } |
| } |
| |
| func TestEncbuf(t *testing.T) { |
| b := newEncbuf(2 << 14) |
| expectEncbufBytes(t, b, "") |
| copy(b.Grow(5), "abcde*****") |
| expectEncbufBytes(t, b, "abcde") |
| b.WriteOneByte('1') |
| expectEncbufBytes(t, b, "abcde1") |
| b.WriteMaximumPossible([]byte("def")) |
| expectEncbufBytes(t, b, "abcde1def") |
| b.Reset() |
| expectEncbufBytes(t, b, "") |
| b.WriteMaximumPossible([]byte("123")) |
| expectEncbufBytes(t, b, "123") |
| } |
| |
| func testEncbufReserve(t *testing.T, base int) { |
| for _, size := range []int{base - 1, base, base + 1} { |
| str := strings.Repeat("x", size) |
| // Test starting empty and writing size. |
| b := newEncbuf(2 << 14) |
| b.WriteMaximumPossible([]byte(str)) |
| expectEncbufBytes(t, b, str) |
| b.WriteMaximumPossible([]byte(str)) |
| expectEncbufBytes(t, b, str+str) |
| // Test starting with one byte and writing size. |
| b = newEncbuf(2 << 14) |
| b.WriteOneByte('A') |
| expectEncbufBytes(t, b, "A") |
| b.WriteMaximumPossible([]byte(str)) |
| expectEncbufBytes(t, b, "A"+str) |
| b.WriteMaximumPossible([]byte(str)) |
| expectEncbufBytes(t, b, "A"+str+str) |
| } |
| } |
| |
| func TestEncbufReserve(t *testing.T) { |
| testEncbufReserve(t, minBufFree) |
| testEncbufReserve(t, minBufFree*2) |
| testEncbufReserve(t, minBufFree*3) |
| testEncbufReserve(t, minBufFree*4) |
| } |
| |
| func TestEncbufHitMaximum(t *testing.T) { |
| maxSize := 2 << 10 |
| b := newEncbuf(maxSize) |
| b.WriteOneByte('A') |
| b.WriteOneByte('B') |
| str := strings.Repeat("x", maxSize) |
| amtWritten := b.WriteMaximumPossible([]byte(str)) |
| if got, want := amtWritten, maxSize-2; got != want { |
| t.Errorf("expected %d bytes to be written, but %d were", want, got) |
| } |
| expectEncbufBytes(t, b, "AB"+str[:len(str)-2]) |
| } |
| |
| func expectReadSmall(t *testing.T, mode string, b *decbuf, n int, expect string, expectErr error) { |
| buf, err := b.ReadSmall(n) |
| if err != nil { |
| if got, want := err, expectErr; got != want { |
| t.Errorf("%s ReadBuf err got %v, want %v", mode, got, want) |
| } |
| return |
| } |
| if got, want := string(buf)[:n], expect; got != want { |
| t.Errorf("%s ReadBuf buf got %q, want %q", mode, got, want) |
| } |
| } |
| |
| func expectSkip(t *testing.T, mode string, b *decbuf, n, expectN int, expectErr error) { |
| nGot, err := b.Skip(n) |
| if got, want := err, expectErr; got != want { |
| t.Errorf("%s Skip err got %v, want %v", mode, got, want) |
| } else if got, want := nGot, expectN; got != want { |
| t.Errorf("%s Skip %d bytes only skipped %d", mode, want, got) |
| } |
| } |
| |
| func expectPeekSmall(t *testing.T, mode string, b *decbuf, n int, expect string, expectErr error) { |
| buf, err := b.PeekSmall(n) |
| if err != nil { |
| if got, want := err, expectErr; got != want { |
| t.Errorf("%s PeakSmall err got %v, want %v", mode, got, want) |
| } |
| return |
| } |
| if got, want := string(buf)[:n], expect; got != want { |
| t.Errorf("%s PeakSmall buf got %q, want %q", mode, got, want) |
| } |
| } |
| |
| func expectReadByte(t *testing.T, mode string, b *decbuf, expect byte, expectErr error) { |
| actual, err := b.ReadByte() |
| if got, want := err, expectErr; got != want { |
| t.Errorf("%s ReadByte err got %v, want %v", mode, got, want) |
| } |
| if got, want := actual, expect; got != want { |
| t.Errorf("%s ReadByte buf got %q, want %q", mode, got, want) |
| } |
| } |
| |
| func expectPeekByte(t *testing.T, mode string, b *decbuf, expect byte, expectErr error) { |
| actual, err := b.PeekByte() |
| if got, want := err, expectErr; got != want { |
| t.Errorf("%s PeekByte err got %v, want %v", mode, got, want) |
| } |
| if got, want := actual, expect; got != want { |
| t.Errorf("%s PeekByte buf got %q, want %q", mode, got, want) |
| } |
| } |
| |
| func expectReadIntoBuf(t *testing.T, mode string, b *decbuf, n, expectN int, expect string, expectErr error) { |
| buf := make([]byte, n) |
| nGot, err := b.ReadIntoBuf(buf) |
| if got, want := err, expectErr; got != want { |
| t.Errorf("%s ReadIntoBuf err got %v, want %v", mode, got, want) |
| } else if got, want := nGot, expectN; got != want { |
| t.Errorf("%s ReadIntoBuf read %d but expected %d", mode, got, want) |
| } |
| if err == nil { |
| if got, want := string(buf), expect; got != want { |
| t.Errorf("%s ReadIntoBuf buf got %q, want %q", mode, got, want) |
| } |
| } |
| } |
| |
| func TestDecbufReadSmall(t *testing.T) { |
| fn := func(mode string, b *decbuf) { |
| expectReadSmall(t, mode, b, 1, "a", nil) |
| expectReadSmall(t, mode, b, 2, "bc", nil) |
| expectReadSmall(t, mode, b, 3, "def", nil) |
| expectReadSmall(t, mode, b, 4, "ghij", nil) |
| expectReadSmall(t, mode, b, 1, "", io.EOF) |
| expectReadSmall(t, mode, b, 1, "", io.EOF) |
| } |
| for _, mode := range allReadModes { |
| fn(mode.String(), newDecbuf(mode.testReader(abcReader(10)))) |
| } |
| fn("fromBytes", newDecbufFromBytes(abcBytes(10))) |
| } |
| |
| func TestDecbufSkip(t *testing.T) { |
| fn := func(mode string, b *decbuf) { |
| expectSkip(t, mode, b, 1, 1, nil) |
| expectReadSmall(t, mode, b, 2, "bc", nil) |
| expectSkip(t, mode, b, 3, 3, nil) |
| expectReadSmall(t, mode, b, 2, "gh", nil) |
| expectSkip(t, mode, b, 2, 2, nil) |
| expectSkip(t, mode, b, 1, 0, io.EOF) |
| expectSkip(t, mode, b, 1, 0, io.EOF) |
| expectReadSmall(t, mode, b, 1, "", io.EOF) |
| expectReadSmall(t, mode, b, 1, "", io.EOF) |
| } |
| for _, mode := range allReadModes { |
| fn(mode.String(), newDecbuf(mode.testReader(abcReader(10)))) |
| } |
| fn("fromBytes", newDecbufFromBytes(abcBytes(10))) |
| } |
| |
| func TestDecbufPeekSmall(t *testing.T) { |
| fn1 := func(mode string, b *decbuf) { |
| // Start peeking at beginning. |
| expectPeekSmall(t, mode, b, 1, "a", nil) |
| expectPeekSmall(t, mode, b, 2, "ab", nil) |
| expectPeekSmall(t, mode, b, 3, "abc", nil) |
| expectPeekSmall(t, mode, b, 4, "", io.EOF) |
| expectReadSmall(t, mode, b, 3, "abc", nil) |
| expectReadSmall(t, mode, b, 1, "", io.EOF) |
| expectPeekSmall(t, mode, b, 1, "", io.EOF) |
| } |
| fn2 := func(mode string, b *decbuf) { |
| // Start peeking after reading 1 byte, which fills the buffer |
| expectReadSmall(t, mode, b, 1, "a", nil) |
| expectPeekSmall(t, mode, b, 1, "b", nil) |
| expectPeekSmall(t, mode, b, 2, "bc", nil) |
| expectPeekSmall(t, mode, b, 3, "bcd", nil) |
| expectPeekSmall(t, mode, b, 4, "", io.EOF) |
| expectReadSmall(t, mode, b, 3, "bcd", nil) |
| expectReadSmall(t, mode, b, 1, "", io.EOF) |
| expectPeekSmall(t, mode, b, 1, "", io.EOF) |
| } |
| for _, mode := range []readMode{readAll, readHalf, readAllEOF, readHalfEOF} { |
| fn1(mode.String(), newDecbuf(mode.testReader(abcReader(3)))) |
| fn2(mode.String(), newDecbuf(mode.testReader(abcReader(4)))) |
| } |
| fn1("fromBytes", newDecbufFromBytes(abcBytes(3))) |
| fn2("fromBytes", newDecbufFromBytes(abcBytes(4))) |
| } |
| |
| func TestDecbufPeekSmall1(t *testing.T) { |
| fn1 := func(mode string, b *decbuf) { |
| // Start peeking at beginning. |
| expectPeekSmall(t, mode, b, 1, "a", nil) |
| expectPeekSmall(t, mode, b, 2, "ab", nil) |
| expectPeekSmall(t, mode, b, 3, "abc", nil) |
| expectPeekSmall(t, mode, b, 2, "ab", nil) |
| expectPeekSmall(t, mode, b, 1, "a", nil) |
| expectPeekSmall(t, mode, b, 4, "", io.EOF) |
| expectReadSmall(t, mode, b, 3, "abc", nil) |
| expectReadSmall(t, mode, b, 1, "", io.EOF) |
| expectPeekSmall(t, mode, b, 1, "", io.EOF) |
| } |
| fn2 := func(mode string, b *decbuf) { |
| // Start peeking after reading 1 byte, which fills the buffer |
| expectReadSmall(t, mode, b, 1, "a", nil) |
| expectPeekSmall(t, mode, b, 1, "b", nil) |
| expectPeekSmall(t, mode, b, 2, "bc", nil) |
| expectPeekSmall(t, mode, b, 3, "bcd", nil) |
| expectPeekSmall(t, mode, b, 2, "bc", nil) |
| expectPeekSmall(t, mode, b, 1, "b", nil) |
| expectPeekSmall(t, mode, b, 4, "", io.EOF) |
| expectReadSmall(t, mode, b, 3, "bcd", nil) |
| expectReadSmall(t, mode, b, 1, "", io.EOF) |
| expectPeekSmall(t, mode, b, 1, "", io.EOF) |
| } |
| for _, mode := range []readMode{readOneByte, readOneByteEOF} { |
| fn1(mode.String(), newDecbuf(mode.testReader(abcReader(3)))) |
| fn2(mode.String(), newDecbuf(mode.testReader(abcReader(4)))) |
| } |
| // Don't try newDecbufFromBytes for this test, since it requires filling the |
| // buffer one byte at a time. |
| } |
| |
| func TestDecbufReadByte(t *testing.T) { |
| fn := func(mode string, b *decbuf) { |
| expectReadByte(t, mode, b, 'a', nil) |
| expectReadByte(t, mode, b, 'b', nil) |
| expectReadByte(t, mode, b, 'c', nil) |
| expectReadByte(t, mode, b, 0, io.EOF) |
| expectReadByte(t, mode, b, 0, io.EOF) |
| } |
| for _, mode := range allReadModes { |
| fn(mode.String(), newDecbuf(mode.testReader(abcReader(3)))) |
| } |
| fn("fromBytes", newDecbufFromBytes(abcBytes(3))) |
| } |
| |
| func TestDecbufPeekByte(t *testing.T) { |
| fn := func(mode string, b *decbuf) { |
| expectPeekByte(t, mode, b, 'a', nil) |
| expectPeekByte(t, mode, b, 'a', nil) |
| expectReadByte(t, mode, b, 'a', nil) |
| |
| expectPeekByte(t, mode, b, 'b', nil) |
| expectPeekByte(t, mode, b, 'b', nil) |
| expectReadByte(t, mode, b, 'b', nil) |
| |
| expectPeekByte(t, mode, b, 'c', nil) |
| expectPeekByte(t, mode, b, 'c', nil) |
| expectReadByte(t, mode, b, 'c', nil) |
| |
| expectPeekByte(t, mode, b, 0, io.EOF) |
| expectPeekByte(t, mode, b, 0, io.EOF) |
| expectReadByte(t, mode, b, 0, io.EOF) |
| } |
| for _, mode := range allReadModes { |
| fn(mode.String(), newDecbuf(mode.testReader(abcReader(3)))) |
| } |
| fn("fromBytes", newDecbufFromBytes(abcBytes(3))) |
| } |
| |
| func TestDecbufReadIntBuf(t *testing.T) { |
| fn1 := func(mode string, b *decbuf) { |
| // Start ReadFull from beginning. |
| expectReadIntoBuf(t, mode, b, 3, 3, "abc", nil) |
| expectReadIntoBuf(t, mode, b, 3, 3, "def", nil) |
| expectReadIntoBuf(t, mode, b, 1, 0, "", io.EOF) |
| expectReadIntoBuf(t, mode, b, 1, 0, "", io.EOF) |
| } |
| fn2 := func(mode string, b *decbuf) { |
| // Start ReadFull after reading 1 byte, which fills the buffer. |
| expectReadSmall(t, mode, b, 1, "a", nil) |
| expectReadIntoBuf(t, mode, b, 2, 2, "bc", nil) |
| expectReadIntoBuf(t, mode, b, 3, 3, "def", nil) |
| expectReadIntoBuf(t, mode, b, 1, 0, "", io.EOF) |
| expectReadIntoBuf(t, mode, b, 1, 0, "", io.EOF) |
| } |
| for _, mode := range allReadModes { |
| fn1(mode.String(), newDecbuf(mode.testReader(abcReader(6)))) |
| fn2(mode.String(), newDecbuf(mode.testReader(abcReader(6)))) |
| } |
| fn1("fromBytes", newDecbufFromBytes(abcBytes(6))) |
| fn2("fromBytes", newDecbufFromBytes(abcBytes(6))) |
| } |
