import java.util.Collection;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

public class OptionReader {
    private final ListMultimap<Class<?>, OptionElement> cachedOptionElements = ArrayListMultimap.create();

    public static TaskDetailsModel from(String taskPath, BuildTaskSelector.BuildSpecificSelector taskSelector, OptionReader optionReader) {
        try {
            Stream<Task> selectedTasks = taskSelector.resolveTaskName(taskPath).getTasks().stream();
            List<TaskDetails> tasks = selectedTasks.map(t -> TaskDetails.from(t, optionReader))
                .sorted(TaskDetails.DEFAULT_COMPARATOR).collect(Collectors.toList());

import java.util.Collection;
import java.util.List;

@ServiceScope(Scope.Gradle.class)
public class CommandLineTaskConfigurer {
    private OptionReader optionReader;

    public CommandLineTaskConfigurer(OptionReader optionReader) {
        this.optionReader = optionReader;
    }

    public List<String> configureTasks(Collection<Task> tasks, List<String> arguments) {
        assert !tasks.isEmpty();

            }
        });
    }

    @Provides
    OptionReader createOptionReader() {
        return new OptionReader();
    }

    @Provides
    CommandLineTaskParser createCommandLineTaskParser(OptionReader optionReader, BuildTaskSelector taskSelector, BuildState build) {
        return new CommandLineTaskParser(new CommandLineTaskConfigurer(optionReader), taskSelector, build);
    }

    @Provides

        return options;
    }

    public static TaskDetails from(Task task, OptionReader optionReader) {
        String path = task.getPath();
        int projectDepth = StringUtils.countMatches(path, Project.PATH_SEPARATOR);
        List<OptionDetails> options = TaskOptionsGenerator.generate(task, optionReader).getAll().stream().map(OptionDetails::from).collect(Collectors.toList());

     *
     * @param task the task, must implement {@link Task}
     * @param optionReader the optionReader
     * @return the generated taskOptions
     */
    public static TaskOptions generate(Object task, OptionReader optionReader) {
        TaskOptions taskOptions = new TaskOptions();
        Map<String, OptionDescriptor> options = optionReader.getOptions(task);
        options.putAll(generateOppositeOptions(task, options, taskOptions));

 */
package org.gradle.execution.commandline

import org.gradle.api.DefaultTask
import org.gradle.api.Project
import org.gradle.api.tasks.options.Option
import org.gradle.api.internal.tasks.options.OptionReader
import org.gradle.api.tasks.TaskAction
import org.gradle.execution.DefaultTaskSelector
import org.gradle.internal.typeconversion.TypeConversionException
import org.gradle.testfixtures.ProjectBuilder

 * limitations under the License.
 */
package org.gradle.configuration;

import org.gradle.api.DefaultTask;
import org.gradle.api.internal.DocumentationRegistry;
import org.gradle.api.internal.tasks.options.OptionReader;
import org.gradle.api.model.ObjectFactory;
import org.gradle.api.provider.Property;
import org.gradle.api.tasks.TaskAction;
import org.gradle.api.tasks.options.Option;

Class <org.gradle.api.internal.tasks.compile.incremental.IncrementalCompilerFactory> is not annotated with @ServiceScope in (IncrementalCompilerFactory.java:0)
Class <org.gradle.api.internal.tasks.options.OptionReader> is not annotated with @ServiceScope in (OptionReader.java:0)
Class <org.gradle.api.logging.LoggingManager> is not annotated with @ServiceScope in (LoggingManager.java:0)

import org.gradle.api.tasks.options.OptionValues
import spock.lang.Issue
import spock.lang.Specification

class OptionReaderTest extends Specification {

    OptionReader reader
    int builtInOptionCount

    def setup() {
        reader = new OptionReader()
        builtInOptionCount = TaskOptionsGenerator.BUILT_IN_OPTIONS.size();
    }

    def "can read options linked to setter methods of a task"() {
        when: