int chunk = (bytes[i++] & 0xFF) << 16 | (bytes[i++] & 0xFF) << 8 | (bytes[i++] & 0xFF);
        target.append(alphabet.encode(chunk >>> 18));
        target.append(alphabet.encode((chunk >>> 12) & 0x3F));
        target.append(alphabet.encode((chunk >>> 6) & 0x3F));
        target.append(alphabet.encode(chunk & 0x3F));
      }
      if (i < off + len) {

        // T = 0x54 -> upper nibble: 0x5 -> 0x46 (F), lower nibble: 0x4 -> 0x45 (E)
        assertEquals('F', dst[1]); // (0x54 >> 4) + 0x41 = 0x46 = 'F'
        assertEquals('E', dst[2]); // (0x54 & 0x0F) + 0x41 = 0x45 = 'E'

        // Check padding (positions 8-30 should be 'CA' pairs for spaces)
        for (int i = 8; i < 31; i += 2) {
            assertEquals('C', dst[i + 1]);

    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!");

    /**
     * UTF-7 Byte Order Mark definition.
     */
    protected static final ByteOrderMark BOM_UTF_7 = new ByteOrderMark("UTF-7", 0x2B, 0x2F, 0x76);

    /**
     * HTML4 unescape translator.
     */
    protected static final CharSequenceTranslator UNESCAPE_HTML4 = new AggregateTranslator(

 * @since 15.0
 */
@GwtCompatible
public class XmlEscapers {
  private XmlEscapers() {}

  private static final char MIN_ASCII_CONTROL_CHAR = 0x00;
  private static final char MAX_ASCII_CONTROL_CHAR = 0x1F;

  // For each xxxEscaper() method, please add links to external reference pages
  // that are considered authoritative for the behavior of that escaper.

  /**

                0x01, // ShareType (DISK)
                0x00, // Reserved
                0x01, 0x00, 0x00, 0x00, // ShareFlags
                0x08, 0x00, 0x00, 0x00, // Capabilities
                (byte) 0xFF, 0x01, 0x1F, 0x00 // MaximalAccess
        };

        // When
        int bytesRead = response.readBytesWireFormat(wireData, 0);

        // Then
        assertEquals(16, bytesRead);

        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

        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();

            SMBUtil.writeInt4(4, buffer, errorStart + 4); // byte count

            // Write some error data
            buffer[errorStart + 8] = (byte) 0xFF;
            buffer[errorStart + 9] = (byte) 0xFE;
            buffer[errorStart + 10] = (byte) 0xFD;
            buffer[errorStart + 11] = (byte) 0xFC;

            testMessage.setBytesRead(0);
            testMessage.decode(buffer, 0);

        lookupSids = new MsrpcLookupSids(mockPolicyHandle, testSids);

        // Act
        int opnum = lookupSids.getOpnum();

        // Assert
        assertEquals(0x0f, opnum);
    }

    @Test
    void constructor_shouldPreservePolicyHandleReference() throws Exception {
        // Arrange
        jcifs.SID mockSid = mock(jcifs.SID.class);