return new URLClassLoader(ClassPathUtil.getClassPathUrls(), classLoader) {
      @Override
      public Class<?> loadClass(String name) throws ClassNotFoundException {
        if (blocklist.contains(name)) {
          throw new ClassNotFoundException("I'm sorry Dave, I'm afraid I can't do that.");
        }
        if (name.startsWith(concurrentPackage)) {
          Class<?> c = findLoadedClass(name);

            .reduce(FileTree::plus)
            .orElse(projectLayout.files().getAsFileTree());
    }

    @TaskAction
    public void checkInvalidPermissions() throws IOException {
        if (Os.isFamily(Os.FAMILY_WINDOWS)) {
            throw new StopExecutionException();
        }
        List<String> failures = getFiles().getFiles()
            .stream()
            .filter(FilePermissionsTask::isExecutableFile)

            generateContents(tempDir, count);

            return tempDir;
        } catch (final Exception e) {
            throw new CrawlerSystemException(e);
        }
    }

    private static void generateContents(final File dir, final int count) throws Exception {
        if (count <= 0) {
            return;
        }

        final String content = getHtmlContent(count);

        authenticator = null;
    }

    @AfterEach
    public void tearDown() throws Exception {
        if (authenticator != null) {
            authenticator.close();
        }
    }

    @Test
    @DisplayName("Test password stored as char array")
    void testPasswordStoredAsCharArray() throws Exception {
        authenticator = new NtlmPasswordAuthenticator("DOMAIN", "username", "password123");

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);

        FessConfig fessConfig = createTestFessConfig();
        ComponentUtil.setFessConfig(fessConfig);

        queryFieldConfig = new QueryFieldConfig();
    }

    @Override
    protected void tearDown(TestInfo testInfo) throws Exception {
        ComponentUtil.setFessConfig(null);

    @Deprecated
    @Override
    public void install(String basedir, String finalName, Artifact artifact, ArtifactRepository localRepository)
            throws ArtifactInstallationException {
        String extension = artifact.getArtifactHandler().getExtension();
        File source = new File(basedir, finalName + "." + extension);

        install(source, artifact, localRepository);

     * @return the corresponding WitnessEventType
     * @throws IllegalArgumentException if value is not recognized
     */
    public static WitnessEventType fromValue(int value) {
        for (WitnessEventType type : values()) {
            if (type.value == value) {
                return type;
            }
        }
        throw new IllegalArgumentException("Unknown witness event type: " + value);
    }

  // helper
  private static void doParallelCacheOp(int count, IntConsumer consumer) {
    IntStream.range(0, count).parallel().forEach(consumer);
  }

  @Override
  public void setUp() throws Exception {
    super.setUp();
    this.cache =
        CacheBuilder.newBuilder()
            .expireAfterAccess(500000, MILLISECONDS)
            .maximumSize(count)
            .build();
  }

      if (actualException instanceof InterruptedException) {
        return Outcome.INTERRUPT;
      } else {
        throw new AssertionError("unexpected exception", targetException);
      }
    } catch (IllegalAccessException e) {
      throw new AssertionError("unexpected exception", e);
    }
  }

  private void enterSatisfyGuardAndLeaveInCurrentThread() {
    monitor.enter();

        assertEquals(-128, response.getServerData().serverTimeZone);
        assertEquals(8, response.getServerData().encryptionKeyLength);
    }

    @Test
    public void testReadBytesWireFormatWithoutExtendedSecurity() throws UnsupportedEncodingException {
        response.getServerData().scapabilities = 0;
        response.getServerData().encryptionKeyLength = 8;
        // Domain name in OEM encoding (ASCII) with null terminator