public void visit(ArtifactVisitor visitor) {
            if (visitor.requireArtifactFiles() && !artifact.getFileSource().getValue().isSuccessful()) {
                visitor.visitFailure(artifact.getFileSource().getValue().getFailure().get());
            } else {
                visitor.visitArtifact(variantName, variantAttributes, capabilities, artifact);
                visitor.endVisitCollection(FileCollectionInternal.OTHER);
            }

    }

    private TaskRequiredServices emptyTaskRequiredServices() {
        Stub(TaskRequiredServices)
    }

    void failure(TaskInternal task, final RuntimeException failure) {
        task.state.getFailure() >> failure
        task.state.rethrowFailure() >> { throw failure }
    }

    private static class MockLock implements ResourceLock {
        final Thread owner = Thread.currentThread()

        resolver.resolve(identifier, componentOverrideMetadata, result);

        if (result.getFailure() != null) {
            return;
        }
        org.gradle.api.artifacts.ClientModule clientModule = componentOverrideMetadata.getClientModule();
        if (clientModule != null) {

        } else {
            List<String> executionReasons = result != null ? result.getUpToDateMessages() : null;
            Throwable failure = finishEvent.getFailure();
            if (failure == null) {
                return new DefaultTaskSuccessResult(startTime, endTime, false, state.isFromCache(), "SUCCESS", incremental, executionReasons);
            } else {

            getRequested() >> selector
            getFromVariant() >> id(from)
            getSelected() >> id(selected)
            getSelectedVariant() >> id(selected)
            getFailure() >> failure
        }
    }

    private Long id(String module) {
        return module.hashCode()
    }

    class DummyModuleVersionSelection implements ResolvedGraphComponent {

        }
        finishFailures.addAll(finishResult.getFailures());
        boolean failed = reportableFailure != null;

        // These should run concurrently
        buildStateRegistry.visitBuilds(buildState -> {
            ExecutionResult<Void> result = buildState.beforeModelDiscarded(failed);
            finishFailures.addAll(result.getFailures());
        });

        visitedArtifacts.select(configuration.getImplicitSelectionSpec()).visitArtifacts(visitor, false);
        resolutionHost.rethrowFailure("files", visitor.getFailures());
        return visitor.getFiles();
    }

    @Override
    @Deprecated
    public Set<File> getFiles(final Spec<? super Dependency> dependencySpec) throws ResolveException {

	ttl := uint32(0) // second

	gwHost := "test.gw.istio.io"
	workingDNSServer := newFakeDNSServer(ttl, sets.New(gwHost))
	failingDNSServer := newFakeDNSServer(ttl, sets.NewWithLength[string](0))
	failingDNSServer.setFailure(true)
	model.NetworkGatewayTestDNSServers = []string{
		// try resolving with the failing server first to make sure the next upstream is retried
		failingDNSServer.Server.PacketConn.LocalAddr().String(),

        selected.visitDependencies(collectingContext);
        if (!lenient) {
            resolutionHost.mapFailure("dependencies", collectingContext.getFailures()).ifPresent(context::visitFailure);
        }
    }

    @Override
    public String getDisplayName() {
        return resolutionHost.displayName("files").getDisplayName();
    }

    @Override

            fileCollection.getSelectedArtifacts().visitArtifacts(visitor, lenient);

            Set<ResolvedArtifactResult> artifactResults = visitor.getArtifacts();
            Set<Throwable> failures = visitor.getFailures();

            if (!lenient) {
                resolutionHost.rethrowFailure("artifacts", failures);
            }
            return new ArtifactSetResult(artifactResults, failures);
        });
    }