assertFalse(range.encloses(Range.openClosed(2, 5)));
    assertFalse(range.encloses(Range.closedOpen(2, 5)));
    assertFalse(range.encloses(Range.closed(1, 4)));
    assertFalse(range.encloses(Range.closed(3, 6)));
    assertFalse(range.encloses(Range.greaterThan(3)));
    assertFalse(range.encloses(Range.lessThan(3)));
    assertFalse(range.encloses(Range.atLeast(3)));

        assertEquals(true, docMap.get("key3"));

        assertTrue(docMap.containsKey("key1"));
        assertTrue(docMap.containsValue("value1"));
        assertFalse(docMap.containsKey("nonexistent"));
        assertFalse(docMap.containsValue("nonexistent"));
    }

    public void test_put_and_get() {
        Map<String, Object> parentMap = new HashMap<>();
        DocMap docMap = new DocMap(parentMap);

        // Should return false when write caching is not enabled
        assertFalse(DirectoryLeaseState.canCacheModifications(Smb2LeaseState.SMB2_LEASE_NONE));
        assertFalse(DirectoryLeaseState.canCacheModifications(Smb2LeaseState.SMB2_LEASE_READ_CACHING));
        assertFalse(DirectoryLeaseState.canCacheModifications(Smb2LeaseState.SMB2_LEASE_HANDLE_CACHING));

    public void test_isUseTimeZoneHandling() {
        // Verify that time zone handling is disabled
        assertFalse(provider.isUseTimeZoneHandling());
    }

    // Test isAcceptCookieTimeZone() method
    public void test_isAcceptCookieTimeZone() {
        // Verify that cookie time zone is not accepted
        assertFalse(provider.isAcceptCookieTimeZone());
    }

    // Test findBusinessTimeZone() method

  }

  public void testContains_no() {
    assertFalse("contains(notPresent) should return false", collection.contains(e3()));
  }

  @CollectionFeature.Require(ALLOWS_NULL_QUERIES)
  public void testContains_nullNotContainedButQueriesSupported() {
    assertFalse("contains(null) should return false", collection.contains(null));
  }

        TestResource resource2 = new TestResource("cleanup2");

        resourceManager.registerResource(resource1);
        resourceManager.registerResource(resource2);

        assertFalse(resource1.isClosed());
        assertFalse(resource2.isClosed());

        int cleaned = resourceManager.forceCleanup();
        assertTrue(cleaned >= 2);

        assertTrue(resource1.isClosed());

package jcifs.util.transport;

import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

        // Then - all keys should be different from each other
        assertFalse(Arrays.equals(signingKey, appKey), "Signing and application keys should be different");
        assertFalse(Arrays.equals(signingKey, encKey), "Signing and encryption keys should be different");
        assertFalse(Arrays.equals(signingKey, decKey), "Signing and decryption keys should be different");

    b = asList(4, 8, 15, 16, 23, 42);
    assertFalse(elementsEqual(a.iterator(), b.iterator()));
    assertFalse(elementsEqual(b.iterator(), a.iterator()));

    // Different lengths, one is empty.
    a = emptySet();
    b = asList(4, 8, 15, 16, 23, 42);
    assertFalse(elementsEqual(a.iterator(), b.iterator()));
    assertFalse(elementsEqual(b.iterator(), a.iterator()));
  }

  public void testPartition_badSize() {

  }

  protected void expectMissingKeys(K... elements) {
    for (K element : elements) {
      assertFalse("Should not contain key " + element, getMap().containsKey(element));
    }
  }

  protected void expectMissingValues(V... elements) {
    for (V element : elements) {
      assertFalse("Should not contain value " + element, getMap().containsValue(element));
    }
  }

  /**