"fmt"
	"sync"
	"testing"
	"time"
)

func TestPriorityQueue(t *testing.T) {
	pq := &pq{}

	t0 := time.Now()
	t1 := &delayTask{runAt: t0.Add(0)}
	t2 := &delayTask{runAt: t0.Add(1 * time.Hour)}
	t3 := &delayTask{runAt: t0.Add(2 * time.Hour)}
	t4 := &delayTask{runAt: t0.Add(3 * time.Hour)}
	sorted := []*delayTask{t1, t2, t3, t4}
	// fill in an unsorted order
	unsorted := []*delayTask{t4, t2, t3, t1}

                @Override
                Void create() {
                    runPmd(ant, parameters)
                    return null
                }
            })
        } else {
            runPmd(ant, parameters)
        }
    }

    private static runPmd(AntBuilderDelegate ant, PmdActionParameters parameters) {

// much of this is taken from the example at https://golang.org/pkg/container/heap/
type pq []*delayTask

func (q pq) Len() int {
	return len(q)
}

func (q pq) Less(i, j int) bool {
	return q[i].runAt.Before(q[j].runAt)
}

func (q *pq) Swap(i, j int) {
	(*q)[i], (*q)[j] = (*q)[j], (*q)[i]
}

func (q *pq) Push(x any) {
	*q = append(*q, x.(*delayTask))
}

func (q *pq) Pop() any {
	old := *q

ant.importBuild(file('build.xml')) { antTaskName ->
    antTaskName == 'b' ? 'ant-b' : antTaskName
}

task runAnt(dependsOn: 'a')
"""
        inTestDirectory().withTasks('runAnt').run().assertTasksExecutedInOrder(':c', ':ant-b', ':a', ':runAnt')

    }

	for _, rt := range versionTest {
		t.Run(rt.name, func(t *testing.T) {
			args := []string{"version"}
			if len(rt.args) > 0 {
				args = append(args, rt.args)
			}
			stdout, _, _, actual := RunCmd(kubeadmPath, args...)
			if (actual == nil) != rt.expected {
				t.Errorf(
					"failed CmdVersion running 'kubeadm version %s' with an error: %v\n\texpected: %t\n\t  actual: %t",
					rt.args,
					actual,

		args     string
		expected bool
	}{
		{"shell not expected", "", false},
		{"unsupported shell type", "foo", false},
	}

	for _, rt := range tests {
		t.Run(rt.name, func(t *testing.T) {
			_, _, _, actual := RunCmd(kubeadmPath, "completion", rt.args)
			if (actual == nil) != rt.expected {
				t.Errorf(
					"failed CmdCompletion running 'kubeadm completion %s' with an error: %v\n\texpected: %t\n\t  actual: %t",
					rt.args,

			args:     "--kubernetes-version=stable-1",
			expected: false,
		},
	}

	kubeadmPath := getKubeadmPath()
	for _, rt := range tests {
		t.Run(rt.name, func(t *testing.T) {
			_, stderr, _, err := RunCmd(kubeadmPath, "config", "images", "list", "--v=1", rt.args)
			if err != nil {
				t.Fatalf("failed to run 'kubeadm config images list --v=1 %s', err: %v", rt.args, err)
			}

	kubeadmArgs := []string{"init", "--dry-run", "--ignore-preflight-errors=all"}
	kubeadmArgs = append(kubeadmArgs, args...)
	return RunCmd(kubeadmPath, kubeadmArgs...)
}

func getKubeadmVersion() *version.Version {
	kubeadmPath := getKubeadmPath()
	kubeadmArgs := []string{"version", "-o=short"}
	out, _, _, err := RunCmd(kubeadmPath, kubeadmArgs...)
	if err != nil {
		panic(fmt.Sprintf("could not run 'kubeadm version -o=short': %v", err))
	}

	defer func() {
		v := recover()
		if v == nil {
			bug()
			println(name, "did not panic")
			return
		}
		runt, ok := v.(runtime.Error)
		if !ok {
			bug()
			println(name, "panicked but not with runtime.Error")
			return
		}
		s := runt.Error()
		if strings.Index(s, err) < 0 {
			bug()
			println(name, "panicked with", s, "not", err)
			return
		}
	}()

	f()
}

    permissions: 0644
    owner: root
    # The GKE metadata server uses ports 987-989, so the sunrpc range should be restricted to be below.
    content: |
      options sunrpc max_resvport=986

runcmd:
 - systemctl daemon-reload
 - systemctl enable kube-node-installation.service
 - systemctl enable kube-node-configuration.service
 - systemctl enable kube-container-runtime-monitor.service