stdout '^C cgoimport cgotag suffix tag $'

# Disabling cgo should exclude cgo files and their imports.
env CGO_ENABLED=0
go list -f '{{range .GoFiles}}{{.}} {{end}}'
stdout 'empty.go suffix_linux.go tag.go'
go list -f '{{range .CgoFiles}}{{.}} {{end}}'
! stdout .
go list -f '{{range .Imports}}{{.}} {{end}}'
stdout '^suffix tag $'

# Changing OS should exclude linux sources.
env GOOS=darwin
go list -f '{{range .GoFiles}}{{.}} {{end}}'

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build cgo

package main

import "runtime/cgo"

type iface interface {
	Get() int
}

type notInHeap struct {
	_ cgo.Incomplete
	i int
}

type myInt struct {
	f *notInHeap
}

func (mi myInt) Get() int {
	return int(mi.f.i)
}

// license that can be found in the LICENSE file.

//go:build (!cgo && !darwin && !windows && !plan9) || android || (osusergo && !windows && !plan9)

package user

import (
	"fmt"
	"os"
	"runtime"
	"strconv"
)

var (
	// unused variables (in this implementation)
	// modified during test to exercise code paths in the cgo implementation.
	userBuffer  = 0
	groupBuffer = 0
)

	if !cgoAvailable {
		t.Skip("cgo resolver not available")
	}
	defer forceCgoDNS()()
	order, _ := systemConf().hostLookupOrder(nil, "go.dev")
	if order != hostLookupCgo {
		t.Fatalf("hostLookupOrder returned: %v, want cgo", order)
	}
	order, _ = systemConf().addrLookupOrder(nil, "192.0.2.1")
	if order != hostLookupCgo {
		t.Fatalf("addrLookupOrder returned: %v, want cgo", order)
	}

# Issue #42565

[!cgo] skip

# We can't build package bad, which uses #cgo LDFLAGS.
cd bad
! go build
stderr no-such-warning

# We can build package ok with the same flags in CGO_LDFLAGS.
env CGO_LDFLAGS=-Wno-such-warning -Wno-unknown-warning-option
cd ../ok
go build

# Build a main program that actually uses LDFLAGS.
cd ..
go build -ldflags=-v

# Because we passed -v the Go linker should print the external linker

// res_nsearch, for cgo systems where that's available.

//go:build cgo && !netgo && unix && !(darwin || linux || openbsd)

package net

/*
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#include <string.h>
#include <arpa/nameser.h>
#include <resolv.h>

#cgo !aix,!dragonfly,!freebsd LDFLAGS: -lresolv
*/
import "C"

# are run is irrelevant here.
# Finally, note that asm and cgo are run twice.

go build -toolexec=$PWD/mytool
[GOARCH:amd64] stderr -count=2 '^asm'${GOEXE}' TOOLEXEC_IMPORTPATH="test/main/withasm"$'
stderr -count=1 '^compile'${GOEXE}' TOOLEXEC_IMPORTPATH="test/main/withasm"$'
[cgo] stderr -count=2 '^cgo'${GOEXE}' TOOLEXEC_IMPORTPATH="test/main/withcgo"$'
[cgo] stderr -count=1 '^compile'${GOEXE}' TOOLEXEC_IMPORTPATH="test/main/withcgo"$'

	if testing.Short() {
		return
	}

	if *ngo < 1 {
		*ngo = 1 // make sure test is run
	}
	if *verbose {
		fmt.Printf("running test using %d goroutines\n", *ngo)
	}

	// generate filenames
	filenames := make(chan string, 32)
	go genFilenames(t, filenames)

	// launch test goroutines
	done := make(chan int)
	for i := 0; i < *ngo; i++ {
		go testFiles(t, filenames, done)
	}

// This test actually doesn't have anything to do with cgo.  It is a
// test of https://golang.org/issue/7234, a compiler/linker bug in
// handling string constants when using -linkmode=external.  The test
// is in this directory because we routinely test -linkmode=external
// here.

var v7234 = [...]string{"runtime/cgo"}

func Test7234(t *testing.T) {
	if v7234[0] != "runtime/cgo" {
		t.Errorf("bad string constant %q", v7234[0])
	}

// license that can be found in the LICENSE file.

// res_search, for cgo systems where that is thread-safe.

//go:build cgo && !netgo && (linux || openbsd)

package net

/*
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#include <string.h>
#include <arpa/nameser.h>
#include <resolv.h>

#cgo !android,!openbsd LDFLAGS: -lresolv
*/
import "C"