b2bit8 && b3bit8 -> 127
          b3bit8 -> 126
          b2bit8 -> 125
          else -> 124
        }
      }

    val b2: Int
      get() = mappedTo[0] and 0x7f

    val b3: Int
      get() = mappedTo[1] and 0x7f
  }

  data class InlineDelta(
    override val rangeStart: Int,
    val codepointDelta: Int,
  ) : MappedRange {
    private val absoluteDelta = abs(codepointDelta)

        // Little-endian 0x12345678 -> 0x78 0x56 0x34 0x12
        byte[] data = new byte[] { 0x78, 0x56, 0x34, 0x12 };
        PacDataInputStream pdis = createInputStream(data);
        assertEquals(0x12345678, pdis.readInt());
    }

    @Test
    public void testReadLong() throws IOException {
        // Little-endian 0x123456789ABCDEF0 -> 0xF0 0xDE 0xBC 0x9A 0x78 0x56 0x34 0x12

class HexdumpTest extends BaseTest {

    @Test
    @DisplayName("Should convert byte array to hex string")
    void testToHexString() {
        // Given
        byte[] data = { 0x00, 0x0F, (byte) 0xFF, 0x7F, (byte) 0x80 };

        // When
        String result = Hexdump.toHexString(data);

        // Then
        assertNotNull(result);
        assertEquals("000FFF7F80", result);
    }

    @Test

                    throw new EOFException("EOF found inside tag value.");
                }
                throw new IOException("corrupted stream - high tag number < 31 found");
            }

            tagNo = b & 0x7f;

            // X.690-0207 8.1.2.4.2
            // "c) bits 7 to 1 of the first subsequent octet shall not all be zero."
            if (0 == tagNo) {

    sectionIndexBuffer.writeByte((section and 0x3f80) shr 7)

    // Section index.
    sectionIndexBuffer.writeByte((sectionOffset and 0x3f80) shr 7)
    sectionIndexBuffer.writeByte(sectionOffset and 0x7f)

    // Ranges.
    for (range in sectionMappedRanges) {
      rangesBuffer.writeByte(range.rangeStart)

      when (range) {
        is MappedRange.Constant -> {
          rangesBuffer.writeByte(range.b1)

      // Encode '+' as '%2B' since we permit ' ' to be encoded as either '+' or '%20'.
      writeUtf8(if (alreadyEncoded) "+" else "%2B")
    } else if (codePoint < 0x20 ||
      codePoint == 0x7f ||
      codePoint >= 0x80 &&
      !unicodeAllowed ||
      codePoint.toChar() in encodeSet ||
      codePoint == '%'.code &&
      (!alreadyEncoded || strict && !input.isPercentEncoded(i, limit))
    ) {

      i++;
    }

    // This loop optimizes for chars less than 0x800.
    for (; i < utf16Length; i++) {
      char c = sequence.charAt(i);
      if (c < 0x800) {
        utf8Length += (0x7f - c) >>> 31; // branch free!
      } else {
        utf8Length += encodedLengthGeneral(sequence, i);
        break;
      }
    }

    if (utf8Length < utf16Length) {

        @Test
        @DisplayName("Various byte values are converted to uppercase hex")
        void testHexConversion() {
            byte[] challenge = new byte[] { (byte) 0x00, (byte) 0x0F, (byte) 0x10, (byte) 0x7F, (byte) 0x80, (byte) 0xFF };
            UniAddress dc = mock(UniAddress.class);
            when(dc.toString()).thenReturn("DC");

            NtlmChallenge nc = new NtlmChallenge(challenge, dc);

                Arguments.of(0x12345678, new byte[] { 0x78, 0x56, 0x34, 0x12 }),
                Arguments.of(0xFFFFFFFF, new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF }),
                Arguments.of(0x7FFFFFFF, new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0x7F }));
    }

    @ParameterizedTest
    @MethodSource("int32Provider")

    // Confirm the data strings are ASCII.
    for (dataString in listOf<String>(compactTable.sections, compactTable.ranges)) {
      for (codePoint in dataString.codePoints()) {
        assertThat(codePoint and 0x7f).isEqualTo(codePoint)
      }
    }

    // Confirm the sections are increasing.
    val rangesIndices = mutableListOf<Int>()
    val rangesOffsets = mutableListOf<Int>()