errors.could_not_delete_logged_in_user=Não é possível excluir o usuário logado.
errors.unauthorized_request=Solicitação não autorizada.
errors.failed_to_print_thread_dump=Não foi possível imprimir o despejo de threads.
errors.file_is_not_supported={0} não é suportado.
errors.plugin_file_is_not_found={0} não encontrado.
errors.failed_to_install_plugin=Não foi possível instalar {0}.

        cli.initialize(request);
        cli.cli(request);
        assertEquals("multithreaded", request.commandLine.getOptionValue(CLIManager.BUILDER));
        assertEquals("8", request.commandLine.getOptionValue(CLIManager.THREADS));

        // override from command line
        request = new CliRequest(new String[] {"--builder", "foobar"}, null);
        cli.cli(request);

 * ExecutionException} or {@link UncheckedExecutionException}. This allows the client code to
 * continue to distinguish between exceptions and errors, even when they come from other threads.
 *
 * @author Chris Povirk
 * @since 10.0
 */
@GwtCompatible
public class ExecutionError extends Error {
  /*
   * Ideally, this class would have exposed only constructors that require a non-null cause. See

    /** Configuration ID */
    public String id;

    /** Configuration name */
    public String name;

    /** File system paths to crawl */
    public String paths;

    /** Number of threads for crawling */
    public String numOfThread;

    /** Interval time between crawling operations */
    public String intervalTime;

    /** Boost value for search ranking */
    public String boost;

   *
   * Note about volatile: volatile doesn't make it safe to read from a mutable graph in one thread
   * while writing to it in another. All it does is help with _reading_ from multiple threads
   * concurrently. For more information, see AbstractNetworkTest.concurrentIteration.
   */
  private transient volatile @Nullable Entry<K, V> cacheEntry;

  MapIteratorCache(Map<K, V> backingMap) {

 * ExecutionException} or {@link UncheckedExecutionException}. This allows the client code to
 * continue to distinguish between exceptions and errors, even when they come from other threads.
 *
 * @author Chris Povirk
 * @since 10.0
 */
@GwtCompatible
public class ExecutionError extends Error {
  /*
   * Ideally, this class would have exposed only constructors that require a non-null cause. See

        crawlerThread.run();

        verify(intervalController, times(1)).delay(IntervalController.NO_URL_IN_QUEUE);
    }

    /**
     * Test isContinue with active threads still running.
     */
    public void test_isContinue_withActiveThreads() throws Exception {
        crawlerContext.setActiveThreadCount(2);

        // Use reflection to access protected method

    @Min(value = 0)
    @Max(value = 9223372036854775807L)
    @ValidateTypeFailure
    public Long maxAccessCount;

    /** The number of threads to use for crawling (required, 1 to 2147483647). */
    @Required
    @Min(value = 1)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer numOfThread;

              task.run();
              awaitUnchecked(barrier);
            }
          };
      for (int j = 0; j < 10; j++) {
        executor.execute(wrapper);
      }
      barrier.await(); // release the threads!
      barrier.await(); // wait for them all to complete
      assertEquals(1, task.get().intValue());
      assertEquals(1, counter.get());
    }
    executor.shutdown();
  }

  @J2ktIncompatible

    /**
     * The user agent string to use during crawling.
     */
    @Required
    @Size(max = 200)
    public String userAgent;

    /**
     * The number of crawler threads to use.
     */
    @Required
    @Min(value = 1)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer numOfThread;

    /**