private static final int TIME_1970_MILLIS_64LE = 8;

    /**
     *
     */
    private Encdec() {
    }

    /*
     * Encode integers
     */

    /**
     * Encodes a 16-bit unsigned integer in big-endian byte order.
     *
     * @param s the short value to encode
     * @param dst the destination byte array
     * @param di the starting index in the destination array

        info.encode(dstOut); // Encode the info structure

        // Simulate totalentries pointer (non-null)
        dstOut.enc_ndr_long(1); // Non-null pointer for totalentries
        totalentries.encode(dstOut); // Encode the totalentries

        dstOut.enc_ndr_long(0); // Simulate retval

        // Use the encoded data for decoding

            // When: Encoding array
            array.encode(mockNdrBuffer);

            // Then: Should encode structure
            verify(mockNdrBuffer).align(4);
            verify(mockNdrBuffer).enc_ndr_long(1);
            verify(mockNdrBuffer).enc_ndr_referent(array.entries, 1);
        }

        @Test
        @DisplayName("Should encode array with null entries")

        firstInstance.decode(originalBuffer, 0, originalBuffer.length);

        // Encode from first instance
        byte[] encodedBuffer = new byte[8];
        firstInstance.encode(encodedBuffer, 0);

        // Decode into second instance
        FileInternalInfo secondInstance = new FileInternalInfo();
        secondInstance.decode(encodedBuffer, 0, encodedBuffer.length);

        @Test
        @DisplayName("Should encode basic lock structure correctly")
        void testBasicEncoding() {
            long offset = 0x1234567890ABCDEFL;
            long length = 0xFEDCBA0987654321L;
            int flags = 0x12345678;

            lock = new Smb2Lock(offset, length, flags);
            int encoded = lock.encode(buffer, 0);

            assertEquals(24, encoded);

            // Verify offset (8 bytes)

        return src[si] & 0xFF | (src[si + 1] & 0xFF) << 8 | (src[si + 2] & 0xFF) << 16 | (src[si + 3] & 0xFF) << 24;
    }

    /* Encode and decode 64 bit integers
     */

    /**
     * Encodes a 64-bit unsigned integer in big-endian byte order.
     *
     * @param l the long value to encode
     * @param dst the destination byte array
     * @param di the starting index in the destination array

            context = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);
            int encoded = context.encode(buffer, 0);

            assertEquals(4 + (count * 2) + 16, encoded);
            assertEquals(context.size(), encoded);
        }

        @Test
        @DisplayName("Should encode and decode correctly")
        void testEncodeAndDecode() throws SMBProtocolDecodingException {

        byte[] buffer1 = new byte[request.size()];
        byte[] buffer2 = new byte[request.size()];

        request.encode(buffer1, 0);
        request.encode(buffer2, 0);

        assertArrayEquals(buffer1, buffer2);
    }

    @Test
    @DisplayName("Test encode with insufficient buffer throws exception")
    void testEncodeWithInsufficientBuffer() {
        ValidateNegotiateInfoRequest request =

            SrvCopychunkCopy copy = new SrvCopychunkCopy(sourceKey, mockChunk1, mockChunk2);
            byte[] buffer = new byte[200];

            // When
            copy.encode(buffer, 0);

            // Then
            verify(mockChunk1, times(1)).encode(eq(buffer), eq(HEADER_SIZE));

        for (long testValue : testValues) {
            // Create and encode
            FileEndOfFileInformation original = new FileEndOfFileInformation(testValue);
            byte[] buffer = new byte[8];
            int encoded = original.encode(buffer, 0);

            assertEquals(8, encoded);

            // Decode into new instance
            FileEndOfFileInformation decoded = new FileEndOfFileInformation();