def unnormalized = file('unnormalized.txt') << content.textWithLineEndings(eol)
        def normalized = file('normalized.txt') << content.textWithLineEndings('\n')

        expect:
        hasher.hashContent(unnormalized).get() == hasher.hashContent(normalized).get()

        where:
        eol     | description
        '\r'    | 'CR'
        '\r\n'  | 'CR-LF'
        '\n'    | 'LF'
    }

            .flatMap(IoFunction.wrap(this::hashContent));
    }

    @Override
    Optional<HashCode> tryHash(ZipEntryContext zipEntryContext) {
        return Optional.of(zipEntryContext)
            .flatMap(IoFunction.wrap(this::hashContent));
    }

    private Optional<HashCode> hashContent(RegularFileSnapshotContext snapshotContext) throws IOException {

        return hashContent(snapshot)
            .orElseGet(IoSupplier.wrap(() -> delegate.hash(snapshot)));
    }

    private Optional<HashCode> hashContent(FileSystemLocationSnapshot snapshot) throws IOException {
        return snapshot.getType() == FileType.RegularFile ? hasher.hashContent(new File(snapshot.getAbsolutePath())) : Optional.empty();
    }

     * @throws IOException
     */
    public Optional<HashCode> hashContent(File file) throws IOException {
        try (FileInputStream inputStream = new FileInputStream(file)) {
            return hashContent(inputStream);
        }
    }

    /**
     * Returns empty if the file is detected to be a binary file
     */

    private boolean currentProjectHasRules;
    private boolean hasContent;
    private boolean detail;
    private boolean showTypes;

    @Override
    public void startProject(ProjectDetails project) {
        currentProjectHasTasks = false;
        currentProjectHasRules = false;
        hasContent = false;
        detail = false;
        super.startProject(project);
    }

    @Override

            return;
        }
        hasContent = true;
        events.add(new Action<StyledTextOutput>() {
            @Override
            public void execute(StyledTextOutput styledTextOutput) {
                styledTextOutput.text(text);
            }
        });
    }

    public boolean getHasContent() {
        return hasContent;
    }

// body. Once writes begin or finish() is called, the response is sent
// on ch.
type populateResponse struct {
	res          *Response
	ch           chan *Response
	wroteHeader  bool
	hasContent   bool
	sentResponse bool
	pw           *io.PipeWriter
}

func (pr *populateResponse) finish() {
	if !pr.wroteHeader {
		pr.WriteHeader(500)
	}
	if !pr.sentResponse {
		pr.sendResponse()
	}

        return file;
    }

    private boolean probeCaseSensitive(File file, String content) {
        try {
            File upperCased = new File(file.getPath().toUpperCase(Locale.ROOT));
            return !hasContent(upperCased, content);
        } catch (IOException e) {
            // not fully accurate but a sensible fallback

        // remains the same as the content in the existing file
        private void updateFileOnlyWhenGeneratedContentChanges() {
            byte[] generatedContent = generateContent();
            if (!hasContent(generatedContent, file)) {
                try {
                    fileGenerationListener.execute(file);
                    Files.write(generatedContent, file);
                } catch (IOException e) {