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

    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() {

        assertTrue(filter.include(newArtifact(Artifact.SCOPE_SYSTEM)));
        assertTrue(filter.include(newArtifact(Artifact.SCOPE_PROVIDED)));
        assertFalse(filter.include(newArtifact(Artifact.SCOPE_RUNTIME)));
        assertFalse(filter.include(newArtifact(Artifact.SCOPE_TEST)));
    }

    @Test
    void testInclude_CompilePlusRuntime() {

    assertTrue(map.isEmpty());
    assertEquals(0, map.size());
    assertFalse(map.containsKey("1"));
    assertFalse(map.containsKey("2"));
    assertFalse(map.containsKey("3"));
    assertEquals(0L, map.get("1"));
    assertEquals(0L, map.get("2"));
    assertEquals(0L, map.get("3"));

    map.putAll(in);
    assertFalse(map.isEmpty());
    assertEquals(3, map.size());
    assertTrue(map.containsKey("1"));

      assertTrue(name, domain.hasPublicSuffix());
      assertFalse(name, domain.isUnderPublicSuffix());
      assertFalse(name, domain.isTopPrivateDomain());
      assertEquals(domain, domain.publicSuffix());
    }

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

        regexRule.addRule("mimeType", Pattern.compile("text/html"));

        assertTrue(regexRule.match(getTestData1()));
        assertFalse(regexRule.match(getTestData2()));
        assertFalse(regexRule.match(getTestData3()));
        assertFalse(regexRule.match(getTestData4()));
    }

    public void test_match_or() {
        final RegexRule regexRule = new RegexRule();

        assertFalse(auth.matches("ftp://hostname:111/"));
        assertFalse(auth.matches("ftp://hostname:xx/"));
        assertFalse(auth.matches("ftp://hoge/test/aaa.html"));
        assertFalse(auth.matches("ftp://hoge/test"));
        assertFalse(auth.matches("ftp://hoge/"));
        assertFalse(auth.matches("ftp://hoge"));
        assertFalse(auth.matches("ftp://"));

    assertEquals(e0(), entryItr.next());
    entryItr.remove();
    assertTrue(getMap().isEmpty());
    assertFalse(entrySet.contains(e0()));
  }

  public void testContainsEntryWithIncomparableKey() {
    try {
      assertFalse(getMap().entrySet().contains(mapEntry(IncomparableType.INSTANCE, v0())));
    } catch (ClassCastException acceptable) {
      // allowed by the spec
    }
  }

    assertEquals(e0(), entryItr.next());
    entryItr.remove();
    assertTrue(getMap().isEmpty());
    assertFalse(entrySet.contains(e0()));
  }

  public void testContainsEntryWithIncomparableKey() {
    try {
      assertFalse(getMap().entrySet().contains(mapEntry(IncomparableType.INSTANCE, v0())));
    } catch (ClassCastException acceptable) {
      // allowed by the spec
    }
  }

import org.eclipse.aether.util.version.GenericVersionScheme;
import org.junit.jupiter.api.Test;

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

public class VersionRangeTest {