Cut<Integer> e = Range.greaterThan(1).lowerBound;
    Cut<Integer> f = Range.greaterThan(1).upperBound;

    testCompareToAndEquals(ImmutableList.of(a, b, c, d, e, f));
  }

  @SuppressWarnings("DistinctVarargsChecker")
  public void testContainsAll() {
    Range<Integer> range = Range.closed(3, 5);
    assertTrue(range.containsAll(asList(3, 3, 4, 5)));
    assertFalse(range.containsAll(asList(3, 3, 4, 5, 6)));

 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")
// @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class CollectionToArrayTester<E> extends AbstractCollectionTester<E> {
  public void testToArray_noArgs() {
    Object[] array = collection.toArray();

    private final PomBuilder builder;

    @Inject
    ConsumerPomArtifactTransformer(PomBuilder builder) {
        this.builder = builder;
    }

    @SuppressWarnings("deprecation")
    @Override
    public void injectTransformedArtifacts(RepositorySystemSession session, MavenProject project) throws IOException {
        if (project.getFile() == null) {

/**
 * Test to verify that repositories from one project don't leak to sibling projects.
 */
@PlexusTest
public class RepositoryLeakageTest extends AbstractMavenProjectTestCase {

    @Test
    @SuppressWarnings("checkstyle:MethodLength")
    public void testRepositoryLeakageBetweenSiblings() throws Exception {
        // Create a temporary directory structure for our test

        assertNull(bothNullException.getMessage());
        assertNull(bothNullException.getCause());
    }

    @Test
    @DisplayName("Test deprecated getRootCause method returns the same as getCause")
    @SuppressWarnings("deprecation")
    public void testGetRootCause() {
        // Test with no cause
        TransportException noCauseException = new TransportException("No cause");
        assertNull(noCauseException.getRootCause());

  public static <K, V> BiMapTestSuiteBuilder<K, V> using(TestBiMapGenerator<K, V> generator) {
    return new BiMapTestSuiteBuilder<K, V>().usingGenerator(generator);
  }

  @SuppressWarnings("rawtypes") // class literals
  @Override
  protected List<Class<? extends AbstractTester>> getTesters() {
    List<Class<? extends AbstractTester>> testers = new ArrayList<>();
    testers.add(BiMapEntrySetTester.class);

 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")
// @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class MultimapGetTester<K, V> extends AbstractMultimapTester<K, V, Multimap<K, V>> {
  public void testGetEmpty() {
    Collection<V> result = multimap().get(k3());
    assertEmpty(result);

 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")
// @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
@NullMarked
public class CollectionIteratorTester<E extends @Nullable Object>
    extends AbstractCollectionTester<E> {
  public void testIterator() {

import junit.framework.TestSuite;
import org.jspecify.annotations.NullUnmarked;

/**
 * Test suite covering {@link Ints#asList(int[])}.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
@SuppressWarnings("cast") // redundant casts are intentional and harmless
@NullUnmarked
@AndroidIncompatible // test-suite builders
public class IntArrayAsListTest extends TestCase {

   */
  /*
   * TODO(cpovirk): Is the unchecked cast avoidable? Would System.arraycopy be similarly fast (if
   * likewise not type-checked)? Could our single caller do something different?
   */
  @SuppressWarnings({"nullness", "unchecked"})
  static <T extends @Nullable Object> T[] copy(Object[] source, int from, int to, T[] arrayOfType) {
    return Arrays.copyOfRange(source, from, to, (Class<? extends T[]>) arrayOfType.getClass());