* interrupting thread. In theory, interruptTask() should be very fast, but due to
         * InterruptibleChannel and JavaLangAccess.blockedOn(Thread, Interruptible), it isn't
         * predictable what work might be done. (e.g., close a file and flush buffers to disk). To
         * protect ourselves from this, we park ourselves and tell our interrupter that we did so.

            this.mirroredRepositories = Collections.emptyList();
        }
    }

    @Override
    public boolean isBlocked() {
        return blocked;
    }

    @Override
    public void setBlocked(boolean blocked) {
        this.blocked = blocked;
    }

            recentAttempts.set(0);
            blocked.set(false);
            blockExpiry = null;
            windowStart = Instant.now();
        }

        void block(Duration duration) {
            blocked.set(true);
            blockExpiry = Instant.now().plus(duration);
        }

        boolean isBlocked() {
            return blocked.get();
        }

        int getRecentAttempts() {

            assertTrue(rateLimiter.checkAttempt("user" + i, ip));
            rateLimiter.recordFailure("user" + i, ip);
        }

        // Should be blocked
        assertFalse(rateLimiter.checkAttempt("user6", ip), "IP should be blocked");

        // Manually unblock
        assertTrue(rateLimiter.unblockIp(ip), "Manual unblock should succeed");

        // Should be allowed again

        final Path baseDir = tempFolder.getRoot().toPath();
        final Path traversalPath = baseDir.resolve("../../../etc/passwd");

        assertFalse("Path traversal should be blocked", FileUtil.isPathSafe(traversalPath, baseDir));
    }

    /**
     * Test isPathSafe with File objects
     *
     * @throws Exception
     */
    @Test

  private static final long SMALL_TIMEOUT_MILLIS = 10;

  /** How long to wait when determining that a thread is blocked if we expect it to be blocked. */
  private static final long EXPECTED_HANG_DELAY_MILLIS = 75;

  /**
   * How long to wait when determining that a thread is blocked if we DON'T expect it to be blocked.
   */
  private static final long UNEXPECTED_HANG_DELAY_MILLIS = 10000;

  /**

    @Test
    public void testClearBlacklist() throws Exception {
        validator.addToBlacklist("\\share\\blocked");
        validator.clearBlacklist();

        // Should allow previously blacklisted path
        String allowed = validator.validatePath("\\share\\blocked\\file.txt");
        assertEquals("\\share\\blocked\\file.txt", allowed);
    }

    @Test
    public void testClearWhitelist() throws Exception {

            }
            throw new RejectedExecutionException();
          }
        };
    SequentialExecutor executor = new SequentialExecutor(delegate);
    ExecutorService blocked = newCachedThreadPool();
    Future<?> first =
        blocked.submit(
            new Runnable() {
              @Override
              public void run() {
                executor.execute(Runnables.doNothing());
              }

            }
            throw new RejectedExecutionException();
          }
        };
    SequentialExecutor executor = new SequentialExecutor(delegate);
    ExecutorService blocked = newCachedThreadPool();
    Future<?> first =
        blocked.submit(
            new Runnable() {
              @Override
              public void run() {
                executor.execute(Runnables.doNothing());
              }

                        + "in this parallel build, those kind of mojos require exclusive access to "
                        + "reactor to prevent race conditions. This mojo execution will be blocked "
                        + "until the aggregator mojo is done.";
                warn(msg);
                acquiredAggregatorLock.lock();
            }
            if (!acquiredProjectLock.tryLock()) {