source "${KUBE_ROOT}/hack/lib/init.sh"
source "${KUBE_ROOT}/hack/lib/util.sh"

kube::golang::setup_env

# Ensure that we find the binaries we build before anything else.
export GOBIN="${KUBE_OUTPUT_BIN}"
PATH="${GOBIN}:${PATH}"

# Install golangci-lint
echo 'installing net parser converter'
go -C "${KUBE_ROOT}/hack/tools" install github.com/aojea/sloppy-netparser

cd "${KUBE_ROOT}"

function git_find() {

[short] skip

# Install an echo command because Windows doesn't have it.
env GOBIN=$WORK/tmp/bin
go install echo.go
env PATH=$GOBIN${:}$PATH

# Test go generate handles a simple command
go generate ./generate/simple.go
stdout 'Success'

# Test go generate handles a command alias
go generate './generate/alias.go'
stdout 'Now is the time for all good men'

# Test go generate's variable substitution
go generate './generate/substitution.go'

	defer os.Setenv("GOROOT", os.Getenv("GOROOT"))
	os.Setenv("GOROOT", goroot_bootstrap)

	defer os.Setenv("GOPATH", os.Getenv("GOPATH"))
	os.Setenv("GOPATH", workspace)

	defer os.Setenv("GOBIN", os.Getenv("GOBIN"))
	os.Setenv("GOBIN", "")

	os.Setenv("GOOS", "")
	os.Setenv("GOHOSTOS", "")
	os.Setenv("GOARCH", "")
	os.Setenv("GOHOSTARCH", "")

	// Run Go bootstrap to build binaries.

kube::golang::setup_env
kube::util::ensure-temp-dir

# Install apidiff and make sure it's found.
export GOBIN="${KUBE_TEMP}"
PATH="${GOBIN}:${PATH}"
echo "Installing apidiff into ${GOBIN}."
go install golang.org/x/exp/cmd/apidiff@latest

cd "${KUBE_ROOT}"

# output_name targets a target directory and prints the base name of
# an output file for that target.

env GO111MODULE=off

# Test that a main_test of 'package main' imports the package,
# not the installed binary.

[short] skip

env GOBIN=$WORK/bin
go test main_test
go install main_test

go list -f '{{.Stale}}' main_test
stdout false

go test main_test

-- main_test/m.go --
package main

func F()    {}
func main() {}
-- main_test/m_test.go --
package main_test

import (
	. "main_test"
	"testing"

//
// This catches accidental dependencies between the HTTP transport and
// server code.
func TestCmdGoNoHTTPServer(t *testing.T) {
	t.Parallel()
	goBin := testenv.GoToolPath(t)
	out, err := testenv.Command(t, goBin, "tool", "nm", goBin).CombinedOutput()
	if err != nil {
		t.Fatalf("go tool nm: %v: %s", err, out)
	}
	wantSym := map[string]bool{
		// Verify these exist: (sanity checking this test)

	// GO_TEST_SHORT=0 causes it to run this portion of the test.)
	var modcacheEnv []string
	{
		out, err := testenv.Command(t, goBin, "env", "GOMODCACHE").Output()
		if err != nil {
			t.Fatalf("%s env GOMODCACHE: %v", goBin, err)
		}
		modcacheOk := false
		if gomodcache := string(bytes.TrimSpace(out)); gomodcache != "" {
			if _, err := os.Stat(gomodcache); err == nil {

[short] skip

# Install an echo command because Windows doesn't have it.
env GOBIN=$WORK/tmp/bin
go install echo.go
env PATH=$GOBIN${:}$PATH

# Test go generate for directory with no go files
! go generate ./nogo
! stdout 'Fail'
stderr 'no Go files'

# Test go  generate for module which doesn't exist should fail
! go generate foo.bar/nothing
stderr 'no required module provides package foo.bar/nothing'

	CGO_FFLAGS
	CGO_FFLAGS_ALLOW
	CGO_FFLAGS_DISALLOW
	CGO_LDFLAGS
	CGO_LDFLAGS_ALLOW
	CGO_LDFLAGS_DISALLOW
	CXX
	FC
	GCCGO
	GO111MODULE
	GO386
	GOAMD64
	GOARCH
	GOARM
	GOARM64
	GOBIN
	GOCACHE
	GOCACHEPROG
	GOENV
	GOEXE
	GOEXPERIMENT
	GOFLAGS
	GOGCCFLAGS
	GOHOSTARCH
	GOHOSTOS
	GOINSECURE
	GOMIPS
	GOMIPS64
	GOMODCACHE
	GONOPROXY
	GONOSUMDB
	GOOS
	GOPATH

cd "${KUBE_TEMP}"/tmp_test_licenses/kubernetes && rm -rf vendor

# Ensure that we find the binaries we build before anything else.
export GOBIN="${KUBE_OUTPUT_BIN}"
PATH="${GOBIN}:${PATH}"

function http_code() {
    curl -I -s -o /dev/null -w "%{http_code}" "$1"
}

packages_flagged=()
packages_url_missing=()
exit_code=0

# Install go-licenses