630 lines
16 KiB
Go
630 lines
16 KiB
Go
// Copyright 2018 The gVisor Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
// Package buffer_test contains tests for the buffer.VectorisedView type.
|
|
package buffer_test
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"reflect"
|
|
"testing"
|
|
"unsafe"
|
|
|
|
"gvisor.dev/gvisor/pkg/tcpip"
|
|
"gvisor.dev/gvisor/pkg/tcpip/buffer"
|
|
)
|
|
|
|
// copy returns a deep-copy of the vectorised view.
|
|
func copyVV(vv buffer.VectorisedView) buffer.VectorisedView {
|
|
views := make([]buffer.View, 0, len(vv.Views()))
|
|
for _, v := range vv.Views() {
|
|
views = append(views, append(buffer.View(nil), v...))
|
|
}
|
|
return buffer.NewVectorisedView(vv.Size(), views)
|
|
}
|
|
|
|
// vv is an helper to build buffer.VectorisedView from different strings.
|
|
func vv(size int, pieces ...string) buffer.VectorisedView {
|
|
views := make([]buffer.View, len(pieces))
|
|
for i, p := range pieces {
|
|
views[i] = []byte(p)
|
|
}
|
|
|
|
return buffer.NewVectorisedView(size, views)
|
|
}
|
|
|
|
// v returns a buffer.View containing piece.
|
|
func v(piece string) buffer.View {
|
|
return buffer.View(piece)
|
|
}
|
|
|
|
var capLengthTestCases = []struct {
|
|
comment string
|
|
in buffer.VectorisedView
|
|
length int
|
|
want buffer.VectorisedView
|
|
}{
|
|
{
|
|
comment: "Simple case",
|
|
in: vv(2, "12"),
|
|
length: 1,
|
|
want: vv(1, "1"),
|
|
},
|
|
{
|
|
comment: "Case spanning across two Views",
|
|
in: vv(4, "123", "4"),
|
|
length: 2,
|
|
want: vv(2, "12"),
|
|
},
|
|
{
|
|
comment: "Corner case with negative length",
|
|
in: vv(1, "1"),
|
|
length: -1,
|
|
want: vv(0),
|
|
},
|
|
{
|
|
comment: "Corner case with length = 0",
|
|
in: vv(3, "12", "3"),
|
|
length: 0,
|
|
want: vv(0),
|
|
},
|
|
{
|
|
comment: "Corner case with length = size",
|
|
in: vv(1, "1"),
|
|
length: 1,
|
|
want: vv(1, "1"),
|
|
},
|
|
{
|
|
comment: "Corner case with length > size",
|
|
in: vv(1, "1"),
|
|
length: 2,
|
|
want: vv(1, "1"),
|
|
},
|
|
}
|
|
|
|
func TestCapLength(t *testing.T) {
|
|
for _, c := range capLengthTestCases {
|
|
orig := copyVV(c.in)
|
|
c.in.CapLength(c.length)
|
|
if !reflect.DeepEqual(c.in, c.want) {
|
|
t.Errorf("Test \"%s\" failed when calling CapLength(%d) on %v. Got %v. Want %v",
|
|
c.comment, c.length, orig, c.in, c.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
var trimFrontTestCases = []struct {
|
|
comment string
|
|
in buffer.VectorisedView
|
|
count int
|
|
want buffer.VectorisedView
|
|
}{
|
|
{
|
|
comment: "Simple case",
|
|
in: vv(2, "12"),
|
|
count: 1,
|
|
want: vv(1, "2"),
|
|
},
|
|
{
|
|
comment: "Case where we trim an entire View",
|
|
in: vv(2, "1", "2"),
|
|
count: 1,
|
|
want: vv(1, "2"),
|
|
},
|
|
{
|
|
comment: "Case spanning across two Views",
|
|
in: vv(3, "1", "23"),
|
|
count: 2,
|
|
want: vv(1, "3"),
|
|
},
|
|
{
|
|
comment: "Case with one empty Views",
|
|
in: vv(3, "1", "", "23"),
|
|
count: 2,
|
|
want: vv(1, "3"),
|
|
},
|
|
{
|
|
comment: "Corner case with negative count",
|
|
in: vv(1, "1"),
|
|
count: -1,
|
|
want: vv(1, "1"),
|
|
},
|
|
{
|
|
comment: " Corner case with count = 0",
|
|
in: vv(1, "1"),
|
|
count: 0,
|
|
want: vv(1, "1"),
|
|
},
|
|
{
|
|
comment: "Corner case with count = size",
|
|
in: vv(1, "1"),
|
|
count: 1,
|
|
want: vv(0),
|
|
},
|
|
{
|
|
comment: "Corner case with count > size",
|
|
in: vv(1, "1"),
|
|
count: 2,
|
|
want: vv(0),
|
|
},
|
|
}
|
|
|
|
func TestTrimFront(t *testing.T) {
|
|
for _, c := range trimFrontTestCases {
|
|
orig := copyVV(c.in)
|
|
c.in.TrimFront(c.count)
|
|
if !reflect.DeepEqual(c.in, c.want) {
|
|
t.Errorf("Test \"%s\" failed when calling TrimFront(%d) on %v. Got %v. Want %v",
|
|
c.comment, c.count, orig, c.in, c.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
var toViewCases = []struct {
|
|
comment string
|
|
in buffer.VectorisedView
|
|
want buffer.View
|
|
}{
|
|
{
|
|
comment: "Simple case",
|
|
in: vv(2, "12"),
|
|
want: []byte("12"),
|
|
},
|
|
{
|
|
comment: "Case with multiple views",
|
|
in: vv(2, "1", "2"),
|
|
want: []byte("12"),
|
|
},
|
|
{
|
|
comment: "Empty case",
|
|
in: vv(0),
|
|
want: []byte(""),
|
|
},
|
|
}
|
|
|
|
func TestToView(t *testing.T) {
|
|
for _, c := range toViewCases {
|
|
got := c.in.ToView()
|
|
if !reflect.DeepEqual(got, c.want) {
|
|
t.Errorf("Test \"%s\" failed when calling ToView() on %v. Got %v. Want %v",
|
|
c.comment, c.in, got, c.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
var toCloneCases = []struct {
|
|
comment string
|
|
inView buffer.VectorisedView
|
|
inBuffer []buffer.View
|
|
}{
|
|
{
|
|
comment: "Simple case",
|
|
inView: vv(1, "1"),
|
|
inBuffer: make([]buffer.View, 1),
|
|
},
|
|
{
|
|
comment: "Case with multiple views",
|
|
inView: vv(2, "1", "2"),
|
|
inBuffer: make([]buffer.View, 2),
|
|
},
|
|
{
|
|
comment: "Case with buffer too small",
|
|
inView: vv(2, "1", "2"),
|
|
inBuffer: make([]buffer.View, 1),
|
|
},
|
|
{
|
|
comment: "Case with buffer larger than needed",
|
|
inView: vv(1, "1"),
|
|
inBuffer: make([]buffer.View, 2),
|
|
},
|
|
{
|
|
comment: "Case with nil buffer",
|
|
inView: vv(1, "1"),
|
|
inBuffer: nil,
|
|
},
|
|
}
|
|
|
|
func TestToClone(t *testing.T) {
|
|
for _, c := range toCloneCases {
|
|
t.Run(c.comment, func(t *testing.T) {
|
|
got := c.inView.Clone(c.inBuffer)
|
|
if !reflect.DeepEqual(got, c.inView) {
|
|
t.Fatalf("got (%+v).Clone(%+v) = %+v, want = %+v",
|
|
c.inView, c.inBuffer, got, c.inView)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
type readToTestCases struct {
|
|
comment string
|
|
vv buffer.VectorisedView
|
|
bytesToRead int
|
|
wantBytes string
|
|
leftVV buffer.VectorisedView
|
|
}
|
|
|
|
func createReadToTestCases() []readToTestCases {
|
|
return []readToTestCases{
|
|
{
|
|
comment: "large VV, short read",
|
|
vv: vv(30, "012345678901234567890123456789"),
|
|
bytesToRead: 10,
|
|
wantBytes: "0123456789",
|
|
leftVV: vv(20, "01234567890123456789"),
|
|
},
|
|
{
|
|
comment: "largeVV, multiple views, short read",
|
|
vv: vv(13, "123", "345", "567", "8910"),
|
|
bytesToRead: 6,
|
|
wantBytes: "123345",
|
|
leftVV: vv(7, "567", "8910"),
|
|
},
|
|
{
|
|
comment: "smallVV (multiple views), large read",
|
|
vv: vv(3, "1", "2", "3"),
|
|
bytesToRead: 10,
|
|
wantBytes: "123",
|
|
leftVV: vv(0, ""),
|
|
},
|
|
{
|
|
comment: "smallVV (single view), large read",
|
|
vv: vv(1, "1"),
|
|
bytesToRead: 10,
|
|
wantBytes: "1",
|
|
leftVV: vv(0, ""),
|
|
},
|
|
{
|
|
comment: "emptyVV, large read",
|
|
vv: vv(0, ""),
|
|
bytesToRead: 10,
|
|
wantBytes: "",
|
|
leftVV: vv(0, ""),
|
|
},
|
|
}
|
|
}
|
|
|
|
func TestVVReadToVV(t *testing.T) {
|
|
for _, tc := range createReadToTestCases() {
|
|
t.Run(tc.comment, func(t *testing.T) {
|
|
var readTo buffer.VectorisedView
|
|
inSize := tc.vv.Size()
|
|
copied := tc.vv.ReadToVV(&readTo, tc.bytesToRead)
|
|
if got, want := copied, len(tc.wantBytes); got != want {
|
|
t.Errorf("incorrect number of bytes copied returned in ReadToVV got: %d, want: %d, tc: %+v", got, want, tc)
|
|
}
|
|
if got, want := string(readTo.ToView()), tc.wantBytes; got != want {
|
|
t.Errorf("unexpected content in readTo got: %s, want: %s", got, want)
|
|
}
|
|
if got, want := tc.vv.Size(), inSize-copied; got != want {
|
|
t.Errorf("test VV has incorrect size after reading got: %d, want: %d, tc.vv: %+v", got, want, tc.vv)
|
|
}
|
|
if got, want := string(tc.vv.ToView()), string(tc.leftVV.ToView()); got != want {
|
|
t.Errorf("unexpected data left in vv after read got: %+v, want: %+v", got, want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestVVReadTo(t *testing.T) {
|
|
for _, tc := range createReadToTestCases() {
|
|
t.Run(tc.comment, func(t *testing.T) {
|
|
b := make([]byte, tc.bytesToRead)
|
|
dst := tcpip.SliceWriter(b)
|
|
origSize := tc.vv.Size()
|
|
copied, err := tc.vv.ReadTo(&dst, false /* peek */)
|
|
if err != nil && err != io.ErrShortWrite {
|
|
t.Errorf("got ReadTo(&dst, false) = (_, %s); want nil or io.ErrShortWrite", err)
|
|
}
|
|
if got, want := copied, len(tc.wantBytes); got != want {
|
|
t.Errorf("got ReadTo(&dst, false) = (%d, _); want %d", got, want)
|
|
}
|
|
if got, want := string(b[:copied]), tc.wantBytes; got != want {
|
|
t.Errorf("got dst = %q, want %q", got, want)
|
|
}
|
|
if got, want := tc.vv.Size(), origSize-copied; got != want {
|
|
t.Errorf("got after-read tc.vv.Size() = %d, want %d", got, want)
|
|
}
|
|
if got, want := string(tc.vv.ToView()), string(tc.leftVV.ToView()); got != want {
|
|
t.Errorf("got after-read data in tc.vv = %q, want %q", got, want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestVVReadToPeek(t *testing.T) {
|
|
for _, tc := range createReadToTestCases() {
|
|
t.Run(tc.comment, func(t *testing.T) {
|
|
b := make([]byte, tc.bytesToRead)
|
|
dst := tcpip.SliceWriter(b)
|
|
origSize := tc.vv.Size()
|
|
origData := string(tc.vv.ToView())
|
|
copied, err := tc.vv.ReadTo(&dst, true /* peek */)
|
|
if err != nil && err != io.ErrShortWrite {
|
|
t.Errorf("got ReadTo(&dst, true) = (_, %s); want nil or io.ErrShortWrite", err)
|
|
}
|
|
if got, want := copied, len(tc.wantBytes); got != want {
|
|
t.Errorf("got ReadTo(&dst, true) = (%d, _); want %d", got, want)
|
|
}
|
|
if got, want := string(b[:copied]), tc.wantBytes; got != want {
|
|
t.Errorf("got dst = %q, want %q", got, want)
|
|
}
|
|
// Expect tc.vv is unchanged.
|
|
if got, want := tc.vv.Size(), origSize; got != want {
|
|
t.Errorf("got after-read tc.vv.Size() = %d, want %d", got, want)
|
|
}
|
|
if got, want := string(tc.vv.ToView()), origData; got != want {
|
|
t.Errorf("got after-read data in tc.vv = %q, want %q", got, want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestVVRead(t *testing.T) {
|
|
testCases := []struct {
|
|
comment string
|
|
vv buffer.VectorisedView
|
|
bytesToRead int
|
|
readBytes string
|
|
leftBytes string
|
|
wantError bool
|
|
}{
|
|
{
|
|
comment: "large VV, short read",
|
|
vv: vv(30, "012345678901234567890123456789"),
|
|
bytesToRead: 10,
|
|
readBytes: "0123456789",
|
|
leftBytes: "01234567890123456789",
|
|
},
|
|
{
|
|
comment: "largeVV, multiple buffers, short read",
|
|
vv: vv(13, "123", "345", "567", "8910"),
|
|
bytesToRead: 6,
|
|
readBytes: "123345",
|
|
leftBytes: "5678910",
|
|
},
|
|
{
|
|
comment: "smallVV, large read",
|
|
vv: vv(3, "1", "2", "3"),
|
|
bytesToRead: 10,
|
|
readBytes: "123",
|
|
leftBytes: "",
|
|
},
|
|
{
|
|
comment: "smallVV, large read",
|
|
vv: vv(1, "1"),
|
|
bytesToRead: 10,
|
|
readBytes: "1",
|
|
leftBytes: "",
|
|
},
|
|
{
|
|
comment: "emptyVV, large read",
|
|
vv: vv(0, ""),
|
|
bytesToRead: 10,
|
|
readBytes: "",
|
|
wantError: true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.comment, func(t *testing.T) {
|
|
readTo := buffer.NewView(tc.bytesToRead)
|
|
inSize := tc.vv.Size()
|
|
copied, err := tc.vv.Read(readTo)
|
|
if !tc.wantError && err != nil {
|
|
t.Fatalf("unexpected error in tc.vv.Read(..) = %s", err)
|
|
}
|
|
readTo = readTo[:copied]
|
|
if got, want := copied, len(tc.readBytes); got != want {
|
|
t.Errorf("incorrect number of bytes copied returned in ReadToVV got: %d, want: %d, tc.vv: %+v", got, want, tc.vv)
|
|
}
|
|
if got, want := string(readTo), tc.readBytes; got != want {
|
|
t.Errorf("unexpected data in readTo got: %s, want: %s", got, want)
|
|
}
|
|
if got, want := tc.vv.Size(), inSize-copied; got != want {
|
|
t.Errorf("test VV has incorrect size after reading got: %d, want: %d, tc.vv: %+v", got, want, tc.vv)
|
|
}
|
|
if got, want := string(tc.vv.ToView()), tc.leftBytes; got != want {
|
|
t.Errorf("vv has incorrect data after Read got: %s, want: %s", got, want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
var pullUpTestCases = []struct {
|
|
comment string
|
|
in buffer.VectorisedView
|
|
count int
|
|
want []byte
|
|
result buffer.VectorisedView
|
|
ok bool
|
|
}{
|
|
{
|
|
comment: "simple case",
|
|
in: vv(2, "12"),
|
|
count: 1,
|
|
want: []byte("1"),
|
|
result: vv(2, "12"),
|
|
ok: true,
|
|
},
|
|
{
|
|
comment: "entire View",
|
|
in: vv(2, "1", "2"),
|
|
count: 1,
|
|
want: []byte("1"),
|
|
result: vv(2, "1", "2"),
|
|
ok: true,
|
|
},
|
|
{
|
|
comment: "spanning across two Views",
|
|
in: vv(3, "1", "23"),
|
|
count: 2,
|
|
want: []byte("12"),
|
|
result: vv(3, "12", "3"),
|
|
ok: true,
|
|
},
|
|
{
|
|
comment: "spanning across all Views",
|
|
in: vv(5, "1", "23", "45"),
|
|
count: 5,
|
|
want: []byte("12345"),
|
|
result: vv(5, "12345"),
|
|
ok: true,
|
|
},
|
|
{
|
|
comment: "count = 0",
|
|
in: vv(1, "1"),
|
|
count: 0,
|
|
want: []byte{},
|
|
result: vv(1, "1"),
|
|
ok: true,
|
|
},
|
|
{
|
|
comment: "count = size",
|
|
in: vv(1, "1"),
|
|
count: 1,
|
|
want: []byte("1"),
|
|
result: vv(1, "1"),
|
|
ok: true,
|
|
},
|
|
{
|
|
comment: "count too large",
|
|
in: vv(3, "1", "23"),
|
|
count: 4,
|
|
want: nil,
|
|
result: vv(3, "1", "23"),
|
|
ok: false,
|
|
},
|
|
{
|
|
comment: "empty vv",
|
|
in: vv(0, ""),
|
|
count: 1,
|
|
want: nil,
|
|
result: vv(0, ""),
|
|
ok: false,
|
|
},
|
|
{
|
|
comment: "empty vv, count = 0",
|
|
in: vv(0, ""),
|
|
count: 0,
|
|
want: nil,
|
|
result: vv(0, ""),
|
|
ok: true,
|
|
},
|
|
{
|
|
comment: "empty views",
|
|
in: vv(3, "", "1", "", "23"),
|
|
count: 2,
|
|
want: []byte("12"),
|
|
result: vv(3, "12", "3"),
|
|
ok: true,
|
|
},
|
|
}
|
|
|
|
func TestPullUp(t *testing.T) {
|
|
for _, c := range pullUpTestCases {
|
|
got, ok := c.in.PullUp(c.count)
|
|
|
|
// Is the return value right?
|
|
if ok != c.ok {
|
|
t.Errorf("Test %q failed when calling PullUp(%d) on %v. Got an ok of %t. Want %t",
|
|
c.comment, c.count, c.in, ok, c.ok)
|
|
}
|
|
if bytes.Compare(got, buffer.View(c.want)) != 0 {
|
|
t.Errorf("Test %q failed when calling PullUp(%d) on %v. Got %v. Want %v",
|
|
c.comment, c.count, c.in, got, c.want)
|
|
}
|
|
|
|
// Is the underlying structure right?
|
|
if !reflect.DeepEqual(c.in, c.result) {
|
|
t.Errorf("Test %q failed when calling PullUp(%d). Got vv with structure %v. Wanted %v",
|
|
c.comment, c.count, c.in, c.result)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestToVectorisedView(t *testing.T) {
|
|
testCases := []struct {
|
|
in buffer.View
|
|
want buffer.VectorisedView
|
|
}{
|
|
{nil, buffer.VectorisedView{}},
|
|
{buffer.View{}, buffer.VectorisedView{}},
|
|
{buffer.View{'a'}, buffer.NewVectorisedView(1, []buffer.View{{'a'}})},
|
|
}
|
|
for _, tc := range testCases {
|
|
if got, want := tc.in.ToVectorisedView(), tc.want; !reflect.DeepEqual(got, want) {
|
|
t.Errorf("(%v).ToVectorisedView failed got: %+v, want: %+v", tc.in, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAppendView(t *testing.T) {
|
|
testCases := []struct {
|
|
vv buffer.VectorisedView
|
|
in buffer.View
|
|
want buffer.VectorisedView
|
|
}{
|
|
{vv(0), nil, vv(0)},
|
|
{vv(0), v(""), vv(0)},
|
|
{vv(4, "abcd"), nil, vv(4, "abcd")},
|
|
{vv(4, "abcd"), v(""), vv(4, "abcd")},
|
|
{vv(4, "abcd"), v("e"), vv(5, "abcd", "e")},
|
|
}
|
|
for _, tc := range testCases {
|
|
tc.vv.AppendView(tc.in)
|
|
if got, want := tc.vv, tc.want; !reflect.DeepEqual(got, want) {
|
|
t.Errorf("(%v).ToVectorisedView failed got: %+v, want: %+v", tc.in, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAppendViews(t *testing.T) {
|
|
testCases := []struct {
|
|
vv buffer.VectorisedView
|
|
in []buffer.View
|
|
want buffer.VectorisedView
|
|
}{
|
|
{vv(0), nil, vv(0)},
|
|
{vv(0), []buffer.View{}, vv(0)},
|
|
{vv(0), []buffer.View{v("")}, vv(0, "")},
|
|
{vv(4, "abcd"), nil, vv(4, "abcd")},
|
|
{vv(4, "abcd"), []buffer.View{}, vv(4, "abcd")},
|
|
{vv(4, "abcd"), []buffer.View{v("")}, vv(4, "abcd", "")},
|
|
{vv(4, "abcd"), []buffer.View{v("")}, vv(4, "abcd", "")},
|
|
{vv(4, "abcd"), []buffer.View{v("e")}, vv(5, "abcd", "e")},
|
|
{vv(4, "abcd"), []buffer.View{v("e"), v("fg")}, vv(7, "abcd", "e", "fg")},
|
|
{vv(4, "abcd"), []buffer.View{v(""), v("fg")}, vv(6, "abcd", "", "fg")},
|
|
}
|
|
for _, tc := range testCases {
|
|
tc.vv.AppendViews(tc.in)
|
|
if got, want := tc.vv, tc.want; !reflect.DeepEqual(got, want) {
|
|
t.Errorf("(%v).ToVectorisedView failed got: %+v, want: %+v", tc.in, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMemSize(t *testing.T) {
|
|
const perViewCap = 128
|
|
views := make([]buffer.View, 2, 32)
|
|
views[0] = make(buffer.View, 10, perViewCap)
|
|
views[1] = make(buffer.View, 20, perViewCap)
|
|
vv := buffer.NewVectorisedView(30, views)
|
|
want := int(unsafe.Sizeof(vv)) + cap(views)*int(unsafe.Sizeof(views)) + 2*perViewCap
|
|
if got := vv.MemSize(); got != want {
|
|
t.Errorf("vv.MemSize() = %d, want %d", got, want)
|
|
}
|
|
}
|