private Object proxy;

    @SuppressWarnings("unchecked") // proxy for a generic class
    <V> Callable<V> waitFor(Callable<V> callable) {
      return waitFor(callable, Callable.class);
    }

    @SuppressWarnings("unchecked") // proxy for a generic class
    <V> ClosingCallable<V> waitFor(ClosingCallable<V> closingCallable) {

    private Object proxy;

    @SuppressWarnings("unchecked") // proxy for a generic class
    <V> Callable<V> waitFor(Callable<V> callable) {
      return waitFor(callable, Callable.class);
    }

    @SuppressWarnings("unchecked") // proxy for a generic class
    <V> ClosingCallable<V> waitFor(ClosingCallable<V> closingCallable) {

import org.codelibs.fess.unit.UnitFessTestCase;
import org.junit.jupiter.api.Test;

public class UserRoleLoginExceptionTest extends UnitFessTestCase {

    // Mock subclass of RootAction for testing generic type safety
    private static class TestAction extends RootAction {
        // Test subclass
    }

    // Another mock subclass for testing
    private static class AdminAction extends RootAction {

def some_function(data: Any):
    print(data)
```

### Generic types { #generic-types }

Some types can take "type parameters" in square brackets, to define their internal types, for example a "list of strings" would be declared `list[str]`.

These types that can take type parameters are called **Generic types** or **Generics**.

You can use the same builtin types as generics (with square brackets and types inside):

* `list`

```python
from typing import Any


def some_function(data: Any):
    print(data)
```

### 泛型（Generic types） { #generic-types }

有些型別可以在方括號中接收「型別參數」，以定義其內部元素的型別，例如「字串的 list」可以宣告為 `list[str]`。

這些能接收型別參數的型別稱為「泛型（Generic types）」或「Generics」。

你可以將相同的內建型別用作泛型（使用方括號並在裡面放型別）：

* `list`
* `tuple`
* `set`
* `dict`

#### List { #list }

            fail("Constructor with RequestManager, UserMessagesCreator, and Class[] parameters should exist");
        }
    }

    @Test
    public void test_classStructure() {
        // Verify the class is generic
        final java.lang.reflect.TypeVariable<?>[] typeParameters = FessActionValidator.class.getTypeParameters();
        assertEquals("Should have one type parameter", 1, typeParameters.length);

* **`400 - 499`** are for "Client error" responses. These are the second type you would probably use the most.
    * An example is `404`, for a "Not Found" response.
    * For generic errors from the client, you can just use `400`.

import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
import java.util.NoSuchElementException;
import java.util.SortedMap;
import org.junit.Ignore;

/**
 * A generic JUnit test which tests operations on a SortedMap. Can't be invoked directly; please see
 * {@code SortedMapTestSuiteBuilder}.
 *
 * @author Jesse Wilson
 * @author Louis Wasserman
 */
@GwtCompatible

  public void testGenericInterface() {
    // test the 1st generic interface on the class
    Type fType = Supplier.class.getTypeParameters()[0];
    assertEquals(
        Integer.class, TypeToken.of(IntegerStringFunction.class).resolveType(fType).getRawType());

    // test the 2nd generic interface on the class
    Type predicateParameterType = Predicate.class.getTypeParameters()[0];

  public void testGenericInterface() {
    // test the 1st generic interface on the class
    Type fType = Supplier.class.getTypeParameters()[0];
    assertEquals(
        Integer.class, TypeToken.of(IntegerStringFunction.class).resolveType(fType).getRawType());

    // test the 2nd generic interface on the class
    Type predicateParameterType = Predicate.class.getTypeParameters()[0];