}
    }

    static class VisualStudioPluginRootRules extends RuleSource {
        // This ensures that subprojects are realized and register their project and project configuration IDE artifacts
        @Mutate
        public static void ensureSubprojectsAreRealized(TaskContainer tasks, ProjectIdentifier projectIdentifier, ServiceRegistry serviceRegistry) {

        this.componentIdentifier = componentIdentifier;
        this.publishArtifact = publishArtifact;
        // In case the publish artifact is backed by an ArchiveTask, this causes the task to be realized.
        // However, if we are at this point, we need the realized task to determine the archive extension/type later
        // to set the 'artifactType' attribute required in matching (even if the variant with the artifact is not selected in the end).

            }
        """
        resolve.prepare()
    }

    def "produces sensible error when bad code is supplied in component metadata rule" () {
        def lines = buildFile.readLines().size()
        buildFile << """
            class WrongRule implements ComponentMetadataRule {
                public void execute(ComponentMetadataContext context) {
                    foo()
                }

        def process = ['readelf', '-h', binaryFile.absolutePath].execute()
        List<String> lines = process.inputStream.readLines()
        return readArch(lines)
    }

    List<String> listObjectFiles() {
        def process = ['ar', '-t', binaryFile.getAbsolutePath()].execute()
        return process.inputStream.readLines()
    }

    List<String> listLinkedLibraries() {

class ProjectVariantResolutionIntegrationTest extends AbstractIntegrationSpec implements VariantAwareDependencyResolutionTestFixture, TasksWithInputsAndOutputs {
    def "does not realize tasks that produce outgoing artifacts that are not required"() {
        createDirs("a", "b")
        settingsFile << """
            include 'a', 'b'
        """
        setupBuildWithColorVariants()

    }
    def "resolution result does not realize artifact tasks"() {
        createDirs("producer")
        settingsFile << "include 'producer'"
        file("producer/build.gradle") << """
            plugins {
                id("base")
            }

            def fooTask = tasks.register("foo", Zip) {
                throw new RuntimeException("Realized artifact task")
            }

public class DefaultRealizableTaskCollection<T extends Task> extends DelegatingNamedDomainObjectSet<T> implements TaskCollection<T>, TaskDependencyContainer {

    private final Class<T> type;
    private final AtomicBoolean realized = new AtomicBoolean();
    private final MutableModelNode modelNode;
    private final Instantiator instantiator;

            file("build/libs1/test-1.3.jar.txt").readLines() == ["1", "2", "3", "4", "5"]
            file("build/libs1/test2-2.3.jar.txt").readLines() == ["1", "2", "3", "4", "5"]
        } else {
            // Counter is isolated at execution time, so transforms will see the increment in each tasks' doLast { }
            file("build/libs2/test-1.3.jar.txt").readLines() == ["2", "3", "4", "5", "6"]

   */
  @CanIgnoreReturnValue // some processors won't return a useful result
  @ParametricNullness
  public static <T extends @Nullable Object> T readLines(
      URL url, Charset charset, LineProcessor<T> callback) throws IOException {
    return asCharSource(url, charset).readLines(callback);
  }

  /**
   * Reads all of the lines from a URL. The lines do not include line-termination characters, but do

    @Requires(UnitTestPreconditions.IsGroovy3)
    def "produces sensible error when bad code is supplied in component selection rule with Groovy 3"() {
        def lines = buildFile.readLines().size()
        buildFile << """
            dependencies {
                conf "org.utils:api:1.2"
            }

            configurations.all {
                resolutionStrategy {