// matching selected configuration. For the select configuration, this mean traversing its dependencies.
            resolveState.getModule(moduleIdentifier).replaceWith(result.getSelected());
        });
    }

        for (ModuleIdentifier module : participatingModules) {
            action.execute(module);
        }
    }

    @Override
    public ComponentState getSelected() {
        return selected;
    }

    @Nullable
    ModuleVersionResolveException getFailure();

    /**
     * Returns the simple id of the selected component, as per {@link ResolvedGraphComponent#getResultId()}.
     */
    @Nullable
    Long getSelected();

    /**
     * Not null only when failure is not null.
     */
    @Nullable
    ComponentSelectionReason getReason();

    boolean isConstraint();

    /**

    public void select(T candidate) {
        selected = candidate;
    }

    @Override
    public void fail(Throwable error) {
        failure = error;
    }

    @Override
    public T getSelected() {
        return selected;
    }

    @Nullable
    @Override
    public Throwable getFailure() {
        return failure;
    }

    @Override
    public boolean hasFailure() {

     */
    void withParticipatingModules(Action<? super ModuleIdentifier> action);

    /**
     * The actual selected component.
     */
    ComponentState getSelected();

        });
    }

    @Inject
    public BuildOperationLoggerFactory getOperationLoggerFactory() {
        throw new UnsupportedOperationException();
    }

    @Inject
    protected Deleter getDeleter() {
        throw new UnsupportedOperationException("Decorator takes care of injection");
    }

    @TaskAction
    public void assemble() {

        );
    }

    private JavaRecompilationSpecProvider createRecompilationSpec(InputChanges inputs, FileTree sources) {
        return new JavaRecompilationSpecProvider(
            getDeleter(),
            getServices().get(FileOperations.class),
            sources,
            inputs.isIncremental(),
            () -> inputs.getFileChanges(getStableSources()).iterator()
        );
    }

                    }
                    grammarFiles.add(fileChange.getFile());
                }
            }
            if (rebuildRequired) {
                try {
                    getDeleter().ensureEmptyDirectory(outputDirectory);
                } catch (IOException ex) {
                    throw new UncheckedIOException(ex);
                }
                grammarFiles.addAll(stableSources.getFiles());

                if (dependency instanceof ResolvedDependencyResult) {
                    ResolvedDependencyResult resolvedDependency = (ResolvedDependencyResult) dependency;
                    reportComponent(resolvedDependency.getSelected(), writer, seen, newIndent);
                } else {
                    writer.println(" -> not found");
                }
            }
        } else {
            writer.println(" (already seen)");
        }

                getResultId() >> 4L
                getRequested() >> requested
            }
            getFromVariant() >> 55L
            getFailure() >> null
            getSelected() >> 12L
            getSelectedVariant() >> 123L
            getReason() >> ComponentSelectionReasons.requested()
        }

        when:
        def bytes = new ByteArrayOutputStream()