import javax.annotation.Nullable;
import java.util.Collections;
import java.util.List;

/**
 * Maps build operations of a particular type into progress events to forward to the tooling API client.
 */
public interface BuildOperationMapper<DETAILS, TO extends InternalOperationDescriptor> {
    boolean isEnabled(BuildEventSubscriptions subscriptions);

    Class<DETAILS> getDetailsType();

    /**

        this.fallback = fallback;
        List<Mapper> mapperBuilder = new ArrayList<>(mappers.size());
        Set<BuildOperationTracker> trackers = new LinkedHashSet<>();
        for (BuildOperationMapper<?, ?> mapper : mappers) {
            if (mapper.isEnabled(subscriptions)) {

    def clientFinishEvent = Stub(InternalOperationFinishedProgressEvent)

    def "passes events when enabled mapper available for details type"() {
        def mapper1 = Mock(BuildOperationMapper)
        def mapper2 = Mock(BuildOperationMapper)
        def mappedProgressEvent = Mock(InternalProgressEvent)

        given:
        mapper1.isEnabled(subscriptions) >> true
        mapper1.trackers >> []

/**
 * Work item listener that forwards all receiving events to the client via the provided {@code ProgressEventConsumer} instance.
 *
 * @since 5.1
 */
class WorkItemOperationMapper implements BuildOperationMapper<ExecuteWorkItemBuildOperationType.Details, DefaultWorkItemDescriptor> {
    @Override
    public boolean isEnabled(BuildEventSubscriptions subscriptions) {

import javax.annotation.Nullable;
import java.util.List;

import static java.util.Collections.singletonList;

class ProjectConfigurationOperationMapper implements BuildOperationMapper<ConfigureProjectBuildOperationType.Details, DefaultProjectConfigurationDescriptor> {
    private final ProjectConfigurationTracker projectConfigurationTracker;

/**
 * Transform listener that forwards all receiving events to the client via the provided {@code ProgressEventConsumer} instance.
 *
 * @since 5.1
 */
class TransformOperationMapper implements BuildOperationMapper<ExecutePlannedTransformStepBuildOperationDetails, DefaultTransformDescriptor>, OperationDependencyLookup {
    private final Map<TransformStepNode, DefaultTransformDescriptor> descriptors = new ConcurrentHashMap<>();

import javax.annotation.Nullable;
import java.net.URI;
import java.net.URISyntaxException;

import static java.util.Collections.singletonList;

public class FileDownloadOperationMapper implements BuildOperationMapper<ExternalResourceReadBuildOperationType.Details, DefaultFileDownloadDescriptor> {
    @Override
    public boolean isEnabled(BuildEventSubscriptions subscriptions) {

        TaskOperationMapper taskOperationMapper = new TaskOperationMapper(postProcessors, taskOriginTracker, operationDependenciesResolver);
        operationDependenciesResolver.addLookup(taskOperationMapper);

        List<BuildOperationMapper<?, ?>> mappers = ImmutableList.of(
            new FileDownloadOperationMapper(),
            new TestOperationMapper(testTaskTracker),
            new ProjectConfigurationOperationMapper(projectConfigurationTracker),

import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import static java.util.Collections.emptySet;
import static java.util.Collections.singletonList;

class TaskOperationMapper implements BuildOperationMapper<ExecuteTaskBuildOperationDetails, DefaultTaskDescriptor>, OperationDependencyLookup {
    private final Map<TaskIdentity<?>, DefaultTaskDescriptor> descriptors = new ConcurrentHashMap<>();

import org.gradle.tooling.internal.protocol.events.InternalOperationStartedProgressEvent;

import javax.annotation.Nullable;
import java.util.ArrayList;
import java.util.List;

class TestOperationMapper implements BuildOperationMapper<ExecuteTestBuildOperationType.Details, DefaultTestDescriptor> {
    private final TestTaskExecutionTracker taskTracker;

    TestOperationMapper(TestTaskExecutionTracker taskTracker) {