}

    @Override
    public String toString() {
        return primitiveType.toString(array);
    }

    @Override
    public void appendToHasher(Hasher hasher) {
        primitiveType.appendTo(hasher, array);
    }

    @Override
    public ValueSnapshot snapshot(@Nullable Object value, ValueSnapshotter snapshotter) {
        PrimitiveType valueType = PrimitiveType.maybeOfValue(value);

class KeyHasherTest extends Specification {
    def "can reuse to hash more than one key"() {
        def hasher = new KeyHasher(BaseSerializerFactory.LONG_SERIALIZER)

        expect:
        hasher.getHashCode(12L) != hasher.getHashCode(11L)
        hasher.getHashCode(12L) == hasher.getHashCode(12L)
        hasher.getHashCode(12L) == new KeyHasher(BaseSerializerFactory.LONG_SERIALIZER).getHashCode(12L)
    }

        this.attributeResourceFilter = attributeResourceFilter;
    }

    @Override
    public void appendConfigurationToHasher(Hasher hasher) {
        super.appendConfigurationToHasher(hasher);
        hasher.putString(getClass().getName());
        attributeResourceFilter.appendConfigurationToHasher(hasher);
    }

    @Override
    boolean filter(RegularFileSnapshotContext context) {

    @Override
    public void appendToHasher(Hasher hasher) {
        hasher.putString(LambdaImplementationSnapshot.class.getName());
        hasher.putString(classIdentifier);
        hasher.putHash(classLoaderHash);
        hasher.putString(functionalInterfaceClass);
        hasher.putString(implClass);
        hasher.putString(implMethodName);
        hasher.putString(implMethodSignature);
        hasher.putInt(implMethodKind);
    }

    @Override
    boolean filter(ZipEntryContext context) {
        return !context.getEntry().isDirectory();
    }

    @Override
    public void appendConfigurationToHasher(Hasher hasher) {
        super.appendConfigurationToHasher(hasher);
        hasher.putString(getClass().getName());
    }

    @Override
    Optional<HashCode> tryHash(RegularFileSnapshotContext snapshotContext) {
        return Optional.of(snapshotContext)

     */
    void putBytes(byte[] bytes, int off, int len);

    /**
     * Feed a single byte into the hasher.
     */
    void putByte(byte value);

    /**
     * Feed an integer byte into the hasher.
     */
    void putInt(int value);

    /**
     * Feed a long value byte into the hasher.
     */
    void putLong(long value);

    /**

        return entries;
    }

    @Override
    public void appendToHasher(Hasher hasher) {
        hasher.putString("Map");
        hasher.putInt(entries.size());
        for (MapEntrySnapshot<T> entry : entries) {
            entry.getKey().appendToHasher(hasher);
            entry.getValue().appendToHasher(hasher);
        }
    }

    @Override
    public boolean equals(Object obj) {

    def "throws IOException generated from hasher"() {
        def file = file('doesNotExist').tap { it.text = "" }
        def delegate = Mock(LineEndingNormalizingFileSystemLocationSnapshotHasher)
        def hasher = LineEndingNormalizingFileSystemLocationSnapshotHasher.wrap(delegate, LineEndingSensitivity.NORMALIZE_LINE_ENDINGS)
        def snapshot = this.snapshot(file)

        when:

    }

    @Override
    public void appendConfigurationToHasher(Hasher hasher) {
        super.appendConfigurationToHasher(hasher);
        hasher.putString(getClass().getName());
        propertiesFilePatterns.forEach(hasher::putString);
        propertiesFileFilters.values().forEach(resourceEntryFilter -> resourceEntryFilter.appendConfigurationToHasher(hasher));
    }

    @Override

        this.resourceSnapshotterCacheService = resourceSnapshotterCacheService;
        Hasher hasher = Hashing.newHasher();
        appendConfigurationToHasher(hasher);
        this.delegateConfigurationHash = hasher.hash();
    }

    @Override
    public void appendConfigurationToHasher(Hasher hasher) {
        delegate.appendConfigurationToHasher(hasher);
    }

    @Nullable
    @Override