// Verify the class is generic
        final java.lang.reflect.TypeVariable<?>[] typeParameters = FessActionValidator.class.getTypeParameters();
        assertEquals("Should have one type parameter", 1, typeParameters.length);
        assertEquals("Type parameter should be MESSAGES", "MESSAGES", typeParameters[0].getName());
    }

    public void test_packageStructure() {

* De variabele `items_s` is een `set`, en elk van de items is van het type `bytes`.

#### Dict

Om een `dict` te definiëren, geef je 2 typeparameters door, gescheiden door komma's.

De eerste typeparameter is voor de sleutels (keys) van de `dict`.

De tweede typeparameter is voor de waarden  (values) van het `dict`:

//// tab | Python 3.9+

```Python hl_lines="1"

        final Map<TypeVariable<?>, Type> map = CollectionsUtil.newLinkedHashMap();

        final TypeVariable<?>[] typeParameters = clazz.getTypeParameters();
        for (final TypeVariable<?> typeParameter : typeParameters) {
            map.put(typeParameter, getActualClass(typeParameter.getBounds()[0], map));
        }

        final Class<?> superClass = clazz.getSuperclass();

 *   return new TypeToken<List<T>>() {}
 *       .where(new TypeParameter<T>() {}, elementType);
 * }
 * }
 *
 * @author Ben Yu
 * @since 12.0
 */
/*
 * A nullable bound would let users create a TypeParameter instance for a parameter with a nullable
 * bound. However, it would also let them create `new TypeParameter<@Nullable T>() {}`, which

 *   return new TypeToken<List<T>>() {}
 *       .where(new TypeParameter<T>() {}, elementType);
 * }
 * }
 *
 * @author Ben Yu
 * @since 12.0
 */
/*
 * A nullable bound would let users create a TypeParameter instance for a parameter with a nullable
 * bound. However, it would also let them create `new TypeParameter<@Nullable T>() {}`, which

    assertThrows(IllegalArgumentException.class, () -> new TypeParameter<String>() {});
  }

  public <A, B> void testEquals() throws Exception {
    Method method = TypeParameterTest.class.getDeclaredMethod("testEquals");
    new EqualsTester()
        .addEqualityGroup(new TypeParameter<A>() {}, new TypeParameter<A>() {})
        .addEqualityGroup(new TypeParameter<B>() {})
        .testEquals();
  }

    assertThrows(IllegalArgumentException.class, () -> new TypeParameter<String>() {});
  }

  public <A, B> void testEquals() throws Exception {
    Method method = TypeParameterTest.class.getDeclaredMethod("testEquals");
    new EqualsTester()
        .addEqualityGroup(new TypeParameter<A>() {}, new TypeParameter<A>() {})
        .addEqualityGroup(new TypeParameter<B>() {})
        .testEquals();
  }

    }
  }

  private static final class TypeParameterSignature {
    final String name;
    final List<Type> bounds;

    TypeParameterSignature(TypeVariable<?> typeParameter) {
      name = typeParameter.getName();
      bounds = asList(typeParameter.getBounds());
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      if (obj instanceof TypeParameterSignature) {

    return new TypeToken<Map<K, V>>() {}.where(new TypeParameter<K>() {}, keyType)
        .where(new TypeParameter<V>() {}, valueType);
  }

  private static <T> TypeToken<T[]> arrayOf(Class<T> componentType) {
    return new TypeToken<T[]>() {}.where(new TypeParameter<T>() {}, componentType);
  }

  public <T> void testNulls() {

    return new TypeToken<Map<K, V>>() {}.where(new TypeParameter<K>() {}, keyType)
        .where(new TypeParameter<V>() {}, valueType);
  }

  private static <T> TypeToken<T[]> arrayOf(Class<T> componentType) {
    return new TypeToken<T[]>() {}.where(new TypeParameter<T>() {}, componentType);
  }

  public <T> void testNulls() {