add Tuple tests

Author: cpunion

tuple_test.go

@@ -0,0 +1,173 @@
+package gp
+
+import (
+	"testing"
+)
+
+func TestTupleCreation(t *testing.T) {
+	// Test empty tuple
+	empty := MakeTupleWithLen(0)
+	if empty.Len() != 0 {
+		t.Errorf("Expected empty tuple length 0, got %d", empty.Len())
+	}
+
+	// Test tuple with values
+	tuple := MakeTuple(42, "hello", 3.14)
+	if tuple.Len() != 3 {
+		t.Errorf("Expected tuple length 3, got %d", tuple.Len())
+	}
+}
+
+func TestTupleGetSet(t *testing.T) {
+	tuple := MakeTupleWithLen(2)
+
+	// Test setting and getting values
+	tuple.Set(0, From(123))
+	tuple.Set(1, From("test"))
+
+	if val := tuple.Get(0).AsLong().Int64(); val != 123 {
+		t.Errorf("Expected 123, got %d", val)
+	}
+	if val := tuple.Get(1).AsStr().String(); val != "test" {
+		t.Errorf("Expected 'test', got %s", val)
+	}
+}
+
+func TestTupleSlice(t *testing.T) {
+	tuple := MakeTuple(1, 2, 3, 4, 5)
+
+	// Test slicing
+	slice := tuple.Slice(1, 4)
+	if slice.Len() != 3 {
+		t.Errorf("Expected slice length 3, got %d", slice.Len())
+	}
+
+	expected := []int64{2, 3, 4}
+	for i := 0; i < slice.Len(); i++ {
+		if val := slice.Get(i).AsLong().Int64(); val != expected[i] {
+			t.Errorf("At index %d: expected %d, got %d", i, expected[i], val)
+		}
+	}
+}
+
+func TestTupleParseArgs(t *testing.T) {
+	tuple := MakeTuple(42, "hello", 3.14, true)
+
+	var (
+		intVal   int
+		strVal   string
+		floatVal float64
+		boolVal  bool
+		extraVal int // This shouldn't get set
+	)
+
+	// Test successful parsing
+	success := tuple.ParseArgs(&intVal, &strVal, &floatVal, &boolVal)
+	if !success {
+		t.Error("ParseArgs failed unexpectedly")
+	}
+
+	if intVal != 42 {
+		t.Errorf("Expected int 42, got %d", intVal)
+	}
+	if strVal != "hello" {
+		t.Errorf("Expected string 'hello', got %s", strVal)
+	}
+	if floatVal != 3.14 {
+		t.Errorf("Expected float 3.14, got %f", floatVal)
+	}
+	if !boolVal {
+		t.Errorf("Expected bool true, got false")
+	}
+
+	// Test parsing with too many arguments
+	success = tuple.ParseArgs(&intVal, &strVal, &floatVal, &boolVal, &extraVal)
+	if success {
+		t.Error("ParseArgs should have failed with too many arguments")
+	}
+
+	// Test parsing with invalid type
+	var invalidPtr *testing.T
+	success = tuple.ParseArgs(&invalidPtr)
+	if success {
+		t.Error("ParseArgs should have failed with invalid type")
+	}
+}
+
+func TestTupleParseArgsTypes(t *testing.T) {
+	// Test all supported numeric types
+	tuple := MakeTuple(42, 42, 42, 42, 42, 42, 42, 42, 42, 42)
+
+	var (
+		intVal    int
+		int8Val   int8
+		int16Val  int16
+		int32Val  int32
+		int64Val  int64
+		uintVal   uint
+		uint8Val  uint8
+		uint16Val uint16
+		uint32Val uint32
+		uint64Val uint64
+	)
+
+	success := tuple.ParseArgs(
+		&intVal, &int8Val, &int16Val, &int32Val, &int64Val,
+		&uintVal, &uint8Val, &uint16Val, &uint32Val, &uint64Val,
+	)
+
+	if !success {
+		t.Error("ParseArgs failed for numeric types")
+	}
+
+	// Test floating point types
+	floatTuple := MakeTuple(3.14, 3.14)
+	var float32Val float32
+	var float64Val float64
+
+	success = floatTuple.ParseArgs(&float32Val, &float64Val)
+	if !success {
+		t.Error("ParseArgs failed for floating point types")
+	}
+
+	// Test complex types
+	complexTuple := MakeTuple(complex(1, 2), complex(3, 4))
+	var complex64Val complex64
+	var complex128Val complex128
+
+	success = complexTuple.ParseArgs(&complex64Val, &complex128Val)
+	if !success {
+		t.Error("ParseArgs failed for complex types")
+	}
+
+	// Test string and bytes
+	strTuple := MakeTuple("hello")
+	var strVal string
+	var bytesVal []byte
+	var objVal Object
+	var pyObj *PyObject
+
+	success = strTuple.ParseArgs(&strVal)
+	if !success || strVal != "hello" {
+		t.Error("ParseArgs failed for string type")
+	}
+
+	success = strTuple.ParseArgs(&bytesVal)
+	if !success || string(bytesVal) != "hello" {
+		t.Error("ParseArgs failed for bytes type")
+	}
+
+	success = strTuple.ParseArgs(&objVal)
+	if !success || !objVal.IsStr() {
+		t.Error("ParseArgs failed for object type")
+	}
+
+	success = strTuple.ParseArgs(&pyObj)
+	if !success || pyObj == nil {
+		t.Error("ParseArgs failed for PyObject type")
+	}
+	str := FromPy(pyObj)
+	if !str.IsStr() || str.String() != "hello" {
+		t.Error("FromPy returned non-string object")
+	}
+}