* @param name the name of the file
     * @return whether the given filename should be included
     * @throws SmbException if an SMB error occurs during evaluation
     */
    boolean accept(SmbFile dir, String name) throws SmbException;

        }
    }

    /**
     * Validates whether the credential type data is correct.
     * @return true if the credential type is valid, false otherwise
     */
    public boolean isCredentialTypeCorrect() {
        return this.credentialType != null && this.credentialType.length < MINIMAL_BUFFER_SIZE;
    }

    public void assembleModelInheritance(Model child, Model parent) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void assembleBuildInheritance(Build childBuild, Build parentBuild, boolean handleAsInheritance) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void copyModel(Model dest, Model source) {
        throw new UnsupportedOperationException();
    }

     */
    @Nonnull
    default String message() {
        return "";
    }

    /**
     * Some CI systems may allow running jobs in "debug" (or some equivalent) mode.
     */
    default boolean isVerbose() {
        return false;
    }

     * @param sessionId Session ID
     */
    void init(String sessionId);

    /**
     * Check if a given url is a target.
     *
     * @param url URL
     * @return true if url is matched
     */
    boolean match(String url);

    /**
     * Add an url pattern as a target.
     *
     * @param urlPattern Regular expression that is crawled
     */
    void addInclude(String urlPattern);

    /**

        char[] password2 = "testpassword".toCharArray();
        char[] password3 = "testpassworX".toCharArray();

        Boolean result1 = (Boolean) constantTimeMethod.invoke(null, password1, password2);
        Boolean result2 = (Boolean) constantTimeMethod.invoke(null, password1, password3);

        assertTrue(result1, "Identical passwords should be equal");

  public final void clear() {
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean isEmpty() {
    return size() == 0;
  }

  @Override
  public boolean containsKey(@Nullable Object key) {
    return get(key) != null;
  }

  @Override
  public boolean containsValue(@Nullable Object value) {
    return values().contains(value);
  }

   */
  public MonitorBasedArrayBlockingQueue(int capacity, boolean fair) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.items = newEArray(capacity);
    monitor = new Monitor(fair);
    notEmpty =
        new Monitor.Guard(monitor) {
          @Override
          public boolean isSatisfied() {
            return count > 0;
          }
        };
    notFull =

          {false, ElementOrder.stable()},
          {true, ElementOrder.stable()},
        });
  }

  private final boolean allowsSelfLoops;
  private final ElementOrder<Integer> incidentEdgeOrder;

  public StandardMutableUndirectedGraphTest(
      boolean allowsSelfLoops, ElementOrder<Integer> incidentEdgeOrder) {
    this.allowsSelfLoops = allowsSelfLoops;
    this.incidentEdgeOrder = incidentEdgeOrder;
  }

    this.delegateList = delegateList;
  }

  @Override
  E get(int index) {
    return delegateList.get(index);
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return delegate.contains(object);
  }

  @Override
  boolean isPartialView() {
    return false;
  }

  @Override
  public int size() {
    return delegateList.size();
  }