testHashTrieMap(t, func() *HashTrieMap[string, int] {
		// Stub out the good hash function with a terrible one.
		// Everything should still work as expected.
		m := NewHashTrieMap[string, int]()
		m.keyHash = func(_ unsafe.Pointer, _ uintptr) uintptr {
			return 0
		}
		return m
	})
}

func testHashTrieMap(t *testing.T, newMap func() *HashTrieMap[string, int]) {
	t.Run("LoadEmpty", func(t *testing.T) {

            if (fallbackZipHasher != null) {
                return fallbackZipHasher.hashZipContents(zipFileSnapshot);
            }
            return zipFileSnapshot.getHash();
        }
    }

    private List<FileSystemLocationFingerprint> fingerprintZipEntries(String zipFile) throws IOException {
        try (ZipInput input = FileZipInput.create(new File(zipFile))) {

            for (File sourceFile : spec.getSourceFiles()) {
                SourceFileState state = incrementalCompilation.getFinalState().getState(sourceFile);
                final HashCode hash = state.getHash();
                List<String> headers = new ArrayList<>();
                for (IncludeFileEdge edge : state.getEdges()) {
                    if (hash.equals(edge.getIncludedBy())) {

        1 * fileSnapshot.getAbsolutePath() >> file.absolutePath
        1 * apiClassExtractor.extractApiClassFrom(_) >> { args -> throw new Exception("Boom!") }

        and:
        1 * fileSnapshot.getHash()

        and:
        noExceptionThrown()
    }

    @Issue("https://github.com/gradle/gradle/issues/20398")
    def "falls back to full zip entry hash when abi extraction fails for a zip entry"() {

                    LOGGER.debug("Malformed class file '{}' found on compile classpath. Falling back to full file hash instead of ABI hashing.", fileSnapshot.getName(), e);
                    return fileSnapshot.getHash();
                }
            }

            @Nullable
            @Override
            HashCode handle(ZipEntryContent zipEntry, IoFunction<ZipEntryContent, HashCode> function) {
                try {

        }
        return Optional.of(new DirectorySnapshot(targetPath, name, getAccessType(), contentHash, childMapFromSorted(relocatedChildren.build())));
    }

    @Override
    public HashCode getHash() {
        return contentHash;
    }

    @Override
    public FileType getType() {
        return FileType.Directory;
    }

    @Override

        return outputSnapshots.entrySet().stream()
            .flatMap(entry ->
                entry.getValue().roots()
                    .map(locationSnapshot -> immutableEntry(entry.getKey(), locationSnapshot.getHash())))
            .collect(toImmutableListMultimap(
                Map.Entry::getKey,
                Map.Entry::getValue
            ));
    }

// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package maphash

import (
	"bytes"
	"fmt"
	"hash"
	"testing"
)

func TestUnseededHash(t *testing.T) {
	m := map[uint64]struct{}{}
	for i := 0; i < 1000; i++ {
		h := new(Hash)
		m[h.Sum64()] = struct{}{}
	}
	if len(m) < 900 {

    }

    RegularFileSnapshot snapshot(File file, FileType fileType) {
        return Mock(RegularFileSnapshot) {
            getAbsolutePath() >> file.absolutePath
            getType() >> fileType
            getHash() >> Hashing.hashFile(file)
        }
    }

                    default:
                        throw new IllegalArgumentException("Unknown file type: " + fileMetadata.getType());
                }
            }))
            .map(FileSystemLocationSnapshot::getHash);
    }

    @Override
    public Optional<FileSystemLocationSnapshot> read(String location, SnapshottingFilter filter) {
        if (filter.isEmpty()) {
            return Optional.of(read(location));