successLatch.countDown();
            })
        .start();

    future.cancel(true);

    assertTrue(future.isCancelled());
    assertTrue(future.isDone());

    assertTrue(successLatch.await(200, MILLISECONDS));
    assertTrue(listenerLatch.await(200, MILLISECONDS));

    latch.countDown();

    exec.shutdown();
    exec.awaitTermination(100, MILLISECONDS);
  }

        MavenArtifactRepositorySubclass r3 = new MavenArtifactRepositorySubclass("bar");

        assertTrue(r1.hashCode() == r2.hashCode());
        assertFalse(r1.hashCode() == r3.hashCode());

        assertTrue(r1.equals(r2), "Expected " + r1 + " to equal " + r2);
        assertTrue(r2.equals(r1), "Expected " + r2 + " to equal " + r1);

        assertFalse(r1.equals(r3), "Expected " + r1 + " to not equal " + r3);

public class CollectionContainsAllTester<E> extends AbstractCollectionTester<E> {
  public void testContainsAll_empty() {
    assertTrue(
        "containsAll(empty) should return true", collection.containsAll(MinimalCollection.of()));
  }

  @CollectionSize.Require(absent = ZERO)
  public void testContainsAll_subset() {
    assertTrue(
        "containsAll(subset) should return true",
        collection.containsAll(MinimalCollection.of(e0())));
  }

            assertTrue(merged.success(), "Merged result should be successful");
            assertEquals(2, merged.processedPoms().size(), "Should merge processed POMs");
            assertEquals(2, merged.modifiedPoms().size(), "Should merge modified POMs");
            assertTrue(merged.processedPoms().contains(pom1), "Should contain overlapping POM");

    thread.start();
    enterLatch.await();
    assertFalse(task.isDone());
    task.cancel(true);
    assertTrue(task.isDone());
    assertTrue(task.isCancelled());
    assertTrue(task.wasInterrupted());
    assertThrows(CancellationException.class, () -> task.get());
    exitLatch.await();
    assertTrue(interruptedExceptionThrown.get());
  }

  @J2ktIncompatible
  @GwtIncompatible // blocking wait

            UpgradeContext context = createMockContext();
            UpgradeResult result = strategy.doApply(context, pomMap);

            assertTrue(result.success(), "Compatibility fix should succeed");
            assertTrue(result.modifiedCount() > 0, "Should have removed duplicate dependency");

            // Verify only one dependency remains
            Editor editor = new Editor(document);

        Collection<Artifact> artifacts = result.getArtifacts();
        assertEquals(3, artifacts.size()); // original jar + consumer pom + build pom

        assertTrue(artifacts.stream().anyMatch(a -> "pom".equals(a.getExtension()) && "".equals(a.getClassifier())));
        assertTrue(
                artifacts.stream().anyMatch(a -> "pom".equals(a.getExtension()) && "build".equals(a.getClassifier())));
    }

    @Test

    sink = new TestCharSink();
  }

  public void testOpenBufferedStream() throws IOException {
    Writer writer = sink.openBufferedStream();
    assertTrue(sink.wasStreamOpened());
    assertFalse(sink.wasStreamClosed());

    writer.write(STRING);
    writer.close();

    assertTrue(sink.wasStreamClosed());
    assertEquals(STRING, sink.getString());
  }

  public void testWrite_string() throws IOException {

    assertTrue("addAll(n, hasDuplicates) should return true", getList().addAll(0, elementsToAdd));
    expectAdded(0, e0(), e1(), e0(), e1());
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  @CollectionFeature.Require(ALLOWS_NULL_VALUES)
  public void testAddAllAtIndex_nullSupported() {
    List<E> containsNull = singletonList(null);

  }

  public void testCancel_notDoneInterrupt() throws Exception {
    InterruptibleFuture future = new InterruptibleFuture();
    assertTrue(future.cancel(true));
    assertTrue(future.isCancelled());
    assertTrue(future.isDone());
    assertTrue(future.wasInterrupted());
    assertTrue(future.interruptTaskWasCalled);
    CancellationException e = assertThrows(CancellationException.class, () -> future.get());