*/
  public static <T extends @Nullable Object> Iterable<List<@Nullable T>> paddedPartition(
      Iterable<T> iterable, int size) {
    checkNotNull(iterable);
    checkArgument(size > 0);
    return new FluentIterable<List<@Nullable T>>() {
      @Override
      public Iterator<List<@Nullable T>> iterator() {
        return Iterators.paddedPartition(iterable.iterator(), size);

public final class CollectorTester<
    T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object> {
  /**
   * Creates a {@code CollectorTester} for the specified {@code Collector}. The result of the {@code
   * Collector} will be compared to the expected value using {@link Object#equals}.
   */
  public static <T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object>

   * there's no way to assign a {@code @Nullable T} to a field {@code T foo;} and instruct the
   * analysis that that means "plain {@code T}" rather than the inferred type {@code @Nullable T}.
   * (And even if annotations on local variables were permitted as an optional hint, no annotation
   * would be the right tool for the job here: {@code @Nullable} is the annotation that we're trying

   * there's no way to assign a {@code @Nullable T} to a field {@code T foo;} and instruct the
   * analysis that that means "plain {@code T}" rather than the inferred type {@code @Nullable T}.
   * (And even if annotations on local variables were permitted as an optional hint, no annotation
   * would be the right tool for the job here: {@code @Nullable} is the annotation that we're trying

   */
  public static MultimapBuilderWithKeys<@Nullable Object> linkedHashKeys(int expectedKeys) {
    checkNonnegative(expectedKeys, "expectedKeys");
    return new MultimapBuilderWithKeys<@Nullable Object>() {
      @Override
      <K extends @Nullable Object, V extends @Nullable Object> Map<K, Collection<V>> createMap() {
        return Platform.newLinkedHashMapWithExpectedSize(expectedKeys);

  }

  private static Iterable<@Nullable Object> iterable(
      @Nullable Object first, @Nullable Object second, @Nullable Object[] rest) {
    checkNotNull(rest);
    return new AbstractList<@Nullable Object>() {
      @Override
      public int size() {
        return rest.length + 2;
      }

      @Override
      public @Nullable Object get(int index) {
        switch (index) {

import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Tests for {@link Functions}.
 *
 * @author Mike Bostock
 * @author Vlad Patryshev
 */
@GwtCompatible
@NullMarked
public class FunctionsTest extends TestCase {

  public void testIdentity_same() {
    Function<@Nullable String, @Nullable String> identity = Functions.identity();
    assertThat(identity.apply(null)).isNull();

   * or reflection: Android VMs ignore the types of elements that aren't used.
   */
  private final @Nullable Object annotatedType;

  Parameter(
      Invokable<?, ?> declaration,
      int position,
      TypeToken<?> type,
      Annotation[] annotations,
      @Nullable Object annotatedType) {
    this.declaration = declaration;
    this.position = position;
    this.type = type;

            DefaultDependencyResolverRequest(
                    @Nonnull Session session,
                    @Nullable RequestTrace trace,
                    @Nonnull RequestType requestType,
                    @Nullable Project project,
                    @Nullable Artifact rootArtifact,
                    @Nullable DependencyCoordinates root,
                    @Nonnull Collection<DependencyCoordinates> dependencies,

import org.jspecify.annotations.Nullable;

/**
 * A simplistic set which implements the bare minimum so that it can be used in tests without
 * relying on any specific Set implementations. Slow. Explicitly allows null elements so that they
 * can be used in the testers.
 *
 * @author Regina O'Dell
 */
@GwtCompatible
@NullMarked
public class MinimalSet<E extends @Nullable Object> extends MinimalCollection<E> implements Set<E> {