| /* |
| * Copyright (C) 2009 The Guava Authors |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.google.common.collect; |
| |
| import static com.google.common.collect.Tables.immutableCell; |
| |
| import com.google.common.annotations.GwtCompatible; |
| import com.google.common.base.Equivalence; |
| import com.google.common.base.Function; |
| import com.google.common.base.MoreObjects; |
| import com.google.common.collect.Table.Cell; |
| import com.google.common.testing.CollectorTester; |
| import java.util.function.BiPredicate; |
| import java.util.stream.Collector; |
| import java.util.stream.Stream; |
| import junit.framework.TestCase; |
| |
| /** Unit tests for {@link TableCollectors}. */ |
| @GwtCompatible(emulated = true) |
| public class TableCollectorsTest { |
| |
| public static final class ToImmutableTableTest extends TestCase { |
| public void testToImmutableTable() { |
| Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> |
| collector = |
| TableCollectors.toImmutableTable(Cell::getRowKey, Cell::getColumnKey, Cell::getValue); |
| BiPredicate<ImmutableTable<String, String, Integer>, ImmutableTable<String, String, Integer>> |
| equivalence = pairwiseOnResultOf(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(), |
| immutableCell("one", "uno", 1), |
| immutableCell("two", "dos", 2), |
| immutableCell("three", "tres", 3)); |
| } |
| |
| public void testToImmutableTableConflict() { |
| Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> |
| collector = |
| TableCollectors.toImmutableTable(Cell::getRowKey, Cell::getColumnKey, Cell::getValue); |
| try { |
| Stream.of(immutableCell("one", "uno", 1), immutableCell("one", "uno", 2)) |
| .collect(collector); |
| fail("Expected IllegalArgumentException"); |
| } catch (IllegalArgumentException expected) { |
| } |
| } |
| |
| public void testToImmutableTableNullRowKey() { |
| Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> |
| collector = |
| TableCollectors.toImmutableTable(t -> null, Cell::getColumnKey, Cell::getValue); |
| try { |
| Stream.of(immutableCell("one", "uno", 1)).collect(collector); |
| fail("Expected NullPointerException"); |
| } catch (NullPointerException expected) { |
| } |
| } |
| |
| public void testToImmutableTableNullColumnKey() { |
| Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> |
| collector = TableCollectors.toImmutableTable(Cell::getRowKey, t -> null, Cell::getValue); |
| try { |
| Stream.of(immutableCell("one", "uno", 1)).collect(collector); |
| fail("Expected NullPointerException"); |
| } catch (NullPointerException expected) { |
| } |
| } |
| |
| public void testToImmutableTableNullValue() { |
| Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> |
| collector = |
| TableCollectors.toImmutableTable(Cell::getRowKey, Cell::getColumnKey, t -> null); |
| try { |
| Stream.of(immutableCell("one", "uno", 1)).collect(collector); |
| fail("Expected NullPointerException"); |
| } catch (NullPointerException expected) { |
| } |
| collector = |
| TableCollectors.toImmutableTable(Cell::getRowKey, Cell::getColumnKey, Cell::getValue); |
| try { |
| Stream.of(immutableCell("one", "uno", 1), immutableCell("one", "uno", (Integer) null)) |
| .collect(collector); |
| fail("Expected NullPointerException"); |
| } catch (NullPointerException expected) { |
| } |
| } |
| |
| public void testToImmutableTableMerging() { |
| Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> |
| collector = |
| TableCollectors.toImmutableTable( |
| Cell::getRowKey, Cell::getColumnKey, Cell::getValue, Integer::sum); |
| BiPredicate<ImmutableTable<String, String, Integer>, ImmutableTable<String, String, Integer>> |
| equivalence = pairwiseOnResultOf(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(), |
| immutableCell("one", "uno", 1), |
| immutableCell("two", "dos", 2), |
| immutableCell("three", "tres", 3), |
| immutableCell("two", "dos", 4)); |
| } |
| |
| public void testToImmutableTableMergingNullRowKey() { |
| Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> |
| collector = |
| TableCollectors.toImmutableTable( |
| t -> null, Cell::getColumnKey, Cell::getValue, Integer::sum); |
| try { |
| Stream.of(immutableCell("one", "uno", 1)).collect(collector); |
| fail("Expected NullPointerException"); |
| } catch (NullPointerException expected) { |
| } |
| } |
| |
| public void testToImmutableTableMergingNullColumnKey() { |
| Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> |
| collector = |
| TableCollectors.toImmutableTable( |
| Cell::getRowKey, t -> null, Cell::getValue, Integer::sum); |
| try { |
| Stream.of(immutableCell("one", "uno", 1)).collect(collector); |
| fail("Expected NullPointerException"); |
| } catch (NullPointerException expected) { |
| } |
| } |
| |
| public void testToImmutableTableMergingNullValue() { |
| Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> |
| collector = |
| TableCollectors.toImmutableTable( |
| Cell::getRowKey, Cell::getColumnKey, t -> null, Integer::sum); |
| try { |
| Stream.of(immutableCell("one", "uno", 1)).collect(collector); |
| fail("Expected NullPointerException"); |
| } catch (NullPointerException expected) { |
| } |
| collector = |
| TableCollectors.toImmutableTable( |
| Cell::getRowKey, |
| Cell::getColumnKey, |
| Cell::getValue, |
| (i, j) -> MoreObjects.firstNonNull(i, 0) + MoreObjects.firstNonNull(j, 0)); |
| try { |
| Stream.of(immutableCell("one", "uno", 1), immutableCell("one", "uno", (Integer) null)) |
| .collect(collector); |
| fail("Expected NullPointerException"); |
| } catch (NullPointerException expected) { |
| } |
| } |
| |
| public void testToImmutableTableMergingNullMerge() { |
| Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> |
| collector = |
| TableCollectors.toImmutableTable( |
| Cell::getRowKey, Cell::getColumnKey, Cell::getValue, (v1, v2) -> null); |
| try { |
| Stream.of(immutableCell("one", "uno", 1), immutableCell("one", "uno", 2)) |
| .collect(collector); |
| fail("Expected NullPointerException"); |
| } catch (NullPointerException expected) { |
| } |
| } |
| } |
| |
| public static final class ToTableTest extends TestCase { |
| |
| public void testToTable() { |
| Collector<Cell<String, String, Integer>, ?, Table<String, String, Integer>> collector = |
| TableCollectors.toTable( |
| Cell::getRowKey, Cell::getColumnKey, Cell::getValue, HashBasedTable::create); |
| BiPredicate<Table<String, String, Integer>, Table<String, String, Integer>> equivalence = |
| pairwiseOnResultOf(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(), |
| immutableCell("one", "uno", 1), |
| immutableCell("two", "dos", 2), |
| immutableCell("three", "tres", 3)); |
| } |
| |
| public void testToTableNullMerge() { |
| Collector<Cell<String, String, Integer>, ?, Table<String, String, Integer>> collector = |
| TableCollectors.toTable( |
| Cell::getRowKey, |
| Cell::getColumnKey, |
| Cell::getValue, |
| (Integer v1, Integer v2) -> null, |
| HashBasedTable::create); |
| BiPredicate<Table<String, String, Integer>, Table<String, String, Integer>> equivalence = |
| pairwiseOnResultOf(Table::cellSet); |
| CollectorTester.of(collector, equivalence) |
| .expectCollects( |
| ImmutableTable.of(), immutableCell("one", "uno", 1), immutableCell("one", "uno", 2)); |
| } |
| |
| public void testToTableNullValues() { |
| Collector<Cell<String, String, Integer>, ?, Table<String, String, Integer>> collector = |
| TableCollectors.toTable( |
| Cell::getRowKey, |
| Cell::getColumnKey, |
| Cell::getValue, |
| () -> ArrayTable.create(ImmutableList.of("one"), ImmutableList.of("uno"))); |
| try { |
| Stream.of(immutableCell("one", "uno", (Integer) null)).collect(collector); |
| fail("Expected NullPointerException"); |
| } catch (NullPointerException expected) { |
| } |
| } |
| |
| public void testToTableConflict() { |
| Collector<Cell<String, String, Integer>, ?, Table<String, String, Integer>> collector = |
| TableCollectors.toTable( |
| Cell::getRowKey, Cell::getColumnKey, Cell::getValue, HashBasedTable::create); |
| try { |
| Stream.of(immutableCell("one", "uno", 1), immutableCell("one", "uno", 2)) |
| .collect(collector); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| } |
| |
| public void testToTableMerging() { |
| Collector<Cell<String, String, Integer>, ?, Table<String, String, Integer>> collector = |
| TableCollectors.toTable( |
| Cell::getRowKey, |
| Cell::getColumnKey, |
| Cell::getValue, |
| Integer::sum, |
| HashBasedTable::create); |
| BiPredicate<Table<String, String, Integer>, Table<String, String, Integer>> equivalence = |
| pairwiseOnResultOf(Table::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(), |
| immutableCell("one", "uno", 1), |
| immutableCell("two", "dos", 2), |
| immutableCell("three", "tres", 3), |
| immutableCell("two", "dos", 4)); |
| } |
| } |
| |
| // This function specifically returns a BiPredicate, because Guava7’s Equivalence class does not |
| // actually implement BiPredicate, and CollectorTests expects a BiPredicate. |
| static <C, E, R extends Iterable<E>> BiPredicate<C, C> pairwiseOnResultOf(Function<C, R> arg) { |
| Equivalence<C> equivalence = Equivalence.equals().<E>pairwise().onResultOf(arg); |
| return equivalence::equivalent; |
| } |
| |
| private TableCollectorsTest() {} |
| } |