new Target(MinimalCollection.of(e0(), e0(), e3(), e3()), "containsDuplicates");
    partialOverlap = new Target(MinimalCollection.of(e2(), e3()), "partialOverlap");
    nullSingleton = new Target(Collections.singleton(null), "nullSingleton");
  }

  // retainAll(empty)

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(ZERO)
  public void testRetainAll_emptyPreviouslyEmpty() {

                realm.addURL(file.toURI().toURL());
            }
        }
        return CoreExtensionEntry.discoverFrom(
                realm,
                Collections.singleton(artifacts.get(0).getFile()),
                extension.getGroupId() + ":" + extension.getArtifactId(),
                extension.getConfiguration());
    }

    private List<Artifact> resolveExtension(

    }
  }

  /**
   * Returns the empty sorted map.
   *
   * <p><b>Performance note:</b> the instance returned is a singleton.
   */
  @SuppressWarnings("unchecked")
  // unsafe, comparator() returns a comparator on the specified type
  // TODO(kevinb): evaluate whether or not of().comparator() should return null

  }

  public void testOrNull_absent() {
    assertThat(Optional.absent().orNull()).isNull();
  }

  public void testAsSet_present() {
    Set<String> expected = Collections.singleton("a");
    assertEquals(expected, Optional.of("a").asSet());
  }

  public void testAsSet_absent() {
    assertTrue("Returned set should be empty", Optional.absent().asSet().isEmpty());
  }

                realm.addURL(file.toUri().toURL());
            }
        }
        return CoreExtensionEntry.discoverFrom(
                realm,
                Collections.singleton(artifacts.get(0).getPath().toFile()),
                extension.getGroupId() + ":" + extension.getArtifactId(),
                extension.getConfiguration());
    }

    private List<Artifact> resolveExtension(

        registerClassSafely(kryo, Collections.emptyMap().getClass());
        registerClassSafely(kryo, Collections.singletonList(null).getClass());
        registerClassSafely(kryo, Collections.singleton(null).getClass());
        registerClassSafely(kryo, Collections.singletonMap(null, null).getClass());
        registerClassSafely(kryo, Arrays.asList().getClass());
    }

    /**

            return new String[0];
        }

        @Override
        public Object getAttribute(String name) {
            if (Constants.HIGHLIGHT_QUERIES.equals(name)) {
                return Collections.singleton("highlight query");
            }
            return null;
        }

        @Override
        public Locale getLocale() {
            return locale;
        }

        @Override

                    .authority(authority)
                    .build();

            final RefreshTokenParameters parameters =
                    RefreshTokenParameters.builder(Collections.singleton("https://graph.microsoft.com/.default"), refreshToken).build();

            final IAuthenticationResult result = app.acquireToken(parameters).get(acquisitionTimeout, TimeUnit.MILLISECONDS);
            if (result == null) {

  @Empty
  static <C extends Comparable<?>> Range<C> generateRange() {
    return Range.all();
  }

  @Generates
  static <C extends Comparable<?>> Range<C> generateRange(C freshElement) {
    return Range.singleton(freshElement);
  }

  @Generates
  static <E> Iterable<E> generateIterable(@Nullable E freshElement) {
    return generateList(freshElement);
  }

  @Generates

        @Override
        public @Nullable Object waitForValue() {
          return null;
        }

        @Override
        public void notifyNewValue(Object newValue) {}
      };

  /** Singleton placeholder that indicates a value is being loaded. */
  @SuppressWarnings("unchecked") // impl never uses a parameter or returns any non-null value
  static <K, V> ValueReference<K, V> unset() {