public void testToImmutableSet() { Collector<String, ?, ImmutableSet<String>> collector = ImmutableSet.toImmutableSet(); Equivalence<ImmutableSet<String>> equivalence = Equivalence.equals().onResultOf(ImmutableSet::asList); CollectorTester.of(collector, equivalence) .expectCollects(ImmutableSet.of("a", "b", "c", "d"), "a", "b", "a", "c", "b", "b", "d"); }
public void testOnResultOf_equals() { new EqualsTester() .addEqualityGroup( Equivalence.identity().onResultOf(Functions.toStringFunction()), Equivalence.identity().onResultOf(Functions.toStringFunction())) .addEqualityGroup(Equivalence.equals().onResultOf(Functions.toStringFunction())) .addEqualityGroup(Equivalence.identity().onResultOf(Functions.identity())) .testEquals(); }
public void testToImmutableSortedSet() { Collector<String, ?, ImmutableSortedSet<String>> collector = ImmutableSortedSet.toImmutableSortedSet(Ordering.natural()); BiPredicate<ImmutableSortedSet<String>, ImmutableSortedSet<String>> equivalence = Equivalence.equals() .onResultOf(ImmutableSortedSet<String>::comparator) .and(Equivalence.equals().onResultOf(ImmutableSortedSet::asList)) .and(Equivalence.equals()); CollectorTester.of(collector, equivalence) .expectCollects( ImmutableSortedSet.of("a", "b", "c", "d"), "a", "b", "a", "c", "b", "b", "d"); }
public void testFlatteningToImmutableListMultimap() { Collector<String, ?, ImmutableListMultimap<Character, Character>> collector = ImmutableListMultimap.flatteningToImmutableListMultimap( str -> str.charAt(0), str -> str.substring(1).chars().mapToObj(c -> (char) c)); BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence = Equivalence.equals() .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet())) .and(Equivalence.equals()); ImmutableListMultimap<Character, Character> empty = ImmutableListMultimap.of(); ImmutableListMultimap<Character, Character> filled = ImmutableListMultimap.<Character, Character>builder() .putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a')) .putAll('a', Arrays.asList('p', 'p', 'l', 'e')) .putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't')) .putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's')) .putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y')) .build(); CollectorTester.of(collector, equivalence) .expectCollects(empty) .expectCollects(filled, "banana", "apple", "carrot", "asparagus", "cherry"); }
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 testFlatteningToMultimap() { Collector<String, ?, ListMultimap<Character, Character>> collector = Multimaps.flatteningToMultimap( str -> str.charAt(0), str -> str.substring(1).chars().mapToObj(c -> (char) c), MultimapBuilder.linkedHashKeys().arrayListValues()::build); BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence = Equivalence.equals() .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet())) .and(Equivalence.equals()); ListMultimap<Character, Character> empty = MultimapBuilder.linkedHashKeys().arrayListValues().build(); ListMultimap<Character, Character> filled = MultimapBuilder.linkedHashKeys().arrayListValues().build(); filled.putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a')); filled.putAll('a', Arrays.asList('p', 'p', 'l', 'e')); filled.putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't')); filled.putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's')); filled.putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y')); CollectorTester.of(collector, equivalence) .expectCollects(empty) .expectCollects(filled, "banana", "apple", "carrot", "asparagus", "cherry"); }
public void testToImmutableMap() { Collector<Entry<String, Integer>, ?, ImmutableMap<String, Integer>> collector = ImmutableMap.toImmutableMap(Entry::getKey, Entry::getValue); Equivalence<ImmutableMap<String, Integer>> equivalence = Equivalence.equals() .<Entry<String, Integer>>pairwise() .onResultOf(ImmutableMap::entrySet); CollectorTester.of(collector, equivalence) .expectCollects( ImmutableMap.of("one", 1, "two", 2, "three", 3), mapEntry("one", 1), mapEntry("two", 2), mapEntry("three", 3)); }
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)); } }
public void testToImmutableMapMerging() { Collector<Entry<String, Integer>, ?, ImmutableMap<String, Integer>> collector = ImmutableMap.toImmutableMap(Entry::getKey, Entry::getValue, Integer::sum); Equivalence<ImmutableMap<String, Integer>> equivalence = Equivalence.equals() .<Entry<String, Integer>>pairwise() .onResultOf(ImmutableMap::entrySet); CollectorTester.of(collector, equivalence) .expectCollects( ImmutableMap.of("one", 1, "two", 4, "three", 3), mapEntry("one", 1), mapEntry("two", 2), mapEntry("three", 3), mapEntry("two", 2)); } }
public void testToImmutableSortedMapMerging() { Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector = ImmutableSortedMap.toImmutableSortedMap( Comparator.naturalOrder(), Entry::getKey, Entry::getValue, Integer::sum); Equivalence<ImmutableMap<String, Integer>> equivalence = Equivalence.equals() .<Entry<String, Integer>>pairwise() .onResultOf(ImmutableMap::entrySet); CollectorTester.of(collector, equivalence) .expectCollects( ImmutableSortedMap.of("one", 1, "three", 3, "two", 4), mapEntry("one", 1), mapEntry("two", 2), mapEntry("three", 3), mapEntry("two", 2)); } }
public void testOnResultOf() { EquivalenceTester.of(Equivalence.equals().onResultOf(Functions.toStringFunction())) .addEquivalenceGroup(new IntValue(1), new IntValue(1)) .addEquivalenceGroup(new IntValue(2)) .test(); }
public void testToMultimap() { Collector<Entry<String, Integer>, ?, TreeMultimap<String, Integer>> collector = Multimaps.toMultimap(Entry::getKey, Entry::getValue, TreeMultimap::create); BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence = Equivalence.equals() .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet())) .and(Equivalence.equals()); TreeMultimap<String, Integer> empty = TreeMultimap.create(); TreeMultimap<String, Integer> filled = TreeMultimap.create(); filled.put("a", 1); filled.put("a", 2); filled.put("b", 2); filled.put("c", 3); CollectorTester.of(collector, equivalence) .expectCollects(empty) .expectCollects( filled, mapEntry("a", 1), mapEntry("a", 2), mapEntry("b", 2), mapEntry("c", 3)); }
public void testToTableNullMerge() { Collector<Cell<String, String, Integer>, ?, Table<String, String, Integer>> collector = Tables.toTable( Cell::getRowKey, Cell::getColumnKey, Cell::getValue, (Integer v1, Integer v2) -> null, HashBasedTable::create); Equivalence<Table<String, String, Integer>> equivalence = Equivalence.equals().<Cell<String, String, Integer>>pairwise().onResultOf(Table::cellSet); CollectorTester.of(collector, equivalence) .expectCollects( ImmutableTable.of(), Tables.immutableCell("one", "uno", 1), Tables.immutableCell("one", "uno", 2)); }
public void testToImmutableBiMap() { Collector<Entry<String, Integer>, ?, ImmutableBiMap<String, Integer>> collector = ImmutableBiMap.toImmutableBiMap(Entry::getKey, Entry::getValue); Equivalence<ImmutableBiMap<String, Integer>> equivalence = Equivalence.equals() .<Entry<String, Integer>>pairwise() .onResultOf(ImmutableBiMap::entrySet); CollectorTester.of(collector, equivalence) .expectCollects( ImmutableBiMap.of("one", 1, "two", 2, "three", 3), mapEntry("one", 1), mapEntry("two", 2), mapEntry("three", 3)); }
public void testToImmutableSortedMap() { Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector = ImmutableSortedMap.toImmutableSortedMap( String.CASE_INSENSITIVE_ORDER, Entry::getKey, Entry::getValue); BiPredicate<ImmutableSortedMap<String, Integer>, ImmutableSortedMap<String, Integer>> equivalence = Equivalence.equals() .onResultOf(ImmutableSortedMap<String, Integer>::comparator) .and(Equivalence.equals().onResultOf(map -> map.entrySet().asList())) .and(Equivalence.equals()); ImmutableSortedMap<String, Integer> expected = ImmutableSortedMap.<String, Integer>orderedBy(String.CASE_INSENSITIVE_ORDER) .put("one", 1) .put("three", 3) .put("two", 2) .build(); CollectorTester.of(collector, equivalence) .expectCollects(expected, mapEntry("one", 1), mapEntry("two", 2), mapEntry("three", 3)); }
public void testToImmutableListMultimap() { Collector<Entry<String, Integer>, ?, ImmutableListMultimap<String, Integer>> collector = ImmutableListMultimap.toImmutableListMultimap(Entry::getKey, Entry::getValue); BiPredicate<ImmutableListMultimap<?, ?>, ImmutableListMultimap<?, ?>> equivalence = Equivalence.equals() .onResultOf((ImmutableListMultimap<?, ?> mm) -> mm.asMap().entrySet().asList()) .and(Equivalence.equals()); CollectorTester.of(collector, equivalence) .expectCollects(ImmutableListMultimap.of()) .expectCollects( ImmutableListMultimap.of("a", 1, "b", 2, "a", 3, "c", 4), mapEntry("a", 1), mapEntry("b", 2), mapEntry("a", 3), mapEntry("c", 4)); }
public void testToImmutableSetMultimap() { Collector<Entry<String, Integer>, ?, ImmutableSetMultimap<String, Integer>> collector = ImmutableSetMultimap.toImmutableSetMultimap(Entry::getKey, Entry::getValue); BiPredicate<ImmutableSetMultimap<?, ?>, ImmutableSetMultimap<?, ?>> equivalence = Equivalence.equals() .onResultOf( (ImmutableSetMultimap<?, ?> mm) -> ImmutableListMultimap.copyOf(mm).asMap().entrySet().asList()) .and(Equivalence.equals()); CollectorTester.of(collector, equivalence) .expectCollects(ImmutableSetMultimap.of()) .expectCollects( ImmutableSetMultimap.of("a", 1, "b", 2, "a", 3, "c", 4), mapEntry("a", 1), mapEntry("b", 2), mapEntry("a", 3), mapEntry("c", 4)); }
public void testToTable() { Collector<Cell<String, String, Integer>, ?, Table<String, String, Integer>> collector = Tables.toTable(Cell::getRowKey, Cell::getColumnKey, Cell::getValue, HashBasedTable::create); Equivalence<Table<String, String, Integer>> equivalence = Equivalence.equals().<Cell<String, String, Integer>>pairwise().onResultOf(Table::cellSet); CollectorTester.of(collector, equivalence) .expectCollects( new ImmutableTable.Builder<String, String, Integer>() .put("one", "uno", 1) .put("two", "dos", 2) .put("three", "tres", 3) .build(), Tables.immutableCell("one", "uno", 1), Tables.immutableCell("two", "dos", 2), Tables.immutableCell("three", "tres", 3)); }
public void testToImmutableTable() { Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> collector = ImmutableTable.toImmutableTable(Cell::getRowKey, Cell::getColumnKey, Cell::getValue); Equivalence<ImmutableTable<String, String, Integer>> equivalence = Equivalence.equals() .<Cell<String, String, Integer>>pairwise() .onResultOf(ImmutableTable::cellSet); CollectorTester.of(collector, equivalence) .expectCollects( new ImmutableTable.Builder<String, String, Integer>() .put("one", "uno", 1) .put("two", "dos", 2) .put("three", "tres", 3) .build(), Tables.immutableCell("one", "uno", 1), Tables.immutableCell("two", "dos", 2), Tables.immutableCell("three", "tres", 3)); }
public void testToImmutableTableMerging() { Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> collector = ImmutableTable.toImmutableTable( Cell::getRowKey, Cell::getColumnKey, Cell::getValue, Integer::sum); Equivalence<ImmutableTable<String, String, Integer>> equivalence = Equivalence.equals() .<Cell<String, String, Integer>>pairwise() .onResultOf(ImmutableTable::cellSet); CollectorTester.of(collector, equivalence) .expectCollects( new ImmutableTable.Builder<String, String, Integer>() .put("one", "uno", 1) .put("two", "dos", 6) .put("three", "tres", 3) .build(), Tables.immutableCell("one", "uno", 1), Tables.immutableCell("two", "dos", 2), Tables.immutableCell("three", "tres", 3), Tables.immutableCell("two", "dos", 4)); }