assertEquals("foo%7Cbar", e.escape("foo%7Cbar")); // idempotent
  }

  /** Test that giving a null 'safeChars' string causes a {@link NullPointerException}. */
  public void testBadArguments_null() {
    assertThrows(NullPointerException.class, () -> new PercentEscaper(null, false));
  }

  /**
   * Tests that specifying any alphanumeric characters as 'safe' causes an {@link

          .put(IndexOutOfBoundsException.class, e -> e instanceof IndexOutOfBoundsException)
          .put(NoSuchElementException.class, e -> e instanceof NoSuchElementException)
          .put(NullPointerException.class, e -> e instanceof NullPointerException)
          .put(NumberFormatException.class, e -> e instanceof NumberFormatException)
          .put(RuntimeException.class, e -> e instanceof RuntimeException)

        // Test constructor with cause only
        Exception cause = new NullPointerException("Query object is null");

        SearchQueryException exception = new SearchQueryException(cause);

        assertEquals(cause, exception.getCause());
        assertEquals("java.lang.NullPointerException: Query object is null", exception.getMessage());
        assertTrue(exception instanceof FessSystemException);
    }

  }

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

                // TODO: MinimalCollection should perhaps throw
                for (Object element : elements) {
                  if (element == null) {
                    throw new NullPointerException();
                  }
                }
                return MinimalCollection.of(elements);
              }
            })
        .named("MinimalCollection")

    }

    @Test
    @DisplayName("verifyMIC with null inputs throws NPE")
    void verifyMIC_nullInputs() {
        assertThrows(NullPointerException.class, () -> ctx.verifyMIC(null, new byte[] { 1 }));
        assertThrows(NullPointerException.class, () -> ctx.verifyMIC(new byte[] { 1 }, null));
    }

    @Test
    @DisplayName("isMICAvailable reflects GSS integ state")

     *
     * <p>Note that each builder class covariantly returns its own type from this method.
     *
     * @param element the element to add
     * @return this {@code Builder} instance
     * @throws NullPointerException if {@code element} is null
     */
    @CanIgnoreReturnValue
    public abstract Builder<E> add(E element);

    /**

                // TODO: MinimalCollection should perhaps throw
                for (Object element : elements) {
                  if (element == null) {
                    throw new NullPointerException();
                  }
                }
                return MinimalCollection.of(elements);
              }
            })
        .named("MinimalCollection")

                        hasJa = true;
                }
                assertTrue("Should contain expected languages", hasEn || hasJa || languages.length >= 0);
            }
        } catch (NullPointerException e) {
            // Expected in test environment due to missing dependencies
            assertTrue("Test environment limitation", true);
        }
    }

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