/*
#include <stdint.h>
#include <stdlib.h>

// T is a C struct with alignment padding after b.
// The padding bytes are not considered initialized by MSAN.
// It is big enough to be passed on stack in C ABI (and least
// on AMD64).
typedef struct { char b; uintptr_t x, y; } T;

extern void F(T);

// Use weak as a hack to permit defining a function even though we use export.
void CF(int x) __attribute__ ((weak));
void CF(int x) {

# business if we try "go test -cover" in atomic mode targeting
# sync/atomic itself (see #57445). Just a short test run is needed
# since we're mainly interested in making sure the test builds and can
# execute at least one test.

go test -short -covermode=atomic -run=TestStoreInt64 sync/atomic
go test -short -covermode=atomic -run=TestAnd8 internal/runtime/atomic

# Skip remainder if no race detector support.
[!race] skip

// defined via an embedded interface t. The compiler
// always flattens embedded interfaces so there should
// be no difference between F and G. Alas, currently
// G is not inlineable (at least via export data), so
// the issue is moot, here.
func G(x interface{}) bool {
	type t0 interface {
		f()
	}
	_, ok := x.(interface {
		t0
	})
	return ok
}

	return nil, nil
}

// Environment is the ambient environment that the test runs in.
type Environment interface {
	Resource

	EnvironmentName() string

	// Clusters in this Environment. There will always be at least one.
	Clusters() cluster.Clusters

	// AllClusters in this Environment, including external control planes.
	AllClusters() cluster.Clusters
	IsMultiCluster() bool
	IsMultiNetwork() bool

				t.Errorf("Do error: %v", err)
				return
			}
			if s, _ := v.(string); s != "bar" {
				t.Errorf("Do = %T %v; want %q", v, v, "bar")
			}
		}()
	}
	wg1.Wait()
	// At least one goroutine is in fn now and all of them have at
	// least reached the line before the Do.
	c <- "bar"
	wg2.Wait()
	if got := calls.Load(); got <= 0 || got >= n {
		t.Errorf("number of calls = %d; want over 0 and less than %d", got, n)
	}
}

	// It is not meaningful to use ZVA if the block size is less than 64,
	// so make sure that n is greater than or equal to 64
	CMP	$63, R1
	BLE	tail63

	CMP	$128, R1
	// Ensure n is at least 128 bytes, so that there is enough to copy after
	// alignment.
	BLT	no_zva
	// Check if ZVA is allowed from user code, and if so get the block size
	MOVW	block_size<>(SB), R5
	TBNZ	$31, R5, no_zva

        when:
        container.project(null).library(null)
        container.dependencies

        then:
        def t = thrown(IllegalDependencyNotation)
        t.message == "A project dependency must have at least a project or library name specified."

        where:
        proj | lib  | displayName
        "p1" | "l1" | "project 'p1' library 'l1'"
        "p1" | null | "project 'p1'"
        null | "l1" | "library 'l1'"
    }

stdout tidy

# go help mod tidy explains tidy
go help mod tidy
stdout 'usage: go mod tidy'

# go mod help tidy does too
go mod help tidy
stdout 'usage: go mod tidy'

# go mod --help doesn't print help but at least suggests it.
! go mod --help
stderr 'Run ''go help mod'' for usage.'

# Earlier versions of Go printed the same as 'go -h' here.
# Also make sure we print the short help line.
! go vet -h
stderr 'usage: go vet .*'

	for _, aa := range aas {
		// Only take interfaces whose OperStatus is IfOperStatusUp(0x01) into DNS configs.
		if aa.OperStatus != windows.IfOperStatusUp {
			continue
		}

		// Only take interfaces which have at least one gateway
		if aa.FirstGatewayAddress == nil {
			continue
		}

		for dns := aa.FirstDnsServerAddress; dns != nil; dns = dns.Next {
			sa, err := dns.Address.Sockaddr.Sockaddr()
			if err != nil {
				continue

	"numberUnavailable":      "The number of nodes that should be running the daemon pod and have none of the daemon pod running and available (ready for at least spec.minReadySeconds)",