/**
     * Pipe operations should behave like the <code>TransactNamedPipe</code> Win32 Named Pipe function.
     */

    int PIPE_TYPE_TRANSACT = 0x0200;

    /**
     * Pipe is used for DCE
     */
    int PIPE_TYPE_DCE_TRANSACT = 0x0200 | 0x0400;

    /**
     * Pipe should use it's own exclusive transport connection
     */
    int PIPE_TYPE_UNSHARED = 0x800;

    /**

    /** NT find capability */
    int CAP_NT_FIND = 0x0200;
    /** DFS capability */
    int CAP_DFS = 0x1000;
    /** Extended security capability */
    int CAP_EXTENDED_SECURITY = 0x80000000;

    // file attribute encoding
    /** Read-only file attribute */
    int ATTR_READONLY = 0x01;
    /** Hidden file attribute */
    int ATTR_HIDDEN = 0x02;
    /** System file attribute */
    int ATTR_SYSTEM = 0x04;

            assertEquals(expectedDialect, response.getSelectedDialect());
        }
    }

    private static Stream<Arguments> provideDialectVersions() {
        return Stream.of(Arguments.of(0x0202, DialectVersion.SMB202, true), Arguments.of(0x0210, DialectVersion.SMB210, true),
                Arguments.of(0x0300, DialectVersion.SMB300, true), Arguments.of(0x0302, DialectVersion.SMB302, true),

        byte[] rawData = new byte[48]; // 8 (size/zero) + 8 (customData) + 32 (machineId)
        // Simulate some data
        rawData[0] = 48; // size
        rawData[16] = 0x01; // machineId start
        rawData[17] = 0x02;

        AvSingleHost avSingleHost = new AvSingleHost(rawData);

        assertNotNull(avSingleHost);
        assertEquals(AvPair.MsvAvSingleHost, avSingleHost.getType());

        assertFalse(key.isZero());
    }

    @Test
    @DisplayName("Should create lease key from byte array")
    void testLeaseKeyFromBytes() {
        byte[] testBytes = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 };

        Smb2LeaseKey key = new Smb2LeaseKey(testBytes);

        assertArrayEquals(testBytes, key.getKey());

            int[] hashAlgos =
                    { PreauthIntegrityNegotiateContext.HASH_ALGO_SHA512, PreauthIntegrityNegotiateContext.HASH_ALGO_SHA512, 0x02, 0x02 };
            byte[] salt = { 0x01, 0x02 };
            PreauthIntegrityNegotiateContext originalContext = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);

            int encoded = originalContext.encode(buffer, 0);

        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05 };
        ByteEncodable encodable = new ByteEncodable(data, 1, 3);

        // Verify size
        assertEquals(3, encodable.size(), "Size should be equal to the specified length");
    }

    @Test
    void testEncodeBasic() {
        // Test basic encoding
        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05 };

        elementVector.add(new DERTaggedObject(0, new ASN1Integer(1))); // authType
        elementVector.add(new DERTaggedObject(1, new DEROctetString(new byte[] { 0x01, 0x02 }))); // authData
        authVector.add(new DERSequence(elementVector));

        byte[] token = new DERSequence(authVector).getEncoded();
        Map<Integer, KerberosKey> keys = new HashMap<>();

        // 2. WHEN

        // Verify that flags are set correctly (DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG)
        // The actual values for DCERPC_FIRST_FRAG and DCERPC_LAST_FRAG are typically 0x01 and 0x02 respectively.
        int expectedFlags = 0x01 | 0x02; // DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG
        assertEquals(expectedFlags, msrpcSamrOpenDomain.getFlags(), "flags should be initialized to DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG");

     */

    public static final int PIPE_TYPE_TRANSACT = 0x0200;

    /**
     * Named pipe type flag for DCE RPC transact operations.
     */
    public static final int PIPE_TYPE_DCE_TRANSACT = 0x0200 | 0x0400;

    InputStream pipeIn;
    OutputStream pipeOut;
    int pipeType;

    /**