err := s.loadCACerts(caOpts, dir)
	g.Expect(err).Should(BeNil())

	_, err = os.Stat(path.Join(dir, "root-cert.pem"))
	g.Expect(os.IsNotExist(err)).Should(Equal(true))

	// Should load remote cacerts successfully.
	createCASecret(t, s.kubeClient)

	err = s.loadCACerts(caOpts, dir)
	g.Expect(err).Should(BeNil())

	expectedRoot, err := readSampleCertFromFile("root-cert.pem")
	g.Expect(err).Should(BeNil())

        ImmutableDomainObjectSet<String> set = new ImmutableDomainObjectSet<String>([])

        expect:
        set.size() == 0
        set.isEmpty()
    }

    def canQuerySize() {
        ImmutableDomainObjectSet<String> set = new ImmutableDomainObjectSet<String>(['a', 'b', 'c'])

        expect:
        set.size() == 3
        !set.isEmpty()
    }

    def canGetElementByIndex() {

		}
		if !reflect.DeepEqual(result.GV, c.expect) {
			t.Errorf("JSON codec failed to unmarshal input '%s': expected %+v, got %+v", c.input, c.expect, result.GV)
		}
		// test the utiljson codec
		if err := utiljson.Unmarshal(c.input, &result); err != nil {
			t.Errorf("util/json codec failed to unmarshal input '%v': %v", c.input, err)
		}
		if !reflect.DeepEqual(result.GV, c.expect) {

    }

    def "can query the project directory"() {
        expect:
        layout.projectDirectory.getAsFile() == projectDir
    }

    def "can resolve directory relative to project directory"() {
        def pathProvider = withValues("a", "b")

        expect:
        def dir = layout.projectDirectory.dir("sub-dir")
        dir.getAsFile() == projectDir.file("sub-dir")

package main

import "log"

func main() {
	defer func() {
		expect(5, recover())
	}()
	func() {
		expect(nil, recover())
		defer func() {
			defer func() {
				defer func() {
					defer func() {
						expect(3, recover())
					}()
					defer panic(3)
					panic(2)
				}()
				defer func() {
					expect(1, recover())
				}()
				panic(1)
			}()
		}()
	}()
	func() {
		for {

        expect:
        userInputHandler.choice('Select count', [1, 2, 3])
            .renderUsing { throw new RuntimeException() }
            .ask() == 1
    }

    def "always returns default for int question"() {
        expect:
        userInputHandler.askIntQuestion('Enter something', 1, 2) == 2
    }

    def "always returns default for text question"() {
        expect:

		d      kubeadm.JoinConfiguration
		expect bool
	}{
		{
			name:   "default Discovery",
			d:      kubeadm.JoinConfiguration{},
			expect: false,
		},
		{
			name: "file Discovery with a path",
			d: kubeadm.JoinConfiguration{
				Discovery: kubeadm.Discovery{
					File: &kubeadm.FileDiscovery{
						KubeConfigPath: "notnil",
					},
				},
			},
			expect: false,
		},
		{

        conversionFails("2.0");
        conversionFails("1_4");
    }

    def convertsVersionToVersion() {
        expect:
        TargetJdk.toVersion(TargetJdk.VERSION_1_4) == TargetJdk.VERSION_1_4
    }

    def convertsNumberToVersion() {
        expect:
        TargetJdk.toVersion(1.3) == TargetJdk.VERSION_1_3
        TargetJdk.toVersion(1.4) == TargetJdk.VERSION_1_4

				return
			}
			if !apiequality.Semantic.DeepEqual(c.expect, kc) {
				t.Fatalf("expect %#v but got %#v", *c.expect, *kc)
			}
		})
	}
}

func TestResolveRelativePaths(t *testing.T) {
	absolutePath := filepath.Join(configDir, "absolute")
	cases := []struct {
		desc          string
		path          string
		expect        string
		skipOnWindows bool
	}{
		{"empty path", "", "", false},

        given:
        server.expect(server.head("/$TEST_DISTRIBUTION_URL"))
        def baseUrl = getAuthenticatedBaseUrl()
        prepareWrapper(baseUrl)
        server.expect(server.get("/$TEST_DISTRIBUTION_URL")
            .sendFile(distribution.binDistribution))
        server.expect(server.get("/versions/current").send("""{ "version" : "7.6" }"""))
        server.expect(server.head("/distributions/gradle-7.6-bin.zip"))