}

    void testIsOrdered() {
      assertTrue(ordering.isOrdered(strictlyOrderedList));
      assertTrue(ordering.isStrictlyOrdered(strictlyOrderedList));
    }

    // generic arrays and unchecked cast
    void testMinAndMax() {
      List<T> shuffledList = new ArrayList<>(strictlyOrderedList);
      shuffledList = shuffledCopy(shuffledList, new Random(5));

      T min = strictlyOrderedList.get(0);

              }
            }
          }
        }

        @Override
        public int read(byte[] buf, int off, int len) throws IOException {
          // Overriding this to work around the fact that InputStream's default implementation of
          // this method will silently swallow exceptions thrown by the single-byte read() method

    public static final String CONSTRAINTS_Null_MESSAGE = "{constraints.Null.message}";

    /** The key of the message: {item} must be a past value. */
    public static final String CONSTRAINTS_Past_MESSAGE = "{constraints.Past.message}";

    /** The key of the message: {item} does not match "{regexp}". */
    public static final String CONSTRAINTS_Pattern_MESSAGE = "{constraints.Pattern.message}";

                 * SmbFile.resolveDfs can re-insert the dr list with
                 * the dr that was successful so that subsequent
                 * attempts to resolve DFS use the last successful
                 * referral first.
                 */
                tmp.setCacheMap(links.map);
                tmp.setKey("\\");
                tmp = tmp.next();
            } while (tmp != dr);

    writeMedium(frame, 8) // Without debug data there's only 2 32-bit fields.
    frame.writeByte(TYPE_GOAWAY)
    frame.writeByte(FLAG_NONE)
    frame.writeInt(0) // connection-scope
    frame.writeInt(expectedStreamId) // last good stream.
    frame.writeInt(expectedError.httpCode)

    // Check writer sends the same bytes.
    assertThat(sendGoAway(expectedStreamId, expectedError, EMPTY_BYTE_ARRAY))
      .isEqualTo(frame)

    checkArgument(
        bytes.length == 4,
        "Byte array has invalid length for an IPv4 address: %s != 4.",
        bytes.length);

    // Given a 4-byte array, this cast should always succeed.
    return (Inet4Address) bytesToInetAddress(bytes, null);
  }

  /**
   * Returns the {@link InetAddress} having the given string representation.
   *

    if (generated != null) {
      freshness.incrementAndGet();
    }
    return generated;
  }

  final <T> @Nullable T generateFresh(Class<T> type) {
    return Primitives.wrap(type).cast(generateFresh(TypeToken.of(type)));
  }

  final <T> T newFreshProxy(Class<T> interfaceType) {
    T proxy = newProxy(interfaceType);
    freshness.incrementAndGet();
    return proxy;
  }

  /**

        }
        return toReturn;
      }

      @GuardedBy("lock")
      /*
       * The GuardedBy checker warns us that we're not holding cancellationDelegate.lock. But in
       * fact we are holding it because it is the same as this.lock, which we know we are holding,
       * thanks to @GuardedBy above. (cancellationDelegate.lock is initialized to this.lock in the
       * call to `new SupplantableFuture` below.)

    --hash=sha256:255538574d6cb6d0a79a17ec8bc0d30985913b87513a01cce8bcdb6b4c44d0e2 \
    --hash=sha256:676f9fa62750bb50cf531b42a0a2a118ad8f7f797a511eda12881c016f093b12
    # via -r ci/official/requirements_updater/requirements.in
gast==0.4.0 \
    --hash=sha256:40feb7b8b8434785585ab224d1568b857edb18297e5a3047f1ba012bc83b42c1 \
    --hash=sha256:b7adcdd5adbebf1adf17378da5ba3f543684dbec47b1cda1f3997e573cd542c4

  }

  @Test
  fun recoverFromCancelReusesConnection() {
    val responseDequeuedLatches =
      listOf(
        // No synchronization for the last request, which is not canceled:
        CountDownLatch(1),
        CountDownLatch(0),
      )
    val requestCanceledLatches =
      listOf(
        CountDownLatch(1),
        CountDownLatch(0),