add test for mix of floats and int arguments in callback (#171)

This test makes sure that int and float arguments take different registers

commit: a91fd92eea51594b980f162268aa3c22874e24a0
author: TotallyGamerJet · 3y ago · 2023-10-03 11:57 UTC
committer: GitHub · 3y ago · 2023-10-03 11:57 UTC
parent: 5b7ae97
signature: GPG Unverified4AEE18F83AFDEB23 The key is unknown

2 files · +23 -4

M callback_test.go +22 -3


@@ -58,7 +58,8 @@ func TestNewCallbackFloat64(t *testing.T) {
58	58		var cbTotal int
59	59		var cbTotalF float64
60	60		imp := purego.NewCallback(func(a1, a2, a3, a4, a5, a6, a7, a8, a9 int,
61		-	f1, f2, f3, f4, f5, f6, f7, f8 float64) {
	61	+	f1, f2, f3, f4, f5, f6, f7, f8 float64,
	62	+	) {
62	63		cbTotal = a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9
63	64		cbTotalF = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8
64	65		})

@@ -76,6 +77,24 @@ func TestNewCallbackFloat64(t *testing.T) {
76	77		}
77	78		}
78	79
	80	+	func TestNewCallbackFloat64AndIntMix(t *testing.T) {
	81	+	// This tests interleaving float and integer arguments to NewCallback
	82	+	const (
	83	+	expectCbTotal = 54.75
	84	+	)
	85	+	var cbTotal float64
	86	+	imp := purego.NewCallback(func(a1, a2 float64, a3, a4, a5 int, a6, a7, a8 float64, a9 int) {
	87	+	cbTotal = a1 + a2 + float64(a3) + float64(a4) + float64(a5) + a6 + a7 + a8 + float64(a9)
	88	+	})
	89	+	var fn func(a1, a2 float64, a3, a4, a5 int, a6, a7, a8 float64, a9 int)
	90	+	purego.RegisterFunc(&fn, imp)
	91	+	fn(1.25, 3.25, 4, 5, 6, 7.5, 8.25, 9.5, 10)
	92	+
	93	+	if cbTotal != expectCbTotal {
	94	+	t.Errorf("cbTotal not correct got %f but wanted %f", cbTotal, expectCbTotal)
	95	+	}
	96	+	}
	97	+
79	98		func TestNewCallbackFloat32(t *testing.T) {
80	99		// This tests the maximum number of float32 arguments a function to NewCallback can take
81	100		const (

@@ -85,7 +104,8 @@ func TestNewCallbackFloat32(t *testing.T) {
85	104		var cbTotal int
86	105		var cbTotalF float32
87	106		imp := purego.NewCallback(func(a1, a2, a3, a4, a5, a6, a7, a8 int,
88		-	f1, f2, f3, f4, f5, f6, f7, f8, f9 float32) {
	107	+	f1, f2, f3, f4, f5, f6, f7, f8, f9 float32,
	108	+	) {
89	109		cbTotal = a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8
90	110		cbTotalF = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9
91	111		})

@@ -114,7 +134,6 @@ func TestNewCallbackFloat32AndFloat64(t *testing.T) {
114	134		imp := purego.NewCallback(func(f1, f2, f3 float32, f4, f5, f6 float64, f7, f8, f9 float32) {
115	135		cbTotalF32 = f1 + f2 + f3 + f7 + f8 + f9
116	136		cbTotalF64 = f4 + f5 + f6
117		-
118	137		})
119	138		var fn func(f1, f2, f3 float32, f4, f5, f6 float64, f7, f8, f9 float32)
120	139		purego.RegisterFunc(&fn, imp)

 	var cbTotal int
 	var cbTotalF float64
 	imp := purego.NewCallback(func(a1, a2, a3, a4, a5, a6, a7, a8, a9 int,
-		f1, f2, f3, f4, f5, f6, f7, f8 float64) {
+		f1, f2, f3, f4, f5, f6, f7, f8 float64,
+	) {
 		cbTotal = a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9
 		cbTotalF = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8
 	})
 	}
 }
+func TestNewCallbackFloat64AndIntMix(t *testing.T) {
+	// This tests interleaving float and integer arguments to NewCallback
+	const (
+		expectCbTotal = 54.75
+	)
+	var cbTotal float64
+	imp := purego.NewCallback(func(a1, a2 float64, a3, a4, a5 int, a6, a7, a8 float64, a9 int) {
+		cbTotal = a1 + a2 + float64(a3) + float64(a4) + float64(a5) + a6 + a7 + a8 + float64(a9)
+	})
+	var fn func(a1, a2 float64, a3, a4, a5 int, a6, a7, a8 float64, a9 int)
+	purego.RegisterFunc(&fn, imp)
+	fn(1.25, 3.25, 4, 5, 6, 7.5, 8.25, 9.5, 10)
+	if cbTotal != expectCbTotal {
+		t.Errorf("cbTotal not correct got %f but wanted %f", cbTotal, expectCbTotal)
+	}
+}
 func TestNewCallbackFloat32(t *testing.T) {
 	// This tests the maximum number of float32 arguments a function to NewCallback can take
 	const (
 	var cbTotal int
 	var cbTotalF float32
 	imp := purego.NewCallback(func(a1, a2, a3, a4, a5, a6, a7, a8 int,
-		f1, f2, f3, f4, f5, f6, f7, f8, f9 float32) {
+		f1, f2, f3, f4, f5, f6, f7, f8, f9 float32,
+	) {
 		cbTotal = a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8
 		cbTotalF = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9
 	})
 	imp := purego.NewCallback(func(f1, f2, f3 float32, f4, f5, f6 float64, f7, f8, f9 float32) {
 		cbTotalF32 = f1 + f2 + f3 + f7 + f8 + f9
 		cbTotalF64 = f4 + f5 + f6
 	})
 	var fn func(f1, f2, f3 float32, f4, f5, f6 float64, f7, f8, f9 float32)
 	purego.RegisterFunc(&fn, imp)

M func.go +1 -1


@@ -245,7 +245,7 @@ func RegisterFunc(fptr interface{}, cfn uintptr) {
245	245		runtime_cgocall(syscall9XABI0, unsafe.Pointer(&syscall))
246	246		r1, r2 = syscall.r1, syscall.r2
247	247		} else {
248		-	// This is a fallback for amd64, 386, and arm. Note this may not support floats
	248	+	// This is a fallback for Windows amd64, 386, and arm. Note this may not support floats
249	249		r1, r2, _ = syscall_syscall9X(cfn, sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4], sysargs[5], sysargs[6], sysargs[7], sysargs[8])
250	250		}
251	251		if ty.NumOut() == 0 {


@@ -245,7 +245,7 @@ func RegisterFunc(fptr interface{}, cfn uintptr) {
245		runtime_cgocall(syscall9XABI0, unsafe.Pointer(&syscall))	245		runtime_cgocall(syscall9XABI0, unsafe.Pointer(&syscall))
246		r1, r2 = syscall.r1, syscall.r2	246		r1, r2 = syscall.r1, syscall.r2
247		} else {	247		} else {
248	-	// This is a fallback for amd64, 386, and arm. Note this may not support floats	248	+	// This is a fallback for Windows amd64, 386, and arm. Note this may not support floats
249		r1, r2, _ = syscall_syscall9X(cfn, sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4], sysargs[5], sysargs[6], sysargs[7], sysargs[8])	249		r1, r2, _ = syscall_syscall9X(cfn, sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4], sysargs[5], sysargs[6], sysargs[7], sysargs[8])
250		}	250		}
251		if ty.NumOut() == 0 {	251		if ty.NumOut() == 0 {