assertFalse(index.contains(".rebuild."), "Index should not contain .rebuild.: " + index);
        }
        // Verify reindex targets are original names (not .rebuild.xxx)
        for (final String[] pair : testClient.reindexPairs) {
            assertFalse(pair[1].contains(".rebuild."), "Reindex target should not contain .rebuild.: " + pair[1]);
        }
    }

    @Test

      shutdown.set(true);
      while (this.isAlive()) {
        Thread.yield();
      }
    }
  }

  void assertWrapsInterruptedException(RuntimeException e) {
    assertThat(e).hasMessageThat().contains("Unexpected interrupt");
    assertThat(e).hasCauseThat().isInstanceOf(InterruptedException.class);
  }

  public void testAwait_countDownLatch_interrupted() {

     *         If all functions return null, the composite function returns null.
     *
     * @throws NullPointerException if the input collection is null or contains null elements.
     */
    static UnaryOperator<String> chain(Collection<? extends UnaryOperator<String>> functions) {
        return s -> {
            for (UnaryOperator<String> function : functions) {

            Collections.addAll(idList, values);
            return idList;
        }

        /**
         * Returns a string representation of this Options object.
         * Contains all option values for debugging and logging purposes.
         *
         * @return string representation containing all option values
         */
        @Override
        public String toString() {

  }

  /**
   * A sensible implementation of {@link SortedMultiset#elementSet} in terms of the following
   * methods: {@link SortedMultiset#clear}, {@link SortedMultiset#comparator}, {@link
   * SortedMultiset#contains}, {@link SortedMultiset#containsAll}, {@link SortedMultiset#count},
   * {@link SortedMultiset#firstEntry} {@link SortedMultiset#headMultiset}, {@link

        TestCredentials creds = new TestCredentials("Z", false, false, new Subject(), true);
        CIFSException ex = assertThrows(CIFSException.class, creds::refresh);
        assertTrue(ex.getMessage().contains("refresh failed"));
    }

    @ParameterizedTest
    @MethodSource("domains")
    @DisplayName("getUserDomain handles null and empty")
    void getUserDomain_edges(String domain) {

                            Thread.sleep(1);
                            session.release();
                        }
                    }
                } catch (Exception e) {
                    if (!e.getMessage().contains("Usage count dropped below zero")) {
                        exceptions.add(e);
                    }
                } finally {
                    endLatch.countDown();
                }
            });

 * escaped in a general way.
 *
 * <p>A good example of usage of this class is for Java source code escaping where the replacement
 * array contains information about special ASCII characters such as {@code \\t} and {@code \\n}
 * while {@link #escapeUnsafe} is overridden to handle general escaping of the form {@code \\uxxxx}.
 *

      shutdown.set(true);
      while (this.isAlive()) {
        Thread.yield();
      }
    }
  }

  void assertWrapsInterruptedException(RuntimeException e) {
    assertThat(e).hasMessageThat().contains("Unexpected interrupt");
    assertThat(e).hasCauseThat().isInstanceOf(InterruptedException.class);
  }

  public void testAwait_countDownLatch_interrupted() {

		return nil, err
	}

	req, err := http.NewRequest(http.MethodPost, target.args.Endpoint.String(), bytes.NewReader(data))
	if err != nil {
		return nil, err
	}

	// Verify if the authToken already contains
	// <Key> <Token> like format, if this is
	// already present we can blindly use the
	// authToken as is instead of adding 'Bearer'
	tokens := strings.Fields(target.args.AuthToken)
	switch len(tokens) {
	case 2: