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_scratch_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 TestVMStoreScratchInvalidScratchRegisterTooSmall(t *testing.T) {
	_, _, err := testVM(t, []bpf.Instruction{
		bpf.StoreScratch{
			Src: bpf.RegA,
			N:   -1,
		},
		bpf.RetA{},
	})
	if errStr(err) != "assembling instruction 1: invalid scratch slot -1" {
		t.Fatalf("unexpected error: %v", err)
	}
}

func TestVMStoreScratchInvalidScratchRegisterTooLarge(t *testing.T) {
	_, _, err := testVM(t, []bpf.Instruction{
		bpf.StoreScratch{
			Src: bpf.RegA,
			N:   16,
		},
		bpf.RetA{},
	})
	if errStr(err) != "assembling instruction 1: invalid scratch slot 16" {
		t.Fatalf("unexpected error: %v", err)
	}
}

func TestVMStoreScratchUnknownSourceRegister(t *testing.T) {
	_, _, err := testVM(t, []bpf.Instruction{
		bpf.StoreScratch{
			Src: 100,
			N:   0,
		},
		bpf.RetA{},
	})
	if errStr(err) != "assembling instruction 1: invalid source register 100" {
		t.Fatalf("unexpected error: %v", err)
	}
}

func TestVMLoadScratchInvalidScratchRegisterTooSmall(t *testing.T) {
	_, _, err := testVM(t, []bpf.Instruction{
		bpf.LoadScratch{
			Dst: bpf.RegX,
			N:   -1,
		},
		bpf.RetA{},
	})
	if errStr(err) != "assembling instruction 1: invalid scratch slot -1" {
		t.Fatalf("unexpected error: %v", err)
	}
}

func TestVMLoadScratchInvalidScratchRegisterTooLarge(t *testing.T) {
	_, _, err := testVM(t, []bpf.Instruction{
		bpf.LoadScratch{
			Dst: bpf.RegX,
			N:   16,
		},
		bpf.RetA{},
	})
	if errStr(err) != "assembling instruction 1: invalid scratch slot 16" {
		t.Fatalf("unexpected error: %v", err)
	}
}

func TestVMLoadScratchUnknownDestinationRegister(t *testing.T) {
	_, _, err := testVM(t, []bpf.Instruction{
		bpf.LoadScratch{
			Dst: 100,
			N:   0,
		},
		bpf.RetA{},
	})
	if errStr(err) != "assembling instruction 1: invalid target register 100" {
		t.Fatalf("unexpected error: %v", err)
	}
}

func TestVMStoreScratchLoadScratchOneValue(t *testing.T) {
	vm, done, err := testVM(t, []bpf.Instruction{
		// Load byte 255
		bpf.LoadAbsolute{
			Off:  8,
			Size: 1,
		},
		// Copy to X and store in scratch[0]
		bpf.TAX{},
		bpf.StoreScratch{
			Src: bpf.RegX,
			N:   0,
		},
		// Load byte 1
		bpf.LoadAbsolute{
			Off:  9,
			Size: 1,
		},
		// Overwrite 1 with 255 from scratch[0]
		bpf.LoadScratch{
			Dst: bpf.RegA,
			N:   0,
		},
		// Return 255
		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,
		255, 1, 2,
	})
	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 TestVMStoreScratchLoadScratchMultipleValues(t *testing.T) {
	vm, done, err := testVM(t, []bpf.Instruction{
		// Load byte 10
		bpf.LoadAbsolute{
			Off:  8,
			Size: 1,
		},
		// Store in scratch[0]
		bpf.StoreScratch{
			Src: bpf.RegA,
			N:   0,
		},
		// Load byte 20
		bpf.LoadAbsolute{
			Off:  9,
			Size: 1,
		},
		// Store in scratch[1]
		bpf.StoreScratch{
			Src: bpf.RegA,
			N:   1,
		},
		// Load byte 30
		bpf.LoadAbsolute{
			Off:  10,
			Size: 1,
		},
		// Store in scratch[2]
		bpf.StoreScratch{
			Src: bpf.RegA,
			N:   2,
		},
		// Load byte 1
		bpf.LoadAbsolute{
			Off:  11,
			Size: 1,
		},
		// Store in scratch[3]
		bpf.StoreScratch{
			Src: bpf.RegA,
			N:   3,
		},
		// Load in byte 10 to X
		bpf.LoadScratch{
			Dst: bpf.RegX,
			N:   0,
		},
		// Copy X -> A
		bpf.TXA{},
		// Verify value is 10
		bpf.JumpIf{
			Cond:     bpf.JumpEqual,
			Val:      10,
			SkipTrue: 1,
		},
		// Fail test if incorrect
		bpf.RetConstant{
			Val: 0,
		},
		// Load in byte 20 to A
		bpf.LoadScratch{
			Dst: bpf.RegA,
			N:   1,
		},
		// Verify value is 20
		bpf.JumpIf{
			Cond:     bpf.JumpEqual,
			Val:      20,
			SkipTrue: 1,
		},
		// Fail test if incorrect
		bpf.RetConstant{
			Val: 0,
		},
		// Load in byte 30 to A
		bpf.LoadScratch{
			Dst: bpf.RegA,
			N:   2,
		},
		// Verify value is 30
		bpf.JumpIf{
			Cond:     bpf.JumpEqual,
			Val:      30,
			SkipTrue: 1,
		},
		// Fail test if incorrect
		bpf.RetConstant{
			Val: 0,
		},
		// Return first two bytes on success
		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,
		10, 20, 30, 1,
	})
	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)
	}
}

${this.title}

Code Editor : vm_scratch_test.go