| // 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() |
| expectEncbufBytes(t, b, "") |
| copy(b.Grow(5), "abcde*****") |
| expectEncbufBytes(t, b, "abcde") |
| b.WriteOneByte('1') |
| expectEncbufBytes(t, b, "abcde1") |
| b.Write([]byte("def")) |
| expectEncbufBytes(t, b, "abcde1def") |
| b.Reset() |
| expectEncbufBytes(t, b, "") |
| b.Write([]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() |
| b.Write([]byte(str)) |
| expectEncbufBytes(t, b, str) |
| b.Write([]byte(str)) |
| expectEncbufBytes(t, b, str+str) |
| // Test starting with one byte and writing size. |
| b = newEncbuf() |
| b.WriteOneByte('A') |
| expectEncbufBytes(t, b, "A") |
| b.Write([]byte(str)) |
| expectEncbufBytes(t, b, "A"+str) |
| b.Write([]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 expectReadAvailable(t *testing.T, mode string, b *decbuf, n int, expect string, expectErr error) { |
| var err error |
| if !b.IsAvailable(n) { |
| err = b.Fill(n) |
| } |
| if got, want := err, expectErr; got != want { |
| t.Errorf("%s ReadAvailable err got %v, want %v", mode, got, want) |
| } |
| if err != nil { |
| return |
| } |
| buf := b.ReadAvailable(n) |
| if got, want := string(buf), expect; got != want { |
| t.Errorf("%s ReadAvailable buf got %q, want %q", mode, got, want) |
| } |
| } |
| |
| func expectSkip(t *testing.T, mode string, b *decbuf, n int, expectErr error) { |
| err := b.Skip(n) |
| if got, want := err, expectErr; got != want { |
| t.Errorf("%s Skip err got %v, want %v", mode, got, want) |
| } |
| } |
| |
| func expectPeekAvailable(t *testing.T, mode string, b *decbuf, n int, expect string, expectErr error) { |
| var err error |
| if !b.IsAvailable(n) { |
| err = b.Fill(n) |
| } |
| if got, want := err, expectErr; got != want { |
| t.Errorf("%s PeekAvailable err got %v, want %v", mode, got, want) |
| return |
| } |
| if err != nil { |
| return |
| } |
| buf := b.PeekAvailable(n) |
| if got, want := string(buf), expect; got != want { |
| t.Errorf("%s PeekAvailable buf got %q, want %q", mode, got, want) |
| } |
| } |
| |
| func expectReadAvailableByte(t *testing.T, mode string, b *decbuf, expect byte, expectErr error) { |
| var err error |
| if !b.IsAvailable(1) { |
| err = b.Fill(1) |
| } |
| if got, want := err, expectErr; got != want { |
| t.Errorf("%s ReadAvailableByte err got %v, want %v", mode, got, want) |
| } |
| if err != nil { |
| return |
| } |
| if got, want := b.ReadAvailableByte(), expect; got != want { |
| t.Errorf("%s ReadAvailableByte buf got %q, want %q", mode, got, want) |
| } |
| } |
| |
| func expectPeekAvailableByte(t *testing.T, mode string, b *decbuf, expect byte, expectErr error) { |
| var err error |
| if !b.IsAvailable(1) { |
| err = b.Fill(1) |
| } |
| if got, want := err, expectErr; got != want { |
| t.Errorf("%s PeekAvailableByte err got %v, want %v", mode, got, want) |
| } |
| if err != nil { |
| return |
| } |
| if got, want := b.PeekAvailableByte(), expect; got != want { |
| t.Errorf("%s PeekAvailableByte buf got %q, want %q", mode, got, want) |
| } |
| } |
| |
| func expectReadIntoBuf(t *testing.T, mode string, b *decbuf, n int, expect string, expectErr error) { |
| buf := make([]byte, n) |
| err := b.ReadIntoBuf(buf) |
| if got, want := err, expectErr; got != want { |
| t.Errorf("%s ReadIntoBuf err got %v, want %v", 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 TestDecbufReadAvailable(t *testing.T) { |
| fn := func(mode string, b *decbuf) { |
| expectReadAvailable(t, mode, b, 1, "a", nil) |
| expectReadAvailable(t, mode, b, 2, "bc", nil) |
| expectReadAvailable(t, mode, b, 3, "def", nil) |
| expectReadAvailable(t, mode, b, 4, "ghij", nil) |
| expectReadAvailable(t, mode, b, 1, "", io.EOF) |
| expectReadAvailable(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, nil) |
| expectReadAvailable(t, mode, b, 2, "bc", nil) |
| expectSkip(t, mode, b, 3, nil) |
| expectReadAvailable(t, mode, b, 2, "gh", nil) |
| expectSkip(t, mode, b, 2, nil) |
| expectSkip(t, mode, b, 1, io.EOF) |
| expectSkip(t, mode, b, 1, io.EOF) |
| expectReadAvailable(t, mode, b, 1, "", io.EOF) |
| expectReadAvailable(t, mode, b, 1, "", io.EOF) |
| } |
| for _, mode := range AllReadModes { |
| fn(mode.String(), newDecbuf(mode.TestReader(ABCReader(10)))) |
| } |
| fn("fromBytes", newDecbufFromBytes(ABCBytes(10))) |
| } |
| |
| func TestDecbufPeekAvailable(t *testing.T) { |
| fn := func(mode string, b *decbuf) { |
| expectPeekAvailable(t, mode, b, 1, "a", nil) |
| expectPeekAvailable(t, mode, b, 2, "ab", nil) |
| expectPeekAvailable(t, mode, b, 3, "abc", nil) |
| expectPeekAvailable(t, mode, b, 4, "", io.EOF) |
| expectPeekAvailable(t, mode, b, 1, "a", nil) |
| expectPeekAvailable(t, mode, b, 2, "ab", nil) |
| expectPeekAvailable(t, mode, b, 3, "abc", nil) |
| expectPeekAvailable(t, mode, b, 4, "", io.EOF) |
| |
| expectReadAvailable(t, mode, b, 1, "a", nil) |
| expectPeekAvailable(t, mode, b, 1, "b", nil) |
| expectPeekAvailable(t, mode, b, 2, "bc", nil) |
| expectPeekAvailable(t, mode, b, 3, "", io.EOF) |
| expectPeekAvailable(t, mode, b, 1, "b", nil) |
| expectPeekAvailable(t, mode, b, 2, "bc", nil) |
| expectPeekAvailable(t, mode, b, 3, "", io.EOF) |
| |
| expectReadAvailable(t, mode, b, 1, "b", nil) |
| expectPeekAvailable(t, mode, b, 1, "c", nil) |
| expectPeekAvailable(t, mode, b, 2, "", io.EOF) |
| expectPeekAvailable(t, mode, b, 1, "c", nil) |
| expectPeekAvailable(t, mode, b, 2, "", io.EOF) |
| |
| expectReadAvailable(t, mode, b, 1, "c", nil) |
| expectPeekAvailable(t, mode, b, 1, "", io.EOF) |
| expectPeekAvailable(t, mode, b, 1, "", io.EOF) |
| |
| expectReadAvailable(t, mode, b, 1, "", io.EOF) |
| expectPeekAvailable(t, mode, b, 1, "", io.EOF) |
| expectPeekAvailable(t, mode, b, 1, "", io.EOF) |
| } |
| for _, mode := range AllReadModes { |
| fn(mode.String(), newDecbuf(mode.TestReader(ABCReader(3)))) |
| } |
| fn("fromBytes", newDecbufFromBytes(ABCBytes(3))) |
| } |
| |
| func TestDecbufReadAvailableByte(t *testing.T) { |
| fn := func(mode string, b *decbuf) { |
| expectReadAvailableByte(t, mode, b, 'a', nil) |
| expectReadAvailableByte(t, mode, b, 'b', nil) |
| expectReadAvailableByte(t, mode, b, 'c', nil) |
| expectReadAvailableByte(t, mode, b, 0, io.EOF) |
| expectReadAvailableByte(t, mode, b, 0, io.EOF) |
| } |
| for _, mode := range AllReadModes { |
| fn(mode.String(), newDecbuf(mode.TestReader(ABCReader(3)))) |
| } |
| fn("fromBytes", newDecbufFromBytes(ABCBytes(3))) |
| } |
| |
| func TestDecbufPeekAvailableByte(t *testing.T) { |
| fn := func(mode string, b *decbuf) { |
| expectPeekAvailableByte(t, mode, b, 'a', nil) |
| expectPeekAvailableByte(t, mode, b, 'a', nil) |
| expectReadAvailableByte(t, mode, b, 'a', nil) |
| |
| expectPeekAvailableByte(t, mode, b, 'b', nil) |
| expectPeekAvailableByte(t, mode, b, 'b', nil) |
| expectReadAvailableByte(t, mode, b, 'b', nil) |
| |
| expectPeekAvailableByte(t, mode, b, 'c', nil) |
| expectPeekAvailableByte(t, mode, b, 'c', nil) |
| expectReadAvailableByte(t, mode, b, 'c', nil) |
| |
| expectPeekAvailableByte(t, mode, b, 0, io.EOF) |
| expectPeekAvailableByte(t, mode, b, 0, io.EOF) |
| expectReadAvailableByte(t, mode, b, 0, io.EOF) |
| } |
| for _, mode := range AllReadModes { |
| fn(mode.String(), newDecbuf(mode.TestReader(ABCReader(3)))) |
| } |
| fn("fromBytes", newDecbufFromBytes(ABCBytes(3))) |
| } |
| |
| func TestDecbufReadIntoBuf(t *testing.T) { |
| fn1 := func(mode string, b *decbuf) { |
| // Start ReadFull from beginning. |
| expectReadIntoBuf(t, mode, b, 3, "abc", nil) |
| expectReadIntoBuf(t, mode, b, 3, "def", nil) |
| expectReadIntoBuf(t, mode, b, 1, "", io.EOF) |
| expectReadIntoBuf(t, mode, b, 1, "", io.EOF) |
| } |
| fn2 := func(mode string, b *decbuf) { |
| // Start ReadFull after reading 1 byte, which fills the buffer. |
| expectReadAvailable(t, mode, b, 1, "a", nil) |
| expectReadIntoBuf(t, mode, b, 2, "bc", nil) |
| expectReadIntoBuf(t, mode, b, 3, "def", nil) |
| expectReadIntoBuf(t, mode, b, 1, "", io.EOF) |
| expectReadIntoBuf(t, mode, b, 1, "", 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))) |
| } |
