misc/cgo/test/test.go

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