/** Annotates a public method that declares subtype assertion. */
  @RequiredModifiers(modifier = Modifier.PUBLIC)
  @Retention(RetentionPolicy.RUNTIME)
  @Target(ElementType.METHOD)
  @Keep
  @interface TestSubtype {
    /** Suppresses the assertion on {@link TypeToken#getSubtype}. */
    boolean suppressGetSubtype() default false;

    /** Suppresses the assertion on {@link TypeToken#getSupertype}. */

    assertEquals((Character) 'b', table.get("bar", 1));
    assertSize(3);
    assertEquals((Character) 'd', table.put("foo", 1, cellValue('d')));
    assertEquals((Character) 'd', table.get("foo", 1));
    assertSize(3);
  }

  public void testPutNull() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertSize(3);

    assertEquals((Character) 'b', table.get("bar", 1));
    assertSize(3);
    assertEquals((Character) 'd', table.put("foo", 1, cellValue('d')));
    assertEquals((Character) 'd', table.get("foo", 1));
    assertSize(3);
  }

  public void testPutNull() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertSize(3);

  public void testNullPointerInstance() {}

  // put() and putAll() aren't supported.
  @Override
  public void testPut() {
    assertThrows(UnsupportedOperationException.class, () -> table.put("foo", 1, 'a'));
    assertSize(0);
  }

  @Override
  public void testPutAllTable() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    Table<String, Integer, Character> other = HashBasedTable.create();

    assertTrue(table.isEmpty());
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertFalse(table.isEmpty());
  }

  public void testSize() {
    assertSize(0);
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertSize(3);
  }

  public void testEquals() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    // We know that we have only added non-null Characters.

#ifndef TENSORFLOW_C_C_OP_REQUIRES_H_
#define TENSORFLOW_C_C_OP_REQUIRES_H_

#include "tensorflow/core/platform/macros.h"

namespace tensorflow {

// Convenience macros for asserting and handling exceptional conditions, for
// C structs, including `TF_OpKernelContext`, `TF_Status`, etc. This is analogus
// to the macros in tensorflow/core/framework/op_requires.h. This is provided

          assertThat(test.dispatcherB.closed).isTrue()
          assertThat(test.dispatcherC.closed).isFalse() // Never started.
        }
        testInstances.clear()

        // No assertion that serverC and serverD are closed, because the MockWebServerExtension
        // runs after this callback.
        if (false) {
          assertThat(dispatcherD.closed).isTrue()

async def test_raw_stream_cancellation() -> None:
    """Raw streaming endpoint should be cancellable within a reasonable time."""
    cancelled = await _run_asgi_and_cancel(app, "/stream-raw", timeout=3.0)
    # The key assertion: we reached this line at all (didn't hang).
    # cancelled will be True because the infinite generator was interrupted.
    assert cancelled


async def test_jsonl_stream_cancellation() -> None:

import com.fasterxml.jackson.databind.node.ObjectNode;

import org.elasticsearch.gradle.internal.test.rest.transform.ReplaceByKey;
import org.gradle.api.tasks.Internal;

/**
 * A transformation to replace the key in a length assertion, must be a numeric type
 * For example, change from "length":{"index._doc": 1} to "length":{"index._doc": 2}
 */
public class ReplaceValueInLength extends ReplaceByKey {

   * the call to {@code contains(null)} is permitted to throw a {@code NullPointerException}.
   *
   * @param message message to use upon assertion failure
   */
  protected void expectNullKeyMissingWhenNullKeysUnsupported(String message) {
    try {
      assertFalse(message, getMap().containsKey(null));
    } catch (NullPointerException tolerated) {