public abstract static class SimpleForwardingLoadingCache<K, V>
      extends ForwardingLoadingCache<K, V> {
    private final LoadingCache<K, V> delegate;

    protected SimpleForwardingLoadingCache(LoadingCache<K, V> delegate) {
      this.delegate = Preconditions.checkNotNull(delegate);
    }

    @Override
    protected final LoadingCache<K, V> delegate() {
      return delegate;
    }
  }

 *
 * @since 4.0.0
 */
@Experimental
public class ModelBuilderException extends MavenException {

    @Serial
    private static final long serialVersionUID = -1865447022070650896L;

    private final ModelBuilderResult result;

    /**
     * Creates a new exception from the specified interim result and its associated problems.
     *

 *
 * @deprecated since 4.0.0, use {@link org.apache.maven.api.services} instead
 */
@Deprecated(since = "4.0.0")
public class FileSource implements Source {
    private final Path path;

    private final int hashCode;

    /**
     * Creates a new source backed by the specified file.
     *
     * @param file The file, must not be {@code null}.
     * @deprecated Use {@link #FileSource(Path)} instead.

```Python
app.dependency_overrides = {}
```

/// tip | Dica

Se você quer sobrepor uma dependência apenas para alguns testes, você pode definir a sobreposição no início do testes (dentro da função de teste) e reiniciá-la ao final (no final da função de teste).

 */
@GwtIncompatible
public final class FeatureUtil {
  /** A cache of annotated objects (typically a Class or Method) to its set of annotations. */
  private static final Map<AnnotatedElement, List<Annotation>> annotationCache = new HashMap<>();

  private static final Map<Class<?>, TesterRequirements> classTesterRequirementsCache =
      new HashMap<>();

            // Create a simple implementation for testing
            FileNotifyInformation impl = new FileNotifyInformation() {
                private final int action = FileNotifyInformation.FILE_ACTION_MODIFIED;
                private final String fileName = "implementation-test.txt";

                @Override
                public int getAction() {
                    return action;
                }

        @Test
        @DisplayName("Should handle compound with final response")
        void testCompoundFinalResponse() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[512];
            System.arraycopy(SMBUtil.SMB2_HEADER, 0, buffer, 0, 4);
            SMBUtil.writeInt4(0, buffer, 20); // nextCommand = 0 (final)

            testMessage.setBytesRead(10);

package okhttp3.slack;

import java.io.IOException;
import java.io.InterruptedIOException;
import okhttp3.HttpUrl;
import okio.Timeout;

/** A connection to Slack as a single user. */
public final class SlackClient {
  private final SlackApi slackApi;
  private OAuthSessionFactory sessionFactory;

  /** Guarded by this. */
  private OAuthSession session;

  public SlackClient(SlackApi slackApi) {
    this.slackApi = slackApi;

/**
 * Unit test for {@link FakeTimeLimiter}.
 *
 * @author Jens Nyman
 */
@NullUnmarked
public class FakeTimeLimiterTest extends TestCase {

  private static final int DELAY_MS = 50;
  private static final String RETURN_VALUE = "abc";

  private TimeLimiter timeLimiter;

  @Override
  protected void setUp() throws Exception {
    super.setUp();
    timeLimiter = new FakeTimeLimiter();
  }

              .withTearDown(parentBuilder.getTearDown())
              .createTestSuite());
    }
    return derivedSuites;
  }

  private static final class ReserializedCollectionGenerator<E>
      implements TestCollectionGenerator<E> {
    final OneSizeTestContainerGenerator<Collection<E>, E> gen;

    private ReserializedCollectionGenerator(OneSizeTestContainerGenerator<Collection<E>, E> gen) {
      this.gen = gen;