aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorMeng-Ying Yang <garfield@dexon.org>2019-05-08 16:37:46 +0800
committerMeng-Ying Yang <garfield@dexon.org>2019-05-09 15:13:47 +0800
commit7d98f2aef224767913874a3d20c0a8f8a2cb3388 (patch)
tree42dbf2e8e19aafa6ef7ad21d245d63cafd444f39
parentc8fd7f412af66040d7e1664f292d83a10807cdc4 (diff)
downloaddexon-wip/gy-sqlvm-runtime-benchmark.tar
dexon-wip/gy-sqlvm-runtime-benchmark.tar.gz
dexon-wip/gy-sqlvm-runtime-benchmark.tar.bz2
dexon-wip/gy-sqlvm-runtime-benchmark.tar.lz
dexon-wip/gy-sqlvm-runtime-benchmark.tar.xz
dexon-wip/gy-sqlvm-runtime-benchmark.tar.zst
dexon-wip/gy-sqlvm-runtime-benchmark.zip
core: vm: sqlvm: add op functions benchmarkwip/gy-sqlvm-runtime-benchmark
Diffstat
-rw-r--r--core/vm/sqlvm/runtime/instructions.go4
-rw-r--r--core/vm/sqlvm/runtime/instructions_op_test.go8038
-rw-r--r--core/vm/sqlvm/runtime/instructions_test.go39
-rw-r--r--core/vm/sqlvm/runtime/instructions_tmpl.go12
-rw-r--r--core/vm/sqlvm/runtime/opbench.txt76
5 files changed, 4201 insertions, 3968 deletions
diff --git a/core/vm/sqlvm/runtime/instructions.go b/core/vm/sqlvm/runtime/instructions.go
index 6fa72d61a..4a45eeba7 100644
--- a/core/vm/sqlvm/runtime/instructions.go
+++ b/core/vm/sqlvm/runtime/instructions.go
@@ -1564,9 +1564,11 @@ func opCast(ctx *common.Context, ops, registers []*Operand, output uint) (err er
op2 := &Operand{Meta: ops[1].cloneMeta(), Data: make([]Tuple, len(op.Data))}
for i := 0; i < len(op.Data); i++ {
- op2.Data[i] = append(Tuple{}, op.Data[i]...)
+ op2.Data[i] = make(Tuple, len(op.Data[i]))
for j, dType := range dTypes {
+ op2.Data[i][j] = op.Data[i][j].clone()
+
if op.Meta[j] == dType {
continue
}
diff --git a/core/vm/sqlvm/runtime/instructions_op_test.go b/core/vm/sqlvm/runtime/instructions_op_test.go
index 979adf5f6..764b0e242 100644
--- a/core/vm/sqlvm/runtime/instructions_op_test.go
+++ b/core/vm/sqlvm/runtime/instructions_op_test.go
@@ -3,4056 +3,4178 @@
package runtime
import (
+ "testing"
+
"github.com/dexon-foundation/decimal"
"github.com/dexon-foundation/dexon/core/vm/sqlvm/ast"
"github.com/dexon-foundation/dexon/core/vm/sqlvm/errors"
)
+var testcasesOpAdd = []opTestcase{
+ {
+ "None Immediate",
+ Instruction{
+ Op: ADD,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-2)}},
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}},
+ {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(3)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(4)}},
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(20)}},
+ {&Raw{Value: decimal.NewFromFloat(-20)}, &Raw{Value: decimal.NewFromFloat(13)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate",
+ Instruction{
+ Op: ADD,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(11)}, &Raw{Value: decimal.NewFromFloat(8)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(-9)}, &Raw{Value: decimal.NewFromFloat(-12)}, &Raw{Value: decimal.NewFromFloat(-20)}},
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate 2",
+ Instruction{
+ Op: ADD,
+ Input: []*Operand{
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(11)}, &Raw{Value: decimal.NewFromFloat(8)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(-9)}, &Raw{Value: decimal.NewFromFloat(-12)}, &Raw{Value: decimal.NewFromFloat(-20)}},
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Overflow - Immediate",
+ Instruction{
+ Op: ADD,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(127)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeOverflow,
+ },
+ {
+ "Overflow None Immediate",
+ Instruction{
+ Op: ADD,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(126)}},
+ {&Raw{Value: decimal.NewFromFloat(126)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeOverflow,
+ },
+ {
+ "Overflow - Immediate",
+ Instruction{
+ Op: ADD,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(-128)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeOverflow,
+ },
+ {
+ "Overflow None Immediate",
+ Instruction{
+ Op: ADD,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(-127)}},
+ {&Raw{Value: decimal.NewFromFloat(-127)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(-2)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeOverflow,
+ },
+}
+
func (s *instructionSuite) TestOpAdd() {
- testcases := []opTestcase{
- {
- "None Immediate",
- Instruction{
- Op: ADD,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-2)}},
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(10)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}},
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}},
- {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(3)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(4)}},
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(20)}},
- {&Raw{Value: decimal.NewFromFloat(-20)}, &Raw{Value: decimal.NewFromFloat(13)}},
- },
- ),
- nil,
- },
- {
- "Immediate",
- Instruction{
- Op: ADD,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(11)}, &Raw{Value: decimal.NewFromFloat(8)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(-9)}, &Raw{Value: decimal.NewFromFloat(-12)}, &Raw{Value: decimal.NewFromFloat(-20)}},
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- },
- ),
- nil,
- },
- {
- "Immediate 2",
- Instruction{
- Op: ADD,
- Input: []*Operand{
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(11)}, &Raw{Value: decimal.NewFromFloat(8)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(-9)}, &Raw{Value: decimal.NewFromFloat(-12)}, &Raw{Value: decimal.NewFromFloat(-20)}},
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- },
- ),
- nil,
- },
- {
- "Overflow - Immediate",
- Instruction{
- Op: ADD,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(127)}},
- {&Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(1)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeOverflow,
- },
- {
- "Overflow None Immediate",
- Instruction{
- Op: ADD,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(126)}},
- {&Raw{Value: decimal.NewFromFloat(126)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeOverflow,
- },
- {
- "Overflow - Immediate",
- Instruction{
- Op: ADD,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(-128)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeOverflow,
- },
- {
- "Overflow None Immediate",
- Instruction{
- Op: ADD,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(-127)}},
- {&Raw{Value: decimal.NewFromFloat(-127)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(-2)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeOverflow,
- },
- }
-
- s.run(testcases, opAdd)
+ s.run(testcasesOpAdd, opAdd)
+}
+
+func BenchmarkOpAdd(b *testing.B) {
+ runBench(b, testcasesOpAdd, opAdd)
+}
+
+var testcasesOpSub = []opTestcase{
+ {
+ "None Immediate",
+ Instruction{
+ Op: SUB,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-2)}},
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}},
+ {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(3)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-4)}},
+ {&Raw{Value: decimal.NewFromFloat(20)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(-20)}, &Raw{Value: decimal.NewFromFloat(7)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate",
+ Instruction{
+ Op: SUB,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(9)}, &Raw{Value: decimal.NewFromFloat(12)}, &Raw{Value: decimal.NewFromFloat(20)}},
+ {&Raw{Value: decimal.NewFromFloat(-11)}, &Raw{Value: decimal.NewFromFloat(-8)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(4)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate 2",
+ Instruction{
+ Op: SUB,
+ Input: []*Operand{
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(-9)}, &Raw{Value: decimal.NewFromFloat(-12)}, &Raw{Value: decimal.NewFromFloat(-20)}},
+ {&Raw{Value: decimal.NewFromFloat(11)}, &Raw{Value: decimal.NewFromFloat(8)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-4)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Overflow - Immediate",
+ Instruction{
+ Op: SUB,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(127)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeOverflow,
+ },
+ {
+ "Overflow None Immediate",
+ Instruction{
+ Op: SUB,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(126)}},
+ {&Raw{Value: decimal.NewFromFloat(126)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(-2)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeOverflow,
+ },
+ {
+ "Overflow - Immediate",
+ Instruction{
+ Op: SUB,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(-128)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeOverflow,
+ },
+ {
+ "Overflow None Immediate",
+ Instruction{
+ Op: SUB,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(-127)}},
+ {&Raw{Value: decimal.NewFromFloat(-127)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeOverflow,
+ },
}
func (s *instructionSuite) TestOpSub() {
- testcases := []opTestcase{
- {
- "None Immediate",
- Instruction{
- Op: SUB,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-2)}},
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(10)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}},
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}},
- {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(3)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-4)}},
- {&Raw{Value: decimal.NewFromFloat(20)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(-20)}, &Raw{Value: decimal.NewFromFloat(7)}},
- },
- ),
- nil,
- },
- {
- "Immediate",
- Instruction{
- Op: SUB,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(9)}, &Raw{Value: decimal.NewFromFloat(12)}, &Raw{Value: decimal.NewFromFloat(20)}},
- {&Raw{Value: decimal.NewFromFloat(-11)}, &Raw{Value: decimal.NewFromFloat(-8)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(4)}, &Raw{Value: decimal.NewFromFloat(10)}},
- },
- ),
- nil,
- },
- {
- "Immediate 2",
- Instruction{
- Op: SUB,
- Input: []*Operand{
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(-9)}, &Raw{Value: decimal.NewFromFloat(-12)}, &Raw{Value: decimal.NewFromFloat(-20)}},
- {&Raw{Value: decimal.NewFromFloat(11)}, &Raw{Value: decimal.NewFromFloat(8)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-4)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- },
- ),
- nil,
- },
- {
- "Overflow - Immediate",
- Instruction{
- Op: SUB,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(127)}},
- {&Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(1)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeOverflow,
- },
- {
- "Overflow None Immediate",
- Instruction{
- Op: SUB,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(126)}},
- {&Raw{Value: decimal.NewFromFloat(126)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(-2)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeOverflow,
- },
- {
- "Overflow - Immediate",
- Instruction{
- Op: SUB,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(-128)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeOverflow,
- },
- {
- "Overflow None Immediate",
- Instruction{
- Op: SUB,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(-127)}},
- {&Raw{Value: decimal.NewFromFloat(-127)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeOverflow,
- },
- }
-
- s.run(testcases, opSub)
+ s.run(testcasesOpSub, opSub)
+}
+
+func BenchmarkOpSub(b *testing.B) {
+ runBench(b, testcasesOpSub, opSub)
+}
+
+var testcasesOpMul = []opTestcase{
+ {
+ "None Immediate",
+ Instruction{
+ Op: MUL,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(4)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(-4)}, &Raw{Value: decimal.NewFromFloat(-100)}},
+ {&Raw{Value: decimal.NewFromFloat(100)}, &Raw{Value: decimal.NewFromFloat(100)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate",
+ Instruction{
+ Op: MUL,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(-20)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(20)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate - 2",
+ Instruction{
+ Op: MUL,
+ Input: []*Operand{
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(-20)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(20)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Overflow - Immediate",
+ Instruction{
+ Op: MUL,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(127)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeOverflow,
+ },
+ {
+ "Overflow None Immediate",
+ Instruction{
+ Op: MUL,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(126)}},
+ {&Raw{Value: decimal.NewFromFloat(126)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeOverflow,
+ },
+ {
+ "Overflow - Immediate",
+ Instruction{
+ Op: MUL,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(-128)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeOverflow,
+ },
+ {
+ "Overflow None Immediate",
+ Instruction{
+ Op: MUL,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(-127)}},
+ {&Raw{Value: decimal.NewFromFloat(-127)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeOverflow,
+ },
}
func (s *instructionSuite) TestOpMul() {
- testcases := []opTestcase{
- {
- "None Immediate",
- Instruction{
- Op: MUL,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(4)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(-4)}, &Raw{Value: decimal.NewFromFloat(-100)}},
- {&Raw{Value: decimal.NewFromFloat(100)}, &Raw{Value: decimal.NewFromFloat(100)}},
- },
- ),
- nil,
- },
- {
- "Immediate",
- Instruction{
- Op: MUL,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(-20)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(20)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- nil,
- },
- {
- "Immediate - 2",
- Instruction{
- Op: MUL,
- Input: []*Operand{
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(-20)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(20)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- nil,
- },
- {
- "Overflow - Immediate",
- Instruction{
- Op: MUL,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(127)}},
- {&Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(1)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeOverflow,
- },
- {
- "Overflow None Immediate",
- Instruction{
- Op: MUL,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(126)}},
- {&Raw{Value: decimal.NewFromFloat(126)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeOverflow,
- },
- {
- "Overflow - Immediate",
- Instruction{
- Op: MUL,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(-128)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeOverflow,
- },
- {
- "Overflow None Immediate",
- Instruction{
- Op: MUL,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(-127)}},
- {&Raw{Value: decimal.NewFromFloat(-127)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeOverflow,
- },
- }
-
- s.run(testcases, opMul)
+ s.run(testcasesOpMul, opMul)
+}
+
+func BenchmarkOpMul(b *testing.B) {
+ runBench(b, testcasesOpMul, opMul)
+}
+
+var testcasesOpDiv = []opTestcase{
+ {
+ "None Immediate",
+ Instruction{
+ Op: DIV,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate",
+ Instruction{
+ Op: DIV,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ {&Raw{Value: decimal.NewFromFloat(13)}, &Raw{Value: decimal.NewFromFloat(13)}},
+ {&Raw{Value: decimal.NewFromFloat(-13)}, &Raw{Value: decimal.NewFromFloat(-13)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-2)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(-5)}},
+ {&Raw{Value: decimal.NewFromFloat(-5)}, &Raw{Value: decimal.NewFromFloat(5)}},
+ {&Raw{Value: decimal.NewFromFloat(6)}, &Raw{Value: decimal.NewFromFloat(-6)}},
+ {&Raw{Value: decimal.NewFromFloat(-6)}, &Raw{Value: decimal.NewFromFloat(6)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate 2",
+ Instruction{
+ Op: DIV,
+ Input: []*Operand{
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(50)}, &Raw{Value: decimal.NewFromFloat(-50)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ {&Raw{Value: decimal.NewFromFloat(9)}, &Raw{Value: decimal.NewFromFloat(9)}},
+ {&Raw{Value: decimal.NewFromFloat(-9)}, &Raw{Value: decimal.NewFromFloat(-9)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(-5)}},
+ {&Raw{Value: decimal.NewFromFloat(-5)}, &Raw{Value: decimal.NewFromFloat(5)}},
+ {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(-5)}},
+ {&Raw{Value: decimal.NewFromFloat(-5)}, &Raw{Value: decimal.NewFromFloat(5)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "DivideByZero Immediate",
+ Instruction{
+ Op: DIV,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(10)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeDividedByZero,
+ },
+ {
+ "DivideByZero None Immediate",
+ Instruction{
+ Op: DIV,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(10)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeDividedByZero,
+ },
+ {
+ "Overflow - Immediate",
+ Instruction{
+ Op: DIV,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(-128)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeOverflow,
+ },
+ {
+ "Overflow None Immediate",
+ Instruction{
+ Op: DIV,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(-128)}},
+ {&Raw{Value: decimal.NewFromFloat(-128)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(-2)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeOverflow,
+ },
}
func (s *instructionSuite) TestOpDiv() {
- testcases := []opTestcase{
- {
- "None Immediate",
- Instruction{
- Op: DIV,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
- },
- ),
- nil,
- },
- {
- "Immediate",
- Instruction{
- Op: DIV,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- {&Raw{Value: decimal.NewFromFloat(13)}, &Raw{Value: decimal.NewFromFloat(13)}},
- {&Raw{Value: decimal.NewFromFloat(-13)}, &Raw{Value: decimal.NewFromFloat(-13)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-2)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(-5)}},
- {&Raw{Value: decimal.NewFromFloat(-5)}, &Raw{Value: decimal.NewFromFloat(5)}},
- {&Raw{Value: decimal.NewFromFloat(6)}, &Raw{Value: decimal.NewFromFloat(-6)}},
- {&Raw{Value: decimal.NewFromFloat(-6)}, &Raw{Value: decimal.NewFromFloat(6)}},
- },
- ),
- nil,
- },
- {
- "Immediate 2",
- Instruction{
- Op: DIV,
- Input: []*Operand{
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(50)}, &Raw{Value: decimal.NewFromFloat(-50)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- {&Raw{Value: decimal.NewFromFloat(9)}, &Raw{Value: decimal.NewFromFloat(9)}},
- {&Raw{Value: decimal.NewFromFloat(-9)}, &Raw{Value: decimal.NewFromFloat(-9)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(-5)}},
- {&Raw{Value: decimal.NewFromFloat(-5)}, &Raw{Value: decimal.NewFromFloat(5)}},
- {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(-5)}},
- {&Raw{Value: decimal.NewFromFloat(-5)}, &Raw{Value: decimal.NewFromFloat(5)}},
- },
- ),
- nil,
- },
- {
- "DivideByZero Immediate",
- Instruction{
- Op: DIV,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(10)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeDividedByZero,
- },
- {
- "DivideByZero None Immediate",
- Instruction{
- Op: DIV,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(10)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeDividedByZero,
- },
- {
- "Overflow - Immediate",
- Instruction{
- Op: DIV,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(-128)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeOverflow,
- },
- {
- "Overflow None Immediate",
- Instruction{
- Op: DIV,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(-128)}},
- {&Raw{Value: decimal.NewFromFloat(-128)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(-2)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeOverflow,
- },
- }
-
- s.run(testcases, opDiv)
+ s.run(testcasesOpDiv, opDiv)
+}
+
+func BenchmarkOpDiv(b *testing.B) {
+ runBench(b, testcasesOpDiv, opDiv)
+}
+
+var testcasesOpMod = []opTestcase{
+ {
+ "None Immediate",
+ Instruction{
+ Op: MOD,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-2)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-2)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(3)}, &Raw{Value: decimal.NewFromFloat(3)}},
+ {&Raw{Value: decimal.NewFromFloat(-3)}, &Raw{Value: decimal.NewFromFloat(-3)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-2)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-2)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate",
+ Instruction{
+ Op: MOD,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ {&Raw{Value: decimal.NewFromFloat(13)}, &Raw{Value: decimal.NewFromFloat(13)}},
+ {&Raw{Value: decimal.NewFromFloat(-13)}, &Raw{Value: decimal.NewFromFloat(-13)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(3)}, &Raw{Value: decimal.NewFromFloat(-3)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate - 2",
+ Instruction{
+ Op: MOD,
+ Input: []*Operand{
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(31)}, &Raw{Value: decimal.NewFromFloat(-31)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
+ {&Raw{Value: decimal.NewFromFloat(13)}, &Raw{Value: decimal.NewFromFloat(13)}},
+ {&Raw{Value: decimal.NewFromFloat(-13)}, &Raw{Value: decimal.NewFromFloat(-13)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(-5)}},
+ {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(-5)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "ModideByZero Immediate",
+ Instruction{
+ Op: MOD,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(10)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeDividedByZero,
+ },
+ {
+ "ModideByZero None Immediate",
+ Instruction{
+ Op: MOD,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(10)}},
+ {&Raw{Value: decimal.NewFromFloat(10)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeDividedByZero,
+ },
}
func (s *instructionSuite) TestOpMod() {
- testcases := []opTestcase{
- {
- "None Immediate",
- Instruction{
- Op: MOD,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-2)}},
- {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-2)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(3)}, &Raw{Value: decimal.NewFromFloat(3)}},
- {&Raw{Value: decimal.NewFromFloat(-3)}, &Raw{Value: decimal.NewFromFloat(-3)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-2)}},
- {&Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-2)}},
- },
- ),
- nil,
- },
- {
- "Immediate",
- Instruction{
- Op: MOD,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- {&Raw{Value: decimal.NewFromFloat(13)}, &Raw{Value: decimal.NewFromFloat(13)}},
- {&Raw{Value: decimal.NewFromFloat(-13)}, &Raw{Value: decimal.NewFromFloat(-13)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(3)}, &Raw{Value: decimal.NewFromFloat(-3)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- nil,
- },
- {
- "Immediate - 2",
- Instruction{
- Op: MOD,
- Input: []*Operand{
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(31)}, &Raw{Value: decimal.NewFromFloat(-31)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(10)}, &Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(-10)}, &Raw{Value: decimal.NewFromFloat(-10)}},
- {&Raw{Value: decimal.NewFromFloat(13)}, &Raw{Value: decimal.NewFromFloat(13)}},
- {&Raw{Value: decimal.NewFromFloat(-13)}, &Raw{Value: decimal.NewFromFloat(-13)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(-5)}},
- {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(-5)}},
- },
- ),
- nil,
- },
- {
- "ModideByZero Immediate",
- Instruction{
- Op: MOD,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(10)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeDividedByZero,
- },
- {
- "ModideByZero None Immediate",
- Instruction{
- Op: MOD,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(10)}},
- {&Raw{Value: decimal.NewFromFloat(10)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeDividedByZero,
- },
- }
-
- s.run(testcases, opMod)
+ s.run(testcasesOpMod, opMod)
+}
+
+func BenchmarkOpMod(b *testing.B) {
+ runBench(b, testcasesOpMod, opMod)
+}
+
+var testcasesOpConcat = []opTestcase{
+ {
+ "Concat bytes",
+ Instruction{
+ Op: CONCAT,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abc-1")}, &Raw{Bytes: []byte("xyz-1")}},
+ {&Raw{Bytes: []byte("abc-2")}, &Raw{Bytes: []byte("xyz-2")}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("ABC-1")}, &Raw{Bytes: []byte("XYZ-1")}},
+ {&Raw{Bytes: []byte("ABC-2")}, &Raw{Bytes: []byte("XYZ-2")}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abc-1ABC-1")}, &Raw{Bytes: []byte("xyz-1XYZ-1")}},
+ {&Raw{Bytes: []byte("abc-2ABC-2")}, &Raw{Bytes: []byte("xyz-2XYZ-2")}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Invalid concat",
+ Instruction{
+ Op: CONCAT,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abc-1")}, rawTrue},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("ABC-1")}, rawFalse},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeInvalidDataType,
+ },
}
func (s *instructionSuite) TestOpConcat() {
- testcases := []opTestcase{
- {
- "Concat bytes",
- Instruction{
- Op: CONCAT,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abc-1")}, &Raw{Bytes: []byte("xyz-1")}},
- {&Raw{Bytes: []byte("abc-2")}, &Raw{Bytes: []byte("xyz-2")}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("ABC-1")}, &Raw{Bytes: []byte("XYZ-1")}},
- {&Raw{Bytes: []byte("ABC-2")}, &Raw{Bytes: []byte("XYZ-2")}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abc-1ABC-1")}, &Raw{Bytes: []byte("xyz-1XYZ-1")}},
- {&Raw{Bytes: []byte("abc-2ABC-2")}, &Raw{Bytes: []byte("xyz-2XYZ-2")}},
- },
- ),
- nil,
- },
- {
- "Invalid concat",
- Instruction{
- Op: CONCAT,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abc-1")}, rawTrue},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("ABC-1")}, rawFalse},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeInvalidDataType,
- },
- }
-
- s.run(testcases, opConcat)
+ s.run(testcasesOpConcat, opConcat)
+}
+
+func BenchmarkOpConcat(b *testing.B) {
+ runBench(b, testcasesOpConcat, opConcat)
+}
+
+var testcasesOpNeg = []opTestcase{
+ {
+ "Neg unary",
+ Instruction{
+ Op: NEG,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Overflow Neg",
+ Instruction{
+ Op: NEG,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(-128)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeOverflow,
+ },
+ {
+ "Invalid Neg",
+ Instruction{
+ Op: NEG,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abc-1")}, rawTrue},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeInvalidDataType,
+ },
+ {
+ "Invalid Neg",
+ Instruction{
+ Op: NEG,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abc-1")}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeDataLengthNotMatch,
+ },
}
func (s *instructionSuite) TestOpNeg() {
- testcases := []opTestcase{
- {
- "Neg unary",
- Instruction{
- Op: NEG,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}},
- },
- ),
- nil,
- },
- {
- "Overflow Neg",
- Instruction{
- Op: NEG,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(-128)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeOverflow,
- },
- {
- "Invalid Neg",
- Instruction{
- Op: NEG,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abc-1")}, rawTrue},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeInvalidDataType,
- },
- {
- "Invalid Neg",
- Instruction{
- Op: NEG,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abc-1")}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeDataLengthNotMatch,
- },
- }
-
- s.run(testcases, opNeg)
+ s.run(testcasesOpNeg, opNeg)
+}
+
+func BenchmarkOpNeg(b *testing.B) {
+ runBench(b, testcasesOpNeg, opNeg)
+}
+
+var testcasesOpLt = []opTestcase{
+ {
+ "None Immediate",
+ Instruction{
+ Op: LT,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawFalse, rawTrue, rawTrue},
+ {rawFalse, rawFalse, rawTrue},
+ {rawFalse, rawFalse, rawFalse},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate",
+ Instruction{
+ Op: LT,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawFalse, rawFalse, rawTrue},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate - 2",
+ Instruction{
+ Op: LT,
+ Input: []*Operand{
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawFalse, rawTrue, rawFalse},
+ },
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpLt() {
- testcases := []opTestcase{
- {
- "None Immediate",
- Instruction{
- Op: LT,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawFalse, rawTrue, rawTrue},
- {rawFalse, rawFalse, rawTrue},
- {rawFalse, rawFalse, rawFalse},
- },
- ),
- nil,
- },
- {
- "Immediate",
- Instruction{
- Op: LT,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawFalse, rawFalse, rawTrue},
- },
- ),
- nil,
- },
- {
- "Immediate - 2",
- Instruction{
- Op: LT,
- Input: []*Operand{
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawFalse, rawTrue, rawFalse},
- },
- ),
- nil,
- },
- }
-
- s.run(testcases, opLt)
+ s.run(testcasesOpLt, opLt)
+}
+
+func BenchmarkOpLt(b *testing.B) {
+ runBench(b, testcasesOpLt, opLt)
+}
+
+var testcasesOpGt = []opTestcase{
+ {
+ "None Immediate",
+ Instruction{
+ Op: GT,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawFalse, rawFalse, rawFalse},
+ {rawTrue, rawFalse, rawFalse},
+ {rawTrue, rawTrue, rawFalse},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate",
+ Instruction{
+ Op: GT,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawFalse, rawTrue, rawFalse},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate - 2",
+ Instruction{
+ Op: GT,
+ Input: []*Operand{
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawFalse, rawFalse, rawTrue},
+ },
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpGt() {
- testcases := []opTestcase{
- {
- "None Immediate",
- Instruction{
- Op: GT,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawFalse, rawFalse, rawFalse},
- {rawTrue, rawFalse, rawFalse},
- {rawTrue, rawTrue, rawFalse},
- },
- ),
- nil,
- },
- {
- "Immediate",
- Instruction{
- Op: GT,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawFalse, rawTrue, rawFalse},
- },
- ),
- nil,
- },
- {
- "Immediate - 2",
- Instruction{
- Op: GT,
- Input: []*Operand{
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawFalse, rawFalse, rawTrue},
- },
- ),
- nil,
- },
- }
-
- s.run(testcases, opGt)
+ s.run(testcasesOpGt, opGt)
+}
+
+func BenchmarkOpGt(b *testing.B) {
+ runBench(b, testcasesOpGt, opGt)
+}
+
+var testcasesOpEq = []opTestcase{
+ {
+ "None Immediate",
+ Instruction{
+ Op: EQ,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawTrue, rawTrue},
+ {rawTrue, rawFalse, rawFalse},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate",
+ Instruction{
+ Op: EQ,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawTrue, rawTrue},
+ {rawTrue, rawFalse, rawFalse},
+ },
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpEq() {
- testcases := []opTestcase{
- {
- "None Immediate",
- Instruction{
- Op: EQ,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(1)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawTrue, rawTrue},
- {rawTrue, rawFalse, rawFalse},
- },
- ),
- nil,
- },
- {
- "Immediate",
- Instruction{
- Op: EQ,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(-1)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawTrue, rawTrue},
- {rawTrue, rawFalse, rawFalse},
- },
- ),
- nil,
- },
- }
-
- s.run(testcases, opEq)
+ s.run(testcasesOpEq, opEq)
+}
+
+func BenchmarkOpEq(b *testing.B) {
+ runBench(b, testcasesOpEq, opEq)
+}
+
+var testcasesOpAnd = []opTestcase{
+ {
+ "None Immediate",
+ Instruction{
+ Op: AND,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawFalse},
+ {rawFalse, rawTrue},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawTrue},
+ {rawFalse, rawFalse},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawFalse},
+ {rawFalse, rawFalse},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate",
+ Instruction{
+ Op: AND,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawFalse},
+ {rawFalse, rawTrue},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawTrue},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawFalse},
+ {rawFalse, rawTrue},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate - 2",
+ Instruction{
+ Op: AND,
+ Input: []*Operand{
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawTrue},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawFalse},
+ {rawFalse, rawTrue},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawFalse},
+ {rawFalse, rawTrue},
+ },
+ ),
+ nil,
+ },
+ {
+ "Invalid Data Type",
+ Instruction{
+ Op: AND,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeInvalidDataType,
+ },
}
func (s *instructionSuite) TestOpAnd() {
- testcases := []opTestcase{
- {
- "None Immediate",
- Instruction{
- Op: AND,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawFalse},
- {rawFalse, rawTrue},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawTrue},
- {rawFalse, rawFalse},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawFalse},
- {rawFalse, rawFalse},
- },
- ),
- nil,
- },
- {
- "Immediate",
- Instruction{
- Op: AND,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawFalse},
- {rawFalse, rawTrue},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawTrue},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawFalse},
- {rawFalse, rawTrue},
- },
- ),
- nil,
- },
- {
- "Immediate - 2",
- Instruction{
- Op: AND,
- Input: []*Operand{
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawTrue},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawFalse},
- {rawFalse, rawTrue},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawFalse},
- {rawFalse, rawTrue},
- },
- ),
- nil,
- },
- {
- "Invalid Data Type",
- Instruction{
- Op: AND,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeInvalidDataType,
- },
- }
-
- s.run(testcases, opAnd)
+ s.run(testcasesOpAnd, opAnd)
+}
+
+func BenchmarkOpAnd(b *testing.B) {
+ runBench(b, testcasesOpAnd, opAnd)
+}
+
+var testcasesOpOr = []opTestcase{
+ {
+ "None Immediate",
+ Instruction{
+ Op: OR,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawFalse},
+ {rawFalse, rawTrue},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawTrue},
+ {rawFalse, rawFalse},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawTrue},
+ {rawFalse, rawTrue},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate",
+ Instruction{
+ Op: OR,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawFalse},
+ {rawFalse, rawTrue},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawTrue},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawTrue},
+ {rawTrue, rawTrue},
+ },
+ ),
+ nil,
+ },
+ {
+ "Immediate - 2",
+ Instruction{
+ Op: OR,
+ Input: []*Operand{
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawTrue},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawFalse},
+ {rawFalse, rawTrue},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawTrue},
+ {rawTrue, rawTrue},
+ },
+ ),
+ nil,
+ },
+ {
+ "Invalid Data Type",
+ Instruction{
+ Op: OR,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeInvalidDataType,
+ },
}
func (s *instructionSuite) TestOpOr() {
- testcases := []opTestcase{
- {
- "None Immediate",
- Instruction{
- Op: OR,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawFalse},
- {rawFalse, rawTrue},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawTrue},
- {rawFalse, rawFalse},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawTrue},
- {rawFalse, rawTrue},
- },
- ),
- nil,
- },
- {
- "Immediate",
- Instruction{
- Op: OR,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawFalse},
- {rawFalse, rawTrue},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawTrue},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawTrue},
- {rawTrue, rawTrue},
- },
- ),
- nil,
- },
- {
- "Immediate - 2",
- Instruction{
- Op: OR,
- Input: []*Operand{
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawTrue},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawFalse},
- {rawFalse, rawTrue},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawTrue},
- {rawTrue, rawTrue},
- },
- ),
- nil,
- },
- {
- "Invalid Data Type",
- Instruction{
- Op: OR,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeInvalidDataType,
- },
- }
-
- s.run(testcases, opOr)
+ s.run(testcasesOpOr, opOr)
+}
+
+func BenchmarkOpOr(b *testing.B) {
+ runBench(b, testcasesOpOr, opOr)
+}
+
+var testcasesOpNot = []opTestcase{
+ {
+ "None Immediate",
+ Instruction{
+ Op: NOT,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawFalse},
+ {rawFalse, rawTrue},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawFalse, rawTrue},
+ {rawTrue, rawFalse},
+ },
+ ),
+ nil,
+ },
+ {
+ "Errors Invalid Data Type",
+ Instruction{
+ Op: NOT,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeInvalidDataType,
+ },
}
func (s *instructionSuite) TestOpNot() {
- testcases := []opTestcase{
- {
- "None Immediate",
- Instruction{
- Op: NOT,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawFalse},
- {rawFalse, rawTrue},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawFalse, rawTrue},
- {rawTrue, rawFalse},
- },
- ),
- nil,
- },
- {
- "Errors Invalid Data Type",
- Instruction{
- Op: NOT,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeInvalidDataType,
- },
- }
-
- s.run(testcases, opNot)
+ s.run(testcasesOpNot, opNot)
+}
+
+func BenchmarkOpNot(b *testing.B) {
+ runBench(b, testcasesOpNot, opNot)
+}
+
+var testcasesOpUnion = []opTestcase{
+ {
+ "None Immediate",
+ Instruction{
+ Op: UNION,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawFalse},
+ {rawFalse, rawTrue},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawTrue},
+ {rawFalse, rawFalse},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawFalse, rawFalse},
+ {rawFalse, rawTrue},
+ {rawTrue, rawFalse},
+ {rawTrue, rawTrue},
+ },
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpUnion() {
- testcases := []opTestcase{
- {
- "None Immediate",
- Instruction{
- Op: UNION,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawFalse},
- {rawFalse, rawTrue},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawTrue},
- {rawFalse, rawFalse},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawFalse, rawFalse},
- {rawFalse, rawTrue},
- {rawTrue, rawFalse},
- {rawTrue, rawTrue},
- },
- ),
- nil,
- },
- }
-
- s.run(testcases, opUnion)
+ s.run(testcasesOpUnion, opUnion)
+}
+
+func BenchmarkOpUnion(b *testing.B) {
+ runBench(b, testcasesOpUnion, opUnion)
+}
+
+var testcasesOpIntxn = []opTestcase{
+ {
+ "None Immediate",
+ Instruction{
+ Op: INTXN,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawFalse},
+ {rawFalse, rawTrue},
+ {rawTrue, rawTrue},
+ {rawFalse, rawFalse},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawTrue},
+ {rawFalse, rawFalse},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawFalse, rawFalse},
+ {rawTrue, rawTrue},
+ },
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpIntxn() {
- testcases := []opTestcase{
- {
- "None Immediate",
- Instruction{
- Op: INTXN,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawFalse},
- {rawFalse, rawTrue},
- {rawTrue, rawTrue},
- {rawFalse, rawFalse},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawTrue},
- {rawFalse, rawFalse},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawFalse, rawFalse},
- {rawTrue, rawTrue},
- },
- ),
- nil,
- },
- }
-
- s.run(testcases, opIntxn)
+ s.run(testcasesOpIntxn, opIntxn)
+}
+
+func BenchmarkOpIntxn(b *testing.B) {
+ runBench(b, testcasesOpIntxn, opIntxn)
+}
+
+var testcasesOpLike = []opTestcase{
+ {
+ "Like %\\%b% escape \\",
+ Instruction{
+ Op: LIKE,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("a%bcdefg")}, &Raw{Bytes: []byte("gfedcba")}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("%\\%b%")}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("\\")}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawFalse},
+ },
+ ),
+ nil,
+ },
+ {
+ "Like t1 escape t2",
+ Instruction{
+ Op: LIKE,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("a%bcdefg")}},
+ {&Raw{Bytes: []byte("gfedcba")}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("%\\%b%")}},
+ {&Raw{Bytes: []byte("_fed%")}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("\\")}},
+ {&Raw{Bytes: []byte("")}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue},
+ {rawTrue},
+ },
+ ),
+ nil,
+ },
+ {
+ "Like with valid and invalid UTF8",
+ Instruction{
+ Op: LIKE,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte{226, 40, 161, 228, 189, 160, 229, 165, 189}}, &Raw{Bytes: []byte("gfedcba")}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte{37, 228, 189, 160, 37}}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawFalse},
+ },
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpLike() {
- testcases := []opTestcase{
- {
- "Like %\\%b% escape \\",
- Instruction{
- Op: LIKE,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("a%bcdefg")}, &Raw{Bytes: []byte("gfedcba")}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("%\\%b%")}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("\\")}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawFalse},
- },
- ),
- nil,
- },
- {
- "Like t1 escape t2",
- Instruction{
- Op: LIKE,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("a%bcdefg")}},
- {&Raw{Bytes: []byte("gfedcba")}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("%\\%b%")}},
- {&Raw{Bytes: []byte("_fed%")}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("\\")}},
- {&Raw{Bytes: []byte("")}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue},
- {rawTrue},
- },
- ),
- nil,
- },
- {
- "Like with valid and invalid UTF8",
- Instruction{
- Op: LIKE,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte{226, 40, 161, 228, 189, 160, 229, 165, 189}}, &Raw{Bytes: []byte("gfedcba")}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte{37, 228, 189, 160, 37}}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawFalse},
- },
- ),
- nil,
- },
- }
-
- s.run(testcases, opLike)
+ s.run(testcasesOpLike, opLike)
+}
+
+func BenchmarkOpLike(b *testing.B) {
+ runBench(b, testcasesOpLike, opLike)
+}
+
+var testcasesOpZip = []opTestcase{
+ {
+ "Zip two array",
+ Instruction{
+ Op: ZIP,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}},
+ {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
+ {&Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
+ {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
+ },
+ ),
+ nil,
+ },
+ {
+ "Zip immediate",
+ Instruction{
+ Op: ZIP,
+ Input: []*Operand{
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
+ {&Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
+ {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
+ },
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpZip() {
- testcases := []opTestcase{
- {
- "Zip two array",
- Instruction{
- Op: ZIP,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}},
- {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
- {&Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
- {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
- },
- ),
- nil,
- },
- {
- "Zip immediate",
- Instruction{
- Op: ZIP,
- Input: []*Operand{
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
- {&Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
- {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
- },
- ),
- nil,
- },
- }
-
- s.run(testcases, opZip)
+ s.run(testcasesOpZip, opZip)
+}
+
+func BenchmarkOpZip(b *testing.B) {
+ runBench(b, testcasesOpZip, opZip)
+}
+
+var testcasesOpField = []opTestcase{
+ {
+ "Retrieve 2nd,3rd column",
+ Instruction{
+ Op: FIELD,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
+ {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpField() {
- testcases := []opTestcase{
- {
- "Retrieve 2nd,3rd column",
- Instruction{
- Op: FIELD,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
- {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- nil,
- },
- }
-
- s.run(testcases, opField)
+ s.run(testcasesOpField, opField)
+}
+
+func BenchmarkOpField(b *testing.B) {
+ runBench(b, testcasesOpField, opField)
+}
+
+var testcasesOpPrune = []opTestcase{
+ {
+ "Prune 2nd,4th,5th column",
+ Instruction{
+ Op: PRUNE,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawFalse, rawTrue},
+ {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawTrue, rawFalse},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(3)}, &Raw{Value: decimal.NewFromFloat(4)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpPrune() {
- testcases := []opTestcase{
- {
- "Prune 2nd,4th,5th column",
- Instruction{
- Op: PRUNE,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawFalse, rawTrue},
- {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawTrue, rawFalse},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(3)}, &Raw{Value: decimal.NewFromFloat(4)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- nil,
- },
- }
-
- s.run(testcases, opPrune)
+ s.run(testcasesOpPrune, opPrune)
+}
+
+func BenchmarkOpPrune(b *testing.B) {
+ runBench(b, testcasesOpPrune, opPrune)
+}
+
+var testcasesOpCut = []opTestcase{
+ {
+ "Cut 2nd to 4th columns",
+ Instruction{
+ Op: CUT,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawFalse, rawTrue},
+ {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawTrue, rawFalse},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(3)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abcdefg-1")}, rawTrue},
+ {&Raw{Bytes: []byte("abcdefg-2")}, rawFalse},
+ },
+ ),
+ nil,
+ },
+ {
+ "Cut 1st column",
+ Instruction{
+ Op: CUT,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawFalse, rawTrue},
+ {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawTrue, rawFalse},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawFalse, rawTrue},
+ {&Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawTrue, rawFalse},
+ },
+ ),
+ nil,
+ },
+ {
+ "Cut since 2nd column",
+ Instruction{
+ Op: CUT,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
+ {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abcdefg-1")}},
+ {&Raw{Bytes: []byte("abcdefg-2")}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Cut all columns",
+ Instruction{
+ Op: CUT,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
+ {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{
+ {},
+ {},
+ },
+ ),
+ nil,
+ },
+ {
+ "Cut error range - 1",
+ Instruction{
+ Op: CUT,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
+ {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(5)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeIndexOutOfRange,
+ },
+ {
+ "Cut error range - 2",
+ Instruction{
+ Op: CUT,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
+ {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(15)}, &Raw{Value: decimal.NewFromFloat(17)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeIndexOutOfRange,
+ },
}
func (s *instructionSuite) TestOpCut() {
- testcases := []opTestcase{
- {
- "Cut 2nd to 4th columns",
- Instruction{
- Op: CUT,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawFalse, rawTrue},
- {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawTrue, rawFalse},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(3)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abcdefg-1")}, rawTrue},
- {&Raw{Bytes: []byte("abcdefg-2")}, rawFalse},
- },
- ),
- nil,
- },
- {
- "Cut 1st column",
- Instruction{
- Op: CUT,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawFalse, rawTrue},
- {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawTrue, rawFalse},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawFalse, rawTrue},
- {&Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawTrue, rawFalse},
- },
- ),
- nil,
- },
- {
- "Cut since 2nd column",
- Instruction{
- Op: CUT,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
- {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abcdefg-1")}},
- {&Raw{Bytes: []byte("abcdefg-2")}},
- },
- ),
- nil,
- },
- {
- "Cut all columns",
- Instruction{
- Op: CUT,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
- {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{
- {},
- {},
- },
- ),
- nil,
- },
- {
- "Cut error range - 1",
- Instruction{
- Op: CUT,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
- {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(5)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeIndexOutOfRange,
- },
- {
- "Cut error range - 2",
- Instruction{
- Op: CUT,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("abcdefg-1")}, &Raw{Bytes: []byte("gfedcba-1")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
- {&Raw{Bytes: []byte("abcdefg-2")}, &Raw{Bytes: []byte("gfedcba-2")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(15)}, &Raw{Value: decimal.NewFromFloat(17)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeIndexOutOfRange,
- },
- }
-
- s.run(testcases, opCut)
+ s.run(testcasesOpCut, opCut)
+}
+
+func BenchmarkOpCut(b *testing.B) {
+ runBench(b, testcasesOpCut, opCut)
+}
+
+var testcasesOpFilter = []opTestcase{
+ {
+ "Filter first 2 rows",
+ Instruction{
+ Op: FILTER,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawFalse},
+ {rawFalse, rawTrue},
+ {rawTrue, rawTrue},
+ {rawFalse, rawFalse},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue},
+ {rawTrue},
+ {rawFalse},
+ {rawFalse},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawFalse},
+ {rawFalse, rawTrue},
+ },
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpFilter() {
- testcases := []opTestcase{
- {
- "Filter first 2 rows",
- Instruction{
- Op: FILTER,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawFalse},
- {rawFalse, rawTrue},
- {rawTrue, rawTrue},
- {rawFalse, rawFalse},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue},
- {rawTrue},
- {rawFalse},
- {rawFalse},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawFalse},
- {rawFalse, rawTrue},
- },
- ),
- nil,
- },
- }
-
- s.run(testcases, opFilter)
+ s.run(testcasesOpFilter, opFilter)
+}
+
+func BenchmarkOpFilter(b *testing.B) {
+ runBench(b, testcasesOpFilter, opFilter)
+}
+
+var testcasesOpCast = []opTestcase{
+ {
+ "None Immediate - int",
+ Instruction{
+ Op: CAST,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 1), ast.ComposeDataType(ast.DataTypeMajorInt, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(127)}, &Raw{Value: decimal.NewFromFloat(127)}},
+ {&Raw{Value: decimal.NewFromFloat(-128)}, &Raw{Value: decimal.NewFromFloat(-128)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 2),
+ },
+ []Tuple{},
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 2),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(127)}, &Raw{Value: decimal.NewFromFloat(127)}},
+ {&Raw{Value: decimal.NewFromFloat(-128)}, &Raw{Value: decimal.NewFromFloat(-128)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "None Immediate - int2",
+ Instruction{
+ Op: CAST,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 1), ast.ComposeDataType(ast.DataTypeMajorInt, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Value: decimal.NewFromFloat(-32768)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 1), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
+ },
+ []Tuple{},
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 1), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Value: decimal.NewFromFloat(32768)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "None Immediate - int3",
+ Instruction{
+ Op: CAST,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 1), ast.ComposeDataType(ast.DataTypeMajorInt, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Value: decimal.NewFromFloat(-32768)}},
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{},
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawTrue},
+ {rawFalse, rawFalse},
+ },
+ ),
+ nil,
+ },
+ {
+ "None Immediate - int4",
+ Instruction{
+ Op: CAST,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 1), ast.ComposeDataType(ast.DataTypeMajorInt, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Value: decimal.NewFromFloat(-32768)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1), ast.ComposeDataType(ast.DataTypeMajorAddress, 0),
+ },
+ []Tuple{},
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1), ast.ComposeDataType(ast.DataTypeMajorAddress, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte{0x7f, 0xff}}, &Raw{Bytes: []byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0x80, 0x00}}},
+ },
+ ),
+ nil,
+ },
+ {
+ "None Immediate - uint",
+ Instruction{
+ Op: CAST,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 1), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(128)}, &Raw{Value: decimal.NewFromFloat(128)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 2),
+ },
+ []Tuple{},
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 2),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(128)}, &Raw{Value: decimal.NewFromFloat(128)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "None Immediate - uint2",
+ Instruction{
+ Op: CAST,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 1), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Value: decimal.NewFromFloat(32768)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 1), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1),
+ },
+ []Tuple{},
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 1), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Bytes: []byte{0x80, 0x00}}},
+ },
+ ),
+ nil,
+ },
+ {
+ "None Immediate - uint3",
+ Instruction{
+ Op: CAST,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 1), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{},
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue, rawFalse},
+ },
+ ),
+ nil,
+ },
+ {
+ "None Immediate - uint4",
+ Instruction{
+ Op: CAST,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 1), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1),
+ },
+ []Tuple{},
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte{0x7f, 0xff}}, &Raw{Bytes: []byte{0x00, 0x00}}},
+ },
+ ),
+ nil,
+ },
+ {
+ "None Immediate - uint5",
+ Instruction{
+ Op: CAST,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(32767)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorAddress, 1),
+ },
+ []Tuple{},
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorAddress, 1),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x7f, 0xff}}},
+ },
+ ),
+ nil,
+ },
+ {
+ "None Immediate - bytes",
+ Instruction{
+ Op: CAST,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte{0xff, 0xff}}, &Raw{Bytes: []byte{0xff, 0xff}}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 2),
+ },
+ []Tuple{},
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 2),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte{0xff}}, &Raw{Bytes: []byte{0xff, 0xff, 0x00}}},
+ },
+ ),
+ nil,
+ },
+ {
+ "None Immediate - bytes2",
+ Instruction{
+ Op: CAST,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte{0x7f, 0xff}}, &Raw{Bytes: []byte{0x80, 0x00}}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 1), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
+ },
+ []Tuple{},
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 1), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Value: decimal.NewFromFloat(32768)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "None Immediate - bytes3",
+ Instruction{
+ Op: CAST,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte{0x7f, 0xff}}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 1),
+ },
+ []Tuple{},
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 1),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte{0x7f, 0xff}}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Same type",
+ Instruction{
+ Op: CAST,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{},
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {rawTrue},
+ },
+ ),
+ nil,
+ },
+ {
+ "Error Invalid Type",
+ Instruction{
+ Op: CAST,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 2),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(-32768)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{},
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{},
+ []Tuple{},
+ ),
+ errors.ErrorCodeInvalidCastType,
+ },
}
func (s *instructionSuite) TestOpCast() {
- testcases := []opTestcase{
- {
- "None Immediate - int",
- Instruction{
- Op: CAST,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 1), ast.ComposeDataType(ast.DataTypeMajorInt, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(127)}, &Raw{Value: decimal.NewFromFloat(127)}},
- {&Raw{Value: decimal.NewFromFloat(-128)}, &Raw{Value: decimal.NewFromFloat(-128)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 2),
- },
- []Tuple{},
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 2),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(127)}, &Raw{Value: decimal.NewFromFloat(127)}},
- {&Raw{Value: decimal.NewFromFloat(-128)}, &Raw{Value: decimal.NewFromFloat(-128)}},
- },
- ),
- nil,
- },
- {
- "None Immediate - int2",
- Instruction{
- Op: CAST,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 1), ast.ComposeDataType(ast.DataTypeMajorInt, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Value: decimal.NewFromFloat(-32768)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 1), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
- },
- []Tuple{},
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 1), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Value: decimal.NewFromFloat(32768)}},
- },
- ),
- nil,
- },
- {
- "None Immediate - int3",
- Instruction{
- Op: CAST,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 1), ast.ComposeDataType(ast.DataTypeMajorInt, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Value: decimal.NewFromFloat(-32768)}},
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{},
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawTrue},
- {rawFalse, rawFalse},
- },
- ),
- nil,
- },
- {
- "None Immediate - int4",
- Instruction{
- Op: CAST,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 1), ast.ComposeDataType(ast.DataTypeMajorInt, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Value: decimal.NewFromFloat(-32768)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1), ast.ComposeDataType(ast.DataTypeMajorAddress, 0),
- },
- []Tuple{},
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1), ast.ComposeDataType(ast.DataTypeMajorAddress, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte{0x7f, 0xff}}, &Raw{Bytes: []byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0x80, 0x00}}},
- },
- ),
- nil,
- },
- {
- "None Immediate - uint",
- Instruction{
- Op: CAST,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 1), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(128)}, &Raw{Value: decimal.NewFromFloat(128)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 2),
- },
- []Tuple{},
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 2),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(128)}, &Raw{Value: decimal.NewFromFloat(128)}},
- },
- ),
- nil,
- },
- {
- "None Immediate - uint2",
- Instruction{
- Op: CAST,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 1), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Value: decimal.NewFromFloat(32768)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 1), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1),
- },
- []Tuple{},
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 1), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Bytes: []byte{0x80, 0x00}}},
- },
- ),
- nil,
- },
- {
- "None Immediate - uint3",
- Instruction{
- Op: CAST,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 1), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{},
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue, rawFalse},
- },
- ),
- nil,
- },
- {
- "None Immediate - uint4",
- Instruction{
- Op: CAST,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 1), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1),
- },
- []Tuple{},
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1),
- },
- []Tuple{
- {&Raw{Bytes: []byte{0x7f, 0xff}}, &Raw{Bytes: []byte{0x00, 0x00}}},
- },
- ),
- nil,
- },
- {
- "None Immediate - uint5",
- Instruction{
- Op: CAST,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(32767)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorAddress, 1),
- },
- []Tuple{},
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorAddress, 1),
- },
- []Tuple{
- {&Raw{Bytes: []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x7f, 0xff}}},
- },
- ),
- nil,
- },
- {
- "None Immediate - bytes",
- Instruction{
- Op: CAST,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1),
- },
- []Tuple{
- {&Raw{Bytes: []byte{0xff, 0xff}}, &Raw{Bytes: []byte{0xff, 0xff}}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 2),
- },
- []Tuple{},
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 2),
- },
- []Tuple{
- {&Raw{Bytes: []byte{0xff}}, &Raw{Bytes: []byte{0xff, 0xff, 0x00}}},
- },
- ),
- nil,
- },
- {
- "None Immediate - bytes2",
- Instruction{
- Op: CAST,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1),
- },
- []Tuple{
- {&Raw{Bytes: []byte{0x7f, 0xff}}, &Raw{Bytes: []byte{0x80, 0x00}}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 1), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
- },
- []Tuple{},
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 1), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(32767)}, &Raw{Value: decimal.NewFromFloat(32768)}},
- },
- ),
- nil,
- },
- {
- "None Immediate - bytes3",
- Instruction{
- Op: CAST,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 1),
- },
- []Tuple{
- {&Raw{Bytes: []byte{0x7f, 0xff}}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 1),
- },
- []Tuple{},
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 1),
- },
- []Tuple{
- {&Raw{Bytes: []byte{0x7f, 0xff}}},
- },
- ),
- nil,
- },
- {
- "Same type",
- Instruction{
- Op: CAST,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{},
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {rawTrue},
- },
- ),
- nil,
- },
- {
- "Error Invalid Type",
- Instruction{
- Op: CAST,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 2),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(-32768)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{},
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{},
- []Tuple{},
- ),
- errors.ErrorCodeInvalidCastType,
- },
- }
-
- s.run(testcases, opCast)
+ s.run(testcasesOpCast, opCast)
+}
+
+func BenchmarkOpCast(b *testing.B) {
+ runBench(b, testcasesOpCast, opCast)
+}
+
+var testcasesOpSort = []opTestcase{
+ {
+ "Multi-column sorting",
+ Instruction{
+ Op: SORT,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("c")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
+ {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(2)}, rawTrue},
+ {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(3)}, rawTrue},
+ {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(1)}, rawFalse},
+ {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
+ {&Raw{Bytes: []byte("c")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
+ {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
+ {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
+ },
+ []Tuple{
+ {rawFalse, &Raw{Value: decimal.NewFromFloat(1)}},
+ {rawTrue, &Raw{Value: decimal.NewFromFloat(2)}},
+ {rawFalse, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("c")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
+ {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
+ {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
+ {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(3)}, rawTrue},
+ {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
+ {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(2)}, rawTrue},
+ {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(1)}, rawFalse},
+ {&Raw{Bytes: []byte("c")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
+ },
+ ),
+ nil,
+ },
+ {
+ "Multi-column sorting - 2",
+ Instruction{
+ Op: SORT,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("c")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
+ {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(2)}, rawTrue},
+ {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(3)}, rawTrue},
+ {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(1)}, rawFalse},
+ {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
+ {&Raw{Bytes: []byte("c")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
+ {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
+ {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
+ },
+ []Tuple{
+ {rawTrue, &Raw{Value: decimal.NewFromFloat(0)}},
+ {rawTrue, &Raw{Value: decimal.NewFromFloat(1)}},
+ {rawFalse, &Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(1)}, rawFalse},
+ {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(3)}, rawTrue},
+ {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
+ {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(2)}, rawTrue},
+ {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
+ {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
+ {&Raw{Bytes: []byte("c")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
+ {&Raw{Bytes: []byte("c")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
+ },
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpSort() {
- testcases := []opTestcase{
- {
- "Multi-column sorting",
- Instruction{
- Op: SORT,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("c")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
- {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(2)}, rawTrue},
- {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(3)}, rawTrue},
- {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(1)}, rawFalse},
- {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
- {&Raw{Bytes: []byte("c")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
- {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
- {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
- },
- []Tuple{
- {rawFalse, &Raw{Value: decimal.NewFromFloat(1)}},
- {rawTrue, &Raw{Value: decimal.NewFromFloat(2)}},
- {rawFalse, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("c")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
- {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
- {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
- {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(3)}, rawTrue},
- {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
- {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(2)}, rawTrue},
- {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(1)}, rawFalse},
- {&Raw{Bytes: []byte("c")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
- },
- ),
- nil,
- },
- {
- "Multi-column sorting - 2",
- Instruction{
- Op: SORT,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("c")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
- {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(2)}, rawTrue},
- {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(3)}, rawTrue},
- {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(1)}, rawFalse},
- {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
- {&Raw{Bytes: []byte("c")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
- {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
- {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorBool, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 1),
- },
- []Tuple{
- {rawTrue, &Raw{Value: decimal.NewFromFloat(0)}},
- {rawTrue, &Raw{Value: decimal.NewFromFloat(1)}},
- {rawFalse, &Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorBool, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(1)}, rawFalse},
- {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(3)}, rawTrue},
- {&Raw{Bytes: []byte("a")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
- {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(2)}, rawTrue},
- {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(2)}, rawFalse},
- {&Raw{Bytes: []byte("b")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
- {&Raw{Bytes: []byte("c")}, &Raw{Value: decimal.NewFromFloat(1)}, rawTrue},
- {&Raw{Bytes: []byte("c")}, &Raw{Value: decimal.NewFromFloat(3)}, rawFalse},
- },
- ),
- nil,
- },
- }
-
- s.run(testcases, opSort)
+ s.run(testcasesOpSort, opSort)
+}
+
+func BenchmarkOpSort(b *testing.B) {
+ runBench(b, testcasesOpSort, opSort)
+}
+
+var testcasesOpRange = []opTestcase{
+ {
+ "Range test limit 2 offset 1",
+ Instruction{
+ Op: RANGE,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ {&Raw{Value: decimal.NewFromFloat(3)}},
+ {&Raw{Value: decimal.NewFromFloat(4)}},
+ {&Raw{Value: decimal.NewFromFloat(5)}},
+ {&Raw{Value: decimal.NewFromFloat(6)}},
+ {&Raw{Value: decimal.NewFromFloat(7)}},
+ {&Raw{Value: decimal.NewFromFloat(8)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 7), ast.ComposeDataType(ast.DataTypeMajorUint, 7),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ {&Raw{Value: decimal.NewFromFloat(3)}},
+ },
+ ),
+ nil,
+ },
+ {
+ "Range test limit 0 offset 1",
+ Instruction{
+ Op: RANGE,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 7), ast.ComposeDataType(ast.DataTypeMajorUint, 7),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{},
+ ),
+ nil,
+ },
+ {
+ "Range test offset 20",
+ Instruction{
+ Op: RANGE,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 7),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(20)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{},
+ ),
+ nil,
+ },
+ {
+ "Range test limit 10 offset 20",
+ Instruction{
+ Op: RANGE,
+ Input: []*Operand{
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}},
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 7), ast.ComposeDataType(ast.DataTypeMajorUint, 7),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(20)}, &Raw{Value: decimal.NewFromFloat(10)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorInt, 0),
+ },
+ []Tuple{},
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpRange() {
- testcases := []opTestcase{
- {
- "Range test limit 2 offset 1",
- Instruction{
- Op: RANGE,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(2)}},
- {&Raw{Value: decimal.NewFromFloat(3)}},
- {&Raw{Value: decimal.NewFromFloat(4)}},
- {&Raw{Value: decimal.NewFromFloat(5)}},
- {&Raw{Value: decimal.NewFromFloat(6)}},
- {&Raw{Value: decimal.NewFromFloat(7)}},
- {&Raw{Value: decimal.NewFromFloat(8)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 7), ast.ComposeDataType(ast.DataTypeMajorUint, 7),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(2)}},
- {&Raw{Value: decimal.NewFromFloat(3)}},
- },
- ),
- nil,
- },
- {
- "Range test limit 0 offset 1",
- Instruction{
- Op: RANGE,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 7), ast.ComposeDataType(ast.DataTypeMajorUint, 7),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(0)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{},
- ),
- nil,
- },
- {
- "Range test offset 20",
- Instruction{
- Op: RANGE,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 7),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(20)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{},
- ),
- nil,
- },
- {
- "Range test limit 10 offset 20",
- Instruction{
- Op: RANGE,
- Input: []*Operand{
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}},
- {&Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 7), ast.ComposeDataType(ast.DataTypeMajorUint, 7),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(20)}, &Raw{Value: decimal.NewFromFloat(10)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorInt, 0),
- },
- []Tuple{},
- ),
- nil,
- },
- }
-
- s.run(testcases, opRange)
+ s.run(testcasesOpRange, opRange)
+}
+
+func BenchmarkOpRange(b *testing.B) {
+ runBench(b, testcasesOpRange, opRange)
+}
+
+var testcasesOpFuncBitAnd = []opTestcase{
+ {
+ "Func BitAnd",
+ Instruction{
+ Op: FUNC,
+ Input: []*Operand{
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(10)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-128)}, &Raw{Bytes: []byte{0x12, 0x34}}, &Raw{Bytes: []byte{0x56, 0x78}}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(6)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Bytes: []byte{0xff, 0xff}}, &Raw{Bytes: []byte{0x00, 0x00}}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-128)}, &Raw{Bytes: []byte{0x12, 0x34}}, &Raw{Bytes: []byte{0x00, 0x00}}},
+ },
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpFuncBitAnd() {
- testcases := []opTestcase{
- {
- "Func BitAnd",
- Instruction{
- Op: FUNC,
- Input: []*Operand{
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(10)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-128)}, &Raw{Bytes: []byte{0x12, 0x34}}, &Raw{Bytes: []byte{0x56, 0x78}}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(6)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Bytes: []byte{0xff, 0xff}}, &Raw{Bytes: []byte{0x00, 0x00}}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-128)}, &Raw{Bytes: []byte{0x12, 0x34}}, &Raw{Bytes: []byte{0x00, 0x00}}},
- },
- ),
- nil,
- },
- }
-
- s.run(testcases, opFunc)
+ s.run(testcasesOpFuncBitAnd, opFunc)
+}
+
+func BenchmarkOpFuncBitAnd(b *testing.B) {
+ runBench(b, testcasesOpFuncBitAnd, opFunc)
+}
+
+var testcasesOpFuncBitOr = []opTestcase{
+ {
+ "Func BitOr",
+ Instruction{
+ Op: FUNC,
+ Input: []*Operand{
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(11)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-128)}, &Raw{Bytes: []byte{0x12, 0x34}}, &Raw{Bytes: []byte{0x56, 0x78}}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(6)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Bytes: []byte{0xff, 0xff}}, &Raw{Bytes: []byte{0x00, 0x00}}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(6)}, &Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Bytes: []byte{0xff, 0xff}}, &Raw{Bytes: []byte{0x56, 0x78}}},
+ },
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpFuncBitOr() {
- testcases := []opTestcase{
- {
- "Func BitOr",
- Instruction{
- Op: FUNC,
- Input: []*Operand{
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(11)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-128)}, &Raw{Bytes: []byte{0x12, 0x34}}, &Raw{Bytes: []byte{0x56, 0x78}}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(6)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Bytes: []byte{0xff, 0xff}}, &Raw{Bytes: []byte{0x00, 0x00}}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(6)}, &Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Bytes: []byte{0xff, 0xff}}, &Raw{Bytes: []byte{0x56, 0x78}}},
- },
- ),
- nil,
- },
- }
-
- s.run(testcases, opFunc)
+ s.run(testcasesOpFuncBitOr, opFunc)
+}
+
+func BenchmarkOpFuncBitOr(b *testing.B) {
+ runBench(b, testcasesOpFuncBitOr, opFunc)
+}
+
+var testcasesOpFuncBitXor = []opTestcase{
+ {
+ "Func BitXor",
+ Instruction{
+ Op: FUNC,
+ Input: []*Operand{
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(12)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-128)}, &Raw{Bytes: []byte{0x12, 0x34}}, &Raw{Bytes: []byte{0x56, 0x78}}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(6)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Bytes: []byte{0xff, 0xff}}, &Raw{Bytes: []byte{0x00, 0x00}}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(4)}, &Raw{Value: decimal.NewFromFloat(4)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(126)}, &Raw{Bytes: []byte{0xed, 0xcb}}, &Raw{Bytes: []byte{0x56, 0x78}}},
+ },
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpFuncBitXor() {
- testcases := []opTestcase{
- {
- "Func BitXor",
- Instruction{
- Op: FUNC,
- Input: []*Operand{
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(12)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-128)}, &Raw{Bytes: []byte{0x12, 0x34}}, &Raw{Bytes: []byte{0x56, 0x78}}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(5)}, &Raw{Value: decimal.NewFromFloat(6)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Value: decimal.NewFromFloat(-2)}, &Raw{Bytes: []byte{0xff, 0xff}}, &Raw{Bytes: []byte{0x00, 0x00}}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(4)}, &Raw{Value: decimal.NewFromFloat(4)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(126)}, &Raw{Bytes: []byte{0xed, 0xcb}}, &Raw{Bytes: []byte{0x56, 0x78}}},
- },
- ),
- nil,
- },
- }
-
- s.run(testcases, opFunc)
+ s.run(testcasesOpFuncBitXor, opFunc)
+}
+
+func BenchmarkOpFuncBitXor(b *testing.B) {
+ runBench(b, testcasesOpFuncBitXor, opFunc)
+}
+
+var testcasesOpFuncBitNot = []opTestcase{
+ {
+ "Func BitNot",
+ Instruction{
+ Op: FUNC,
+ Input: []*Operand{
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(13)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(128)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-128)}, &Raw{Bytes: []byte{0x12, 0x34}}, &Raw{Bytes: []byte{0xff, 0x00}}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(127)}, &Raw{Value: decimal.NewFromFloat(255)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(127)}, &Raw{Bytes: []byte{0xed, 0xcb}}, &Raw{Bytes: []byte{0x00, 0xff}}},
+ },
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpFuncBitNot() {
- testcases := []opTestcase{
- {
- "Func BitNot",
- Instruction{
- Op: FUNC,
- Input: []*Operand{
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(13)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(128)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(-1)}, &Raw{Value: decimal.NewFromFloat(-128)}, &Raw{Bytes: []byte{0x12, 0x34}}, &Raw{Bytes: []byte{0xff, 0x00}}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorUint, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorInt, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0), ast.ComposeDataType(ast.DataTypeMajorFixedBytes, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(127)}, &Raw{Value: decimal.NewFromFloat(255)}, &Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(127)}, &Raw{Bytes: []byte{0xed, 0xcb}}, &Raw{Bytes: []byte{0x00, 0xff}}},
- },
- ),
- nil,
- },
- }
-
- s.run(testcases, opFunc)
+ s.run(testcasesOpFuncBitNot, opFunc)
+}
+
+func BenchmarkOpFuncBitNot(b *testing.B) {
+ runBench(b, testcasesOpFuncBitNot, opFunc)
+}
+
+var testcasesOpFuncOctetLength = []opTestcase{
+ {
+ "Func octet length",
+ Instruction{
+ Op: FUNC,
+ Input: []*Operand{
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(14)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte{}}, &Raw{Bytes: []byte{1}}, &Raw{Bytes: []byte{1, 2}}, &Raw{Bytes: []byte{1, 2, 3}}, &Raw{Bytes: []byte{1, 2, 3, 4}}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 32), ast.ComposeDataType(ast.DataTypeMajorUint, 32), ast.ComposeDataType(ast.DataTypeMajorUint, 32), ast.ComposeDataType(ast.DataTypeMajorUint, 32), ast.ComposeDataType(ast.DataTypeMajorUint, 32),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(3)}, &Raw{Value: decimal.NewFromFloat(4)}},
+ },
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpFuncOctetLength() {
- testcases := []opTestcase{
- {
- "Func octet length",
- Instruction{
- Op: FUNC,
- Input: []*Operand{
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(14)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0), ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte{}}, &Raw{Bytes: []byte{1}}, &Raw{Bytes: []byte{1, 2}}, &Raw{Bytes: []byte{1, 2, 3}}, &Raw{Bytes: []byte{1, 2, 3, 4}}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 32), ast.ComposeDataType(ast.DataTypeMajorUint, 32), ast.ComposeDataType(ast.DataTypeMajorUint, 32), ast.ComposeDataType(ast.DataTypeMajorUint, 32), ast.ComposeDataType(ast.DataTypeMajorUint, 32),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(0)}, &Raw{Value: decimal.NewFromFloat(1)}, &Raw{Value: decimal.NewFromFloat(2)}, &Raw{Value: decimal.NewFromFloat(3)}, &Raw{Value: decimal.NewFromFloat(4)}},
- },
- ),
- nil,
- },
- }
-
- s.run(testcases, opFunc)
+ s.run(testcasesOpFuncOctetLength, opFunc)
+}
+
+func BenchmarkOpFuncOctetLength(b *testing.B) {
+ runBench(b, testcasesOpFuncOctetLength, opFunc)
+}
+
+var testcasesOpFuncSubString = []opTestcase{
+ {
+ "Func sub string",
+ Instruction{
+ Op: FUNC,
+ Input: []*Operand{
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 0),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 1),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(15)}},
+ },
+ ),
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9}}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 7),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(2)}},
+ },
+ ),
+ makeOperand(
+ true,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorUint, 7),
+ },
+ []Tuple{
+ {&Raw{Value: decimal.NewFromFloat(5)}},
+ },
+ ),
+ },
+ Output: 0,
+ },
+ makeOperand(
+ false,
+ []ast.DataType{
+ ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
+ },
+ []Tuple{
+ {&Raw{Bytes: []byte{3, 4, 5, 6, 7}}},
+ },
+ ),
+ nil,
+ },
}
func (s *instructionSuite) TestOpFuncSubString() {
- testcases := []opTestcase{
- {
- "Func sub string",
- Instruction{
- Op: FUNC,
- Input: []*Operand{
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 0),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 1),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(15)}},
- },
- ),
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9}}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 7),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(2)}},
- },
- ),
- makeOperand(
- true,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorUint, 7),
- },
- []Tuple{
- {&Raw{Value: decimal.NewFromFloat(5)}},
- },
- ),
- },
- Output: 0,
- },
- makeOperand(
- false,
- []ast.DataType{
- ast.ComposeDataType(ast.DataTypeMajorDynamicBytes, 0),
- },
- []Tuple{
- {&Raw{Bytes: []byte{3, 4, 5, 6, 7}}},
- },
- ),
- nil,
- },
- }
-
- s.run(testcases, opFunc)
+ s.run(testcasesOpFuncSubString, opFunc)
+}
+
+func BenchmarkOpFuncSubString(b *testing.B) {
+ runBench(b, testcasesOpFuncSubString, opFunc)
}
diff --git a/core/vm/sqlvm/runtime/instructions_test.go b/core/vm/sqlvm/runtime/instructions_test.go
index a00ac12dd..2cc162b73 100644
--- a/core/vm/sqlvm/runtime/instructions_test.go
+++ b/core/vm/sqlvm/runtime/instructions_test.go
@@ -500,6 +500,15 @@ func loadRegister(input, registers []*Operand) {
}
}
+func setRegister(input, registers []*Operand) {
+ for i, j := 0, 0; i < len(input); i++ {
+ if !input[i].IsImmediate {
+ registers[j] = input[i]
+ j++
+ }
+ }
+}
+
type opTestcase struct {
Name string
In Instruction
@@ -515,12 +524,8 @@ func (s *instructionSuite) run(testcases []opTestcase, opfunc OpFunction) {
for idx, c := range testcases {
registers := make([]*Operand, len(c.In.Input))
- for i, j := 0, 0; i < len(c.In.Input); i++ {
- if !c.In.Input[i].IsImmediate {
- registers[j] = c.In.Input[i]
- j++
- }
- }
+ setRegister(c.In.Input, registers)
+
err := opfunc(
&common.Context{Opt: common.Option{SafeMath: true}},
c.In.Input, registers, c.In.Output)
@@ -541,3 +546,25 @@ func (s *instructionSuite) run(testcases []opTestcase, opfunc OpFunction) {
)
}
}
+
+func runBench(b *testing.B, testcases []opTestcase, opfunc OpFunction) {
+ for _, c := range testcases {
+ if c.Err != nil {
+ // skip error case
+ continue
+ }
+
+ b.Run(c.Name, func(b *testing.B) {
+ registers := make([]*Operand, len(c.In.Input))
+ for i := 0; i < b.N; i++ {
+ b.StopTimer()
+ setRegister(c.In.Input, registers)
+ b.StartTimer()
+ opfunc(
+ &common.Context{Opt: common.Option{SafeMath: true}},
+ c.In.Input, registers, c.In.Output)
+ }
+ b.ReportAllocs()
+ })
+ }
+}
diff --git a/core/vm/sqlvm/runtime/instructions_tmpl.go b/core/vm/sqlvm/runtime/instructions_tmpl.go
index 7c9df3d80..dfab9aaa1 100644
--- a/core/vm/sqlvm/runtime/instructions_tmpl.go
+++ b/core/vm/sqlvm/runtime/instructions_tmpl.go
@@ -243,6 +243,8 @@ const binOpTmplStr = `
package runtime
import (
+ "testing"
+
"github.com/dexon-foundation/decimal"
"github.com/dexon-foundation/dexon/core/vm/sqlvm/ast"
@@ -250,8 +252,7 @@ import (
)
{{range .BinOpCollections}}
-func (s *instructionSuite) Test{{.TestName}}() {
- testcases := []opTestcase{ {{range .Cases}}
+var testcases{{.TestName}} = []opTestcase{ {{range .Cases}}
{
"{{.Name}}",
Instruction{
@@ -282,7 +283,12 @@ func (s *instructionSuite) Test{{.TestName}}() {
},{{end}}
}
- s.run(testcases, {{.OpFunc}})
+func (s *instructionSuite) Test{{.TestName}}() {
+ s.run(testcases{{.TestName}}, {{.OpFunc}})
+}
+
+func Benchmark{{.TestName}}(b *testing.B) {
+ runBench(b, testcases{{.TestName}}, {{.OpFunc}})
}
{{end}}
`
diff --git a/core/vm/sqlvm/runtime/opbench.txt b/core/vm/sqlvm/runtime/opbench.txt
new file mode 100644
index 000000000..d4921c312
--- /dev/null
+++ b/core/vm/sqlvm/runtime/opbench.txt
@@ -0,0 +1,76 @@
+goos: darwin
+goarch: amd64
+pkg: github.com/dexon-foundation/dexon/core/vm/sqlvm/runtime
+BenchmarkOpAdd/None_Immediate-4 100000 17468 ns/op 4496 B/op 107 allocs/op
+BenchmarkOpAdd/Immediate-4 100000 18143 ns/op 4688 B/op 110 allocs/op
+BenchmarkOpAdd/Immediate_2-4 100000 18329 ns/op 4688 B/op 110 allocs/op
+BenchmarkOpSub/None_Immediate-4 100000 17939 ns/op 4496 B/op 107 allocs/op
+BenchmarkOpSub/Immediate-4 100000 18385 ns/op 4688 B/op 110 allocs/op
+BenchmarkOpSub/Immediate_2-4 100000 19257 ns/op 4688 B/op 110 allocs/op
+BenchmarkOpMul/None_Immediate-4 100000 14991 ns/op 3424 B/op 79 allocs/op
+BenchmarkOpMul/Immediate-4 100000 16816 ns/op 4320 B/op 102 allocs/op
+BenchmarkOpMul/Immediate_-_2-4 100000 16073 ns/op 4320 B/op 102 allocs/op
+BenchmarkOpDiv/None_Immediate-4 100000 11825 ns/op 2048 B/op 47 allocs/op
+BenchmarkOpDiv/Immediate-4 100000 14047 ns/op 2848 B/op 65 allocs/op
+BenchmarkOpDiv/Immediate_2-4 100000 12647 ns/op 2480 B/op 56 allocs/op
+BenchmarkOpMod/None_Immediate-4 200000 10560 ns/op 2000 B/op 46 allocs/op
+BenchmarkOpMod/Immediate-4 100000 12612 ns/op 3040 B/op 69 allocs/op
+BenchmarkOpMod/Immediate_-_2-4 200000 11857 ns/op 2672 B/op 60 allocs/op
+BenchmarkOpConcat/Concat_bytes-4 300000 4710 ns/op 592 B/op 14 allocs/op
+BenchmarkOpNeg/Neg_unary-4 200000 5778 ns/op 672 B/op 13 allocs/op
+BenchmarkOpLt/None_Immediate-4 300000 4728 ns/op 448 B/op 7 allocs/op
+BenchmarkOpLt/Immediate-4 300000 3730 ns/op 336 B/op 5 allocs/op
+BenchmarkOpLt/Immediate_-_2-4 500000 3708 ns/op 336 B/op 5 allocs/op
+BenchmarkOpGt/None_Immediate-4 300000 4648 ns/op 448 B/op 7 allocs/op
+BenchmarkOpGt/Immediate-4 500000 3638 ns/op 336 B/op 5 allocs/op
+BenchmarkOpGt/Immediate_-_2-4 500000 3602 ns/op 336 B/op 5 allocs/op
+BenchmarkOpEq/None_Immediate-4 500000 4391 ns/op 384 B/op 6 allocs/op
+BenchmarkOpEq/Immediate-4 300000 5883 ns/op 384 B/op 6 allocs/op
+BenchmarkOpAnd/None_Immediate-4 300000 4489 ns/op 352 B/op 6 allocs/op
+BenchmarkOpAnd/Immediate-4 300000 4590 ns/op 352 B/op 6 allocs/op
+BenchmarkOpAnd/Immediate_-_2-4 300000 4507 ns/op 352 B/op 6 allocs/op
+BenchmarkOpOr/None_Immediate-4 300000 4455 ns/op 352 B/op 6 allocs/op
+BenchmarkOpOr/Immediate-4 300000 4709 ns/op 352 B/op 6 allocs/op
+BenchmarkOpOr/Immediate_-_2-4 300000 4114 ns/op 352 B/op 6 allocs/op
+BenchmarkOpNot/None_Immediate-4 500000 4011 ns/op 352 B/op 6 allocs/op
+BenchmarkOpUnion/None_Immediate-4 100000 23658 ns/op 2336 B/op 73 allocs/op
+BenchmarkOpIntxn/None_Immediate-4 50000 28130 ns/op 3088 B/op 101 allocs/op
+BenchmarkOpLike/Like_%\%b%_escape_\-4 50000 27794 ns/op 39952 B/op 38 allocs/op
+BenchmarkOpLike/Like_t1_escape_t2-4 30000 45375 ns/op 80112 B/op 73 allocs/op
+BenchmarkOpLike/Like_with_valid_and_invalid_UTF8-4 50000 29623 ns/op 40672 B/op 40 allocs/op
+BenchmarkOpZip/Zip_two_array-4 300000 4844 ns/op 416 B/op 8 allocs/op
+BenchmarkOpZip/Zip_immediate-4 300000 4773 ns/op 416 B/op 8 allocs/op
+BenchmarkOpField/Retrieve_2nd,3rd_column-4 300000 4968 ns/op 512 B/op 11 allocs/op
+BenchmarkOpPrune/Prune_2nd,4th,5th_column-4 500000 3570 ns/op 384 B/op 6 allocs/op
+BenchmarkOpCut/Cut_2nd_to_4th_columns-4 500000 3420 ns/op 352 B/op 5 allocs/op
+BenchmarkOpCut/Cut_1st_column-4 1000000 2666 ns/op 256 B/op 3 allocs/op
+BenchmarkOpCut/Cut_since_2nd_column-4 500000 3111 ns/op 272 B/op 3 allocs/op
+BenchmarkOpCut/Cut_all_columns-4 500000 2582 ns/op 224 B/op 2 allocs/op
+BenchmarkOpFilter/Filter_first_2_rows-4 300000 4727 ns/op 384 B/op 7 allocs/op
+BenchmarkOpCast/None_Immediate_-_int-4 200000 10657 ns/op 1760 B/op 50 allocs/op
+BenchmarkOpCast/None_Immediate_-_int2-4 200000 8089 ns/op 1008 B/op 25 allocs/op
+BenchmarkOpCast/None_Immediate_-_int3-4 300000 4377 ns/op 544 B/op 10 allocs/op
+BenchmarkOpCast/None_Immediate_-_int4-4 200000 7047 ns/op 784 B/op 19 allocs/op
+BenchmarkOpCast/None_Immediate_-_uint-4 200000 7756 ns/op 1024 B/op 26 allocs/op
+BenchmarkOpCast/None_Immediate_-_uint2-4 200000 6788 ns/op 880 B/op 22 allocs/op
+BenchmarkOpCast/None_Immediate_-_uint3-4 500000 4622 ns/op 416 B/op 7 allocs/op
+BenchmarkOpCast/None_Immediate_-_uint4-4 300000 6274 ns/op 592 B/op 14 allocs/op
+BenchmarkOpCast/None_Immediate_-_uint5-4 200000 6113 ns/op 552 B/op 12 allocs/op
+BenchmarkOpCast/None_Immediate_-_bytes-4 300000 4651 ns/op 416 B/op 10 allocs/op
+BenchmarkOpCast/None_Immediate_-_bytes2-4 300000 6056 ns/op 672 B/op 15 allocs/op
+BenchmarkOpCast/None_Immediate_-_bytes3-4 500000 4081 ns/op 360 B/op 7 allocs/op
+BenchmarkOpCast/Same_type-4 500000 3695 ns/op 360 B/op 6 allocs/op
+BenchmarkOpSort/Multi-column_sorting-4 200000 6386 ns/op 544 B/op 10 allocs/op
+BenchmarkOpSort/Multi-column_sorting_-_2-4 300000 5890 ns/op 544 B/op 10 allocs/op
+BenchmarkOpRange/Range_test_limit_2_offset_1-4 500000 3270 ns/op 352 B/op 5 allocs/op
+BenchmarkOpRange/Range_test_limit_0_offset_1-4 500000 3118 ns/op 352 B/op 5 allocs/op
+BenchmarkOpRange/Range_test_offset_20-4 300000 4096 ns/op 480 B/op 8 allocs/op
+BenchmarkOpRange/Range_test_limit_10_offset_20-4 300000 4020 ns/op 480 B/op 8 allocs/op
+BenchmarkOpFuncBitAnd/Func_BitAnd-4 100000 13608 ns/op 2992 B/op 89 allocs/op
+BenchmarkOpFuncBitOr/Func_BitOr-4 100000 12854 ns/op 2864 B/op 86 allocs/op
+BenchmarkOpFuncBitXor/Func_BitXor-4 100000 12634 ns/op 2864 B/op 84 allocs/op
+BenchmarkOpFuncBitNot/Func_BitNot-4 200000 10303 ns/op 1936 B/op 54 allocs/op
+BenchmarkOpFuncOctetLength/Func_octet_length-4 200000 6893 ns/op 1264 B/op 27 allocs/op
+BenchmarkOpFuncSubString/Func_sub_string-4 200000 6401 ns/op 1000 B/op 22 allocs/op
+PASS
+ok github.com/dexon-foundation/dexon/core/vm/sqlvm/runtime 1149.744s
generated by cgit v1.2.3 (git 2.25.1) at 2025-03-28 18:17:07 +0800