1 * target.text >> 'content'
        0 * target._
    }

    def fetchesAndCachesContentWhenContentQueriedAsReader() {
        when:
        assert resource.asReader.text == 'content'
        assert resource.exists
        assert resource.asReader.text == 'content'

        then:
        1 * target.text >> 'content'
        0 * target._
    }

    def fetchesAndCachesContentWhenContentIsEmptyIsChecked() {

    def "can use char source text resource"() {
        when:
        def r = new CharSourceBackedTextResource("display name", CharSource.wrap("foo"))

        then:
        r.asString() == "foo"
        r.asReader().text == "foo"
    }

    TextResource resource

    def "read as string"() {
        expect:
        resource.asString() == "contents"
    }

    def "read as reader"() {
        expect:
        def reader = resource.asReader()

        try {
            reader.readLine() == "contents"
        } finally {
            reader.close()
        }
    }

    def "read as file"() {
        expect:

        /**
         * See {@code org.gradle.api.internal.project.taskfactory.TaskIdentity#uniqueId}.
         */
        long getTaskId();

        boolean isReplacement();

        boolean isEager();
    }

    public interface Result {
    }

    private RealizeTaskBuildOperationType() {
    }

                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>asString</td>
            </tr>
            <tr>
                <td>asReader</td>
            </tr>
            <tr>
                <td>asFile</td>
            </tr>
        </table>
    </section>

      lines.add(line);
    }
    r.close();
    return lines;
  }

  private static List<String> readUsingReader(String input, int chunk, boolean asReader)
      throws IOException {
    Readable readable =
        asReader ? getChunkedReader(input, chunk) : getChunkedReadable(input, chunk);
    LineReader r = new LineReader(readable);
    List<String> lines = Lists.newArrayList();
    String line;

      lines.add(line);
    }
    r.close();
    return lines;
  }

  private static List<String> readUsingReader(String input, int chunk, boolean asReader)
      throws IOException {
    Readable readable =
        asReader ? getChunkedReader(input, chunk) : getChunkedReadable(input, chunk);
    LineReader r = new LineReader(readable);
    List<String> lines = Lists.newArrayList();
    String line;

    @Override
    public String toString() {
        return getDisplayName();
    }

    @Override
    public String asString() {
        return string;
    }

    @Override
    public Reader asReader() {
        return new StringReader(string);
    }

    @Override
    public File asFile(String charset) {
        File file = tempFileProvider.createTemporaryFile("string", ".txt", "resource");
        try {

        try {
            return charSource.read();
        } catch (IOException e) {
            throw ResourceExceptions.readFailed(displayName, e);
        }
    }

    @Override
    public Reader asReader() {
        try {
            return charSource.openStream();
        } catch (IOException e) {
            throw ResourceExceptions.readFailed(displayName, e);
        }
    }

    @Override

            throw ResourceExceptions.readMissing(file, e);
        } catch (IOException e) {
            throw ResourceExceptions.readFailed(file, e);
        }
    }

    @Override
    public Reader asReader() {
        File file = asFile();
        try {
            return Files.newReader(asFile(), charset);
        } catch (FileNotFoundException e) {
            throw ResourceExceptions.readMissing(file, e);
        }