try {
            resolver.resolveArtifactsWithType(component, artifactType, result);
        } catch (Exception t) {
            result.failed(new ArtifactResolveException(component.getId(), t));
        }
    }

    @Override
    public void resolveArtifact(ComponentArtifactResolveMetadata component, ComponentArtifactMetadata artifact, BuildableArtifactResolveResult result) {
        try {

    def "maps class id to original id when fetching test output"() {
        def writer = Stub(Writer)
        def class1 = Stub(TestClassResult) {
            getId() >> 12
            getClassName() >> 'class-1'
        }
        def class2 = Stub(TestClassResult) {
            getId() >> 12
            getClassName() >> 'class-2'
        }

        when:
        provider.visitClasses(Stub(Action))

        then:

            final String item1Id = item1.getId();
            if (mergedIdSet.contains(item1Id)) {
                continue;
            }

            SuggestItem mergedItem = item1;
            for (final SuggestItem item2 : items) {
                if (item1.equals(item2)) {
                    continue;
                }

                final String item2Id = item2.getId();
                if (item1Id.equals(item2Id)) {

    }

    void started(InternalOperationStartedProgressEvent event) {
        delegate.dispatch(event);
        startedIds.add(event.getDescriptor().getId());
    }

    void finished(InternalOperationFinishedProgressEvent event) {
        startedIds.remove(event.getDescriptor().getId());
        delegate.dispatch(event);
    }

    void progress(InternalProgressEvent event) {
        delegate.dispatch(event);
    }

                        aggregatedTestResults.put(classResult.getClassName(), newTestResult);
                    }
                    classOutputProviders.put(newTestResult.getId(), new DelegateProvider(classResult.getId(), provider));
                }
            });
        }
        for (OverlaidIdProxyingTestClassResult classResult : aggregatedTestResults.values()) {
            visitor.execute(classResult);

        public SimpleResolvedModuleVersion(ComponentMetadata result) {
            this.result = result;
        }

        @Override
        public ModuleVersionIdentifier getId() {
            return result.getId();
        }
    }

@Singleton
@Deprecated
public class FlatRepositoryLayout implements ArtifactRepositoryLayout {

    private static final char ARTIFACT_SEPARATOR = '-';

    private static final char GROUP_SEPARATOR = '.';

    public String getId() {
        return "flat";
    }

    public String pathOf(Artifact artifact) {
        ArtifactHandler artifactHandler = artifact.getArtifactHandler();

        StringBuilder path = new StringBuilder(128);

        SubsetScriptTransformer initialTransformer = new SubsetScriptTransformer(initialPassStatementTransformer);
        String id = INTERNER.intern("cp_" + initialPassScriptTarget.getId());
        return new NoDataCompileOperation(id, CLASSPATH_COMPILE_STAGE, initialTransformer);
    }

    @Override

                switch (execution.getResultType()) {
                    case SUCCESS:
                        return Collections.singleton(success(classId, execution.getId()));
                    case SKIPPED:
                        return Collections.singleton(skipped(classId, execution.getId()));
                    case FAILURE:
                        return failures(classId, execution, allFailed

            resultProcessor.started(testInternal, startEvent());
        }

        Throwable exception = failure.getException();
        reportFailure(testInternal.getId(), exception);
        if (needEndEvent) {
            resultProcessor.completed(testInternal.getId(), new TestCompleteEvent(clock.getCurrentTime()));
        }
    }

    private void reportFailure(Object descriptorId, Throwable throwable) {