ory-client 1.2.9 → 1.2.11

data/vendor/bundle/ruby/2.5.0/gems/ffi-1.16.3/ext/ffi_c/libffi/testsuite/libffi.closures/cls_dbls_struct.c

@@ -0,0 +1,68 @@
+/* Area:		ffi_call, closure_call
+   Purpose:		Check double arguments in structs.
+   Limitations:	none.
+   PR:			none.
+   Originator:	Blake Chaffin 6/23/2007	*/
+
+/* { dg-do run } */
+
+#include "ffitest.h"
+
+typedef struct Dbls {
+	double x;
+	double y;
+} Dbls;
+
+void
+closure_test_fn(Dbls p)
+{
+	printf("%.1f %.1f\n", p.x, p.y);
+	CHECK(p.x == 1);
+	CHECK(p.y == 2);
+}
+
+void
+closure_test_gn(ffi_cif* cif __UNUSED__, void* resp __UNUSED__,
+		void** args, void* userdata __UNUSED__)
+{
+	closure_test_fn(*(Dbls*)args[0]);
+}
+
+int main(int argc __UNUSED__, char** argv __UNUSED__)
+{
+	ffi_cif cif;
+
+        void *code;
+	ffi_closure*	pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+	ffi_type*		cl_arg_types[1];
+
+	ffi_type	ts1_type;
+	ffi_type*	ts1_type_elements[4];
+
+	Dbls arg = { 1.0, 2.0 };
+
+	ts1_type.size = 0;
+	ts1_type.alignment = 0;
+	ts1_type.type = FFI_TYPE_STRUCT;
+	ts1_type.elements = ts1_type_elements;
+
+	ts1_type_elements[0] = &ffi_type_double;
+	ts1_type_elements[1] = &ffi_type_double;
+	ts1_type_elements[2] = NULL;
+
+	cl_arg_types[0] = &ts1_type;
+
+	/* Initialize the cif */
+	CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1,
+				 &ffi_type_void, cl_arg_types) == FFI_OK);
+
+	CHECK(ffi_prep_closure_loc(pcl, &cif, closure_test_gn, NULL, code) == FFI_OK);
+
+	((void (*)(Dbls))(code))(arg);
+	/* { dg-output "1.0 2.0" } */
+
+	closure_test_fn(arg);
+	/* { dg-output "\n1.0 2.0" } */
+
+	return 0;
+}

data/vendor/bundle/ruby/2.5.0/gems/ffi-1.16.3/ext/ffi_c/libffi/testsuite/libffi.closures/cls_double_va.c

@@ -0,0 +1,69 @@
+/* Area:		ffi_call, closure_call
+   Purpose:		Test doubles passed in variable argument lists.
+   Limitations:	none.
+   PR:			none.
+   Originator:	Blake Chaffin 6/6/2007	 */
+
+/* { dg-do run { xfail strongarm*-*-* xscale*-*-* } } */
+/* { dg-output "" { xfail avr32*-*-* } } */
+/* { dg-output "" { xfail mips-sgi-irix6* } } PR libffi/46660 */
+
+#include "ffitest.h"
+
+#define BUF_SIZE 50
+static char buffer[BUF_SIZE];
+
+static void
+cls_double_va_fn(ffi_cif* cif __UNUSED__, void* resp,
+		 void** args, void* userdata __UNUSED__)
+{
+	char*	format		= *(char**)args[0];
+	double	doubleValue	= *(double*)args[1];
+
+	*(ffi_arg*)resp = printf(format, doubleValue);
+	CHECK(*(ffi_arg*)resp == 4);
+	snprintf(buffer, BUF_SIZE, format, doubleValue);
+	CHECK(strncmp(buffer, "7.0\n", 4) == 0);
+}
+
+int main (void)
+{
+	ffi_cif cif;
+        void *code;
+	ffi_closure *pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+	void* args[3];
+	ffi_type* arg_types[3];
+
+	char*	format		= "%.1f\n";
+	double	doubleArg	= 7;
+	ffi_arg	res			= 0;
+
+	arg_types[0] = &ffi_type_pointer;
+	arg_types[1] = &ffi_type_double;
+	arg_types[2] = NULL;
+
+	/* This printf call is variadic */
+	CHECK(ffi_prep_cif_var(&cif, FFI_DEFAULT_ABI, 1, 2, &ffi_type_sint,
+			       arg_types) == FFI_OK);
+
+	args[0] = &format;
+	args[1] = &doubleArg;
+	args[2] = NULL;
+
+	ffi_call(&cif, FFI_FN(printf), &res, args);
+	/* { dg-output "7.0" } */
+	printf("res: %d\n", (int) res);
+	/* { dg-output "\nres: 4" } */
+	CHECK(res == 4);
+
+	CHECK(ffi_prep_closure_loc(pcl, &cif, cls_double_va_fn, NULL,
+				   code) == FFI_OK);
+
+	res = ((int(*)(char*, ...))(code))(format, doubleArg);
+	/* { dg-output "\n7.0" } */
+	printf("res: %d\n", (int) res);
+	/* { dg-output "\nres: 4" } */
+	CHECK(res == 4);
+
+	exit(0);
+}

data/vendor/bundle/ruby/2.5.0/gems/ffi-1.16.3/ext/ffi_c/libffi/testsuite/libffi.closures/cls_float.c

@@ -0,0 +1,46 @@
+/* Area:	closure_call
+   Purpose:	Check return value float.
+   Limitations:	none.
+   PR:		none.
+   Originator:	<andreast@gcc.gnu.org> 20030828	 */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+static void cls_ret_float_fn(ffi_cif* cif __UNUSED__, void* resp, void** args,
+			     void* userdata __UNUSED__)
+ {
+   *(float *)resp = *(float *)args[0];
+
+   printf("%g: %g\n",*(float *)args[0],
+	  *(float *)resp);
+
+   CHECK((int)(*(float *)args[0]) == -2122);
+   CHECK((int)(*(float *)resp) == -2122);
+ }
+
+typedef float (*cls_ret_float)(float);
+
+int main (void)
+{
+  ffi_cif cif;
+  void *code;
+  ffi_closure *pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+  ffi_type * cl_arg_types[2];
+  float res;
+
+  cl_arg_types[0] = &ffi_type_float;
+  cl_arg_types[1] = NULL;
+
+  /* Initialize the cif */
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1,
+		     &ffi_type_float, cl_arg_types) == FFI_OK);
+
+  CHECK(ffi_prep_closure_loc(pcl, &cif, cls_ret_float_fn, NULL, code)  == FFI_OK);
+  res = ((((cls_ret_float)code)(-2122.12)));
+  /* { dg-output "\\-2122.12: \\-2122.12" } */
+  printf("res: %.6f\n", res);
+  /* { dg-output "\nres: \-2122.120117" } */
+  CHECK((int)res == -2122);
+  exit(0);
+}

data/vendor/bundle/ruby/2.5.0/gems/ffi-1.16.3/ext/ffi_c/libffi/testsuite/libffi.closures/cls_longdouble.c

@@ -0,0 +1,115 @@
+/* Area:		ffi_call, closure_call
+   Purpose:		Check long double arguments.
+   Limitations:	none.
+   PR:			none.
+   Originator:	Blake Chaffin	*/
+
+/* This test is known to PASS on armv7l-unknown-linux-gnueabihf, so I have
+   remove the xfail for arm*-*-* below, until we know more.  */
+/* { dg-do run { xfail strongarm*-*-* xscale*-*-* } } */
+/* { dg-options -mlong-double-128 { target powerpc64*-*-linux-gnu* } } */
+
+#include "ffitest.h"
+
+long double cls_ldouble_fn(
+	long double	a1,
+	long double	a2,
+	long double	a3,
+	long double	a4,
+	long double	a5,
+	long double	a6,
+	long double	a7,
+	long double	a8)
+{
+	long double	r = a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8;
+
+	printf("%Lg %Lg %Lg %Lg %Lg %Lg %Lg %Lg: %Lg\n",
+		a1, a2, a3, a4, a5, a6, a7, a8, r);
+	CHECK(a1 == 1);
+	CHECK(a2 == 2);
+	CHECK(a3 == 3);
+	CHECK(a4 == 4);
+	CHECK(a5 == 5);
+	CHECK(a6 == 6);
+	CHECK(a7 == 7);
+	CHECK(a8 == 8);
+
+	return r;
+}
+
+static void
+cls_ldouble_gn(ffi_cif* cif __UNUSED__, void* resp, 
+	       void** args, void* userdata __UNUSED__)
+{
+	long double	a1	= *(long double*)args[0];
+	long double	a2	= *(long double*)args[1];
+	long double	a3	= *(long double*)args[2];
+	long double	a4	= *(long double*)args[3];
+	long double	a5	= *(long double*)args[4];
+	long double	a6	= *(long double*)args[5];
+	long double	a7	= *(long double*)args[6];
+	long double	a8	= *(long double*)args[7];
+
+	*(long double*)resp = cls_ldouble_fn(
+		a1, a2, a3, a4, a5, a6, a7, a8);
+}
+
+int main(void)
+{
+	ffi_cif	cif;
+        void* code;
+	ffi_closure*	pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+	void*			args[9];
+	ffi_type*		arg_types[9];
+	long double		res	= 0;
+
+	long double	arg1	= 1;
+	long double	arg2	= 2;
+	long double	arg3	= 3;
+	long double	arg4	= 4;
+	long double	arg5	= 5;
+	long double	arg6	= 6;
+	long double	arg7	= 7;
+	long double	arg8	= 8;
+
+	arg_types[0] = &ffi_type_longdouble;
+	arg_types[1] = &ffi_type_longdouble;
+	arg_types[2] = &ffi_type_longdouble;
+	arg_types[3] = &ffi_type_longdouble;
+	arg_types[4] = &ffi_type_longdouble;
+	arg_types[5] = &ffi_type_longdouble;
+	arg_types[6] = &ffi_type_longdouble;
+	arg_types[7] = &ffi_type_longdouble;
+	arg_types[8] = NULL;
+
+	CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 8, &ffi_type_longdouble,
+		arg_types) == FFI_OK);
+
+	args[0] = &arg1;
+	args[1] = &arg2;
+	args[2] = &arg3;
+	args[3] = &arg4;
+	args[4] = &arg5;
+	args[5] = &arg6;
+	args[6] = &arg7;
+	args[7] = &arg8;
+	args[8] = NULL;
+
+	ffi_call(&cif, FFI_FN(cls_ldouble_fn), &res, args);
+	/* { dg-output "1 2 3 4 5 6 7 8: 36" } */
+	printf("res: %Lg\n", res);
+	/* { dg-output "\nres: 36" } */
+	CHECK(res == 36);
+
+	CHECK(ffi_prep_closure_loc(pcl, &cif, cls_ldouble_gn, NULL, code) == FFI_OK);
+
+	res = ((long double(*)(long double, long double, long double, long double,
+		long double, long double, long double, long double))(code))(arg1, arg2,
+		arg3, arg4, arg5, arg6, arg7, arg8);
+	/* { dg-output "\n1 2 3 4 5 6 7 8: 36" } */
+	printf("res: %Lg\n", res);
+	/* { dg-output "\nres: 36" } */
+	CHECK(res == 36);
+
+	return 0;
+}

data/vendor/bundle/ruby/2.5.0/gems/ffi-1.16.3/ext/ffi_c/libffi/testsuite/libffi.closures/cls_longdouble_va.c

@@ -0,0 +1,80 @@
+/* Area:		ffi_call, closure_call
+   Purpose:		Test long doubles passed in variable argument lists.
+   Limitations:	none.
+   PR:			none.
+   Originator:	Blake Chaffin 6/6/2007	 */
+
+/* { dg-do run { xfail strongarm*-*-* xscale*-*-* } } */
+/* { dg-output "" { xfail avr32*-*-* } } */
+/* { dg-output "" { xfail mips-sgi-irix6* } } PR libffi/46660 */
+
+#include "ffitest.h"
+#include <stdarg.h>
+
+#define BUF_SIZE 50
+static char buffer[BUF_SIZE];
+
+static int
+wrap_printf(char* fmt, ...) {
+	va_list ap;
+	va_start(ap, fmt);
+	long double ldArg = va_arg(ap, long double);
+	va_end(ap);
+	CHECK((int)ldArg == 7);
+	return printf(fmt, ldArg);	
+}
+
+static void
+cls_longdouble_va_fn(ffi_cif* cif __UNUSED__, void* resp,
+		     void** args, void* userdata __UNUSED__)
+{
+	char*		format	= *(char**)args[0];
+	long double	ldValue	= *(long double*)args[1];
+
+	*(ffi_arg*)resp = printf(format, ldValue);
+	CHECK(*(ffi_arg*)resp == 4);
+	snprintf(buffer, BUF_SIZE, format, ldValue);
+	CHECK(strncmp(buffer, "7.0\n", BUF_SIZE) == 0);
+}
+
+int main (void)
+{
+	ffi_cif cif;
+        void *code;
+	ffi_closure *pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+	void* args[3];
+	ffi_type* arg_types[3];
+
+	char*		format	= "%.1Lf\n";
+	long double	ldArg	= 7;
+	ffi_arg		res		= 0;
+
+	arg_types[0] = &ffi_type_pointer;
+	arg_types[1] = &ffi_type_longdouble;
+	arg_types[2] = NULL;
+
+	/* This printf call is variadic */
+	CHECK(ffi_prep_cif_var(&cif, FFI_DEFAULT_ABI, 1, 2, &ffi_type_sint,
+			       arg_types) == FFI_OK);
+
+	args[0] = &format;
+	args[1] = &ldArg;
+	args[2] = NULL;
+
+	ffi_call(&cif, FFI_FN(wrap_printf), &res, args);
+	/* { dg-output "7.0" } */
+	printf("res: %d\n", (int) res);
+	/* { dg-output "\nres: 4" } */
+	CHECK(res == 4);
+
+	CHECK(ffi_prep_closure_loc(pcl, &cif, cls_longdouble_va_fn, NULL,
+				   code) == FFI_OK);
+
+	res = ((int(*)(char*, ...))(code))(format, ldArg);
+	/* { dg-output "\n7.0" } */
+	printf("res: %d\n", (int) res);
+	/* { dg-output "\nres: 4" } */
+	CHECK(res == 4);
+
+	exit(0);
+}

data/vendor/bundle/ruby/2.5.0/gems/ffi-1.16.3/ext/ffi_c/libffi/testsuite/libffi.closures/cls_multi_schar.c

@@ -0,0 +1,78 @@
+/* Area:	ffi_call, closure_call
+   Purpose:	Check passing of multiple signed char values.
+   Limitations:	none.
+   PR:		PR13221.
+   Originator:	<hos@tamanegi.org> 20031129  */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+static signed char test_func_fn(signed char a1, signed char a2)
+{
+  signed char result;
+
+  result = a1 + a2;
+
+  printf("%d %d: %d\n", a1, a2, result);
+
+  return result;
+
+}
+
+static void test_func_gn(ffi_cif *cif __UNUSED__, void *rval, void **avals,
+			 void *data __UNUSED__)
+{
+  signed char a1, a2;
+
+  a1 = *(signed char *)avals[0];
+  a2 = *(signed char *)avals[1];
+  CHECK(a1 == 2);
+  CHECK(a2 == 125);
+
+  *(ffi_arg *)rval = test_func_fn(a1, a2);
+
+}
+
+typedef signed char (*test_type)(signed char, signed char);
+
+int main (void)
+{
+  ffi_cif cif;
+  void *code;
+  ffi_closure *pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+  void * args_dbl[3];
+  ffi_type * cl_arg_types[3];
+  ffi_arg res_call;
+  signed char a, b, res_closure;
+
+  a = 2;
+  b = 125;
+
+  args_dbl[0] = &a;
+  args_dbl[1] = &b;
+  args_dbl[2] = NULL;
+
+  cl_arg_types[0] = &ffi_type_schar;
+  cl_arg_types[1] = &ffi_type_schar;
+  cl_arg_types[2] = NULL;
+
+  /* Initialize the cif */
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 2,
+		     &ffi_type_schar, cl_arg_types) == FFI_OK);
+
+  ffi_call(&cif, FFI_FN(test_func_fn), &res_call, args_dbl);
+  /* { dg-output "2 125: 127" } */
+  printf("res: %d\n", (signed char)res_call);
+  /* { dg-output "\nres: 127" } */
+  CHECK((signed char)res_call == 127);
+
+  CHECK(ffi_prep_closure_loc(pcl, &cif, test_func_gn, NULL, code)  == FFI_OK);
+
+  res_closure = (*((test_type)code))(2, 125);
+  /* { dg-output "\n2 125: 127" } */
+  printf("res: %d\n", res_closure);
+  /* { dg-output "\nres: 127" } */
+  CHECK(res_closure == 127);
+
+  exit(0);
+}

data/vendor/bundle/ruby/2.5.0/gems/ffi-1.16.3/ext/ffi_c/libffi/testsuite/libffi.closures/cls_multi_sshort.c

@@ -0,0 +1,79 @@
+/* Area:	ffi_call, closure_call
+   Purpose:	Check passing of multiple signed short values.
+   Limitations:	none.
+   PR:		PR13221.
+   Originator:	<andreast@gcc.gnu.org> 20031129  */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+static signed short test_func_fn(signed short a1, signed short a2)
+{
+  signed short result;
+
+  result = a1 + a2;
+
+  printf("%d %d: %d\n", a1, a2, result);
+  CHECK(a1 == 2);
+  CHECK(a2 == 32765);
+  CHECK(result == 32767);
+
+  return result;
+
+}
+
+static void test_func_gn(ffi_cif *cif __UNUSED__, void *rval, void **avals,
+			 void *data __UNUSED__)
+{
+  signed short a1, a2;
+
+  a1 = *(signed short *)avals[0];
+  a2 = *(signed short *)avals[1];
+
+  *(ffi_arg *)rval = test_func_fn(a1, a2);
+
+}
+
+typedef signed short (*test_type)(signed short, signed short);
+
+int main (void)
+{
+  ffi_cif cif;
+  void *code;
+  ffi_closure *pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+  void * args_dbl[3];
+  ffi_type * cl_arg_types[3];
+  ffi_arg res_call;
+  unsigned short a, b, res_closure;
+
+  a = 2;
+  b = 32765;
+
+  args_dbl[0] = &a;
+  args_dbl[1] = &b;
+  args_dbl[2] = NULL;
+
+  cl_arg_types[0] = &ffi_type_sshort;
+  cl_arg_types[1] = &ffi_type_sshort;
+  cl_arg_types[2] = NULL;
+
+  /* Initialize the cif */
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 2,
+		     &ffi_type_sshort, cl_arg_types) == FFI_OK);
+
+  ffi_call(&cif, FFI_FN(test_func_fn), &res_call, args_dbl);
+  /* { dg-output "2 32765: 32767" } */
+  printf("res: %d\n", (unsigned short)res_call);
+  /* { dg-output "\nres: 32767" } */
+  CHECK((unsigned short)res_call == 32767);
+
+  CHECK(ffi_prep_closure_loc(pcl, &cif, test_func_gn, NULL, code)  == FFI_OK);
+
+  res_closure = (*((test_type)code))(2, 32765);
+  /* { dg-output "\n2 32765: 32767" } */
+  printf("res: %d\n", res_closure);
+  /* { dg-output "\nres: 32767" } */
+  CHECK(res_closure == 32767);
+
+  exit(0);
+}

data/vendor/bundle/ruby/2.5.0/gems/ffi-1.16.3/ext/ffi_c/libffi/testsuite/libffi.closures/cls_multi_sshortchar.c

@@ -0,0 +1,94 @@
+/* Area:	ffi_call, closure_call
+   Purpose:	Check passing of multiple signed short/char values.
+   Limitations:	none.
+   PR:		PR13221.
+   Originator:	<andreast@gcc.gnu.org> 20031129  */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+static signed short test_func_fn(signed char a1, signed short a2,
+			  signed char a3, signed short a4)
+{
+  signed short result;
+
+  result = a1 + a2 + a3 + a4;
+
+  printf("%d %d %d %d: %d\n", a1, a2, a3, a4, result);
+
+  CHECK(a1 == 1);
+  CHECK(a2 == 32765);
+  CHECK(a3 == 127);
+  CHECK(a4 == -128);
+  CHECK(result == 32765);
+
+  return result;
+
+}
+
+static void test_func_gn(ffi_cif *cif __UNUSED__, void *rval, void **avals,
+			 void *data __UNUSED__)
+{
+  signed char a1, a3;
+  signed short a2, a4;
+
+  a1 = *(signed char *)avals[0];
+  a2 = *(signed short *)avals[1];
+  a3 = *(signed char *)avals[2];
+  a4 = *(signed short *)avals[3];
+
+  *(ffi_arg *)rval = test_func_fn(a1, a2, a3, a4);
+
+}
+
+typedef signed short (*test_type)(signed char, signed short,
+				  signed char, signed short);
+
+int main (void)
+{
+  ffi_cif cif;
+  void *code;
+  ffi_closure *pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+  void * args_dbl[5];
+  ffi_type * cl_arg_types[5];
+  ffi_arg res_call;
+  signed char a, c;
+  signed short b, d, res_closure;
+
+  a = 1;
+  b = 32765;
+  c = 127;
+  d = -128;
+
+  args_dbl[0] = &a;
+  args_dbl[1] = &b;
+  args_dbl[2] = &c;
+  args_dbl[3] = &d;
+  args_dbl[4] = NULL;
+
+  cl_arg_types[0] = &ffi_type_schar;
+  cl_arg_types[1] = &ffi_type_sshort;
+  cl_arg_types[2] = &ffi_type_schar;
+  cl_arg_types[3] = &ffi_type_sshort;
+  cl_arg_types[4] = NULL;
+
+  /* Initialize the cif */
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 4,
+		     &ffi_type_sshort, cl_arg_types) == FFI_OK);
+
+  ffi_call(&cif, FFI_FN(test_func_fn), &res_call, args_dbl);
+  /* { dg-output "1 32765 127 -128: 32765" } */
+  printf("res: %d\n", (signed short)res_call);
+  /* { dg-output "\nres: 32765" } */
+  CHECK(res_call == 32765);
+
+  CHECK(ffi_prep_closure_loc(pcl, &cif, test_func_gn, NULL, code)  == FFI_OK);
+
+  res_closure = (*((test_type)code))(1, 32765, 127, -128);
+  /* { dg-output "\n1 32765 127 -128: 32765" } */
+  printf("res: %d\n", res_closure);
+  /* { dg-output "\nres: 32765" } */
+  CHECK(res_closure == 32765);
+
+  exit(0);
+}