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");

        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 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) {

     * @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(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"));
    }

    @Test
    public void test_defaultBufferSizeConstant() throws IOException {

        yamlTestSourceSet.getOutput()
            .dir(
                project.getTasks()
                    .withType(CopyRestApiTask.class)
                    .named(RestResourcesPlugin.COPY_REST_API_SPECS_TASK)
                    .flatMap(CopyRestApiTask::getOutputResourceDir)
            );

        yamlTestSourceSet.getOutput()
            .dir(
                project.getTasks()

        BuildResult result = getGradleRunner().withArguments(":launchReaper", "-S", "--info").build();
        assertTaskSuccessful(result, ":launchReaper");
        assertOutputContains(result.getOutput(), "Copying reaper.jar...");
    }

  explicit CSession(TF_Session* session);

  ~CSession();

  void SetInputs(std::vector<std::pair<TF_Operation*, TF_Tensor*>> inputs);
  void SetOutputs(std::initializer_list<TF_Operation*> outputs);
  void SetOutputs(const std::vector<TF_Output>& outputs);
  void SetTargets(std::initializer_list<TF_Operation*> targets);

  void Run(TF_Status* s);

  void CloseAndDelete(TF_Status* s);

                        .findFirst()
                        .orElse(null)
                );
            });

        defaultSourceSet.getOutput().dir(copyRestYamlApiTask.map(CopyRestApiTask::getOutputResourceDir));
        defaultSourceSet.getOutput().dir(copyRestYamlTestTask.map(CopyRestTestsTask::getOutputResourceDir));
    }

        assertEquals("line1 line2", item.getOutput());
    }

    @Test
    public void test_constructor_withNullOutput() {
        // Test with null output
        String[] inputs = { "input" };
        CharMappingItem item = new CharMappingItem(1L, inputs, null);

        assertNull(item.getOutput());
    }

    @Test
    public void test_constructor_withUnsortedInputs() {