//go:build aix || dragonfly || freebsd || linux || netbsd || solaris

package cgosotest

/*
extern int __thread tlsvar;
int *getTLS() { return &tlsvar; }
*/
import "C"

func init() {
	if v := *C.getTLS(); v != 12345 {
		println("got", v)
		panic("BAD TLS value")
	}

        def file1 = rootDir.createFile("a/b/1.txt")
        file1 << '12345'
        def file2 = rootDir.createFile("a/b/2.txt")
        file2 << '12345'
        def file3 = rootDir.createFile("a/b/3.txt")
        file3 << '12345'
        def fileTree = new DirectoryFileTree(rootDir, new PatternSet(), NativeServicesTestFixture.getInstance().get(FileSystem), false)

        def delegateOutput = Mock(Object)
        def delegateResult = Mock(WorkspaceResult)
        def originMetadata = Stub(OriginMetadata) {
            buildInvocationId >> "12345"
        }
        def executionOutputState = Mock(ExecutionOutputState)

        def execution = step.executeDeferred(work, context, cache)

        when:
        def cacheResult = execution.completeAndGet()

					Ports: []v1.ServicePort{
						{
							Name:     "testPort",
							Port:     int32(12345),
							Protocol: v1.ProtocolTCP,
						},
					},
				},
			},
			expected: map[ServicePortName]*BaseServicePortInfo{
				makeServicePortName("test", "extra-space", "testPort", v1.ProtocolTCP): makeTestServiceInfo(testClusterIPv4, 12345, "TCP", 0, func(bsvcPortInfo *BaseServicePortInfo) {

type T struct {
	a, b, c, d, e int
}

//go:noinline
func F() {
	a, b := g(), g()
	h(b, b)
	h(a, g())
	if a.a == 1 {
		a = g()
	}
	h(a, a)
}

//go:noinline
func g() T {
	return T{1, 2, 3, 4, 5}
}

//go:noinline
func h(s, t T) {
	if s != t {
		println("NEQ")
	}
}

	}
}

func TestSimpleGet(t *testing.T) {
	c := NewLRUExpireCache(10)
	c.Add("long-lived", "12345", 10*time.Hour)

	assertKeys(t, c.Keys(), []interface{}{"long-lived"})

	expectEntry(t, c, "long-lived", "12345")
}

func TestSimpleRemove(t *testing.T) {
	c := NewLRUExpireCache(10)
	c.Add("long-lived", "12345", 10*time.Hour)
	c.Remove("long-lived")

	assertKeys(t, c.Keys(), []interface{}{})

	a := float64(x)
	b := int64(x)
	return a, b
}

var a, b, c float64

// Poison some floating point registers with non-zero high bits.
//
//go:noinline
func poison(x float64) {
	a = x - 123.45
	b = a * 1.2
	c = b + 3.4
}

func main() {
	poison(333.3)
	_, b := F(123)
	if b != 123 {
		panic("FAIL")
	}

func (f fakeWinNodeStatsClient) getNodeMetrics() (nodeMetrics, error) {
	return nodeMetrics{
		cpuUsageCoreNanoSeconds:   123,
		cpuUsageNanoCores:         23,
		memoryPrivWorkingSetBytes: 1234,
		memoryCommittedBytes:      12345,
		timeStamp:                 timeStamp,
	}, nil
}

func (f fakeWinNodeStatsClient) getNodeInfo() nodeInfo {
	return nodeInfo{
		kernelVersion:               "v42",
		memoryPhysicalCapacityBytes: 1.6e+10,
	}

	grace := int64(30)
	enableServiceLinks := v1.DefaultEnableServiceLinks
	pod := &v1.Pod{
		TypeMeta: metav1.TypeMeta{
			APIVersion: "",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      "test",
			UID:       "12345",
			Namespace: "mynamespace",
		},
		Spec: v1.PodSpec{
			RestartPolicy:                 v1.RestartPolicyAlways,
			DNSPolicy:                     v1.DNSClusterFirst,
			TerminationGracePeriodSeconds: &grace,

	"os"
	"reflect"
	"strings"
	"testing"

	tracingapi "k8s.io/component-base/tracing/api/v1"
)

var (
	localhost    = "localhost:4317"
	ipAddress    = "127.0.0.1:4317"
	samplingRate = int32(12345)
)

func strptr(s string) *string {
	return &s
}

func TestValidateTracingOptions(t *testing.T) {
	testcases := []struct {
		name        string
		expectError bool
		contents    *TracingOptions
	}{