if (delegate != null) {
      metadata =
          Ints.constrainToRange(size(), CompactHashing.DEFAULT_SIZE, CompactHashing.MAX_SIZE);
      delegate.clear(); // invalidate any iterators left over!
      table = null;
      size = 0;
    } else {
      Arrays.fill(requireKeys(), 0, size, null);
      Arrays.fill(requireValues(), 0, size, null);
      CompactHashing.tableClear(requireTable());

   * {@code IllegalStateException} if this queue is full.
   *
   * @param e the element to add
   * @return {@code true} (as specified by {@link Collection#add})
   * @throws IllegalStateException if this queue is full
   * @throws NullPointerException if the specified element is null
   */
  @CanIgnoreReturnValue
  @Override
  public boolean add(E e) {
    return super.add(e);

        super(formatMessage(errorCode, message), cause);
        this.errorCode = errorCode;
        this.originalMessage = message;
        this.retryPolicy = retryPolicy != null ? retryPolicy : RetryPolicy.DEFAULT;
        this.context = context != null ? new HashMap<>(context) : new HashMap<>();
        this.operationStartTime = System.currentTimeMillis();
        this.operationName = extractOperationName();
        this.attemptNumber = 1;

        assertNotNull(generator);
    }

    @Test
    public void test_getName() {
        // Test getName and setName methods
        generator = new TestThumbnailGenerator();

        // Default name should be null
        assertNull(generator.getName());

        // Set and get name
        generator.setName("test-generator");
        assertEquals("test-generator", generator.getName());

        // Change name

      TesterRequirements requirements = classTesterRequirementsCache.get(testerClass);
      if (requirements == null) {
        requirements = buildTesterRequirements(testerClass);
        classTesterRequirementsCache.put(testerClass, requirements);
      }
      return requirements;
    }
  }

  /**
   * Get the full set of requirements for a tester class.
   *
   * @param testerMethod a test method of a tester class

 * a handle after network failures or server reboots.
 */
public class HandleInfo implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * The full path to the file or directory associated with this handle
     */
    private final String path;

    /**
     * The create GUID used to uniquely identify this handle for reconnection
     */

    /**
     * Returns the full uncanonicalized URL of this SMB resource. An
     * <code>SmbFile</code> constructed with the result of this method will
     * result in an <code>SmbFile</code> that is equal to the original.
     *
     * @return The uncanonicalized full URL of this SMB resource.
     */

    String getPath();

    /**
     * Returns the full URL of this SMB resource with '.' and '..' components

    @Optional
    public FileCollection getNoticeFiles() {
        FileTree tree = null;
        for (File dir : licensesDirs) {
            if (tree == null) {
                tree = getProject().fileTree(dir);
            } else {
                tree = tree.plus(getProject().fileTree(dir));
            }
        }
        return tree == null ? null : tree.matching(patternFilterable -> patternFilterable.include("**/*-NOTICE.txt"));

  /** Initialized in [callStart]. */
  private var callStackTrace: Any? = null

  /** Finds an exchange to send the next request and receive the next response. */
  private var exchangeFinder: ExchangeFinder? = null

  var connection: RealConnection? = null
    private set
  private var timeoutEarlyExit = false

  /**

  volatile @Nullable Set<Throwable> seenExceptionsField = null;

  volatile int remainingField;

  private static final AtomicHelper ATOMIC_HELPER;

  private static final LazyLogger log = new LazyLogger(AggregateFutureState.class);

  static {
    AtomicHelper helper;
    Throwable thrownReflectionFailure = null;
    try {
      helper = new SafeAtomicHelper();