expectAdded((E) null);
  }

  @CollectionFeature.Require(value = SUPPORTS_ADD, absent = ALLOWS_NULL_VALUES)
  public void testOffer_nullUnsupported() {
    assertThrows(NullPointerException.class, () -> getQueue().offer(null));
    expectUnchanged();
    expectNullMissingWhenNullUnsupported("Should not contain null after unsupported offer(null)");
  }

    }

    public void test_constructor_withStatusCodeAndNullException() {
        // Test constructor with status code and null exception
        int statusCode = 400;
        NullPointerException cause = new NullPointerException();

        WebApiException exception = new WebApiException(statusCode, cause);

        assertEquals(statusCode, exception.getStatusCode());
        assertNull(exception.getMessage());

        @Test
        @DisplayName("null handle throws NPE")
        void nullHandle() {
            assertThrows(NullPointerException.class, () -> new SmbPipeInputStream(null, tree));
        }

        @Test
        @DisplayName("null tree throws NPE")
        void nullTree() {
            assertThrows(NullPointerException.class, () -> new SmbPipeInputStream(handle, null));
        }
    }

        System.out.println(ex.getMessage());
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetCause() throws Exception {
        final Throwable t = new NullPointerException("test");
        final ClRuntimeException ex = new ClRuntimeException("ECL0017", asArray(t), t);
        assertThat(ex.getCause(), is(t));
        ex.printStackTrace();
    }

    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)
          }
        }
      }
    }
  }

/**
 * @author David Beaumont
 */
@GwtCompatible
@NullUnmarked
public class ArrayBasedEscaperMapTest extends TestCase {
  public void testNullMap() {
    assertThrows(NullPointerException.class, () -> ArrayBasedEscaperMap.create(null));
  }

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

   * 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);

    public void test_execute_withNullPointerException() {
        // Create mock SearchEngineClient that throws NullPointerException
        searchEngineClient = new SearchEngineClient() {
            @Override
            public long deleteByQuery(String index, QueryBuilder query) {
                throw new NullPointerException("Null value encountered");
            }
        };

  public void testContainsNullValueNo() {
    assertFalse(multimap().containsValue(null));
  }

  @MapFeature.Require(absent = ALLOWS_NULL_VALUE_QUERIES)
  public void testContainsNullValueFails() {
    assertThrows(NullPointerException.class, () -> multimap().containsValue(null));
  }

  @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)