for (SearchLogEvent event : events) {
            // All methods should be callable without exceptions
            String id = event.getId();
            Long version = event.getVersionNo();
            Map<String, Object> source = event.toSource();
            String type = event.getEventType();

            // Just verify the methods are callable
            assertTrue(true);
        }
    }

import com.google.common.annotations.J2ktIncompatible;
import com.google.common.collect.ImmutableMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;

/**
 * This class provides a skeletal implementation of the {@code Cache} interface to minimize the

import static java.util.concurrent.TimeUnit.MILLISECONDS;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.atomic.AtomicReference;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

## 參數化的相依 { #parameterized-dependencies }

到目前為止看到的相依都是固定的函式或類別。

但有些情況下，你可能想要能為相依設定參數，而不必宣告許多不同的函式或類別。

想像我們想要一個相依，用來檢查查詢參數 `q` 是否包含某些固定內容。

同時我們希望能將那個固定內容參數化。

## 「callable」的實例 { #a-callable-instance }

在 Python 中有一種方式可以讓一個類別的實例變成「callable」。

不是類別本身（類別本來就可呼叫），而是該類別的實例。

要做到這點，我們宣告一個 `__call__` 方法：

{* ../../docs_src/dependencies/tutorial011_an_py310.py hl[12] *}

        try {
            target.expired();
        } catch (Exception e) {
            // Expected that it may fail due to missing dependencies in test environment
            // but method should be callable
            assertNotNull(e, "Exception should not be null if thrown");
        }
    }

    @Test
    public void test_package_structure() {

## 参数化的依赖项 { #parameterized-dependencies }

目前我们看到的依赖项都是固定的函数或类。

但有时你可能希望为依赖项设置参数，而不必声明许多不同的函数或类。

假设我们要有一个依赖项，用来检查查询参数 `q` 是否包含某个固定内容。

但我们希望能够把这个固定内容参数化。

## “可调用”的实例 { #a-callable-instance }

在 Python 中，可以让某个类的实例变成“可调用对象”（callable）。

这里指的是类的实例（类本身已经是可调用的），而不是类本身。

为此，声明一个 `__call__` 方法：

{* ../../docs_src/dependencies/tutorial011_an_py310.py hl[12] *}

Aber wir wollen diesen vordefinierten Inhalt per Parameter festlegen können.

## Eine „aufrufbare“ Instanz { #a-callable-instance }

In Python gibt es eine Möglichkeit, eine Instanz einer Klasse <abbr title="Englisch „callable“">„aufrufbar“</abbr> zu machen.

Nicht die Klasse selbst (die bereits aufrufbar ist), sondern eine Instanz dieser Klasse.

Dazu deklarieren wir eine Methode `__call__`:

import static java.lang.Math.max;

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.MoreObjects;
import java.util.Objects;
import java.util.concurrent.Callable;
import org.jspecify.annotations.Nullable;

/**
 * Statistics about the performance of a {@link Cache}. Instances of this class are immutable.
 *
 * <p>Cache statistics are incremented according to the following rules:

import static java.lang.Math.max;

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.MoreObjects;
import java.util.Objects;
import java.util.concurrent.Callable;
import org.jspecify.annotations.Nullable;

/**
 * Statistics about the performance of a {@link Cache}. Instances of this class are immutable.
 *
 * <p>Cache statistics are incremented according to the following rules:

   * *J2CL* doesn't look at it.)
   *
   * However, once it's a @JsMethod, GWT produces a warning. That's because (a) the *other* purpose
   * of @JsMethod is to make a method *callable* from JavaScript and (b) this method would not be
   * useful to call from vanilla JavaScript because it returns an instance of Class, which can't be