@Override
  protected abstract Multimap<K, V> delegate();

  @Override
  public Map<K, Collection<V>> asMap() {
    return delegate().asMap();
  }

  @Override
  public void clear() {
    delegate().clear();
  }

  @Override
  public boolean containsEntry(@Nullable Object key, @Nullable Object value) {
    return delegate().containsEntry(key, value);
  }

  @Override

  @Override
  protected abstract Multimap<K, V> delegate();

  @Override
  public Map<K, Collection<V>> asMap() {
    return delegate().asMap();
  }

  @Override
  public void clear() {
    delegate().clear();
  }

  @Override
  public boolean containsEntry(@Nullable Object key, @Nullable Object value) {
    return delegate().containsEntry(key, value);
  }

  @Override

public class DataConfigPagerTest extends UnitFessTestCase {

    public void test_DataConfigPager() {
        DataConfigPager dataconfigpager = new DataConfigPager();

        dataconfigpager.clear();
        assertEquals(0, dataconfigpager.getAllRecordCount());
        assertEquals(0, dataconfigpager.getAllPageCount());
        assertEquals(false, dataconfigpager.isExistPrePage());

        factoryField.set(null, null);

        // Clear the protocol handlers cache
        Field handlersField = Handler.class.getDeclaredField("PROTOCOL_HANDLERS");
        handlersField.setAccessible(true);
        @SuppressWarnings("unchecked")
        Map<String, URLStreamHandler> handlers = (Map<String, URLStreamHandler>) handlersField.get(null);
        handlers.clear();
    }

    /**

        // Create a defensive copy to avoid ConcurrentModificationException
        List<CommonServerMessageBlock> operationsCopy = List.copyOf(pendingOps);

        // Clear the failed channel's pending operations first
        failedChannel.clearPendingOperations();

        // Redistribute to healthy channels
        for (CommonServerMessageBlock op : operationsCopy) {
            try {

  }

  @Override
  public boolean addAll(Collection<? extends E> c) {
    assertTrue(Thread.holdsLock(mutex));
    return super.addAll(c);
  }

  @Override
  public void clear() {
    assertTrue(Thread.holdsLock(mutex));
    super.clear();
  }

  @Override
  public boolean contains(@Nullable Object o) {
    assertTrue(Thread.holdsLock(mutex));
    return super.contains(o);
  }

  @Override

    public boolean containsValue(@Nullable Object value) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.containsValue(value);
    }

    @Override
    public void clear() {
      assertTrue(Thread.holdsLock(mutex));
      delegate.clear();
    }

    @Override
    public Collection<V> values() {
      assertTrue(Thread.holdsLock(mutex));
      /* TODO: verify that the Collection is also synchronized? */

    /**
     * The created time.
     */
    public String createdTime;

    /**
     * The version number.
     */
    public String versionNo;

    /**
     * Clear the pager.
     */
    public void clear() {
        allRecordCount = 0;
        allPageCount = 0;
        existPrePage = false;
        existNextPage = false;
        pageSize = getDefaultPageSize();

    }

    @Override
    public boolean contains(@Nullable Object o) {
      return AbstractMultimap.this.containsValue(o);
    }

    @Override
    public void clear() {
      AbstractMultimap.this.clear();
    }
  }

  Iterator<V> valueIterator() {
    return Maps.valueIterator(entries().iterator());
  }

  @LazyInit private transient @Nullable Map<K, Collection<V>> asMap;

{* ../../docs_src/background_tasks/tutorial001.py hl[1,13] *}

**FastAPI** créera l'objet de type `BackgroundTasks` pour vous et le passera comme paramètre.

## Créer une fonction de tâche

Une fonction à exécuter comme tâche d'arrière-plan est juste une fonction standard qui peut recevoir des paramètres.