/**
     * Names of dependencies whose shas should not exist.
     */
    private Set<String> ignoreShas = new HashSet<>();

    /**
     *  Names of files that should be ignored by the check
     */
    private LinkedHashSet<String> ignoreFiles = new LinkedHashSet<>();

    /**
     * Add a mapping from a regex pattern for the jar name, to a prefix to find

      val conn: HttpURLConnection
      try {
        conn = url.openConnection() as HttpURLConnection
        responseCode.set(conn.responseCode) // Force the connection to hit the "server".
      } catch (ignored: IOException) {
      }
    }

    /**
     * This filter can be considerably more efficient than other file filters
     * as the specified wildcard and attributes are passed to the server for
     * filtering there (although attributes are largely ignored by servers
     * they are filtered locally by the default accept method).
     *
     * @param wildcard the wildcard pattern for matching file names (e.g., "*.txt")

    }

    /**
     * Block an IP address for the specified duration.
     * Note: The duration is ignored as the cache uses the configured block duration.
     * @param ip the IP address to block
     * @param durationMs the duration in milliseconds (ignored, uses configured value)
     */
    public void blockIp(final String ip, final long durationMs) {
        blockedIps.put(ip, Boolean.TRUE);

    FilenameFilter filter = new PatternFilenameFilter("a+");
    assertTrue(filter.accept(dir, "a"));
    assertTrue(filter.accept(dir, "aaaa"));
    assertFalse(filter.accept(dir, "b"));

    // Show that dir is ignored
    assertTrue(filter.accept(null, "a"));
  }

  public void testNulls() throws Exception {
    NullPointerTester tester = new NullPointerTester();

						<id>check-compatibility</id>
						<goals>
							<goal>check</goal>
						</goals>
					</execution>
				</executions>
				<configuration>
					<failOnError>false</failOnError>
					<ignored>
						<difference>
							<!-- seems to be a clirr bug that it cannot handle the different inherited 
								return types -->
							<className>**</className>
							<differenceType>7006</differenceType>

     */
    String FATJAR = "fatjar";

    /**
     * Artifact type name for a JAR file to unconditionally place on the class path.
     * If the JAR is modular, its module information are ignored.
     * This type is new in Maven 4.
     */
    String CLASSPATH_JAR = "classpath-jar";

    /**
     * Artifact type name for a JAR file to unconditionally place on the module path.

        //    } else {
        //        return null;
        //    }
        //}
        //try {
        //    return CDef.DefMeta.valueOf(searchName);
        //} catch (IllegalArgumentException ignored) { // not found
        //    return null; // handled later
        //}
    }

    @Override
    public OptionalThing<String> determineAlias(final Locale locale) {
        return OptionalObject.empty();
    }

      val story00 = path / "story_00.json"
      if (!fileSystem.exists(story00)) continue
      try {
        readStory(story00)
        result.add(path.name)
      } catch (ignored: IOException) {
        // Skip this path.
      }
    }
    return result.toTypedArray<String>()
  }

  /**
   * Reads stories named "story_xx.json" from the folder provided.
   */

        then:
        1 * delegate.completed("testId1", testCompleteEvent1)
        1 * delegate.completed("rootId", rootCompleteEvent)
    }

    def "events for aborted tests are ignored"() {
        given:
        def delegate = Mock(TestResultProcessor)
        def processor = new RerunTestResultProcessor(delegate);
        def rootDescriptor = descriptor("rootId")