}

		// How handlers set Trailers: declare it ahead of time
		// with the Trailer header, and then mutate the
		// Header() of those values later, after the response
		// has been written (we wrote to w above).
		w.Header().Set("Server-Trailer-A", "valuea")
		w.Header().Set("Server-Trailer-C", "valuec") // skipping B
		w.Header().Set("Server-Trailer-NotDeclared", "should be omitted")
	}))

	res, err := cst.c.Get(cst.ts.URL)

					Value: `{"/app-health/foo/livez":{"httpGet":{"path":"/","port":8000,"scheme":"HTTP"}}}`,
				},
				{
					Name:  "TEST_ENV_VAR2",
					Value: "value2",
				},
			},
			probers: `{"/app-health/bar/livez":{"httpGet":{"path":"/","port":9000,"scheme":"HTTP"}}}`,
			want: []corev1.EnvVar{
				{
					Name:  "TEST_ENV_VAR1",
					Value: "value1",
				},
				{

		// Change annotation keys for Validating's fail open to Mutating's fail open.
		failOpenAnnotations := map[string]string{}
		for key, value := range t.ExpectAnnotations {
			if strings.HasPrefix(key, "failed-open.validating.webhook.admission.k8s.io/") {
				failOpenAnnotations[key] = value
			}
		}
		for key, value := range failOpenAnnotations {

        producer.delegate = configurationContainer
        def value = producer()

        assert value.name == name

        def value2 = configurationContainer.getByName(name)

        assert value2.name == name

        action(value)
        action(value2)

        true
    }

custom.prop = providers.provider { "\${'some value 2'.substring(5)}" }
assert custom.prop.get() == "value 2"

custom.prop = null
custom.prop.convention("\${'some value 3'.substring(5)}")
assert custom.prop.get() == "value 3"

custom.prop.convention(providers.provider { "\${'some value 4'.substring(5)}" })
assert custom.prop.get() == "value 4"
"""

        expect:
        succeeds()
    }

    @Requires(

												Operator: v1.NodeSelectorOpIn,
												Values:   []string{"bar", "value2"},
											},
										},
									},
									{
										MatchExpressions: []v1.NodeSelectorRequirement{
											{
												Key:      "diffkey",
												Operator: v1.NodeSelectorOpIn,
												Values:   []string{"wrong", "value2"},
											},
										},
									},
								},

            to.attribute(artifactType, 'final')

            if (hasExtraAttribute) {
                from.attribute(extraAttribute, 'whatever')
                to.attribute(extraAttribute, 'value1')
            }
        }
        registerTransform(TestTransform) { // B
            from.attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, Usage.JAVA_API))

`(read-only) File libsDir`::
The directory to generate libraries into. Default value: `layout.buildDirectory.dir(__libsDirName__)`

`String distsDirName`::
The name of the directory to generate distributions into, relative to the build directory. Default value: `distributions`

`(read-only) File distsDir`::

		})
	}
}

func TestK8sObject_Equal(t *testing.T) {
	obj1 := K8sObject{
		object: &unstructured.Unstructured{Object: map[string]any{
			"key": "value1",
		}},
	}
	obj2 := K8sObject{
		object: &unstructured.Unstructured{Object: map[string]any{
			"key": "value2",
		}},
	}
	cases := []struct {
		desc string
		o1   *K8sObject
		o2   *K8sObject
		want bool
	}{
		{
			desc: "Equals",

        def value = instantiator.named(Thing, "value1")

        expect:
        def isolated = isolatableFactory.isolate(value)
        isolated instanceof IsolatedImmutableManagedValue
        isolated.isolate().is(value)
    }

    def "can coerce named managed type"() {
        def instantiator = TestUtil.objectInstantiator()
        def value = instantiator.named(Thing, "value1")