final SuggestIndexResponse res = indexFromQueryLog(queryLogs.toArray(new QueryLog[queryLogs.size()]));
                        errors.addAll(res.getErrors());
                        numberOfSuggestDocs += res.getNumberOfSuggestDocs();
                        numberOfInputDocs += res.getNumberOfInputDocs();
                        queryLogs.clear();

            Trans2FindFirst2Response resp = inv.getArgument(1);
            // First response content
            FE[] res = java.util.Arrays.stream(batches.get(0)).map(FE::new).toArray(FE[]::new);
            setField(resp, jcifs.internal.smb1.trans.SmbComTransactionResponse.class, "results", res);
            setField(resp, Trans2FindFirst2Response.class, "sid", 42);

        byte[] data = new byte[] { 1, 2, 3 };
        byte[] mic = new byte[] { 9, 8 };
        when(gssContext.getMIC(eq(data), eq(0), eq(3), any())).thenReturn(mic);

        byte[] res = ctx.calculateMIC(data);
        assertArrayEquals(mic, res);
        verify(gssContext, times(1)).getMIC(eq(data), eq(0), eq(3), any());
    }

    @Test
    @DisplayName("calculateMIC wraps GSSException into CIFSException")

                e = i - 4;
                break;
            }
        }

        final StackTraceElement[] res = new StackTraceElement[e - s];
        System.arraycopy(stackTrace, s, res, 0, e - s);
        return res;
    }

    /**
     * {@inheritDoc}
     *
     * @see java.lang.Object#finalize()
     */
    @Override

                                encoded.length(), fessConfig.getCookieSearchParameterMaxLengthAsInteger());
                        return;
                    }
                    LaResponseUtil.getOptionalResponse().ifPresent(res -> {
                        final Cookie cookie = new Cookie(fessConfig.getCookieSearchParameterName(), encoded);

                    }
                    if (res == null) {
                        res = r.combine(next);
                    } else {
                        res.append(r.combine(next));
                    }
                } while (next != nextstart);
            }
        } while (r != start);

        if (res != null) {
            return res;
        }

        return dr;
    }

        int total = 0;
        for (byte[] a : arrays) {
            total += a.length;
        }
        byte[] res = new byte[total];
        int off = 0;
        for (byte[] a : arrays) {
            System.arraycopy(a, 0, res, off, a.length);
            off += a.length;
        }
        return res;
    }

    @Test
    @DisplayName("Read single bytes from stream with message packet")

        if (ComponentUtil.getFessConfig().isLoggingSearchDocsEnabled()) {
            queryResponseList.stream().forEach(res -> {
                final Map<String, Object> map = new HashMap<>();
                Arrays.stream(ComponentUtil.getFessConfig().getLoggingSearchDocsFieldsAsArray()).forEach(s -> map.put(s, res.get(s)));
                searchLog.addDocument(map);
            });
        }
    }

    /**

            SmbFileInputStream in = new SmbFileInputStream(mockFile, mockTree, mockHandle);
            int res = in.readDirect(new byte[1024], 0, 256);
            assertEquals(-1, res);
        }

        @Test
        @DisplayName("LargeReadX splits count across maxCount/openTimeout")
        void largeReadXSetsRequestFields() throws Exception {

        // Using a SmbComClose instance triggers early return without DFS/session work
        SmbComClose closeReq = mock(SmbComClose.class);
        SmbResourceLocator res = c.ensureDFSResolved(loc, closeReq);
        assertSame(loc, res);
        // No connect attempts expected
        verify(c, never()).connectWrapException(any());
    }

    @Test