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

   1 // Copyright 2010 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // Test cases for cgo.
   6 // Both the import "C" prologue and the main file are sorted by issue number.
   7 // This file contains C definitions (not just declarations)
   8 // and so it must NOT contain any //export directives on Go functions.
   9 // See testx.go for exports.
  10
  11 package cgotest
  12
  13 /*
  14 #include <complex.h>
  15 #include <math.h>
  16 #include <stdarg.h>
  17 #include <stdbool.h>
  18 #include <stddef.h>
  19 #include <stdint.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24 #include <sys/stat.h>
  25 #include <errno.h>
  26 #cgo !darwin LDFLAGS: -lm
  27
  28 #ifndef WIN32
  29 #include <pthread.h>
  30 #include <signal.h>
  31 #endif
  32
  33 // alignment tests
  34
  35 typedef unsigned char Uint8;
  36 typedef unsigned short Uint16;
  37
  38 typedef enum {
  39  MOD1 = 0x0000,
  40  MODX = 0x8000
  41 } SDLMod;
  42
  43 typedef enum {
  44  A1 = 1,
  45  B1 = 322,
  46  SDLK_LAST
  47 } SDLKey;
  48
  49 typedef struct SDL_keysym {
  50         Uint8 scancode;
  51         SDLKey sym;
  52         SDLMod mod;
  53         Uint16 unicode;
  54 } SDL_keysym;
  55
  56 typedef struct SDL_KeyboardEvent {
  57         Uint8 typ;
  58         Uint8 which;
  59         Uint8 state;
  60         SDL_keysym keysym;
  61 } SDL_KeyboardEvent;
  62
  63 void makeEvent(SDL_KeyboardEvent *event) {
  64  unsigned char *p;
  65  int i;
  66
  67  p = (unsigned char*)event;
  68  for (i=0; i<sizeof *event; i++) {
  69    p[i] = i;
  70  }
  71 }
  72
  73 int same(SDL_KeyboardEvent* e, Uint8 typ, Uint8 which, Uint8 state, Uint8 scan, SDLKey sym, SDLMod mod, Uint16 uni) {
  74   return e->typ == typ && e->which == which && e->state == state && e->keysym.scancode == scan && e->keysym.sym == sym && e->keysym.mod == mod && e->keysym.unicode == uni;
  75 }
  76
  77 void cTest(SDL_KeyboardEvent *event) {
  78  printf("C: %#x %#x %#x %#x %#x %#x %#x\n", event->typ, event->which, event->state,
  79    event->keysym.scancode, event->keysym.sym, event->keysym.mod, event->keysym.unicode);
  80  fflush(stdout);
  81 }
  82
  83 // api
  84
  85 const char *greeting = "hello, world";
  86
  87 // basic test cases
  88
  89 #define SHIFT(x, y)  ((x)<<(y))
  90 #define KILO SHIFT(1, 10)
  91 #define UINT32VAL 0xc008427bU
  92
  93 enum E {
  94         Enum1 = 1,
  95         Enum2 = 2,
  96 };
  97
  98 typedef unsigned char cgo_uuid_t[20];
  99
 100 void uuid_generate(cgo_uuid_t x) {
 101         x[0] = 0;
 102 }
 103
 104 struct S {
 105         int x;
 106 };
 107
 108 const char *cstr = "abcefghijklmnopqrstuvwxyzABCEFGHIJKLMNOPQRSTUVWXYZ1234567890";
 109
 110 extern enum E myConstFunc(struct S* const ctx, int const id, struct S **const filter);
 111
 112 enum E myConstFunc(struct S *const ctx, int const id, struct S **const filter) { return 0; }
 113
 114 int add(int x, int y) {
 115         return x+y;
 116 };
 117
 118 // escape vs noescape
 119
 120 // 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{}