/** Tests that the {@link Future#get()} method blocks until a value is available. */
  public void testGetBlocksUntilValueAvailable() throws Throwable {

    assertFalse(future.isDone());
    assertFalse(future.isCancelled());

    ExecutorService executor = newSingleThreadExecutor();

    try {
      Future<Boolean> getResult = executor.submit(() -> future.get());

    assertEquals("a", iterator.next());
    assertFalse(iterator.hasNext());
    assertThrows(NoSuchElementException.class, iterator::next);
    assertThrows(IllegalStateException.class, iterable::iterator);
  }

  public void testFrom_empty() {
    Iterable<String> iterable = MinimalIterable.from(Collections.<String>emptySet());
    Iterator<String> iterator = iterable.iterator();
    assertFalse(iterator.hasNext());

    assertFalse(matcher.matches(s.charAt(0)));
    assertFalse(matcher.apply(s.charAt(0)));
    assertEquals(-1, matcher.indexIn(s));
    assertEquals(-1, matcher.indexIn(s, 0));
    assertEquals(-1, matcher.indexIn(s, 1));
    assertEquals(-1, matcher.lastIndexIn(s));
    assertFalse(matcher.matchesAnyOf(s));
    assertFalse(matcher.matchesAllOf(s));

        // None of the optional flags should be present
        assertFalse(options.plugins().isPresent(), "--plugins should not be present by default");
        assertFalse(options.all().isPresent(), "--all should not be present by default");
        assertFalse(options.infer().isPresent(), "--infer should not be present by default");
        assertFalse(options.model().isPresent(), "--fix-model should not be present by default");

        try {
            Path nonExistingFile = tempDir.resolve("non_existing.tmp");
            assertFalse(Files.exists(nonExistingFile));

            // Should return false without throwing exception
            boolean deleted = Files.deleteIfExists(nonExistingFile);

            assertFalse(deleted);
        } finally {
            deleteDirectory(tempDir.toFile());
        }
    }

    Predicate<@Nullable Object> equalTo1 = Equivalence.equals().equivalentTo("1");
    assertTrue(equalTo1.apply("1"));
    assertFalse(equalTo1.apply("2"));
    assertFalse(equalTo1.apply(null));
    Predicate<@Nullable Object> isNull = Equivalence.equals().equivalentTo(null);
    assertFalse(isNull.apply("1"));
    assertFalse(isNull.apply("2"));
    assertTrue(isNull.apply(null));

    new EqualsTester()

package jcifs.util.transport;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

    @Test
    public void testIsNotArray() {
        assertTrue(ArrayUtil.isNotArray(null));
        assertTrue(ArrayUtil.isNotArray("hoge"));
        assertFalse(ArrayUtil.isNotArray(new Object[] {}));
        assertFalse(ArrayUtil.isNotArray(new Object[] { "" }));
        assertFalse(ArrayUtil.isNotArray(new Object[] { "aaa" }));
    }

    void testEqualsWithDifferentObjectType() {
        SmbShareInfo info = new SmbShareInfo(TEST_NET_NAME, TEST_TYPE, TEST_REMARK);
        assertFalse(info.equals("Not a SmbShareInfo"));
        assertFalse(info.equals(null));
        assertFalse(info.equals(new Object()));
    }

    @Test
    @DisplayName("Test hashCode method")
    void testHashCode() {

    assertTrue(asMap.containsKey("foo"));
    assertFalse(asMap.containsKey("cow"));

    Set<Entry<String, Collection<Integer>>> entries = asMap.entrySet();
    assertFalse(entries.contains((Object) 4.5));
    assertFalse(entries.remove((Object) 4.5));
    assertFalse(entries.contains(Maps.immutableEntry("foo", singletonList(1))));
    assertFalse(entries.remove(Maps.immutableEntry("foo", singletonList(1))));