static class CustomRuntimeException extends RuntimeException {}

  public void testCatching() throws Exception {
    FluentFuture<?> f =
        FluentFuture.from(immediateFailedFuture(new CustomRuntimeException()))
            .catching(
                Throwable.class,
                new Function<Throwable, Class<?>>() {
                  @Override

            entity.setLastUpdated(System.currentTimeMillis());
        }
    }

    // Simple mock class without complex interface requirements
    private static class MockLaCron implements LaCron {
        @Override
        public org.lastaflute.job.subsidiary.RegisteredJob register(String cronExp, Class<? extends org.lastaflute.job.LaJob> jobType,

///

## Mais informações

Para aprender mais sobre as opções, verifique a documentação do Starlette para:

* <a href="https://www.starlette.io/websockets/" class="external-link" target="_blank">A classe `WebSocket`</a>.

/**
 * Tests representing the contract of {@link SortedMap}. Concrete subclasses of this base class test
 * conformance of concrete {@link SortedMap} subclasses to that contract.
 *
 * @author Jared Levy
 */
// TODO: Use this class to test classes besides ImmutableSortedMap.
@GwtCompatible
public abstract class SortedMapInterfaceTest<K, V> extends MapInterfaceTest<K, V> {

  protected SortedMapInterfaceTest(

 * is a thin wrapper around {@link InetAddresses} and {@link InternetDomainName}; the unit tests for
 * those classes explore numerous corner cases. The intent here is to confirm that everything is
 * wired up properly.
 *
 * @author Craig Berry
 */
@NullUnmarked
public final class HostSpecifierTest extends TestCase {

  private static final ImmutableList<String> GOOD_IPS =

/**
 * Tests representing the contract of {@link SortedMap}. Concrete subclasses of this base class test
 * conformance of concrete {@link SortedMap} subclasses to that contract.
 *
 * @author Jared Levy
 */
// TODO: Use this class to test classes besides ImmutableSortedMap.
@GwtCompatible
public abstract class SortedMapInterfaceTest<K, V> extends MapInterfaceTest<K, V> {

  protected SortedMapInterfaceTest(

  // public named classes with a public default constructor.

  public static final class DoublesAsListGenerator extends TestDoubleListGenerator {
    @Override
    protected List<Double> create(Double[] elements) {
      return asList(elements);
    }
  }

  public static final class DoublesAsListHeadSubListGenerator extends TestDoubleListGenerator {
    @Override

import java.util.concurrent.Future;
import org.jspecify.annotations.NullUnmarked;
import org.jspecify.annotations.Nullable;

/**
 * Classes and futures used in {@link FuturesGetCheckedTest} and {@link FuturesGetUncheckedTest}.
 */
@GwtCompatible
@NullUnmarked
final class FuturesGetCheckedInputs {
  static final Exception CHECKED_EXCEPTION = new Exception("mymessage");
  static final Future<String> FAILED_FUTURE_CHECKED_EXCEPTION =

        return connection.getContent();
    }

    @Override
    public Object getContent(final Class[] classes) throws IOException {
        try {
            handshake();
        } catch (final IOException ex) {}
        return connection.getContent(classes);
    }

    @Override
    public Permission getPermission() throws IOException {
        return connection.getPermission();

# Custom Request and APIRoute class { #custom-request-and-apiroute-class }

In some cases, you may want to override the logic used by the `Request` and `APIRoute` classes.

In particular, this may be a good alternative to logic in a middleware.

For example, if you want to read or manipulate the request body before it is processed by your application.

/// danger

This is an "advanced" feature.