}
  }

  @Override
  protected void tearDown() {
    stack.runTearDown();
  }

  static final Exception EXCEPTION = new Exception();

  static final class ExampleClassUnderTest {
    static final Logger logger = Logger.getLogger(ExampleClassUnderTest.class.getName());

    static void foo() {
      logger.log(Level.INFO, "message", EXCEPTION);
    }

    private ExampleClassUnderTest() {}
  }

  }

  // TODO(cpovirk): Use standard Javadoc form for SimpleForwarding* class and constructor
  /**
   * A simplified version of {@link ForwardingListenableFuture} where subclasses can pass in an
   * already constructed {@link ListenableFuture} as the delegate.
   *
   * @since 9.0
   */
  public abstract static class SimpleForwardingListenableFuture<V extends @Nullable Object>
      extends ForwardingListenableFuture<V> {

import org.codelibs.fess.crawler.entity.ResponseData;
import org.codelibs.fess.crawler.exception.CrawlingAccessException;

/**
 * Utility class for handling response data.
 */
public final class ResponseDataUtil {

    /**
     * Private constructor to prevent instantiation of this utility class.
     */
    private ResponseDataUtil() {
    }

    /**

/**
 * @author shinsuke
 *
 */
public class DataServiceImplTest extends PlainTestCase {
    public DataService dataService;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        StandardCrawlerContainer container = new StandardCrawlerContainer().singleton("dataHelper", MemoryDataHelper.class)//
                .singleton("dataService", DataServiceImpl.class);

import jakarta.annotation.Resource;

/**
 * Service class for managing group operations in the Fess application.
 * Provides CRUD operations for groups, including integration with LDAP manager
 * and user-group relationships. Handles group pagination, searching, and
 * maintaining data consistency between groups and associated users.
 */
public class GroupService {

    /** Behavior class for group database operations */
    @Resource

    stopwatch.start();
    assertThrows(IllegalStateException.class, stopwatch::start);
    assertTrue(stopwatch.isRunning());
  }

  public void testStop() {
    stopwatch.start();
    assertSame(stopwatch, stopwatch.stop());
    assertFalse(stopwatch.isRunning());
  }

  public void testStop_new() {
    assertThrows(IllegalStateException.class, stopwatch::stop);
    assertFalse(stopwatch.isRunning());
  }

// @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
@IgnoreJRERequirement // We opt into library desugaring for our tests.
public class MapMergeTester<K, V> extends AbstractMapTester<K, V> {
  @MapFeature.Require(SUPPORTS_PUT)
  public void testAbsent() {
    assertEquals(
        "Map.merge(absent, value, function) should return value",
        v3(),

  @Override
  public <T extends @NonNull B> @Nullable T getInstance(Class<T> type) {
    return trustedGet(TypeToken.of(type));
  }

  @Override
  public <T extends @NonNull B> @Nullable T getInstance(TypeToken<T> type) {
    return trustedGet(type.rejectTypeVariables());
  }

  @Override
  @CanIgnoreReturnValue
  public <T extends B> @Nullable T putInstance(
      Class<@NonNull T> type, @ParametricNullness T value) {

import junit.framework.TestCase;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/** Test case for {@link TrustedListenableFutureTask}. */
@NullMarked
@GwtCompatible
public class TrustedListenableFutureTaskTest extends TestCase {

  public void testSuccessful() throws Exception {
    TrustedListenableFutureTask<Integer> task = TrustedListenableFutureTask.create(returning(2));

# Geschichte, Design und Zukunft

Vor einiger Zeit fragte <a href="https://github.com/fastapi/fastapi/issues/3#issuecomment-454956920" class="external-link" target="_blank">ein **FastAPI**-Benutzer</a>:

> Was ist die Geschichte dieses Projekts? Es scheint, als wäre es in ein paar Wochen aus dem Nichts zu etwas Großartigem geworden [...]

Hier ist ein wenig über diese Geschichte.

## Alternativen