Gecko [ www.smanegeri1koba.sch.id ]

Name	Size	Permission
testdata	[ DIR ]	dr-xr-xr-x
asm.go	1.24 KB	-r--r--r--
constants.go	6.04 KB	-r--r--r--
doc.go	3.14 KB	-r--r--r--
instructions.go	17.68 KB	-r--r--r--
instructions_test.go	15.18 KB	-r--r--r--
setter.go	310 B	-r--r--r--
vm.go	4.03 KB	-r--r--r--
vm_aluop_test.go	9.66 KB	-r--r--r--
vm_bpf_test.go	4.82 KB	-r--r--r--
vm_extension_test.go	1.01 KB	-r--r--r--
vm_instructions.go	3.87 KB	-r--r--r--
vm_jump_test.go	13.53 KB	-r--r--r--
vm_load_test.go	5.56 KB	-r--r--r--
vm_ret_test.go	2.31 KB	-r--r--r--
vm_scratch_test.go	4.73 KB	-r--r--r--
vm_test.go	3.25 KB	-r--r--r--

Code Editor : vm_aluop_test.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 TestVMALUOpAdd(t *testing.T) {
	vm, done, err := testVM(t, []bpf.Instruction{
		bpf.LoadAbsolute{
			Off:  8,
			Size: 1,
		},
		bpf.ALUOpConstant{
			Op:  bpf.ALUOpAdd,
			Val: 3,
		},
		bpf.RetA{},
	})
	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,
		8, 2, 3,
	})
	if err != nil {
		t.Fatalf("unexpected error while running program: %v", err)
	}
	if want, got := 3, out; want != got {
		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
			want, got)
	}
}

func TestVMALUOpSub(t *testing.T) {
	vm, done, err := testVM(t, []bpf.Instruction{
		bpf.LoadAbsolute{
			Off:  8,
			Size: 1,
		},
		bpf.TAX{},
		bpf.ALUOpX{
			Op: bpf.ALUOpSub,
		},
		bpf.RetA{},
	})
	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, 2, 3,
	})
	if err != nil {
		t.Fatalf("unexpected error while running program: %v", err)
	}
	if want, got := 0, out; want != got {
		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
			want, got)
	}
}

func TestVMALUOpMul(t *testing.T) {
	vm, done, err := testVM(t, []bpf.Instruction{
		bpf.LoadAbsolute{
			Off:  8,
			Size: 1,
		},
		bpf.ALUOpConstant{
			Op:  bpf.ALUOpMul,
			Val: 2,
		},
		bpf.RetA{},
	})
	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,
		6, 2, 3, 4,
	})
	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 TestVMALUOpDiv(t *testing.T) {
	vm, done, err := testVM(t, []bpf.Instruction{
		bpf.LoadAbsolute{
			Off:  8,
			Size: 1,
		},
		bpf.ALUOpConstant{
			Op:  bpf.ALUOpDiv,
			Val: 2,
		},
		bpf.RetA{},
	})
	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,
		20, 2, 3, 4,
	})
	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 TestVMALUOpDivByZeroALUOpConstant(t *testing.T) {
	_, _, err := testVM(t, []bpf.Instruction{
		bpf.ALUOpConstant{
			Op:  bpf.ALUOpDiv,
			Val: 0,
		},
		bpf.RetA{},
	})
	if errStr(err) != "cannot divide by zero using ALUOpConstant" {
		t.Fatalf("unexpected error: %v", err)
	}
}

func TestVMALUOpDivByZeroALUOpX(t *testing.T) {
	vm, done, err := testVM(t, []bpf.Instruction{
		// Load byte 0 into X
		bpf.LoadAbsolute{
			Off:  8,
			Size: 1,
		},
		bpf.TAX{},
		// Load byte 1 into A
		bpf.LoadAbsolute{
			Off:  9,
			Size: 1,
		},
		// Attempt to perform 1/0
		bpf.ALUOpX{
			Op: bpf.ALUOpDiv,
		},
		// Return 4 bytes if program does not terminate
		bpf.LoadConstant{
			Val: 12,
		},
		bpf.RetA{},
	})
	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, 3, 4,
	})
	if err != nil {
		t.Fatalf("unexpected error while running program: %v", err)
	}
	if want, got := 0, out; want != got {
		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
			want, got)
	}
}

func TestVMALUOpOr(t *testing.T) {
	vm, done, err := testVM(t, []bpf.Instruction{
		bpf.LoadAbsolute{
			Off:  8,
			Size: 2,
		},
		bpf.ALUOpConstant{
			Op:  bpf.ALUOpOr,
			Val: 0x01,
		},
		bpf.RetA{},
	})
	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,
		0x00, 0x10, 0x03, 0x04,
		0x05, 0x06, 0x07, 0x08,
		0x09, 0xff,
	})
	if err != nil {
		t.Fatalf("unexpected error while running program: %v", err)
	}
	if want, got := 9, out; want != got {
		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
			want, got)
	}
}

func TestVMALUOpAnd(t *testing.T) {
	vm, done, err := testVM(t, []bpf.Instruction{
		bpf.LoadAbsolute{
			Off:  8,
			Size: 2,
		},
		bpf.ALUOpConstant{
			Op:  bpf.ALUOpAnd,
			Val: 0x0019,
		},
		bpf.RetA{},
	})
	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,
		0xaa, 0x09,
	})
	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 TestVMALUOpShiftLeft(t *testing.T) {
	vm, done, err := testVM(t, []bpf.Instruction{
		bpf.LoadAbsolute{
			Off:  8,
			Size: 1,
		},
		bpf.ALUOpConstant{
			Op:  bpf.ALUOpShiftLeft,
			Val: 0x01,
		},
		bpf.JumpIf{
			Cond:     bpf.JumpEqual,
			Val:      0x02,
			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,
		0x01, 0xaa,
	})
	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 TestVMALUOpShiftRight(t *testing.T) {
	vm, done, err := testVM(t, []bpf.Instruction{
		bpf.LoadAbsolute{
			Off:  8,
			Size: 1,
		},
		bpf.ALUOpConstant{
			Op:  bpf.ALUOpShiftRight,
			Val: 0x01,
		},
		bpf.JumpIf{
			Cond:     bpf.JumpEqual,
			Val:      0x04,
			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,
		0x08, 0xff, 0xff,
	})
	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 TestVMALUOpMod(t *testing.T) {
	vm, done, err := testVM(t, []bpf.Instruction{
		bpf.LoadAbsolute{
			Off:  8,
			Size: 1,
		},
		bpf.ALUOpConstant{
			Op:  bpf.ALUOpMod,
			Val: 20,
		},
		bpf.RetA{},
	})
	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,
		30, 0, 0,
	})
	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 TestVMALUOpModByZeroALUOpConstant(t *testing.T) {
	_, _, err := testVM(t, []bpf.Instruction{
		bpf.LoadAbsolute{
			Off:  8,
			Size: 1,
		},
		bpf.ALUOpConstant{
			Op:  bpf.ALUOpMod,
			Val: 0,
		},
		bpf.RetA{},
	})
	if errStr(err) != "cannot divide by zero using ALUOpConstant" {
		t.Fatalf("unexpected error: %v", err)
	}
}

func TestVMALUOpModByZeroALUOpX(t *testing.T) {
	vm, done, err := testVM(t, []bpf.Instruction{
		// Load byte 0 into X
		bpf.LoadAbsolute{
			Off:  8,
			Size: 1,
		},
		bpf.TAX{},
		// Load byte 1 into A
		bpf.LoadAbsolute{
			Off:  9,
			Size: 1,
		},
		// Attempt to perform 1%0
		bpf.ALUOpX{
			Op: bpf.ALUOpMod,
		},
		// Return 4 bytes if program does not terminate
		bpf.LoadConstant{
			Val: 12,
		},
		bpf.RetA{},
	})
	if err != nil {
		t.Fatalf("failed to load BPF program: %v", err)
	}
	defer done()

func TestVMALUOpXor(t *testing.T) {
	vm, done, err := testVM(t, []bpf.Instruction{
		bpf.LoadAbsolute{
			Off:  8,
			Size: 1,
		},
		bpf.ALUOpConstant{
			Op:  bpf.ALUOpXor,
			Val: 0x0a,
		},
		bpf.JumpIf{
			Cond:     bpf.JumpEqual,
			Val:      0x01,
			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,
		0x0b, 0x00, 0x00, 0x00,
	})
	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 TestVMALUOpUnknown(t *testing.T) {
	vm, done, err := testVM(t, []bpf.Instruction{
		bpf.LoadAbsolute{
			Off:  8,
			Size: 1,
		},
		bpf.ALUOpConstant{
			Op:  bpf.ALUOpAdd,
			Val: 1,
		},
		// Verify that an unknown operation is a no-op
		bpf.ALUOpConstant{
			Op: 100,
		},
		bpf.JumpIf{
			Cond:     bpf.JumpEqual,
			Val:      0x02,
			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)
	}
}

${this.title}

Code Editor : vm_aluop_test.go