assertThrows(NoSuchElementException.class, () -> navigableMap.firstKey());
  }

  @CollectionSize.Require(ZERO)
  public void testEmptyMapLast() {
    assertThrows(NoSuchElementException.class, () -> assertNull(navigableMap.lastKey()));
  }

  @CollectionSize.Require(ONE)
  public void testSingletonMapFirst() {
    assertEquals(a.getKey(), navigableMap.firstKey());
  }

  @CollectionSize.Require(ONE)

    if (chunk1 > 0) {
      write(out, data, 0, chunk1, singleByte);
      assertTrue(ByteSource.wrap(data).slice(0, chunk1).contentEquals(source));
    }
    File file = out.getFile();
    assertNull(file);

    // Write data to go over the threshold
    if (chunk2 > 0) {
      if (JAVA_IO_TMPDIR.value().equals("/sdcard")) {
        assertThrows(IOException.class, () -> write(out, data, chunk1, chunk2, singleByte));

    }

    /**
     * Test Rule with null rule ID
     */
    public void test_nullRuleId() {
        TestRule rule = new TestRule(null, new TestResponseProcessor("test"), true);

        assertNull(rule.getRuleId());

        ResponseData responseData = new ResponseData();
        assertTrue(rule.match(responseData));
    }

    /**
     * Test Rule with null ResponseProcessor
     */

    assertEquals("bar", getOnlyElement(iterator, "bar"));
  }

  public void testGetOnlyElement_withDefault_empty_null() {
    Iterator<String> iterator = emptyIterator();
    assertNull(Iterators.<@Nullable String>getOnlyElement(iterator, null));
  }

  public void testGetOnlyElement_withDefault_two() {
    Iterator<String> iterator = asList("foo", "bar").iterator();

    assertEquals("bar", getOnlyElement(iterable, "bar"));
  }

  public void testGetOnlyElement_withDefault_empty_null() {
    Iterable<String> iterable = emptyList();
    assertNull(Iterables.<@Nullable String>getOnlyElement(iterable, null));
  }

  public void testGetOnlyElement_withDefault_multiple() {
    Iterable<String> iterable = asList("foo", "bar");

        result = (String) method.invoke(keyMatchHelper, "Mixed_Case");
        assertEquals("mixed_case", result);

        result = (String) method.invoke(keyMatchHelper, (String) null);
        assertNull(result);

        result = (String) method.invoke(keyMatchHelper, "");
        assertEquals("", result);

        result = (String) method.invoke(keyMatchHelper, "Test123");

        }
    }

    public void test_addShutdownListener_null() {
        // Test adding null listener
        jobExecutor.addShutdownListener(null);
        assertNull(jobExecutor.shutdownListener);

        // Shutdown with null listener should throw NullPointerException
        try {
            jobExecutor.shutdown();
            fail("Expected NullPointerException");

      assertFalse(name, domain.isPublicSuffix());
      assertFalse(name, domain.hasPublicSuffix());
      assertFalse(name, domain.isUnderPublicSuffix());
      assertFalse(name, domain.isTopPrivateDomain());
      assertNull(domain.publicSuffix());
    }

    for (String name : NON_PS) {
      InternetDomainName domain = InternetDomainName.from(name);
      assertFalse(name, domain.isPublicSuffix());

        QueryBuilder builder = queryCommand.convertTermQuery(queryContext, (TermQuery) query, 1.0f);
        if (text.startsWith("sort:")) {
            assertNull(builder);
        } else {
            logger.info("{} => {}", text, builder.toString());
            assertEquals(expectedClass, builder.getClass());

        ProtwordsFile.ProtwordsUpdater updater = protwordsFile.new ProtwordsUpdater(item);

        // Write the same item (should delete)
        ProtwordsItem result = updater.write(item);

        assertNull(result);

        updater.close();
    }

    public void test_ProtwordsUpdater_write_mismatchException() {
        protwordsFile.reload(null);

        // Create an item for update