addClassLoader(knownClassLoaders, registry.getRuntimeClassLoader(), "runtime:" + gradleVersion);
        addClassLoader(knownClassLoaders, registry.getGradleApiClassLoader(), "gradle-api:" + gradleVersion);
        addClassLoader(knownClassLoaders, registry.getGradleCoreApiClassLoader(), "gradle-core-api:" + gradleVersion);
        addClassLoader(knownClassLoaders, registry.getPluginsClassLoader(), "plugins:" + gradleVersion);

    DaemonRegistry registry

    def setup() {
        // Start with a new registry on each test.
        registry = new EmbeddedDaemonRegistry()
    }

    DaemonInfo registerDaemon(DaemonStateControl.State state, long lastIdle = -1) {
        final String uid = UUID.randomUUID().toString()
        final int id = registry.getAll().size() + 1

        def propertyMetadata = Mock(PropertyMetadata)
        def softwareType = Mock(SoftwareType)

        when:
        registry.register(SoftwareTypeImpl, RegisteringPlugin)
        registry.register(SoftwareTypeImpl, RegisteringPlugin)
        def implementations = registry.softwareTypeImplementations

        then:
        1 * inspectionScheme.getMetadataStore() >> metadataStore

    def setup() {
        registry.register(
            ModelRegistrations.of(collectionPath, nodeInitializerRegistry.getNodeInitializer(forType(collectionType)))
                .descriptor("define collection")
                .build()
        )
    }

    void mutate(@DelegatesTo(ModelSet) Closure<?> action) {
        registry.mutate(reference, new ClosureBackedAction<>(action))

    public static final String REGISTRY_BECAME_UNREADABLE = "after the daemon registry became unreadable";
    public static final String REGISTRY_ENTRY_UNEXPECTEDLY_LOST = "after the daemon was no longer found in the daemon registry";
    public static final String REGISTRY_BECAME_INACCESSIBLE = "after the daemon registry became inaccessible";

    private final Daemon daemon;

		}
	}
	return 1
}

// Helper function to create a registry.
func runAddRegistry(f *fuzz.ConsumeFuzzer, c *aggregate.Controller) error {
	registry := serviceregistry.Simple{}
	err := f.GenerateStruct(&registry)
	if err != nil {
		return err
	}
	if registry.DiscoveryController == nil {
		return fmt.Errorf("registry required")
	}
	c.AddRegistry(registry)
	return nil
}

// Helper function to delete a registry.

	if err != nil {
		return append(errors, err)
	}

	for _, registry := range registries {
		// filter out known groups
		groups = unknownGroups(groups, registry)
	}
	if len(groups) != 0 {
		errors = append(errors, fmt.Errorf("unknown api groups %s", strings.Join(groups, ",")))
	}

	return errors
}

// ApplyTo override MergedResourceConfig with defaults and registry

import org.gradle.internal.service.scopes.BasicGlobalScopeServices
import org.gradle.launcher.daemon.client.DaemonClientGlobalServices
import org.gradle.launcher.daemon.registry.DaemonRegistry
import org.gradle.launcher.daemon.registry.DaemonRegistryServices
import org.gradle.testfixtures.internal.NativeServicesTestFixture
import org.gradle.util.GradleVersion

        registry.register(fooRegistration)

        def barList = []
        def factory = Mock(org.gradle.internal.Factory) {
            create() >> barList
        }
        def barRegistration = ModelRegistrations.unmanagedInstance(barReference, factory).descriptor(descriptor).build()
        registry.register(barRegistration)

	var err error
	scopes.Framework.Info("=== BEGIN: Deploy registry redirector server ===")
	defer func() {
		if err != nil {
			err = fmt.Errorf("container registry deployment failed: %v", err)
			scopes.Framework.Infof("=== FAILED: Deploy registry redirector server ===")
			_ = c.Close()
		} else {
			scopes.Framework.Info("=== SUCCEEDED: Deploy registry redirector server ===")
		}
	}()