private class DnsSystem : Dns {
      override fun lookup(hostname: String): List<InetAddress> {
        try {
          return InetAddress.getAllByName(hostname).toList()
        } catch (e: NullPointerException) {
          throw UnknownHostException("Broken system behaviour for dns lookup of $hostname").apply {
            initCause(e)
          }
        }
      }
    }
  }

   * original interned instance was garbage-collected.
   *
   * <p><b>Warning:</b> do not use with mutable objects.
   *
   * @throws NullPointerException if {@code sample} is null
   */
  E intern(E sample);

        override fun contains(element: Protocol?): Boolean {
          if (element == null) throw NullPointerException()
          return super.contains(element)
        }

        override fun indexOf(element: Protocol?): Int {
          if (element == null) throw NullPointerException()
          return super.indexOf(element)
        }
      } as List<Protocol>
    val client =
      OkHttpClient

    assertSetCount(null, 1);
  }

  @CollectionFeature.Require(value = SUPPORTS_ADD, absent = ALLOWS_NULL_VALUES)
  public void testSetCount_addNull_nullUnsupported() {
    assertThrows(NullPointerException.class, () -> setCountNoCheckReturnValue(null, 1));
  }

  @CollectionFeature.Require(ALLOWS_NULL_VALUES)
  public void testSetCount_noOpNull_nullSupported() {
    try {
      assertSetCount(null, 0);

   *       Objects.equals}{@code (a, b)} implies that {@code Objects.equals(function.apply(a),
   *       function.apply(b))}.
   * </ul>
   *
   * @throws NullPointerException if {@code input} is null and this function does not accept null
   *     arguments
   */
  @ParametricNullness
  T apply(@ParametricNullness F input);

  /**

  @CollectionSize.Require(absent = ZERO)
  public void testSetValueNullUnsupported() {
    for (Entry<K, V> entry : getMap().entrySet()) {
      assertThrows(NullPointerException.class, () -> entry.setValue(null));
      expectUnchanged();
    }
  }

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})
  @CollectionSize.Require(absent = ZERO)

  }

  // This test assumes that the implementation does not support null keys.
  public void testRowNull() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertThrows(NullPointerException.class, () -> table.row(null));
  }

  public void testColumn() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertEquals(ImmutableMap.of("foo", 'a', "bar", 'b'), table.column(1));

        assertNotNull(nullBufferResponse);

        // But trying to read data should cause NullPointerException
        byte[] buffer = new byte[10];
        assertThrows(NullPointerException.class, () -> nullBufferResponse.readDataWireFormat(buffer, 0, 5));
    }

    @Test
    void testReadDataWireFormatWithNegativeLength() {

 */
@GwtCompatible
@NullUnmarked
public class ArrayBasedEscaperMapTest extends TestCase {
  @SuppressWarnings("nullness") // test of a bogus call
  public void testNullMap() {
    assertThrows(NullPointerException.class, () -> ArrayBasedEscaperMap.create(null));
  }

  public void testEmptyMap() {
    Map<Character, String> map = ImmutableMap.of();
    ArrayBasedEscaperMap fem = ArrayBasedEscaperMap.create(map);

  }

  @MapFeature.Require(absent = ALLOWS_NULL_KEY_QUERIES)
  public void testGet_nullNotContainedAndUnsupported() {
    try {
      assertNull("get(null) should return null or throw", get(null));
    } catch (NullPointerException tolerated) {
    }
  }

  @MapFeature.Require(ALLOWS_NULL_KEYS)
  @CollectionSize.Require(absent = ZERO)
  public void testGet_nonNullWhenNullContained() {
    initMapWithNullKey();