github.com/google/grumpy@v0.0.0-20171122020858-3ec87959189c/runtime/native_test.go

// Copyright 2016 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package grumpy

import (
	"errors"
	"fmt"
	"math/big"
	"reflect"
	"regexp"
	"testing"
)

func TestNativeMetaclassNew(t *testing.T) {
	var i int16
	intType := newNativeType(reflect.TypeOf(i), IntType)
	fun := wrapFuncForTest(func(f *Frame, args ...*Object) *BaseException {
		newFunc, raised := GetAttr(f, intType.ToObject(), NewStr("new"), nil)
		if raised != nil {
			return raised
		}
		ret, raised := newFunc.Call(f, args, nil)
		if raised != nil {
			return raised
		}
		got, raised := ToNative(f, ret)
		if raised != nil {
			return raised
		}
		if got.Type() != reflect.TypeOf(&i) {
			t.Errorf("%v.new() returned a %s, want a *int16", intType, nativeTypeName(got.Type()))
		} else if p, ok := got.Interface().(*int16); !ok || p == nil || *p != 0 {
			t.Errorf("%v.new() returned %v, want &int16(0)", intType, got)
		}
		return nil
	})
	cases := []invokeTestCase{
		{want: None},
		{args: wrapArgs("abc"), wantExc: mustCreateException(TypeErrorType, "'new' of 'nativetype' requires 1 arguments")},
	}
	for _, cas := range cases {
		if err := runInvokeTestCase(fun, &cas); err != "" {
			t.Error(err)
		}
	}
}

func TestNativeFuncCall(t *testing.T) {
	cases := []struct {
		fun interface{}
		invokeTestCase
	}{
		{func() {}, invokeTestCase{want: None}},
		{func() float32 { return 2.0 }, invokeTestCase{want: NewFloat(2.0).ToObject()}},
		{func(s string) string { return s }, invokeTestCase{args: wrapArgs("foo"), want: NewStr("foo").ToObject()}},
		{func() (int, string) { return 42, "bar" }, invokeTestCase{want: newTestTuple(42, "bar").ToObject()}},
		{func(s ...string) int { return len(s) }, invokeTestCase{args: wrapArgs("foo", "bar"), want: NewInt(2).ToObject()}},
		{func() {}, invokeTestCase{args: wrapArgs(3.14), wantExc: mustCreateException(TypeErrorType, "native function takes 0 arguments, (1 given)")}},
		{func(int, ...string) {}, invokeTestCase{wantExc: mustCreateException(TypeErrorType, "native function takes at least 1 arguments, (0 given)")}},
	}
	for _, cas := range cases {
		n := &native{Object{typ: nativeFuncType}, reflect.ValueOf(cas.fun)}
		if err := runInvokeTestCase(n.ToObject(), &cas.invokeTestCase); err != "" {
			t.Error(err)
		}
	}
}

func TestNativeFuncName(t *testing.T) {
	re := regexp.MustCompile(`(\w+\.)*\w+$`)
	fun := wrapFuncForTest(func(f *Frame, o *Object) (string, *BaseException) {
		desc, raised := GetItem(f, nativeFuncType.Dict().ToObject(), internedName.ToObject())
		if raised != nil {
			return "", raised
		}
		get, raised := GetAttr(f, desc, NewStr("__get__"), nil)
		if raised != nil {
			return "", raised
		}
		name, raised := get.Call(f, wrapArgs(o, nativeFuncType), nil)
		if raised != nil {
			return "", raised
		}
		if raised := Assert(f, GetBool(name.isInstance(StrType)).ToObject(), nil); raised != nil {
			return "", raised
		}
		return re.FindString(toStrUnsafe(name).Value()), nil
	})
	cases := []invokeTestCase{
		{args: wrapArgs(TestNativeFuncName), want: NewStr("grumpy.TestNativeFuncName").ToObject()},
		{args: wrapArgs(None), wantExc: mustCreateException(TypeErrorType, "'_get_name' requires a 'func' object but received a 'NoneType'")},
	}
	for _, cas := range cases {
		if err := runInvokeTestCase(fun, &cas); err != "" {
			t.Error(err)
		}
	}
}

func TestNativeFuncStrRepr(t *testing.T) {
	cases := []struct {
		args        Args
		wantPattern string
	}{
		{wrapArgs(TestNativeFuncStrRepr), `<func\(\*T\) .*grumpy\.TestNativeFuncStrRepr at 0x[a-f0-9]+>`},
		{wrapArgs(func() {}), `<func\(\) .*grumpy\.TestNativeFuncStrRepr\.\w+ at 0x[a-f0-9]+>`},
		{wrapArgs(Repr), `<func\(\*Frame, \*Object\) .*grumpy\.Repr at 0x[a-f0-9]+>`},
	}
	for _, cas := range cases {
		re := regexp.MustCompile(cas.wantPattern)
		fun := wrapFuncForTest(func(f *Frame, o *Object) *BaseException {
			s, raised := ToStr(f, o)
			if raised != nil {
				return raised
			}
			if !re.MatchString(s.Value()) {
				t.Errorf("str(%v) = %v, want %v", o, s, re)
			}
			s, raised = Repr(f, o)
			if raised != nil {
				return raised
			}
			if !re.MatchString(s.Value()) {
				t.Errorf("repr(%v) = %v, want %v", o, s, re)
			}
			return nil
		})
		if err := runInvokeTestCase(fun, &invokeTestCase{args: cas.args, want: None}); err != "" {
			t.Error(err)
		}
	}
}

func TestNativeNew(t *testing.T) {
	fun := wrapFuncForTest(func(f *Frame, t *Type, args ...*Object) (*Tuple, *BaseException) {
		o, raised := t.Call(f, args, nil)
		if raised != nil {
			return nil, raised
		}
		return newTestTuple(o, o.Type()), nil
	})
	type testBool bool
	testBoolType := getNativeType(reflect.TypeOf(testBool(false)))
	type testFloat float32
	testFloatType := getNativeType(reflect.TypeOf(testFloat(0)))
	type testString string
	testStringType := getNativeType(reflect.TypeOf(testString("")))
	cases := []invokeTestCase{
		{args: wrapArgs(testBoolType), want: newTestTuple(false, testBoolType).ToObject()},
		{args: wrapArgs(testBoolType, ""), want: newTestTuple(false, testBoolType).ToObject()},
		{args: wrapArgs(testBoolType, 123), want: newTestTuple(true, testBoolType).ToObject()},
		{args: wrapArgs(testBoolType, "foo", "bar"), wantExc: mustCreateException(TypeErrorType, "testBool() takes at most 1 argument (2 given)")},
		{args: wrapArgs(testFloatType), want: newTestTuple(0.0, testFloatType).ToObject()},
		{args: wrapArgs(testFloatType, 3.14), want: newTestTuple(3.14, testFloatType).ToObject()},
		{args: wrapArgs(testFloatType, "foo", "bar"), wantExc: mustCreateException(TypeErrorType, "'__new__' of 'float' requires 0 or 1 arguments")},
		{args: wrapArgs(testStringType), want: newTestTuple("", testStringType).ToObject()},
		{args: wrapArgs(testStringType, "foo"), want: newTestTuple("foo", testStringType).ToObject()},
		{args: wrapArgs(testStringType, "foo", "bar"), wantExc: mustCreateException(TypeErrorType, "str() takes at most 1 argument (2 given)")},
	}
	for _, cas := range cases {
		if err := runInvokeTestCase(fun, &cas); err != "" {
			t.Error(err)
		}
	}
}

func TestNativeSliceIter(t *testing.T) {
	fun := wrapFuncForTest(func(f *Frame, slice interface{}) (*Object, *BaseException) {
		o, raised := WrapNative(f, reflect.ValueOf(slice))
		if raised != nil {
			return nil, raised
		}
		return TupleType.Call(f, []*Object{o}, nil)
	})
	o := newObject(ObjectType)
	cases := []invokeTestCase{
		{args: wrapArgs([]int{}), want: NewTuple().ToObject()},
		{args: wrapArgs([]string{"foo", "bar"}), want: newTestTuple("foo", "bar").ToObject()},
		{args: wrapArgs([]*Object{True.ToObject(), o}), want: newTestTuple(true, o).ToObject()},
	}
	for _, cas := range cases {
		if err := runInvokeTestCase(fun, &cas); err != "" {
			t.Error(err)
		}
	}
}

func TestSliceIteratorIter(t *testing.T) {
	iter := newSliceIterator(reflect.ValueOf([]*Object{}))
	cas := &invokeTestCase{args: wrapArgs(iter), want: iter}
	if err := runInvokeMethodTestCase(sliceIteratorType, "__iter__", cas); err != "" {
		t.Error(err)
	}
}

func TestWrapNative(t *testing.T) {
	o := newObject(ObjectType)
	d := NewDict()
	i := 0
	n := &native{Object{typ: nativeType}, reflect.ValueOf(&i)}
	cases := []struct {
		value   interface{}
		want    *Object
		wantExc *BaseException
	}{
		{true, True.ToObject(), nil},
		{True, True.ToObject(), nil},
		{123, NewInt(123).ToObject(), nil},
		{int8(10), NewInt(10).ToObject(), nil},
		{float32(0.5), NewFloat(0.5).ToObject(), nil},
		{NewFloat(3.14), NewFloat(3.14).ToObject(), nil},
		{uint(MaxInt), NewInt(MaxInt).ToObject(), nil},
		{"foobar", NewStr("foobar").ToObject(), nil},
		{NewStr("foo"), NewStr("foo").ToObject(), nil},
		{uint64(MaxInt) + 100, NewLong(new(big.Int).SetUint64(uint64(MaxInt) + 100)).ToObject(), nil},
		{o, o, nil},
		{d, d.ToObject(), nil},
		{(*Object)(nil), None, nil},
		{uintptr(123), NewInt(123).ToObject(), nil},
		{n, n.ToObject(), nil},
		{(chan int)(nil), None, nil},
		{[]rune("hola"), NewUnicode("hola").ToObject(), nil},
		{big.NewInt(12345), NewLong(big.NewInt(12345)).ToObject(), nil},
		{*big.NewInt(12345), NewLong(big.NewInt(12345)).ToObject(), nil},
	}
	for _, cas := range cases {
		fun := wrapFuncForTest(func(f *Frame) (*Object, *BaseException) {
			return WrapNative(f, reflect.ValueOf(cas.value))
		})
		testCase := invokeTestCase{want: cas.want, wantExc: cas.wantExc}
		if err := runInvokeTestCase(fun, &testCase); err != "" {
			t.Error(err)
		}
	}
}

func TestWrapNativeFunc(t *testing.T) {
	foo := func() int { return 42 }
	wrappedFoo := mustNotRaise(WrapNative(NewRootFrame(), reflect.ValueOf(foo)))
	if err := runInvokeTestCase(wrappedFoo, &invokeTestCase{want: NewInt(42).ToObject()}); err != "" {
		t.Error(err)
	}
}

func TestWrapNativeInterface(t *testing.T) {
	// This seems to be the simplest way to get a reflect.Value that has
	// Interface kind.
	iVal := reflect.ValueOf(func() error { return errors.New("foo") }).Call(nil)[0]
	if iVal.Kind() != reflect.Interface {
		t.Fatalf("iVal.Kind() = %v, want interface", iVal.Kind())
	}
	o := mustNotRaise(WrapNative(NewRootFrame(), iVal))
	cas := &invokeTestCase{args: wrapArgs(o), want: NewStr("foo").ToObject()}
	if err := runInvokeMethodTestCase(o.typ, "Error", cas); err != "" {
		t.Error(err)
	}
	// Also test the nil interface case.
	nilVal := reflect.ValueOf(func() error { return nil }).Call(nil)[0]
	if nilVal.Kind() != reflect.Interface {
		t.Fatalf("nilVal.Kind() = %v, want interface", nilVal.Kind())
	}
	if o := mustNotRaise(WrapNative(NewRootFrame(), nilVal)); o != None {
		t.Errorf("WrapNative(%v) = %v, want None", nilVal, o)
	}
}

func TestWrapNativeOpaque(t *testing.T) {
	type fooStruct struct{}
	foo := &fooStruct{}
	fooVal := reflect.ValueOf(foo)
	fun := wrapFuncForTest(func(f *Frame) *BaseException {
		o, raised := WrapNative(f, fooVal)
		if raised != nil {
			return raised
		}
		if !o.isInstance(nativeType) {
			t.Errorf("WrapNative(%v) = %v, want %v", fooVal, o, foo)
		} else if v := toNativeUnsafe(o).value; v.Type() != reflect.TypeOf(foo) {
			t.Errorf("WrapNative(%v) = %v, want %v", fooVal, v, foo)
		} else if got := v.Interface().(*fooStruct); got != foo {
			t.Errorf("WrapNative(%v) = %v, want %v", fooVal, got, foo)
		}
		return nil
	})
	if err := runInvokeTestCase(fun, &invokeTestCase{want: None}); err != "" {
		t.Error(err)
	}
}

func TestGetNativeTypeCaches(t *testing.T) {
	foo := []struct{}{}
	typ := getNativeType(reflect.TypeOf(foo))
	if got := getNativeType(reflect.TypeOf(foo)); got != typ {
		t.Errorf("getNativeType(foo) = %v, want %v", got, typ)
	}
}

func TestGetNativeTypeFunc(t *testing.T) {
	if typ := getNativeType(reflect.TypeOf(func() {})); !typ.isSubclass(nativeFuncType) {
		t.Errorf("getNativeType(func() {}) = %v, want a subclass of func", typ)
	} else if name := typ.Name(); name != "func()" {
		t.Errorf(`%v.__name__ == %q, want "func()"`, typ, name)
	}
}

type testNativeType struct {
	data int64
}

func (n *testNativeType) Int64() int64 {
	return n.data
}

func TestGetNativeTypeMethods(t *testing.T) {
	fun := wrapFuncForTest(func(f *Frame, o *Object) (*Object, *BaseException) {
		if raised := Assert(f, GetBool(o.isInstance(nativeType)).ToObject(), nil); raised != nil {
			return nil, raised
		}
		int64Method, raised := GetAttr(f, o.Type().ToObject(), NewStr("Int64"), nil)
		if raised != nil {
			return nil, raised
		}
		return int64Method.Call(f, []*Object{o}, nil)
	})
	cas := invokeTestCase{args: wrapArgs(&testNativeType{12}), want: NewInt(12).ToObject()}
	if err := runInvokeTestCase(fun, &cas); err != "" {
		t.Error(err)
	}
}

func TestGetNativeTypeSlice(t *testing.T) {
	if typ := getNativeType(reflect.TypeOf([]int{})); !typ.isSubclass(nativeSliceType) {
		t.Errorf("getNativeType([]int) = %v, want a subclass of slice", typ)
	} else if name := typ.Name(); name != "[]int" {
		t.Errorf(`%v.__name__ == %q, want "func()"`, typ, name)
	}
}

func TestGetNativeTypeTypedefs(t *testing.T) {
	type testBool bool
	type testInt int
	type testFloat float32
	type testString string
	cases := []struct {
		rtype reflect.Type
		super *Type
	}{
		{reflect.TypeOf(testBool(true)), BoolType},
		{reflect.TypeOf(testFloat(3.14)), FloatType},
		{reflect.TypeOf(testInt(42)), IntType},
		{reflect.TypeOf(testString("foo")), StrType},
	}
	for _, cas := range cases {
		if typ := getNativeType(cas.rtype); typ == cas.super || !typ.isSubclass(cas.super) {
			t.Errorf("getNativeType(%v) = %v, want a subclass of %v", cas.rtype, typ, cas.super)
		}
	}
}

func TestGetNativeTypeBigInts(t *testing.T) {
	cases := []struct {
		rtype reflect.Type
		typ   *Type
	}{
		{reflect.TypeOf(big.Int{}), LongType},
		{reflect.TypeOf((*big.Int)(nil)), LongType},
	}
	for _, cas := range cases {
		if typ := getNativeType(cas.rtype); typ != cas.typ {
			t.Errorf("getNativeType(%v) = %v, want %v", cas.rtype, typ, cas.typ)
		}
	}
}

func TestMaybeConvertValue(t *testing.T) {
	type fooStruct struct{}
	foo := &fooStruct{}
	fooNative := &native{Object{typ: nativeType}, reflect.ValueOf(&foo)}
	cases := []struct {
		o             *Object
		expectedRType reflect.Type
		want          interface{}
		wantExc       *BaseException
	}{
		{NewInt(42).ToObject(), reflect.TypeOf(int(0)), 42, nil},
		{NewFloat(0.5).ToObject(), reflect.TypeOf(float32(0)), float32(0.5), nil},
		{fooNative.ToObject(), reflect.TypeOf(&fooStruct{}), foo, nil},
		{None, reflect.TypeOf((*int)(nil)), (*int)(nil), nil},
		{None, reflect.TypeOf(""), nil, mustCreateException(TypeErrorType, "an string is required")},
	}
	for _, cas := range cases {
		fun := wrapFuncForTest(func(f *Frame) *BaseException {
			got, raised := maybeConvertValue(f, cas.o, cas.expectedRType)
			if raised != nil {
				return raised
			}
			if !got.IsValid() || !reflect.DeepEqual(got.Interface(), cas.want) {
				t.Errorf("maybeConvertValue(%v, %v) = %v, want %v", cas.o, nativeTypeName(cas.expectedRType), got, cas.want)
			}
			return nil
		})
		testCase := invokeTestCase{}
		if cas.wantExc != nil {
			testCase.wantExc = cas.wantExc
		} else {
			testCase.want = None
		}
		if err := runInvokeTestCase(fun, &testCase); err != "" {
			t.Error(err)
		}
	}
}

func TestNativeTypedefNative(t *testing.T) {
	fun := wrapFuncForTest(func(f *Frame, o *Object, wantType reflect.Type) (bool, *BaseException) {
		val, raised := ToNative(f, o)
		if raised != nil {
			return false, raised
		}
		return val.Type() == wantType, nil
	})
	type testBool bool
	testBoolRType := reflect.TypeOf(testBool(false))
	type testInt int
	testIntRType := reflect.TypeOf(testInt(0))
	cases := []invokeTestCase{
		{args: wrapArgs(mustNotRaise(getNativeType(testBoolRType).Call(NewRootFrame(), wrapArgs(true), nil)), testBoolRType), want: True.ToObject()},
		{args: wrapArgs(mustNotRaise(getNativeType(testIntRType).Call(NewRootFrame(), wrapArgs(123), nil)), testIntRType), want: True.ToObject()},
	}
	for _, cas := range cases {
		if err := runInvokeTestCase(fun, &cas); err != "" {
			t.Error(err)
		}
	}
}

func TestNativeTypeName(t *testing.T) {
	type fooStruct struct{}
	cases := []struct {
		rtype reflect.Type
		want  string
	}{
		{reflect.TypeOf([4]int{}), "[4]int"},
		{reflect.TypeOf(make(chan *string)), "chan *string"},
		{reflect.TypeOf(func() {}), "func()"},
		{reflect.TypeOf(func(int, string) {}), "func(int, string)"},
		{reflect.TypeOf(func() int { return 0 }), "func() int"},
		{reflect.TypeOf(func() (int, float32) { return 0, 0.0 }), "func() (int, float32)"},
		{reflect.TypeOf(map[int]fooStruct{}), "map[int]fooStruct"},
		{reflect.TypeOf(&fooStruct{}), "*fooStruct"},
		{reflect.TypeOf([]byte{}), "[]uint8"},
		{reflect.TypeOf(struct{}{}), "anonymous struct"},
	}
	for _, cas := range cases {
		if got := nativeTypeName(cas.rtype); got != cas.want {
			t.Errorf("nativeTypeName(%v) = %q, want %q", cas.rtype, got, cas.want)
		}
	}
}

func TestNewNativeFieldChecksInstanceType(t *testing.T) {
	f := NewRootFrame()

	// Given a native object
	native, raised := WrapNative(f, reflect.ValueOf(struct{ foo string }{}))
	if raised != nil {
		t.Fatal("Unexpected exception:", raised)
	}

	// When its field property is assigned to a different type
	property, raised := native.typ.Dict().GetItemString(f, "foo")
	if raised != nil {
		t.Fatal("Unexpected exception:", raised)
	}
	if raised := IntType.Dict().SetItemString(f, "foo", property); raised != nil {
		t.Fatal("Unexpected exception:", raised)
	}

	// And we try to access that property on an object of the new type
	_, raised = GetAttr(f, NewInt(1).ToObject(), NewStr("foo"), nil)

	// Then expect a TypeError was raised
	if raised == nil || raised.Type() != TypeErrorType {
		t.Fatal("Wanted TypeError; got:", raised)
	}
}

func TestNativeSliceGetItem(t *testing.T) {
	testRange := make([]int, 20)
	for i := 0; i < len(testRange); i++ {
		testRange[i] = i
	}
	badIndexType := newTestClass("badIndex", []*Type{ObjectType}, newStringDict(map[string]*Object{
		"__index__": newBuiltinFunction("__index__", func(f *Frame, _ Args, _ KWArgs) (*Object, *BaseException) {
			return nil, f.RaiseType(ValueErrorType, "wut")
		}).ToObject(),
	}))
	cases := []invokeTestCase{
		{args: wrapArgs(testRange, 0), want: NewInt(0).ToObject()},
		{args: wrapArgs(testRange, 19), want: NewInt(19).ToObject()},
		{args: wrapArgs([]struct{}{}, 101), wantExc: mustCreateException(IndexErrorType, "index out of range")},
		{args: wrapArgs([]bool{true}, None), wantExc: mustCreateException(TypeErrorType, "native slice indices must be integers, not NoneType")},
		{args: wrapArgs(testRange, newObject(badIndexType)), wantExc: mustCreateException(ValueErrorType, "wut")},
	}
	for _, cas := range cases {
		if err := runInvokeTestCase(wrapFuncForTest(GetItem), &cas); err != "" {
			t.Error(err)
		}
	}
}

func TestNativeSliceGetItemSlice(t *testing.T) {
	fun := wrapFuncForTest(func(f *Frame, o *Object, slice *Slice, want interface{}) *BaseException {
		item, raised := GetItem(f, o, slice.ToObject())
		if raised != nil {
			return raised
		}
		val, raised := ToNative(f, item)
		if raised != nil {
			return raised
		}
		v := val.Interface()
		msg := fmt.Sprintf("%v[%v] = %v, want %v", o, slice, v, want)
		return Assert(f, GetBool(reflect.DeepEqual(v, want)).ToObject(), NewStr(msg).ToObject())
	})
	type fooStruct struct {
		Bar int
	}
	cases := []invokeTestCase{
		{args: wrapArgs([]string{}, newTestSlice(50, 100), []string{}), want: None},
		{args: wrapArgs([]int{1, 2, 3, 4, 5}, newTestSlice(1, 3, None), []int{2, 3}), want: None},
		{args: wrapArgs([]fooStruct{fooStruct{1}, fooStruct{10}}, newTestSlice(-1, None, None), []fooStruct{fooStruct{10}}), want: None},
		{args: wrapArgs([]int{1, 2, 3, 4, 5}, newTestSlice(1, None, 2), []int{2, 4}), want: None},
		{args: wrapArgs([]float64{1.0, 2.0, 3.0, 4.0, 5.0}, newTestSlice(big.NewInt(1), None, 2), []float64{2.0, 4.0}), want: None},
		{args: wrapArgs([]string{"1", "2", "3", "4", "5"}, newTestSlice(1, big.NewInt(5), 2), []string{"2", "4"}), want: None},
		{args: wrapArgs([]int{1, 2, 3, 4, 5}, newTestSlice(1, None, big.NewInt(2)), []int{2, 4}), want: None},
		{args: wrapArgs([]int16{1, 2, 3, 4, 5}, newTestSlice(1.0, 3, None), None), wantExc: mustCreateException(TypeErrorType, errBadSliceIndex)},
		{args: wrapArgs([]byte{1, 2, 3}, newTestSlice(1, None, 0), None), wantExc: mustCreateException(ValueErrorType, "slice step cannot be zero")},
	}
	for _, cas := range cases {
		if err := runInvokeTestCase(fun, &cas); err != "" {
			t.Error(err)
		}
	}
}

func TestNativeSliceLen(t *testing.T) {
	cases := []invokeTestCase{
		{args: wrapArgs([]string{"foo", "bar"}), want: NewInt(2).ToObject()},
		{args: wrapArgs(make([]int, 100)), want: NewInt(100).ToObject()},
	}
	for _, cas := range cases {
		if err := runInvokeTestCase(wrapFuncForTest(Len), &cas); err != "" {
			t.Error(err)
		}
	}
}

func TestNativeSliceStrRepr(t *testing.T) {
	slice := make([]*Object, 2)
	o := mustNotRaise(WrapNative(NewRootFrame(), reflect.ValueOf(slice)))
	slice[0] = o
	slice[1] = NewStr("foo").ToObject()
	cases := []invokeTestCase{
		{args: wrapArgs([]string{"foo", "bar"}), want: NewStr("[]string{'foo', 'bar'}").ToObject()},
		{args: wrapArgs([]uint16{123}), want: NewStr("[]uint16{123}").ToObject()},
		{args: wrapArgs(o), want: NewStr("[]*Object{[]*Object{...}, 'foo'}").ToObject()},
	}
	for _, cas := range cases {
		if err := runInvokeTestCase(wrapFuncForTest(ToStr), &cas); err != "" {
			t.Error(err)
		}
		if err := runInvokeTestCase(wrapFuncForTest(Repr), &cas); err != "" {
			t.Error(err)
		}
	}
}

func TestNativeSliceSetItemSlice(t *testing.T) {
	fun := wrapFuncForTest(func(f *Frame, o, index, value *Object, want interface{}) *BaseException {
		originalStr := o.String()
		if raised := SetItem(f, o, index, value); raised != nil {
			return raised
		}
		val, raised := ToNative(f, o)
		if raised != nil {
			return raised
		}
		v := val.Interface()
		msg := fmt.Sprintf("%v[%v] = %v -> %v, want %v", originalStr, index, value, o, want)
		return Assert(f, GetBool(reflect.DeepEqual(v, want)).ToObject(), NewStr(msg).ToObject())
	})
	type fooStruct struct {
		bar []int
	}
	foo := fooStruct{[]int{1, 2, 3}}
	bar := mustNotRaise(WrapNative(NewRootFrame(), reflect.ValueOf(foo).Field(0)))
	cases := []invokeTestCase{
		{args: wrapArgs([]string{"foo", "bar"}, 1, "baz", []string{"foo", "baz"}), want: None},
		{args: wrapArgs([]uint16{1, 2, 3}, newTestSlice(1), newTestList(4), []uint16{4, 2, 3}), want: None},
		{args: wrapArgs([]int{1, 2, 4, 5}, newTestSlice(1, None, 2), newTestTuple(10, 20), []int{1, 10, 4, 20}), want: None},
		{args: wrapArgs([]float64{}, newTestSlice(4, 8, 0), NewList(), None), wantExc: mustCreateException(ValueErrorType, "slice step cannot be zero")},
		{args: wrapArgs([]string{"foo", "bar"}, -100, None, None), wantExc: mustCreateException(IndexErrorType, "index out of range")},
		{args: wrapArgs([]int{}, 101, None, None), wantExc: mustCreateException(IndexErrorType, "index out of range")},
		{args: wrapArgs([]bool{true}, None, false, None), wantExc: mustCreateException(TypeErrorType, "native slice indices must be integers, not NoneType")},
		{args: wrapArgs([]int8{1, 2, 3}, newTestSlice(0), []int8{0}, []int8{0, 1, 2, 3}), wantExc: mustCreateException(ValueErrorType, "attempt to assign sequence of size 1 to slice of size 0")},
		{args: wrapArgs([]int{1, 2, 3}, newTestSlice(2, None), newTestList("foo"), None), wantExc: mustCreateException(TypeErrorType, "an int is required")},
		{args: wrapArgs(bar, 1, 42, None), wantExc: mustCreateException(TypeErrorType, "cannot set slice element")},
		{args: wrapArgs(bar, newTestSlice(1), newTestList(42), None), wantExc: mustCreateException(TypeErrorType, "cannot set slice element")},
		{args: wrapArgs([]string{"foo", "bar"}, 1, 123.0, None), wantExc: mustCreateException(TypeErrorType, "an string is required")},
		{args: wrapArgs([]string{"foo", "bar"}, 1, 123.0, None), wantExc: mustCreateException(TypeErrorType, "an string is required")},
	}
	for _, cas := range cases {
		if err := runInvokeTestCase(fun, &cas); err != "" {
			t.Error(err)
		}
	}
}

func TestNativeStructFieldGet(t *testing.T) {
	fun := wrapFuncForTest(func(f *Frame, o *Object, attr *Str) (*Object, *BaseException) {
		return GetAttr(f, o, attr, nil)
	})
	type fooStruct struct {
		bar int
		Baz float64
	}
	cases := []invokeTestCase{
		{args: wrapArgs(fooStruct{bar: 1}, "bar"), want: NewInt(1).ToObject()},
		{args: wrapArgs(&fooStruct{Baz: 3.14}, "Baz"), want: NewFloat(3.14).ToObject()},
		{args: wrapArgs(fooStruct{}, "qux"), wantExc: mustCreateException(AttributeErrorType, `'fooStruct' object has no attribute 'qux'`)},
	}
	for _, cas := range cases {
		if err := runInvokeTestCase(fun, &cas); err != "" {
			t.Error(err)
		}
	}
}

func TestNativeStructFieldSet(t *testing.T) {
	fun := wrapFuncForTest(func(f *Frame, o *Object, attr *Str, value *Object) (*Object, *BaseException) {
		if raised := SetAttr(f, o, attr, value); raised != nil {
			return nil, raised
		}
		return GetAttr(f, o, attr, nil)
	})
	type fooStruct struct {
		bar int
		Baz float64
	}
	cases := []invokeTestCase{
		{args: wrapArgs(&fooStruct{}, "Baz", 1.5), want: NewFloat(1.5).ToObject()},
		{args: wrapArgs(fooStruct{}, "bar", 123), wantExc: mustCreateException(TypeErrorType, `cannot set field 'bar' of type 'fooStruct'`)},
		{args: wrapArgs(fooStruct{}, "qux", "abc"), wantExc: mustCreateException(AttributeErrorType, `'fooStruct' has no attribute 'qux'`)},
		{args: wrapArgs(&fooStruct{}, "Baz", "abc"), wantExc: mustCreateException(TypeErrorType, "an float64 is required")},
	}
	for _, cas := range cases {
		if err := runInvokeTestCase(fun, &cas); err != "" {
			t.Error(err)
		}
	}
}

func wrapArgs(elems ...interface{}) Args {
	f := NewRootFrame()
	argc := len(elems)
	result := make(Args, argc, argc)
	var raised *BaseException
	for i, elem := range elems {
		if result[i], raised = WrapNative(f, reflect.ValueOf(elem)); raised != nil {
			panic(raised)
		}
	}
	return result
}

func wrapKWArgs(elems ...interface{}) KWArgs {
	if len(elems)%2 != 0 {
		panic("invalid kwargs")
	}
	numItems := len(elems) / 2
	kwargs := make(KWArgs, numItems, numItems)
	f := NewRootFrame()
	for i := 0; i < numItems; i++ {
		kwargs[i].Name = elems[i*2].(string)
		kwargs[i].Value = mustNotRaise(WrapNative(f, reflect.ValueOf(elems[i*2+1])))
	}
	return kwargs
}