assertEquals("fess_suggest", testBuilder.settingsIndexName);
        assertNotNull(testBuilder.timeoutSettings);
        assertNotNull(testBuilder.initialSettings);
        assertTrue(testBuilder.initialSettings.isEmpty());
    }

    @Test
    public void testSetSettingsIndexName() {
        // Test setting index name with lowercase conversion
        SuggestSettingsBuilder result = builder.setSettingsIndexName("TEST_INDEX");

/** Returns an immutable copy of this. */
@Suppress("UNCHECKED_CAST")
internal fun <T> List<T>.toImmutableList(): List<T> =
  when {
    this.isEmpty() -> emptyList()
    this.size == 1 -> Collections.singletonList(this[0])
    // Collection.toArray returns Object[] (covariant).
    // It is faster than creating real T[] via reflection (Arrays.copyOf).

    List<Object> buf = new ArrayList<>();
    int elements = Queues.drain(q, buf, -1, MAX_VALUE, NANOSECONDS);
    assertEquals(0, elements);
    assertThat(buf).isEmpty();

    // Free the producer thread, and give subsequent tests a clean slate.
    q.take();
  }

  public void testDrain_throws() throws Exception {
    for (BlockingQueue<Object> q : blockingQueues()) {

			r, ok := dnsBuckets[bucket]
			if !ok {
				bucketsToBeUpdated.Add(bucket)
				continue
			}
			if !globalDomainIPs.Intersection(set.CreateStringSet(getHostsSlice(r)...)).IsEmpty() {
				if globalDomainIPs.Difference(set.CreateStringSet(getHostsSlice(r)...)).IsEmpty() && !domainMissing {
					// No difference in terms of domainIPs and nothing
					// has changed so we don't change anything on the etcd.
					//

        assertNotNull(stringRep);
        assertTrue(stringRep.contains("Smb2TransformHeader"));
        // toString() implementation may vary, just check it's not null and not empty
        assertFalse(stringRep.isEmpty());
    }

    @Test
    @DisplayName("Should generate correct associated data for AEAD")
    void testGetAssociatedData() {
        // Given
        transformHeader.setNonce(testNonce);

        this.columnNumber = location.getColumnNumber();
        this.source = location.getSource() != null ? new InputSource(location.getSource()) : null;
        this.locations = location.getLocations().isEmpty()
                ? null
                : location.getLocations().entrySet().stream()
                        .collect(Collectors.toMap(
                                e -> e.getKey(),

   * {@link ForwardingMultiset#clear}, {@link ForwardingMultiset#contains}, {@link
   * ForwardingMultiset#containsAll}, {@link ForwardingMultiset#count}, {@link
   * ForwardingMultiset#isEmpty}, the {@link Set#size} and {@link Set#iterator} methods of {@link
   * ForwardingMultiset#entrySet}, and {@link ForwardingMultiset#remove(Object, int)}. In many

      }
    } else {
      keys[dstIndex] = null;
      values[dstIndex] = null;
      entries[dstIndex] = 0;
    }
  }

  int firstEntryIndex() {
    return isEmpty() ? -1 : 0;
  }

  int getSuccessor(int entryIndex) {
    return (entryIndex + 1 < size) ? entryIndex + 1 : -1;
  }

  /**

    // TODO(kevinb): Support a concurrently modified collection?
    Iterable<E> iterable = getDelegate();
    if (iterable instanceof List) {
      List<E> list = (List<E>) iterable;
      if (list.isEmpty()) {
        return Optional.absent();
      }
      return Optional.of(list.get(list.size() - 1));
    }
    Iterator<E> iterator = iterable.iterator();
    if (!iterator.hasNext()) {

                    }
                    regex.append(c);
                }
            }

            // If pattern doesn't end with $, it implicitly matches anything after it
            if (pattern.isEmpty() || pattern.charAt(pattern.length() - 1) != '$') {
                // This makes "/fish" match "/fish", "/fishing", "/fish/", etc.
                // No need to add anything - the pattern naturally continues
            }