@Tag("Slowish")
class TaskRunnerRealBackendTest {
  private val log = LinkedBlockingDeque<String>()

  private val loggingUncaughtExceptionHandler =
    UncaughtExceptionHandler { _, throwable ->
      log.put("uncaught exception: $throwable")
    }

  private val threadFactory =
    ThreadFactory { runnable ->
      Thread(runnable, "TaskRunnerRealBackendTest").apply {
        isDaemon = true

    opt raise Exception
        dep -->> handler: Lanzar Exception
        handler -->> client: Response HTTP de error
    end
    dep ->> operation: Ejecutar dependencia, por ejemplo, sesión de BD
    opt raise
        operation -->> dep: Lanzar Exception (por ejemplo, HTTPException)
        opt handle
            dep -->> dep: Puede capturar excepción, lanzar una nueva HTTPException, lanzar otra excepción

  private final OkHttpClient client = new OkHttpClient.Builder()
      .addInterceptor(new LoggingInterceptor())
      .build();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://publicobject.com/helloworld.txt")
        .build();

    Response response = client.newCall(request).execute();
    response.body().close();
  }

 */
@GwtCompatible
@NullMarked
public class EvictingQueueTest extends TestCase {

  public void testCreateWithNegativeSize() throws Exception {
    assertThrows(IllegalArgumentException.class, () -> EvictingQueue.create(-1));
  }

  public void testCreateWithZeroSize() throws Exception {
    EvictingQueue<String> queue = EvictingQueue.create(0);
    assertEquals(0, queue.size());

    assertTrue(queue.add("hi"));

    MetadataGraphVertex v3;
    MetadataGraphVertex v4;

    // ------------------------------------------------------------------------------------------
    @BeforeEach
    void setUp() throws Exception {
        graph = new MetadataGraph(4, 3);
        /*
         *       v2
         *   v1<
         *       v3-v4
         *
         */
        v1 = graph.addVertex(new ArtifactMetadata("g", "a1", "1.0"));

   *       complex cases may require using thread pools or making deeper changes.)
   *   <li>If an exception propagates out of a {@code Runnable}, it is not necessarily seen by any
   *       {@code UncaughtExceptionHandler} for the thread. For example, if the callback passed to
   *       {@link Futures#addCallback} throws an exception, that exception will be typically be

            numCalls.incrementAndGet();
            throw new RuntimeException("FAKE EXCEPTION!");
          }
        };

    e.execute(runMe);
    e.execute(runMe);
    fakePool.runAll();

    assertEquals(2, numCalls.get());
  }

  public void testInterrupt_beforeRunRestoresInterruption() throws Exception {
    // Run a task on the composed Executor that interrupts its thread (i.e. this thread).

import java.io.FilterReader;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * @author ricebin
 */
@NullUnmarked
public class MultiReaderTest extends TestCase {

  public void testOnlyOneOpen() throws Exception {
    String testString = "abcdefgh";

    ListenableFuture<String> f = FluentFuture.from(SettableFuture.create());
    assertThat(FluentFuture.from(f)).isSameInstanceAs(f);
  }

  public void testFromNonFluentFuture() throws Exception {
    ListenableFuture<String> f =
        new SimpleForwardingListenableFuture<String>(immediateFuture("a")) {};
    verify(!(f instanceof FluentFuture));
    assertThat(FluentFuture.from(f).get()).isEqualTo("a");

            @Throws(Exception::class)
            public
            override fun doExecute(bufferedWriter: BufferedWriter) {
                val packages = Implementation(excludes.get(), includes.get()).collectPackages(classpath.files.map(File::toPath))
                packages.dump(false, object : ErroringAction<String>() {
                    @Throws(Exception::class)