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

View as plain text