return ((0xFL << 4) | (codePoint >>> 18))
        | ((0x80L | (0x3F & (codePoint >>> 12))) << 8)
        | ((0x80L | (0x3F & (codePoint >>> 6))) << 16)
        | ((0x80L | (0x3F & codePoint)) << 24);
  }

  private static long charToThreeUtf8Bytes(char c) {
    return ((0x7L << 5) | (c >>> 12))
        | ((0x80 | (0x3F & (c >>> 6))) << 8)
        | ((0x80 | (0x3F & c)) << 16);
  }

        System.arraycopy(dst, 2, writtenDescr, 0, descr.length);
        assertArrayEquals(descr, writtenDescr);

        int currentIndex = 2 + descr.length;
        // Verify level (0x0001)
        assertEquals(1, (dst[currentIndex] & 0xFF) | ((dst[currentIndex + 1] & 0xFF) << 8));
        currentIndex += 2;

        // Verify maxDataCount

     */
    public static final int FILE_NOTIFY_CHANGE_EA = 0x80;
    /**
     * Notify when security descriptor changes
     */
    public static final int FILE_NOTIFY_CHANGE_SECURITY = 0x100;
    /**
     * Notify when alternate data stream name changes
     */
    public static final int FILE_NOTIFY_CHANGE_STREAM_NAME = 0x200;
    /**
     * Notify when alternate data stream size changes
     */

            throw new PACDecodingException("Empty kerberos token");
        }

        byte[] content;
        try (ASN1InputStream stream = new ASN1InputStream(token)) {
            content = ASN1Util.readUnparsedTagged(0, 0x8000, stream);
        } catch (IOException e) {
            throw new PACDecodingException("Malformed kerberos token", e);
        }

        try (ASN1InputStream stream = new ASN1InputStream(content)) {

        // Should write 2 bytes: information level
        assertEquals(2, written);

        // Check information level (SMB_INFO_ALLOCATION maps to 0x0001)
        int actualInfoLevel = SMBUtil.readInt2(buffer, 0);
        assertEquals(0x0001, actualInfoLevel);
    }

    @Test
    @DisplayName("Test writeParametersWireFormat with FS_SIZE_INFO")
    void testWriteParametersWireFormatWithFsSizeInfo() {

# ADR-0008 - Use NullAway for null checking

## Status

- ACCEPTED on 2025-08-06

## Context

Our codebase uses `null` extensively to represent an absence of value or optionality of the argument.
We utilize nullness annotations in Java code and somewhat rely on IDE warnings to guide us.
However, the Java code we have is not fully annotated, which causes several consequences:
* IDE warnings can be misleading

            // Initialize the data buffer with proper SMB2 header structure
            SMBUtil.writeInt4(0xFE534D42, data, 0); // SMB2 signature
            SMBUtil.writeInt4(0x0000, data, 12); // Command = 0
            SMBUtil.writeInt4(0x0000, data, 16); // Flags = 0

            CommonServerMessageBlock request = mock(CommonServerMessageBlock.class);
            CommonServerMessageBlock response = mock(CommonServerMessageBlock.class);

 */

package jcifs.smb1.smb1;

import java.util.Date;

import jcifs.smb1.util.Hexdump;

class SmbComQueryInformationResponse extends ServerMessageBlock implements Info {

    private int fileAttributes = 0x0000;
    private long lastWriteTime = 0L;
    private final long serverTimeZoneOffset;
    private int fileSize = 0;

    SmbComQueryInformationResponse(final long serverTimeZoneOffset) {

                si++;
                if ((ch & 0xC0) != 0x80) {
                    throw new IOException("Invalid UTF-8 sequence");
                }
                uni[ui] |= (ch & 0x3F) << 6;
                ch = src[si++] & 0xFF;
                uni[ui] |= ch & 0x3F;
                if ((ch & 0xC0) != 0x80 || uni[ui] < 0x800) {
                    throw new IOException("Invalid UTF-8 sequence");

    Random rng = new Random(0);
    for (int z = 0; z < 100; z++) {
      int[] codePoints = new int[rng.nextInt(8)];
      for (int i = 0; i < codePoints.length; i++) {
        do {
          codePoints[i] = rng.nextInt(0x800);
        } while (!Character.isValidCodePoint(codePoints[i])
            || (codePoints[i] >= Character.MIN_SURROGATE
                && codePoints[i] <= Character.MAX_SURROGATE));
      }