*
   * <p>Traversers created using this method are guaranteed to visit each node reachable from the
   * start node(s) at most once.
   *
   * <p>If you know that no node in {@code graph} is reachable by more than one path from the start
   * node(s), consider using {@link #forTree(SuccessorsFunction)} instead.
   *
   * <p><b>Performance notes</b>
   *
   * <ul>

      pluginManager.withPlugin("elasticsearch.testclusters") {
        afterEvaluate {
          // This afterEvaluate hooks is required to avoid deprecated configuration resolution
          // This configuration can be removed once system modules are available
          def extraFipsJars = configurations.detachedConfiguration(bcFips, bcTlsFips)
          testClusters.configureEach {
            extraFipsJars.files.each {
              extraJarFile it

    /**
     * Sets the URL stream handler factory for the environment.  This
     * allows specification of the factory used in creating underlying
     * stream handlers.  This can be called once per JVM instance.
     *
     * @param factory The URL stream handler factory.
     */
    public static void setURLStreamHandlerFactory(final URLStreamHandlerFactory factory) {
        synchronized (PROTOCOL_HANDLERS) {

        assertEquals("Domain Users", s2.getAccountName());
        assertEquals("TESTDOM", s2.getDomainName());
        assertEquals(jcifs.SID.SID_TYPE_DOM_GRP, s2.getType());

        // Interaction: sendrecv invoked exactly once
        verify(handle, times(1)).sendrecv(any(jcifs.dcerpc.msrpc.MsrpcLookupSids.class));
    }

    @ParameterizedTest
    @ValueSource(ints = { NtStatus.NT_STATUS_SUCCESS, NtStatus.NT_STATUS_NONE_MAPPED, 0x00000107 })

    int originalSize = collection.size();
    Iterator<E> iterator = collection.iterator();
    Object element = iterator.next();
    // If it's an Entry, it may become invalid once it's removed from the Map. Copy it.
    if (element instanceof Entry) {
      Entry<?, ?> entry = (Entry<?, ?>) element;
      element = mapEntry(entry.getKey(), entry.getValue());
    }

    void constructorAndSimpleDelegations() {
        // Ensures constructor acquires tree connection and simple delegate methods forward correctly
        // Verify constructor invoked acquire once
        verify(treeConnection, times(1)).acquire();

        // getConfig delegates
        when(treeConnection.getConfig()).thenReturn(config);
        assertSame(config, handle.getConfig());

import java.math.BigInteger
import okio.Buffer
import okio.BufferedSink
import okio.ByteString

internal class DerWriter(
  sink: BufferedSink,
) {
  /** A stack of buffers that will be concatenated once we know the length of each. */
  private val stack = mutableListOf(sink)

  /** Type hints scoped to the call stack, manipulated with [pushTypeHint] and [popTypeHint]. */
  private val typeHintStack = mutableListOf<Any?>()

   * returns a {@link SortedSet}, instead of the {@link Collection} specified in the {@link
   * Multimap} interface.
   *
   * <p>Any duplicates in {@code values} will be stored in the multimap once.
   */
  @CanIgnoreReturnValue
  @Override
  public SortedSet<V> replaceValues(@ParametricNullness K key, Iterable<? extends V> values) {
    return (SortedSet<V>) super.replaceValues(key, values);
  }

 *       have, of returning a new, independent iterator
 * </ul>
 *
 * <p>Because of this situation, any public method accepting an iterable should invoke the {@code
 * iterator} method only once, and should be tested using this class. Exceptions to this rule should
 * be clearly documented.
 *
 * <p>Note that although your APIs should be liberal in what they accept, your methods which

  @CanIgnoreReturnValue
  public CharEscaperBuilder addEscape(char c, String r) {
    map.put(c, checkNotNull(r));
    if (c > max) {
      max = c;
    }
    return this;
  }

  /** Add multiple mappings at once for a particular index. */
  @CanIgnoreReturnValue
  public CharEscaperBuilder addEscapes(char[] cs, String r) {
    checkNotNull(r);
    for (char c : cs) {
      addEscape(c, r);
    }
    return this;
  }