when(mockConnection.getRequestMethod()).thenReturn("GET");
        when(mockConnection.getAllowUserInteraction()).thenReturn(true);
        when(mockConnection.getDoInput()).thenReturn(true);
        when(mockConnection.getDoOutput()).thenReturn(true);
        when(mockConnection.getIfModifiedSince()).thenReturn(12345L);
        when(mockConnection.getUseCaches()).thenReturn(false);
        when(mockConnection.getReadTimeout()).thenReturn(1000);

    @Override
    public void setDoOutput(final boolean doOutput) {
        connection.setDoOutput(doOutput);
        this.doOutput = doOutput;
    }

    @Override
    public boolean getDoOutput() {
        return connection.getDoOutput();
    }

    @Override
    public void setAllowUserInteraction(final boolean allowUserInteraction) {
        connection.setAllowUserInteraction(allowUserInteraction);

    public void setDoOutput(final boolean doOutput) {
        this.connection.setDoOutput(doOutput);
        this.doOutput = doOutput;
    }

    @Override
    public boolean getDoOutput() {
        return this.connection.getDoOutput();
    }

    @Override
    public void setAllowUserInteraction(final boolean allowUserInteraction) {
        this.connection.setAllowUserInteraction(allowUserInteraction);

        thread.start();

        Thread.sleep(50);

        String output1 = thread.getOutput();
        boolean contains1 = thread.contains("concurrent1");

        thread.join(1000);

        String output2 = thread.getOutput();
        boolean contains2 = thread.contains("concurrent1");

        assertNotNull(output1);
        assertNotNull(output2);

        SmbPipeInputStream in1 = handle.getInput();
        SmbPipeInputStream in2 = handle.getInput();
        SmbPipeOutputStream out1 = handle.getOutput();
        SmbPipeOutputStream out2 = handle.getOutput();

        // Assert: same instances are returned subsequently
        assertSame(in1, in2, "Input stream should be cached");
        assertSame(out1, out2, "Output stream should be cached");

        }
        return this.input;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbPipeHandle#getOutput()
     */
    @Override
    public SmbPipeOutputStream getOutput() throws CIFSException {
        if (!this.open) {
            throw new SmbException("Already closed");
        }

        if (this.output != null) {

        assertEquals(2, callbackResults.size());
        assertEquals("integration test", callbackResults.get(0));
        assertEquals("second line", callbackResults.get(1));

        String output = thread.getOutput();
        assertTrue(output.contains("integration test"));
        assertTrue(output.contains("second line"));
    }

    public void test_defaultBufferSizeConstant() throws IOException {

     * @throws CIFSException if an error occurs while getting the stream.
     */
    @Test
    public void testGetOutputStream() throws CIFSException {
        assertEquals(mockOutputStream, smbPipeHandle.getOutput(), "getOutput() should return the correct output stream.");
    }

    /**
     * Tests related to the lifecycle management of the handle (e.g., closing).
     */
    @Nested
    public class LifecycleManagementTest {

        assertEquals("c", item1.getOutput());

        OptionalEntity<CharMappingItem> result2 = charMappingFile.get(2L);
        assertTrue(result2.isPresent());
        CharMappingItem item2 = result2.get();
        assertEquals(2L, item2.getId());
        assertArrayEquals(new String[] { "d", "e" }, item2.getInputs());
        assertEquals("f", item2.getOutput());

        return String.join("\n", inputs);
    }

    /**
     * Returns the output character sequence that inputs are mapped to.
     *
     * @return the output sequence
     */
    public String getOutput() {
        return output;
    }

    /**
     * Checks whether this mapping item has pending updates.
     *
     * @return true if both newInputs and newOutput are not null, indicating pending updates