}
      }
      int undrainedIndex = reads.size() - segment.recencyQueue.size();
      checkAndDrainRecencyQueue(map, segment, reads.subList(undrainedIndex, reads.size()));
      readOrder.addAll(reads);

      checkEvictionQueues(map, segment, readOrder, writeOrder);
      checkExpirationTimes(map);
    }
  }

  public void testComputeExistingEntry() throws ExecutionException {

        }
      }
      int undrainedIndex = reads.size() - segment.recencyQueue.size();
      checkAndDrainRecencyQueue(map, segment, reads.subList(undrainedIndex, reads.size()));
      readOrder.addAll(reads);

      checkEvictionQueues(map, segment, readOrder, writeOrder);
      checkExpirationTimes(map);
    }
  }

  public void testComputeExistingEntry() throws ExecutionException {

    assertEquals(nestingDepth, Iterators.size(iterator));
  }

  public void testAddAllWithEmptyIterator() {
    List<String> alreadyThere = Lists.newArrayList("already", "there");

    boolean changed = Iterators.addAll(alreadyThere, Iterators.<String>emptyIterator());
    assertThat(alreadyThere).containsExactly("already", "there").inOrder();
    assertFalse(changed);
  }

  public void testAddAllToList() {

                    } catch (final Exception e) {
                        throw new OpenSearchAccessException("Failed to delete " + urlQueueList, e);
                    }

                    waitingQueue.addAll(urlQueueList);
                    urlQueue = waitingQueue.poll();
                    if (urlQueue == null) {
                        return null;
                    }
                }
            }

  /**
   * Returns a set of all row key / column key / value triplets. Changes to the returned set will
   * update the underlying table, and vice versa. The cell set does not support the {@code add} or
   * {@code addAll} methods.
   *
   * @return set of table cells consisting of row key / column key / value triplets
   */
  Set<Cell<R, C, V>> cellSet();

  /**

        put(entry.getKey(), entry.getValue());
      }
      return this;
    }

    @CanIgnoreReturnValue
    Builder<K, V> combine(Builder<K, V> builder) {
      entries.addAll(builder.entries);
      return this;
    }

    /**
     * Returns an {@code ImmutableRangeMap} containing the associations previously added to this
     * builder.
     *

    NamedObject(String name) {
      this.name = Preconditions.checkNotNull(name);
    }

    @CanIgnoreReturnValue
    NamedObject addPeers(String... names) {
      peerNames.addAll(ImmutableList.copyOf(names));
      return this;
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      if (obj instanceof NamedObject) {
        NamedObject that = (NamedObject) obj;

   */
  @CanIgnoreReturnValue
  public static <T extends @Nullable Object> boolean addAll(
      Collection<T> addTo, Iterable<? extends T> elementsToAdd) {
    if (elementsToAdd instanceof Collection) {
      Collection<? extends T> c = (Collection<? extends T>) elementsToAdd;
      return addTo.addAll(c);
    }
    return Iterators.addAll(addTo, checkNotNull(elementsToAdd).iterator());
  }

  /**

                        calculateLifecycleMappings(session, project, lifecyclePhase);

                for (List<MojoExecution> mojoExecutionsFromLifecycle : phaseToMojoMapping.values()) {
                    mojoExecutions.addAll(mojoExecutionsFromLifecycle);
                }
            } else {
                throw new IllegalStateException("unexpected task " + task);
            }
        }
        return mojoExecutions;
    }

            if (logger.isDebugEnabled()) {
                logger.debug("Failed to access storage endpoint: {}", fessConfig.getStorageEndpoint(), e);
            }
        }

        list.addAll(fileList);
        return list;
    }

    /**
     * Extracts the file name from a full object path.
     *
     * @param objectName the full object path
     * @return the file name portion of the path