Java 类com.google.common.collect.testing.AnEnum 实例源码

public void testIteratesOnce() {
  Map<AnEnum, AnEnum> map =
      Maps.asMap(
          ImmutableSet.of(AnEnum.A),
          new Function<AnEnum, AnEnum>() {
            boolean used = false;

            @Override
            public AnEnum apply(AnEnum ae) {
              checkState(!used, "should not be applied more than once");
              used = true;
              return ae;
            }
          });
  ImmutableMap<AnEnum, AnEnum> copy = Maps.immutableEnumMap(map);
  assertThat(copy.entrySet()).containsExactly(Helpers.mapEntry(AnEnum.A, AnEnum.A));
}

public void testIteratesOnce() {
  Map<AnEnum, AnEnum> map =
      Maps.asMap(
          ImmutableSet.of(AnEnum.A),
          new Function<AnEnum, AnEnum>() {
            boolean used = false;

            @Override
            public AnEnum apply(AnEnum ae) {
              checkState(!used, "should not be applied more than once");
              used = true;
              return ae;
            }
          });
  ImmutableMap<AnEnum, AnEnum> copy = Maps.immutableEnumMap(map);
  assertThat(copy.entrySet()).containsExactly(Helpers.mapEntry(AnEnum.A, AnEnum.A));
}

@Override
public Multiset<AnEnum> create(Object... elements) {
  AnEnum[] array = new AnEnum[elements.length];
  int i = 0;
  for (Object e : elements) {
    array[i++] = (AnEnum) e;
  }
  return create(array);
}

@Override
protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
  Map<AnEnum, String> map = Maps.newHashMap();
  for (Entry<AnEnum, String> entry : entries) {
    // checkArgument(!map.containsKey(entry.getKey()));
    map.put(entry.getKey(), entry.getValue());
  }
  return Maps.immutableEnumMap(map);
}

@Override
protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
  EnumMap<AnEnum, String> map = new EnumMap<>(AnEnum.class);
  for (Entry<AnEnum, String> entry : entries) {
    map.put(entry.getKey(), entry.getValue());
  }
  return ImmutableMap.copyOf(map);
}

@Override
public Iterable<Entry<AnEnum, String>> order(List<Entry<AnEnum, String>> insertionOrder) {
  return new Ordering<Entry<AnEnum, String>>() {

    @Override
    public int compare(Entry<AnEnum, String> left, Entry<AnEnum, String> right) {
      return left.getKey().compareTo(right.getKey());
    }
  }.sortedCopy(insertionOrder);
}

@Override
protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
  Map<AnEnum, String> map = Maps.newHashMap();
  for (Entry<AnEnum, String> entry : entries) {
    map.put(entry.getKey(), entry.getValue());
  }
  return Maps.immutableEnumMap(map);
}

public void testImmutableEnumMapOrdering() {
  ImmutableMap<AnEnum, String> map = Maps.immutableEnumMap(
      ImmutableMap.of(AnEnum.C, "c", AnEnum.A, "a", AnEnum.E, "e"));

  assertThat(map.entrySet()).containsExactly(
      Helpers.mapEntry(AnEnum.A, "a"),
      Helpers.mapEntry(AnEnum.C, "c"),
      Helpers.mapEntry(AnEnum.E, "e")).inOrder();
}

public void testToImmutableEnumMap() {
  Collector<Entry<AnEnum, Integer>, ?, ImmutableMap<AnEnum, Integer>> collector =
      Maps.toImmutableEnumMap(Entry::getKey, Entry::getValue);
  Equivalence<ImmutableMap<AnEnum, Integer>> equivalence =
      Equivalence.equals().<Entry<AnEnum, Integer>>pairwise().onResultOf(ImmutableMap::entrySet);
  CollectorTester.of(collector, equivalence)
      .expectCollects(
          ImmutableMap.of(AnEnum.A, 1, AnEnum.C, 2, AnEnum.E, 3),
          mapEntry(AnEnum.A, 1),
          mapEntry(AnEnum.C, 2),
          mapEntry(AnEnum.E, 3));
}

public void testToImmutableMap_exceptionOnDuplicateKey() {
  Collector<Entry<AnEnum, Integer>, ?, ImmutableMap<AnEnum, Integer>> collector =
      Maps.toImmutableEnumMap(Entry::getKey, Entry::getValue);
  try {
    Stream.of(mapEntry(AnEnum.A, 1), mapEntry(AnEnum.A, 11)).collect(collector);
    fail("Expected IllegalArgumentException");
  } catch (IllegalArgumentException expected) {
  }
}

public void testToImmutableMapMerging() {
  Collector<Entry<AnEnum, Integer>, ?, ImmutableMap<AnEnum, Integer>> collector =
      Maps.toImmutableEnumMap(Entry::getKey, Entry::getValue, Integer::sum);
  Equivalence<ImmutableMap<AnEnum, Integer>> equivalence =
      Equivalence.equals().<Entry<AnEnum, Integer>>pairwise().onResultOf(ImmutableMap::entrySet);
  CollectorTester.of(collector, equivalence)
      .expectCollects(
          ImmutableMap.of(AnEnum.A, 1, AnEnum.B, 4, AnEnum.C, 3),
          mapEntry(AnEnum.A, 1),
          mapEntry(AnEnum.B, 2),
          mapEntry(AnEnum.C, 3),
          mapEntry(AnEnum.B, 2));
}

private static TestEnumMultisetGenerator enumMultisetGenerator() {
  return new TestEnumMultisetGenerator() {
    @Override protected Multiset<AnEnum> create(AnEnum[] elements) {
      return (elements.length == 0)
          ? EnumMultiset.create(AnEnum.class)
          : EnumMultiset.create(asList(elements));
    }
  };
}

@Override
public Multiset<AnEnum> create(Object... elements) {
  AnEnum[] array = new AnEnum[elements.length];
  int i = 0;
  for (Object e : elements) {
    array[i++] = (AnEnum) e;
  }
  return create(array);
}

@Override
protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
  Map<AnEnum, String> map = Maps.newHashMap();
  for (Entry<AnEnum, String> entry : entries) {
    // checkArgument(!map.containsKey(entry.getKey()));
    map.put(entry.getKey(), entry.getValue());
  }
  return Maps.immutableEnumMap(map);
}

@Override
protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
  EnumMap<AnEnum, String> map = new EnumMap<AnEnum, String>(AnEnum.class);
  for (Entry<AnEnum, String> entry : entries) {
    map.put(entry.getKey(), entry.getValue());
  }
  return ImmutableMap.copyOf(map);
}

@Override
public Iterable<Entry<AnEnum, String>> order(List<Entry<AnEnum, String>> insertionOrder) {
  return new Ordering<Entry<AnEnum, String>>() {

    @Override
    public int compare(Entry<AnEnum, String> left, Entry<AnEnum, String> right) {
      return left.getKey().compareTo(right.getKey());
    }
  }.sortedCopy(insertionOrder);
}

@Override
protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
  Map<AnEnum, String> map = Maps.newHashMap();
  for (Entry<AnEnum, String> entry : entries) {
    map.put(entry.getKey(), entry.getValue());
  }
  return Maps.immutableEnumMap(map);
}

public void testImmutableEnumMapOrdering() {
  ImmutableMap<AnEnum, String> map = Maps.immutableEnumMap(
      ImmutableMap.of(AnEnum.C, "c", AnEnum.A, "a", AnEnum.E, "e"));

  assertThat(map.entrySet()).containsExactly(
      Helpers.mapEntry(AnEnum.A, "a"),
      Helpers.mapEntry(AnEnum.C, "c"),
      Helpers.mapEntry(AnEnum.E, "e")).inOrder();
}

public void testToImmutableEnumMap() {
  Collector<Entry<AnEnum, Integer>, ?, ImmutableMap<AnEnum, Integer>> collector =
      Maps.toImmutableEnumMap(Entry::getKey, Entry::getValue);
  Equivalence<ImmutableMap<AnEnum, Integer>> equivalence =
      Equivalence.equals().<Entry<AnEnum, Integer>>pairwise().onResultOf(ImmutableMap::entrySet);
  CollectorTester.of(collector, equivalence)
      .expectCollects(
          ImmutableMap.of(AnEnum.A, 1, AnEnum.C, 2, AnEnum.E, 3),
          mapEntry(AnEnum.A, 1),
          mapEntry(AnEnum.C, 2),
          mapEntry(AnEnum.E, 3));
}

public void testToImmutableMap_exceptionOnDuplicateKey() {
  Collector<Entry<AnEnum, Integer>, ?, ImmutableMap<AnEnum, Integer>> collector =
      Maps.toImmutableEnumMap(Entry::getKey, Entry::getValue);
  try {
    Stream.of(mapEntry(AnEnum.A, 1), mapEntry(AnEnum.A, 11)).collect(collector);
    fail("Expected IllegalArgumentException");
  } catch (IllegalArgumentException expected) {
  }
}

public void testToImmutableMapMerging() {
  Collector<Entry<AnEnum, Integer>, ?, ImmutableMap<AnEnum, Integer>> collector =
      Maps.toImmutableEnumMap(Entry::getKey, Entry::getValue, Integer::sum);
  Equivalence<ImmutableMap<AnEnum, Integer>> equivalence =
      Equivalence.equals().<Entry<AnEnum, Integer>>pairwise().onResultOf(ImmutableMap::entrySet);
  CollectorTester.of(collector, equivalence)
      .expectCollects(
          ImmutableMap.of(AnEnum.A, 1, AnEnum.B, 4, AnEnum.C, 3),
          mapEntry(AnEnum.A, 1),
          mapEntry(AnEnum.B, 2),
          mapEntry(AnEnum.C, 3),
          mapEntry(AnEnum.B, 2));
}

private static TestEnumMultisetGenerator enumMultisetGenerator() {
  return new TestEnumMultisetGenerator() {
    @Override protected Multiset<AnEnum> create(AnEnum[] elements) {
      return (elements.length == 0)
          ? EnumMultiset.create(AnEnum.class)
          : EnumMultiset.create(asList(elements));
    }
  };
}

@Override
protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
  Map<AnEnum, String> map = new HashMap<AnEnum, String>();
  for (Entry<AnEnum, String> entry : entries) {
    map.put(entry.getKey(), entry.getValue());
  }
  return Immutables.immutableEnumMap(map);
}

public void testImmutableEnumMapOrdering() {
  ImmutableMap<AnEnum, String> map = Immutables.immutableEnumMap(
      ImmutableMap.of(AnEnum.C, "c", AnEnum.A, "a", AnEnum.E, "e"));

  assertThat(map.entrySet()).containsExactly(
      Helpers.mapEntry(AnEnum.A, "a"),
      Helpers.mapEntry(AnEnum.C, "c"),
      Helpers.mapEntry(AnEnum.E, "e")).inOrder();
}

@Override
public Multiset<AnEnum> create(Object... elements) {
  AnEnum[] array = new AnEnum[elements.length];
  int i = 0;
  for (Object e : elements) {
    array[i++] = (AnEnum) e;
  }
  return create(array);
}

@Override
protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
  Map<AnEnum, String> map = Maps.newHashMap();
  for (Entry<AnEnum, String> entry : entries) {
    // checkArgument(!map.containsKey(entry.getKey()));
    map.put(entry.getKey(), entry.getValue());
  }
  return Maps.immutableEnumMap(map);
}

@Override
protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
  EnumMap<AnEnum, String> map = new EnumMap<AnEnum, String>(AnEnum.class);
  for (Entry<AnEnum, String> entry : entries) {
    map.put(entry.getKey(), entry.getValue());
  }
  return ImmutableMap.copyOf(map);
}

@Override
public Iterable<Entry<AnEnum, String>> order(List<Entry<AnEnum, String>> insertionOrder) {
  return new Ordering<Entry<AnEnum, String>>() {

    @Override
    public int compare(Entry<AnEnum, String> left, Entry<AnEnum, String> right) {
      return left.getKey().compareTo(right.getKey());
    }

  }.sortedCopy(insertionOrder);
}

@Override
protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
  Map<AnEnum, String> map = Maps.newHashMap();
  for (Entry<AnEnum, String> entry : entries) {
    map.put(entry.getKey(), entry.getValue());
  }
  return Maps.immutableEnumMap(map);
}

public void testImmutableEnumMapOrdering() {
  ImmutableMap<AnEnum, String> map = Maps.immutableEnumMap(
      ImmutableMap.of(AnEnum.C, "c", AnEnum.A, "a", AnEnum.E, "e"));

  assertThat(map.entrySet()).containsExactly(
      Helpers.mapEntry(AnEnum.A, "a"),
      Helpers.mapEntry(AnEnum.C, "c"),
      Helpers.mapEntry(AnEnum.E, "e")).inOrder();
}

private static TestEnumMultisetGenerator enumMultisetGenerator() {
  return new TestEnumMultisetGenerator() {
    @Override protected Multiset<AnEnum> create(AnEnum[] elements) {
      return (elements.length == 0)
          ? EnumMultiset.create(AnEnum.class)
          : EnumMultiset.create(asList(elements));
    }
  };
}

@Override
protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
  Map<AnEnum, String> map = Maps.newHashMap();
  for (Entry<AnEnum, String> entry : entries) {
    map.put(entry.getKey(), entry.getValue());
  }
  return Maps.immutableEnumMap(map);
}

public void testImmutableEnumMapOrdering() {
  ImmutableMap<AnEnum, String> map = Maps.immutableEnumMap(
      ImmutableMap.of(AnEnum.C, "c", AnEnum.A, "a", AnEnum.E, "e"));

  assertThat(map.entrySet()).containsExactly(
      Helpers.mapEntry(AnEnum.A, "a"),
      Helpers.mapEntry(AnEnum.C, "c"),
      Helpers.mapEntry(AnEnum.E, "e")).inOrder();
}

private static TestEnumMultisetGenerator enumMultisetGenerator() {
  return new TestEnumMultisetGenerator() {
    @Override protected Multiset<AnEnum> create(AnEnum[] elements) {
      return (elements.length == 0)
          ? EnumMultiset.create(AnEnum.class)
          : EnumMultiset.create(asList(elements));
    }
  };
}

@Override
public Multiset<AnEnum> create(Object... elements) {
  AnEnum[] array = new AnEnum[elements.length];
  int i = 0;
  for (Object e : elements) {
    array[i++] = (AnEnum) e;
  }
  return create(array);
}

@Override
protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
  Map<AnEnum, String> map = Maps.newHashMap();
  for (Entry<AnEnum, String> entry : entries) {
    // checkArgument(!map.containsKey(entry.getKey()));
    map.put(entry.getKey(), entry.getValue());
  }
  return Maps.immutableEnumMap(map);
}

@Override
protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
  EnumMap<AnEnum, String> map = new EnumMap<>(AnEnum.class);
  for (Entry<AnEnum, String> entry : entries) {
    map.put(entry.getKey(), entry.getValue());
  }
  return ImmutableMap.copyOf(map);
}

@Override
public Iterable<Entry<AnEnum, String>> order(List<Entry<AnEnum, String>> insertionOrder) {
  return new Ordering<Entry<AnEnum, String>>() {

    @Override
    public int compare(Entry<AnEnum, String> left, Entry<AnEnum, String> right) {
      return left.getKey().compareTo(right.getKey());
    }
  }.sortedCopy(insertionOrder);
}

@Override
public Multiset<AnEnum> create(Object... elements) {
  AnEnum[] array = new AnEnum[elements.length];
  int i = 0;
  for (Object e : elements) {
    array[i++] = (AnEnum) e;
  }
  return create(array);
}

@Override
protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
  Map<AnEnum, String> map = Maps.newHashMap();
  for (Entry<AnEnum, String> entry : entries) {
    // checkArgument(!map.containsKey(entry.getKey()));
    map.put(entry.getKey(), entry.getValue());
  }
  return Maps.immutableEnumMap(map);
}