@Mock
    private ServletOutputStream servletOutputStream;

    @BeforeEach
    void setUp() throws Exception {
        filter = new NtlmHttpFilter();

        // Setup lenient stubs for common mock interactions
        lenient().when(request.getSession()).thenReturn(httpSession);
        lenient().when(request.getSession(anyBoolean())).thenReturn(httpSession);

    }

    @Test
    @DisplayName("getInput/getOutput return cached streams when open; throw when closed")
    void getInputOutput_caching_and_closed() throws Exception {
        // Arrange: minimal stubs so stream construction works
        SmbPipeHandleImpl handle = newHandleWithBasicStubs(0, "\\\\pipe\\\\foo");
        when(pipe.ensureTreeConnected()).thenReturn(tree);
        when(tree.acquire()).thenReturn(tree);

	void _cgo_allocate(void *a, int c) { }
	void _cgo_panic(void *a, int c) { }
	void _cgo_reginit(void) { }

The extra functions here are stubs to satisfy the references in the C
code generated for gcc. The build process links this stub, along with
_cgo_export.c and *.cgo2.c, into a dynamic executable and then lets
cgo examine the executable. Cgo records the list of shared library

    def jApiClassifier = Stub(JApiClass) // represents interfaces, enums and annotations
    def jApiMethod = Stub(JApiMethod)
    def jApiField = Stub(JApiField) // represents fields and enum literals
    def jApiConstructor = Stub(JApiConstructor)
    def incubatingAnnotation = Stub(JApiAnnotation)
    def deprecatedAnnotation = Stub(JApiAnnotation)
    def overrideAnnotation = Stub(JApiAnnotation)

                if (off + stub_frag_len > stub.length) {
                    // shouldn't happen if alloc_hint is correct or greater
                    final byte[] tmp = new byte[off + stub_frag_len];
                    System.arraycopy(stub, 0, tmp, 0, off);
                    stub = tmp;
                }

                System.arraycopy(frag, 24, stub, off, stub_frag_len);
                off += stub_frag_len;

    private static rpc.sid_t buildSidT(byte revision, byte[] identAuth, int... subs) {
        rpc.sid_t s = new rpc.sid_t();
        s.revision = revision;
        s.sub_authority_count = (byte) subs.length;
        s.identifier_authority = Arrays.copyOf(identAuth, 6);
        s.sub_authority = Arrays.copyOf(subs, subs.length);
        return s;
    }

    @Nested

        }
    }
    
    public WitnessRegisterResponse register(WitnessRegisterRequest request) throws IOException {
        try {
            WitnessRegisterStub stub = new WitnessRegisterStub(request);
            handle.sendrecv(stub);
            return stub.getResponse();
        } catch (Exception e) {
            throw new IOException("Witness register RPC failed", e);
        }
    }
    

     */
    @Nonnull
    Optional<Source> getSource();

    /**
     * Determines whether a stub model should be allowed when the POM is missing or unreadable.
     * A stub model contains only minimal information derived from the project's coordinates.
     *
     * @return true if a stub model should be allowed, false otherwise
     */
    boolean isAllowStubModel();

    /**

/**
 * JUnit 5 tests for AndXServerMessageBlock in legacy smb1 package.
 *
 * The tests use small stub subclasses to drive encode/decode paths and
 * validate batching, chaining, signing, and NT_CREATE_ANDX extended handling.
 */
class AndXServerMessageBlockTest {

    /**
     * Test stub for AndXServerMessageBlock to control read/write logic.
     */
    static class DummyAndXBlock extends AndXServerMessageBlock {

            terminal = ft.getTerminal();
        }
        List<String> subs = new ArrayList<>();
        subs.add("type=" + terminal.getType());
        if (terminal instanceof TerminalExt te) {
            subs.add("provider=" + te.getProvider().name());
        }
        if (terminal instanceof AbstractPosixTerminal pt) {
            subs.add("pty=" + pt.getPty().getClass().getName());
        }