}

    @Override
    public void convert(DependencyFactoryInternal.ClassPathNotation notation, NotationConvertResult<? super FileCollectionDependency> result) throws TypeConversionException {
        FileCollectionDependency dependency = internCache.get(notation);
        if (dependency == null) {
            dependency = create(notation);
        }
        result.converted(dependency);

                return (T) methodHandle.bindTo(classLoader).invokeWithArguments(arguments);
            } catch (Throwable e) {
                throw new RuntimeException(e);
            }
        }

        private MethodHandles.Lookup getLookupForClassLoader(ClassLoader classLoader) throws IllegalAccessException {
            try {
                return MethodHandles.privateLookupIn(classLoader.getClass(), baseLookup);

/**
 * A ModuleComponentRepository that catches any exception and applies it to the result object.
 * This allows other repository implementations to throw exceptions on failure.
 *
 * This implementation will also disable any repository that throws a critical failure, failing-fast with that
 * repository for any subsequent requests.
 */

        }
        return loader
    }

    private static class GroovyInvocationHandler implements InvocationHandler, Serializable {
        Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            return "result!"
        }
    }

     * This method throws {@code IllegalArgumentException} if any of {@code cmd} elements contain spaces.
     *
     * @param cmd the command line elements to be converted
     * @return a comma-separated list of string literals
     */
    static String cmdToStringLiteral(List<String> cmd) {
        if (cmd.any { it.contains(" ") }) {

        waitFor.eventually {
            assert toolingApi.daemons.daemons.size() == number
            toolingApi.daemons.daemons*.assertBusy()
        }
        // `eventually` throws a runtime exception when the condition is never met
    }

        private void remapClass(Class<?> classToMap, ZipOutputStream jar) throws IOException {
            String internalName = Type.getInternalName(classToMap);
            String resourceName = internalName.concat(".class");
            URL resource = WorkerProcessClassPathProvider.class.getClassLoader().getResource(resourceName);
            if (resource == null) {

        super(distribution, testDirectoryProvider, gradleVersion, buildContext);
    }

    @Override
    public void assertCanExecute() throws AssertionError {
        if (!getDistribution().isSupportsSpacesInGradleAndJavaOpts()) {
            Map<String, String> environmentVars = buildInvocation().environmentVars;

        return new DeserializeMap() {
            @Override
            public Class<?> resolveClass(ClassLoaderDetails classLoaderDetails, String className) throws ClassNotFoundException {
                Set<ClassLoader> candidates = getClassLoaders(classLoaderDetails);
                if (candidates != null) {
                    // TODO:ADAM - This isn't quite right

            DefaultResolverResults.DefaultLegacyResolverResults.buildDependenciesResolved(EmptyResults.INSTANCE)
        );
    }

    @Override
    public ResolverResults resolveGraph(ResolveContext resolveContext) throws ResolveException {
        if (resolveContext.hasDependencies()) {
            return delegate.resolveGraph(resolveContext);
        }

        if (resolveContext.getResolutionStrategy().isDependencyLockingEnabled()) {