given:
        fileResolver.resolveUri('https://host') >> new URI('https://host')
        fileResolver.resolveUri('https://other/') >> new URI('https://other/')

        when:
        def resolver = repository.createResolver()

        then:
        resolver.artifactPatterns == ['https://host/[layoutPattern]', 'https://other/[additionalPattern]']
        resolver.ivyPatterns == resolver.artifactPatterns
    }

        expect:
        action.execute()
    }

    void appliesScriptsToDefaultTargetObject() {
        given:
        1 * resolver.resolveUri('script') >> file
        1 * parentCompileScope.createChild("script-$file", null) >> scriptCompileScope
        1 * scriptHandlerFactory.create(_, scriptCompileScope) >> scriptHandler

name := """fess-suggest-test"""

version := "1.0-SNAPSHOT"

lazy val root = (project in file(".")).enablePlugins(PlayJava)

resolvers += Resolver.url("codelibs", url("http://maven.codelibs.org/"))(Resolver.ivyStylePatterns)

resolvers += (
  "Local Maven Repository" at "file://"+Path.userHome.absolutePath+"/.m2/repository"
  )

scalaVersion := "2.11.1"

libraryDependencies ++= Seq(
  javaJdbc,
  javaEbean,
  cache,
  javaWs

        def repositories = IntStream.range(0, resolvers.length)
            .mapToObj { i -> mockRepository("resolver" + i, resolvers[i]) }
            .collect(Collectors.toList())

        registry.requestedRepositories() >> repositories
    }

    private RealizedJavaToolchainRepository mockRepository(String repositoryName, JavaToolchainResolver resolver) {

    private final CompositeBuildPluginResolver resolver;

    public CompositeBuildPluginResolverContributor(BuildIncluder buildIncluder) {
        this.resolver = new CompositeBuildPluginResolver(buildIncluder);
    }

    @Override
    public void discardAll() {
        resolver.discardAll();
    }

    @Override
    public void collectResolversInto(Collection<PluginResolver> resolvers) {
        resolvers.add(resolver);
    }

    private final List<Resolver> resolvers;
    private final Map<String, Set<NodeState>> capabilityWithoutVersionToNodes = new HashMap<>();
    private final Deque<CapabilityConflict> conflicts = new ArrayDeque<>();

    public DefaultCapabilitiesConflictHandler(List<Resolver> resolvers) {
        this.resolvers = resolvers;
    }

    @Override

    private final RelativeFilePathResolver resolver;

    public CachingTextUriResourceLoader(ExternalResourceAccessor externalResourceAccessor, Set<String> cachedSchemes, RelativeFilePathResolver resolver) {
        this.externalResourceAccessor = externalResourceAccessor;
        this.cachedSchemes = cachedSchemes;
        this.resolver = resolver;
    }

    @Override

    // methods ----------------------------------------------------------------

    /**
     * Gets a conflict resolver of the specified type.
     *
     * @param type the type of conflict resolver to obtain
     * @return the conflict resolver
     * @throws ConflictResolverNotFoundException
     *          if the specified type was not found
     */

import org.gradle.vcs.internal.resolver.DefaultVcsVersionWorkingDirResolver;
import org.gradle.vcs.internal.resolver.OfflineVcsVersionWorkingDirResolver;
import org.gradle.vcs.internal.resolver.OncePerBuildInvocationVcsVersionWorkingDirResolver;
import org.gradle.vcs.internal.resolver.PersistentVcsMetadataCache;
import org.gradle.vcs.internal.resolver.VcsDependencyResolver;

	defer dnsWaitGroup.Wait()

	resolvers := make([]*lookupCustomResolver, 2)
	for i := range resolvers {
		cs := lookupCustomResolver{Resolver: &Resolver{PreferGo: true}}
		cs.Dial = cs.dial()
		resolvers[i] = &cs
	}

	var wg sync.WaitGroup
	wg.Add(len(resolvers))
	for i, resolver := range resolvers {
		go func(r *Resolver, index int) {
			defer wg.Done()