ByteBuffer buffer = ByteBuffer.allocate(200);
        buffer.order(ByteOrder.LITTLE_ENDIAN);

        // First notification with nextEntryOffset pointing to second
        int secondOffset = 48;
        buffer.putInt(secondOffset); // nextEntryOffset to second entry
        buffer.putInt(FileNotifyInformation.FILE_ACTION_ADDED);
        String fileName1 = "first.txt";
        byte[] fileNameBytes1 = fileName1.getBytes("UTF-16LE");

        bb.getInt();

        // LinkSpeed (8 bytes) - in bits per second
        long linkSpeedBps = bb.getLong();

        // Parse sockaddr structure (starts at offset + 24)
        InetAddress addr = parseSockaddr(data, offset + 24);

        if (addr == null) {
            return null;
        }

        // Convert bits per second to Mbps for internal use

        byte[] first = impl.getBuffer(); // should return slot 0 -> a
        byte[] second = impl.getBuffer(); // then slot 1 -> c
        byte[] third = impl.getBuffer(); // cache empty -> new with size 3

        assertSame(a, first, "First get should return first cached buffer");
        assertSame(c, second, "Second get should return second cached buffer");

        assertEquals(sidT1, lsarSidArrayX.sids[0].sid, "First SID should be unwrapped correctly");
        assertEquals(sidT2, lsarSidArrayX.sids[1].sid, "Second SID should be unwrapped correctly");
    }

    @Test
    void testConstructorWithJcifsSIDArrayDirectAssignment() {
        // Create mock SID objects
        SID mockSid1 = mock(SID.class);

    private final CIFSContext context;
    private final ScheduledExecutorService cleanupExecutor;
    private static final long DEFAULT_LEASE_CLEANUP_INTERVAL = 60000; // 60 seconds
    private static final int DEFAULT_LEASE_BREAK_TIMEOUT = 60; // 60 seconds per MS-SMB2

    /**
     * Create a new lease manager
     *
     * @param context CIFS context
     */
    public LeaseManager(CIFSContext context) {

                    endLatch.countDown();
                }
            });
        }

        startLatch.countDown(); // Start all threads
        assertTrue(endLatch.await(30, TimeUnit.SECONDS), "All threads should complete within timeout");
        executor.shutdown();

        long overallEnd = System.nanoTime();
        double overallTimeMs = (overallEnd - overallStart) / 1_000_000.0;

        if (t != 0L) {
            t = (t + SmbConstants.MILLISECONDS_BETWEEN_1970_AND_1601) * 10000L;
        }
        writeInt8(t, dst, dstIndex);
    }

    /**
     * Reads a Unix time value (32-bit seconds) and converts it to Java time in milliseconds
     * @param buffer the source byte array
     * @param bufferIndex the starting index in the source array
     * @return the time value in milliseconds since January 1, 1970 UTC

        // Second decode - should overwrite values
        byte[] buffer2 = new byte[50];
        SMBUtil.writeInt4(0x22222222, buffer2, 0);
        SMBUtil.writeInt2(0x2222, buffer2, 20);
        SMBUtil.writeInt2(0x0311, buffer2, 22);

        response.decode(buffer2, 0, 24);
        assertEquals(0x22222222, response.getCapabilities(), "Second decode capabilities");

                } finally {
                    latch.countDown();
                }
            });
        }

        latch.await(5, TimeUnit.SECONDS);
        executor.shutdown();

        // Verify all listeners were added
        assertEquals(numThreads, fesenClient.onConnectListenerList.size());
    }

    /**

    }

    @Test
    @DisplayName("Iterator with rejecting filter - finds next acceptable")
    void iteratorWithRejectingFilter() throws Exception {
        // Setup: first entry rejected, second accepted
        FileEntry entry1 = mock(FileEntry.class);
        FileEntry entry2 = mock(FileEntry.class);

        when(delegate.hasNext()).thenReturn(true, true, false);