TrueCloudLab/neo-go
8
0
Fork 0
mirror of https://github.com/nspcc-dev/neo-go.git synced 2025-01-11 01:20:37 +00:00
Code Issues Projects Releases Packages Wiki Activity

vm: make NewBigInteger accept *big.Int

Browse source 
It creates big.Int internally anyway, so this is the most flexible way.
This commit is contained in:
Evgenii Stratonikov 2020-04-16 15:28:34 +03:00
parent 9586af32f2
commit 3831aec53f
7 changed files with 45 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
pkg/compiler/for_test.go
View file

@ -34,7 +34,7 @@ func TestEntryPointWithArgs(t *testing.T) {
return 2 + args[1].(int) return 2 + args[1].(int)
} }
` `
args := []vm.StackItem{vm.NewBigIntegerItem(0), vm.NewBigIntegerItem(1)} args := []vm.StackItem{vm.NewBigIntegerItem(big.NewInt(0)), vm.NewBigIntegerItem(big.NewInt(1))}
evalWithArgs(t, src, nil, args, big.NewInt(3)) evalWithArgs(t, src, nil, args, big.NewInt(3))
} }
@ -49,7 +49,7 @@ func TestEntryPointWithMethodAndArgs(t *testing.T) {
return 0 return 0
} }
` `
args := []vm.StackItem{vm.NewBigIntegerItem(0), vm.NewBigIntegerItem(1)} args := []vm.StackItem{vm.NewBigIntegerItem(big.NewInt(0)), vm.NewBigIntegerItem(big.NewInt(1))}
evalWithArgs(t, src, []byte("foobar"), args, big.NewInt(3)) evalWithArgs(t, src, []byte("foobar"), args, big.NewInt(3))
} }
@ -154,9 +154,9 @@ func TestIntArray(t *testing.T) {
} }
` `
eval(t, src, []vm.StackItem{ eval(t, src, []vm.StackItem{
vm.NewBigIntegerItem(1), vm.NewBigIntegerItem(big.NewInt(1)),
vm.NewBigIntegerItem(2), vm.NewBigIntegerItem(big.NewInt(2)),
vm.NewBigIntegerItem(3), vm.NewBigIntegerItem(big.NewInt(3)),
}) })
} }

4
pkg/compiler/struct_test.go
View file

@ -271,8 +271,8 @@ var structTestCases = []testCase{
} }
`, `,
[]vm.StackItem{ []vm.StackItem{
vm.NewBigIntegerItem(1), vm.NewBigIntegerItem(big.NewInt(1)),
vm.NewBigIntegerItem(2), vm.NewBigIntegerItem(big.NewInt(2)),
vm.NewByteArrayItem([]byte("hello")), vm.NewByteArrayItem([]byte("hello")),
vm.NewByteArrayItem([]byte{}), vm.NewByteArrayItem([]byte{}),
}, },

3
pkg/compiler/syscall_test.go
View file

@ -1,6 +1,7 @@
package compiler_test package compiler_test
import ( import (
"math/big"
"testing" "testing"
"github.com/nspcc-dev/neo-go/pkg/vm" "github.com/nspcc-dev/neo-go/pkg/vm"
@ -40,7 +41,7 @@ func TestNotify(t *testing.T) {
require.NoError(t, v.Run()) require.NoError(t, v.Run())
require.Equal(t, 3, len(s.events)) require.Equal(t, 3, len(s.events))
exp0 := []vm.StackItem{vm.NewBigIntegerItem(11), vm.NewByteArrayItem([]byte("sum")), vm.NewBigIntegerItem(12)} exp0 := []vm.StackItem{vm.NewBigIntegerItem(big.NewInt(11)), vm.NewByteArrayItem([]byte("sum")), vm.NewBigIntegerItem(big.NewInt(12))}
assert.Equal(t, exp0, s.events[0].Value()) assert.Equal(t, exp0, s.events[0].Value())
assert.Equal(t, []vm.StackItem{}, s.events[1].Value()) assert.Equal(t, []vm.StackItem{}, s.events[1].Value())
assert.Equal(t, []vm.StackItem{vm.NewByteArrayItem([]byte("single"))}, s.events[2].Value()) assert.Equal(t, []vm.StackItem{vm.NewByteArrayItem([]byte("single"))}, s.events[2].Value())

3
pkg/vm/cli/cli.go
View file

@ -6,6 +6,7 @@ import (
"errors" "errors"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"math/big"
"os" "os"
"strconv" "strconv"
"strings" "strings"
@ -438,7 +439,7 @@ func parseArgs(args []string) ([]vm.StackItem, error) {
if err != nil { if err != nil {
return nil, err return nil, err
} }
items[i] = vm.NewBigIntegerItem(val) items[i] = vm.NewBigIntegerItem(big.NewInt(val))
case stringType: case stringType:
items[i] = vm.NewByteArrayItem([]byte(value)) items[i] = vm.NewByteArrayItem([]byte(value))
} }

4
pkg/vm/stack_item.go
View file

@ -241,9 +241,9 @@ type BigIntegerItem struct {
} }
// NewBigIntegerItem returns an new BigIntegerItem object. // NewBigIntegerItem returns an new BigIntegerItem object.
func NewBigIntegerItem(value int64) *BigIntegerItem { func NewBigIntegerItem(value *big.Int) *BigIntegerItem {
return &BigIntegerItem{ return &BigIntegerItem{
value: big.NewInt(value), value: value,
} }
} }

50
pkg/vm/stack_item_test.go
View file

@ -104,7 +104,7 @@ var stringerTestCases = []struct {
result: "Struct", result: "Struct",
}, },
{ {
input: NewBigIntegerItem(3), input: NewBigIntegerItem(big.NewInt(3)),
result: "BigInteger", result: "BigInteger",
}, },
{ {
@ -148,48 +148,48 @@ var equalsTestCases = map[string][]struct {
}, },
{ {
item1: NewStructItem(nil), item1: NewStructItem(nil),
item2: NewBigIntegerItem(1), item2: NewBigIntegerItem(big.NewInt(1)),
result: false, result: false,
}, },
{ {
item1: NewStructItem(nil), item1: NewStructItem(nil),
item2: NewStructItem([]StackItem{NewBigIntegerItem(1)}), item2: NewStructItem([]StackItem{NewBigIntegerItem(big.NewInt(1))}),
result: false, result: false,
}, },
{ {
item1: NewStructItem([]StackItem{NewBigIntegerItem(1)}), item1: NewStructItem([]StackItem{NewBigIntegerItem(big.NewInt(1))}),
item2: NewStructItem([]StackItem{NewBigIntegerItem(2)}), item2: NewStructItem([]StackItem{NewBigIntegerItem(big.NewInt(2))}),
result: false, result: false,
}, },
{ {
item1: NewStructItem([]StackItem{NewBigIntegerItem(1)}), item1: NewStructItem([]StackItem{NewBigIntegerItem(big.NewInt(1))}),
item2: NewStructItem([]StackItem{NewBigIntegerItem(1)}), item2: NewStructItem([]StackItem{NewBigIntegerItem(big.NewInt(1))}),
result: true, result: true,
}, },
}, },
"bigint": { "bigint": {
{ {
item1: NewBigIntegerItem(2), item1: NewBigIntegerItem(big.NewInt(2)),
item2: nil, item2: nil,
result: false, result: false,
}, },
{ {
item1: NewBigIntegerItem(2), item1: NewBigIntegerItem(big.NewInt(2)),
item2: NewBigIntegerItem(2), item2: NewBigIntegerItem(big.NewInt(2)),
result: true, result: true,
}, },
{ {
item1: NewBigIntegerItem(2), item1: NewBigIntegerItem(big.NewInt(2)),
item2: NewBoolItem(false), item2: NewBoolItem(false),
result: false, result: false,
}, },
{ {
item1: NewBigIntegerItem(0), item1: NewBigIntegerItem(big.NewInt(0)),
item2: NewBoolItem(false), item2: NewBoolItem(false),
result: false, result: false,
}, },
{ {
item1: NewBigIntegerItem(2), item1: NewBigIntegerItem(big.NewInt(2)),
item2: makeStackItem(int32(2)), item2: makeStackItem(int32(2)),
result: true, result: true,
}, },
@ -207,7 +207,7 @@ var equalsTestCases = map[string][]struct {
}, },
{ {
item1: NewBoolItem(true), item1: NewBoolItem(true),
item2: NewBigIntegerItem(1), item2: NewBigIntegerItem(big.NewInt(1)),
result: true, result: true,
}, },
{ {
@ -234,7 +234,7 @@ var equalsTestCases = map[string][]struct {
}, },
{ {
item1: NewByteArrayItem([]byte{1}), item1: NewByteArrayItem([]byte{1}),
item2: NewBigIntegerItem(1), item2: NewBigIntegerItem(big.NewInt(1)),
result: true, result: true,
}, },
{ {
@ -261,7 +261,7 @@ var equalsTestCases = map[string][]struct {
}, },
{ {
item1: NewArrayItem([]StackItem{&BigIntegerItem{big.NewInt(1)}}), item1: NewArrayItem([]StackItem{&BigIntegerItem{big.NewInt(1)}}),
item2: NewBigIntegerItem(1), item2: NewBigIntegerItem(big.NewInt(1)),
result: false, result: false,
}, },
{ {
@ -282,13 +282,13 @@ var equalsTestCases = map[string][]struct {
result: false, result: false,
}, },
{ {
item1: &MapItem{value: []MapElement{{NewByteArrayItem([]byte("first")), NewBigIntegerItem(1)}, {NewBoolItem(true), NewByteArrayItem([]byte{2})}}}, item1: &MapItem{value: []MapElement{{NewByteArrayItem([]byte("first")), NewBigIntegerItem(big.NewInt(1))}, {NewBoolItem(true), NewByteArrayItem([]byte{2})}}},
item2: &MapItem{value: []MapElement{{NewByteArrayItem([]byte("first")), NewBigIntegerItem(1)}, {NewBoolItem(true), NewByteArrayItem([]byte{2})}}}, item2: &MapItem{value: []MapElement{{NewByteArrayItem([]byte("first")), NewBigIntegerItem(big.NewInt(1))}, {NewBoolItem(true), NewByteArrayItem([]byte{2})}}},
result: false, result: false,
}, },
{ {
item1: &MapItem{value: []MapElement{{NewByteArrayItem([]byte("first")), NewBigIntegerItem(1)}, {NewBoolItem(true), NewByteArrayItem([]byte{2})}}}, item1: &MapItem{value: []MapElement{{NewByteArrayItem([]byte("first")), NewBigIntegerItem(big.NewInt(1))}, {NewBoolItem(true), NewByteArrayItem([]byte{2})}}},
item2: &MapItem{value: []MapElement{{NewByteArrayItem([]byte("first")), NewBigIntegerItem(1)}, {NewBoolItem(true), NewByteArrayItem([]byte{3})}}}, item2: &MapItem{value: []MapElement{{NewByteArrayItem([]byte("first")), NewBigIntegerItem(big.NewInt(1))}, {NewBoolItem(true), NewByteArrayItem([]byte{3})}}},
result: false, result: false,
}, },
}, },
@ -333,7 +333,7 @@ var marshalJSONTestCases = []struct {
result []byte result []byte
}{ }{
{ {
input: NewBigIntegerItem(2), input: NewBigIntegerItem(big.NewInt(2)),
result: []byte(`2`), result: []byte(`2`),
}, },
{ {
@ -386,7 +386,7 @@ var toContractParameterTestCases = []struct {
}{ }{
{ {
input: NewStructItem([]StackItem{ input: NewStructItem([]StackItem{
NewBigIntegerItem(1), NewBigIntegerItem(big.NewInt(1)),
NewBoolItem(true), NewBoolItem(true),
}), }),
result: smartcontract.Parameter{Type: smartcontract.ArrayType, Value: []smartcontract.Parameter{ result: smartcontract.Parameter{Type: smartcontract.ArrayType, Value: []smartcontract.Parameter{
@ -403,7 +403,7 @@ var toContractParameterTestCases = []struct {
result: smartcontract.Parameter{Type: smartcontract.ByteArrayType, Value: []byte{0x01, 0x02, 0x03}}, result: smartcontract.Parameter{Type: smartcontract.ByteArrayType, Value: []byte{0x01, 0x02, 0x03}},
}, },
{ {
input: NewArrayItem([]StackItem{NewBigIntegerItem(2), NewBoolItem(true)}), input: NewArrayItem([]StackItem{NewBigIntegerItem(big.NewInt(2)), NewBoolItem(true)}),
result: smartcontract.Parameter{Type: smartcontract.ArrayType, Value: []smartcontract.Parameter{ result: smartcontract.Parameter{Type: smartcontract.ArrayType, Value: []smartcontract.Parameter{
{Type: smartcontract.IntegerType, Value: int64(2)}, {Type: smartcontract.IntegerType, Value: int64(2)},
{Type: smartcontract.BoolType, Value: true}, {Type: smartcontract.BoolType, Value: true},
@ -415,8 +415,8 @@ var toContractParameterTestCases = []struct {
}, },
{ {
input: &MapItem{value: []MapElement{ input: &MapItem{value: []MapElement{
{NewBigIntegerItem(1), NewBoolItem(true)}, {NewBigIntegerItem(big.NewInt(1)), NewBoolItem(true)},
{NewByteArrayItem([]byte("qwerty")), NewBigIntegerItem(3)}, {NewByteArrayItem([]byte("qwerty")), NewBigIntegerItem(big.NewInt(3))},
{NewBoolItem(true), NewBoolItem(false)}, {NewBoolItem(true), NewBoolItem(false)},
}}, }},
result: smartcontract.Parameter{ result: smartcontract.Parameter{

14
pkg/vm/vm_test.go
View file

@ -441,7 +441,7 @@ func testIterableCreate(t *testing.T, typ string) {
vm := load(prog) vm := load(prog)
arr := []StackItem{ arr := []StackItem{
NewBigIntegerItem(42), NewBigIntegerItem(big.NewInt(42)),
NewByteArrayItem([]byte{3, 2, 1}), NewByteArrayItem([]byte{3, 2, 1}),
} }
vm.estack.Push(&Element{value: NewArrayItem(arr)}) vm.estack.Push(&Element{value: NewArrayItem(arr)})
@ -479,7 +479,7 @@ func testIterableConcat(t *testing.T, typ string) {
arr := []StackItem{ arr := []StackItem{
NewBoolItem(false), NewBoolItem(false),
NewBigIntegerItem(123), NewBigIntegerItem(big.NewInt(123)),
NewMapItem(), NewMapItem(),
} }
vm.estack.Push(&Element{value: NewArrayItem(arr[:1])}) vm.estack.Push(&Element{value: NewArrayItem(arr[:1])})
@ -521,15 +521,15 @@ func TestIteratorKeys(t *testing.T) {
v := load(prog) v := load(prog)
arr := NewArrayItem([]StackItem{ arr := NewArrayItem([]StackItem{
NewBoolItem(false), NewBoolItem(false),
NewBigIntegerItem(42), NewBigIntegerItem(big.NewInt(42)),
}) })
v.estack.PushVal(arr) v.estack.PushVal(arr)
runVM(t, v) runVM(t, v)
checkEnumeratorStack(t, v, []StackItem{ checkEnumeratorStack(t, v, []StackItem{
NewBigIntegerItem(1), NewBoolItem(true), NewBigIntegerItem(big.NewInt(1)), NewBoolItem(true),
NewBigIntegerItem(0), NewBoolItem(true), NewBigIntegerItem(big.NewInt(0)), NewBoolItem(true),
}) })
} }
@ -541,7 +541,7 @@ func TestIteratorValues(t *testing.T) {
v := load(prog) v := load(prog)
m := NewMapItem() m := NewMapItem()
m.Add(NewBigIntegerItem(1), NewBoolItem(false)) m.Add(NewBigIntegerItem(big.NewInt(1)), NewBoolItem(false))
m.Add(NewByteArrayItem([]byte{32}), NewByteArrayItem([]byte{7})) m.Add(NewByteArrayItem([]byte{32}), NewByteArrayItem([]byte{7}))
v.estack.PushVal(m) v.estack.PushVal(m)
@ -680,7 +680,7 @@ func TestDeserializeUnknown(t *testing.T) {
prog := append(getSyscallProg("Neo.Runtime.Deserialize"), byte(opcode.RET)) prog := append(getSyscallProg("Neo.Runtime.Deserialize"), byte(opcode.RET))
vm := load(prog) vm := load(prog)
data, err := SerializeItem(NewBigIntegerItem(123)) data, err := SerializeItem(NewBigIntegerItem(big.NewInt(123)))
require.NoError(t, err) require.NoError(t, err)
data[0] = 0xFF data[0] = 0xFF