* sequences, but encoding never reproduces these. Such byte sequences are <i>not</i> considered
   * well-formed.
   *
   * <p>This method returns {@code true} if and only if {@code Arrays.equals(bytes, new
   * String(bytes, UTF_8).getBytes(UTF_8))} does, but is more efficient in both time and space.
   */
  public static boolean isWellFormed(byte[] bytes) {

            }
          }
        };

    // The first time, the sneakily-thrown exception comes out
    assertThrows(SomeCheckedException.class, iter::hasNext);
    // But the second time, AbstractIterator itself throws an ISE
    assertThrows(IllegalStateException.class, iter::hasNext);
  }

  public void testException() {
    SomeUncheckedException exception = new SomeUncheckedException();

 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *

        writeLittleEndianLong(baos, 1000); // offset way out of bounds
        byte[] pacData = baos.toByteArray();

        // This currently throws ArrayIndexOutOfBoundsException
        // but should be wrapped in PACDecodingException
        assertThrows(Exception.class, () -> new Pac(pacData, keys));
    }

    @Test
    void testZeroBufferCount() throws IOException {

   *
   * QUIC is not natively supported by OkHttp, but provided to allow a theoretical interceptor that
   * provides support.
   */
  QUIC("quic"),

  /**
   * HTTP/3 is the third and upcoming major version of the Hypertext Transfer Protocol used to
   * exchange information. HTTP/3 runs over QUIC, which is published as RFC 9000.
   *
   * HTTP/3 is not natively supported by OkHttp, but provided to allow a theoretical interceptor

    }
  }

/** If we fail to parse a date in a non-standard format, try each of these formats in sequence. */
private val BROWSER_COMPATIBLE_DATE_FORMAT_STRINGS =
  arrayOf(
    // HTTP formats required by RFC2616 but with any timezone:
    // RFC 822, updated by RFC 1123 with any TZ.
    "EEE, dd MMM yyyy HH:mm:ss zzz",
    // RFC 850, obsoleted by RFC 1036 with any TZ.
    "EEEE, dd-MMM-yy HH:mm:ss zzz",
    // ANSI C's asctime() format

 * {@code SerializableTester} calls with other, GWT-compatible tests.
 *
 * @author Mike Bostock
 * @since 10.0
 */
@GwtCompatible // but no-op!
@NullMarked
public final class SerializableTester {
  private SerializableTester() {}

  /**
   * Serializes and deserializes the specified object.
   *

      }
      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }
    if (userPassedSupplier) {
      throw new AssertionError(
          "expected to throw "
              + expectedThrowable.getSimpleName()
              + " but returned result: "
              + result);
    } else {

   * Returns a fixed-size list backed by the specified array, similar to {@link
   * Arrays#asList(Object[])}. The list supports {@link List#set(int, Object)}, but any attempt to
   * set a value to {@code null} will result in a {@link NullPointerException}.
   *
   * <p>The returned list maintains the values, but not the identities, of {@code Long} objects
   * written to or read from it. For example, whether {@code list.get(0) == list.get(0)} is true for

   * to reduce cache contention on most processors. Padding is
   * overkill for most Atomics because they are usually irregularly
   * scattered in memory and thus don't interfere much with each
   * other. But Atomic objects residing in arrays will tend to be
   * placed adjacent to each other, and so will most often share
   * cache lines (with a huge negative performance impact) without
   * this precaution.
   *