Merge pull request #13 from cpunion/tests

Tests

Author: cpunion

dict.go

@@ -18,9 +18,7 @@ func newDict(obj *PyObject) Dict {
 }
 
 func DictFromPairs(pairs ...any) Dict {
-	if len(pairs)%2 != 0 {
-		panic("DictFromPairs requires an even number of arguments")
-	}
+	check(len(pairs)%2 == 0, "DictFromPairs requires an even number of arguments")
 	dict := newDict(C.PyDict_New())
 	for i := 0; i < len(pairs); i += 2 {
 		key := From(pairs[i])
@@ -62,9 +60,7 @@ func (d Dict) SetString(key string, value Objecter) {
 	ckey := AllocCStr(key)
 	r := C.PyDict_SetItemString(d.obj, ckey, valueObj)
 	C.free(unsafe.Pointer(ckey))
-	if r != 0 {
-		panic(fmt.Errorf("failed to set item string: %v", r))
-	}
+	check(r == 0, fmt.Sprintf("failed to set item string: %v", r))
 }
 
 func (d Dict) GetString(key string) Object {
@@ -81,9 +77,7 @@ func (d Dict) Del(key Objecter) {
 
 func (d Dict) ForEach(fn func(key, value Object)) {
 	items := C.PyDict_Items(d.obj)
-	if items == nil {
-		panic(fmt.Errorf("failed to get items of dict"))
-	}
+	check(items != nil, "failed to get items of dict")
 	defer C.Py_DecRef(items)
 	iter := C.PyObject_GetIter(items)
 	for {

function.go

@@ -74,7 +74,8 @@ func (f Func) Call(args ...any) Object {
 		for i, arg := range args {
 			obj := From(arg).Obj()
 			C.Py_IncRef(obj)
-			C.PyTuple_SetItem(argsTuple, C.Py_ssize_t(i), obj)
+			r := C.PyTuple_SetItem(argsTuple, C.Py_ssize_t(i), obj)
+			check(r == 0, fmt.Sprintf("failed to set item %d in tuple", i))
 		}
 		return newObject(C.PyObject_CallObject(f.obj, argsTuple))
 	}
@@ -471,9 +472,7 @@ func getMembers(t reflect.Type, methods map[uint]*slotMeta) (members *C.PyMember
 func AddType[T any](m Module, init any, name string, doc string) Object {
 	wrapper := wrapperType[T]{}
 	ty := reflect.TypeOf(wrapper.v)
-	if ty.Kind() != reflect.Struct {
-		panic("AddType: t must be a struct")
-	}
+	check(ty.Kind() == reflect.Struct, "AddType: t must be a struct")
 
 	meta := &typeMeta{
 		typ:     ty,
@@ -517,27 +516,21 @@ func AddType[T any](m Module, init any, name string, doc string) Object {
 	}
 
 	typeObj := C.PyType_FromSpec(spec)
-	if typeObj == nil {
-		panic(fmt.Sprintf("Failed to create type %s", name))
-	}
+	check(typeObj != nil, fmt.Sprintf("Failed to create type %s", name))
 
 	typeMetaMap[typeObj] = meta
 	pyTypeMap[ty] = typeObj
 
-	if C.PyModule_AddObject(m.obj, C.CString(name), typeObj) < 0 {
-		C.Py_DecRef(typeObj)
-		panic(fmt.Sprintf("Failed to add type %s to module", name))
-	}
+	r := C.PyModule_AddObjectRef(m.obj, C.CString(name), typeObj)
+	check(r == 0, fmt.Sprintf("Failed to add type %s to module", name))
 
 	return newObject(typeObj)
 }
 
 func (m Module) AddMethod(name string, fn any, doc string) Func {
 	v := reflect.ValueOf(fn)
 	t := v.Type()
-	if t.Kind() != reflect.Func {
-		panic("AddFunction: fn must be a function")
-	}
+	check(t.Kind() == reflect.Func, "AddFunction: fn must be a function")
 
 	if name == "" {
 		name = runtime.FuncForPC(v.Pointer()).Name()
@@ -583,14 +576,10 @@ func (m Module) AddMethod(name string, fn any, doc string) Func {
 	}
 
 	pyFunc := C.PyCFunction_New(def, m.obj)
-	if pyFunc == nil {
-		panic(fmt.Sprintf("Failed to create function %s", name))
-	}
+	check(pyFunc != nil, fmt.Sprintf("Failed to create function %s", name))
 
-	if C.PyModule_AddObject(m.obj, cName, pyFunc) < 0 {
-		C.Py_DecRef(pyFunc)
-		panic(fmt.Sprintf("Failed to add function %s to module", name))
-	}
+	r := C.PyModule_AddObjectRef(m.obj, cName, pyFunc)
+	check(r == 0, fmt.Sprintf("Failed to add function %s to module", name))
 
 	return newFunc(pyFunc)
 }

list.go

@@ -4,6 +4,7 @@ package gp
 #include <Python.h>
 */
 import "C"
+import "fmt"
 
 type List struct {
 	Object
@@ -31,13 +32,15 @@ func (l List) GetItem(index int) Object {
 func (l List) SetItem(index int, item Objecter) {
 	itemObj := item.Obj()
 	C.Py_IncRef(itemObj)
-	C.PyList_SetItem(l.obj, C.Py_ssize_t(index), itemObj)
+	r := C.PyList_SetItem(l.obj, C.Py_ssize_t(index), itemObj)
+	check(r == 0, fmt.Sprintf("failed to set item %d in list", index))
 }
 
 func (l List) Len() int {
 	return int(C.PyList_Size(l.obj))
 }
 
 func (l List) Append(obj Objecter) {
-	C.PyList_Append(l.obj, obj.Obj())
+	r := C.PyList_Append(l.obj, obj.Obj())
+	check(r == 0, "failed to append item to list")
 }

object.go

@@ -117,7 +117,9 @@ func (obj Object) AttrFunc(name string) Func {
 
 func (obj Object) SetAttr(name string, value any) {
 	cname := AllocCStr(name)
-	C.PyObject_SetAttrString(obj.obj, cname, From(value).obj)
+	r := C.PyObject_SetAttrString(obj.obj, cname, From(value).obj)
+	C.PyErr_Print()
+	check(r == 0, fmt.Sprintf("failed to set attribute %s", name))
 	C.free(unsafe.Pointer(cname))
 }
 
@@ -294,38 +296,21 @@ func ToValue(obj Object, v reflect.Value) bool {
 	if !v.IsValid() || !v.CanSet() {
 		return false
 	}
+
 	switch v.Kind() {
-	case reflect.Int8:
-		fallthrough
-	case reflect.Int16:
-		fallthrough
-	case reflect.Int32:
-		fallthrough
-	case reflect.Int64:
-		fallthrough
-	case reflect.Int:
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
 		if obj.IsLong() {
 			v.SetInt(Cast[Long](obj).Int64())
 		} else {
 			return false
 		}
-	case reflect.Uint8:
-		fallthrough
-	case reflect.Uint16:
-		fallthrough
-	case reflect.Uint32:
-		fallthrough
-	case reflect.Uint64:
-		fallthrough
-	case reflect.Uint:
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
 		if obj.IsLong() {
 			v.SetUint(Cast[Long](obj).Uint64())
 		} else {
 			return false
 		}
-	case reflect.Float32:
-		fallthrough
-	case reflect.Float64:
+	case reflect.Float32, reflect.Float64:
 		if obj.IsFloat() || obj.IsLong() {
 			v.SetFloat(Cast[Float](obj).Float64())
 		} else {
@@ -407,62 +392,6 @@ func ToValue(obj Object, v reflect.Value) bool {
 	return true
 }
 
-func To[T any](obj Object) (ret T) {
-	switch any(ret).(type) {
-	case int8:
-		return any(int8(Cast[Long](obj).Int64())).(T)
-	case int16:
-		return any(int16(Cast[Long](obj).Int64())).(T)
-	case int32:
-		return any(int32(Cast[Long](obj).Int64())).(T)
-	case int64:
-		return any(Cast[Long](obj).Int64()).(T)
-	case int:
-		return any(int(Cast[Long](obj).Int64())).(T)
-	case uint8:
-		return any(uint8(Cast[Long](obj).Uint64())).(T)
-	case uint16:
-		return any(uint16(Cast[Long](obj).Uint64())).(T)
-	case uint32:
-		return any(uint32(Cast[Long](obj).Uint64())).(T)
-	case uint64:
-		return any(Cast[Long](obj).Uint64()).(T)
-	case uint:
-		return any(uint(Cast[Long](obj).Uint64())).(T)
-	case float32:
-		return any(float32(Cast[Float](obj).Float64())).(T)
-	case float64:
-		return any(Cast[Float](obj).Float64()).(T)
-	case complex64:
-		return any(complex64(Cast[Complex](obj).Complex128())).(T)
-	case complex128:
-		return any(Cast[Complex](obj).Complex128()).(T)
-	case string:
-		return any(Cast[Str](obj).String()).(T)
-	case bool:
-		return any(Cast[Bool](obj).Bool()).(T)
-	case []byte:
-		return any(Cast[Bytes](obj).Bytes()).(T)
-	default:
-		v := reflect.ValueOf(ret)
-		switch v.Kind() {
-		case reflect.Slice:
-			return toSlice[T](obj, v)
-		}
-		panic(fmt.Errorf("unsupported type conversion from Python object to %T", ret))
-	}
-}
-
-func toSlice[T any](obj Object, v reflect.Value) T {
-	list := Cast[List](obj)
-	l := list.Len()
-	v = reflect.MakeSlice(v.Type(), l, l)
-	for i := 0; i < l; i++ {
-		v.Index(i).Set(reflect.ValueOf(To[T](list.GetItem(i))))
-	}
-	return v.Interface().(T)
-}
-
 func fromSlice(v reflect.Value) List {
 	l := v.Len()
 	list := newList(C.PyList_New(C.Py_ssize_t(l)))

object_test.go

@@ -1,6 +1,7 @@
 package gp
 
 import (
+	"bytes"
 	"reflect"
 	"testing"
 )
@@ -377,6 +378,56 @@ def make_tuple():
 			t.Error("Object.Obj() should return nil for nil object")
 		}
 	}()
+
+	func() {
+		// Test AttrBytes
+		builtins := ImportModule("types")
+		objType := builtins.AttrFunc("SimpleNamespace")
+		obj := objType.Call()
+
+		// Create a simple object with bytes attribute
+		obj.SetAttr("bytes_val", From([]byte("hello")))
+
+		if !bytes.Equal(obj.AttrBytes("bytes_val").Bytes(), []byte("hello")) {
+			t.Error("AttrBytes failed")
+		}
+	}()
+
+	func() {
+		// Test Object.Call with kwargs
+		pyCode := `
+def test_func(a, b=10, c="default"):
+    return (a, b, c)
+`
+		locals := MakeDict(nil)
+		globals := MakeDict(nil)
+		globals.Set(MakeStr("__builtins__"), builtins.Object)
+
+		code, err := CompileString(pyCode, "<string>", FileInput)
+		if err != nil {
+			t.Errorf("CompileString() error = %v", err)
+		}
+		EvalCode(code, globals, locals)
+
+		testFunc := locals.Get(MakeStr("test_func"))
+
+		// Call with positional and keyword arguments
+		result := testFunc.Call("__call__", 1, KwArgs{
+			"b": 20,
+			"c": "custom",
+		})
+
+		tuple := result.AsTuple()
+		if tuple.Get(0).AsLong().Int64() != 1 {
+			t.Error("Wrong value for first argument")
+		}
+		if tuple.Get(1).AsLong().Int64() != 20 {
+			t.Error("Wrong value for keyword argument b")
+		}
+		if tuple.Get(2).AsStr().String() != "custom" {
+			t.Error("Wrong value for keyword argument c")
+		}
+	}()
 }
 
 func TestToValue(t *testing.T) {
@@ -517,3 +568,48 @@ func TestToValue(t *testing.T) {
 		}
 	}()
 }
+
+func TestFromSpecialCases(t *testing.T) {
+	setupTest(t)
+
+	func() {
+		// Test From with uint values
+		tests := []struct {
+			input    uint
+			expected uint64
+		}{
+			{0, 0},
+			{42, 42},
+			{^uint(0), ^uint64(0)}, // maximum uint value
+		}
+
+		for _, tt := range tests {
+			obj := From(tt.input)
+			if !obj.IsLong() {
+				t.Errorf("From(uint) did not create Long object")
+			}
+			if got := obj.AsLong().Uint64(); got != tt.expected {
+				t.Errorf("From(%d) = %d, want %d", tt.input, got, tt.expected)
+			}
+		}
+	}()
+
+	func() {
+		// Test From with Object.Obj()
+		original := From(42)
+		obj := From(original.Obj())
+
+		if !obj.IsLong() {
+			t.Error("From(Object.Obj()) did not create Long object")
+		}
+		if got := obj.AsLong().Int64(); got != 42 {
+			t.Errorf("From(Object.Obj()) = %d, want 42", got)
+		}
+
+		// Test that the new object is independent
+		original = From(100)
+		if got := obj.AsLong().Int64(); got != 42 {
+			t.Errorf("Object was not independent, got %d after modifying original", got)
+		}
+	}()
+}

python.go

@@ -21,7 +21,8 @@ func Initialize() {
 }
 
 func Finalize() {
-	C.Py_FinalizeEx()
+	r := C.Py_FinalizeEx()
+	check(r == 0, "failed to finalize Python")
 	typeMetaMap = make(map[*C.PyObject]*typeMeta)
 	pyTypeMap = make(map[reflect.Type]*C.PyObject)
 }
@@ -112,3 +113,11 @@ func RunString(code string) error {
 	}
 	return nil
 }
+
+// ----------------------------------------------------------------------------
+
+func check(b bool, msg string) {
+	if !b {
+		panic(msg)
+	}
+}