*   <li>Each other step is derived from one or more input steps. At each step, zero or more objects
 *       can be captured for later closing.
 *   <li>There is one last step (the root of the tree), from which you can extract the final result
 *       of the computation. After that result is available (or the computation fails), all objects
 *       captured by any of the steps in the pipeline are closed.
 * </ol>
 *
 * <h3>Starting a pipeline</h3>
 *

                    throw new CrawlerSystemException(e);
                }
            }
        }

        /**
         * Gets the captured output as a single string.
         * @return The captured output with newlines.
         */
        public String getOutput() {
            final StringBuilder buf = new StringBuilder(100);
            for (final String value : list) {

            // Give the writer thread time to process and set exception
            w.wait(100);
        }

        // Wait a bit more to ensure exception is captured
        Thread.sleep(100);

        // Act + Assert: checkException should throw the SmbException captured by the thread
        assertThrows(SmbException.class, w::checkException);

        // Stop the thread
        synchronized (w) {

    When a dependency with yield raises after the yield (not in an except), the
    response is already "successfully" sent back to the client, but there's still
    an error in the server afterwards, an exception is raised and captured or shown
    in the server logs.
    """
    with TestClient(app, raise_server_exceptions=False) as client:
        response = client.get("/broken")
        assert response.status_code == 200

            RecordingFilter filter = new RecordingFilter();
            filter.accept(mockFile);
            // Verify the filter stored the reference
            // assertSame may not be necessary but demonstrates captured file
            // we simply check that getPath was called
            verify(mockFile, times(1)).getPath();
        }
    }

    assertAssignable(
        TypeToken.of(new TypeCapture<L>() {}.capture()),
        TypeToken.of(new TypeCapture<L>() {}.capture()));
    assertNotAssignable(
        TypeToken.of(new TypeCapture<R>() {}.capture()),
        TypeToken.of(new TypeCapture<L>() {}.capture()));
    assertAssignable(TypeToken.of(new TypeCapture<L>() {}.capture()), new TypeToken<List<R>>() {});
  }

  public void testisSupertypeOf_resolved() {

        every { buildType.steps } returns steps
        every { buildType.stage } returns buildModel.stages[2]
        every {
            buildType.steps(capture(stepsCapturer))
        } answers {
            stepsCapturer.captured(steps)
            mockk()
        }
    }

    @Test
    fun `can apply defaults to configurations`() {
        applyDefaults(buildModel, buildType, "myTask")

        assertNull(ex.getRootCause(), "Root cause should be null by default");
        assertTrue(ex instanceof SmbException, "Should be an SmbException subtype");
    }

    /**
     * Ensures the exception is thrown and captured via assertThrows with the right message.
     */
    @Test
    void assertThrowsCapturesExceptionAndMessage() {
        // Act & Assert
        SmbEndOfFileException thrown = assertThrows(SmbEndOfFileException.class, () -> {

    """
    When a dependency with yield raises after the streaming response already started
    the 200 status code is already sent, but there's still an error in the server
    afterwards, an exception is raised and captured or shown in the server logs.
    """
    with TestClient(app, raise_server_exceptions=False) as client:
        response = client.get("/broken-session-stream")
        assert response.status_code == 200

        // Capture one known interaction to verify argument integrity
        ArgumentCaptor<Integer> codeCap = ArgumentCaptor.forClass(Integer.class);
        ArgumentCaptor<String> msgCap = ArgumentCaptor.forClass(String.class);
        verify(handler, atLeastOnce()).handle(codeCap.capture(), msgCap.capture());

        // Assert at least one captured pair is a known mapping (happy path spot check)