diff --git a/builtins.go b/builtins.go index a89e72f..fcda81c 100644 --- a/builtins.go +++ b/builtins.go @@ -17,6 +17,10 @@ var builtinFuncs = []*BuiltinFunction{ Name: "delete", Value: builtinDelete, }, + { + Name: "splice", + Value: builtinSplice, + }, { Name: "string", Value: builtinString, @@ -532,3 +536,76 @@ func builtinDelete(args ...Object) (Object, error) { } } } + +// builtinSplice deletes and changes given Array, returns deleted items. +// usage: +// deleted_items := splice(array[,start[,delete_count[,item1[,item2[,...]]]]) +func builtinSplice(args ...Object) (Object, error) { + argsLen := len(args) + if argsLen == 0 { + return nil, ErrWrongNumArguments + } + + array, ok := args[0].(*Array) + if !ok { + return nil, ErrInvalidArgumentType{ + Name: "first", + Expected: "array", + Found: args[0].TypeName(), + } + } + arrayLen := len(array.Value) + + var startIdx int + if argsLen > 1 { + arg1, ok := args[1].(*Int) + if !ok { + return nil, ErrInvalidArgumentType{ + Name: "second", + Expected: "int", + Found: args[1].TypeName(), + } + } + startIdx = int(arg1.Value) + if startIdx < 0 || startIdx > arrayLen { + return nil, ErrIndexOutOfBounds + } + } + + delCount := len(array.Value) + if argsLen > 2 { + arg2, ok := args[2].(*Int) + if !ok { + return nil, ErrInvalidArgumentType{ + Name: "third", + Expected: "int", + Found: args[2].TypeName(), + } + } + delCount = int(arg2.Value) + if delCount < 0 { + return nil, ErrIndexOutOfBounds + } + } + // if count of to be deleted items is bigger than expected, truncate it + if startIdx+delCount > arrayLen { + delCount = arrayLen - startIdx + } + // delete items + endIdx := startIdx + delCount + deleted := append([]Object{}, array.Value[startIdx:endIdx]...) + + head := array.Value[:startIdx] + var items []Object + if argsLen > 3 { + items = make([]Object, 0, argsLen-3) + for i := 3; i < argsLen; i++ { + items = append(items, args[i]) + } + } + items = append(items, array.Value[endIdx:]...) + array.Value = append(head, items...) + + // return deleted items + return &Array{Value: deleted}, nil +} diff --git a/builtins_test.go b/builtins_test.go index 4f0d837..2f2e47c 100644 --- a/builtins_test.go +++ b/builtins_test.go @@ -1,79 +1,113 @@ -package tengo +package tengo_test import ( "errors" "reflect" "testing" + + "github.com/d5/tengo/v2" ) func Test_builtinDelete(t *testing.T) { + var builtinDelete func(args ...tengo.Object) (tengo.Object, error) + for _, f := range tengo.GetAllBuiltinFunctions() { + if f.Name == "delete" { + builtinDelete = f.Value + break + } + } + if builtinDelete == nil { + t.Fatal("builtin delete not found") + } type args struct { - args []Object + args []tengo.Object } tests := []struct { name string args args - want Object + want tengo.Object wantErr bool wantedErr error target interface{} }{ - //Map - {name: "invalid-arg", args: args{[]Object{&String{}, &String{}}}, wantErr: true, - wantedErr: ErrInvalidArgumentType{Name: "first", Expected: "map", Found: "string"}}, - {name: "no-args", wantErr: true, wantedErr: ErrWrongNumArguments}, - {name: "empty-args", args: args{[]Object{}}, wantErr: true, wantedErr: ErrWrongNumArguments}, - {name: "3-args", args: args{[]Object{(*Map)(nil), (*String)(nil), (*String)(nil)}}, wantErr: true, wantedErr: ErrWrongNumArguments}, - {name: "nil-map-empty-key", args: args{[]Object{&Map{}, &String{}}}, want: UndefinedValue}, - {name: "nil-map-nonstr-key", args: args{[]Object{&Map{}, &Int{}}}, wantErr: true, - wantedErr: ErrInvalidArgumentType{Name: "second", Expected: "string", Found: "int"}}, - {name: "nil-map-no-key", args: args{[]Object{&Map{}}}, wantErr: true, - wantedErr: ErrWrongNumArguments}, + {name: "invalid-arg", args: args{[]tengo.Object{&tengo.String{}, + &tengo.String{}}}, wantErr: true, + wantedErr: tengo.ErrInvalidArgumentType{ + Name: "first", + Expected: "map", + Found: "string"}, + }, + {name: "no-args", + wantErr: true, wantedErr: tengo.ErrWrongNumArguments}, + {name: "empty-args", args: args{[]tengo.Object{}}, wantErr: true, + wantedErr: tengo.ErrWrongNumArguments, + }, + {name: "3-args", args: args{[]tengo.Object{ + (*tengo.Map)(nil), (*tengo.String)(nil), (*tengo.String)(nil)}}, + wantErr: true, wantedErr: tengo.ErrWrongNumArguments, + }, + {name: "nil-map-empty-key", + args: args{[]tengo.Object{&tengo.Map{}, &tengo.String{}}}, + want: tengo.UndefinedValue, + }, + {name: "nil-map-nonstr-key", + args: args{[]tengo.Object{ + &tengo.Map{}, &tengo.Int{}}}, wantErr: true, + wantedErr: tengo.ErrInvalidArgumentType{ + Name: "second", Expected: "string", Found: "int"}, + }, + {name: "nil-map-no-key", + args: args{[]tengo.Object{&tengo.Map{}}}, wantErr: true, + wantedErr: tengo.ErrWrongNumArguments, + }, {name: "map-missing-key", args: args{ - []Object{ - &Map{Value: map[string]Object{ - "key": &String{Value: "value"}, + []tengo.Object{ + &tengo.Map{Value: map[string]tengo.Object{ + "key": &tengo.String{Value: "value"}, }}, - &String{Value: "key1"}, - }}, - want: UndefinedValue, - target: &Map{Value: map[string]Object{"key": &String{Value: "value"}}}, + &tengo.String{Value: "key1"}}}, + want: tengo.UndefinedValue, + target: &tengo.Map{ + Value: map[string]tengo.Object{ + "key": &tengo.String{ + Value: "value"}}}, }, {name: "map-emptied", args: args{ - []Object{ - &Map{Value: map[string]Object{ - "key": &String{Value: "value"}, + []tengo.Object{ + &tengo.Map{Value: map[string]tengo.Object{ + "key": &tengo.String{Value: "value"}, }}, - &String{Value: "key"}, - }}, - want: UndefinedValue, - target: &Map{Value: map[string]Object{}}, + &tengo.String{Value: "key"}}}, + want: tengo.UndefinedValue, + target: &tengo.Map{Value: map[string]tengo.Object{}}, }, {name: "map-multi-keys", args: args{ - []Object{ - &Map{Value: map[string]Object{ - "key1": &String{Value: "value1"}, - "key2": &Int{Value: 10}, + []tengo.Object{ + &tengo.Map{Value: map[string]tengo.Object{ + "key1": &tengo.String{Value: "value1"}, + "key2": &tengo.Int{Value: 10}, }}, - &String{Value: "key1"}, - }}, - want: UndefinedValue, - target: &Map{Value: map[string]Object{"key2": &Int{Value: 10}}}, + &tengo.String{Value: "key1"}}}, + want: tengo.UndefinedValue, + target: &tengo.Map{Value: map[string]tengo.Object{ + "key2": &tengo.Int{Value: 10}}}, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { got, err := builtinDelete(tt.args.args...) if (err != nil) != tt.wantErr { - t.Errorf("builtinDelete() error = %v, wantErr %v", err, tt.wantErr) + t.Errorf("builtinDelete() error = %v, wantErr %v", + err, tt.wantErr) return } if tt.wantErr && !errors.Is(err, tt.wantedErr) { if err.Error() != tt.wantedErr.Error() { - t.Errorf("builtinDelete() error = %v, wantedErr %v", err, tt.wantedErr) + t.Errorf("builtinDelete() error = %v, wantedErr %v", + err, tt.wantedErr) return } } @@ -83,15 +117,237 @@ func Test_builtinDelete(t *testing.T) { } if !tt.wantErr && tt.target != nil { switch v := tt.args.args[0].(type) { - case *Map, *Array: + case *tengo.Map, *tengo.Array: if !reflect.DeepEqual(tt.target, tt.args.args[0]) { - t.Errorf("builtinDelete() objects are not equal got: %+v, want: %+v", tt.args.args[0], tt.target) + t.Errorf("builtinDelete() objects are not equal "+ + "got: %+v, want: %+v", tt.args.args[0], tt.target) } default: - t.Errorf("builtinDelete() unsuporrted arg[0] type %s", v.TypeName()) + t.Errorf("builtinDelete() unsuporrted arg[0] type %s", + v.TypeName()) return } } }) } } + +func Test_builtinSplice(t *testing.T) { + var builtinSplice func(args ...tengo.Object) (tengo.Object, error) + for _, f := range tengo.GetAllBuiltinFunctions() { + if f.Name == "splice" { + builtinSplice = f.Value + break + } + } + if builtinSplice == nil { + t.Fatal("builtin splice not found") + } + tests := []struct { + name string + args []tengo.Object + deleted tengo.Object + Array *tengo.Array + wantErr bool + wantedErr error + }{ + {name: "no args", args: []tengo.Object{}, wantErr: true, + wantedErr: tengo.ErrWrongNumArguments, + }, + {name: "invalid args", args: []tengo.Object{&tengo.Map{}}, + wantErr: true, + wantedErr: tengo.ErrInvalidArgumentType{ + Name: "first", Expected: "array", Found: "map"}, + }, + {name: "invalid args", + args: []tengo.Object{&tengo.Array{}, &tengo.String{}}, + wantErr: true, + wantedErr: tengo.ErrInvalidArgumentType{ + Name: "second", Expected: "int", Found: "string"}, + }, + {name: "negative index", + args: []tengo.Object{&tengo.Array{}, &tengo.Int{Value: -1}}, + wantErr: true, + wantedErr: tengo.ErrIndexOutOfBounds}, + {name: "non int count", + args: []tengo.Object{ + &tengo.Array{}, &tengo.Int{Value: 0}, + &tengo.String{Value: ""}}, + wantErr: true, + wantedErr: tengo.ErrInvalidArgumentType{ + Name: "third", Expected: "int", Found: "string"}, + }, + {name: "negative count", + args: []tengo.Object{ + &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 0}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}}}, + &tengo.Int{Value: 0}, + &tengo.Int{Value: -1}}, + wantErr: true, + wantedErr: tengo.ErrIndexOutOfBounds, + }, + {name: "insert with zero count", + args: []tengo.Object{ + &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 0}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}}}, + &tengo.Int{Value: 0}, + &tengo.Int{Value: 0}, + &tengo.String{Value: "b"}}, + deleted: &tengo.Array{Value: []tengo.Object{}}, + Array: &tengo.Array{Value: []tengo.Object{ + &tengo.String{Value: "b"}, + &tengo.Int{Value: 0}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}}}, + }, + {name: "insert", + args: []tengo.Object{ + &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 0}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}}}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 0}, + &tengo.String{Value: "c"}, + &tengo.String{Value: "d"}}, + deleted: &tengo.Array{Value: []tengo.Object{}}, + Array: &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 0}, + &tengo.String{Value: "c"}, + &tengo.String{Value: "d"}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}}}, + }, + {name: "insert with zero count", + args: []tengo.Object{ + &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 0}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}}}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 0}, + &tengo.String{Value: "c"}, + &tengo.String{Value: "d"}}, + deleted: &tengo.Array{Value: []tengo.Object{}}, + Array: &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 0}, + &tengo.String{Value: "c"}, + &tengo.String{Value: "d"}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}}}, + }, + {name: "insert with delete", + args: []tengo.Object{ + &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 0}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}}}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 1}, + &tengo.String{Value: "c"}, + &tengo.String{Value: "d"}}, + deleted: &tengo.Array{ + Value: []tengo.Object{&tengo.Int{Value: 1}}}, + Array: &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 0}, + &tengo.String{Value: "c"}, + &tengo.String{Value: "d"}, + &tengo.Int{Value: 2}}}, + }, + {name: "insert with delete multi", + args: []tengo.Object{ + &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 0}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}}}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}, + &tengo.String{Value: "c"}, + &tengo.String{Value: "d"}}, + deleted: &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}}}, + Array: &tengo.Array{ + Value: []tengo.Object{ + &tengo.Int{Value: 0}, + &tengo.String{Value: "c"}, + &tengo.String{Value: "d"}}}, + }, + {name: "delete all with positive count", + args: []tengo.Object{ + &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 0}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}}}, + &tengo.Int{Value: 0}, + &tengo.Int{Value: 3}}, + deleted: &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 0}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}}}, + Array: &tengo.Array{Value: []tengo.Object{}}, + }, + {name: "delete all with big count", + args: []tengo.Object{ + &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 0}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}}}, + &tengo.Int{Value: 0}, + &tengo.Int{Value: 5}}, + deleted: &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 0}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}}}, + Array: &tengo.Array{Value: []tengo.Object{}}, + }, + {name: "nothing2", + args: []tengo.Object{ + &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 0}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}}}}, + Array: &tengo.Array{Value: []tengo.Object{}}, + deleted: &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 0}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}}}, + }, + {name: "pop without count", + args: []tengo.Object{ + &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 0}, + &tengo.Int{Value: 1}, + &tengo.Int{Value: 2}}}, + &tengo.Int{Value: 2}}, + deleted: &tengo.Array{Value: []tengo.Object{&tengo.Int{Value: 2}}}, + Array: &tengo.Array{Value: []tengo.Object{ + &tengo.Int{Value: 0}, &tengo.Int{Value: 1}}}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := builtinSplice(tt.args...) + if (err != nil) != tt.wantErr { + t.Errorf("builtinSplice() error = %v, wantErr %v", + err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.deleted) { + t.Errorf("builtinSplice() = %v, want %v", got, tt.deleted) + } + if tt.wantErr && tt.wantedErr.Error() != err.Error() { + t.Errorf("builtinSplice() error = %v, wantedErr %v", + err, tt.wantedErr) + } + if tt.Array != nil && !reflect.DeepEqual(tt.Array, tt.args[0]) { + t.Errorf("builtinSplice() arrays are not equal expected"+ + " %s, got %s", tt.Array, tt.args[0].(*tengo.Array)) + } + }) + } +} diff --git a/docs/builtins.md b/docs/builtins.md index 23db51e..fc15833 100644 --- a/docs/builtins.md +++ b/docs/builtins.md @@ -67,6 +67,65 @@ delete({}) // runtime error, second argument is missing delete({}, 1) // runtime error, second argument must be a string type ``` +## splice + +Deletes and/or changes the contents of a given array and returns +deleted items as a new array. `splice` is similar to +JS `Array.prototype.splice()` except splice is a builtin function and +first argument must an array. First argument must be an array, and +if second and third arguments are provided those must be integers +otherwise runtime error is returned. + +Usage: + +`deleted_items := splice(array[, start[, delete_count[, item1[, item2[, ...]]]])` + +```golang +v := [1, 2, 3] +items := splice(v, 0) // items == [1, 2, 3], v == [] +``` + +```golang +v := [1, 2, 3] +items := splice(v, 1) // items == [2, 3], v == [1] +``` + +```golang +v := [1, 2, 3] +items := splice(v, 0, 1) // items == [1], v == [2, 3] +``` + +```golang +// deleting +v := ["a", "b", "c"] +items := splice(v, 1, 2) // items == ["b", "c"], v == ["a"] +// splice(v, 1, 3) or splice(v, 1, 99) has same effect for this example +``` + +```golang +// appending +v := ["a", "b", "c"] +items := splice(v, 3, 0, "d", "e") // items == [], v == ["a", "b", "c", "d", "e"] +``` + +```golang +// replacing +v := ["a", "b", "c"] +items := splice(v, 2, 1, "d") // items == ["c"], v == ["a", "b", "d"] +``` + +```golang +// inserting +v := ["a", "b", "c"] +items := splice(v, 0, 0, "d", "e") // items == [], v == ["d", "e", "a", "b", "c"] +``` + +```golang +// deleting and inserting +v := ["a", "b", "c"] +items := splice(v, 1, 1, "d", "e") // items == ["b"], v == ["a", "d", "e", "c"] +``` + ## type_name Returns the type_name of an object. diff --git a/vm_test.go b/vm_test.go index b59806e..4ffaed7 100644 --- a/vm_test.go +++ b/vm_test.go @@ -735,31 +735,164 @@ func TestBuiltinFunction(t *testing.T) { expectError(t, `delete(1, 1)`, nil, `invalid type for argument 'first'`) expectError(t, `delete(1.0, 1)`, nil, `invalid type for argument 'first'`) expectError(t, `delete("str", 1)`, nil, `invalid type for argument 'first'`) - expectError(t, `delete(bytes("str"), 1)`, nil, `invalid type for argument 'first'`) - expectError(t, `delete(error("err"), 1)`, nil, `invalid type for argument 'first'`) + expectError(t, `delete(bytes("str"), 1)`, nil, + `invalid type for argument 'first'`) + expectError(t, `delete(error("err"), 1)`, nil, + `invalid type for argument 'first'`) expectError(t, `delete(true, 1)`, nil, `invalid type for argument 'first'`) - expectError(t, `delete(char('c'), 1)`, nil, `invalid type for argument 'first'`) - expectError(t, `delete(undefined, 1)`, nil, `invalid type for argument 'first'`) - expectError(t, `delete(time(1257894000), 1)`, nil, `invalid type for argument 'first'`) - expectError(t, `delete(immutable({}), "key")`, nil, `invalid type for argument 'first'`) - expectError(t, `delete(immutable([]), "")`, nil, `invalid type for argument 'first'`) + expectError(t, `delete(char('c'), 1)`, nil, + `invalid type for argument 'first'`) + expectError(t, `delete(undefined, 1)`, nil, + `invalid type for argument 'first'`) + expectError(t, `delete(time(1257894000), 1)`, nil, + `invalid type for argument 'first'`) + expectError(t, `delete(immutable({}), "key")`, nil, + `invalid type for argument 'first'`) + expectError(t, `delete(immutable([]), "")`, nil, + `invalid type for argument 'first'`) expectError(t, `delete([], "")`, nil, `invalid type for argument 'first'`) expectError(t, `delete({}, 1)`, nil, `invalid type for argument 'second'`) expectError(t, `delete({}, 1.0)`, nil, `invalid type for argument 'second'`) - expectError(t, `delete({}, undefined)`, nil, `invalid type for argument 'second'`) + expectError(t, `delete({}, undefined)`, nil, + `invalid type for argument 'second'`) expectError(t, `delete({}, [])`, nil, `invalid type for argument 'second'`) expectError(t, `delete({}, {})`, nil, `invalid type for argument 'second'`) - expectError(t, `delete({}, error("err"))`, nil, `invalid type for argument 'second'`) - expectError(t, `delete({}, bytes("str"))`, nil, `invalid type for argument 'second'`) - expectError(t, `delete({}, char(35))`, nil, `invalid type for argument 'second'`) - expectError(t, `delete({}, time(1257894000))`, nil, `invalid type for argument 'second'`) - expectError(t, `delete({}, immutable({}))`, nil, `invalid type for argument 'second'`) - expectError(t, `delete({}, immutable([]))`, nil, `invalid type for argument 'second'`) + expectError(t, `delete({}, error("err"))`, nil, + `invalid type for argument 'second'`) + expectError(t, `delete({}, bytes("str"))`, nil, + `invalid type for argument 'second'`) + expectError(t, `delete({}, char(35))`, nil, + `invalid type for argument 'second'`) + expectError(t, `delete({}, time(1257894000))`, nil, + `invalid type for argument 'second'`) + expectError(t, `delete({}, immutable({}))`, nil, + `invalid type for argument 'second'`) + expectError(t, `delete({}, immutable([]))`, nil, + `invalid type for argument 'second'`) expectRun(t, `out = delete({}, "")`, nil, tengo.UndefinedValue) expectRun(t, `out = {key1: 1}; delete(out, "key1")`, nil, MAP{}) - expectRun(t, `out = {key1: 1, key2: "2"}; delete(out, "key1")`, nil, MAP{"key2": "2"}) - expectRun(t, `out = [1, "2", {a: "b", c: 10}]; delete(out[2], "c")`, nil, ARR{1, "2", MAP{"a": "b"}}) + expectRun(t, `out = {key1: 1, key2: "2"}; delete(out, "key1")`, nil, + MAP{"key2": "2"}) + expectRun(t, `out = [1, "2", {a: "b", c: 10}]; delete(out[2], "c")`, nil, + ARR{1, "2", MAP{"a": "b"}}) + + // splice + expectError(t, `splice()`, nil, tengo.ErrWrongNumArguments.Error()) + expectError(t, `splice(1)`, nil, `invalid type for argument 'first'`) + expectError(t, `splice(1.0)`, nil, `invalid type for argument 'first'`) + expectError(t, `splice("str")`, nil, `invalid type for argument 'first'`) + expectError(t, `splice(bytes("str"))`, nil, + `invalid type for argument 'first'`) + expectError(t, `splice(error("err"))`, nil, + `invalid type for argument 'first'`) + expectError(t, `splice(true)`, nil, `invalid type for argument 'first'`) + expectError(t, `splice(char('c'))`, nil, + `invalid type for argument 'first'`) + expectError(t, `splice(undefined)`, nil, + `invalid type for argument 'first'`) + expectError(t, `splice(time(1257894000))`, nil, + `invalid type for argument 'first'`) + expectError(t, `splice(immutable({}))`, nil, + `invalid type for argument 'first'`) + expectError(t, `splice(immutable([]))`, nil, + `invalid type for argument 'first'`) + expectError(t, `splice({})`, nil, `invalid type for argument 'first'`) + expectError(t, `splice([], 1.0)`, nil, + `invalid type for argument 'second'`) + expectError(t, `splice([], "str")`, nil, + `invalid type for argument 'second'`) + expectError(t, `splice([], bytes("str"))`, nil, + `invalid type for argument 'second'`) + expectError(t, `splice([], error("error"))`, nil, + `invalid type for argument 'second'`) + expectError(t, `splice([], false)`, nil, + `invalid type for argument 'second'`) + expectError(t, `splice([], char('d'))`, nil, + `invalid type for argument 'second'`) + expectError(t, `splice([], undefined)`, nil, + `invalid type for argument 'second'`) + expectError(t, `splice([], time(0))`, nil, + `invalid type for argument 'second'`) + expectError(t, `splice([], [])`, nil, + `invalid type for argument 'second'`) + expectError(t, `splice([], {})`, nil, + `invalid type for argument 'second'`) + expectError(t, `splice([], immutable([]))`, nil, + `invalid type for argument 'second'`) + expectError(t, `splice([], immutable({}))`, nil, + `invalid type for argument 'second'`) + expectError(t, `splice([], 0, 1.0)`, nil, + `invalid type for argument 'third'`) + expectError(t, `splice([], 0, "string")`, nil, + `invalid type for argument 'third'`) + expectError(t, `splice([], 0, bytes("string"))`, nil, + `invalid type for argument 'third'`) + expectError(t, `splice([], 0, error("string"))`, nil, + `invalid type for argument 'third'`) + expectError(t, `splice([], 0, true)`, nil, + `invalid type for argument 'third'`) + expectError(t, `splice([], 0, char('f'))`, nil, + `invalid type for argument 'third'`) + expectError(t, `splice([], 0, undefined)`, nil, + `invalid type for argument 'third'`) + expectError(t, `splice([], 0, time(0))`, nil, + `invalid type for argument 'third'`) + expectError(t, `splice([], 0, [])`, nil, + `invalid type for argument 'third'`) + expectError(t, `splice([], 0, {})`, nil, + `invalid type for argument 'third'`) + expectError(t, `splice([], 0, immutable([]))`, nil, + `invalid type for argument 'third'`) + expectError(t, `splice([], 0, immutable({}))`, nil, + `invalid type for argument 'third'`) + expectError(t, `splice([], 1)`, nil, tengo.ErrIndexOutOfBounds.Error()) + expectError(t, `splice([1, 2, 3], 0, -1)`, nil, + tengo.ErrIndexOutOfBounds.Error()) + expectError(t, `splice([1, 2, 3], 99, 0, "a", "b")`, nil, + tengo.ErrIndexOutOfBounds.Error()) + expectRun(t, `out = []; splice(out)`, nil, ARR{}) + expectRun(t, `out = ["a"]; splice(out, 1)`, nil, ARR{"a"}) + expectRun(t, `out = ["a"]; out = splice(out, 1)`, nil, ARR{}) + expectRun(t, `out = [1, 2, 3]; splice(out, 0, 1)`, nil, ARR{2, 3}) + expectRun(t, `out = [1, 2, 3]; out = splice(out, 0, 1)`, nil, ARR{1}) + expectRun(t, `out = [1, 2, 3]; splice(out, 0, 0, "a", "b")`, nil, + ARR{"a", "b", 1, 2, 3}) + expectRun(t, `out = [1, 2, 3]; out = splice(out, 0, 0, "a", "b")`, nil, + ARR{}) + expectRun(t, `out = [1, 2, 3]; splice(out, 1, 0, "a", "b")`, nil, + ARR{1, "a", "b", 2, 3}) + expectRun(t, `out = [1, 2, 3]; out = splice(out, 1, 0, "a", "b")`, nil, + ARR{}) + expectRun(t, `out = [1, 2, 3]; splice(out, 1, 0, "a", "b")`, nil, + ARR{1, "a", "b", 2, 3}) + expectRun(t, `out = [1, 2, 3]; splice(out, 2, 0, "a", "b")`, nil, + ARR{1, 2, "a", "b", 3}) + expectRun(t, `out = [1, 2, 3]; splice(out, 3, 0, "a", "b")`, nil, + ARR{1, 2, 3, "a", "b"}) + expectRun(t, `array := [1, 2, 3]; deleted := splice(array, 1, 1, "a", "b"); + out = [deleted, array]`, nil, ARR{ARR{2}, ARR{1, "a", "b", 3}}) + expectRun(t, `array := [1, 2, 3]; deleted := splice(array, 1); + out = [deleted, array]`, nil, ARR{ARR{2, 3}, ARR{1}}) + expectRun(t, `out = []; splice(out, 0, 0, "a", "b")`, nil, ARR{"a", "b"}) + expectRun(t, `out = []; splice(out, 0, 1, "a", "b")`, nil, ARR{"a", "b"}) + expectRun(t, `out = []; out = splice(out, 0, 0, "a", "b")`, nil, ARR{}) + expectRun(t, `out = splice(splice([1, 2, 3], 0, 3), 1, 3)`, nil, ARR{2, 3}) + // splice doc examples + expectRun(t, `v := [1, 2, 3]; deleted := splice(v, 0); + out = [deleted, v]`, nil, ARR{ARR{1, 2, 3}, ARR{}}) + expectRun(t, `v := [1, 2, 3]; deleted := splice(v, 1); + out = [deleted, v]`, nil, ARR{ARR{2, 3}, ARR{1}}) + expectRun(t, `v := [1, 2, 3]; deleted := splice(v, 0, 1); + out = [deleted, v]`, nil, ARR{ARR{1}, ARR{2, 3}}) + expectRun(t, `v := ["a", "b", "c"]; deleted := splice(v, 1, 2); + out = [deleted, v]`, nil, ARR{ARR{"b", "c"}, ARR{"a"}}) + expectRun(t, `v := ["a", "b", "c"]; deleted := splice(v, 2, 1, "d"); + out = [deleted, v]`, nil, ARR{ARR{"c"}, ARR{"a", "b", "d"}}) + expectRun(t, `v := ["a", "b", "c"]; deleted := splice(v, 0, 0, "d", "e"); + out = [deleted, v]`, nil, ARR{ARR{}, ARR{"d", "e", "a", "b", "c"}}) + expectRun(t, `v := ["a", "b", "c"]; deleted := splice(v, 1, 1, "d", "e"); + out = [deleted, v]`, nil, ARR{ARR{"b"}, ARR{"a", "d", "e", "c"}}) } func TestBytesN(t *testing.T) {