Refactor to use derived suite overrides per review feedback

Instead of adding ConcurrentMapSpliteratorTester to the map tester list,
use the derived suite architecture as @chaoren suggested:

- Add ConcurrentCollectionSpliteratorTester that tests any collection's
  spliterator for the CONCURRENT characteristic
- Add ConcurrentSetTestSuiteBuilder and ConcurrentCollectionTestSuiteBuilder
  that include this tester
- Override createDerivedEntrySetSuite/KeySetSuite/ValueCollectionSuite in
  ConcurrentMapTestSuiteBuilder to use the concurrent builders
- Delete ConcurrentMapSpliteratorTester (no longer needed)

This approach is more composable - the tester can be reused for any
concurrent collection, not just ConcurrentMap views.

Author: nickita-khylkouski

guava-testlib/src/com/google/common/collect/testing/ConcurrentCollectionTestSuiteBuilder.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2025 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.common.collect.testing;
+
+import static com.google.common.collect.testing.Helpers.copyToList;
+
+import com.google.common.annotations.GwtIncompatible;
+import com.google.common.collect.testing.testers.ConcurrentCollectionSpliteratorTester;
+import java.util.List;
+
+/**
+ * Creates, based on your criteria, a JUnit test suite that exhaustively tests a concurrent
+ * Collection implementation.
+ *
+ * <p>This builder adds {@link ConcurrentCollectionSpliteratorTester} to verify that the
+ * collection's spliterator has the {@link java.util.Spliterator#CONCURRENT} characteristic.
+ *
+ * @author Guava Authors
+ */
+@GwtIncompatible
+public class ConcurrentCollectionTestSuiteBuilder<E> extends CollectionTestSuiteBuilder<E> {
+
+  public static <E> ConcurrentCollectionTestSuiteBuilder<E> using(
+      TestCollectionGenerator<E> generator) {
+    ConcurrentCollectionTestSuiteBuilder<E> result = new ConcurrentCollectionTestSuiteBuilder<>();
+    result.usingGenerator(generator);
+    return result;
+  }
+
+  @SuppressWarnings("rawtypes") // class literals
+  @Override
+  protected List<Class<? extends AbstractTester>> getTesters() {
+    List<Class<? extends AbstractTester>> testers = copyToList(super.getTesters());
+    testers.add(ConcurrentCollectionSpliteratorTester.class);
+    return testers;
+  }
+}

guava-testlib/src/com/google/common/collect/testing/ConcurrentMapTestSuiteBuilder.java

@@ -22,8 +22,8 @@
 import com.google.common.collect.testing.testers.ConcurrentMapRemoveTester;
 import com.google.common.collect.testing.testers.ConcurrentMapReplaceEntryTester;
 import com.google.common.collect.testing.testers.ConcurrentMapReplaceTester;
-import com.google.common.collect.testing.testers.ConcurrentMapSpliteratorTester;
 import java.util.List;
+import java.util.Map.Entry;
 
 /**
  * Creates, based on your criteria, a JUnit test suite that exhaustively tests a ConcurrentMap
@@ -45,8 +45,7 @@ public static <K, V> ConcurrentMapTestSuiteBuilder<K, V> using(TestMapGenerator<
           ConcurrentMapPutIfAbsentTester.class,
           ConcurrentMapRemoveTester.class,
           ConcurrentMapReplaceTester.class,
-          ConcurrentMapReplaceEntryTester.class,
-          ConcurrentMapSpliteratorTester.class);
+          ConcurrentMapReplaceEntryTester.class);
 
   @SuppressWarnings("rawtypes") // class literals
   @Override
@@ -55,4 +54,21 @@ protected List<Class<? extends AbstractTester>> getTesters() {
     testers.addAll(TESTERS);
     return testers;
   }
+
+  @Override
+  protected SetTestSuiteBuilder<Entry<K, V>> createDerivedEntrySetSuite(
+      TestSetGenerator<Entry<K, V>> entrySetGenerator) {
+    return ConcurrentSetTestSuiteBuilder.using(entrySetGenerator);
+  }
+
+  @Override
+  protected SetTestSuiteBuilder<K> createDerivedKeySetSuite(TestSetGenerator<K> keySetGenerator) {
+    return ConcurrentSetTestSuiteBuilder.using(keySetGenerator);
+  }
+
+  @Override
+  protected CollectionTestSuiteBuilder<V> createDerivedValueCollectionSuite(
+      TestCollectionGenerator<V> valueCollectionGenerator) {
+    return ConcurrentCollectionTestSuiteBuilder.using(valueCollectionGenerator);
+  }
 }

guava-testlib/src/com/google/common/collect/testing/ConcurrentSetTestSuiteBuilder.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2025 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.common.collect.testing;
+
+import static com.google.common.collect.testing.Helpers.copyToList;
+
+import com.google.common.annotations.GwtIncompatible;
+import com.google.common.collect.testing.testers.ConcurrentCollectionSpliteratorTester;
+import java.util.List;
+
+/**
+ * Creates, based on your criteria, a JUnit test suite that exhaustively tests a concurrent Set
+ * implementation.
+ *
+ * <p>This builder adds {@link ConcurrentCollectionSpliteratorTester} to verify that the set's
+ * spliterator has the {@link java.util.Spliterator#CONCURRENT} characteristic.
+ *
+ * @author Guava Authors
+ */
+@GwtIncompatible
+public class ConcurrentSetTestSuiteBuilder<E> extends SetTestSuiteBuilder<E> {
+
+  public static <E> ConcurrentSetTestSuiteBuilder<E> using(TestSetGenerator<E> generator) {
+    ConcurrentSetTestSuiteBuilder<E> result = new ConcurrentSetTestSuiteBuilder<>();
+    result.usingGenerator(generator);
+    return result;
+  }
+
+  @SuppressWarnings("rawtypes") // class literals
+  @Override
+  protected List<Class<? extends AbstractTester>> getTesters() {
+    List<Class<? extends AbstractTester>> testers = copyToList(super.getTesters());
+    testers.add(ConcurrentCollectionSpliteratorTester.class);
+    return testers;
+  }
+}

guava-testlib/src/com/google/common/collect/testing/testers/ConcurrentCollectionSpliteratorTester.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2025 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.common.collect.testing.testers;
+
+import com.google.common.annotations.GwtCompatible;
+import com.google.common.collect.testing.AbstractCollectionTester;
+import java.util.Spliterator;
+import org.jspecify.annotations.NullMarked;
+import org.junit.Ignore;
+
+/**
+ * A generic JUnit test which tests that a collection's spliterator has the {@link
+ * Spliterator#CONCURRENT} characteristic. This tester is intended for use with concurrent
+ * collections such as views of {@link java.util.concurrent.ConcurrentMap}.
+ *
+ * <p>Can't be invoked directly; please see {@link
+ * com.google.common.collect.testing.ConcurrentCollectionTestSuiteBuilder} or {@link
+ * com.google.common.collect.testing.ConcurrentSetTestSuiteBuilder}.
+ *
+ * @author Guava Authors
+ */
+@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 ConcurrentCollectionSpliteratorTester<E> extends AbstractCollectionTester<E> {
+
+  /**
+   * Tests that the spliterator returned by {@code collection.spliterator()} has the {@code
+   * CONCURRENT} characteristic.
+   */
+  public void testSpliteratorHasConcurrent() {
+    Spliterator<E> spliterator = collection.spliterator();
+    assertTrue(
+        "spliterator() should have CONCURRENT characteristic",
+        spliterator.hasCharacteristics(Spliterator.CONCURRENT));
+  }
+}