assertTrue(isInOrder(asList(0, 3), Ordering.natural()));
    assertTrue(isInOrder(singleton(1), Ordering.natural()));
    assertTrue(isInOrder(Collections.<Integer>emptyList(), Ordering.natural()));
  }

  public void testIsInStrictOrder() {
    assertFalse(isInStrictOrder(asList(5, 3, 0, 9), Ordering.natural()));
    assertFalse(isInStrictOrder(asList(0, 5, 3, 9), Ordering.natural()));

            new TestStringListGenerator() {
              @Override
              public List<String> create(String[] elements) {
                return emptyList();
              }
            })
        .named("emptyList")
        .withFeatures(CollectionFeature.SERIALIZABLE, CollectionSize.ZERO)
        .suppressing(suppressForEmptyList())
        .createTestSuite();
  }

  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAllEmptyCollectionOnAbsentKey() {
    assertFalse(multimap().putAll(k3(), Collections.<V>emptyList()));
    expectUnchanged();
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAllEmptyIterableOnAbsentKey() {
    Iterable<V> iterable =
        new Iterable<V>() {
          @Override

@Deprecated(since = "4.0.0")
public class Result<T> {

    /**
     * Success without warnings
     *
     * @param model
     */
    public static <T> Result<T> success(T model) {
        return success(model, Collections.emptyList());
    }

    /**
     * Success with warnings
     *
     * @param model
     * @param problems
     */
    public static <T> Result<T> success(T model, Iterable<? extends ModelProblem> problems) {

import static com.google.common.collect.testing.features.CollectionFeature.SERIALIZABLE;
import static com.google.common.truth.Truth.assertThat;
import static java.util.Arrays.asList;
import static java.util.Collections.emptyList;
import static java.util.Collections.nCopies;
import static java.util.Collections.singletonList;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;

        // nothing
    }

    @SafeVarargs
    public static <T> StreamOf<T> stream(final T... values) {
        return new StreamOf<>(() -> values != null ? Arrays.stream(values) : Collections.<T> emptyList().stream());
    }

    public static StreamOf<String> split(final String value, final String regex) {
        return stream(value == null ? null : value.split(regex));
    }

import static com.google.common.collect.testing.IteratorFeature.UNMODIFIABLE;
import static com.google.common.truth.Truth.assertThat;
import static java.util.Arrays.asList;
import static java.util.Collections.emptyList;
import static java.util.Collections.emptySet;
import static java.util.Collections.singleton;
import static java.util.Collections.singletonList;

import com.google.common.annotations.GwtCompatible;

import static com.google.common.collect.testing.google.ReflectionFreeAssertThrows.assertThrows;
import static java.util.Arrays.asList;
import static java.util.Collections.emptyList;
import static java.util.Collections.singletonList;

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.Multimap;
import com.google.common.collect.testing.features.CollectionSize;

        Collections2.permutations(Collections.<Integer>emptyList());

    assertEquals(1, permutationSet.size());
    assertTrue(permutationSet.contains(Collections.<Integer>emptyList()));

    Iterator<List<Integer>> permutations = permutationSet.iterator();
    assertNextPermutation(Collections.<Integer>emptyList(), permutations);
    assertNoMorePermutations(permutations);
  }

      override fun saveFromResponse(
        url: HttpUrl,
        cookies: List<Cookie>,
      ) {
      }

      override fun loadForRequest(url: HttpUrl): List<Cookie> {
        return emptyList()
      }
    }
  }