Source file misc/cgo/test/test.go

     1  // Copyright 2010 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Test cases for cgo.
     6  // Both the import "C" prologue and the main file are sorted by issue number.
     7  // This file contains C definitions (not just declarations)
     8  // and so it must NOT contain any //export directives on Go functions.
     9  // See testx.go for exports.
    10  
    11  package cgotest
    12  
    13  /*
    14  #include <complex.h>
    15  #include <math.h>
    16  #include <stdarg.h>
    17  #include <stdbool.h>
    18  #include <stddef.h>
    19  #include <stdint.h>
    20  #include <stdio.h>
    21  #include <stdlib.h>
    22  #include <string.h>
    23  #include <unistd.h>
    24  #include <sys/stat.h>
    25  #include <errno.h>
    26  #cgo LDFLAGS: -lm
    27  
    28  #ifndef WIN32
    29  #include <pthread.h>
    30  #include <signal.h>
    31  #endif
    32  
    33  // alignment tests
    34  
    35  typedef unsigned char Uint8;
    36  typedef unsigned short Uint16;
    37  
    38  typedef enum {
    39   MOD1 = 0x0000,
    40   MODX = 0x8000
    41  } SDLMod;
    42  
    43  typedef enum {
    44   A1 = 1,
    45   B1 = 322,
    46   SDLK_LAST
    47  } SDLKey;
    48  
    49  typedef struct SDL_keysym {
    50  	Uint8 scancode;
    51  	SDLKey sym;
    52  	SDLMod mod;
    53  	Uint16 unicode;
    54  } SDL_keysym;
    55  
    56  typedef struct SDL_KeyboardEvent {
    57  	Uint8 typ;
    58  	Uint8 which;
    59  	Uint8 state;
    60  	SDL_keysym keysym;
    61  } SDL_KeyboardEvent;
    62  
    63  void makeEvent(SDL_KeyboardEvent *event) {
    64   unsigned char *p;
    65   int i;
    66  
    67   p = (unsigned char*)event;
    68   for (i=0; i<sizeof *event; i++) {
    69     p[i] = i;
    70   }
    71  }
    72  
    73  int same(SDL_KeyboardEvent* e, Uint8 typ, Uint8 which, Uint8 state, Uint8 scan, SDLKey sym, SDLMod mod, Uint16 uni) {
    74    return e->typ == typ && e->which == which && e->state == state && e->keysym.scancode == scan && e->keysym.sym == sym && e->keysym.mod == mod && e->keysym.unicode == uni;
    75  }
    76  
    77  void cTest(SDL_KeyboardEvent *event) {
    78   printf("C: %#x %#x %#x %#x %#x %#x %#x\n", event->typ, event->which, event->state,
    79     event->keysym.scancode, event->keysym.sym, event->keysym.mod, event->keysym.unicode);
    80   fflush(stdout);
    81  }
    82  
    83  // api
    84  
    85  const char *greeting = "hello, world";
    86  
    87  // basic test cases
    88  
    89  #define SHIFT(x, y)  ((x)<<(y))
    90  #define KILO SHIFT(1, 10)
    91  #define UINT32VAL 0xc008427bU
    92  
    93  enum E {
    94  	Enum1 = 1,
    95  	Enum2 = 2,
    96  };
    97  
    98  typedef unsigned char cgo_uuid_t[20];
    99  
   100  void uuid_generate(cgo_uuid_t x) {
   101  	x[0] = 0;
   102  }
   103  
   104  struct S {
   105  	int x;
   106  };
   107  
   108  const char *cstr = "abcefghijklmnopqrstuvwxyzABCEFGHIJKLMNOPQRSTUVWXYZ1234567890";
   109  
   110  extern enum E myConstFunc(struct S* const ctx, int const id, struct S **const filter);
   111  
   112  enum E myConstFunc(struct S *const ctx, int const id, struct S **const filter) { return 0; }
   113  
   114  int add(int x, int y) {
   115  	return x+y;
   116  };
   117  
   118  // Following mimicks vulkan complex definitions for benchmarking cgocheck overhead.
   119  
   120  typedef uint32_t VkFlags;
   121  typedef VkFlags  VkDeviceQueueCreateFlags;
   122  typedef uint32_t VkStructureType;
   123  
   124  typedef struct VkDeviceQueueCreateInfo {
   125      VkStructureType             sType;
   126      const void*                 pNext;
   127      VkDeviceQueueCreateFlags    flags;
   128      uint32_t                    queueFamilyIndex;
   129      uint32_t                    queueCount;
   130      const float*                pQueuePriorities;
   131  } VkDeviceQueueCreateInfo;
   132  
   133  typedef struct VkPhysicalDeviceFeatures {
   134      uint32_t bools[56];
   135  } VkPhysicalDeviceFeatures;
   136  
   137  typedef struct VkDeviceCreateInfo {
   138      VkStructureType                    sType;
   139      const void*                        pNext;
   140      VkFlags                            flags;
   141      uint32_t                           queueCreateInfoCount;
   142      const VkDeviceQueueCreateInfo*     pQueueCreateInfos;
   143      uint32_t                           enabledLayerCount;
   144      const char* const*                 ppEnabledLayerNames;
   145      uint32_t                           enabledExtensionCount;
   146      const char* const*                 ppEnabledExtensionNames;
   147      const VkPhysicalDeviceFeatures*    pEnabledFeatures;
   148  } VkDeviceCreateInfo;
   149  
   150  void handleComplexPointer(VkDeviceCreateInfo *a0) {}
   151  void handleComplexPointer8(
   152  	VkDeviceCreateInfo *a0, VkDeviceCreateInfo *a1, VkDeviceCreateInfo *a2, VkDeviceCreateInfo *a3,
   153  	VkDeviceCreateInfo *a4, VkDeviceCreateInfo *a5, VkDeviceCreateInfo *a6, VkDeviceCreateInfo *a7
   154  ) {}
   155  
   156  // complex alignment
   157  
   158  struct {
   159  	float x;
   160  	_Complex float y;
   161  } cplxAlign = { 3.14, 2.17 };
   162  
   163  // constants and pointer checking
   164  
   165  #define CheckConstVal 0
   166  
   167  typedef struct {
   168  	int *p;
   169  } CheckConstStruct;
   170  
   171  static void CheckConstFunc(CheckConstStruct *p, int e) {}
   172  
   173  // duplicate symbol
   174  
   175  int base_symbol = 0;
   176  #define alias_one base_symbol
   177  #define alias_two base_symbol
   178  
   179  // function pointer variables
   180  
   181  typedef int (*intFunc) ();
   182  
   183  int
   184  bridge_int_func(intFunc f)
   185  {
   186  	return f();
   187  }
   188  
   189  int fortytwo()
   190  {
   191  	return 42;
   192  }
   193  
   194  // issue 1222
   195  typedef union {
   196  	long align;
   197  } xxpthread_mutex_t;
   198  struct ibv_async_event {
   199  	union {
   200  		int x;
   201  	} element;
   202  };
   203  struct ibv_context {
   204  	xxpthread_mutex_t mutex;
   205  };
   206  
   207  // issue 1635
   208  // Mac OS X's gcc will generate scattered relocation 2/1 for
   209  // this function on Darwin/386, and 8l couldn't handle it.
   210  // this example is in issue 1635
   211  void scatter() {
   212  	void *p = scatter;
   213  	printf("scatter = %p\n", p);
   214  }
   215  
   216  // Adding this explicit extern declaration makes this a test for
   217  // https://gcc.gnu.org/PR68072 aka https://golang.org/issue/13344 .
   218  // It used to cause a cgo error when building with GCC 6.
   219  extern int hola;
   220  
   221  // this example is in issue 3253
   222  int hola = 0;
   223  int testHola() { return hola; }
   224  
   225  // issue 3250
   226  #ifdef WIN32
   227  void testSendSIG() {}
   228  #else
   229  static void *thread(void *p) {
   230  	const int M = 100;
   231  	int i;
   232  	(void)p;
   233  	for (i = 0; i < M; i++) {
   234  		pthread_kill(pthread_self(), SIGCHLD);
   235  		usleep(rand() % 20 + 5);
   236  	}
   237  	return NULL;
   238  }
   239  void testSendSIG() {
   240  	const int N = 20;
   241  	int i;
   242  	pthread_t tid[N];
   243  	for (i = 0; i < N; i++) {
   244  		usleep(rand() % 200 + 100);
   245  		pthread_create(&tid[i], 0, thread, NULL);
   246  	}
   247  	for (i = 0; i < N; i++)
   248  		pthread_join(tid[i], 0);
   249  }
   250  #endif
   251  
   252  // issue 3261
   253  // libgcc on ARM might be compiled as thumb code, but our 5l
   254  // can't handle that, so we have to disable this test on arm.
   255  #ifdef __ARMEL__
   256  int vabs(int x) {
   257  	puts("testLibgcc is disabled on ARM because 5l cannot handle thumb library.");
   258  	return (x < 0) ? -x : x;
   259  }
   260  #elif defined(__arm64__) && defined(__clang__)
   261  int vabs(int x) {
   262  	puts("testLibgcc is disabled on ARM64 with clang due to lack of libgcc.");
   263  	return (x < 0) ? -x : x;
   264  }
   265  #else
   266  int __absvsi2(int); // dummy prototype for libgcc function
   267  // we shouldn't name the function abs, as gcc might use
   268  // the builtin one.
   269  int vabs(int x) { return __absvsi2(x); }
   270  #endif
   271  
   272  
   273  // issue 3729
   274  // access errno from void C function
   275  const char _expA = 0x42;
   276  const float _expB = 3.14159;
   277  const short _expC = 0x55aa;
   278  const int _expD = 0xdeadbeef;
   279  
   280  #ifdef WIN32
   281  void g(void) {}
   282  void g2(int x, char a, float b, short c, int d) {}
   283  #else
   284  
   285  void g(void) {
   286  	errno = E2BIG;
   287  }
   288  
   289  // try to pass some non-trivial arguments to function g2
   290  void g2(int x, char a, float b, short c, int d) {
   291  	if (a == _expA && b == _expB && c == _expC && d == _expD)
   292  		errno = x;
   293  	else
   294  		errno = -1;
   295  }
   296  #endif
   297  
   298  // issue 3945
   299  // Test that cgo reserves enough stack space during cgo call.
   300  // See https://golang.org/issue/3945 for details.
   301  void say() {
   302  	printf("%s from C\n", "hello");
   303  }
   304  
   305  // issue 4054 part 1 - other half in testx.go
   306  
   307  typedef enum {
   308  	A = 0,
   309  	B,
   310  	C,
   311  	D,
   312  	E,
   313  	F,
   314  	G,
   315  	H,
   316  	II,
   317  	J,
   318  } issue4054a;
   319  
   320  // issue 4339
   321  // We've historically permitted #include <>, so test it here.  Issue 29333.
   322  // Also see issue 41059.
   323  #include <issue4339.h>
   324  
   325  // issue 4417
   326  // cmd/cgo: bool alignment/padding issue.
   327  // bool alignment is wrong and causing wrong arguments when calling functions.
   328  static int c_bool(bool a, bool b, int c, bool d, bool e)  {
   329     return c;
   330  }
   331  
   332  // issue 4857
   333  #cgo CFLAGS: -Werror
   334  const struct { int a; } *issue4857() { return (void *)0; }
   335  
   336  // issue 5224
   337  // Test that the #cgo CFLAGS directive works,
   338  // with and without platform filters.
   339  #cgo CFLAGS: -DCOMMON_VALUE=123
   340  #cgo windows CFLAGS: -DIS_WINDOWS=1
   341  #cgo !windows CFLAGS: -DIS_WINDOWS=0
   342  int common = COMMON_VALUE;
   343  int is_windows = IS_WINDOWS;
   344  
   345  // issue 5227
   346  // linker incorrectly treats common symbols and
   347  // leaves them undefined.
   348  
   349  typedef struct {
   350          int Count;
   351  } Fontinfo;
   352  
   353  Fontinfo SansTypeface;
   354  
   355  extern void init();
   356  
   357  Fontinfo loadfont() {
   358          Fontinfo f = {0};
   359          return f;
   360  }
   361  
   362  void init() {
   363          SansTypeface = loadfont();
   364  }
   365  
   366  // issue 5242
   367  // Cgo incorrectly computed the alignment of structs
   368  // with no Go accessible fields as 0, and then panicked on
   369  // modulo-by-zero computations.
   370  
   371  // issue 50987
   372  // disable arm64 GCC warnings
   373  #cgo CFLAGS: -Wno-psabi -Wno-unknown-warning-option
   374  
   375  typedef struct {
   376  } foo;
   377  
   378  typedef struct {
   379  	int x : 1;
   380  } bar;
   381  
   382  int issue5242(foo f, bar b) {
   383  	return 5242;
   384  }
   385  
   386  // issue 5337
   387  // Verify that we can withstand SIGPROF received on foreign threads
   388  
   389  #ifdef WIN32
   390  void test5337() {}
   391  #else
   392  static void *thread1(void *p) {
   393  	(void)p;
   394  	pthread_kill(pthread_self(), SIGPROF);
   395  	return NULL;
   396  }
   397  void test5337() {
   398  	pthread_t tid;
   399  	pthread_create(&tid, 0, thread1, NULL);
   400  	pthread_join(tid, 0);
   401  }
   402  #endif
   403  
   404  // issue 5603
   405  
   406  const long long issue5603exp = 0x12345678;
   407  long long issue5603foo0() { return issue5603exp; }
   408  long long issue5603foo1(void *p) { return issue5603exp; }
   409  long long issue5603foo2(void *p, void *q) { return issue5603exp; }
   410  long long issue5603foo3(void *p, void *q, void *r) { return issue5603exp; }
   411  long long issue5603foo4(void *p, void *q, void *r, void *s) { return issue5603exp; }
   412  
   413  // issue 5740
   414  
   415  int test5740a(void), test5740b(void);
   416  
   417  // issue 5986
   418  static void output5986()
   419  {
   420      int current_row = 0, row_count = 0;
   421      double sum_squares = 0;
   422      double d;
   423      do {
   424          if (current_row == 10) {
   425              current_row = 0;
   426          }
   427          ++row_count;
   428      }
   429      while (current_row++ != 1);
   430      d =  sqrt(sum_squares / row_count);
   431      printf("sqrt is: %g\n", d);
   432  }
   433  
   434  // issue 6128
   435  // Test handling of #defined names in clang.
   436  // NOTE: Must use hex, or else a shortcut for decimals
   437  // in cgo avoids trying to pass this to clang.
   438  #define X 0x1
   439  
   440  // issue 6472
   441  typedef struct
   442  {
   443          struct
   444          {
   445              int x;
   446          } y[16];
   447  } z;
   448  
   449  // issue 6612
   450  // Test new scheme for deciding whether C.name is an expression, type, constant.
   451  // Clang silences some warnings when the name is a #defined macro, so test those too
   452  // (even though we now use errors exclusively, not warnings).
   453  
   454  void myfunc(void) {}
   455  int myvar = 5;
   456  const char *mytext = "abcdef";
   457  typedef int mytype;
   458  enum {
   459  	myenum = 1234,
   460  };
   461  
   462  #define myfunc_def myfunc
   463  #define myvar_def myvar
   464  #define mytext_def mytext
   465  #define mytype_def mytype
   466  #define myenum_def myenum
   467  #define myint_def 12345
   468  #define myfloat_def 1.5
   469  #define mystring_def "hello"
   470  
   471  // issue 6907
   472  char* Issue6907CopyString(_GoString_ s) {
   473  	size_t n;
   474  	const char *p;
   475  	char *r;
   476  
   477  	n = _GoStringLen(s);
   478  	p = _GoStringPtr(s);
   479  	r = malloc(n + 1);
   480  	memmove(r, p, n);
   481  	r[n] = '\0';
   482  	return r;
   483  }
   484  
   485  // issue 7560
   486  typedef struct {
   487  	char x;
   488  	long y;
   489  } __attribute__((__packed__)) misaligned;
   490  
   491  int
   492  offset7560(void)
   493  {
   494  	return (uintptr_t)&((misaligned*)0)->y;
   495  }
   496  
   497  // issue 7786
   498  // No runtime test, just make sure that typedef and struct/union/class are interchangeable at compile time.
   499  
   500  struct test7786;
   501  typedef struct test7786 typedef_test7786;
   502  void f7786(struct test7786 *ctx) {}
   503  void g7786(typedef_test7786 *ctx) {}
   504  
   505  typedef struct body7786 typedef_body7786;
   506  struct body7786 { int x; };
   507  void b7786(struct body7786 *ctx) {}
   508  void c7786(typedef_body7786 *ctx) {}
   509  
   510  typedef union union7786 typedef_union7786;
   511  void u7786(union union7786 *ctx) {}
   512  void v7786(typedef_union7786 *ctx) {}
   513  
   514  // issue 8092
   515  // Test that linker defined symbols (e.g., text, data) don't
   516  // conflict with C symbols.
   517  char text[] = "text";
   518  char data[] = "data";
   519  char *ctext(void) { return text; }
   520  char *cdata(void) { return data; }
   521  
   522  // issue 8428
   523  // Cgo inconsistently translated zero size arrays.
   524  
   525  struct issue8428one {
   526  	char b;
   527  	char rest[];
   528  };
   529  
   530  struct issue8428two {
   531  	void *p;
   532  	char b;
   533  	char rest[0];
   534  	char pad;
   535  };
   536  
   537  struct issue8428three {
   538  	char w[1][2][3][0];
   539  	char x[2][3][0][1];
   540  	char y[3][0][1][2];
   541  	char z[0][1][2][3];
   542  };
   543  
   544  // issue 8331 part 1 - part 2 in testx.go
   545  // A typedef of an unnamed struct is the same struct when
   546  // #include'd twice.  No runtime test; just make sure it compiles.
   547  #include "issue8331.h"
   548  
   549  // issue 8368 and 8441
   550  // Recursive struct definitions didn't work.
   551  // No runtime test; just make sure it compiles.
   552  typedef struct one one;
   553  typedef struct two two;
   554  struct one {
   555  	two *x;
   556  };
   557  struct two {
   558  	one *x;
   559  };
   560  
   561  // issue 8811
   562  
   563  extern int issue8811Initialized;
   564  extern void issue8811Init();
   565  
   566  void issue8811Execute() {
   567  	if(!issue8811Initialized)
   568  		issue8811Init();
   569  }
   570  
   571  // issue 8945
   572  
   573  typedef void (*PFunc8945)();
   574  PFunc8945 func8945;
   575  
   576  // issue 9557
   577  
   578  struct issue9557_t {
   579    int a;
   580  } test9557bar = { 42 };
   581  struct issue9557_t *issue9557foo = &test9557bar;
   582  
   583  // issue 10303
   584  // Pointers passed to C were not marked as escaping (bug in cgo).
   585  
   586  typedef int *intptr;
   587  
   588  void setintstar(int *x) {
   589  	*x = 1;
   590  }
   591  
   592  void setintptr(intptr x) {
   593  	*x = 1;
   594  }
   595  
   596  void setvoidptr(void *x) {
   597  	*(int*)x = 1;
   598  }
   599  
   600  typedef struct Struct Struct;
   601  struct Struct {
   602  	int *P;
   603  };
   604  
   605  void setstruct(Struct s) {
   606  	*s.P = 1;
   607  }
   608  
   609  // issue 11925
   610  // Structs with zero-length trailing fields are now padded by the Go compiler.
   611  
   612  struct a11925 {
   613  	int i;
   614  	char a[0];
   615  	char b[0];
   616  };
   617  
   618  struct b11925 {
   619  	int i;
   620  	char a[0];
   621  	char b[];
   622  };
   623  
   624  // issue 12030
   625  void issue12030conv(char *buf, double x) {
   626  	sprintf(buf, "d=%g", x);
   627  }
   628  
   629  // issue 14838
   630  
   631  int check_cbytes(char *b, size_t l) {
   632  	int i;
   633  	for (i = 0; i < l; i++) {
   634  		if (b[i] != i) {
   635  			return 0;
   636  		}
   637  	}
   638  	return 1;
   639  }
   640  
   641  // issue 17065
   642  // Test that C symbols larger than a page play nicely with the race detector.
   643  int ii[65537];
   644  
   645  // issue 17537
   646  // The void* cast introduced by cgo to avoid problems
   647  // with const/volatile qualifiers breaks C preprocessor macros that
   648  // emulate functions.
   649  
   650  typedef struct {
   651  	int i;
   652  } S17537;
   653  
   654  int I17537(S17537 *p);
   655  
   656  #define I17537(p) ((p)->i)
   657  
   658  // Calling this function used to fail without the cast.
   659  const int F17537(const char **p) {
   660  	return **p;
   661  }
   662  
   663  // issue 17723
   664  // API compatibility checks
   665  
   666  typedef char *cstring_pointer;
   667  static void cstring_pointer_fun(cstring_pointer dummy) { }
   668  const char *api_hello = "hello!";
   669  
   670  // Calling this function used to trigger an error from the C compiler
   671  // (issue 18298).
   672  void F18298(const void *const *p) {
   673  }
   674  
   675  // Test that conversions between typedefs work as they used to.
   676  typedef const void *T18298_1;
   677  struct S18298 { int i; };
   678  typedef const struct S18298 *T18298_2;
   679  void G18298(T18298_1 t) {
   680  }
   681  
   682  // issue 18126
   683  // cgo check of void function returning errno.
   684  void Issue18126C(void **p) {}
   685  
   686  // issue 18720
   687  
   688  #define HELLO "hello"
   689  #define WORLD "world"
   690  #define HELLO_WORLD HELLO "\000" WORLD
   691  
   692  struct foo { char c; };
   693  #define SIZE_OF(x) sizeof(x)
   694  #define SIZE_OF_FOO SIZE_OF(struct foo)
   695  #define VAR1 VAR
   696  #define VAR var
   697  int var = 5;
   698  
   699  #define ADDR &var
   700  
   701  #define CALL fn()
   702  int fn(void) {
   703  	return ++var;
   704  }
   705  
   706  // issue 20129
   707  
   708  int issue20129 = 0;
   709  typedef void issue20129Void;
   710  issue20129Void issue20129Foo() {
   711  	issue20129 = 1;
   712  }
   713  typedef issue20129Void issue20129Void2;
   714  issue20129Void2 issue20129Bar() {
   715  	issue20129 = 2;
   716  }
   717  
   718  // issue 20369
   719  #define XUINT64_MAX        18446744073709551615ULL
   720  
   721  // issue 21668
   722  // Fail to guess the kind of the constant "x".
   723  // No runtime test; just make sure it compiles.
   724  const int x21668 = 42;
   725  
   726  // issue 21708
   727  #define CAST_TO_INT64 (int64_t)(-1)
   728  
   729  // issue 21809
   730  // Compile C `typedef` to go type aliases.
   731  
   732  typedef long MySigned_t;
   733  // tests alias-to-alias
   734  typedef MySigned_t MySigned2_t;
   735  long takes_long(long x) { return x * x; }
   736  MySigned_t takes_typedef(MySigned_t x) { return x * x; }
   737  
   738  // issue 22906
   739  
   740  // It's going to be hard to include a whole real JVM to test this.
   741  // So we'll simulate a really easy JVM using just the parts we need.
   742  // This is the relevant part of jni.h.
   743  
   744  struct _jobject;
   745  
   746  typedef struct _jobject *jobject;
   747  typedef jobject jclass;
   748  typedef jobject jthrowable;
   749  typedef jobject jstring;
   750  typedef jobject jarray;
   751  typedef jarray jbooleanArray;
   752  typedef jarray jbyteArray;
   753  typedef jarray jcharArray;
   754  typedef jarray jshortArray;
   755  typedef jarray jintArray;
   756  typedef jarray jlongArray;
   757  typedef jarray jfloatArray;
   758  typedef jarray jdoubleArray;
   759  typedef jarray jobjectArray;
   760  
   761  typedef jobject jweak;
   762  
   763  // Note: jvalue is already a non-pointer type due to it being a C union.
   764  
   765  // issue 22958
   766  
   767  typedef struct {
   768  	unsigned long long f8  : 8;
   769  	unsigned long long f16 : 16;
   770  	unsigned long long f24 : 24;
   771  	unsigned long long f32 : 32;
   772  	unsigned long long f40 : 40;
   773  	unsigned long long f48 : 48;
   774  	unsigned long long f56 : 56;
   775  	unsigned long long f64 : 64;
   776  } issue22958Type;
   777  
   778  // issue 23356
   779  int a(void) { return 5; };
   780  int r(void) { return 3; };
   781  
   782  // issue 23720
   783  typedef int *issue23720A;
   784  typedef const int *issue23720B;
   785  void issue23720F(issue23720B a) {}
   786  
   787  // issue 24206
   788  #if defined(__linux__) && defined(__x86_64__)
   789  #include <sys/mman.h>
   790  // Returns string with null byte at the last valid address
   791  char* dangerousString1() {
   792  	int pageSize = 4096;
   793  	char *data = mmap(0, 2 * pageSize, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, 0, 0);
   794  	mprotect(data + pageSize,pageSize,PROT_NONE);
   795  	int start = pageSize - 123 - 1; // last 123 bytes of first page + 1 null byte
   796  	int i = start;
   797  	for (; i < pageSize; i++) {
   798  	data[i] = 'x';
   799  	}
   800  	data[pageSize -1 ] = 0;
   801  	return data+start;
   802  }
   803  
   804  char* dangerousString2() {
   805  	int pageSize = 4096;
   806  	char *data = mmap(0, 3 * pageSize, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, 0, 0);
   807  	mprotect(data + 2 * pageSize,pageSize,PROT_NONE);
   808  	int start = pageSize - 123 - 1; // last 123 bytes of first page + 1 null byte
   809  	int i = start;
   810  	for (; i < 2 * pageSize; i++) {
   811  	data[i] = 'x';
   812  	}
   813  	data[2*pageSize -1 ] = 0;
   814  	return data+start;
   815  }
   816  #else
   817  char *dangerousString1() { return NULL; }
   818  char *dangerousString2() { return NULL; }
   819  #endif
   820  
   821  // issue 26066
   822  const unsigned long long int issue26066 = (const unsigned long long) -1;
   823  
   824  // issue 26517
   825  // Introduce two pointer types which are distinct, but have the same
   826  // base type. Make sure that both of those pointer types get resolved
   827  // correctly. Before the fix for 26517 if one of these pointer types
   828  // was resolved before the other one was processed, the second one
   829  // would never be resolved.
   830  // Before this issue was fixed this test failed on Windows,
   831  // where va_list expands to a named char* type.
   832  typedef va_list TypeOne;
   833  typedef char *TypeTwo;
   834  
   835  // issue 28540
   836  
   837  static void twoargs1(void *p, int n) {}
   838  static void *twoargs2() { return 0; }
   839  static int twoargs3(void * p) { return 0; }
   840  
   841  // issue 28545
   842  // Failed to add type conversion for negative constant.
   843  
   844  static void issue28545F(char **p, int n, complex double a) {}
   845  
   846  // issue 28772 part 1 - part 2 in testx.go
   847  // Failed to add type conversion for Go constant set to C constant.
   848  // No runtime test; just make sure it compiles.
   849  
   850  #define issue28772Constant 1
   851  
   852  // issue 28896
   853  // cgo was incorrectly adding padding after a packed struct.
   854  typedef struct {
   855  	void *f1;
   856  	uint32_t f2;
   857  } __attribute__((__packed__)) innerPacked;
   858  
   859  typedef struct {
   860  	innerPacked g1;
   861  	uint64_t g2;
   862  } outerPacked;
   863  
   864  typedef struct {
   865  	void *f1;
   866  	uint32_t f2;
   867  } innerUnpacked;
   868  
   869  typedef struct {
   870  	innerUnpacked g1;
   871  	uint64_t g2;
   872  } outerUnpacked;
   873  
   874  size_t offset(int x) {
   875  	switch (x) {
   876  	case 0:
   877  		return offsetof(innerPacked, f2);
   878  	case 1:
   879  		return offsetof(outerPacked, g2);
   880  	case 2:
   881  		return offsetof(innerUnpacked, f2);
   882  	case 3:
   883  		return offsetof(outerUnpacked, g2);
   884  	default:
   885  		abort();
   886  	}
   887  }
   888  
   889  // issue 29748
   890  
   891  typedef struct { char **p; } S29748;
   892  static int f29748(S29748 *p) { return 0; }
   893  
   894  // issue 29781
   895  // Error with newline inserted into constant expression.
   896  // Compilation test only, nothing to run.
   897  
   898  static void issue29781F(char **p, int n) {}
   899  #define ISSUE29781C 0
   900  
   901  // issue 31093
   902  static uint16_t issue31093F(uint16_t v) { return v; }
   903  
   904  // issue 32579
   905  typedef struct S32579 { unsigned char data[1]; } S32579;
   906  
   907  // issue 37033, cgo.Handle
   908  extern void GoFunc37033(uintptr_t handle);
   909  void cFunc37033(uintptr_t handle) { GoFunc37033(handle); }
   910  
   911  // issue 38649
   912  // Test that #define'd type aliases work.
   913  #define netbsd_gid unsigned int
   914  
   915  // issue 40494
   916  // Inconsistent handling of tagged enum and union types.
   917  enum Enum40494 { X_40494 };
   918  union Union40494 { int x; };
   919  void issue40494(enum Enum40494 e, union Union40494* up) {}
   920  
   921  // Issue 45451, bad handling of go:notinheap types.
   922  typedef struct issue45451Undefined issue45451;
   923  
   924  // Issue 49633, example of cgo.Handle with void*.
   925  extern void GoFunc49633(void*);
   926  void cfunc49633(void *context) { GoFunc49633(context); }
   927  
   928  */
   929  import "C"
   930  
   931  import (
   932  	"context"
   933  	"fmt"
   934  	"math"
   935  	"math/rand"
   936  	"os"
   937  	"os/signal"
   938  	"reflect"
   939  	"runtime"
   940  	"runtime/cgo"
   941  	"sync"
   942  	"syscall"
   943  	"testing"
   944  	"time"
   945  	"unsafe"
   946  )
   947  
   948  // alignment
   949  
   950  func testAlign(t *testing.T) {
   951  	var evt C.SDL_KeyboardEvent
   952  	C.makeEvent(&evt)
   953  	if C.same(&evt, evt.typ, evt.which, evt.state, evt.keysym.scancode, evt.keysym.sym, evt.keysym.mod, evt.keysym.unicode) == 0 {
   954  		t.Error("*** bad alignment")
   955  		C.cTest(&evt)
   956  		t.Errorf("Go: %#x %#x %#x %#x %#x %#x %#x\n",
   957  			evt.typ, evt.which, evt.state, evt.keysym.scancode,
   958  			evt.keysym.sym, evt.keysym.mod, evt.keysym.unicode)
   959  		t.Error(evt)
   960  	}
   961  }
   962  
   963  // api
   964  
   965  const greeting = "hello, world"
   966  
   967  type testPair struct {
   968  	Name      string
   969  	Got, Want interface{}
   970  }
   971  
   972  var testPairs = []testPair{
   973  	{"GoString", C.GoString(C.greeting), greeting},
   974  	{"GoStringN", C.GoStringN(C.greeting, 5), greeting[:5]},
   975  	{"GoBytes", C.GoBytes(unsafe.Pointer(C.greeting), 5), []byte(greeting[:5])},
   976  }
   977  
   978  func testHelpers(t *testing.T) {
   979  	for _, pair := range testPairs {
   980  		if !reflect.DeepEqual(pair.Got, pair.Want) {
   981  			t.Errorf("%s: got %#v, want %#v", pair.Name, pair.Got, pair.Want)
   982  		}
   983  	}
   984  }
   985  
   986  // basic test cases
   987  
   988  const EINVAL = C.EINVAL /* test #define */
   989  
   990  var KILO = C.KILO
   991  
   992  func uuidgen() {
   993  	var uuid C.cgo_uuid_t
   994  	C.uuid_generate(&uuid[0])
   995  }
   996  
   997  func Strtol(s string, base int) (int, error) {
   998  	p := C.CString(s)
   999  	n, err := C.strtol(p, nil, C.int(base))
  1000  	C.free(unsafe.Pointer(p))
  1001  	return int(n), err
  1002  }
  1003  
  1004  func Atol(s string) int {
  1005  	p := C.CString(s)
  1006  	n := C.atol(p)
  1007  	C.free(unsafe.Pointer(p))
  1008  	return int(n)
  1009  }
  1010  
  1011  func testConst(t *testing.T) {
  1012  	C.myConstFunc(nil, 0, nil)
  1013  }
  1014  
  1015  func testEnum(t *testing.T) {
  1016  	if C.Enum1 != 1 || C.Enum2 != 2 {
  1017  		t.Error("bad enum", C.Enum1, C.Enum2)
  1018  	}
  1019  }
  1020  
  1021  func testNamedEnum(t *testing.T) {
  1022  	e := new(C.enum_E)
  1023  
  1024  	*e = C.Enum1
  1025  	if *e != 1 {
  1026  		t.Error("bad enum", C.Enum1)
  1027  	}
  1028  
  1029  	*e = C.Enum2
  1030  	if *e != 2 {
  1031  		t.Error("bad enum", C.Enum2)
  1032  	}
  1033  }
  1034  
  1035  func testCastToEnum(t *testing.T) {
  1036  	e := C.enum_E(C.Enum1)
  1037  	if e != 1 {
  1038  		t.Error("bad enum", C.Enum1)
  1039  	}
  1040  
  1041  	e = C.enum_E(C.Enum2)
  1042  	if e != 2 {
  1043  		t.Error("bad enum", C.Enum2)
  1044  	}
  1045  }
  1046  
  1047  func testAtol(t *testing.T) {
  1048  	l := Atol("123")
  1049  	if l != 123 {
  1050  		t.Error("Atol 123: ", l)
  1051  	}
  1052  }
  1053  
  1054  func testErrno(t *testing.T) {
  1055  	p := C.CString("no-such-file")
  1056  	m := C.CString("r")
  1057  	f, err := C.fopen(p, m)
  1058  	C.free(unsafe.Pointer(p))
  1059  	C.free(unsafe.Pointer(m))
  1060  	if err == nil {
  1061  		C.fclose(f)
  1062  		t.Fatalf("C.fopen: should fail")
  1063  	}
  1064  	if err != syscall.ENOENT {
  1065  		t.Fatalf("C.fopen: unexpected error: %v", err)
  1066  	}
  1067  }
  1068  
  1069  func testMultipleAssign(t *testing.T) {
  1070  	p := C.CString("234")
  1071  	n, m := C.strtol(p, nil, 345), C.strtol(p, nil, 10)
  1072  	if runtime.GOOS == "openbsd" {
  1073  		// Bug in OpenBSD strtol(3) - base > 36 succeeds.
  1074  		if (n != 0 && n != 239089) || m != 234 {
  1075  			t.Fatal("Strtol x2: ", n, m)
  1076  		}
  1077  	} else if n != 0 || m != 234 {
  1078  		t.Fatal("Strtol x2: ", n, m)
  1079  	}
  1080  	C.free(unsafe.Pointer(p))
  1081  }
  1082  
  1083  var (
  1084  	cuint  = (C.uint)(0)
  1085  	culong C.ulong
  1086  	cchar  C.char
  1087  )
  1088  
  1089  type Context struct {
  1090  	ctx *C.struct_ibv_context
  1091  }
  1092  
  1093  func benchCgoCall(b *testing.B) {
  1094  	b.Run("add-int", func(b *testing.B) {
  1095  		const x = C.int(2)
  1096  		const y = C.int(3)
  1097  
  1098  		for i := 0; i < b.N; i++ {
  1099  			C.add(x, y)
  1100  		}
  1101  	})
  1102  
  1103  	b.Run("one-pointer", func(b *testing.B) {
  1104  		var a0 C.VkDeviceCreateInfo
  1105  		for i := 0; i < b.N; i++ {
  1106  			C.handleComplexPointer(&a0)
  1107  		}
  1108  	})
  1109  	b.Run("eight-pointers", func(b *testing.B) {
  1110  		var a0, a1, a2, a3, a4, a5, a6, a7 C.VkDeviceCreateInfo
  1111  		for i := 0; i < b.N; i++ {
  1112  			C.handleComplexPointer8(&a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7)
  1113  		}
  1114  	})
  1115  	b.Run("eight-pointers-nil", func(b *testing.B) {
  1116  		var a0, a1, a2, a3, a4, a5, a6, a7 *C.VkDeviceCreateInfo
  1117  		for i := 0; i < b.N; i++ {
  1118  			C.handleComplexPointer8(a0, a1, a2, a3, a4, a5, a6, a7)
  1119  		}
  1120  	})
  1121  	b.Run("eight-pointers-array", func(b *testing.B) {
  1122  		var a [8]C.VkDeviceCreateInfo
  1123  		for i := 0; i < b.N; i++ {
  1124  			C.handleComplexPointer8(&a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7])
  1125  		}
  1126  	})
  1127  	b.Run("eight-pointers-slice", func(b *testing.B) {
  1128  		a := make([]C.VkDeviceCreateInfo, 8)
  1129  		for i := 0; i < b.N; i++ {
  1130  			C.handleComplexPointer8(&a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7])
  1131  		}
  1132  	})
  1133  }
  1134  
  1135  // Benchmark measuring overhead from Go to C and back to Go (via a callback)
  1136  func benchCallback(b *testing.B) {
  1137  	var x = false
  1138  	for i := 0; i < b.N; i++ {
  1139  		nestedCall(func() { x = true })
  1140  	}
  1141  	if !x {
  1142  		b.Fatal("nestedCall was not invoked")
  1143  	}
  1144  }
  1145  
  1146  var sinkString string
  1147  
  1148  func benchGoString(b *testing.B) {
  1149  	for i := 0; i < b.N; i++ {
  1150  		sinkString = C.GoString(C.cstr)
  1151  	}
  1152  	const want = "abcefghijklmnopqrstuvwxyzABCEFGHIJKLMNOPQRSTUVWXYZ1234567890"
  1153  	if sinkString != want {
  1154  		b.Fatalf("%q != %q", sinkString, want)
  1155  	}
  1156  }
  1157  
  1158  // Static (build-time) test that syntax traversal visits all operands of s[i:j:k].
  1159  func sliceOperands(array [2000]int) {
  1160  	_ = array[C.KILO:C.KILO:C.KILO] // no type error
  1161  }
  1162  
  1163  // set in cgo_thread_lock.go init
  1164  var testThreadLockFunc = func(*testing.T) {}
  1165  
  1166  // complex alignment
  1167  
  1168  func TestComplexAlign(t *testing.T) {
  1169  	if C.cplxAlign.x != 3.14 {
  1170  		t.Errorf("got %v, expected 3.14", C.cplxAlign.x)
  1171  	}
  1172  	if C.cplxAlign.y != 2.17 {
  1173  		t.Errorf("got %v, expected 2.17", C.cplxAlign.y)
  1174  	}
  1175  }
  1176  
  1177  // constants and pointer checking
  1178  
  1179  func testCheckConst(t *testing.T) {
  1180  	// The test is that this compiles successfully.
  1181  	p := C.malloc(C.size_t(unsafe.Sizeof(C.int(0))))
  1182  	defer C.free(p)
  1183  	C.CheckConstFunc(&C.CheckConstStruct{(*C.int)(p)}, C.CheckConstVal)
  1184  }
  1185  
  1186  // duplicate symbol
  1187  
  1188  func duplicateSymbols() {
  1189  	fmt.Printf("%v %v %v\n", C.base_symbol, C.alias_one, C.alias_two)
  1190  }
  1191  
  1192  // environment
  1193  
  1194  // This is really an os package test but here for convenience.
  1195  func testSetEnv(t *testing.T) {
  1196  	if runtime.GOOS == "windows" {
  1197  		// Go uses SetEnvironmentVariable on windows. However,
  1198  		// C runtime takes a *copy* at process startup of the
  1199  		// OS environment, and stores it in environ/envp.
  1200  		// It is this copy that	getenv/putenv manipulate.
  1201  		t.Logf("skipping test")
  1202  		return
  1203  	}
  1204  	const key = "CGO_OS_TEST_KEY"
  1205  	const val = "CGO_OS_TEST_VALUE"
  1206  	os.Setenv(key, val)
  1207  	keyc := C.CString(key)
  1208  	defer C.free(unsafe.Pointer(keyc))
  1209  	v := C.getenv(keyc)
  1210  	if uintptr(unsafe.Pointer(v)) == 0 {
  1211  		t.Fatal("getenv returned NULL")
  1212  	}
  1213  	vs := C.GoString(v)
  1214  	if vs != val {
  1215  		t.Fatalf("getenv() = %q; want %q", vs, val)
  1216  	}
  1217  }
  1218  
  1219  // function pointer variables
  1220  
  1221  func callBridge(f C.intFunc) int {
  1222  	return int(C.bridge_int_func(f))
  1223  }
  1224  
  1225  func callCBridge(f C.intFunc) C.int {
  1226  	return C.bridge_int_func(f)
  1227  }
  1228  
  1229  func testFpVar(t *testing.T) {
  1230  	const expected = 42
  1231  	f := C.intFunc(C.fortytwo)
  1232  	res1 := C.bridge_int_func(f)
  1233  	if r1 := int(res1); r1 != expected {
  1234  		t.Errorf("got %d, want %d", r1, expected)
  1235  	}
  1236  	res2 := callCBridge(f)
  1237  	if r2 := int(res2); r2 != expected {
  1238  		t.Errorf("got %d, want %d", r2, expected)
  1239  	}
  1240  	r3 := callBridge(f)
  1241  	if r3 != expected {
  1242  		t.Errorf("got %d, want %d", r3, expected)
  1243  	}
  1244  }
  1245  
  1246  // issue 1222
  1247  type AsyncEvent struct {
  1248  	event C.struct_ibv_async_event
  1249  }
  1250  
  1251  // issue 1635
  1252  
  1253  func test1635(t *testing.T) {
  1254  	C.scatter()
  1255  	if v := C.hola; v != 0 {
  1256  		t.Fatalf("C.hola is %d, should be 0", v)
  1257  	}
  1258  	if v := C.testHola(); v != 0 {
  1259  		t.Fatalf("C.testHola() is %d, should be 0", v)
  1260  	}
  1261  }
  1262  
  1263  // issue 2470
  1264  
  1265  func testUnsignedInt(t *testing.T) {
  1266  	a := (int64)(C.UINT32VAL)
  1267  	b := (int64)(0xc008427b)
  1268  	if a != b {
  1269  		t.Errorf("Incorrect unsigned int - got %x, want %x", a, b)
  1270  	}
  1271  }
  1272  
  1273  // issue 3250
  1274  
  1275  func test3250(t *testing.T) {
  1276  	if runtime.GOOS == "windows" {
  1277  		t.Skip("not applicable on windows")
  1278  	}
  1279  
  1280  	t.Skip("skipped, see golang.org/issue/5885")
  1281  	var (
  1282  		thres = 1
  1283  		sig   = syscall_dot_SIGCHLD
  1284  	)
  1285  	type result struct {
  1286  		n   int
  1287  		sig os.Signal
  1288  	}
  1289  	var (
  1290  		sigCh     = make(chan os.Signal, 10)
  1291  		waitStart = make(chan struct{})
  1292  		waitDone  = make(chan result)
  1293  	)
  1294  
  1295  	signal.Notify(sigCh, sig)
  1296  
  1297  	go func() {
  1298  		n := 0
  1299  		alarm := time.After(time.Second * 3)
  1300  		for {
  1301  			select {
  1302  			case <-waitStart:
  1303  				waitStart = nil
  1304  			case v := <-sigCh:
  1305  				n++
  1306  				if v != sig || n > thres {
  1307  					waitDone <- result{n, v}
  1308  					return
  1309  				}
  1310  			case <-alarm:
  1311  				waitDone <- result{n, sig}
  1312  				return
  1313  			}
  1314  		}
  1315  	}()
  1316  
  1317  	waitStart <- struct{}{}
  1318  	C.testSendSIG()
  1319  	r := <-waitDone
  1320  	if r.sig != sig {
  1321  		t.Fatalf("received signal %v, but want %v", r.sig, sig)
  1322  	}
  1323  	t.Logf("got %d signals\n", r.n)
  1324  	if r.n <= thres {
  1325  		t.Fatalf("expected more than %d", thres)
  1326  	}
  1327  }
  1328  
  1329  // issue 3261
  1330  
  1331  func testLibgcc(t *testing.T) {
  1332  	var table = []struct {
  1333  		in, out C.int
  1334  	}{
  1335  		{0, 0},
  1336  		{1, 1},
  1337  		{-42, 42},
  1338  		{1000300, 1000300},
  1339  		{1 - 1<<31, 1<<31 - 1},
  1340  	}
  1341  	for _, v := range table {
  1342  		if o := C.vabs(v.in); o != v.out {
  1343  			t.Fatalf("abs(%d) got %d, should be %d", v.in, o, v.out)
  1344  			return
  1345  		}
  1346  	}
  1347  }
  1348  
  1349  // issue 3729
  1350  
  1351  func test3729(t *testing.T) {
  1352  	if runtime.GOOS == "windows" {
  1353  		t.Skip("skipping on windows")
  1354  	}
  1355  
  1356  	_, e := C.g()
  1357  	if e != syscall.E2BIG {
  1358  		t.Errorf("got %q, expect %q", e, syscall.E2BIG)
  1359  	}
  1360  	_, e = C.g2(C.EINVAL, C._expA, C._expB, C._expC, C._expD)
  1361  	if e != syscall.EINVAL {
  1362  		t.Errorf("got %q, expect %q", e, syscall.EINVAL)
  1363  	}
  1364  }
  1365  
  1366  // issue 3945
  1367  
  1368  func testPrintf(t *testing.T) {
  1369  	C.say()
  1370  }
  1371  
  1372  // issue 4054
  1373  
  1374  var issue4054a = []int{C.A, C.B, C.C, C.D, C.E, C.F, C.G, C.H, C.I, C.J}
  1375  
  1376  // issue 4339
  1377  
  1378  func test4339(t *testing.T) {
  1379  	C.handle4339(&C.exported4339)
  1380  }
  1381  
  1382  // issue 4417
  1383  
  1384  func testBoolAlign(t *testing.T) {
  1385  	b := C.c_bool(true, true, 10, true, false)
  1386  	if b != 10 {
  1387  		t.Fatalf("found %d expected 10\n", b)
  1388  	}
  1389  	b = C.c_bool(true, true, 5, true, true)
  1390  	if b != 5 {
  1391  		t.Fatalf("found %d expected 5\n", b)
  1392  	}
  1393  	b = C.c_bool(true, true, 3, true, false)
  1394  	if b != 3 {
  1395  		t.Fatalf("found %d expected 3\n", b)
  1396  	}
  1397  	b = C.c_bool(false, false, 1, true, false)
  1398  	if b != 1 {
  1399  		t.Fatalf("found %d expected 1\n", b)
  1400  	}
  1401  	b = C.c_bool(false, true, 200, true, false)
  1402  	if b != 200 {
  1403  		t.Fatalf("found %d expected 200\n", b)
  1404  	}
  1405  }
  1406  
  1407  // issue 4857
  1408  
  1409  func test4857() {
  1410  	_ = C.issue4857()
  1411  }
  1412  
  1413  // issue 5224
  1414  
  1415  func testCflags(t *testing.T) {
  1416  	is_windows := C.is_windows == 1
  1417  	if is_windows != (runtime.GOOS == "windows") {
  1418  		t.Errorf("is_windows: %v, runtime.GOOS: %s", is_windows, runtime.GOOS)
  1419  	}
  1420  	if C.common != 123 {
  1421  		t.Errorf("common: %v (expected 123)", C.common)
  1422  	}
  1423  }
  1424  
  1425  // issue 5227
  1426  
  1427  func test5227(t *testing.T) {
  1428  	C.init()
  1429  }
  1430  
  1431  func selectfont() C.Fontinfo {
  1432  	return C.SansTypeface
  1433  }
  1434  
  1435  // issue 5242
  1436  
  1437  func test5242(t *testing.T) {
  1438  	if got := C.issue5242(C.foo{}, C.bar{}); got != 5242 {
  1439  		t.Errorf("got %v", got)
  1440  	}
  1441  }
  1442  
  1443  func test5603(t *testing.T) {
  1444  	var x [5]int64
  1445  	exp := int64(C.issue5603exp)
  1446  	x[0] = int64(C.issue5603foo0())
  1447  	x[1] = int64(C.issue5603foo1(nil))
  1448  	x[2] = int64(C.issue5603foo2(nil, nil))
  1449  	x[3] = int64(C.issue5603foo3(nil, nil, nil))
  1450  	x[4] = int64(C.issue5603foo4(nil, nil, nil, nil))
  1451  	for i, v := range x {
  1452  		if v != exp {
  1453  			t.Errorf("issue5603foo%d() returns %v, expected %v", i, v, exp)
  1454  		}
  1455  	}
  1456  }
  1457  
  1458  // issue 5337
  1459  
  1460  func test5337(t *testing.T) {
  1461  	C.test5337()
  1462  }
  1463  
  1464  // issue 5740
  1465  
  1466  func test5740(t *testing.T) {
  1467  	if v := C.test5740a() + C.test5740b(); v != 5 {
  1468  		t.Errorf("expected 5, got %v", v)
  1469  	}
  1470  }
  1471  
  1472  // issue 5986
  1473  
  1474  func test5986(t *testing.T) {
  1475  	C.output5986()
  1476  }
  1477  
  1478  // issue 6128
  1479  
  1480  func test6128() {
  1481  	// nothing to run, just make sure this compiles.
  1482  	_ = C.X
  1483  }
  1484  
  1485  // issue 6390
  1486  
  1487  func test6390(t *testing.T) {
  1488  	p1 := C.malloc(1024)
  1489  	if p1 == nil {
  1490  		t.Fatalf("C.malloc(1024) returned nil")
  1491  	}
  1492  	p2 := C.malloc(0)
  1493  	if p2 == nil {
  1494  		t.Fatalf("C.malloc(0) returned nil")
  1495  	}
  1496  	C.free(p1)
  1497  	C.free(p2)
  1498  }
  1499  
  1500  func test6472() {
  1501  	// nothing to run, just make sure this compiles
  1502  	s := new(C.z)
  1503  	println(s.y[0].x)
  1504  }
  1505  
  1506  // issue 6506
  1507  
  1508  func test6506() {
  1509  	// nothing to run, just make sure this compiles
  1510  	var x C.size_t
  1511  
  1512  	C.calloc(x, x)
  1513  	C.malloc(x)
  1514  	C.realloc(nil, x)
  1515  	C.memcpy(nil, nil, x)
  1516  	C.memcmp(nil, nil, x)
  1517  	C.memmove(nil, nil, x)
  1518  	C.strncpy(nil, nil, x)
  1519  	C.strncmp(nil, nil, x)
  1520  	C.strncat(nil, nil, x)
  1521  	x = C.strxfrm(nil, nil, x)
  1522  	C.memchr(nil, 0, x)
  1523  	x = C.strcspn(nil, nil)
  1524  	x = C.strspn(nil, nil)
  1525  	C.memset(nil, 0, x)
  1526  	x = C.strlen(nil)
  1527  	_ = x
  1528  }
  1529  
  1530  // issue 6612
  1531  
  1532  func testNaming(t *testing.T) {
  1533  	C.myfunc()
  1534  	C.myfunc_def()
  1535  	if v := C.myvar; v != 5 {
  1536  		t.Errorf("C.myvar = %d, want 5", v)
  1537  	}
  1538  	if v := C.myvar_def; v != 5 {
  1539  		t.Errorf("C.myvar_def = %d, want 5", v)
  1540  	}
  1541  	if s := C.GoString(C.mytext); s != "abcdef" {
  1542  		t.Errorf("C.mytext = %q, want %q", s, "abcdef")
  1543  	}
  1544  	if s := C.GoString(C.mytext_def); s != "abcdef" {
  1545  		t.Errorf("C.mytext_def = %q, want %q", s, "abcdef")
  1546  	}
  1547  	if c := C.myenum; c != 1234 {
  1548  		t.Errorf("C.myenum = %v, want 1234", c)
  1549  	}
  1550  	if c := C.myenum_def; c != 1234 {
  1551  		t.Errorf("C.myenum_def = %v, want 1234", c)
  1552  	}
  1553  	{
  1554  		const c = C.myenum
  1555  		if c != 1234 {
  1556  			t.Errorf("C.myenum as const = %v, want 1234", c)
  1557  		}
  1558  	}
  1559  	{
  1560  		const c = C.myenum_def
  1561  		if c != 1234 {
  1562  			t.Errorf("C.myenum as const = %v, want 1234", c)
  1563  		}
  1564  	}
  1565  	if c := C.myint_def; c != 12345 {
  1566  		t.Errorf("C.myint_def = %v, want 12345", c)
  1567  	}
  1568  	{
  1569  		const c = C.myint_def
  1570  		if c != 12345 {
  1571  			t.Errorf("C.myint as const = %v, want 12345", c)
  1572  		}
  1573  	}
  1574  
  1575  	if c := C.myfloat_def; c != 1.5 {
  1576  		t.Errorf("C.myint_def = %v, want 1.5", c)
  1577  	}
  1578  	{
  1579  		const c = C.myfloat_def
  1580  		if c != 1.5 {
  1581  			t.Errorf("C.myint as const = %v, want 1.5", c)
  1582  		}
  1583  	}
  1584  
  1585  	if s := C.mystring_def; s != "hello" {
  1586  		t.Errorf("C.mystring_def = %q, want %q", s, "hello")
  1587  	}
  1588  }
  1589  
  1590  // issue 6907
  1591  
  1592  func test6907(t *testing.T) {
  1593  	want := "yarn"
  1594  	if got := C.GoString(C.Issue6907CopyString(want)); got != want {
  1595  		t.Errorf("C.GoString(C.Issue6907CopyString(%q)) == %q, want %q", want, got, want)
  1596  	}
  1597  }
  1598  
  1599  // issue 7560
  1600  
  1601  func test7560(t *testing.T) {
  1602  	// some mingw don't implement __packed__ correctly.
  1603  	if C.offset7560() != 1 {
  1604  		t.Skip("C compiler did not pack struct")
  1605  	}
  1606  
  1607  	// C.misaligned should have x but then a padding field to get to the end of the struct.
  1608  	// There should not be a field named 'y'.
  1609  	var v C.misaligned
  1610  	rt := reflect.TypeOf(&v).Elem()
  1611  	if rt.NumField() != 2 || rt.Field(0).Name != "x" || rt.Field(1).Name != "_" {
  1612  		t.Errorf("unexpected fields in C.misaligned:\n")
  1613  		for i := 0; i < rt.NumField(); i++ {
  1614  			t.Logf("%+v\n", rt.Field(i))
  1615  		}
  1616  	}
  1617  }
  1618  
  1619  // issue 7786
  1620  
  1621  func f() {
  1622  	var x1 *C.typedef_test7786
  1623  	var x2 *C.struct_test7786
  1624  	x1 = x2
  1625  	x2 = x1
  1626  	C.f7786(x1)
  1627  	C.f7786(x2)
  1628  	C.g7786(x1)
  1629  	C.g7786(x2)
  1630  
  1631  	var b1 *C.typedef_body7786
  1632  	var b2 *C.struct_body7786
  1633  	b1 = b2
  1634  	b2 = b1
  1635  	C.b7786(b1)
  1636  	C.b7786(b2)
  1637  	C.c7786(b1)
  1638  	C.c7786(b2)
  1639  
  1640  	var u1 *C.typedef_union7786
  1641  	var u2 *C.union_union7786
  1642  	u1 = u2
  1643  	u2 = u1
  1644  	C.u7786(u1)
  1645  	C.u7786(u2)
  1646  	C.v7786(u1)
  1647  	C.v7786(u2)
  1648  }
  1649  
  1650  // issue 8092
  1651  
  1652  func test8092(t *testing.T) {
  1653  	tests := []struct {
  1654  		s    string
  1655  		a, b *C.char
  1656  	}{
  1657  		{"text", &C.text[0], C.ctext()},
  1658  		{"data", &C.data[0], C.cdata()},
  1659  	}
  1660  	for _, test := range tests {
  1661  		if test.a != test.b {
  1662  			t.Errorf("%s: pointer mismatch: %v != %v", test.s, test.a, test.b)
  1663  		}
  1664  		if got := C.GoString(test.a); got != test.s {
  1665  			t.Errorf("%s: points at %#v, want %#v", test.s, got, test.s)
  1666  		}
  1667  	}
  1668  }
  1669  
  1670  // issues 8368 and 8441
  1671  
  1672  func issue8368(one *C.struct_one, two *C.struct_two) {
  1673  }
  1674  
  1675  func issue8441(one *C.one, two *C.two) {
  1676  	issue8441(two.x, one.x)
  1677  }
  1678  
  1679  // issue 8428
  1680  
  1681  var _ = C.struct_issue8428one{
  1682  	b: C.char(0),
  1683  	// The trailing rest field is not available in cgo.
  1684  	// See issue 11925.
  1685  	// rest: [0]C.char{},
  1686  }
  1687  
  1688  var _ = C.struct_issue8428two{
  1689  	p:    unsafe.Pointer(nil),
  1690  	b:    C.char(0),
  1691  	rest: [0]C.char{},
  1692  }
  1693  
  1694  var _ = C.struct_issue8428three{
  1695  	w: [1][2][3][0]C.char{},
  1696  	x: [2][3][0][1]C.char{},
  1697  	y: [3][0][1][2]C.char{},
  1698  	z: [0][1][2][3]C.char{},
  1699  }
  1700  
  1701  // issue 8811
  1702  
  1703  func test8811(t *testing.T) {
  1704  	C.issue8811Execute()
  1705  }
  1706  
  1707  // issue 9557
  1708  
  1709  func test9557(t *testing.T) {
  1710  	// implicitly dereference a Go variable
  1711  	foo := C.issue9557foo
  1712  	if v := foo.a; v != 42 {
  1713  		t.Fatalf("foo.a expected 42, but got %d", v)
  1714  	}
  1715  
  1716  	// explicitly dereference a C variable
  1717  	if v := (*C.issue9557foo).a; v != 42 {
  1718  		t.Fatalf("(*C.issue9557foo).a expected 42, but is %d", v)
  1719  	}
  1720  
  1721  	// implicitly dereference a C variable
  1722  	if v := C.issue9557foo.a; v != 42 {
  1723  		t.Fatalf("C.issue9557foo.a expected 42, but is %d", v)
  1724  	}
  1725  }
  1726  
  1727  // issue 8331 part 1
  1728  
  1729  func issue8331a() C.issue8331 {
  1730  	return issue8331Var
  1731  }
  1732  
  1733  // issue 10303
  1734  
  1735  func test10303(t *testing.T, n int) {
  1736  	if runtime.Compiler == "gccgo" {
  1737  		t.Skip("gccgo permits C pointers on the stack")
  1738  	}
  1739  
  1740  	// Run at a few different stack depths just to avoid an unlucky pass
  1741  	// due to variables ending up on different pages.
  1742  	if n > 0 {
  1743  		test10303(t, n-1)
  1744  	}
  1745  	if t.Failed() {
  1746  		return
  1747  	}
  1748  	var x, y, z, v, si C.int
  1749  	var s C.Struct
  1750  	C.setintstar(&x)
  1751  	C.setintptr(&y)
  1752  	C.setvoidptr(unsafe.Pointer(&v))
  1753  	s.P = &si
  1754  	C.setstruct(s)
  1755  
  1756  	if uintptr(unsafe.Pointer(&x))&^0xfff == uintptr(unsafe.Pointer(&z))&^0xfff {
  1757  		t.Error("C int* argument on stack")
  1758  	}
  1759  	if uintptr(unsafe.Pointer(&y))&^0xfff == uintptr(unsafe.Pointer(&z))&^0xfff {
  1760  		t.Error("C intptr argument on stack")
  1761  	}
  1762  	if uintptr(unsafe.Pointer(&v))&^0xfff == uintptr(unsafe.Pointer(&z))&^0xfff {
  1763  		t.Error("C void* argument on stack")
  1764  	}
  1765  	if uintptr(unsafe.Pointer(&si))&^0xfff == uintptr(unsafe.Pointer(&z))&^0xfff {
  1766  		t.Error("C struct field pointer on stack")
  1767  	}
  1768  }
  1769  
  1770  // issue 11925
  1771  
  1772  func test11925(t *testing.T) {
  1773  	if C.sizeof_struct_a11925 != unsafe.Sizeof(C.struct_a11925{}) {
  1774  		t.Errorf("size of a changed: C %d, Go %d", C.sizeof_struct_a11925, unsafe.Sizeof(C.struct_a11925{}))
  1775  	}
  1776  	if C.sizeof_struct_b11925 != unsafe.Sizeof(C.struct_b11925{}) {
  1777  		t.Errorf("size of b changed: C %d, Go %d", C.sizeof_struct_b11925, unsafe.Sizeof(C.struct_b11925{}))
  1778  	}
  1779  }
  1780  
  1781  // issue 12030
  1782  
  1783  func test12030(t *testing.T) {
  1784  	buf := (*C.char)(C.malloc(256))
  1785  	defer C.free(unsafe.Pointer(buf))
  1786  	for _, f := range []float64{1.0, 2.0, 3.14} {
  1787  		C.issue12030conv(buf, C.double(f))
  1788  		got := C.GoString(buf)
  1789  		if want := fmt.Sprintf("d=%g", f); got != want {
  1790  			t.Fatalf("C.sprintf failed for %g: %q != %q", f, got, want)
  1791  		}
  1792  	}
  1793  }
  1794  
  1795  // issue 13402
  1796  
  1797  var _ C.complexfloat
  1798  var _ C.complexdouble
  1799  
  1800  // issue 13930
  1801  // Test that cgo's multiple-value special form for
  1802  // C function calls works in variable declaration statements.
  1803  
  1804  var _, _ = C.abs(0)
  1805  
  1806  // issue 14838
  1807  
  1808  func test14838(t *testing.T) {
  1809  	data := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
  1810  	cData := C.CBytes(data)
  1811  	defer C.free(cData)
  1812  
  1813  	if C.check_cbytes((*C.char)(cData), C.size_t(len(data))) == 0 {
  1814  		t.Fatalf("mismatched data: expected %v, got %v", data, (*(*[10]byte)(unsafe.Pointer(cData)))[:])
  1815  	}
  1816  }
  1817  
  1818  // issue 17065
  1819  
  1820  var sink C.int
  1821  
  1822  func test17065(t *testing.T) {
  1823  	if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
  1824  		t.Skip("broken on darwin; issue 17065")
  1825  	}
  1826  	for i := range C.ii {
  1827  		sink = C.ii[i]
  1828  	}
  1829  }
  1830  
  1831  // issue 17537
  1832  
  1833  func test17537(t *testing.T) {
  1834  	v := C.S17537{i: 17537}
  1835  	if got, want := C.I17537(&v), C.int(17537); got != want {
  1836  		t.Errorf("got %d, want %d", got, want)
  1837  	}
  1838  
  1839  	p := (*C.char)(C.malloc(1))
  1840  	*p = 17
  1841  	if got, want := C.F17537(&p), C.int(17); got != want {
  1842  		t.Errorf("got %d, want %d", got, want)
  1843  	}
  1844  
  1845  	C.F18298(nil)
  1846  	var v18298 C.T18298_2
  1847  	C.G18298(C.T18298_1(v18298))
  1848  }
  1849  
  1850  // issue 17723
  1851  
  1852  func testAPI() {
  1853  	var cs *C.char
  1854  	cs = C.CString("hello")
  1855  	defer C.free(unsafe.Pointer(cs))
  1856  	var s string
  1857  	s = C.GoString((*C.char)(C.api_hello))
  1858  	s = C.GoStringN((*C.char)(C.api_hello), C.int(6))
  1859  	var b []byte
  1860  	b = C.GoBytes(unsafe.Pointer(C.api_hello), C.int(6))
  1861  	_, _ = s, b
  1862  	C.cstring_pointer_fun(nil)
  1863  }
  1864  
  1865  // issue 18126
  1866  
  1867  func test18126(t *testing.T) {
  1868  	p := C.malloc(1)
  1869  	_, err := C.Issue18126C(&p)
  1870  	C.free(p)
  1871  	_ = err
  1872  }
  1873  
  1874  // issue 18720
  1875  
  1876  func test18720(t *testing.T) {
  1877  	if got, want := C.HELLO_WORLD, "hello\000world"; got != want {
  1878  		t.Errorf("C.HELLO_WORLD == %q, expected %q", got, want)
  1879  	}
  1880  
  1881  	if got, want := C.VAR1, C.int(5); got != want {
  1882  		t.Errorf("C.VAR1 == %v, expected %v", got, want)
  1883  	}
  1884  
  1885  	if got, want := *C.ADDR, C.int(5); got != want {
  1886  		t.Errorf("*C.ADDR == %v, expected %v", got, want)
  1887  	}
  1888  
  1889  	if got, want := C.CALL, C.int(6); got != want {
  1890  		t.Errorf("C.CALL == %v, expected %v", got, want)
  1891  	}
  1892  
  1893  	if got, want := C.CALL, C.int(7); got != want {
  1894  		t.Errorf("C.CALL == %v, expected %v", got, want)
  1895  	}
  1896  
  1897  	// Issue 20125.
  1898  	if got, want := C.SIZE_OF_FOO, 1; got != want {
  1899  		t.Errorf("C.SIZE_OF_FOO == %v, expected %v", got, want)
  1900  	}
  1901  }
  1902  
  1903  // issue 20129
  1904  
  1905  func test20129(t *testing.T) {
  1906  	if C.issue20129 != 0 {
  1907  		t.Fatal("test is broken")
  1908  	}
  1909  	C.issue20129Foo()
  1910  	if C.issue20129 != 1 {
  1911  		t.Errorf("got %v but expected %v", C.issue20129, 1)
  1912  	}
  1913  	C.issue20129Bar()
  1914  	if C.issue20129 != 2 {
  1915  		t.Errorf("got %v but expected %v", C.issue20129, 2)
  1916  	}
  1917  }
  1918  
  1919  // issue 20369
  1920  
  1921  func test20369(t *testing.T) {
  1922  	if C.XUINT64_MAX != math.MaxUint64 {
  1923  		t.Fatalf("got %v, want %v", uint64(C.XUINT64_MAX), uint64(math.MaxUint64))
  1924  	}
  1925  }
  1926  
  1927  // issue 21668
  1928  
  1929  var issue21668_X = C.x21668
  1930  
  1931  // issue 21708
  1932  
  1933  func test21708(t *testing.T) {
  1934  	if got, want := C.CAST_TO_INT64, -1; got != want {
  1935  		t.Errorf("C.CAST_TO_INT64 == %v, expected %v", got, want)
  1936  	}
  1937  }
  1938  
  1939  // issue 21809
  1940  
  1941  func test21809(t *testing.T) {
  1942  	longVar := C.long(3)
  1943  	typedefVar := C.MySigned_t(4)
  1944  	typedefTypedefVar := C.MySigned2_t(5)
  1945  
  1946  	// all three should be considered identical to `long`
  1947  	if ret := C.takes_long(longVar); ret != 9 {
  1948  		t.Errorf("got %v but expected %v", ret, 9)
  1949  	}
  1950  	if ret := C.takes_long(typedefVar); ret != 16 {
  1951  		t.Errorf("got %v but expected %v", ret, 16)
  1952  	}
  1953  	if ret := C.takes_long(typedefTypedefVar); ret != 25 {
  1954  		t.Errorf("got %v but expected %v", ret, 25)
  1955  	}
  1956  
  1957  	// They should also be identical to the typedef'd type
  1958  	if ret := C.takes_typedef(longVar); ret != 9 {
  1959  		t.Errorf("got %v but expected %v", ret, 9)
  1960  	}
  1961  	if ret := C.takes_typedef(typedefVar); ret != 16 {
  1962  		t.Errorf("got %v but expected %v", ret, 16)
  1963  	}
  1964  	if ret := C.takes_typedef(typedefTypedefVar); ret != 25 {
  1965  		t.Errorf("got %v but expected %v", ret, 25)
  1966  	}
  1967  }
  1968  
  1969  // issue 22906
  1970  
  1971  func test22906(t *testing.T) {
  1972  	var x1 C.jobject = 0 // Note: 0, not nil. That makes sure we use uintptr for these types.
  1973  	_ = x1
  1974  	var x2 C.jclass = 0
  1975  	_ = x2
  1976  	var x3 C.jthrowable = 0
  1977  	_ = x3
  1978  	var x4 C.jstring = 0
  1979  	_ = x4
  1980  	var x5 C.jarray = 0
  1981  	_ = x5
  1982  	var x6 C.jbooleanArray = 0
  1983  	_ = x6
  1984  	var x7 C.jbyteArray = 0
  1985  	_ = x7
  1986  	var x8 C.jcharArray = 0
  1987  	_ = x8
  1988  	var x9 C.jshortArray = 0
  1989  	_ = x9
  1990  	var x10 C.jintArray = 0
  1991  	_ = x10
  1992  	var x11 C.jlongArray = 0
  1993  	_ = x11
  1994  	var x12 C.jfloatArray = 0
  1995  	_ = x12
  1996  	var x13 C.jdoubleArray = 0
  1997  	_ = x13
  1998  	var x14 C.jobjectArray = 0
  1999  	_ = x14
  2000  	var x15 C.jweak = 0
  2001  	_ = x15
  2002  }
  2003  
  2004  // issue 22958
  2005  // Nothing to run, just make sure this compiles.
  2006  var Vissue22958 C.issue22958Type
  2007  
  2008  func test23356(t *testing.T) {
  2009  	if got, want := C.a(), C.int(5); got != want {
  2010  		t.Errorf("C.a() == %v, expected %v", got, want)
  2011  	}
  2012  	if got, want := C.r(), C.int(3); got != want {
  2013  		t.Errorf("C.r() == %v, expected %v", got, want)
  2014  	}
  2015  }
  2016  
  2017  // issue 23720
  2018  
  2019  func Issue23720F() {
  2020  	var x C.issue23720A
  2021  	C.issue23720F(x)
  2022  }
  2023  
  2024  // issue 24206
  2025  
  2026  func test24206(t *testing.T) {
  2027  	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
  2028  		t.Skipf("skipping on %s/%s", runtime.GOOS, runtime.GOARCH)
  2029  	}
  2030  
  2031  	if l := len(C.GoString(C.dangerousString1())); l != 123 {
  2032  		t.Errorf("Incorrect string length - got %d, want 123", l)
  2033  	}
  2034  	if l := len(C.GoString(C.dangerousString2())); l != 4096+123 {
  2035  		t.Errorf("Incorrect string length - got %d, want %d", l, 4096+123)
  2036  	}
  2037  }
  2038  
  2039  // issue 25143
  2040  
  2041  func issue25143sum(ns ...C.int) C.int {
  2042  	total := C.int(0)
  2043  	for _, n := range ns {
  2044  		total += n
  2045  	}
  2046  	return total
  2047  }
  2048  
  2049  func test25143(t *testing.T) {
  2050  	if got, want := issue25143sum(1, 2, 3), C.int(6); got != want {
  2051  		t.Errorf("issue25143sum(1, 2, 3) == %v, expected %v", got, want)
  2052  	}
  2053  }
  2054  
  2055  // issue 26066
  2056  // Wrong type of constant with GCC 8 and newer.
  2057  
  2058  func test26066(t *testing.T) {
  2059  	var i = int64(C.issue26066)
  2060  	if i != -1 {
  2061  		t.Errorf("got %d, want -1", i)
  2062  	}
  2063  }
  2064  
  2065  // issue 26517
  2066  var a C.TypeOne
  2067  var b C.TypeTwo
  2068  
  2069  // issue 27660
  2070  // Stress the interaction between the race detector and cgo in an
  2071  // attempt to reproduce the memory corruption described in #27660.
  2072  // The bug was very timing sensitive; at the time of writing this
  2073  // test would only trigger the bug about once out of every five runs.
  2074  
  2075  func test27660(t *testing.T) {
  2076  	ctx, cancel := context.WithCancel(context.Background())
  2077  	defer cancel()
  2078  	ints := make([]int, 100)
  2079  	locks := make([]sync.Mutex, 100)
  2080  	// Slowly create threads so that ThreadSanitizer is forced to
  2081  	// frequently resize its SyncClocks.
  2082  	for i := 0; i < 100; i++ {
  2083  		go func() {
  2084  			for ctx.Err() == nil {
  2085  				// Sleep in C for long enough that it is likely that the runtime
  2086  				// will retake this goroutine's currently wired P.
  2087  				C.usleep(1000 /* 1ms */)
  2088  				runtime.Gosched() // avoid starvation (see #28701)
  2089  			}
  2090  		}()
  2091  		go func() {
  2092  			// Trigger lots of synchronization and memory reads/writes to
  2093  			// increase the likelihood that the race described in #27660
  2094  			// results in corruption of ThreadSanitizer's internal state
  2095  			// and thus an assertion failure or segfault.
  2096  			i := 0
  2097  			for ctx.Err() == nil {
  2098  				j := rand.Intn(100)
  2099  				locks[j].Lock()
  2100  				ints[j]++
  2101  				locks[j].Unlock()
  2102  				// needed for gccgo, to avoid creation of an
  2103  				// unpreemptible "fast path" in this loop. Choice
  2104  				// of (1<<24) is somewhat arbitrary.
  2105  				if i%(1<<24) == 0 {
  2106  					runtime.Gosched()
  2107  				}
  2108  				i++
  2109  
  2110  			}
  2111  		}()
  2112  		time.Sleep(time.Millisecond)
  2113  	}
  2114  }
  2115  
  2116  // issue 28540
  2117  
  2118  func twoargsF() {
  2119  	v := []string{}
  2120  	C.twoargs1(C.twoargs2(), C.twoargs3(unsafe.Pointer(&v)))
  2121  }
  2122  
  2123  // issue 28545
  2124  
  2125  func issue28545G(p **C.char) {
  2126  	C.issue28545F(p, -1, (0))
  2127  	C.issue28545F(p, 2+3, complex(1, 1))
  2128  	C.issue28545F(p, issue28772Constant, issue28772Constant2)
  2129  }
  2130  
  2131  // issue 28772 part 1 - part 2 in testx.go
  2132  
  2133  const issue28772Constant = C.issue28772Constant
  2134  
  2135  // issue 28896
  2136  
  2137  func offset(i int) uintptr {
  2138  	var pi C.innerPacked
  2139  	var po C.outerPacked
  2140  	var ui C.innerUnpacked
  2141  	var uo C.outerUnpacked
  2142  	switch i {
  2143  	case 0:
  2144  		return unsafe.Offsetof(pi.f2)
  2145  	case 1:
  2146  		return unsafe.Offsetof(po.g2)
  2147  	case 2:
  2148  		return unsafe.Offsetof(ui.f2)
  2149  	case 3:
  2150  		return unsafe.Offsetof(uo.g2)
  2151  	default:
  2152  		panic("can't happen")
  2153  	}
  2154  }
  2155  
  2156  func test28896(t *testing.T) {
  2157  	for i := 0; i < 4; i++ {
  2158  		c := uintptr(C.offset(C.int(i)))
  2159  		g := offset(i)
  2160  		if c != g {
  2161  			t.Errorf("%d: C: %d != Go %d", i, c, g)
  2162  		}
  2163  	}
  2164  }
  2165  
  2166  // issue 29383
  2167  // cgo's /*line*/ comments failed when inserted after '/',
  2168  // because the result looked like a "//" comment.
  2169  // No runtime test; just make sure it compiles.
  2170  
  2171  func Issue29383(n, size uint) int {
  2172  	if ^C.size_t(0)/C.size_t(n) < C.size_t(size) {
  2173  		return 0
  2174  	}
  2175  	return 0
  2176  }
  2177  
  2178  // issue 29748
  2179  // Error handling a struct initializer that requires pointer checking.
  2180  // Compilation test only, nothing to run.
  2181  
  2182  var Vissue29748 = C.f29748(&C.S29748{
  2183  	nil,
  2184  })
  2185  
  2186  func Fissue299748() {
  2187  	C.f29748(&C.S29748{
  2188  		nil,
  2189  	})
  2190  }
  2191  
  2192  // issue 29781
  2193  
  2194  var issue29781X struct{ X int }
  2195  
  2196  func issue29781F(...int) int { return 0 }
  2197  
  2198  func issue29781G() {
  2199  	var p *C.char
  2200  	C.issue29781F(&p, C.ISSUE29781C+1)
  2201  	C.issue29781F(nil, (C.int)(
  2202  		0))
  2203  	C.issue29781F(&p, (C.int)(0))
  2204  	C.issue29781F(&p, (C.int)(
  2205  		0))
  2206  	C.issue29781F(&p, (C.int)(issue29781X.
  2207  		X))
  2208  }
  2209  
  2210  // issue 30065
  2211  
  2212  func test30065(t *testing.T) {
  2213  	var a [256]byte
  2214  	b := []byte("a")
  2215  	C.memcpy(unsafe.Pointer(&a), unsafe.Pointer(&b[0]), 1)
  2216  	if a[0] != 'a' {
  2217  		t.Errorf("&a failed: got %c, want %c", a[0], 'a')
  2218  	}
  2219  
  2220  	b = []byte("b")
  2221  	C.memcpy(unsafe.Pointer(&a[0]), unsafe.Pointer(&b[0]), 1)
  2222  	if a[0] != 'b' {
  2223  		t.Errorf("&a[0] failed: got %c, want %c", a[0], 'b')
  2224  	}
  2225  
  2226  	d := make([]byte, 256)
  2227  	b = []byte("c")
  2228  	C.memcpy(unsafe.Pointer(&d[0]), unsafe.Pointer(&b[0]), 1)
  2229  	if d[0] != 'c' {
  2230  		t.Errorf("&d[0] failed: got %c, want %c", d[0], 'c')
  2231  	}
  2232  }
  2233  
  2234  // issue 31093
  2235  // No runtime test; just make sure it compiles.
  2236  
  2237  func Issue31093() {
  2238  	C.issue31093F(C.ushort(0))
  2239  }
  2240  
  2241  // issue 32579
  2242  
  2243  func test32579(t *testing.T) {
  2244  	var s [1]C.struct_S32579
  2245  	C.memset(unsafe.Pointer(&s[0].data[0]), 1, 1)
  2246  	if s[0].data[0] != 1 {
  2247  		t.Errorf("&s[0].data[0] failed: got %d, want %d", s[0].data[0], 1)
  2248  	}
  2249  }
  2250  
  2251  // issue 37033, check if cgo.Handle works properly
  2252  
  2253  func testHandle(t *testing.T) {
  2254  	ch := make(chan int)
  2255  
  2256  	for i := 0; i < 42; i++ {
  2257  		h := cgo.NewHandle(ch)
  2258  		go func() {
  2259  			C.cFunc37033(C.uintptr_t(h))
  2260  		}()
  2261  		if v := <-ch; issue37033 != v {
  2262  			t.Fatalf("unexpected receiving value: got %d, want %d", v, issue37033)
  2263  		}
  2264  		h.Delete()
  2265  	}
  2266  }
  2267  
  2268  // issue 38649
  2269  
  2270  var issue38649 C.netbsd_gid = 42
  2271  
  2272  // issue 39877
  2273  
  2274  var issue39877 *C.void = nil
  2275  
  2276  // issue 40494
  2277  // No runtime test; just make sure it compiles.
  2278  
  2279  func Issue40494() {
  2280  	C.issue40494(C.enum_Enum40494(C.X_40494), (*C.union_Union40494)(nil))
  2281  }
  2282  
  2283  // Issue 45451.
  2284  func test45451(t *testing.T) {
  2285  	var u *C.issue45451
  2286  	typ := reflect.ValueOf(u).Type().Elem()
  2287  
  2288  	// The type is undefined in C so allocating it should panic.
  2289  	defer func() {
  2290  		if r := recover(); r == nil {
  2291  			t.Error("expected panic")
  2292  		}
  2293  	}()
  2294  
  2295  	_ = reflect.New(typ)
  2296  	t.Errorf("reflect.New(%v) should have panicked", typ)
  2297  }
  2298  

View as plain text