DownloadedArtifact getArtifact();

        /**
         * Returns a mapping of repositories to the exceptions encountered while resolving the artifact.
         *
         * @return A {@link Map} where keys are {@link Repository} instances and values are {@link Exception} instances.
         */
        Map<Repository, List<Exception>> getExceptions();

        /**
         * Returns the repository from which the artifact was resolved.

        final Exception[] exceptions = new Exception[threadCount];

        for (int i = 0; i < threadCount; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                try {
                    providers[index] = new FessTimeResourceProvider(mockConfig);
                } catch (Exception e) {
                    exceptions[index] = e;
                }

   * RuntimeException runtime exceptions} thrown by the executor.
   */
  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
  private static void executeListener(Runnable runnable, Executor executor) {
    try {
      executor.execute(runnable);
    } catch (Exception e) { // sneaky checked exception

        assertTrue(exception instanceof RuntimeException);
        assertTrue(exception instanceof Exception);
        assertTrue(exception instanceof Throwable);
    }

    public void test_serializable() {
        // Test that the exception has serialVersionUID
        WebApiException exception = new WebApiException(404, "Not Found");

                            assertTrue(CrawlerStatus.INITIALIZING.compareTo(CrawlerStatus.DONE) < 0);
                        }
                    } catch (Exception e) {
                        synchronized (exceptions) {
                            exceptions.add(e);
                        }
                    }
                }
            });
        }

        // Start all threads

They can declare request requirements (like headers) or other sub-dependencies:

{* ../../docs_src/dependencies/tutorial006_an_py39.py hl[8,13] *}

### Raise exceptions { #raise-exceptions }

These dependencies can `raise` exceptions, the same as normal dependencies:

{* ../../docs_src/dependencies/tutorial006_an_py39.py hl[10,15] *}

### Return values { #return-values }

     * Verify that all methods can be called with null buffers without
     * throwing exceptions. This test ensures robustness of the implementation.
     */
    @Test
    void methodsHandleNullBuffersGracefully() {
        // Arrange
        TransWaitNamedPipeResponse resp = new TransWaitNamedPipeResponse();
        // Act & Assert - no exceptions should be thrown
        assertDoesNotThrow(() -> resp.writeSetupWireFormat(null, 0));

        }

        try {
            dataIndexHelper.crawl("test-session-force-stop");
            assertTrue("Should exit quickly when force stopped", true);
        } catch (Exception e) {
            assertTrue("Force stop should handle exceptions quickly", true);
        }
    }

    public void test_crawl_with_short_intervals() {
        try {
            // Test with minimal interval

         * @param request the request data
         * @param exceptionList the list of exceptions that occurred during retries
         */
        void onRequestEnd(FaultTolerantClient client, RequestData request, List<Exception> exceptionList);

        /**
         * Called when an exception occurs during a request attempt.
         *
         * @param client the fault-tolerant client

        @DisplayName("Should handle deeply nested exceptions")
        void testToStringWithNestedExceptions() {
            Exception innermost = new IOException("Innermost exception");
            Exception middle = new RuntimeException("Middle exception", innermost);
            Exception rootCause = new IllegalStateException("Outer exception", middle);
            TransportException exception = new TransportException("Transport failed", rootCause);