misc/cgo/test/testx.go

   1 // Copyright 2011 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 //export directives on Go functions
   8 // and so it must NOT contain C definitions (only declarations).
   9 // See test.go for C definitions.
  10
  11 package cgotest
  12
  13 import (
  14         "runtime"
  15         "runtime/cgo"
  16         "runtime/debug"
  17         "strings"
  18         "sync"
  19         "sync/atomic"
  20         "testing"
  21         "unsafe"
  22 )
  23
  24 /*
  25 // threads
  26 extern void doAdd(int, int);
  27 extern int callGoInCThread(int);
  28
  29 // issue 1328
  30 void IntoC(void);
  31
  32 // issue 1560
  33 extern void Issue1560InC(void);
  34
  35 // twoSleep returns the absolute start time of the first sleep
  36 // in ms.
  37 long long twoSleep(int);
  38
  39 // issue 3775
  40 void lockOSThreadC(void);
  41 int usleep(unsigned usec);
  42
  43 // issue 4054 part 2 - part 1 in test.go
  44 typedef enum {
  45         A = 0,
  46         B,
  47         C,
  48         D,
  49         E,
  50         F,
  51         G,
  52         H,
  53         II,
  54         J,
  55 } issue4054b;
  56
  57 // issue 5548
  58
  59 extern int issue5548_in_c(void);
  60
  61 // issue 6833
  62
  63 extern unsigned long long issue6833Func(unsigned int, unsigned long long);
  64
  65 // issue 6907
  66
  67 extern int CheckIssue6907C(_GoString_);
  68
  69 // issue 7665
  70
  71 extern void f7665(void);
  72
  73 // issue 7978
  74 // Stack tracing didn't work during cgo code after calling a Go
  75 // callback.  Make sure GC works and the stack trace is correct.
  76
  77 #include <stdint.h>
  78
  79 // use ugly atomic variable sync since that doesn't require calling back into
  80 // Go code or OS dependencies
  81 void issue7978c(uint32_t *sync);
  82
  83 // issue 8331 part 2 - part 1 in test.go
  84 // A typedef of an unnamed struct is the same struct when
  85 // #include'd twice.  No runtime test; just make sure it compiles.
  86 #include "issue8331.h"
  87
  88 // issue 8945
  89
  90 typedef void (*PFunc8945)();
  91 extern PFunc8945 func8945; // definition is in test.go
  92
  93 // issue 20910
  94 void callMulti(void);
  95
  96 // issue 28772 part 2 - part 1 in issuex.go
  97 #define issue28772Constant2 2
  98
  99
 100 // issue 31891
 101 typedef struct {
 102         long obj;
 103 } Issue31891A;
 104
 105 typedef struct {
 106         long obj;
 107 } Issue31891B;
 108
 109 void callIssue31891(void);
 110
 111 typedef struct {
 112         int i;
 113 } Issue38408, *PIssue38408;
 114
 115 extern void cfunc49633(void*); // definition is in test.go
 116 */
 117 import "C"
 118
 119 // exports
 120
 121 //export ReturnIntLong
 122 func ReturnIntLong() (int, C.long) {
 123         return 1, 2
 124 }
 125
 126 //export gc
 127 func gc() {
 128         runtime.GC()
 129 }
 130
 131 // threads
 132
 133 var sum struct {
 134         sync.Mutex
 135         i int
 136 }
 137
 138 //export Add
 139 func Add(x int) {
 140         defer func() {
 141                 recover()
 142         }()
 143         sum.Lock()
 144         sum.i += x
 145         sum.Unlock()
 146         var p *int
 147         *p = 2
 148 }
 149
 150 //export goDummy
 151 func goDummy() {
 152 }
 153
 154 func testCthread(t *testing.T) {
 155         if (runtime.GOOS == "darwin" || runtime.GOOS == "ios") && runtime.GOARCH == "arm64" {
 156                 t.Skip("the iOS exec wrapper is unable to properly handle the panic from Add")
 157         }
 158         sum.i = 0
 159         C.doAdd(10, 6)
 160
 161         want := 10 * (10 - 1) / 2 * 6
 162         if sum.i != want {
 163                 t.Fatalf("sum=%d, want %d", sum.i, want)
 164         }
 165 }
 166
 167 // Benchmark measuring overhead from C to Go in a C thread.
 168 // Create a new C thread and invoke Go function repeatedly in the new C thread.
 169 func benchCGoInCthread(b *testing.B) {
 170         n := C.callGoInCThread(C.int(b.N))
 171         if int(n) != b.N {
 172                 b.Fatal("unmatch loop times")
 173         }
 174 }
 175
 176 // issue 1328
 177
 178 //export BackIntoGo
 179 func BackIntoGo() {
 180         x := 1
 181
 182         for i := 0; i < 10000; i++ {
 183                 xvariadic(x)
 184                 if x != 1 {
 185                         panic("x is not 1?")
 186                 }
 187         }
 188 }
 189
 190 func xvariadic(x ...interface{}) {
 191 }
 192
 193 func test1328(t *testing.T) {
 194         C.IntoC()
 195 }
 196
 197 // issue 1560
 198 // Test that C functions and Go functions run in parallel.
 199
 200 var (
 201         issue1560 int32
 202
 203         issue1560Ch = make(chan bool, 2)
 204 )
 205
 206 //export Issue1560FromC
 207 func Issue1560FromC() {
 208         for atomic.LoadInt32(&issue1560) != 1 {
 209                 runtime.Gosched()
 210         }
 211         atomic.AddInt32(&issue1560, 1)
 212         for atomic.LoadInt32(&issue1560) != 3 {
 213                 runtime.Gosched()
 214         }
 215         issue1560Ch <- true
 216 }
 217
 218 func Issue1560FromGo() {
 219         atomic.AddInt32(&issue1560, 1)
 220         for atomic.LoadInt32(&issue1560) != 2 {
 221                 runtime.Gosched()
 222         }
 223         atomic.AddInt32(&issue1560, 1)
 224         issue1560Ch <- true
 225 }
 226
 227 func test1560(t *testing.T) {
 228         go Issue1560FromGo()
 229         go C.Issue1560InC()
 230         <-issue1560Ch
 231         <-issue1560Ch
 232 }
 233
 234 // issue 2462
 235
 236 //export exportbyte
 237 func exportbyte() byte {
 238         return 0
 239 }
 240
 241 //export exportbool
 242 func exportbool() bool {
 243         return false
 244 }
 245
 246 //export exportrune
 247 func exportrune() rune {
 248         return 0
 249 }
 250
 251 //export exporterror
 252 func exporterror() error {
 253         return nil
 254 }
 255
 256 //export exportint
 257 func exportint() int {
 258         return 0
 259 }
 260
 261 //export exportuint
 262 func exportuint() uint {
 263         return 0
 264 }
 265
 266 //export exportuintptr
 267 func exportuintptr() uintptr {
 268         return (uintptr)(0)
 269 }
 270
 271 //export exportint8
 272 func exportint8() int8 {
 273         return 0
 274 }
 275
 276 //export exportuint8
 277 func exportuint8() uint8 {
 278         return 0
 279 }
 280
 281 //export exportint16
 282 func exportint16() int16 {
 283         return 0
 284 }
 285
 286 //export exportuint16
 287 func exportuint16() uint16 {
 288         return 0
 289 }
 290
 291 //export exportint32
 292 func exportint32() int32 {
 293         return 0
 294 }
 295
 296 //export exportuint32
 297 func exportuint32() uint32 {
 298         return 0
 299 }
 300
 301 //export exportint64
 302 func exportint64() int64 {
 303         return 0
 304 }
 305
 306 //export exportuint64
 307 func exportuint64() uint64 {
 308         return 0
 309 }
 310
 311 //export exportfloat32
 312 func exportfloat32() float32 {
 313         return 0
 314 }
 315
 316 //export exportfloat64
 317 func exportfloat64() float64 {
 318         return 0
 319 }
 320
 321 //export exportcomplex64
 322 func exportcomplex64() complex64 {
 323         return 0
 324 }
 325
 326 //export exportcomplex128
 327 func exportcomplex128() complex128 {
 328         return 0
 329 }
 330
 331 // issue 3741
 332
 333 //export exportSliceIn
 334 func exportSliceIn(s []byte) bool {
 335         return len(s) == cap(s)
 336 }
 337
 338 //export exportSliceOut
 339 func exportSliceOut() []byte {
 340         return []byte{1}
 341 }
 342
 343 //export exportSliceInOut
 344 func exportSliceInOut(s []byte) []byte {
 345         return s
 346 }
 347
 348 // issue 3775
 349
 350 func init() {
 351         if runtime.GOOS == "android" {
 352                 return
 353         }
 354         // Same as test3775 but run during init so that
 355         // there are two levels of internal runtime lock
 356         // (1 for init, 1 for cgo).
 357         // This would have been broken by CL 11663043.
 358         C.lockOSThreadC()
 359 }
 360
 361 func test3775(t *testing.T) {
 362         if runtime.GOOS == "android" {
 363                 return
 364         }
 365         // Used to panic because of the UnlockOSThread below.
 366         C.lockOSThreadC()
 367 }
 368
 369 //export lockOSThreadCallback
 370 func lockOSThreadCallback() {
 371         runtime.LockOSThread()
 372         runtime.UnlockOSThread()
 373         go C.usleep(10000)
 374         runtime.Gosched()
 375 }
 376
 377 // issue 4054 part 2 - part 1 in test.go
 378
 379 var issue4054b = []int{C.A, C.B, C.C, C.D, C.E, C.F, C.G, C.H, C.II, C.J}
 380
 381 //export issue5548FromC
 382 func issue5548FromC(s string, i int) int {
 383         if len(s) == 4 && s == "test" && i == 42 {
 384                 return 12345
 385         }
 386         println("got", len(s), i)
 387         return 9876
 388 }
 389
 390 func test5548(t *testing.T) {
 391         if x := C.issue5548_in_c(); x != 12345 {
 392                 t.Errorf("issue5548_in_c = %d, want %d", x, 12345)
 393         }
 394 }
 395
 396 // issue 6833
 397
 398 //export GoIssue6833Func
 399 func GoIssue6833Func(aui uint, aui64 uint64) uint64 {
 400         return aui64 + uint64(aui)
 401 }
 402
 403 func test6833(t *testing.T) {
 404         ui := 7
 405         ull := uint64(0x4000300020001000)
 406         v := uint64(C.issue6833Func(C.uint(ui), C.ulonglong(ull)))
 407         exp := uint64(ui) + ull
 408         if v != exp {
 409                 t.Errorf("issue6833Func() returns %x, expected %x", v, exp)
 410         }
 411 }
 412
 413 // issue 6907
 414
 415 const CString = "C string"
 416
 417 //export CheckIssue6907Go
 418 func CheckIssue6907Go(s string) C.int {
 419         if s == CString {
 420                 return 1
 421         }
 422         return 0
 423 }
 424
 425 func test6907Go(t *testing.T) {
 426         if got := C.CheckIssue6907C(CString); got != 1 {
 427                 t.Errorf("C.CheckIssue6907C() == %d, want %d", got, 1)
 428         }
 429 }
 430
 431 // issue 7665
 432
 433 var bad7665 unsafe.Pointer = C.f7665
 434 var good7665 uintptr = uintptr(C.f7665)
 435
 436 func test7665(t *testing.T) {
 437         if bad7665 == nil || uintptr(bad7665) != good7665 {
 438                 t.Errorf("ptrs = %p, %#x, want same non-nil pointer", bad7665, good7665)
 439         }
 440 }
 441
 442 // issue 7978
 443
 444 var issue7978sync uint32
 445
 446 func issue7978check(t *testing.T, wantFunc string, badFunc string, depth int) {
 447         runtime.GC()
 448         buf := make([]byte, 65536)
 449         trace := string(buf[:runtime.Stack(buf, true)])
 450         for _, goroutine := range strings.Split(trace, "\n\n") {
 451                 if strings.Contains(goroutine, "test.issue7978go") {
 452                         trace := strings.Split(goroutine, "\n")
 453                         // look for the expected function in the stack
 454                         for i := 0; i < depth; i++ {
 455                                 if badFunc != "" && strings.Contains(trace[1+2*i], badFunc) {
 456                                         t.Errorf("bad stack: found %s in the stack:\n%s", badFunc, goroutine)
 457                                         return
 458                                 }
 459                                 if strings.Contains(trace[1+2*i], wantFunc) {
 460                                         return
 461                                 }
 462                         }
 463                         t.Errorf("bad stack: didn't find %s in the stack:\n%s", wantFunc, goroutine)
 464                         return
 465                 }
 466         }
 467         t.Errorf("bad stack: goroutine not found. Full stack dump:\n%s", trace)
 468 }
 469
 470 func issue7978wait(store uint32, wait uint32) {
 471         if store != 0 {
 472                 atomic.StoreUint32(&issue7978sync, store)
 473         }
 474         for atomic.LoadUint32(&issue7978sync) != wait {
 475                 runtime.Gosched()
 476         }
 477 }
 478
 479 //export issue7978cb
 480 func issue7978cb() {
 481         // Force a stack growth from the callback to put extra
 482         // pressure on the runtime. See issue #17785.
 483         growStack(64)
 484         issue7978wait(3, 4)
 485 }
 486
 487 func growStack(n int) int {
 488         var buf [128]int
 489         if n == 0 {
 490                 return 0
 491         }
 492         return buf[growStack(n-1)]
 493 }
 494
 495 func issue7978go() {
 496         C.issue7978c((*C.uint32_t)(&issue7978sync))
 497         issue7978wait(7, 8)
 498 }
 499
 500 func test7978(t *testing.T) {
 501         if runtime.Compiler == "gccgo" {
 502                 t.Skip("gccgo can not do stack traces of C code")
 503         }
 504         debug.SetTraceback("2")
 505         issue7978sync = 0
 506         go issue7978go()
 507         // test in c code, before callback
 508         issue7978wait(0, 1)
 509         issue7978check(t, "_Cfunc_issue7978c(", "", 1)
 510         // test in go code, during callback
 511         issue7978wait(2, 3)
 512         issue7978check(t, "test.issue7978cb(", "test.issue7978go", 3)
 513         // test in c code, after callback
 514         issue7978wait(4, 5)
 515         issue7978check(t, "_Cfunc_issue7978c(", "_cgoexpwrap", 1)
 516         // test in go code, after return from cgo
 517         issue7978wait(6, 7)
 518         issue7978check(t, "test.issue7978go(", "", 3)
 519         atomic.StoreUint32(&issue7978sync, 8)
 520 }
 521
 522 // issue 8331 part 2
 523
 524 var issue8331Var C.issue8331
 525
 526 // issue 8945
 527
 528 //export Test8945
 529 func Test8945() {
 530         _ = C.func8945
 531 }
 532
 533 // issue 20910
 534
 535 //export multi
 536 func multi() (*C.char, C.int) {
 537         return C.CString("multi"), 0
 538 }
 539
 540 func test20910(t *testing.T) {
 541         C.callMulti()
 542 }
 543
 544 // issue 28772 part 2
 545
 546 const issue28772Constant2 = C.issue28772Constant2
 547
 548 // issue 31891
 549
 550 //export useIssue31891A
 551 func useIssue31891A(c *C.Issue31891A) {}
 552
 553 //export useIssue31891B
 554 func useIssue31891B(c *C.Issue31891B) {}
 555
 556 func test31891(t *testing.T) {
 557         C.callIssue31891()
 558 }
 559
 560 // issue 37033, check if cgo.Handle works properly
 561
 562 var issue37033 = 42
 563
 564 //export GoFunc37033
 565 func GoFunc37033(handle C.uintptr_t) {
 566         h := cgo.Handle(handle)
 567         ch := h.Value().(chan int)
 568         ch <- issue37033
 569 }
 570
 571 // issue 38408
 572 // A typedef pointer can be used as the element type.
 573 // No runtime test; just make sure it compiles.
 574 var _ C.PIssue38408 = &C.Issue38408{i: 1}
 575
 576 // issue 49633, example use of cgo.Handle with void*
 577
 578 type data49633 struct {
 579         msg string
 580 }
 581
 582 //export GoFunc49633
 583 func GoFunc49633(context unsafe.Pointer) {
 584         h := *(*cgo.Handle)(context)
 585         v := h.Value().(*data49633)
 586         v.msg = "hello"
 587 }
 588
 589 func test49633(t *testing.T) {
 590         v := &data49633{}
 591         h := cgo.NewHandle(v)
 592         defer h.Delete()
 593         C.cfunc49633(unsafe.Pointer(&h))
 594         if v.msg != "hello" {
 595                 t.Errorf("msg = %q, want 'hello'", v.msg)
 596         }
 597 }