assertFalse(c3.isClosed());

    closer.close();

    assertTrue(c1.isClosed());
    assertTrue(c2.isClosed());
    assertTrue(c3.isClosed());

    assertTrue(suppressor.suppressions.isEmpty());
  }

  public void testExceptionThrown_fromTryBlock() throws IOException {
    Closer closer = new Closer(suppressor);

    TestCloseable c1 = closer.register(TestCloseable.normal());

    entryIterator.next();
    entryIterator.remove();
    assertFalse(underlying.containsKey("g"));

    assertTrue(underlying.isEmpty());
    assertTrue(map.isEmpty());
    assertTrue(keys.isEmpty());
    assertTrue(values.isEmpty());
    assertTrue(entries.isEmpty());
  }

  public void testTransformEquals() {
    Map<String, Integer> underlying = ImmutableMap.of("a", 0, "b", 1, "c", 2);

    assertThat(directedGraph.nodes()).isEmpty();
    assertThat(directedGraph.edges()).isEmpty();
    assertThat(directedGraph.addEdge(N1, N2, E12)).isTrue();
    assertThat(directedGraph.edgesConnecting(N1, N2)).isEqualTo(ImmutableSet.of(E12));
    assertThat(directedGraph.edgesConnecting(N2, N1)).isEmpty();

    // By default, parallel edges are not allowed.
    IllegalArgumentException e =

                onInlineContent();
                visitor.onText(text);
            } else if (!elementStack.isEmpty() && !blockContent.contains(elementStack.getFirst())) {
                visitor.onText(text);
            }
        }

        @Override
        void onEnd() {
            while (!elementStack.isEmpty()) {
                visitor.onEndHtmlElement(elementStack.removeFirst());
            }

        }
        if (packaging != null) {
            xml.append("    <packaging>").append(packaging).append("</packaging>\n");
        }

        if (!properties.isEmpty()) {
            xml.append("    <properties>\n");
            for (Property property : properties) {
                xml.append("        <")
                        .append(property.name)

    }

    @Override
    public int size() {
      assertTrue(Thread.holdsLock(mutex));
      return super.size();
    }

    @Override
    public boolean isEmpty() {
      assertTrue(Thread.holdsLock(mutex));
      return super.isEmpty();
    }

    @Override
    public @Nullable V remove(Object object) {
      assertTrue(Thread.holdsLock(mutex));
      return super.remove(object);
    }

  if (addresses.size < 2) {
    return addresses
  }

  val (ipv6, ipv4) = addresses.partition { it is Inet6Address }

  return if (ipv6.isEmpty() || ipv4.isEmpty()) {
    addresses
  } else {
    interleave(ipv6, ipv4)
  }

        List<?> list = dep.getDependencies();
        assertNotNull(list, "No dependencies");
        assertTrue(!list.isEmpty(), "Empty dependency list");

        Map<?, ?> map = projectToClone.getManagedVersionMap();
        assertNotNull(map, "No ManagedVersionMap");
        assertTrue(!map.isEmpty(), "ManagedVersionMap is empty");

        MavenProject clonedProject = projectToClone.clone();

        if (graph == null) {
            return null;
        }

        final MetadataGraphVertex entry = graph.getEntry();
        if (entry == null) {
            return null;
        }

        if (graph.isEmpty()) {
            throw new GraphConflictResolutionException("graph with an entry, but not vertices do not exist");
        }

        if (graph.isEmptyEdges()) {
            return null; // no edges - nothing to worry about

    Optional<Object> getOptional() {
      if (extras.isEmpty()) {
        return Optional.ofNullable(element);
      } else {
        throw multiples(false);
      }
    }

    Object getElement() {
      if (element == null) {
        throw new NoSuchElementException();
      } else if (extras.isEmpty()) {
        return element;
      } else {
        throw multiples(false);