// When an output buffer is provided, bytes are copied and getOutputData(Class) should fail.
        byte[] header = buildHeader(NtStatus.NT_STATUS_SUCCESS);
        byte[] output = new byte[] { 1, 2, 3, 4, 5 };
        byte[] body = buildIoctlResponseBody(Smb2IoctlRequest.FSCTL_SRV_COPYCHUNK, new byte[16], 0, null, output.length, output, 0x0);
        byte[] packet = new byte[header.length + body.length];

    void testPrepareWithoutReceivedDoesNotPropagate() {
        Smb2SessionSetupResponse resp = newResponse();
        // Set a sessionId, but do not mark as received via decode
        resp.setSessionId(0x1234L);

        CIFSContext mockCtx = mock(CIFSContext.class);
        when(mockCtx.getConfig()).thenReturn(mock(Configuration.class));

    Iterator<Integer> iterator = singleton(0).iterator();
    assertEquals(1, Iterators.size(iterator));
  }

  public void testSize_partiallyConsumed() {
    Iterator<Integer> iterator = asList(1, 2, 3, 4, 5).iterator();
    iterator.next();
    iterator.next();
    assertEquals(3, Iterators.size(iterator));
  }

  public void test_contains_nonnull_yes() {

		wantSize: 01234,
	}, {
		input: makeInput(FormatGNU, "1234",
			append(makeSparseStrings(sparseDatas{{0, 0}, {1, 1}}), []string{"", "blah"}...)...),
		wantMap:  sparseDatas{{0, 0}, {1, 1}},
		wantSize: 01234,
	}, {
		input: makeInput(FormatGNU, "3333",
			makeSparseStrings(sparseDatas{{0, 1}, {2, 1}, {4, 1}, {6, 1}})...),
		wantMap:  sparseDatas{{0, 1}, {2, 1}, {4, 1}, {6, 1}},
		wantSize: 03333,
	}, {

        DummyPlainSMB next = new DummyPlainSMB();
        DummyAndXBlock block = new DummyAndXBlock(next);
        block.customBatchLimit = 2; // batchLevel (0) < limit (2) so chaining allowed
        block.uid = 0x1234;
        block.useUnicode = true;

        byte[] buf = new byte[256];
        int n = block.writeAndXWireFormat(buf, 0);

        assertTrue(n > 0);

        when(resp.getErrorCode()).thenReturn(0);
        when(resp.getNotifyInformation()).thenReturn(info);
        setupSmb2(resp, new byte[16]);
        SmbWatchHandleImpl sut = new SmbWatchHandleImpl(handle, 0x1234, true);

        List<FileNotifyInformation> result = sut.watch();

        assertSame(info, result, "Should return response notify information");

        RdmaProvider provider = RdmaProviderFactory.selectBestProvider();

        // Use localhost for testing - should work with TCP fallback
        InetSocketAddress address = new InetSocketAddress("localhost", 12345);

        try (RdmaConnection connection = provider.createConnection(address, null)) {
            assertNotNull(connection, "Connection should not be null");

pkg html/template, const ErrJSTemplate ErrorCode #59584
pkg io/fs, func FormatDirEntry(DirEntry) string #54451
pkg io/fs, func FormatFileInfo(FileInfo) string #54451
pkg log/slog, const KindAny = 0 #56345
pkg log/slog, const KindAny Kind #56345
pkg log/slog, const KindBool = 1 #56345
pkg log/slog, const KindBool Kind #56345
pkg log/slog, const KindDuration = 2 #56345
pkg log/slog, const KindDuration Kind #56345

            // Given
            int result = 0;
            when(mockBuffer.dec_ndr_short()).thenReturn(4096, 4096, 10, result, 0);
            when(mockBuffer.dec_ndr_long()).thenReturn(12345);
            when(mockBuffer.dec_ndr_small()).thenReturn(1);
            lenient().doNothing().when(mockBuffer).advance(anyInt());
            lenient().when(mockBuffer.align(anyInt())).thenReturn(0);

    }

    @Test
    @DisplayName("Should handle parsing invalid message bytes")
    void testInvalidMessageBytes() {
        // Given
        byte[] invalidBytes = { 1, 2, 3, 4, 5 }; // Too short and invalid

        // When/Then
        assertThrows(IOException.class, () -> {
            new Type3Message(invalidBytes);
        });
    }

    @Test