* @throws IOException if an I/O error occurs
   */
  public static List<String> readLines(File file, Charset charset) throws IOException {
    // don't use asCharSource(file, charset).readLines() because that returns
    // an immutable list, which would change the behavior of this method
    return asCharSource(file, charset)
        .readLines(
            new LineProcessor<List<String>>() {

 *     of the Java collection this collection property corresponds to</li>
 *     <li>{@link CollectingSupplier}, when the collection is still being added to - in that case,
 *     the collecting supplier will wrap a {@link Collector} that lazily represents the yet-to-be realized contents of the collection - see below for details</li>
 * </ul>
 *

    void assertWatchedHierarchies(Iterable<File> expected) {
        if (!hierarchicalWatcher) {
            // No hierarchies to expect
            return
        }
        def watchedHierarchies = output.readLines()
            .find { it.contains("Watched directory hierarchies: [") }
            .with { line ->
                def matcher = line =~ /Watched directory hierarchies: \[(.*)]/

//   . Legalizes control flow operations.
//   . Decomposes compound resource operations so that the only remaining
//     operations on resource variables are resource reads/writes..
//   . Replaces resource reads/writes with function inputs/outputs and
//     eliminates the use of resource variables.
//   . Legalizes the operations to XLA HLO operations.

        return binder;
    }

    @Override
    public <T> T realize(String path, Class<T> type) {
        return realize(path, ModelType.of(type));
    }

    @Override
    public <T> T realize(String path, ModelType<T> type) {
        return realize(ModelPath.path(path), type);
    }

    @Override
    public <T> T realize(ModelPath path, ModelType<T> type) {

        tasks.withType(ClimbTask).all { it.steps = 14 }
        tasks.matching { it.name.contains('jump') }.all { it.height = 7 }


        //It should be possible to reference the tasks without having to do tasks.realize()
        assert overruleTask.text == "actionWoman I'm the real commander"
        assert jumpTask.height == 7
        assert climbTask.steps == 14
        """

        when:
        succeeds('actionMan')

        outputContains "FINISH [Gradle Test Run :test] [Gradle Test Run :test]\n"
        result.output.readLines().find { it.matches "START \\[Gradle Test Executor \\d+] \\[Gradle Test Executor \\d+]" }
        result.output.readLines().find { it.matches "FINISH \\[Gradle Test Executor \\d+] \\[Gradle Test Executor \\d+]" }
        outputContains "START [Test suite 'Gradle suite'] [Gradle suite]\n"

        @Receiver File self,
        @CallerClassName String consumer
    ) throws IOException {
        Instrumented.fileOpened(self, consumer);
        return ResourceGroovyMethods.readLines(self);
    }

    @InterceptGroovyCalls
    @InstanceMethod
    @WithExtensionReferences(toClass = ResourceGroovyMethods.class)
    public static List<String> intercept_readLines(
        @Receiver File self,

        realizeModelElement(path, ModelType.of(type))
    }

    public <T> T realizeModelElement(String path, ModelType<T> type) {
        project.modelRegistry.realize(path, type)
    }

    ModelMap<BinarySpec> getBinaries() {
        realizeModelElement("binaries", modelMap(BinarySpec))
    }

    NativeToolChainRegistry getToolChains() {

        parser.option('B')
        def outstr = new StringWriter()

        expect:
        parser.printUsage(outstr)
        outstr.toString().readLines() == [
            '-a, --long-option                    this is option a',
            '--another-long-option                this is a long option',
            '-B',
            '-b',