зеркало из https://github.com/golang/net.git
727 строки
14 KiB
Go
727 строки
14 KiB
Go
// Copyright 2016 The Go 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 bpf_test
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"golang.org/x/net/bpf"
|
|
)
|
|
|
|
func TestVMJumpOne(t *testing.T) {
|
|
vm, done, err := testVM(t, []bpf.Instruction{
|
|
bpf.LoadAbsolute{
|
|
Off: 8,
|
|
Size: 1,
|
|
},
|
|
bpf.Jump{
|
|
Skip: 1,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 0,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 9,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to load BPF program: %v", err)
|
|
}
|
|
defer done()
|
|
|
|
out, err := vm.Run([]byte{
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff,
|
|
1,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error while running program: %v", err)
|
|
}
|
|
if want, got := 1, out; want != got {
|
|
t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
|
|
want, got)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpOutOfProgram(t *testing.T) {
|
|
_, _, err := testVM(t, []bpf.Instruction{
|
|
bpf.Jump{
|
|
Skip: 1,
|
|
},
|
|
bpf.RetA{},
|
|
})
|
|
if errStr(err) != "cannot jump 1 instructions; jumping past program bounds" {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfTrueOutOfProgram(t *testing.T) {
|
|
_, _, err := testVM(t, []bpf.Instruction{
|
|
bpf.JumpIf{
|
|
Cond: bpf.JumpEqual,
|
|
SkipTrue: 2,
|
|
},
|
|
bpf.RetA{},
|
|
})
|
|
if errStr(err) != "cannot jump 2 instructions in true case; jumping past program bounds" {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfFalseOutOfProgram(t *testing.T) {
|
|
_, _, err := testVM(t, []bpf.Instruction{
|
|
bpf.JumpIf{
|
|
Cond: bpf.JumpEqual,
|
|
SkipFalse: 3,
|
|
},
|
|
bpf.RetA{},
|
|
})
|
|
if errStr(err) != "cannot jump 3 instructions in false case; jumping past program bounds" {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfXTrueOutOfProgram(t *testing.T) {
|
|
_, _, err := testVM(t, []bpf.Instruction{
|
|
bpf.JumpIfX{
|
|
Cond: bpf.JumpEqual,
|
|
SkipTrue: 2,
|
|
},
|
|
bpf.RetA{},
|
|
})
|
|
if errStr(err) != "cannot jump 2 instructions in true case; jumping past program bounds" {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfXFalseOutOfProgram(t *testing.T) {
|
|
_, _, err := testVM(t, []bpf.Instruction{
|
|
bpf.JumpIfX{
|
|
Cond: bpf.JumpEqual,
|
|
SkipFalse: 3,
|
|
},
|
|
bpf.RetA{},
|
|
})
|
|
if errStr(err) != "cannot jump 3 instructions in false case; jumping past program bounds" {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfEqual(t *testing.T) {
|
|
vm, done, err := testVM(t, []bpf.Instruction{
|
|
bpf.LoadAbsolute{
|
|
Off: 8,
|
|
Size: 1,
|
|
},
|
|
bpf.JumpIf{
|
|
Cond: bpf.JumpEqual,
|
|
Val: 1,
|
|
SkipTrue: 1,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 0,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 9,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to load BPF program: %v", err)
|
|
}
|
|
defer done()
|
|
|
|
out, err := vm.Run([]byte{
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff,
|
|
1,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error while running program: %v", err)
|
|
}
|
|
if want, got := 1, out; want != got {
|
|
t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
|
|
want, got)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfNotEqual(t *testing.T) {
|
|
vm, done, err := testVM(t, []bpf.Instruction{
|
|
bpf.LoadAbsolute{
|
|
Off: 8,
|
|
Size: 1,
|
|
},
|
|
bpf.JumpIf{
|
|
Cond: bpf.JumpNotEqual,
|
|
Val: 1,
|
|
SkipFalse: 1,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 0,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 9,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to load BPF program: %v", err)
|
|
}
|
|
defer done()
|
|
|
|
out, err := vm.Run([]byte{
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff,
|
|
1,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error while running program: %v", err)
|
|
}
|
|
if want, got := 1, out; want != got {
|
|
t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
|
|
want, got)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfGreaterThan(t *testing.T) {
|
|
vm, done, err := testVM(t, []bpf.Instruction{
|
|
bpf.LoadAbsolute{
|
|
Off: 8,
|
|
Size: 4,
|
|
},
|
|
bpf.JumpIf{
|
|
Cond: bpf.JumpGreaterThan,
|
|
Val: 0x00010202,
|
|
SkipTrue: 1,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 0,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 12,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to load BPF program: %v", err)
|
|
}
|
|
defer done()
|
|
|
|
out, err := vm.Run([]byte{
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0, 1, 2, 3,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error while running program: %v", err)
|
|
}
|
|
if want, got := 4, out; want != got {
|
|
t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
|
|
want, got)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfLessThan(t *testing.T) {
|
|
vm, done, err := testVM(t, []bpf.Instruction{
|
|
bpf.LoadAbsolute{
|
|
Off: 8,
|
|
Size: 4,
|
|
},
|
|
bpf.JumpIf{
|
|
Cond: bpf.JumpLessThan,
|
|
Val: 0xff010203,
|
|
SkipTrue: 1,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 0,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 12,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to load BPF program: %v", err)
|
|
}
|
|
defer done()
|
|
|
|
out, err := vm.Run([]byte{
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0, 1, 2, 3,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error while running program: %v", err)
|
|
}
|
|
if want, got := 4, out; want != got {
|
|
t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
|
|
want, got)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfGreaterOrEqual(t *testing.T) {
|
|
vm, done, err := testVM(t, []bpf.Instruction{
|
|
bpf.LoadAbsolute{
|
|
Off: 8,
|
|
Size: 4,
|
|
},
|
|
bpf.JumpIf{
|
|
Cond: bpf.JumpGreaterOrEqual,
|
|
Val: 0x00010203,
|
|
SkipTrue: 1,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 0,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 12,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to load BPF program: %v", err)
|
|
}
|
|
defer done()
|
|
|
|
out, err := vm.Run([]byte{
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0, 1, 2, 3,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error while running program: %v", err)
|
|
}
|
|
if want, got := 4, out; want != got {
|
|
t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
|
|
want, got)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfLessOrEqual(t *testing.T) {
|
|
vm, done, err := testVM(t, []bpf.Instruction{
|
|
bpf.LoadAbsolute{
|
|
Off: 8,
|
|
Size: 4,
|
|
},
|
|
bpf.JumpIf{
|
|
Cond: bpf.JumpLessOrEqual,
|
|
Val: 0xff010203,
|
|
SkipTrue: 1,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 0,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 12,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to load BPF program: %v", err)
|
|
}
|
|
defer done()
|
|
|
|
out, err := vm.Run([]byte{
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0, 1, 2, 3,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error while running program: %v", err)
|
|
}
|
|
if want, got := 4, out; want != got {
|
|
t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
|
|
want, got)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfBitsSet(t *testing.T) {
|
|
vm, done, err := testVM(t, []bpf.Instruction{
|
|
bpf.LoadAbsolute{
|
|
Off: 8,
|
|
Size: 2,
|
|
},
|
|
bpf.JumpIf{
|
|
Cond: bpf.JumpBitsSet,
|
|
Val: 0x1122,
|
|
SkipTrue: 1,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 0,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 10,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to load BPF program: %v", err)
|
|
}
|
|
defer done()
|
|
|
|
out, err := vm.Run([]byte{
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0x01, 0x02,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error while running program: %v", err)
|
|
}
|
|
if want, got := 2, out; want != got {
|
|
t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
|
|
want, got)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfBitsNotSet(t *testing.T) {
|
|
vm, done, err := testVM(t, []bpf.Instruction{
|
|
bpf.LoadAbsolute{
|
|
Off: 8,
|
|
Size: 2,
|
|
},
|
|
bpf.JumpIf{
|
|
Cond: bpf.JumpBitsNotSet,
|
|
Val: 0x1221,
|
|
SkipTrue: 1,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 0,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 10,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to load BPF program: %v", err)
|
|
}
|
|
defer done()
|
|
|
|
out, err := vm.Run([]byte{
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0x01, 0x02,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error while running program: %v", err)
|
|
}
|
|
if want, got := 2, out; want != got {
|
|
t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
|
|
want, got)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfXEqual(t *testing.T) {
|
|
vm, done, err := testVM(t, []bpf.Instruction{
|
|
bpf.LoadAbsolute{
|
|
Off: 8,
|
|
Size: 1,
|
|
},
|
|
bpf.LoadConstant{
|
|
Dst: bpf.RegX,
|
|
Val: 1,
|
|
},
|
|
bpf.JumpIfX{
|
|
Cond: bpf.JumpEqual,
|
|
SkipTrue: 1,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 0,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 9,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to load BPF program: %v", err)
|
|
}
|
|
defer done()
|
|
|
|
out, err := vm.Run([]byte{
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff,
|
|
1,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error while running program: %v", err)
|
|
}
|
|
if want, got := 1, out; want != got {
|
|
t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
|
|
want, got)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfXNotEqual(t *testing.T) {
|
|
vm, done, err := testVM(t, []bpf.Instruction{
|
|
bpf.LoadAbsolute{
|
|
Off: 8,
|
|
Size: 1,
|
|
},
|
|
bpf.LoadConstant{
|
|
Dst: bpf.RegX,
|
|
Val: 1,
|
|
},
|
|
bpf.JumpIfX{
|
|
Cond: bpf.JumpNotEqual,
|
|
SkipFalse: 1,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 0,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 9,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to load BPF program: %v", err)
|
|
}
|
|
defer done()
|
|
|
|
out, err := vm.Run([]byte{
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff,
|
|
1,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error while running program: %v", err)
|
|
}
|
|
if want, got := 1, out; want != got {
|
|
t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
|
|
want, got)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfXGreaterThan(t *testing.T) {
|
|
vm, done, err := testVM(t, []bpf.Instruction{
|
|
bpf.LoadAbsolute{
|
|
Off: 8,
|
|
Size: 4,
|
|
},
|
|
bpf.LoadConstant{
|
|
Dst: bpf.RegX,
|
|
Val: 0x00010202,
|
|
},
|
|
bpf.JumpIfX{
|
|
Cond: bpf.JumpGreaterThan,
|
|
SkipTrue: 1,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 0,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 12,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to load BPF program: %v", err)
|
|
}
|
|
defer done()
|
|
|
|
out, err := vm.Run([]byte{
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0, 1, 2, 3,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error while running program: %v", err)
|
|
}
|
|
if want, got := 4, out; want != got {
|
|
t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
|
|
want, got)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfXLessThan(t *testing.T) {
|
|
vm, done, err := testVM(t, []bpf.Instruction{
|
|
bpf.LoadAbsolute{
|
|
Off: 8,
|
|
Size: 4,
|
|
},
|
|
bpf.LoadConstant{
|
|
Dst: bpf.RegX,
|
|
Val: 0xff010203,
|
|
},
|
|
bpf.JumpIfX{
|
|
Cond: bpf.JumpLessThan,
|
|
SkipTrue: 1,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 0,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 12,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to load BPF program: %v", err)
|
|
}
|
|
defer done()
|
|
|
|
out, err := vm.Run([]byte{
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0, 1, 2, 3,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error while running program: %v", err)
|
|
}
|
|
if want, got := 4, out; want != got {
|
|
t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
|
|
want, got)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfXGreaterOrEqual(t *testing.T) {
|
|
vm, done, err := testVM(t, []bpf.Instruction{
|
|
bpf.LoadAbsolute{
|
|
Off: 8,
|
|
Size: 4,
|
|
},
|
|
bpf.LoadConstant{
|
|
Dst: bpf.RegX,
|
|
Val: 0x00010203,
|
|
},
|
|
bpf.JumpIfX{
|
|
Cond: bpf.JumpGreaterOrEqual,
|
|
SkipTrue: 1,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 0,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 12,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to load BPF program: %v", err)
|
|
}
|
|
defer done()
|
|
|
|
out, err := vm.Run([]byte{
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0, 1, 2, 3,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error while running program: %v", err)
|
|
}
|
|
if want, got := 4, out; want != got {
|
|
t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
|
|
want, got)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfXLessOrEqual(t *testing.T) {
|
|
vm, done, err := testVM(t, []bpf.Instruction{
|
|
bpf.LoadAbsolute{
|
|
Off: 8,
|
|
Size: 4,
|
|
},
|
|
bpf.LoadConstant{
|
|
Dst: bpf.RegX,
|
|
Val: 0xff010203,
|
|
},
|
|
bpf.JumpIfX{
|
|
Cond: bpf.JumpLessOrEqual,
|
|
SkipTrue: 1,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 0,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 12,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to load BPF program: %v", err)
|
|
}
|
|
defer done()
|
|
|
|
out, err := vm.Run([]byte{
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0, 1, 2, 3,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error while running program: %v", err)
|
|
}
|
|
if want, got := 4, out; want != got {
|
|
t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
|
|
want, got)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfXBitsSet(t *testing.T) {
|
|
vm, done, err := testVM(t, []bpf.Instruction{
|
|
bpf.LoadAbsolute{
|
|
Off: 8,
|
|
Size: 2,
|
|
},
|
|
bpf.LoadConstant{
|
|
Dst: bpf.RegX,
|
|
Val: 0x1122,
|
|
},
|
|
bpf.JumpIfX{
|
|
Cond: bpf.JumpBitsSet,
|
|
SkipTrue: 1,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 0,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 10,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to load BPF program: %v", err)
|
|
}
|
|
defer done()
|
|
|
|
out, err := vm.Run([]byte{
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0x01, 0x02,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error while running program: %v", err)
|
|
}
|
|
if want, got := 2, out; want != got {
|
|
t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
|
|
want, got)
|
|
}
|
|
}
|
|
|
|
func TestVMJumpIfXBitsNotSet(t *testing.T) {
|
|
vm, done, err := testVM(t, []bpf.Instruction{
|
|
bpf.LoadAbsolute{
|
|
Off: 8,
|
|
Size: 2,
|
|
},
|
|
bpf.LoadConstant{
|
|
Dst: bpf.RegX,
|
|
Val: 0x1221,
|
|
},
|
|
bpf.JumpIfX{
|
|
Cond: bpf.JumpBitsNotSet,
|
|
SkipTrue: 1,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 0,
|
|
},
|
|
bpf.RetConstant{
|
|
Val: 10,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to load BPF program: %v", err)
|
|
}
|
|
defer done()
|
|
|
|
out, err := vm.Run([]byte{
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff,
|
|
0x01, 0x02,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error while running program: %v", err)
|
|
}
|
|
if want, got := 2, out; want != got {
|
|
t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
|
|
want, got)
|
|
}
|
|
}
|