ManagedFactory factory = managedFactoryRegistry.lookup(factoryId);
            Managed managed = Cast.uncheckedCast(factory.fromState(publicClass, readState(decoder)));
            assert managed != null;
            return new IsolatedImmutableManagedValue(managed, managedFactoryRegistry);
        }

        @Override
        public Class<IsolatedImmutableManagedValue> getIsolatableClass() {

		return true, ""
	}
	obj := store.Get(name, namespace)
	if obj == nil {
		// no object, we can manage it
		return true, ""
	}
	_, managed := obj.GetLabels()[constants.ManagedGatewayLabel]
	// If object already exists, we can only manage it if it has the label
	return managed, obj.GetResourceVersion()
}

// setGatewayNameLabel sets either the new or deprecated gateway name label

        snapshot == snapshotter.snapshot(value2)
        snapshot != snapshotter.snapshot(value3)
        snapshot != snapshotter.snapshot("123")
    }

    def "creates snapshot for named managed type"() {
        def instantiator = TestUtil.objectInstantiator()
        def value = instantiator.named(Thing, "value1")
        def value1 = instantiator.named(Thing, "value1")

import org.gradle.api.provider.Property
import org.gradle.api.provider.ValueSource
import org.gradle.api.provider.ValueSourceParameters
import org.gradle.api.reflect.ObjectInstantiationException
import org.gradle.internal.state.Managed
import org.gradle.process.ExecOperations
import org.gradle.process.ExecResult

import javax.inject.Inject

import static org.gradle.api.internal.provider.ValueSourceProviderFactory.ValueListener.ObtainedValue

}

// addUsersAndGroupsImpl adds the managed users and groups to the files specified
// by pathUsers and pathGroups. It uses the file specified with pathLoginDef to
// determine limits for UID and GID. If managed users and groups exist in these files
// validation is performed on them. The function returns a pointer to a Users object
// that can be used to return UID and GID of managed users.

@UnsupportedWithConfigurationCache(because = "software model")
class CustomBinaryIntegrationTest extends AbstractIntegrationSpec {
    def "setup"() {
        buildFile << """
@Managed interface SampleBinary extends BinarySpec {
    String getVersion()
    void setVersion(String version)
}
"""
    }

    def "custom binary type can be registered and created"() {
        when:

    inputs:
      - foo.bar.baz MyPlugin.MyThing2 (parameter 1) [*]
'''
    }

    def "unbound dsl rule by-path subject and inputs are reported"() {
        given:
        buildScript '''
            @Managed interface Thing { }

            model {
                foo.bar {
                    // Subject only
                }
                foo.bla {
                    println $.unknown.thing

		SkipCRIDetect: true,
	})
}

// fetchCertificateExpirationInfo returns the certificate expiration info for the given renewal manager
func fetchCertificateExpirationInfo(rm *renewal.Manager) (*outputapiv1alpha3.CertificateExpirationInfo, error) {
	info := &outputapiv1alpha3.CertificateExpirationInfo{}

	for _, handler := range rm.Certificates() {

import org.gradle.model.*
import org.gradle.model.internal.core.*
import org.gradle.model.internal.fixture.ProjectRegistrySpec
import org.gradle.model.internal.manage.schema.extract.InvalidManagedModelElementTypeException
import org.gradle.model.internal.manage.schema.extract.ModelStoreTestUtils
import org.gradle.model.internal.registry.DefaultModelRegistry
import org.gradle.model.internal.registry.ModelRegistry

  labels:
    {{- toJsonMap
      .InfrastructureLabels
      (strdict
        "gateway.networking.k8s.io/gateway-name" .Name
        "istio.io/gateway-name" .Name
        "gateway.istio.io/managed" "istio.io-mesh-controller"
      ) | nindent 4 }}
  ownerReferences:
  - apiVersion: gateway.networking.k8s.io/v1beta1
    kind: Gateway
    name: "{{.Name}}"
    uid: "{{.UID}}"
spec:
  selector: