import org.gradle.api.tasks.OutputDirectory;
import org.gradle.api.tasks.SkipWhenEmpty;
import org.gradle.api.tasks.TaskAction;
import org.gradle.api.tasks.util.PatternFilterable;
import org.gradle.api.tasks.util.PatternSet;
import org.gradle.internal.Factory;

import java.io.File;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import javax.inject.Inject;

    protected void mergePatternSet(
            PatternSet target, PatternSet source, boolean sourceDominant, Map<Object, Object> context) {
        mergePatternSet_Includes(target, source, sourceDominant, context);
        mergePatternSet_Excludes(target, source, sourceDominant, context);
    }

    protected void mergePatternSet_Includes(
            PatternSet target, PatternSet source, boolean sourceDominant, Map<Object, Object> context) {

      </codeSegments>
    </class>
    <class>
      <name>PatternSet</name>
      <version>3.0.0+</version>
      <description>Definition of include or exclude patterns.</description>
      <fields>
        <field>
          <name>includes</name>
          <version>3.0.0+</version>
          <description>
            A list of patterns to include, e.g. {@code **&amp;#47;*.xml}.
          </description>

        void testSourceKeyAlternatingPattern() {
            // Given
            byte[] patternKey = new byte[SOURCE_KEY_SIZE];
            for (int i = 0; i < SOURCE_KEY_SIZE; i++) {
                patternKey[i] = (byte) ((i % 2 == 0) ? 0xAA : 0x55);
            }
            SrvCopychunkCopy copy = new SrvCopychunkCopy(patternKey);
            byte[] buffer = new byte[100];

            // When

import org.apache.maven.artifact.Artifact;

/**
 * Filter to include from a list of artifact patterns.
 *
 */
public class IncludesArtifactFilter implements ArtifactFilter {
    private final Set<String> patterns;

    public IncludesArtifactFilter(List<String> patterns) {
        this.patterns = new LinkedHashSet<>(patterns);
    }

    @Override
    public boolean include(Artifact artifact) {

 * <p>
 * Pattern syntax supports:
 * <ul>
 *   <li>Standard glob patterns with {@code *}, {@code ?}, and {@code **} wildcards</li>
 *   <li>Explicit syntax prefixes like {@code "glob:"} or {@code "regex:"}</li>
 *   <li>Maven 3 compatible behavior for patterns without explicit syntax</li>
 *   <li>Default exclusion patterns for SCM files when requested</li>
 * </ul>
 *
 * @since 4.0.0
 * @see PathMatcher
 */

#      interval: "weekly"
#    groups:
#      dependencies:
#        applies-to: version-updates
#        patterns:
#          - "*"
#  - package-ecosystem: "maven"
#    directory: "/android"
#    schedule:
#      interval: "weekly"
#    groups:
#      dependencies:
#        applies-to: version-updates
#        patterns:
#          - "*"
  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:

        excludeFilterCache.invalidate(sessionId);
    }

    /**
     * Gets the list of include URL patterns for the specified session.
     *
     * @param sessionId The session ID.
     * @return The list of compiled include patterns.
     * @throws CrawlerSystemException if the patterns cannot be loaded.
     */
    @Override
    public List<Pattern> getIncludeUrlPatternList(final String sessionId) {

                .value() > 0);

        // Verify pattern can be retrieved
        final List<Pattern> patterns = urlFilterService.getIncludeUrlPatternList(sessionId);
        assertEquals(1, patterns.size());
        assertTrue(patterns.get(0).matcher("http://example.com/page1").matches());
        assertFalse(patterns.get(0).matcher("http://other.com/page1").matches());

        urlFilterService.delete(sessionId);
    }

/**
 */
class FilterHashEqualsTest {

    @Test
    void testIncludesExcludesArtifactFilter() {
        List<String> patterns = Arrays.asList("c", "d", "e");

        IncludesArtifactFilter f1 = new IncludesArtifactFilter(patterns);

        IncludesArtifactFilter f2 = new IncludesArtifactFilter(patterns);

        assertTrue(f1.equals(f2), "Expected " + f1 + " to equal " + f2);