SerializableTester.reserializeAndAssert(map.entrySet());
    SerializableTester.reserializeAndAssert(map.keySet());
    assertEquals(
        new ArrayList<>(map.values()),
        new ArrayList<>(SerializableTester.reserialize(map.values())));
  }

  @GwtIncompatible // SerializableTester
  public void testEmpty_serialization() {
    SortedSet<String> set = new SafeTreeSet<>();

            versions.addAll(versioning.getVersions());
            versioning.setVersions(new ArrayList<>(versions));
        }

        // just carry-on as-is
        if (!recessive.getPlugins().isEmpty()) {
            metadata.setPlugins(new ArrayList<>(recessive.getPlugins()));
        }
    }

    public Object getKey() {
        return getGroupId() + ':' + getArtifactId();
    }

    private List<ModelProblem> problems;

    DefaultModelBuildingResult() {
        modelIds = new ArrayList<>();
        rawModels = new HashMap<>();
        activePomProfiles = new HashMap<>();
        activeExternalProfiles = new ArrayList<>();
        problems = new ArrayList<>();
    }

    @Override
    public Model getEffectiveModel() {
        return effectiveModel;
    }

    }
  }

  public void testDrainOverflow() throws InterruptedException {
    Queues.drain(new SynchronousQueue<>(), new ArrayList<>(), /* numElements= */ 0, MAX_DURATION);
  }

  public void testDrainUninterruptiblyOverflow() {
    Queues.drainUninterruptibly(
        new SynchronousQueue<>(), new ArrayList<>(), /* numElements= */ 0, MAX_DURATION);
  }

  public void testZeroElements() throws Exception {

 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.execution;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Stream;

import static java.util.stream.Collectors.toSet;

/**

            target.setLicenses(new ArrayList<>(source.getLicenses()));
        }
    }

    @Override
    protected void mergeModel_Developers(
            Model target, Model source, boolean sourceDominant, Map<Object, Object> context) {
        if (target.getDevelopers().isEmpty()) {
            target.setDevelopers(new ArrayList<>(source.getDevelopers()));
        }
    }

    @Override

    @SuppressWarnings("UseCollectionConstructor") // test of factory method
    ArrayList<Integer> list = Lists.newArrayList();
    assertEquals(emptyList(), list);
  }

  public void testNewArrayListWithCapacity() {
    ArrayList<Integer> list = Lists.newArrayListWithCapacity(0);
    assertEquals(emptyList(), list);

    ArrayList<Integer> bigger = Lists.newArrayListWithCapacity(256);
    assertEquals(emptyList(), bigger);

@SuppressWarnings("deprecation")
class ProjectBuildingExceptionTest {

    @Test
    void testDetailedExceptionMessageWithMultipleProblems() {
        List<ProjectBuildingResult> results = new ArrayList<>();

        List<ModelProblem> problems1 = new ArrayList<>();
        Collections.addAll(
                problems1,
                new DefaultModelProblem(
                        "Missing required dependency",

      AbstractNetworkTest.validateNetwork(network);

      while (network.nodes().size() < NUM_NODES) {
        network.addNode(gen.nextInt(NODE_POOL_SIZE));
      }
      ArrayList<Integer> nodeList = new ArrayList<>(network.nodes());
      for (int i = 0; i < NUM_EDGES; ++i) {
        // Parallel edges are allowed, so this should always succeed.
        assertThat(
                network.addEdge(

      expectUnchanged();
      // Be extra thorough in case internal state was corrupted by the expected null.
      assertEquals(new ArrayList<>(), new ArrayList<>(values));
      assertEquals(size, multimap().size());
    } else {
      assertEquals(newArrayList(v3()), new ArrayList<>(values));
      assertEquals(size + 1, multimap().size());
    }
  }