assertNotNull(robotsTxt.getDirective("goodbot"));
        assertFalse(robotsTxt.allows("/admin/", "GoodBot"));
        assertTrue(robotsTxt.allows("/public/", "GoodBot"));
        // Invalid directives should not cause parsing to fail

        // Test crawl-delay with invalid values
        // Invalid number should be ignored, valid ones should work

   * with underutilization, then we want stored permits to be given out /faster/ than fresh ones,
   * because underutilization = free resources for the taking. If we are primarily interested to
   * deal with overflow, then stored permits could be given out /slower/ than fresh ones. Thus, we
   * require a (different in each case) function that translates storedPermits to throttling time.
   *

    }

    public void test_parseXmlSitemaps_mixedValidInvalid() {
        // Mix of valid and invalid entries should parse valid ones
        final String xml =
                "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + "<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\n"

  /**
   * When we need a new thread to run tasks, we call [Backend.execute]. A few microseconds later we
   * expect a newly-started thread to call [Runnable.run]. We shouldn't request new threads until
   * the already-requested ones are in service, otherwise we might create more threads than we need.
   *
   * We use [executeCallCount] and [runCallCount] to defend against starting more threads than we
   * need. Both fields are guarded by `this`.
   */

    for (Future<?> result : results) {
      if (!result.isCancelled()) {
        result.get(10, SECONDS);
      }
      // TODO(cpovirk): Verify that the cancelled futures are exactly ones that we expect.
    }

    assertThat(logHandler.getStoredLogRecords()).isEmpty();
  }

  public void testAvoidsStackOverflow_manySubmitted() throws Exception {

   * invoked in the same order as the underlying service enters those states. Additionally, at most
   * one of the listener's callbacks will execute at once. However, multiple listeners' callbacks
   * may execute concurrently, and listeners may execute in an order different from the one in which
   * they were registered.
   *
   * <p>RuntimeExceptions thrown by a listener will be caught and logged. Any exception thrown

     *
     * <p>This method is designed to be resilient to malformed robots.txt files.
     * It will parse valid directives and ignore invalid ones, ensuring that partial
     * content can be extracted even from poorly formatted files.</p>
     *
     * <p>The following errors are handled gracefully (line is skipped, parsing continues):</p>
     * <ul>

        // All patterns should be accepted
        assertDoesNotThrow(() -> request.setFileId(allZeros), "Should handle all-zeros file ID");
        assertDoesNotThrow(() -> request.setFileId(allOnes), "Should handle all-ones file ID");
        assertDoesNotThrow(() -> request.setFileId(alternating), "Should handle alternating pattern file ID");
    }

    @Test
    @DisplayName("Should create custom implementation of RequestWithFileId")

        byte[] zeroFileId = new byte[16];
        Smb2FlushRequest zeroRequest = new Smb2FlushRequest(mockConfig, zeroFileId);
        testFileIdInRequest(zeroRequest, zeroFileId);

        // Test with all ones
        byte[] onesFileId = new byte[16];
        Arrays.fill(onesFileId, (byte) 0xFF);
        Smb2FlushRequest onesRequest = new Smb2FlushRequest(mockConfig, onesFileId);
        testFileIdInRequest(onesRequest, onesFileId);

    }
    if (e is SSLPeerUnverifiedException) {
      // e.g. a certificate pinning error.
      return false
    }
    // An example of one we might want to retry with a different route is a problem connecting to a
    // proxy and would manifest as a standard IOException. Unless it is one we know we should not
    // retry, we return true and try a new route.
    return true
  }

  /**