.prepareGetMappings(actualIndex)
                        .execute()
                        .actionGet(settings.getIndicesTimeout())
                        .getMappings()
                        .isEmpty();
            } catch (final IndexNotFoundException e) {
                empty = true;
                final CreateIndexResponse response = client.admin()
                        .indices()

  }

  private static <E> ImmutableSortedMultiset<E> copyOfSortedEntries(
      Comparator<? super E> comparator, Collection<Entry<E>> entries) {
    if (entries.isEmpty()) {
      return emptyMultiset(comparator);
    }
    ImmutableList.Builder<E> elementsBuilder = new ImmutableList.Builder<>(entries.size());
    long[] cumulativeCounts = new long[entries.size() + 1];
    int i = 0;

            list.subList(0, size - 1),
            list.subList(1, size),
            list.subList(0, 0),
            list.subList(size, size))) {
      assertEquals(subList.size() == 0, subList.isEmpty());
    }
  }

  @CollectionSize.Require(absent = {ZERO, ONE})
  public void testSubList_get() {
    List<E> list = getList();
    int size = getNumElements();
    List<E> copy = list.subList(0, size);

   * @since 10.0
   */
  public static <R, C, V> Table<R, C, V> newCustomTable(
      Map<R, Map<C, V>> backingMap, Supplier<? extends Map<C, V>> factory) {
    checkArgument(backingMap.isEmpty());
    checkNotNull(factory);
    // TODO(jlevy): Wrap factory to validate that the supplied maps are empty?
    return new StandardTable<>(backingMap, factory);
  }

  /**

    
    public void invalidateHierarchy(String path) {
        // Invalidate all parent directories up to root
        String currentPath = path;
        while (currentPath != null && !currentPath.isEmpty()) {
            DirectoryCacheEntry entry = leaseManager.getCacheEntry(currentPath);
            if (entry != null) {
                entry.invalidate();
            }

                if (docId != null && docId.toString().length() > 0) {
                    docIdList.add(docId.toString());
                }
            }

            if (!docIdList.isEmpty()) {
                final Map<String, String[]> resultDocIdsCache = getResultDocIdsCache(session);
                resultDocIdsCache.put(queryId, docIdList.toArray(new String[docIdList.size()]));
            }
        });

        // Check resolver order
        assertNotNull(testConfig.getResolveOrder());
        assertFalse(testConfig.getResolveOrder().isEmpty());

        // Check protocol versions
        assertNotNull(testConfig.getMinimumVersion());
        assertNotNull(testConfig.getMaximumVersion());

        // Check disallow compound

                }
            });
        }

        startLatch.countDown();
        endLatch.await(10, TimeUnit.SECONDS);
        executor.shutdown();

        assertTrue(exceptions.isEmpty());
        // Final name should be from one of the threads
        assertNotNull(testTransformer.getName());
        assertTrue(testTransformer.getName().startsWith("thread"));
    }

    /**

                    }
                }
                bufferedList.clear();
            }
        });
        if (!bufferedList.isEmpty()) {
            final BulkResponse response = doInsertAll(bufferedList, opType);
            if (response.hasFailures()) {
                final String failureMessage = buildFailureMessage(response, ignoreAlreadyExists);

  }

  /**
   * Returns {@code true} if the given string is null or is the empty string.
   *
   * <p>Consider normalizing your string references with {@link #nullToEmpty}. If you do, you can
   * use {@link String#isEmpty()} instead of this method, and you won't need special null-safe forms
   * of methods like {@link String#toUpperCase} either. Or, if you'd like to normalize "in the other