*/
  public static List<Throwable> getCausalChain(Throwable throwable) {
    checkNotNull(throwable);
    List<Throwable> causes = new ArrayList<>(4);
    causes.add(throwable);

    // Keep a second pointer that slowly walks the causal chain. If the fast pointer ever catches
    // the slower pointer, then there's a loop.
    Throwable slowPointer = throwable;

    @Override
    void dispatch(Object event, Iterator<Subscriber> subscribers) {
      checkNotNull(event);
      while (subscribers.hasNext()) {
        queue.add(new EventWithSubscriber(event, subscribers.next()));
      }

      EventWithSubscriber e;
      while ((e = queue.poll()) != null) {
        e.subscriber.dispatchEvent(e.event);
      }
    }

    }

    /**
     * @throws Exception
     */
    @Test
    public void testAdd() throws Exception {
        list.addLast("1");
        list.addLast("2");
        list.addLast("3");
        list.add(1, "4");
        assertThat(list.get(1), is("4"));
        assertThat(list.get(2), is("2"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testIndexOf() throws Exception {

RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt

COPY ./app /code/app

CMD ["fastapi", "run", "app/main.py", "--port", "80"]

# If running behind a proxy like Nginx or Traefik add --proxy-headers
# CMD ["fastapi", "run", "app/main.py", "--port", "80", "--proxy-headers"]
```

</details>

## コンテナとは何か { #what-is-a-container }

    }
  }

  private static List<Callable<String>> createTasks(int n) {
    List<Callable<String>> callables = new ArrayList<>();
    for (int i = 0; i < n; i++) {
      callables.add(Callables.returning(RESULT_VALUE + i));
    }
    return callables;
  }

  private static final class WrappedCallable<T> implements Callable<T> {
    private final Callable<T> delegate;

    val proxySelector = RecordingProxySelector()
    val socketAddress = InetSocketAddress.createUnresolved("myproxy", 8008)
    proxySelector.proxies.add(Proxy(Proxy.Type.HTTP, socketAddress))

    // Define two host names for the DNS routing of fake proxy servers
    val proxyServer1 = InetAddress.getByAddress("proxyServer1", byteArrayOf(127, 0, 0, 2))

    directedGraph.removeEdge(N1, N2);
    directedGraph.removeEdge(N2, N1);
    containsExactlySanityCheck(edges);

    assertThrows(
        UnsupportedOperationException.class, () -> edges.add(EndpointPair.ordered(N1, N2)));
  }

  @Test
  public void endpointPair_undirected_contains() {
    MutableGraph<Integer> undirectedGraph = GraphBuilder.undirected().allowsSelfLoops(true).build();

    }
  }

  private static List<Callable<String>> createTasks(int n) {
    List<Callable<String>> callables = new ArrayList<>();
    for (int i = 0; i < n; i++) {
      callables.add(Callables.returning(RESULT_VALUE + i));
    }
    return callables;
  }

  private static final class WrappedCallable<T> implements Callable<T> {
    private final Callable<T> delegate;

    directedGraph.removeEdge(N1, N2);
    directedGraph.removeEdge(N2, N1);
    containsExactlySanityCheck(edges);

    assertThrows(
        UnsupportedOperationException.class, () -> edges.add(EndpointPair.ordered(N1, N2)));
  }

  @Test
  public void endpointPair_undirected_contains() {
    MutableGraph<Integer> undirectedGraph = GraphBuilder.undirected().allowsSelfLoops(true).build();

          push(stack, collector.combiner().apply(left, right));
        }
        return pop(stack);
      }

      <E extends @Nullable Object> void push(List<E> stack, E value) {
        stack.add(value);
      }

      <E extends @Nullable Object> E pop(List<E> stack) {
        return stack.remove(stack.size() - 1);
      }
    };