t.Fatalf("expected %#v, Got %#v", expected, update)
		}

	case <-time.After(wait.ForeverTestTimeout):
		t.Fatalf("expected update, timeout instead")
	}
}

func TestReadPodsFromFileExistAlready(t *testing.T) {
	hostname := types.NodeName("random-test-hostname")
	var testCases = getTestCases(hostname)

	for _, testCase := range testCases {
		func() {
			dirName, err := mkTempDir("file-test")
			if err != nil {

import spock.lang.Specification

class MaximumHeapHelperTest extends Specification {

    def "default max heap on IBM #testCase is #expected"() {
        expect:
        maximumHeapHelper.getDefaultMaximumHeapSize(osTotalMemory.bytes) == expected.bytes

        where:
        osTotalMemory            | expected
        MemoryAmount.of('2g')    | MemoryAmount.of('512m')
        MemoryAmount.of('1g')    | MemoryAmount.of('512m')

        expect:
        event.prompt == "question? (default: yes) [yes, no] " // trailing space
    }

    def "accepts valid input"() {
        def event = new BooleanQuestionPromptEvent(123, "question?", true)

        expect:
        def result = event.convert(input)
        result.response == expected
        result.newPrompt == null

        where:

		fn             func() error
		filter, expect string
	}{
		{call: "Setegid(1)", fn: func() error { return syscall.Setegid(1) }, filter: "Gid:", expect: "\t0\t1\t0\t1"},
		{call: "Setegid(0)", fn: func() error { return syscall.Setegid(0) }, filter: "Gid:", expect: "\t0\t0\t0\t0"},

		{call: "Seteuid(1)", fn: func() error { return syscall.Seteuid(1) }, filter: "Uid:", expect: "\t0\t1\t0\t1"},

	signedHeaders := []string{"host", "x-amz-content-sha256", "x-amz-date", "transfer-encoding"}

	// If the `expect` key exists in the signed headers then golang server would have stripped out the value, expecting the `expect` header set to `100-continue` in the result.
	signedHeaders = append(signedHeaders, "expect")
	// expected header values.
	expectedHost := "play.min.io:9000"
	expectedContentSha256 := "1234abcd"

        executer.requireDaemon()
    }

    def "Given daemon toolchain version When executing any task Then daemon jvm was set up with expected configuration"() {
        given:
        writeJvmCriteria(Jvm.current())
        captureJavaHome()

        expect:
        succeeds("help")
        assertDaemonUsedJvm(Jvm.current())
        outputContains("Daemon JVM discovery is an incubating feature.")
    }

    }

    def "#a <=> #b: #expected"() {
        def hashA = HashCode.fromString(a)
        def hashB = HashCode.fromString(b)
        def compareAB = hashA <=> hashB
        def compareBA = hashB <=> hashA

        expect:
        Math.signum(compareAB) == expected
        Math.signum(compareBA) == -expected

        where:

			}
			lister := informerFactory.Storage().V1().StorageClasses().Lister()
			actual, err := GetDefaultClass(lister)
			if err != nil {
				t.Errorf("Expected no error, got %v", err)
				return
			}
			if tc.expect != actual {
				t.Errorf("Expected %v, got %v", tc.expect, actual)
			}
		})
	}

        // Captures current, but maybe not desired behavior
        expect:
        succeeds( "updateDaemonJvm", "--jvm-version=10000")
    }

    @NotYetImplemented
    def "When execute updateDaemonJvm for valid vendor option Then build properties are populated with expected values"() {
        when:
        run "updateDaemonJvm", "--toolchain-vendor=$vendor"

        then:

		k := instanceKey(i)
		if _, ok := expected[k]; !ok {
			unexpected[k] = struct{}{}
		}
	}
	for _, i := range got {
		k := instanceKey(i)
		// just remove the items rather than looping over expected, if anythings left we missed it
		delete(expected, k)
		if _, ok := unexpected[k]; ok {
			t.Errorf("expected %s to be filtered out", k)
		}
	}
	if len(expected) > 0 {
		t.Errorf("did not include %v", expected)