* Evaluates whether the argument is an ISATAP address.
   *
   * <p>From RFC 5214: "ISATAP interface identifiers are constructed in Modified EUI-64 format [...]
   * by concatenating the 24-bit IANA OUI (00-00-5E), the 8-bit hexadecimal value 0xFE, and a 32-bit
   * IPv4 address in network byte order [...]"
   *
   * <p>For more on ISATAP addresses see section 6.1 of <a target="_parent"

   */
  static boolean usingFastPath() {
    return byteArray.usesFastPath();
  }

  /**
   * Common interface for retrieving a 64-bit long from a little-endian byte array.
   *
   * <p>This abstraction allows us to use single-instruction load and put when available, or fall
   * back on the slower approach of using Longs.fromBytes(byte...).
   */

    assertFailsWith<IllegalArgumentException> {
      var streamId = 3
      streamId = streamId or (1L shl 31).toInt() // set reserved bit
      writer.frameHeader(streamId, Http2.INITIAL_MAX_FRAME_SIZE, Http2.TYPE_DATA, FLAG_NONE)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("reserved bit set: -2147483645")
    }
  }

  private fun literalHeaders(sentHeaders: List<Header>): Buffer {
    val out = Buffer()

      assertFalse(
          "Inverse should not contain value " + reversed.getValue(),
          inv.containsValue(reversed.getValue()));
      /*
       * TODO(cpovirk): This is a bit stronger than super.expectMissing(), which permits a <key,
       * someOtherValue> pair.
       */
      assertNull(
          "Inverse should not return a mapping for key " + reversed.getKey(),

   *
   * <p>For the case of {@link RoundingMode#HALF_EVEN}, this implementation uses the IEEE 754
   * default rounding mode: if the two nearest representable values are equally near, the one with
   * the least significant bit zero is chosen. (In such cases, both of the nearest representable
   * values are even integers; this method returns the one that is a multiple of a greater power of
   * two.)
   *

import java.nio.file.attribute.PosixFileAttributes;
import java.util.Arrays;
import org.jspecify.annotations.NullUnmarked;

/**
 * Unit tests for {@link FileBackedOutputStream}.
 *
 * <p>For a tiny bit more testing, see {@link FileBackedOutputStreamAndroidIncompatibleTest}.
 *
 * @author Chris Nokleberg
 */
@NullUnmarked
public class FileBackedOutputStreamTest extends IoTestCase {

        assertThrows(IllegalArgumentException.class, () -> new PercentEscaper(" ", true));
    assertThat(expected).hasMessageThat().isEqualTo(msg);
  }

  /** Helper to manually escape a 7-bit ascii character */
  private String escapeAscii(char c) {
    Preconditions.checkArgument(c < 128);
    String hex = "0123456789ABCDEF";
    return "%" + hex.charAt((c >> 4) & 0xf) + hex.charAt(c & 0xf);
  }

import com.google.common.primitives.UnsignedInts;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.io.Serializable;
import org.jspecify.annotations.Nullable;

/**
 * An immutable hash code of arbitrary bit length.
 *
 * @author Dimitris Andreou
 * @author Kurt Alfred Kluever
 * @since 11.0
 */
public abstract class HashCode {
  HashCode() {}

      return array.length;
    }
  }

  /**
   * Implementation of Striped where up to 2^k stripes can be represented, using an
   * AtomicReferenceArray of size 2^k. To map a user key into a stripe, we take a k-bit slice of the
   * user key's (smeared) hashCode(). The stripes are lazily initialized and are weakly referenced.
   */
  @VisibleForTesting
  static final class SmallLazyStriped<L> extends PowerOfTwoStriped<L> {

  @CanIgnoreReturnValue
  PrimitiveSink putBoolean(boolean b);

  /** Puts a character into this sink. */
  @CanIgnoreReturnValue
  PrimitiveSink putChar(char c);

  /**
   * Puts each 16-bit code unit from the {@link CharSequence} into this sink.
   *
   * <p><b>Warning:</b> This method will produce different output than most other languages do when