@DisplayName("Should handle overflow correctly")
        void testConstructorOverflow() {
            // Given/When: Creating NdrShort with value > 255
            NdrShort ndrShort = new NdrShort(300);

            // Then: Value should be masked (300 & 0xFF = 44)
            assertEquals(44, ndrShort.value);
        }
    }

    @Nested
    @DisplayName("Encoding Tests")
    class EncodingTests {

        @Test

@NullUnmarked
public class FileBackedOutputStreamTest extends IoTestCase {


  public void testThreshold() throws Exception {
    testThreshold(0, 100, true, false);
    testThreshold(10, 100, true, false);
    testThreshold(100, 100, true, false);
    testThreshold(1000, 100, true, false);
    testThreshold(0, 100, false, false);
    testThreshold(10, 100, false, false);
    testThreshold(100, 100, false, false);

  }

  @Test
  fun inet4AddressToAscii() {
    assertThat(
      inet4AddressToAscii(
        byteArrayOf(0, 0, 0, 0),
      ),
    ).isEqualTo("0.0.0.0")

    assertThat(
      inet4AddressToAscii(
        byteArrayOf(1, 2, 3, 4),
      ),
    ).isEqualTo("1.2.3.4")

    assertThat(
      inet4AddressToAscii(

            dstIndex += 2;
            writeInt2(ntHash.length, dst, dstIndex);
        }
        dstIndex += 2;
        dst[dstIndex] = (byte) 0x00;
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00;
        dst[dstIndex++] = (byte) 0x00;
        dst[dstIndex++] = (byte) 0x00;
        writeInt4(capabilities, dst, dstIndex);
        dstIndex += 4;

        return dstIndex - start;
    }

    @Override

        SMBUtil.writeInt2(this.fid, dst, dstIndex);
        dstIndex += 2;
        dst[dstIndex] = this.watchTree ? (byte) 0x01 : (byte) 0x00; // watchTree
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00; // Reserved
        return dstIndex - start;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb1.trans.SmbComTransaction#writeParametersWireFormat(byte[], int)
     */
    @Override

/**
 * SMB2 Lease State constants
 *
 * MS-SMB2 2.2.13.2.8
 */
public class Smb2LeaseState {

    /**
     * No lease caching
     */
    public static final int SMB2_LEASE_NONE = 0x00;

    /**
     * Read caching lease (R)
     */
    public static final int SMB2_LEASE_READ_CACHING = 0x01;

    /**
     * Handle caching lease (H)
     */

  }

  @Test
  @Throws(Exception::class)
  fun parseNonStandardStrings() {
    // RFC 822, updated by RFC 1123 with any TZ
    assertThat("Thu, 01 Jan 1970 00:00:00 GMT-01:00".toHttpDateOrNull()!!.time).isEqualTo(3600000L)
    assertThat("Thu, 01 Jan 1970 00:00:00 PST".toHttpDateOrNull()!!.time).isEqualTo(28800000L)
    // Ignore trailing junk

        ByteBuffer bb = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN);
        bb.putShort((short) fid);
        bb.put((byte) 0x00); // Reserved
        bb.put((byte) 0x00); // Reserved
        bb.putInt(securityInformation);
        return bb.array();
    }

    /**
     * Provide a range of values that are valid for the constructor.
     */

            buffer[0] = 0x10;
            buffer[1] = 0x00;
            // Share type (DISK)
            buffer[2] = Smb2TreeConnectResponse.SMB2_SHARE_TYPE_DISK;
            // Reserved
            buffer[3] = 0;
            // Share flags (DFS)
            buffer[4] = 0x01;
            buffer[5] = 0x00;
            buffer[6] = 0x00;
            buffer[7] = 0x00;
            // Capabilities (DFS)

    void testGetInetAddressArray() throws UnknownHostException {
        testProperties.setProperty("test.hosts", "localhost,127.0.0.1");
        InetAddress[] defaultArray = { InetAddress.getByName("0.0.0.0") };

        InetAddress[] result = Config.getInetAddressArray(testProperties, "test.hosts", ",", defaultArray);
        assertEquals(2, result.length);
        assertEquals(InetAddress.getByName("localhost"), result[0]);