* since the Equivalence base type now implements this logic itself
       */
      assertTrue(item + " must be inequivalent to null", !equivalence.equivalent(item, null));
      assertTrue("null must be inequivalent to " + item, !equivalence.equivalent(null, item));
      assertTrue(item + " must be equivalent to itself", equivalence.equivalent(item, item));
      assertEquals(

       * since the Equivalence base type now implements this logic itself
       */
      assertTrue(item + " must be inequivalent to null", !equivalence.equivalent(item, null));
      assertTrue("null must be inequivalent to " + item, !equivalence.equivalent(null, item));
      assertTrue(item + " must be equivalent to itself", equivalence.equivalent(item, item));
      assertEquals(

    multimap.put("foo", 3);
    multimap.put("foo", -1);
    multimap.put(null, null);
    multimap.put("bar", 1);
    multimap.put("foo", 2);
    multimap.put(null, 0);
    multimap.put("bar", 2);
    multimap.put("bar", null);
    multimap.put("foo", null);
    multimap.put("foo", 4);
    multimap.put(null, -1);
    multimap.put("bar", 3);
    multimap.put("bar", 1);
    multimap.put("foo", 1);

<div class="screenshot">
<img src="/img/tutorial/separate-openapi-schemas/image02.png">
</div>

Das bedeutet, dass es **immer einen Wert** hat, der Wert kann jedoch manchmal `None` sein (oder `null` in JSON).

        return System.getProperty(TEST_TOKEN, DEFAULT_TEST_TOKEN);
    }

    public static String settingTestToken() {
        final String testToken = System.getProperty(TEST_TOKEN);
        if (testToken != null) {
            logger.info("Token: {}", testToken);
            return testToken;
        }

        given().contentType("application/json").body("{\"index\":{\"_index\":\"fess_config.access_token\",\"_id\":\""

            url.scheme,
            challenge.realm,
            challenge.scheme,
            url.toUrl(),
            Authenticator.RequestorType.SERVER,
          )
        }

      if (auth != null) {
        val credentialHeader = if (proxyAuthorization) "Proxy-Authorization" else "Authorization"
        val credential =
          Credentials.basic(
            auth.userName,
            String(auth.password),

import java.util.AbstractMap.SimpleImmutableEntry;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A notification of the removal of a single entry. The key and/or value may be null if they were
 * already garbage collected.
 *
 * <p>Like other {@code Entry} instances associated with {@code CacheBuilder}, this class holds

 * support even a "normal" `TypeParameter<T>` when `<T>` has a nullable bound. (See the discussion
 * on TypeToken.where.) So, in the interest of failing fast and encouraging the user to switch to a
 * non-null bound if possible, let's require a non-null bound here.
 *
 * TODO(cpovirk): Elaborate on "wouldn't behave as users might expect."
 */
public abstract class TypeParameter<T> extends TypeCapture<T> {

  final TypeVariable<?> typeVariable;

  }

  @Override
  @CheckForNull
  public N removeInEdge(E edge, boolean isSelfLoop) {
    if (!isSelfLoop) {
      return removeOutEdge(edge);
    }
    return null;
  }

  @Override
  public N removeOutEdge(E edge) {
    N previousNode = incidentEdgeMap.remove(edge);
    // We're relying on callers to call this method only with an edge that's in the graph.

     * .
     */
    @Test
    public void testAssertArgumentNotNull() {
        exception.expect(NullArgumentException.class);
        exception.expectMessage(is("[ECL0008]argument[hoge] is null."));
        assertArgumentNotNull("hoge", null);
    }

    /**
     * Test method for
     * {@link org.codelibs.core.misc.AssertionUtil#assertArgument(String, boolean, String)}
     * .
     */
    @Test