val sourceCodePoint1: Int,
  val type: Int,
  val mappedTo: ByteString,
) {
  val section: Int
    get() = sourceCodePoint0 and 0x1fff80

  val rangeStart: Int
    get() = sourceCodePoint0 and 0x7f

  val hasSingleSourceCodePoint: Boolean
    get() = sourceCodePoint0 == sourceCodePoint1

  val spansSections: Boolean
    get() = (sourceCodePoint0 and 0x1fff80) != (sourceCodePoint1 and 0x1fff80)

                Arguments.of(new byte[] { (byte) 0x0F }, "0f"), Arguments.of(new byte[] { (byte) 0x10 }, "10"),
                Arguments.of(new byte[] { (byte) 0xAB }, "ab"),
                Arguments.of(new byte[] { (byte) 0x7F, (byte) 0x80, (byte) 0xFF }, "7f80ff"));
    }

    // Verifies that toString() formats bytes as lower-case hex with zero-padding

        byte[] buffer = new byte[100];
        int bufferIndex = 0;

        // Reserved bytes
        buffer[bufferIndex] = (byte) 0xFF;
        buffer[bufferIndex + 1] = (byte) 0xFF;
        buffer[bufferIndex + 2] = (byte) 0xFF;

        // Set fields with negative values (should be treated as unsigned)
        SMBUtil.writeInt4(-1, buffer, bufferIndex + 3); // Should be read as 0xFFFFFFFF

    testDecodes(base64(), "Zg====", "f");
  }

  public void testBase64InvalidDecodings() {
    // These contain bytes not in the decodabet.
    assertFailsToDecode(base64(), "A\u007f", "Unrecognized character: 0x7f");
    assertFailsToDecode(base64(), "Wf2!", "Unrecognized character: !");
    // This sentence just isn't base64() encoded.
    assertFailsToDecode(base64(), "let's not talk of love or chains!");

        assertEquals(0, cap.getValue().length, "Optimistic token must be zero-length");
    }

    @ParameterizedTest
    @ValueSource(bytes = { 0x00, 0x7F, (byte) 0xFF })
    @DisplayName("initSecContext throws on invalid token type")
    void testInitSecContextInvalidTokenType(byte firstByte) throws Exception {
        SpnegoContext ctx = newContext();

        val codepointDelta = (b1 and 0xF shl 14) or (b2 shl 7) or b3
        sink.writeUtf8CodePoint(codePoint - codepointDelta)
      }
      in 80..95 -> {
        // Mapped inline as codePoint delta to add
        val b2 = ranges[rangesIndex + 2].code
        val b3 = ranges[rangesIndex + 3].code

        val codepointDelta = (b1 and 0xF shl 14) or (b2 shl 7) or b3

      encodings[ 0x1c] = encoding // File Separator
      encodings[ 0x1d] = encoding // Group Separator
      encodings[ 0x1e] = encoding // Record Separator
      encodings[ 0x1f] = encoding // Unit Separator
      encodings[ 0x7f] = encoding // Delete
    }

  fun nonAscii(encoding: Encoding) =
    apply {
      encodings[UNICODE_2] = encoding
      encodings[UNICODE_3] = encoding

        assertNull(serverData.guid);
    }

    /**
     * Test setting and getting byte field (sflags)
     */
    @ParameterizedTest
    @ValueSource(bytes = { 0x00, 0x01, 0x7F, (byte) 0x80, (byte) 0xFF })
    @DisplayName("Test sflags field with various byte values")
    public void testSflagsField(byte value) {
        // When
        serverData.sflags = value;

        // Then

import com.google.common.annotations.GwtCompatible;
import java.nio.charset.StandardCharsets;

/**
 * Static methods pertaining to ASCII characters (those in the range of values {@code 0x00} through
 * {@code 0x7F}), and to strings containing such characters.
 *
 * <p>ASCII utilities also exist in other classes of this package:
 *
 * <ul>
 *   <!-- TODO(kevinb): how can we make this not produce a warning when building gwt javadoc? -->

        doAnswer(inv -> {
            byte[] b = inv.getArgument(0);
            int off = inv.getArgument(1);
            b[off] = (byte) 0xFF;
            return 1;
        }).when(raf).read(any(byte[].class), anyInt(), eq(1));
        assertTrue(raf.readBoolean());
        assertEquals((byte) 0xFF, raf.readByte());
        assertEquals(0xFF, raf.readUnsignedByte());
    }