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  	defer C.free(unsafe.Pointer(p))
  1102  	if runtime.GOOS == "openbsd" {
  1103  		// Bug in OpenBSD strtol(3) - base > 36 succeeds.
  1104  		if (n != 0 && n != 239089) || m != 234 {
  1105  			t.Fatal("Strtol x2: ", n, m)
  1106  		}
  1107  	} else if n != 0 || m != 234 {
  1108  		t.Fatal("Strtol x2: ", n, m)
  1109  	}
  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  	s := C.Issue6907CopyString(want)
  1636  	defer C.free(unsafe.Pointer(s))
  1637  	if got := C.GoString(s); got != want {
  1638  		t.Errorf("C.GoString(C.Issue6907CopyString(%q)) == %q, want %q", want, got, want)
  1639  	}
  1640  }
  1641  
  1642  // issue 7560
  1643  
  1644  func test7560(t *testing.T) {
  1645  	// some mingw don't implement __packed__ correctly.
  1646  	if C.offset7560() != 1 {
  1647  		t.Skip("C compiler did not pack struct")
  1648  	}
  1649  
  1650  	// C.misaligned should have x but then a padding field to get to the end of the struct.
  1651  	// There should not be a field named 'y'.
  1652  	var v C.misaligned
  1653  	rt := reflect.TypeOf(&v).Elem()
  1654  	if rt.NumField() != 2 || rt.Field(0).Name != "x" || rt.Field(1).Name != "_" {
  1655  		t.Errorf("unexpected fields in C.misaligned:\n")
  1656  		for i := 0; i < rt.NumField(); i++ {
  1657  			t.Logf("%+v\n", rt.Field(i))
  1658  		}
  1659  	}
  1660  }
  1661  
  1662  // issue 7786
  1663  
  1664  func f() {
  1665  	var x1 *C.typedef_test7786
  1666  	var x2 *C.struct_test7786
  1667  	x1 = x2
  1668  	x2 = x1
  1669  	C.f7786(x1)
  1670  	C.f7786(x2)
  1671  	C.g7786(x1)
  1672  	C.g7786(x2)
  1673  
  1674  	var b1 *C.typedef_body7786
  1675  	var b2 *C.struct_body7786
  1676  	b1 = b2
  1677  	b2 = b1
  1678  	C.b7786(b1)
  1679  	C.b7786(b2)
  1680  	C.c7786(b1)
  1681  	C.c7786(b2)
  1682  
  1683  	var u1 *C.typedef_union7786
  1684  	var u2 *C.union_union7786
  1685  	u1 = u2
  1686  	u2 = u1
  1687  	C.u7786(u1)
  1688  	C.u7786(u2)
  1689  	C.v7786(u1)
  1690  	C.v7786(u2)
  1691  }
  1692  
  1693  // issue 8092
  1694  
  1695  func test8092(t *testing.T) {
  1696  	tests := []struct {
  1697  		s    string
  1698  		a, b *C.char
  1699  	}{
  1700  		{"text", &C.text[0], C.ctext()},
  1701  		{"data", &C.data[0], C.cdata()},
  1702  	}
  1703  	for _, test := range tests {
  1704  		if test.a != test.b {
  1705  			t.Errorf("%s: pointer mismatch: %v != %v", test.s, test.a, test.b)
  1706  		}
  1707  		if got := C.GoString(test.a); got != test.s {
  1708  			t.Errorf("%s: points at %#v, want %#v", test.s, got, test.s)
  1709  		}
  1710  	}
  1711  }
  1712  
  1713  // issues 8368 and 8441
  1714  
  1715  func issue8368(one *C.struct_one, two *C.struct_two) {
  1716  }
  1717  
  1718  func issue8441(one *C.one, two *C.two) {
  1719  	issue8441(two.x, one.x)
  1720  }
  1721  
  1722  // issue 8428
  1723  
  1724  var _ = C.struct_issue8428one{
  1725  	b: C.char(0),
  1726  	// The trailing rest field is not available in cgo.
  1727  	// See issue 11925.
  1728  	// rest: [0]C.char{},
  1729  }
  1730  
  1731  var _ = C.struct_issue8428two{
  1732  	p:    unsafe.Pointer(nil),
  1733  	b:    C.char(0),
  1734  	rest: [0]C.char{},
  1735  }
  1736  
  1737  var _ = C.struct_issue8428three{
  1738  	w: [1][2][3][0]C.char{},
  1739  	x: [2][3][0][1]C.char{},
  1740  	y: [3][0][1][2]C.char{},
  1741  	z: [0][1][2][3]C.char{},
  1742  }
  1743  
  1744  // issue 8811
  1745  
  1746  func test8811(t *testing.T) {
  1747  	C.issue8811Execute()
  1748  }
  1749  
  1750  // issue 9557
  1751  
  1752  func test9557(t *testing.T) {
  1753  	// implicitly dereference a Go variable
  1754  	foo := C.issue9557foo
  1755  	if v := foo.a; v != 42 {
  1756  		t.Fatalf("foo.a expected 42, but got %d", v)
  1757  	}
  1758  
  1759  	// explicitly dereference a C variable
  1760  	if v := (*C.issue9557foo).a; v != 42 {
  1761  		t.Fatalf("(*C.issue9557foo).a expected 42, but is %d", v)
  1762  	}
  1763  
  1764  	// implicitly dereference a C variable
  1765  	if v := C.issue9557foo.a; v != 42 {
  1766  		t.Fatalf("C.issue9557foo.a expected 42, but is %d", v)
  1767  	}
  1768  }
  1769  
  1770  // issue 8331 part 1
  1771  
  1772  func issue8331a() C.issue8331 {
  1773  	return issue8331Var
  1774  }
  1775  
  1776  // issue 10303
  1777  
  1778  func test10303(t *testing.T, n int) {
  1779  	if asan.Enabled {
  1780  		t.Skip("variable z is heap-allocated due to extra allocations with -asan; see #70079")
  1781  	}
  1782  	if runtime.Compiler == "gccgo" {
  1783  		t.Skip("gccgo permits C pointers on the stack")
  1784  	}
  1785  
  1786  	// Run at a few different stack depths just to avoid an unlucky pass
  1787  	// due to variables ending up on different pages.
  1788  	if n > 0 {
  1789  		test10303(t, n-1)
  1790  	}
  1791  	if t.Failed() {
  1792  		return
  1793  	}
  1794  	var x, y, z, v, si C.int
  1795  	var s C.Struct
  1796  	C.setintstar(&x)
  1797  	C.setintptr(&y)
  1798  	C.setvoidptr(unsafe.Pointer(&v))
  1799  	s.P = &si
  1800  	C.setstruct(s)
  1801  
  1802  	if uintptr(unsafe.Pointer(&x))&^0xfff == uintptr(unsafe.Pointer(&z))&^0xfff {
  1803  		t.Error("C int* argument on stack")
  1804  	}
  1805  	if uintptr(unsafe.Pointer(&y))&^0xfff == uintptr(unsafe.Pointer(&z))&^0xfff {
  1806  		t.Error("C intptr argument on stack")
  1807  	}
  1808  	if uintptr(unsafe.Pointer(&v))&^0xfff == uintptr(unsafe.Pointer(&z))&^0xfff {
  1809  		t.Error("C void* argument on stack")
  1810  	}
  1811  	if uintptr(unsafe.Pointer(&si))&^0xfff == uintptr(unsafe.Pointer(&z))&^0xfff {
  1812  		t.Error("C struct field pointer on stack")
  1813  	}
  1814  }
  1815  
  1816  // issue 11925
  1817  
  1818  func test11925(t *testing.T) {
  1819  	if C.sizeof_struct_a11925 != unsafe.Sizeof(C.struct_a11925{}) {
  1820  		t.Errorf("size of a changed: C %d, Go %d", C.sizeof_struct_a11925, unsafe.Sizeof(C.struct_a11925{}))
  1821  	}
  1822  	if C.sizeof_struct_b11925 != unsafe.Sizeof(C.struct_b11925{}) {
  1823  		t.Errorf("size of b changed: C %d, Go %d", C.sizeof_struct_b11925, unsafe.Sizeof(C.struct_b11925{}))
  1824  	}
  1825  }
  1826  
  1827  // issue 12030
  1828  
  1829  func test12030(t *testing.T) {
  1830  	buf := (*C.char)(C.malloc(256))
  1831  	defer C.free(unsafe.Pointer(buf))
  1832  	for _, f := range []float64{1.0, 2.0, 3.14} {
  1833  		C.issue12030conv(buf, C.double(f))
  1834  		got := C.GoString(buf)
  1835  		if want := fmt.Sprintf("d=%g", f); got != want {
  1836  			t.Fatalf("C.sprintf failed for %g: %q != %q", f, got, want)
  1837  		}
  1838  	}
  1839  }
  1840  
  1841  // issue 13402
  1842  
  1843  var _ C.complexfloat
  1844  var _ C.complexdouble
  1845  
  1846  // issue 13930
  1847  // Test that cgo's multiple-value special form for
  1848  // C function calls works in variable declaration statements.
  1849  
  1850  var _, _ = C.abs(0)
  1851  
  1852  // issue 14838
  1853  
  1854  func test14838(t *testing.T) {
  1855  	data := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
  1856  	cData := C.CBytes(data)
  1857  	defer C.free(cData)
  1858  
  1859  	if C.check_cbytes((*C.char)(cData), C.size_t(len(data))) == 0 {
  1860  		t.Fatalf("mismatched data: expected %v, got %v", data, (*(*[10]byte)(unsafe.Pointer(cData)))[:])
  1861  	}
  1862  }
  1863  
  1864  // issue 17065
  1865  
  1866  var sink C.int
  1867  
  1868  func test17065(t *testing.T) {
  1869  	if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
  1870  		t.Skip("broken on darwin; issue 17065")
  1871  	}
  1872  	for i := range C.ii {
  1873  		sink = C.ii[i]
  1874  	}
  1875  }
  1876  
  1877  // issue 17537
  1878  
  1879  func test17537(t *testing.T) {
  1880  	v := C.S17537{i: 17537}
  1881  	if got, want := C.I17537(&v), C.int(17537); got != want {
  1882  		t.Errorf("got %d, want %d", got, want)
  1883  	}
  1884  
  1885  	p := (*C.char)(C.malloc(1))
  1886  	defer C.free(unsafe.Pointer(p))
  1887  	*p = 17
  1888  	if got, want := C.F17537(&p), C.int(17); got != want {
  1889  		t.Errorf("got %d, want %d", got, want)
  1890  	}
  1891  
  1892  	C.F18298(nil)
  1893  	var v18298 C.T18298_2
  1894  	C.G18298(C.T18298_1(v18298))
  1895  }
  1896  
  1897  // issue 17723
  1898  
  1899  func testAPI() {
  1900  	var cs *C.char
  1901  	cs = C.CString("hello")
  1902  	defer C.free(unsafe.Pointer(cs))
  1903  	var s string
  1904  	s = C.GoString((*C.char)(C.api_hello))
  1905  	s = C.GoStringN((*C.char)(C.api_hello), C.int(6))
  1906  	var b []byte
  1907  	b = C.GoBytes(unsafe.Pointer(C.api_hello), C.int(6))
  1908  	_, _ = s, b
  1909  	C.cstring_pointer_fun(nil)
  1910  }
  1911  
  1912  // issue 18126
  1913  
  1914  func test18126(t *testing.T) {
  1915  	p := C.malloc(1)
  1916  	_, err := C.Issue18126C(&p)
  1917  	C.free(p)
  1918  	_ = err
  1919  }
  1920  
  1921  // issue 18720
  1922  
  1923  func test18720(t *testing.T) {
  1924  	if got, want := C.HELLO_WORLD, "hello\000world"; got != want {
  1925  		t.Errorf("C.HELLO_WORLD == %q, expected %q", got, want)
  1926  	}
  1927  
  1928  	if got, want := C.VAR1, C.int(5); got != want {
  1929  		t.Errorf("C.VAR1 == %v, expected %v", got, want)
  1930  	}
  1931  
  1932  	if got, want := *C.ADDR, C.int(5); got != want {
  1933  		t.Errorf("*C.ADDR == %v, expected %v", got, want)
  1934  	}
  1935  
  1936  	if got, want := C.CALL, C.int(6); got != want {
  1937  		t.Errorf("C.CALL == %v, expected %v", got, want)
  1938  	}
  1939  
  1940  	if got, want := C.CALL, C.int(7); got != want {
  1941  		t.Errorf("C.CALL == %v, expected %v", got, want)
  1942  	}
  1943  
  1944  	// Issue 20125.
  1945  	if got, want := C.SIZE_OF_FOO, 1; got != want {
  1946  		t.Errorf("C.SIZE_OF_FOO == %v, expected %v", got, want)
  1947  	}
  1948  }
  1949  
  1950  // issue 20129
  1951  
  1952  func test20129(t *testing.T) {
  1953  	if C.issue20129 != 0 {
  1954  		t.Fatal("test is broken")
  1955  	}
  1956  	C.issue20129Foo()
  1957  	if C.issue20129 != 1 {
  1958  		t.Errorf("got %v but expected %v", C.issue20129, 1)
  1959  	}
  1960  	C.issue20129Bar()
  1961  	if C.issue20129 != 2 {
  1962  		t.Errorf("got %v but expected %v", C.issue20129, 2)
  1963  	}
  1964  }
  1965  
  1966  // issue 20369
  1967  
  1968  func test20369(t *testing.T) {
  1969  	if C.XUINT64_MAX != math.MaxUint64 {
  1970  		t.Fatalf("got %v, want %v", uint64(C.XUINT64_MAX), uint64(math.MaxUint64))
  1971  	}
  1972  }
  1973  
  1974  // issue 21668
  1975  
  1976  var issue21668_X = C.x21668
  1977  
  1978  // issue 21708
  1979  
  1980  func test21708(t *testing.T) {
  1981  	if got, want := C.CAST_TO_INT64, -1; got != want {
  1982  		t.Errorf("C.CAST_TO_INT64 == %v, expected %v", got, want)
  1983  	}
  1984  }
  1985  
  1986  // issue 21809
  1987  
  1988  func test21809(t *testing.T) {
  1989  	longVar := C.long(3)
  1990  	typedefVar := C.MySigned_t(4)
  1991  	typedefTypedefVar := C.MySigned2_t(5)
  1992  
  1993  	// all three should be considered identical to `long`
  1994  	if ret := C.takes_long(longVar); ret != 9 {
  1995  		t.Errorf("got %v but expected %v", ret, 9)
  1996  	}
  1997  	if ret := C.takes_long(typedefVar); ret != 16 {
  1998  		t.Errorf("got %v but expected %v", ret, 16)
  1999  	}
  2000  	if ret := C.takes_long(typedefTypedefVar); ret != 25 {
  2001  		t.Errorf("got %v but expected %v", ret, 25)
  2002  	}
  2003  
  2004  	// They should also be identical to the typedef'd type
  2005  	if ret := C.takes_typedef(longVar); ret != 9 {
  2006  		t.Errorf("got %v but expected %v", ret, 9)
  2007  	}
  2008  	if ret := C.takes_typedef(typedefVar); ret != 16 {
  2009  		t.Errorf("got %v but expected %v", ret, 16)
  2010  	}
  2011  	if ret := C.takes_typedef(typedefTypedefVar); ret != 25 {
  2012  		t.Errorf("got %v but expected %v", ret, 25)
  2013  	}
  2014  }
  2015  
  2016  // issue 22906
  2017  
  2018  func test22906(t *testing.T) {
  2019  	var x1 C.jobject = 0 // Note: 0, not nil. That makes sure we use uintptr for these types.
  2020  	_ = x1
  2021  	var x2 C.jclass = 0
  2022  	_ = x2
  2023  	var x3 C.jthrowable = 0
  2024  	_ = x3
  2025  	var x4 C.jstring = 0
  2026  	_ = x4
  2027  	var x5 C.jarray = 0
  2028  	_ = x5
  2029  	var x6 C.jbooleanArray = 0
  2030  	_ = x6
  2031  	var x7 C.jbyteArray = 0
  2032  	_ = x7
  2033  	var x8 C.jcharArray = 0
  2034  	_ = x8
  2035  	var x9 C.jshortArray = 0
  2036  	_ = x9
  2037  	var x10 C.jintArray = 0
  2038  	_ = x10
  2039  	var x11 C.jlongArray = 0
  2040  	_ = x11
  2041  	var x12 C.jfloatArray = 0
  2042  	_ = x12
  2043  	var x13 C.jdoubleArray = 0
  2044  	_ = x13
  2045  	var x14 C.jobjectArray = 0
  2046  	_ = x14
  2047  	var x15 C.jweak = 0
  2048  	_ = x15
  2049  }
  2050  
  2051  // issue 22958
  2052  // Nothing to run, just make sure this compiles.
  2053  var Vissue22958 C.issue22958Type
  2054  
  2055  func test23356(t *testing.T) {
  2056  	if got, want := C.a(), C.int(5); got != want {
  2057  		t.Errorf("C.a() == %v, expected %v", got, want)
  2058  	}
  2059  	if got, want := C.r(), C.int(3); got != want {
  2060  		t.Errorf("C.r() == %v, expected %v", got, want)
  2061  	}
  2062  }
  2063  
  2064  // issue 23720
  2065  
  2066  func Issue23720F() {
  2067  	var x C.issue23720A
  2068  	C.issue23720F(x)
  2069  }
  2070  
  2071  // issue 24206
  2072  
  2073  func test24206(t *testing.T) {
  2074  	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
  2075  		t.Skipf("skipping on %s/%s", runtime.GOOS, runtime.GOARCH)
  2076  	}
  2077  
  2078  	if l := len(C.GoString(C.dangerousString1())); l != 123 {
  2079  		t.Errorf("Incorrect string length - got %d, want 123", l)
  2080  	}
  2081  	if l := len(C.GoString(C.dangerousString2())); l != 4096+123 {
  2082  		t.Errorf("Incorrect string length - got %d, want %d", l, 4096+123)
  2083  	}
  2084  }
  2085  
  2086  // issue 25143
  2087  
  2088  func issue25143sum(ns ...C.int) C.int {
  2089  	total := C.int(0)
  2090  	for _, n := range ns {
  2091  		total += n
  2092  	}
  2093  	return total
  2094  }
  2095  
  2096  func test25143(t *testing.T) {
  2097  	if got, want := issue25143sum(1, 2, 3), C.int(6); got != want {
  2098  		t.Errorf("issue25143sum(1, 2, 3) == %v, expected %v", got, want)
  2099  	}
  2100  }
  2101  
  2102  // issue 26066
  2103  // Wrong type of constant with GCC 8 and newer.
  2104  
  2105  func test26066(t *testing.T) {
  2106  	var i = int64(C.issue26066)
  2107  	if i != -1 {
  2108  		t.Errorf("got %d, want -1", i)
  2109  	}
  2110  }
  2111  
  2112  // issue 26517
  2113  var a C.TypeOne
  2114  var b C.TypeTwo
  2115  
  2116  // issue 27660
  2117  // Stress the interaction between the race detector and cgo in an
  2118  // attempt to reproduce the memory corruption described in #27660.
  2119  // The bug was very timing sensitive; at the time of writing this
  2120  // test would only trigger the bug about once out of every five runs.
  2121  
  2122  func test27660(t *testing.T) {
  2123  	ctx, cancel := context.WithCancel(context.Background())
  2124  	defer cancel()
  2125  	ints := make([]int, 100)
  2126  	locks := make([]sync.Mutex, 100)
  2127  	// Slowly create threads so that ThreadSanitizer is forced to
  2128  	// frequently resize its SyncClocks.
  2129  	for i := 0; i < 100; i++ {
  2130  		go func() {
  2131  			for ctx.Err() == nil {
  2132  				// Sleep in C for long enough that it is likely that the runtime
  2133  				// will retake this goroutine's currently wired P.
  2134  				C.usleep(1000 /* 1ms */)
  2135  				runtime.Gosched() // avoid starvation (see #28701)
  2136  			}
  2137  		}()
  2138  		go func() {
  2139  			// Trigger lots of synchronization and memory reads/writes to
  2140  			// increase the likelihood that the race described in #27660
  2141  			// results in corruption of ThreadSanitizer's internal state
  2142  			// and thus an assertion failure or segfault.
  2143  			i := 0
  2144  			for ctx.Err() == nil {
  2145  				j := rand.Intn(100)
  2146  				locks[j].Lock()
  2147  				ints[j]++
  2148  				locks[j].Unlock()
  2149  				// needed for gccgo, to avoid creation of an
  2150  				// unpreemptible "fast path" in this loop. Choice
  2151  				// of (1<<24) is somewhat arbitrary.
  2152  				if i%(1<<24) == 0 {
  2153  					runtime.Gosched()
  2154  				}
  2155  				i++
  2156  
  2157  			}
  2158  		}()
  2159  		time.Sleep(time.Millisecond)
  2160  	}
  2161  }
  2162  
  2163  // issue 28540
  2164  
  2165  func twoargsF() {
  2166  	var v struct{ p *byte }
  2167  	C.twoargs1(C.twoargs2(), C.twoargs3(unsafe.Pointer(&v)))
  2168  }
  2169  
  2170  // issue 28545
  2171  
  2172  func issue28545G(p **C.char) {
  2173  	C.issue28545F(p, -1, (0))
  2174  	C.issue28545F(p, 2+3, complex(1, 1))
  2175  	C.issue28545F(p, issue28772Constant, issue28772Constant2)
  2176  }
  2177  
  2178  // issue 28772 part 1 - part 2 in testx.go
  2179  
  2180  const issue28772Constant = C.issue28772Constant
  2181  
  2182  // issue 28896
  2183  
  2184  func offset(i int) uintptr {
  2185  	var pi C.innerPacked
  2186  	var po C.outerPacked
  2187  	var ui C.innerUnpacked
  2188  	var uo C.outerUnpacked
  2189  	switch i {
  2190  	case 0:
  2191  		return unsafe.Offsetof(pi.f2)
  2192  	case 1:
  2193  		return unsafe.Offsetof(po.g2)
  2194  	case 2:
  2195  		return unsafe.Offsetof(ui.f2)
  2196  	case 3:
  2197  		return unsafe.Offsetof(uo.g2)
  2198  	default:
  2199  		panic("can't happen")
  2200  	}
  2201  }
  2202  
  2203  func test28896(t *testing.T) {
  2204  	for i := 0; i < 4; i++ {
  2205  		c := uintptr(C.offset(C.int(i)))
  2206  		g := offset(i)
  2207  		if c != g {
  2208  			t.Errorf("%d: C: %d != Go %d", i, c, g)
  2209  		}
  2210  	}
  2211  }
  2212  
  2213  // issue 29383
  2214  // cgo's /*line*/ comments failed when inserted after '/',
  2215  // because the result looked like a "//" comment.
  2216  // No runtime test; just make sure it compiles.
  2217  
  2218  func Issue29383(n, size uint) int {
  2219  	if ^C.size_t(0)/C.size_t(n) < C.size_t(size) {
  2220  		return 0
  2221  	}
  2222  	return 0
  2223  }
  2224  
  2225  // issue 29748
  2226  // Error handling a struct initializer that requires pointer checking.
  2227  // Compilation test only, nothing to run.
  2228  
  2229  var Vissue29748 = C.f29748(&C.S29748{
  2230  	nil,
  2231  })
  2232  
  2233  func Fissue299748() {
  2234  	C.f29748(&C.S29748{
  2235  		nil,
  2236  	})
  2237  }
  2238  
  2239  // issue 29781
  2240  
  2241  var issue29781X struct{ X int }
  2242  
  2243  func issue29781F(...int) int { return 0 }
  2244  
  2245  func issue29781G() {
  2246  	var p *C.char
  2247  	C.issue29781F(&p, C.ISSUE29781C+1)
  2248  	C.issue29781F(nil, (C.int)(
  2249  		0))
  2250  	C.issue29781F(&p, (C.int)(0))
  2251  	C.issue29781F(&p, (C.int)(
  2252  		0))
  2253  	C.issue29781F(&p, (C.int)(issue29781X.
  2254  		X))
  2255  }
  2256  
  2257  // issue 30065
  2258  
  2259  func test30065(t *testing.T) {
  2260  	var a [256]byte
  2261  	b := []byte("a")
  2262  	C.memcpy(unsafe.Pointer(&a), unsafe.Pointer(&b[0]), 1)
  2263  	if a[0] != 'a' {
  2264  		t.Errorf("&a failed: got %c, want %c", a[0], 'a')
  2265  	}
  2266  
  2267  	b = []byte("b")
  2268  	C.memcpy(unsafe.Pointer(&a[0]), unsafe.Pointer(&b[0]), 1)
  2269  	if a[0] != 'b' {
  2270  		t.Errorf("&a[0] failed: got %c, want %c", a[0], 'b')
  2271  	}
  2272  
  2273  	d := make([]byte, 256)
  2274  	b = []byte("c")
  2275  	C.memcpy(unsafe.Pointer(&d[0]), unsafe.Pointer(&b[0]), 1)
  2276  	if d[0] != 'c' {
  2277  		t.Errorf("&d[0] failed: got %c, want %c", d[0], 'c')
  2278  	}
  2279  }
  2280  
  2281  // issue 31093
  2282  // No runtime test; just make sure it compiles.
  2283  
  2284  func Issue31093() {
  2285  	C.issue31093F(C.ushort(0))
  2286  }
  2287  
  2288  // issue 32579
  2289  
  2290  func test32579(t *testing.T) {
  2291  	var s [1]C.struct_S32579
  2292  	C.memset(unsafe.Pointer(&s[0].data[0]), 1, 1)
  2293  	if s[0].data[0] != 1 {
  2294  		t.Errorf("&s[0].data[0] failed: got %d, want %d", s[0].data[0], 1)
  2295  	}
  2296  }
  2297  
  2298  // issue 37033, check if cgo.Handle works properly
  2299  
  2300  func testHandle(t *testing.T) {
  2301  	ch := make(chan int)
  2302  
  2303  	for i := 0; i < 42; i++ {
  2304  		h := cgo.NewHandle(ch)
  2305  		go func() {
  2306  			C.cFunc37033(C.uintptr_t(h))
  2307  		}()
  2308  		if v := <-ch; issue37033 != v {
  2309  			t.Fatalf("unexpected receiving value: got %d, want %d", v, issue37033)
  2310  		}
  2311  		h.Delete()
  2312  	}
  2313  }
  2314  
  2315  // issue 38649
  2316  
  2317  var issue38649 C.netbsd_gid = 42
  2318  
  2319  // issue 39877
  2320  
  2321  var issue39877 *C.void = nil
  2322  
  2323  // issue 40494
  2324  // No runtime test; just make sure it compiles.
  2325  
  2326  func Issue40494() {
  2327  	C.issue40494(C.enum_Enum40494(C.X_40494), (*C.union_Union40494)(nil))
  2328  }
  2329  
  2330  // Issue 45451.
  2331  func test45451(t *testing.T) {
  2332  	var u *C.issue45451
  2333  	typ := reflect.ValueOf(u).Type().Elem()
  2334  
  2335  	// The type is undefined in C so allocating it should panic.
  2336  	defer func() {
  2337  		if r := recover(); r == nil {
  2338  			t.Error("expected panic")
  2339  		}
  2340  	}()
  2341  
  2342  	_ = reflect.New(typ)
  2343  	t.Errorf("reflect.New(%v) should have panicked", typ)
  2344  }
  2345  
  2346  // issue 52542
  2347  
  2348  func func52542[T ~[]C.int]() {}
  2349  
  2350  type type52542[T ~*C.float] struct{}
  2351  
  2352  // issue67517 is just a compilation test, there is no runtime test.
  2353  func issue67517() {
  2354  	C.issue67517(&C.issue67517struct{
  2355  		a: 0,
  2356  
  2357  		b: nil,
  2358  	})
  2359  	C.issue67517(&C.issue67517struct{
  2360  		a: 0,
  2361  		// comment
  2362  		b: nil,
  2363  	})
  2364  	C.issue67517(&C.issue67517struct{
  2365  		a: 0 +
  2366  			// comment
  2367  			1,
  2368  		// comment
  2369  		b: nil,
  2370  	})
  2371  }
  2372  
  2373  // Issue 69086.
  2374  func test69086(t *testing.T) {
  2375  	var s C.issue69086struct
  2376  
  2377  	typ := reflect.TypeOf(s)
  2378  	for i := 0; i < typ.NumField(); i++ {
  2379  		f := typ.Field(i)
  2380  		t.Logf("field %d: name %s size %d align %d offset %d", i, f.Name, f.Type.Size(), f.Type.Align(), f.Offset)
  2381  	}
  2382  
  2383  	s.c = 1
  2384  	got := C.issue690861(&s)
  2385  	if got != 1 {
  2386  		t.Errorf("field: got %d, want 1", got)
  2387  	}
  2388  	got = C.issue690862(1, 2, 3, s)
  2389  	if got != 1234 {
  2390  		t.Errorf("call: got %d, want 1234", got)
  2391  	}
  2392  }
  2393  

View as plain text