t.Errorf("%s: %v", test.m, err)
			}
			zipHash := hex.EncodeToString(h.Sum(nil))
			if zipHash != test.wantFileHash {
				if *updateTestData {
					t.Logf("%s: updating zip file hash to %s", test.m, zipHash)
					test.wantFileHash = zipHash
					needUpdate = true
				} else {
					t.Errorf("%s: got zip file hash %s; want hash %s (but content sum matches)", test.m, zipHash, test.wantFileHash)
				}
			}
		})
	}

            if (resourceHash.equals(NO_HASH)) {
                return null;
            }
            return resourceHash;
        }

        resourceHash = hashCodeSupplier.get();

        if (resourceHash != null) {
            indexedCache.put(resourceHashCacheKey, resourceHash);
        } else {
            indexedCache.put(resourceHashCacheKey, NO_HASH);
        }
        return resourceHash;
    }

            this.artifact = ArtifactUtils.copyArtifact(artifact);
            if ("pom".equals(artifact.getType()) && file != null) {
                pomHash = file.getPath().hashCode() + file.lastModified();
            } else {
                pomHash = 0;
            }
            this.resolveManagedVersions = resolveManagedVersions;
            this.repositories.add(localRepository);

        try {
            return doHash(inputStream, ByteStreams.nullOutputStream());
        } catch (IOException e) {
            throw new UncheckedIOException("Failed to create MD5 hash for file content.", e);
        }
    }

    @Override
    public HashCode hashCopy(InputStream inputStream, OutputStream outputStream) throws IOException {
        return doHash(inputStream, outputStream);
    }

     */
    abstract Optional<HashCode> tryHash(RegularFileSnapshotContext snapshotContext);

    /**
     * Try to hash the resource, and signal for fallback if it can't be hashed.
     *
     * @return An Optional containing the hash, or an empty Optional if fallback should be triggered
     */
    abstract Optional<HashCode> tryHash(ZipEntryContext zipEntryContext);

	if !fs.ValidPath(path) {
		return "", errInvalidPath
	}
	return localize(path)
}

// ToSlash is filepath.ToSlash.
func ToSlash(path string) string {
	if Separator == '/' {
		return path
	}
	return replaceStringByte(path, Separator, '/')
}

// FromSlash is filepath.ToSlash.
func FromSlash(path string) string {
	if Separator == '/' {
		return path
	}

	return e.workers.Load()
}

type expiryOp interface {
	OpHash() uint64
}

type freeVersionTask struct {
	ObjectInfo
}

func (f freeVersionTask) OpHash() uint64 {
	return xxh3.HashString(f.TransitionedObject.Tier + f.TransitionedObject.Name)
}

func (n newerNoncurrentTask) OpHash() uint64 {
	return xxh3.HashString(n.bucket + n.versions[0].ObjectV.ObjectName)
}

        hasher.putString(getClass().getName());
    }

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

    @Override
    Optional<HashCode> tryHash(ZipEntryContext zipEntryContext) {
        return Optional.of(zipEntryContext)

                    return Arrays.equals(a.getGenericParameterTypes(), b.getGenericParameterTypes());
                }
            }
            return false;
        }

        @Override
        protected int doHash(Method method) {
            return new HashCodeBuilder()
                .append(method.getName())
                .append(method.getParameterTypes())
                .toHashCode();
        }
    };

    /**

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

    @Override
    public Optional<HashCode> tryHash(RegularFileSnapshotContext snapshotContext) {
        return Optional.ofNullable(matchingFiltersFor(snapshotContext.getRelativePathSegments()))
            .map(resourceEntryFilter -> {