assertEquals(original, copy);
    assertTrue(copy instanceof ImmutableSet);
    return copy;
  }

  @CanIgnoreReturnValue
  @GwtIncompatible // SerializableTester
  static <E> Multiset<E> reserializeAndAssertLenient(Multiset<E> original) {
    Multiset<E> copy = reserialize(original);
    assertEquals(original, copy);
    assertTrue(copy instanceof ImmutableMultiset);
    return copy;
  }

        if (exception != null) {
            if (exception instanceof MojoExecutionException) {
                reference = MojoExecutionException.class.getSimpleName();

                Throwable cause = exception.getCause();
                if (cause instanceof IOException) {
                    cause = cause.getCause();
                    if (cause instanceof ConnectException) {

    assertThat(multimap.get("b")).containsExactly(3, 6).inOrder();
    assertFalse(multimap.get("a") instanceof ImmutableSortedSet);
    assertFalse(multimap.get("x") instanceof ImmutableSortedSet);
    assertFalse(multimap.asMap().get("a") instanceof ImmutableSortedSet);
  }

  public void testBuilderOrderKeysByDuplicates() {

    assertTrue(descendingKeySet instanceof SynchronizedNavigableSet);
    assertSame(mutex, ((SynchronizedNavigableSet<String>) descendingKeySet).mutex);
  }

  public void testDescendingMap() {
    NavigableMap<String, Integer> map = create();
    NavigableMap<String, Integer> descendingMap = map.descendingMap();
    assertTrue(descendingMap instanceof SynchronizedNavigableMap);

    assertEquals(2, factory.count);
    assertEquals("{BLUE=[3, 1, 4, 1], RED=[2, 7, 1, 8]}", multimap.toString());
    assertFalse(multimap.get(Color.BLUE) instanceof RandomAccess);

    assertTrue(multimap.keySet() instanceof SortedSet);
    assertTrue(multimap.asMap() instanceof SortedMap);
  }

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  public void testNewListMultimapSerialization() {

            return;
        }

        if (value instanceof Entity) {
            data.register(key, BeanUtil.copyBeanToNewMap(value));
        } else {
            if ((value instanceof final Collection<?> coll) && !coll.isEmpty()) {
                // care performance for List that the most frequent pattern
                final Object first = coll instanceof List<?> ? ((List<?>) coll).get(0) : coll.iterator().next();

        this.problemMessage = problemMessage;
    }

    @Override
    public boolean matches(Object o) {
        if (!(o instanceof ProjectBuildingResult)) {
            return false;
        }

        final ProjectBuildingResult r = (ProjectBuildingResult) o;

        return r.getProblems().stream().anyMatch(p -> p.getMessage().contains(problemMessage));
    }

    @Override
    public void describeTo(Description description) {

    }
    if (runtimeType instanceof GenericArrayType) {
      return of(supertype).isSupertypeOfArray((GenericArrayType) runtimeType);
    }
    // Proceed to regular Type subtype check
    if (supertype instanceof Class) {
      return this.someRawTypeIsSubclassOf((Class<?>) supertype);
    } else if (supertype instanceof ParameterizedType) {

            if (metadata instanceof ProjectArtifactMetadata) {
                org.eclipse.aether.artifact.Artifact pomArtifact = new SubArtifact(mainArtifact, "", "pom");
                pomArtifact = pomArtifact.setFile(((ProjectArtifactMetadata) metadata).getFile());
                request.addArtifact(pomArtifact);
            } else if (metadata instanceof SnapshotArtifactRepositoryMetadata

    this.valueTypeOrObjectUnderJ2cl = valueTypeOrObjectUnderJ2cl;
  }

  static <K extends Enum<K>> Class<K> inferKeyTypeOrObjectUnderJ2cl(Map<K, ?> map) {
    if (map instanceof EnumBiMap) {
      return ((EnumBiMap<K, ?>) map).keyTypeOrObjectUnderJ2cl;
    }
    if (map instanceof EnumHashBiMap) {
      return ((EnumHashBiMap<K, ?>) map).keyTypeOrObjectUnderJ2cl;
    }
    checkArgument(!map.isEmpty());