Source file src/cmd/cgo/internal/test/test.go

Documentation: cmd/cgo/internal/test

     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  // TODO(#56378): enable in Go 1.23:
   121  // #cgo noescape 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  */
   937  import "C"
   938  
   939  import (
   940  	"context"
   941  	"fmt"
   942  	"math"
   943  	"math/rand"
   944  	"os"
   945  	"os/signal"
   946  	"reflect"
   947  	"runtime"
   948  	"runtime/cgo"
   949  	"sync"
   950  	"syscall"
   951  	"testing"
   952  	"time"
   953  	"unsafe"
   954  )
   955  
   956  // alignment
   957  
   958  func testAlign(t *testing.T) {
   959  	var evt C.SDL_KeyboardEvent
   960  	C.makeEvent(&evt)
   961  	if C.same(&evt, evt.typ, evt.which, evt.state, evt.keysym.scancode, evt.keysym.sym, evt.keysym.mod, evt.keysym.unicode) == 0 {
   962  		t.Error("*** bad alignment")
   963  		C.cTest(&evt)
   964  		t.Errorf("Go: %#x %#x %#x %#x %#x %#x %#x\n",
   965  			evt.typ, evt.which, evt.state, evt.keysym.scancode,
   966  			evt.keysym.sym, evt.keysym.mod, evt.keysym.unicode)
   967  		t.Error(evt)
   968  	}
   969  }
   970  
   971  // api
   972  
   973  const greeting = "hello, world"
   974  
   975  type testPair struct {
   976  	Name      string
   977  	Got, Want interface{}
   978  }
   979  
   980  var testPairs = []testPair{
   981  	{"GoString", C.GoString(C.greeting), greeting},
   982  	{"GoStringN", C.GoStringN(C.greeting, 5), greeting[:5]},
   983  	{"GoBytes", C.GoBytes(unsafe.Pointer(C.greeting), 5), []byte(greeting[:5])},
   984  }
   985  
   986  func testHelpers(t *testing.T) {
   987  	for _, pair := range testPairs {
   988  		if !reflect.DeepEqual(pair.Got, pair.Want) {
   989  			t.Errorf("%s: got %#v, want %#v", pair.Name, pair.Got, pair.Want)
   990  		}
   991  	}
   992  }
   993  
   994  // basic test cases
   995  
   996  const EINVAL = C.EINVAL /* test #define */
   997  
   998  var KILO = C.KILO
   999  
  1000  func uuidgen() {
  1001  	var uuid C.cgo_uuid_t
  1002  	C.uuid_generate(&uuid[0])
  1003  }
  1004  
  1005  func Strtol(s string, base int) (int, error) {
  1006  	p := C.CString(s)
  1007  	n, err := C.strtol(p, nil, C.int(base))
  1008  	C.free(unsafe.Pointer(p))
  1009  	return int(n), err
  1010  }
  1011  
  1012  func Atol(s string) int {
  1013  	p := C.CString(s)
  1014  	n := C.atol(p)
  1015  	C.free(unsafe.Pointer(p))
  1016  	return int(n)
  1017  }
  1018  
  1019  func testConst(t *testing.T) {
  1020  	C.myConstFunc(nil, 0, nil)
  1021  }
  1022  
  1023  func testEnum(t *testing.T) {
  1024  	if C.Enum1 != 1 || C.Enum2 != 2 {
  1025  		t.Error("bad enum", C.Enum1, C.Enum2)
  1026  	}
  1027  }
  1028  
  1029  func testNamedEnum(t *testing.T) {
  1030  	e := new(C.enum_E)
  1031  
  1032  	*e = C.Enum1
  1033  	if *e != 1 {
  1034  		t.Error("bad enum", C.Enum1)
  1035  	}
  1036  
  1037  	*e = C.Enum2
  1038  	if *e != 2 {
  1039  		t.Error("bad enum", C.Enum2)
  1040  	}
  1041  }
  1042  
  1043  func testCastToEnum(t *testing.T) {
  1044  	e := C.enum_E(C.Enum1)
  1045  	if e != 1 {
  1046  		t.Error("bad enum", C.Enum1)
  1047  	}
  1048  
  1049  	e = C.enum_E(C.Enum2)
  1050  	if e != 2 {
  1051  		t.Error("bad enum", C.Enum2)
  1052  	}
  1053  }
  1054  
  1055  func testAtol(t *testing.T) {
  1056  	l := Atol("123")
  1057  	if l != 123 {
  1058  		t.Error("Atol 123: ", l)
  1059  	}
  1060  }
  1061  
  1062  func testErrno(t *testing.T) {
  1063  	p := C.CString("no-such-file")
  1064  	m := C.CString("r")
  1065  	f, err := C.fopen(p, m)
  1066  	C.free(unsafe.Pointer(p))
  1067  	C.free(unsafe.Pointer(m))
  1068  	if err == nil {
  1069  		C.fclose(f)
  1070  		t.Fatalf("C.fopen: should fail")
  1071  	}
  1072  	if err != syscall.ENOENT {
  1073  		t.Fatalf("C.fopen: unexpected error: %v", err)
  1074  	}
  1075  }
  1076  
  1077  func testMultipleAssign(t *testing.T) {
  1078  	p := C.CString("234")
  1079  	n, m := C.strtol(p, nil, 345), C.strtol(p, nil, 10)
  1080  	if runtime.GOOS == "openbsd" {
  1081  		// Bug in OpenBSD strtol(3) - base > 36 succeeds.
  1082  		if (n != 0 && n != 239089) || m != 234 {
  1083  			t.Fatal("Strtol x2: ", n, m)
  1084  		}
  1085  	} else if n != 0 || m != 234 {
  1086  		t.Fatal("Strtol x2: ", n, m)
  1087  	}
  1088  	C.free(unsafe.Pointer(p))
  1089  }
  1090  
  1091  var (
  1092  	cuint  = (C.uint)(0)
  1093  	culong C.ulong
  1094  	cchar  C.char
  1095  )
  1096  
  1097  type Context struct {
  1098  	ctx *C.struct_ibv_context
  1099  }
  1100  
  1101  func benchCgoCall(b *testing.B) {
  1102  	b.Run("add-int", func(b *testing.B) {
  1103  		const x = C.int(2)
  1104  		const y = C.int(3)
  1105  
  1106  		for i := 0; i < b.N; i++ {
  1107  			C.add(x, y)
  1108  		}
  1109  	})
  1110  
  1111  	b.Run("one-pointer", func(b *testing.B) {
  1112  		var a0 C.VkDeviceCreateInfo
  1113  		for i := 0; i < b.N; i++ {
  1114  			C.handleComplexPointer(&a0)
  1115  		}
  1116  	})
  1117  	b.Run("string-pointer-escape", func(b *testing.B) {
  1118  		for i := 0; i < b.N; i++ {
  1119  			var s string
  1120  			C.handleGoStringPointerEscape(unsafe.Pointer(&s))
  1121  		}
  1122  	})
  1123  	b.Run("string-pointer-noescape", func(b *testing.B) {
  1124  		for i := 0; i < b.N; i++ {
  1125  			var s string
  1126  			C.handleGoStringPointerNoescape(unsafe.Pointer(&s))
  1127  		}
  1128  	})
  1129  	b.Run("eight-pointers", func(b *testing.B) {
  1130  		var a0, a1, a2, a3, a4, a5, a6, a7 C.VkDeviceCreateInfo
  1131  		for i := 0; i < b.N; i++ {
  1132  			C.handleComplexPointer8(&a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7)
  1133  		}
  1134  	})
  1135  	b.Run("eight-pointers-nil", func(b *testing.B) {
  1136  		var a0, a1, a2, a3, a4, a5, a6, a7 *C.VkDeviceCreateInfo
  1137  		for i := 0; i < b.N; i++ {
  1138  			C.handleComplexPointer8(a0, a1, a2, a3, a4, a5, a6, a7)
  1139  		}
  1140  	})
  1141  	b.Run("eight-pointers-array", func(b *testing.B) {
  1142  		var a [8]C.VkDeviceCreateInfo
  1143  		for i := 0; i < b.N; i++ {
  1144  			C.handleComplexPointer8(&a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7])
  1145  		}
  1146  	})
  1147  	b.Run("eight-pointers-slice", func(b *testing.B) {
  1148  		a := make([]C.VkDeviceCreateInfo, 8)
  1149  		for i := 0; i < b.N; i++ {
  1150  			C.handleComplexPointer8(&a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7])
  1151  		}
  1152  	})
  1153  }
  1154  
  1155  // Benchmark measuring overhead from Go to C and back to Go (via a callback)
  1156  func benchCallback(b *testing.B) {
  1157  	var x = false
  1158  	for i := 0; i < b.N; i++ {
  1159  		nestedCall(func() { x = true })
  1160  	}
  1161  	if !x {
  1162  		b.Fatal("nestedCall was not invoked")
  1163  	}
  1164  }
  1165  
  1166  var sinkString string
  1167  
  1168  func benchGoString(b *testing.B) {
  1169  	for i := 0; i < b.N; i++ {
  1170  		sinkString = C.GoString(C.cstr)
  1171  	}
  1172  	const want = "abcefghijklmnopqrstuvwxyzABCEFGHIJKLMNOPQRSTUVWXYZ1234567890"
  1173  	if sinkString != want {
  1174  		b.Fatalf("%q != %q", sinkString, want)
  1175  	}
  1176  }
  1177  
  1178  // Static (build-time) test that syntax traversal visits all operands of s[i:j:k].
  1179  func sliceOperands(array [2000]int) {
  1180  	_ = array[C.KILO:C.KILO:C.KILO] // no type error
  1181  }
  1182  
  1183  // set in cgo_thread_lock.go init
  1184  var testThreadLockFunc = func(*testing.T) {}
  1185  
  1186  // complex alignment
  1187  
  1188  func TestComplexAlign(t *testing.T) {
  1189  	if C.cplxAlign.x != 3.14 {
  1190  		t.Errorf("got %v, expected 3.14", C.cplxAlign.x)
  1191  	}
  1192  	if C.cplxAlign.y != 2.17 {
  1193  		t.Errorf("got %v, expected 2.17", C.cplxAlign.y)
  1194  	}
  1195  }
  1196  
  1197  // constants and pointer checking
  1198  
  1199  func testCheckConst(t *testing.T) {
  1200  	// The test is that this compiles successfully.
  1201  	p := C.malloc(C.size_t(unsafe.Sizeof(C.int(0))))
  1202  	defer C.free(p)
  1203  	C.CheckConstFunc(&C.CheckConstStruct{(*C.int)(p)}, C.CheckConstVal)
  1204  }
  1205  
  1206  // duplicate symbol
  1207  
  1208  func duplicateSymbols() {
  1209  	fmt.Printf("%v %v %v\n", C.base_symbol, C.alias_one, C.alias_two)
  1210  }
  1211  
  1212  // environment
  1213  
  1214  // This is really an os package test but here for convenience.
  1215  func testSetEnv(t *testing.T) {
  1216  	if runtime.GOOS == "windows" {
  1217  		// Go uses SetEnvironmentVariable on windows. However,
  1218  		// C runtime takes a *copy* at process startup of the
  1219  		// OS environment, and stores it in environ/envp.
  1220  		// It is this copy that	getenv/putenv manipulate.
  1221  		t.Logf("skipping test")
  1222  		return
  1223  	}
  1224  	const key = "CGO_OS_TEST_KEY"
  1225  	const val = "CGO_OS_TEST_VALUE"
  1226  	os.Setenv(key, val)
  1227  	keyc := C.CString(key)
  1228  	defer C.free(unsafe.Pointer(keyc))
  1229  	v := C.getenv(keyc)
  1230  	if uintptr(unsafe.Pointer(v)) == 0 {
  1231  		t.Fatal("getenv returned NULL")
  1232  	}
  1233  	vs := C.GoString(v)
  1234  	if vs != val {
  1235  		t.Fatalf("getenv() = %q; want %q", vs, val)
  1236  	}
  1237  }
  1238  
  1239  // function pointer variables
  1240  
  1241  func callBridge(f C.intFunc) int {
  1242  	return int(C.bridge_int_func(f))
  1243  }
  1244  
  1245  func callCBridge(f C.intFunc) C.int {
  1246  	return C.bridge_int_func(f)
  1247  }
  1248  
  1249  func testFpVar(t *testing.T) {
  1250  	const expected = 42
  1251  	f := C.intFunc(C.fortytwo)
  1252  	res1 := C.bridge_int_func(f)
  1253  	if r1 := int(res1); r1 != expected {
  1254  		t.Errorf("got %d, want %d", r1, expected)
  1255  	}
  1256  	res2 := callCBridge(f)
  1257  	if r2 := int(res2); r2 != expected {
  1258  		t.Errorf("got %d, want %d", r2, expected)
  1259  	}
  1260  	r3 := callBridge(f)
  1261  	if r3 != expected {
  1262  		t.Errorf("got %d, want %d", r3, expected)
  1263  	}
  1264  }
  1265  
  1266  // issue 1222
  1267  type AsyncEvent struct {
  1268  	event C.struct_ibv_async_event
  1269  }
  1270  
  1271  // issue 1635
  1272  
  1273  func test1635(t *testing.T) {
  1274  	C.scatter()
  1275  	if v := C.hola; v != 0 {
  1276  		t.Fatalf("C.hola is %d, should be 0", v)
  1277  	}
  1278  	if v := C.testHola(); v != 0 {
  1279  		t.Fatalf("C.testHola() is %d, should be 0", v)
  1280  	}
  1281  }
  1282  
  1283  // issue 2470
  1284  
  1285  func testUnsignedInt(t *testing.T) {
  1286  	a := (int64)(C.UINT32VAL)
  1287  	b := (int64)(0xc008427b)
  1288  	if a != b {
  1289  		t.Errorf("Incorrect unsigned int - got %x, want %x", a, b)
  1290  	}
  1291  }
  1292  
  1293  // issue 3250
  1294  
  1295  func test3250(t *testing.T) {
  1296  	if runtime.GOOS == "windows" {
  1297  		t.Skip("not applicable on windows")
  1298  	}
  1299  
  1300  	t.Skip("skipped, see golang.org/issue/5885")
  1301  	var (
  1302  		thres = 1
  1303  		sig   = syscall_dot_SIGCHLD
  1304  	)
  1305  	type result struct {
  1306  		n   int
  1307  		sig os.Signal
  1308  	}
  1309  	var (
  1310  		sigCh     = make(chan os.Signal, 10)
  1311  		waitStart = make(chan struct{})
  1312  		waitDone  = make(chan result)
  1313  	)
  1314  
  1315  	signal.Notify(sigCh, sig)
  1316  
  1317  	go func() {
  1318  		n := 0
  1319  		alarm := time.After(time.Second * 3)
  1320  		for {
  1321  			select {
  1322  			case <-waitStart:
  1323  				waitStart = nil
  1324  			case v := <-sigCh:
  1325  				n++
  1326  				if v != sig || n > thres {
  1327  					waitDone <- result{n, v}
  1328  					return
  1329  				}
  1330  			case <-alarm:
  1331  				waitDone <- result{n, sig}
  1332  				return
  1333  			}
  1334  		}
  1335  	}()
  1336  
  1337  	waitStart <- struct{}{}
  1338  	C.testSendSIG()
  1339  	r := <-waitDone
  1340  	if r.sig != sig {
  1341  		t.Fatalf("received signal %v, but want %v", r.sig, sig)
  1342  	}
  1343  	t.Logf("got %d signals\n", r.n)
  1344  	if r.n <= thres {
  1345  		t.Fatalf("expected more than %d", thres)
  1346  	}
  1347  }
  1348  
  1349  // issue 3261
  1350  
  1351  func testLibgcc(t *testing.T) {
  1352  	var table = []struct {
  1353  		in, out C.int
  1354  	}{
  1355  		{0, 0},
  1356  		{1, 1},
  1357  		{-42, 42},
  1358  		{1000300, 1000300},
  1359  		{1 - 1<<31, 1<<31 - 1},
  1360  	}
  1361  	for _, v := range table {
  1362  		if o := C.vabs(v.in); o != v.out {
  1363  			t.Fatalf("abs(%d) got %d, should be %d", v.in, o, v.out)
  1364  			return
  1365  		}
  1366  	}
  1367  }
  1368  
  1369  // issue 3729
  1370  
  1371  func test3729(t *testing.T) {
  1372  	if runtime.GOOS == "windows" {
  1373  		t.Skip("skipping on windows")
  1374  	}
  1375  
  1376  	_, e := C.g()
  1377  	if e != syscall.E2BIG {
  1378  		t.Errorf("got %q, expect %q", e, syscall.E2BIG)
  1379  	}
  1380  	_, e = C.g2(C.EINVAL, C._expA, C._expB, C._expC, C._expD)
  1381  	if e != syscall.EINVAL {
  1382  		t.Errorf("got %q, expect %q", e, syscall.EINVAL)
  1383  	}
  1384  }
  1385  
  1386  // issue 3945
  1387  
  1388  func testPrintf(t *testing.T) {
  1389  	C.say()
  1390  }
  1391  
  1392  // issue 4054
  1393  
  1394  var issue4054a = []int{C.A, C.B, C.C, C.D, C.E, C.F, C.G, C.H, C.I, C.J}
  1395  
  1396  // issue 4339
  1397  
  1398  func test4339(t *testing.T) {
  1399  	C.handle4339(&C.exported4339)
  1400  }
  1401  
  1402  // issue 4417
  1403  
  1404  func testBoolAlign(t *testing.T) {
  1405  	b := C.c_bool(true, true, 10, true, false)
  1406  	if b != 10 {
  1407  		t.Fatalf("found %d expected 10\n", b)
  1408  	}
  1409  	b = C.c_bool(true, true, 5, true, true)
  1410  	if b != 5 {
  1411  		t.Fatalf("found %d expected 5\n", b)
  1412  	}
  1413  	b = C.c_bool(true, true, 3, true, false)
  1414  	if b != 3 {
  1415  		t.Fatalf("found %d expected 3\n", b)
  1416  	}
  1417  	b = C.c_bool(false, false, 1, true, false)
  1418  	if b != 1 {
  1419  		t.Fatalf("found %d expected 1\n", b)
  1420  	}
  1421  	b = C.c_bool(false, true, 200, true, false)
  1422  	if b != 200 {
  1423  		t.Fatalf("found %d expected 200\n", b)
  1424  	}
  1425  }
  1426  
  1427  // issue 4857
  1428  
  1429  func test4857() {
  1430  	_ = C.issue4857()
  1431  }
  1432  
  1433  // issue 5224
  1434  
  1435  func testCflags(t *testing.T) {
  1436  	is_windows := C.is_windows == 1
  1437  	if is_windows != (runtime.GOOS == "windows") {
  1438  		t.Errorf("is_windows: %v, runtime.GOOS: %s", is_windows, runtime.GOOS)
  1439  	}
  1440  	if C.common != 123 {
  1441  		t.Errorf("common: %v (expected 123)", C.common)
  1442  	}
  1443  }
  1444  
  1445  // issue 5227
  1446  
  1447  func test5227(t *testing.T) {
  1448  	C.init()
  1449  }
  1450  
  1451  func selectfont() C.Fontinfo {
  1452  	return C.SansTypeface
  1453  }
  1454  
  1455  // issue 5242
  1456  
  1457  func test5242(t *testing.T) {
  1458  	if got := C.issue5242(C.foo{}, C.bar{}); got != 5242 {
  1459  		t.Errorf("got %v", got)
  1460  	}
  1461  }
  1462  
  1463  func test5603(t *testing.T) {
  1464  	var x [5]int64
  1465  	exp := int64(C.issue5603exp)
  1466  	x[0] = int64(C.issue5603foo0())
  1467  	x[1] = int64(C.issue5603foo1(nil))
  1468  	x[2] = int64(C.issue5603foo2(nil, nil))
  1469  	x[3] = int64(C.issue5603foo3(nil, nil, nil))
  1470  	x[4] = int64(C.issue5603foo4(nil, nil, nil, nil))
  1471  	for i, v := range x {
  1472  		if v != exp {
  1473  			t.Errorf("issue5603foo%d() returns %v, expected %v", i, v, exp)
  1474  		}
  1475  	}
  1476  }
  1477  
  1478  // issue 5337
  1479  
  1480  func test5337(t *testing.T) {
  1481  	C.test5337()
  1482  }
  1483  
  1484  // issue 5740
  1485  
  1486  func test5740(t *testing.T) {
  1487  	if v := C.test5740a() + C.test5740b(); v != 5 {
  1488  		t.Errorf("expected 5, got %v", v)
  1489  	}
  1490  }
  1491  
  1492  // issue 5986
  1493  
  1494  func test5986(t *testing.T) {
  1495  	C.output5986()
  1496  }
  1497  
  1498  // issue 6128
  1499  
  1500  func test6128() {
  1501  	// nothing to run, just make sure this compiles.
  1502  	_ = C.X
  1503  }
  1504  
  1505  // issue 6390
  1506  
  1507  func test6390(t *testing.T) {
  1508  	p1 := C.malloc(1024)
  1509  	if p1 == nil {
  1510  		t.Fatalf("C.malloc(1024) returned nil")
  1511  	}
  1512  	p2 := C.malloc(0)
  1513  	if p2 == nil {
  1514  		t.Fatalf("C.malloc(0) returned nil")
  1515  	}
  1516  	C.free(p1)
  1517  	C.free(p2)
  1518  }
  1519  
  1520  func test6472() {
  1521  	// nothing to run, just make sure this compiles
  1522  	s := new(C.z)
  1523  	println(s.y[0].x)
  1524  }
  1525  
  1526  // issue 6506
  1527  
  1528  func test6506() {
  1529  	// nothing to run, just make sure this compiles
  1530  	var x C.size_t
  1531  
  1532  	C.calloc(x, x)
  1533  	C.malloc(x)
  1534  	C.realloc(nil, x)
  1535  	C.memcpy(nil, nil, x)
  1536  	C.memcmp(nil, nil, x)
  1537  	C.memmove(nil, nil, x)
  1538  	C.strncpy(nil, nil, x)
  1539  	C.strncmp(nil, nil, x)
  1540  	C.strncat(nil, nil, x)
  1541  	x = C.strxfrm(nil, nil, x)
  1542  	C.memchr(nil, 0, x)
  1543  	x = C.strcspn(nil, nil)
  1544  	x = C.strspn(nil, nil)
  1545  	C.memset(nil, 0, x)
  1546  	x = C.strlen(nil)
  1547  	_ = x
  1548  }
  1549  
  1550  // issue 6612
  1551  
  1552  func testNaming(t *testing.T) {
  1553  	C.myfunc()
  1554  	C.myfunc_def()
  1555  	if v := C.myvar; v != 5 {
  1556  		t.Errorf("C.myvar = %d, want 5", v)
  1557  	}
  1558  	if v := C.myvar_def; v != 5 {
  1559  		t.Errorf("C.myvar_def = %d, want 5", v)
  1560  	}
  1561  	if s := C.GoString(C.mytext); s != "abcdef" {
  1562  		t.Errorf("C.mytext = %q, want %q", s, "abcdef")
  1563  	}
  1564  	if s := C.GoString(C.mytext_def); s != "abcdef" {
  1565  		t.Errorf("C.mytext_def = %q, want %q", s, "abcdef")
  1566  	}
  1567  	if c := C.myenum; c != 1234 {
  1568  		t.Errorf("C.myenum = %v, want 1234", c)
  1569  	}
  1570  	if c := C.myenum_def; c != 1234 {
  1571  		t.Errorf("C.myenum_def = %v, want 1234", c)
  1572  	}
  1573  	{
  1574  		const c = C.myenum
  1575  		if c != 1234 {
  1576  			t.Errorf("C.myenum as const = %v, want 1234", c)
  1577  		}
  1578  	}
  1579  	{
  1580  		const c = C.myenum_def
  1581  		if c != 1234 {
  1582  			t.Errorf("C.myenum as const = %v, want 1234", c)
  1583  		}
  1584  	}
  1585  	if c := C.myint_def; c != 12345 {
  1586  		t.Errorf("C.myint_def = %v, want 12345", c)
  1587  	}
  1588  	{
  1589  		const c = C.myint_def
  1590  		if c != 12345 {
  1591  			t.Errorf("C.myint as const = %v, want 12345", c)
  1592  		}
  1593  	}
  1594  
  1595  	if c := C.myfloat_def; c != 1.5 {
  1596  		t.Errorf("C.myint_def = %v, want 1.5", c)
  1597  	}
  1598  	{
  1599  		const c = C.myfloat_def
  1600  		if c != 1.5 {
  1601  			t.Errorf("C.myint as const = %v, want 1.5", c)
  1602  		}
  1603  	}
  1604  
  1605  	if s := C.mystring_def; s != "hello" {
  1606  		t.Errorf("C.mystring_def = %q, want %q", s, "hello")
  1607  	}
  1608  }
  1609  
  1610  // issue 6907
  1611  
  1612  func test6907(t *testing.T) {
  1613  	want := "yarn"
  1614  	if got := C.GoString(C.Issue6907CopyString(want)); got != want {
  1615  		t.Errorf("C.GoString(C.Issue6907CopyString(%q)) == %q, want %q", want, got, want)
  1616  	}
  1617  }
  1618  
  1619  // issue 7560
  1620  
  1621  func test7560(t *testing.T) {
  1622  	// some mingw don't implement __packed__ correctly.
  1623  	if C.offset7560() != 1 {
  1624  		t.Skip("C compiler did not pack struct")
  1625  	}
  1626  
  1627  	// C.misaligned should have x but then a padding field to get to the end of the struct.
  1628  	// There should not be a field named 'y'.
  1629  	var v C.misaligned
  1630  	rt := reflect.TypeOf(&v).Elem()
  1631  	if rt.NumField() != 2 || rt.Field(0).Name != "x" || rt.Field(1).Name != "_" {
  1632  		t.Errorf("unexpected fields in C.misaligned:\n")
  1633  		for i := 0; i < rt.NumField(); i++ {
  1634  			t.Logf("%+v\n", rt.Field(i))
  1635  		}
  1636  	}
  1637  }
  1638  
  1639  // issue 7786
  1640  
  1641  func f() {
  1642  	var x1 *C.typedef_test7786
  1643  	var x2 *C.struct_test7786
  1644  	x1 = x2
  1645  	x2 = x1
  1646  	C.f7786(x1)
  1647  	C.f7786(x2)
  1648  	C.g7786(x1)
  1649  	C.g7786(x2)
  1650  
  1651  	var b1 *C.typedef_body7786
  1652  	var b2 *C.struct_body7786
  1653  	b1 = b2
  1654  	b2 = b1
  1655  	C.b7786(b1)
  1656  	C.b7786(b2)
  1657  	C.c7786(b1)
  1658  	C.c7786(b2)
  1659  
  1660  	var u1 *C.typedef_union7786
  1661  	var u2 *C.union_union7786
  1662  	u1 = u2
  1663  	u2 = u1
  1664  	C.u7786(u1)
  1665  	C.u7786(u2)
  1666  	C.v7786(u1)
  1667  	C.v7786(u2)
  1668  }
  1669  
  1670  // issue 8092
  1671  
  1672  func test8092(t *testing.T) {
  1673  	tests := []struct {
  1674  		s    string
  1675  		a, b *C.char
  1676  	}{
  1677  		{"text", &C.text[0], C.ctext()},
  1678  		{"data", &C.data[0], C.cdata()},
  1679  	}
  1680  	for _, test := range tests {
  1681  		if test.a != test.b {
  1682  			t.Errorf("%s: pointer mismatch: %v != %v", test.s, test.a, test.b)
  1683  		}
  1684  		if got := C.GoString(test.a); got != test.s {
  1685  			t.Errorf("%s: points at %#v, want %#v", test.s, got, test.s)
  1686  		}
  1687  	}
  1688  }
  1689  
  1690  // issues 8368 and 8441
  1691  
  1692  func issue8368(one *C.struct_one, two *C.struct_two) {
  1693  }
  1694  
  1695  func issue8441(one *C.one, two *C.two) {
  1696  	issue8441(two.x, one.x)
  1697  }
  1698  
  1699  // issue 8428
  1700  
  1701  var _ = C.struct_issue8428one{
  1702  	b: C.char(0),
  1703  	// The trailing rest field is not available in cgo.
  1704  	// See issue 11925.
  1705  	// rest: [0]C.char{},
  1706  }
  1707  
  1708  var _ = C.struct_issue8428two{
  1709  	p:    unsafe.Pointer(nil),
  1710  	b:    C.char(0),
  1711  	rest: [0]C.char{},
  1712  }
  1713  
  1714  var _ = C.struct_issue8428three{
  1715  	w: [1][2][3][0]C.char{},
  1716  	x: [2][3][0][1]C.char{},
  1717  	y: [3][0][1][2]C.char{},
  1718  	z: [0][1][2][3]C.char{},
  1719  }
  1720  
  1721  // issue 8811
  1722  
  1723  func test8811(t *testing.T) {
  1724  	C.issue8811Execute()
  1725  }
  1726  
  1727  // issue 9557
  1728  
  1729  func test9557(t *testing.T) {
  1730  	// implicitly dereference a Go variable
  1731  	foo := C.issue9557foo
  1732  	if v := foo.a; v != 42 {
  1733  		t.Fatalf("foo.a expected 42, but got %d", v)
  1734  	}
  1735  
  1736  	// explicitly dereference a C variable
  1737  	if v := (*C.issue9557foo).a; v != 42 {
  1738  		t.Fatalf("(*C.issue9557foo).a expected 42, but is %d", v)
  1739  	}
  1740  
  1741  	// implicitly dereference a C variable
  1742  	if v := C.issue9557foo.a; v != 42 {
  1743  		t.Fatalf("C.issue9557foo.a expected 42, but is %d", v)
  1744  	}
  1745  }
  1746  
  1747  // issue 8331 part 1
  1748  
  1749  func issue8331a() C.issue8331 {
  1750  	return issue8331Var
  1751  }
  1752  
  1753  // issue 10303
  1754  
  1755  func test10303(t *testing.T, n int) {
  1756  	if runtime.Compiler == "gccgo" {
  1757  		t.Skip("gccgo permits C pointers on the stack")
  1758  	}
  1759  
  1760  	// Run at a few different stack depths just to avoid an unlucky pass
  1761  	// due to variables ending up on different pages.
  1762  	if n > 0 {
  1763  		test10303(t, n-1)
  1764  	}
  1765  	if t.Failed() {
  1766  		return
  1767  	}
  1768  	var x, y, z, v, si C.int
  1769  	var s C.Struct
  1770  	C.setintstar(&x)
  1771  	C.setintptr(&y)
  1772  	C.setvoidptr(unsafe.Pointer(&v))
  1773  	s.P = &si
  1774  	C.setstruct(s)
  1775  
  1776  	if uintptr(unsafe.Pointer(&x))&^0xfff == uintptr(unsafe.Pointer(&z))&^0xfff {
  1777  		t.Error("C int* argument on stack")
  1778  	}
  1779  	if uintptr(unsafe.Pointer(&y))&^0xfff == uintptr(unsafe.Pointer(&z))&^0xfff {
  1780  		t.Error("C intptr argument on stack")
  1781  	}
  1782  	if uintptr(unsafe.Pointer(&v))&^0xfff == uintptr(unsafe.Pointer(&z))&^0xfff {
  1783  		t.Error("C void* argument on stack")
  1784  	}
  1785  	if uintptr(unsafe.Pointer(&si))&^0xfff == uintptr(unsafe.Pointer(&z))&^0xfff {
  1786  		t.Error("C struct field pointer on stack")
  1787  	}
  1788  }
  1789  
  1790  // issue 11925
  1791  
  1792  func test11925(t *testing.T) {
  1793  	if C.sizeof_struct_a11925 != unsafe.Sizeof(C.struct_a11925{}) {
  1794  		t.Errorf("size of a changed: C %d, Go %d", C.sizeof_struct_a11925, unsafe.Sizeof(C.struct_a11925{}))
  1795  	}
  1796  	if C.sizeof_struct_b11925 != unsafe.Sizeof(C.struct_b11925{}) {
  1797  		t.Errorf("size of b changed: C %d, Go %d", C.sizeof_struct_b11925, unsafe.Sizeof(C.struct_b11925{}))
  1798  	}
  1799  }
  1800  
  1801  // issue 12030
  1802  
  1803  func test12030(t *testing.T) {
  1804  	buf := (*C.char)(C.malloc(256))
  1805  	defer C.free(unsafe.Pointer(buf))
  1806  	for _, f := range []float64{1.0, 2.0, 3.14} {
  1807  		C.issue12030conv(buf, C.double(f))
  1808  		got := C.GoString(buf)
  1809  		if want := fmt.Sprintf("d=%g", f); got != want {
  1810  			t.Fatalf("C.sprintf failed for %g: %q != %q", f, got, want)
  1811  		}
  1812  	}
  1813  }
  1814  
  1815  // issue 13402
  1816  
  1817  var _ C.complexfloat
  1818  var _ C.complexdouble
  1819  
  1820  // issue 13930
  1821  // Test that cgo's multiple-value special form for
  1822  // C function calls works in variable declaration statements.
  1823  
  1824  var _, _ = C.abs(0)
  1825  
  1826  // issue 14838
  1827  
  1828  func test14838(t *testing.T) {
  1829  	data := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
  1830  	cData := C.CBytes(data)
  1831  	defer C.free(cData)
  1832  
  1833  	if C.check_cbytes((*C.char)(cData), C.size_t(len(data))) == 0 {
  1834  		t.Fatalf("mismatched data: expected %v, got %v", data, (*(*[10]byte)(unsafe.Pointer(cData)))[:])
  1835  	}
  1836  }
  1837  
  1838  // issue 17065
  1839  
  1840  var sink C.int
  1841  
  1842  func test17065(t *testing.T) {
  1843  	if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
  1844  		t.Skip("broken on darwin; issue 17065")
  1845  	}
  1846  	for i := range C.ii {
  1847  		sink = C.ii[i]
  1848  	}
  1849  }
  1850  
  1851  // issue 17537
  1852  
  1853  func test17537(t *testing.T) {
  1854  	v := C.S17537{i: 17537}
  1855  	if got, want := C.I17537(&v), C.int(17537); got != want {
  1856  		t.Errorf("got %d, want %d", got, want)
  1857  	}
  1858  
  1859  	p := (*C.char)(C.malloc(1))
  1860  	*p = 17
  1861  	if got, want := C.F17537(&p), C.int(17); got != want {
  1862  		t.Errorf("got %d, want %d", got, want)
  1863  	}
  1864  
  1865  	C.F18298(nil)
  1866  	var v18298 C.T18298_2
  1867  	C.G18298(C.T18298_1(v18298))
  1868  }
  1869  
  1870  // issue 17723
  1871  
  1872  func testAPI() {
  1873  	var cs *C.char
  1874  	cs = C.CString("hello")
  1875  	defer C.free(unsafe.Pointer(cs))
  1876  	var s string
  1877  	s = C.GoString((*C.char)(C.api_hello))
  1878  	s = C.GoStringN((*C.char)(C.api_hello), C.int(6))
  1879  	var b []byte
  1880  	b = C.GoBytes(unsafe.Pointer(C.api_hello), C.int(6))
  1881  	_, _ = s, b
  1882  	C.cstring_pointer_fun(nil)
  1883  }
  1884  
  1885  // issue 18126
  1886  
  1887  func test18126(t *testing.T) {
  1888  	p := C.malloc(1)
  1889  	_, err := C.Issue18126C(&p)
  1890  	C.free(p)
  1891  	_ = err
  1892  }
  1893  
  1894  // issue 18720
  1895  
  1896  func test18720(t *testing.T) {
  1897  	if got, want := C.HELLO_WORLD, "hello\000world"; got != want {
  1898  		t.Errorf("C.HELLO_WORLD == %q, expected %q", got, want)
  1899  	}
  1900  
  1901  	if got, want := C.VAR1, C.int(5); got != want {
  1902  		t.Errorf("C.VAR1 == %v, expected %v", got, want)
  1903  	}
  1904  
  1905  	if got, want := *C.ADDR, C.int(5); got != want {
  1906  		t.Errorf("*C.ADDR == %v, expected %v", got, want)
  1907  	}
  1908  
  1909  	if got, want := C.CALL, C.int(6); got != want {
  1910  		t.Errorf("C.CALL == %v, expected %v", got, want)
  1911  	}
  1912  
  1913  	if got, want := C.CALL, C.int(7); got != want {
  1914  		t.Errorf("C.CALL == %v, expected %v", got, want)
  1915  	}
  1916  
  1917  	// Issue 20125.
  1918  	if got, want := C.SIZE_OF_FOO, 1; got != want {
  1919  		t.Errorf("C.SIZE_OF_FOO == %v, expected %v", got, want)
  1920  	}
  1921  }
  1922  
  1923  // issue 20129
  1924  
  1925  func test20129(t *testing.T) {
  1926  	if C.issue20129 != 0 {
  1927  		t.Fatal("test is broken")
  1928  	}
  1929  	C.issue20129Foo()
  1930  	if C.issue20129 != 1 {
  1931  		t.Errorf("got %v but expected %v", C.issue20129, 1)
  1932  	}
  1933  	C.issue20129Bar()
  1934  	if C.issue20129 != 2 {
  1935  		t.Errorf("got %v but expected %v", C.issue20129, 2)
  1936  	}
  1937  }
  1938  
  1939  // issue 20369
  1940  
  1941  func test20369(t *testing.T) {
  1942  	if C.XUINT64_MAX != math.MaxUint64 {
  1943  		t.Fatalf("got %v, want %v", uint64(C.XUINT64_MAX), uint64(math.MaxUint64))
  1944  	}
  1945  }
  1946  
  1947  // issue 21668
  1948  
  1949  var issue21668_X = C.x21668
  1950  
  1951  // issue 21708
  1952  
  1953  func test21708(t *testing.T) {
  1954  	if got, want := C.CAST_TO_INT64, -1; got != want {
  1955  		t.Errorf("C.CAST_TO_INT64 == %v, expected %v", got, want)
  1956  	}
  1957  }
  1958  
  1959  // issue 21809
  1960  
  1961  func test21809(t *testing.T) {
  1962  	longVar := C.long(3)
  1963  	typedefVar := C.MySigned_t(4)
  1964  	typedefTypedefVar := C.MySigned2_t(5)
  1965  
  1966  	// all three should be considered identical to `long`
  1967  	if ret := C.takes_long(longVar); ret != 9 {
  1968  		t.Errorf("got %v but expected %v", ret, 9)
  1969  	}
  1970  	if ret := C.takes_long(typedefVar); ret != 16 {
  1971  		t.Errorf("got %v but expected %v", ret, 16)
  1972  	}
  1973  	if ret := C.takes_long(typedefTypedefVar); ret != 25 {
  1974  		t.Errorf("got %v but expected %v", ret, 25)
  1975  	}
  1976  
  1977  	// They should also be identical to the typedef'd type
  1978  	if ret := C.takes_typedef(longVar); ret != 9 {
  1979  		t.Errorf("got %v but expected %v", ret, 9)
  1980  	}
  1981  	if ret := C.takes_typedef(typedefVar); ret != 16 {
  1982  		t.Errorf("got %v but expected %v", ret, 16)
  1983  	}
  1984  	if ret := C.takes_typedef(typedefTypedefVar); ret != 25 {
  1985  		t.Errorf("got %v but expected %v", ret, 25)
  1986  	}
  1987  }
  1988  
  1989  // issue 22906
  1990  
  1991  func test22906(t *testing.T) {
  1992  	var x1 C.jobject = 0 // Note: 0, not nil. That makes sure we use uintptr for these types.
  1993  	_ = x1
  1994  	var x2 C.jclass = 0
  1995  	_ = x2
  1996  	var x3 C.jthrowable = 0
  1997  	_ = x3
  1998  	var x4 C.jstring = 0
  1999  	_ = x4
  2000  	var x5 C.jarray = 0
  2001  	_ = x5
  2002  	var x6 C.jbooleanArray = 0
  2003  	_ = x6
  2004  	var x7 C.jbyteArray = 0
  2005  	_ = x7
  2006  	var x8 C.jcharArray = 0
  2007  	_ = x8
  2008  	var x9 C.jshortArray = 0
  2009  	_ = x9
  2010  	var x10 C.jintArray = 0
  2011  	_ = x10
  2012  	var x11 C.jlongArray = 0
  2013  	_ = x11
  2014  	var x12 C.jfloatArray = 0
  2015  	_ = x12
  2016  	var x13 C.jdoubleArray = 0
  2017  	_ = x13
  2018  	var x14 C.jobjectArray = 0
  2019  	_ = x14
  2020  	var x15 C.jweak = 0
  2021  	_ = x15
  2022  }
  2023  
  2024  // issue 22958
  2025  // Nothing to run, just make sure this compiles.
  2026  var Vissue22958 C.issue22958Type
  2027  
  2028  func test23356(t *testing.T) {
  2029  	if got, want := C.a(), C.int(5); got != want {
  2030  		t.Errorf("C.a() == %v, expected %v", got, want)
  2031  	}
  2032  	if got, want := C.r(), C.int(3); got != want {
  2033  		t.Errorf("C.r() == %v, expected %v", got, want)
  2034  	}
  2035  }
  2036  
  2037  // issue 23720
  2038  
  2039  func Issue23720F() {
  2040  	var x C.issue23720A
  2041  	C.issue23720F(x)
  2042  }
  2043  
  2044  // issue 24206
  2045  
  2046  func test24206(t *testing.T) {
  2047  	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
  2048  		t.Skipf("skipping on %s/%s", runtime.GOOS, runtime.GOARCH)
  2049  	}
  2050  
  2051  	if l := len(C.GoString(C.dangerousString1())); l != 123 {
  2052  		t.Errorf("Incorrect string length - got %d, want 123", l)
  2053  	}
  2054  	if l := len(C.GoString(C.dangerousString2())); l != 4096+123 {
  2055  		t.Errorf("Incorrect string length - got %d, want %d", l, 4096+123)
  2056  	}
  2057  }
  2058  
  2059  // issue 25143
  2060  
  2061  func issue25143sum(ns ...C.int) C.int {
  2062  	total := C.int(0)
  2063  	for _, n := range ns {
  2064  		total += n
  2065  	}
  2066  	return total
  2067  }
  2068  
  2069  func test25143(t *testing.T) {
  2070  	if got, want := issue25143sum(1, 2, 3), C.int(6); got != want {
  2071  		t.Errorf("issue25143sum(1, 2, 3) == %v, expected %v", got, want)
  2072  	}
  2073  }
  2074  
  2075  // issue 26066
  2076  // Wrong type of constant with GCC 8 and newer.
  2077  
  2078  func test26066(t *testing.T) {
  2079  	var i = int64(C.issue26066)
  2080  	if i != -1 {
  2081  		t.Errorf("got %d, want -1", i)
  2082  	}
  2083  }
  2084  
  2085  // issue 26517
  2086  var a C.TypeOne
  2087  var b C.TypeTwo
  2088  
  2089  // issue 27660
  2090  // Stress the interaction between the race detector and cgo in an
  2091  // attempt to reproduce the memory corruption described in #27660.
  2092  // The bug was very timing sensitive; at the time of writing this
  2093  // test would only trigger the bug about once out of every five runs.
  2094  
  2095  func test27660(t *testing.T) {
  2096  	ctx, cancel := context.WithCancel(context.Background())
  2097  	defer cancel()
  2098  	ints := make([]int, 100)
  2099  	locks := make([]sync.Mutex, 100)
  2100  	// Slowly create threads so that ThreadSanitizer is forced to
  2101  	// frequently resize its SyncClocks.
  2102  	for i := 0; i < 100; i++ {
  2103  		go func() {
  2104  			for ctx.Err() == nil {
  2105  				// Sleep in C for long enough that it is likely that the runtime
  2106  				// will retake this goroutine's currently wired P.
  2107  				C.usleep(1000 /* 1ms */)
  2108  				runtime.Gosched() // avoid starvation (see #28701)
  2109  			}
  2110  		}()
  2111  		go func() {
  2112  			// Trigger lots of synchronization and memory reads/writes to
  2113  			// increase the likelihood that the race described in #27660
  2114  			// results in corruption of ThreadSanitizer's internal state
  2115  			// and thus an assertion failure or segfault.
  2116  			i := 0
  2117  			for ctx.Err() == nil {
  2118  				j := rand.Intn(100)
  2119  				locks[j].Lock()
  2120  				ints[j]++
  2121  				locks[j].Unlock()
  2122  				// needed for gccgo, to avoid creation of an
  2123  				// unpreemptible "fast path" in this loop. Choice
  2124  				// of (1<<24) is somewhat arbitrary.
  2125  				if i%(1<<24) == 0 {
  2126  					runtime.Gosched()
  2127  				}
  2128  				i++
  2129  
  2130  			}
  2131  		}()
  2132  		time.Sleep(time.Millisecond)
  2133  	}
  2134  }
  2135  
  2136  // issue 28540
  2137  
  2138  func twoargsF() {
  2139  	var v struct{ p *byte }
  2140  	C.twoargs1(C.twoargs2(), C.twoargs3(unsafe.Pointer(&v)))
  2141  }
  2142  
  2143  // issue 28545
  2144  
  2145  func issue28545G(p **C.char) {
  2146  	C.issue28545F(p, -1, (0))
  2147  	C.issue28545F(p, 2+3, complex(1, 1))
  2148  	C.issue28545F(p, issue28772Constant, issue28772Constant2)
  2149  }
  2150  
  2151  // issue 28772 part 1 - part 2 in testx.go
  2152  
  2153  const issue28772Constant = C.issue28772Constant
  2154  
  2155  // issue 28896
  2156  
  2157  func offset(i int) uintptr {
  2158  	var pi C.innerPacked
  2159  	var po C.outerPacked
  2160  	var ui C.innerUnpacked
  2161  	var uo C.outerUnpacked
  2162  	switch i {
  2163  	case 0:
  2164  		return unsafe.Offsetof(pi.f2)
  2165  	case 1:
  2166  		return unsafe.Offsetof(po.g2)
  2167  	case 2:
  2168  		return unsafe.Offsetof(ui.f2)
  2169  	case 3:
  2170  		return unsafe.Offsetof(uo.g2)
  2171  	default:
  2172  		panic("can't happen")
  2173  	}
  2174  }
  2175  
  2176  func test28896(t *testing.T) {
  2177  	for i := 0; i < 4; i++ {
  2178  		c := uintptr(C.offset(C.int(i)))
  2179  		g := offset(i)
  2180  		if c != g {
  2181  			t.Errorf("%d: C: %d != Go %d", i, c, g)
  2182  		}
  2183  	}
  2184  }
  2185  
  2186  // issue 29383
  2187  // cgo's /*line*/ comments failed when inserted after '/',
  2188  // because the result looked like a "//" comment.
  2189  // No runtime test; just make sure it compiles.
  2190  
  2191  func Issue29383(n, size uint) int {
  2192  	if ^C.size_t(0)/C.size_t(n) < C.size_t(size) {
  2193  		return 0
  2194  	}
  2195  	return 0
  2196  }
  2197  
  2198  // issue 29748
  2199  // Error handling a struct initializer that requires pointer checking.
  2200  // Compilation test only, nothing to run.
  2201  
  2202  var Vissue29748 = C.f29748(&C.S29748{
  2203  	nil,
  2204  })
  2205  
  2206  func Fissue299748() {
  2207  	C.f29748(&C.S29748{
  2208  		nil,
  2209  	})
  2210  }
  2211  
  2212  // issue 29781
  2213  
  2214  var issue29781X struct{ X int }
  2215  
  2216  func issue29781F(...int) int { return 0 }
  2217  
  2218  func issue29781G() {
  2219  	var p *C.char
  2220  	C.issue29781F(&p, C.ISSUE29781C+1)
  2221  	C.issue29781F(nil, (C.int)(
  2222  		0))
  2223  	C.issue29781F(&p, (C.int)(0))
  2224  	C.issue29781F(&p, (C.int)(
  2225  		0))
  2226  	C.issue29781F(&p, (C.int)(issue29781X.
  2227  		X))
  2228  }
  2229  
  2230  // issue 30065
  2231  
  2232  func test30065(t *testing.T) {
  2233  	var a [256]byte
  2234  	b := []byte("a")
  2235  	C.memcpy(unsafe.Pointer(&a), unsafe.Pointer(&b[0]), 1)
  2236  	if a[0] != 'a' {
  2237  		t.Errorf("&a failed: got %c, want %c", a[0], 'a')
  2238  	}
  2239  
  2240  	b = []byte("b")
  2241  	C.memcpy(unsafe.Pointer(&a[0]), unsafe.Pointer(&b[0]), 1)
  2242  	if a[0] != 'b' {
  2243  		t.Errorf("&a[0] failed: got %c, want %c", a[0], 'b')
  2244  	}
  2245  
  2246  	d := make([]byte, 256)
  2247  	b = []byte("c")
  2248  	C.memcpy(unsafe.Pointer(&d[0]), unsafe.Pointer(&b[0]), 1)
  2249  	if d[0] != 'c' {
  2250  		t.Errorf("&d[0] failed: got %c, want %c", d[0], 'c')
  2251  	}
  2252  }
  2253  
  2254  // issue 31093
  2255  // No runtime test; just make sure it compiles.
  2256  
  2257  func Issue31093() {
  2258  	C.issue31093F(C.ushort(0))
  2259  }
  2260  
  2261  // issue 32579
  2262  
  2263  func test32579(t *testing.T) {
  2264  	var s [1]C.struct_S32579
  2265  	C.memset(unsafe.Pointer(&s[0].data[0]), 1, 1)
  2266  	if s[0].data[0] != 1 {
  2267  		t.Errorf("&s[0].data[0] failed: got %d, want %d", s[0].data[0], 1)
  2268  	}
  2269  }
  2270  
  2271  // issue 37033, check if cgo.Handle works properly
  2272  
  2273  func testHandle(t *testing.T) {
  2274  	ch := make(chan int)
  2275  
  2276  	for i := 0; i < 42; i++ {
  2277  		h := cgo.NewHandle(ch)
  2278  		go func() {
  2279  			C.cFunc37033(C.uintptr_t(h))
  2280  		}()
  2281  		if v := <-ch; issue37033 != v {
  2282  			t.Fatalf("unexpected receiving value: got %d, want %d", v, issue37033)
  2283  		}
  2284  		h.Delete()
  2285  	}
  2286  }
  2287  
  2288  // issue 38649
  2289  
  2290  var issue38649 C.netbsd_gid = 42
  2291  
  2292  // issue 39877
  2293  
  2294  var issue39877 *C.void = nil
  2295  
  2296  // issue 40494
  2297  // No runtime test; just make sure it compiles.
  2298  
  2299  func Issue40494() {
  2300  	C.issue40494(C.enum_Enum40494(C.X_40494), (*C.union_Union40494)(nil))
  2301  }
  2302  
  2303  // Issue 45451.
  2304  func test45451(t *testing.T) {
  2305  	var u *C.issue45451
  2306  	typ := reflect.ValueOf(u).Type().Elem()
  2307  
  2308  	// The type is undefined in C so allocating it should panic.
  2309  	defer func() {
  2310  		if r := recover(); r == nil {
  2311  			t.Error("expected panic")
  2312  		}
  2313  	}()
  2314  
  2315  	_ = reflect.New(typ)
  2316  	t.Errorf("reflect.New(%v) should have panicked", typ)
  2317  }
  2318  
  2319  // issue 52542
  2320  
  2321  func func52542[T ~[]C.int]() {}
  2322  
  2323  type type52542[T ~*C.float] struct{}
  2324  

View as plain text