when:
        buildLogicInput.text = 'bar!'

        and:
        configurationCacheRun 'tasks', '-I', initScript.absolutePath

        then:
        outputContains 'bar!'
        configurationCache.assertStateStored()

        when:
        configurationCacheRun 'tasks', '-I', initScript.absolutePath

        then:
        outputDoesNotContain 'bar!'
        configurationCache.assertStateLoaded()
    }

                id = "test"

                foo {
                    bar = "baz"
                }
            }
        """
    }

    static String getDeclarativeScriptThatConfiguresOnlyTestSoftwareTypeFoo() {
        return """
            testSoftwareType {
                foo {
                    bar = "baz"
                }
            }
        """
    }

-t table -N chain
-t table -I chain 1 -f foo -b bar
-t table -I chain 2 -f foo -b baaz

* table
-N chain
-I chain 1 -f foo -b bar
-I chain 2 -f foo -b baaz
-I chain 3 -f foo -b baz

        when:
        configurationCacheRun 'ok', '-Dfoo=foo'

        then:
        outputContains "*(foo | bar = foo)*"
        configurationCache.assertStateStored()

        when:
        configurationCacheRun 'ok', '-Dbar=bar'

        then:
        outputContains "*(foo | bar = bar)*"
        configurationCache.assertStateLoaded()

        when:
        configurationCacheRun 'ok', '-Dbaz=baz'

	// Setup storage with the following structure:
	//  /
	//   - first/
	//  |         - bar
	//  |
	//   - second/
	//  |         - bar
	//  |         - foo
	barFirst := &example.Pod{ObjectMeta: metav1.ObjectMeta{Namespace: "first", Name: "bar"}}
	barSecond := &example.Pod{ObjectMeta: metav1.ObjectMeta{Namespace: "second", Name: "bar"}}
	fooSecond := &example.Pod{ObjectMeta: metav1.ObjectMeta{Namespace: "second", Name: "foo"}}

			},
		},
		{
			"with keys",
			`{"level":"info","time":"2020-01-01T00:00:00.356374Z","msg":"my message","key":"string value","bar":2}`,
			cniLog{
				Level: "info",
				Time:  *wantT,
				Msg:   "my message",
				Arbitrary: map[string]any{
					"key": "string value",
					"bar": float64(2),
				},
			},
		},
	}
	for _, tt := range cases {
		t.Run(tt.name, func(t *testing.T) {

            listOf(1, 2, 3)
        )
    }

    @Test
    fun `can serialize Java lambda with MapProperty`() {
        assertProviderRoundtrip(
            mapPropertyOf("foo" to 1, "bar" to 2),
            mapOf("foo" to 1, "bar" to 2)
        )
    }

    @Test
    fun `can serialize Java lambda with SetProperty`() {
        assertProviderRoundtrip(
            setPropertyOf(1, 2, 3),
            setOf(1, 2, 3)

architecture pair has its own subdirectory of pkg
(pkg/GOOS_GOARCH).

If DIR is a directory listed in the GOPATH, a package with
source in DIR/src/foo/bar can be imported as "foo/bar" and
has its compiled form installed to "DIR/pkg/GOOS_GOARCH/foo/bar.a".

The bin directory holds compiled commands.
Each command is named for its source directory, but only
the final element, not the entire path. That is, the

	c.FuzzNoCustom(obj)

	// Pinning values for fields that get defaults if fuzz value is empty string or nil (thus making the round trip test fail)
	obj.CertificatesDir = "foo"
	obj.ClusterName = "bar"
	obj.ImageRepository = "baz"
	obj.CIImageRepository = "" // This fields doesn't exists in public API >> using default to get the roundtrip test pass
	obj.KubernetesVersion = "qux"