!restoredNormalization.getPropertiesFileFilters()[PropertiesFileFilter.ALL_PROPERTIES].shouldBeIgnored("not.ignored")
        restoredNormalization.getPropertiesFileFilters()["some.properties"].shouldBeIgnored("ignored.in.some")
        !restoredNormalization.getPropertiesFileFilters()["some.properties"].shouldBeIgnored("not.ignored")
    }

        for (String ignore : ignores) {
            hasher.putString(ignore);
        }
    }

    @Override
    public boolean shouldBeIgnored(Supplier<String[]> relativePathFactory) {
        if (ignoreMatchers.isEmpty()) {
            return false;
        }
        return shouldBeIgnored(relativePathFactory.get());
    }

        @Override
        public boolean shouldBeIgnored(Supplier<String[]> relativePathFactory) {
            return false;
        }

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

    boolean shouldBeIgnored(Supplier<String[]> relativePathFactory);

        @Override
        public boolean shouldBeIgnored(String entry) {
            return false;
        }

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

    boolean shouldBeIgnored(String entry);

    public UnionResourceEntryFilter(Collection<ResourceEntryFilter> filters) {
        this.filters = filters;
    }

    @Override
    public boolean shouldBeIgnored(String entry) {
        return filters.stream().anyMatch(resourceEntryFilter -> resourceEntryFilter.shouldBeIgnored(entry));
    }

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

        return resourceFilter.shouldBeIgnored(snapshotContext.getRelativePathSegments()) ? null : delegate.hash(snapshotContext);
    }

    @Nullable
    @Override
    public HashCode hash(ZipEntryContext zipEntryContext) throws IOException {
        return resourceFilter.shouldBeIgnored(zipEntryContext.getRelativePathSegments()) ? null : delegate.hash(zipEntryContext);
    }

        hasher.hash(snapshotContext)

        then:
        1 * resourceFilter.shouldBeIgnored(_) >> false
        1 * delegate.hash(snapshotContext)
    }

    def "filters resources when resource filter matches"() {
        when:
        def hash = hasher.hash(snapshotContext)

        then:
        1 * resourceFilter.shouldBeIgnored(_) >> true
        0 * delegate.hash(_)

        and:
        hash == null
    }

    private final ImmutableSet<String> ignores;

    public IgnoringResourceEntryFilter(ImmutableSet<String> ignores) {
        this.ignores = ignores;
    }

    @Override
    public boolean shouldBeIgnored(String entry) {
        return ignores.contains(entry);
    }

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

            ));
        List<Map.Entry<String, String>> normalizedEntries = entries.
            entrySet()
            .stream()
            .filter(entry -> !attributeResourceFilter.shouldBeIgnored(entry.getKey()))
            .sorted(Map.Entry.comparingByKey())
            .collect(Collectors.toList());

        // Short-circuiting when there's no matching entries allows empty manifest sections to be ignored

        Map<String, String> entries = Maps.fromProperties(properties);
        entries
            .entrySet()
            .stream()
            .filter(entry ->
                !propertyResourceFilter.shouldBeIgnored(entry.getKey()))
            .sorted(Map.Entry.comparingByKey())
            .forEach(entry -> {
                hasher.putString(entry.getKey());
                hasher.putString(entry.getValue());
            });