}

    @Override
    final boolean isDone() {
      return TrustedListenableFutureTask.this.isDone();
    }

    @Override
    @ParametricNullness
    V runInterruptibly() throws Exception {
      return callable.call();
    }

    @Override
    void afterRanInterruptiblySuccess(@ParametricNullness V result) {
      TrustedListenableFutureTask.this.set(result);
    }

            assertEquals(443, Handler.DEFAULT_HTTPS_PORT);
        }

        @Test
        @DisplayName("DEFAULT_HTTPS_PORT should be public static final")
        void testDefaultHttpsPortModifiers() throws NoSuchFieldException {
            // When
            var field = Handler.class.getField("DEFAULT_HTTPS_PORT");

            // Then
            assertTrue(Modifier.isPublic(field.getModifiers()));

            for (long i = 0; i < LIMIT; i++) {
                ords.add(0, i % DISTINCT_VALUES);
            }
            if (ords.size() != DISTINCT_VALUES) {
                throw new IllegalArgumentException("Expected [" + DISTINCT_VALUES + "] but found [" + ords.size() + "]");
            }
            bh.consume(ords);
        }
    }

    /**

     * @param keys the Kerberos keys for decryption
     * @return a list of parsed authorization data
     * @throws PACDecodingException if the data cannot be decoded
     */
    public static List<KerberosAuthData> parse(int authType, byte[] token, Map<Integer, KerberosKey> keys) throws PACDecodingException {

        List<KerberosAuthData> authorizations = new ArrayList<>();

        switch (authType) {

                NullPointerException.class, () -> new UrlSource(null), "Should fail, since you must specify a url");
        assertEquals("url cannot be null", e.getMessage());
    }

    @Test
    void testGetInputStream() throws Exception {
        URL txtFile = new File("target/test-classes/source.txt").toURI().toURL();
        UrlSource source = new UrlSource(txtFile);
        try (InputStream is = source.getInputStream();

    ProxyInfo getProxy(String protocol);

    void getArtifact(Artifact artifact, ArtifactRepository repository)
            throws TransferFailedException, ResourceDoesNotExistException;

    void getArtifact(Artifact artifact, List<ArtifactRepository> remoteRepositories)
            throws TransferFailedException, ResourceDoesNotExistException;

    ArtifactRepository getMirrorRepository(ArtifactRepository repository);

  static {
    try {
      DELEGATE_METHOD = ForwardingObject.class.getDeclaredMethod("delegate");
      DELEGATE_METHOD.setAccessible(true);
    } catch (SecurityException e) {
      throw new RuntimeException(e);
    } catch (NoSuchMethodException e) {
      throw new AssertionError(e);
    }
  }

  /**
   * Ensures that all interface methods of {@code forwarderClass} are forwarded to the {@link

  static {
    try {
      DELEGATE_METHOD = ForwardingObject.class.getDeclaredMethod("delegate");
      DELEGATE_METHOD.setAccessible(true);
    } catch (SecurityException e) {
      throw new RuntimeException(e);
    } catch (NoSuchMethodException e) {
      throw new AssertionError(e);
    }
  }

  /**
   * Ensures that all interface methods of {@code forwarderClass} are forwarded to the {@link

                }
                throw new CommandExecutionException("The command execution is timeout for user: " + username);
            }
            return exitValue;
        } catch (final CrawlerSystemException e) {
            throw e;
        } catch (final InterruptedException e) {
            if (mt != null && mt.isTeminated()) {

    public void formatProgress(StringBuilder builder, long progressedSize, long size) {
        if (progressedSize < 0L) {
            throw new IllegalArgumentException("progressed file size cannot be negative: " + size);
        }
        if (size >= 0 && progressedSize > size) {
            throw new IllegalArgumentException(
                    "progressed file size cannot be greater than size: " + progressedSize + " > " + size);
        }