InvalidAccessTokenException exception = new InvalidAccessTokenException(type, message);

        String firstCall = exception.getType();
        String secondCall = exception.getType();

        assertSame(firstCall, secondCall);
        assertEquals(type, firstCall);
    }

    public void test_inheritanceFromFessSystemException() {

            failureCalls[0]++;
          }
        };
    addCallback(future, callback, directExecutor());
    SomeError e = assertThrows(SomeError.class, () -> future.set(result));
    assertSame(error, e);
    assertEquals(result, future.get());
    assertThat(successCalls[0]).isEqualTo(1);
    assertThat(failureCalls[0]).isEqualTo(0);
  }

  public void testWildcardFuture() {

        dataMap.put("test", "value");

        // Execute
        Map<String, Object> result = indexUpdateCallback.ingest(paramMap, dataMap);

        // Verify data is returned unchanged
        assertSame(dataMap, result);
    }

    public void test_ingest_withFactory() {
        // Setup ingest factory
        TestIngester ingester = new TestIngester();
        ingestFactory.ingesters.add(ingester);

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

        StackTraceElement[] originalStackTrace = exception.getStackTrace();
        assertNotNull(originalStackTrace);

        Throwable filled = exception.fillInStackTrace();
        assertSame(exception, filled);

        StackTraceElement[] newStackTrace = exception.getStackTrace();
        assertNotNull(newStackTrace);
    }

    public void test_multipleInstances() {

      if (i == 10) {
        new Thread(() -> latch.countDown()).start();
      }

      future.addListener(listenerLatch::countDown, exec);
    }

    assertSame(Boolean.TRUE, future.get());
    // Wait for the listener latch to complete.
    listenerLatch.await(500, MILLISECONDS);

    exec.shutdown();
    exec.awaitTermination(500, MILLISECONDS);
  }

    BadFuture badInput = new BadFuture(immediateFuture(20));
    ListenableFuture<String> chain = buildChainingFuture(badInput);
    ExecutionException e = assertThrows(ExecutionException.class, () -> chain.get());
    assertSame(RuntimeException.class, e.getCause().getClass());
  }

  /** Proxy to throw a {@link RuntimeException} out of the {@link #get()} method. */
  public static class BadFuture extends SimpleForwardingListenableFuture<Integer> {

    BadFuture badInput = new BadFuture(immediateFuture(20));
    ListenableFuture<String> chain = buildChainingFuture(badInput);
    ExecutionException e = assertThrows(ExecutionException.class, () -> chain.get());
    assertSame(RuntimeException.class, e.getCause().getClass());
  }

  /** Proxy to throw a {@link RuntimeException} out of the {@link #get()} method. */
  public static class BadFuture extends SimpleForwardingListenableFuture<Integer> {

  }

  public void testInverseMinimizesWork() {
    ImmutableSetMultimap<String, Character> multimap =
        ImmutableSetMultimap.of("of", 'o', "of", 'f', "to", 't', "to", 'o');
    assertSame(multimap.inverse(), multimap.inverse());
    assertSame(multimap, multimap.inverse().inverse());
  }

  private static <K, V> void assertMultimapEquals(
      Multimap<K, V> multimap, Object... alternatingKeysAndValues) {

            throw exception;
          }
        };

    // It should pass through untouched
    SomeUncheckedException e = assertThrows(SomeUncheckedException.class, iter::hasNext);
    assertSame(exception, e);
  }

  public void testExceptionAfterEndOfData() {
    Iterator<Integer> iter =
        new AbstractIterator<Integer>() {
          @Override
          public Integer computeNext() {