1/*
2 * Copyright (C) 2008 The Guava Authors
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.google.common.collect;
18
19import static org.junit.contrib.truth.Truth.ASSERT;
20
21import com.google.common.annotations.GwtCompatible;
22import com.google.common.annotations.GwtIncompatible;
23import com.google.common.base.Objects;
24import com.google.common.testing.EqualsTester;
25import com.google.common.testing.NullPointerTester;
26
27import junit.framework.TestCase;
28
29/**
30 * Test cases for {@link Table} read operations.
31 *
32 * @author Jared Levy
33 */
34@GwtCompatible(emulated = true)
35public abstract class AbstractTableReadTest extends TestCase {
36  protected Table<String, Integer, Character> table;
37
38  /**
39   * Creates a table with the specified data.
40   *
41   * @param data the table data, repeating the sequence row key, column key,
42   *     value once per mapping
43   * @throws IllegalArgumentException if the size of {@code data} isn't a
44   *     multiple of 3
45   * @throws ClassCastException if a data element has the wrong type
46   */
47  protected abstract Table<String, Integer, Character>
48      create(Object... data);
49
50  protected void assertSize(int expectedSize) {
51    assertEquals(expectedSize, table.size());
52  }
53
54  @Override public void setUp() throws Exception {
55    super.setUp();
56    table = create();
57  }
58
59  public void testContains() {
60    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
61    assertTrue(table.contains("foo", 1));
62    assertTrue(table.contains("bar", 1));
63    assertTrue(table.contains("foo", 3));
64    assertFalse(table.contains("foo", 2));
65    assertFalse(table.contains("bar", 3));
66    assertFalse(table.contains("cat", 1));
67    assertFalse(table.contains("foo", null));
68    assertFalse(table.contains(null, 1));
69    assertFalse(table.contains(null, null));
70  }
71
72  public void testContainsRow() {
73    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
74    assertTrue(table.containsRow("foo"));
75    assertTrue(table.containsRow("bar"));
76    assertFalse(table.containsRow("cat"));
77    assertFalse(table.containsRow(null));
78  }
79
80  public void testContainsColumn() {
81    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
82    assertTrue(table.containsColumn(1));
83    assertTrue(table.containsColumn(3));
84    assertFalse(table.containsColumn(2));
85    assertFalse(table.containsColumn(null));
86  }
87
88  public void testContainsValue() {
89    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
90    assertTrue(table.containsValue('a'));
91    assertTrue(table.containsValue('b'));
92    assertTrue(table.containsValue('c'));
93    assertFalse(table.containsValue('x'));
94    assertFalse(table.containsValue(null));
95  }
96
97  public void testGet() {
98    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
99    assertEquals((Character) 'a', table.get("foo", 1));
100    assertEquals((Character) 'b', table.get("bar", 1));
101    assertEquals((Character) 'c', table.get("foo", 3));
102    assertNull(table.get("foo", 2));
103    assertNull(table.get("bar", 3));
104    assertNull(table.get("cat", 1));
105    assertNull(table.get("foo", null));
106    assertNull(table.get(null, 1));
107    assertNull(table.get(null, null));
108  }
109
110  public void testIsEmpty() {
111    assertTrue(table.isEmpty());
112    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
113    assertFalse(table.isEmpty());
114  }
115
116  public void testSize() {
117    assertSize(0);
118    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
119    assertSize(3);
120  }
121
122  public void testEquals() {
123    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
124    Table<String, Integer, Character> hashCopy = HashBasedTable.create(table);
125    Table<String, Integer, Character> reordered
126        = create("foo", 3, 'c', "foo", 1, 'a', "bar", 1, 'b');
127    Table<String, Integer, Character> smaller
128        = create("foo", 1, 'a', "bar", 1, 'b');
129    Table<String, Integer, Character> swapOuter
130        = create("bar", 1, 'a', "foo", 1, 'b', "bar", 3, 'c');
131    Table<String, Integer, Character> swapValues
132        = create("foo", 1, 'c', "bar", 1, 'b', "foo", 3, 'a');
133
134    new EqualsTester()
135        .addEqualityGroup(table, hashCopy, reordered)
136        .addEqualityGroup(smaller)
137        .addEqualityGroup(swapOuter)
138        .addEqualityGroup(swapValues)
139        .testEquals();
140  }
141
142  public void testHashCode() {
143    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
144    int expected = Objects.hashCode("foo", 1, 'a')
145        + Objects.hashCode("bar", 1, 'b')
146        + Objects.hashCode("foo", 3, 'c');
147    assertEquals(expected, table.hashCode());
148  }
149
150  public void testToStringSize1() {
151    table = create("foo", 1, 'a');
152    assertEquals("{foo={1=a}}", table.toString());
153  }
154
155  public void testRow() {
156    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
157    assertEquals(ImmutableMap.of(1, 'a', 3, 'c'), table.row("foo"));
158  }
159
160  // This test assumes that the implementation does not support null keys.
161  public void testRowNull() {
162    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
163    try {
164      table.row(null);
165      fail();
166    } catch (NullPointerException expected) {}
167  }
168
169  public void testColumn() {
170    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
171    assertEquals(ImmutableMap.of("foo", 'a', "bar", 'b'), table.column(1));
172  }
173
174  // This test assumes that the implementation does not support null keys.
175  public void testColumnNull() {
176    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
177    try {
178      table.column(null);
179      fail();
180    } catch (NullPointerException expected) {}
181  }
182
183  public void testColumnSetPartialOverlap() {
184    table = create(
185        "foo", 1, 'a', "bar", 1, 'b', "foo", 2, 'c', "bar", 3, 'd');
186    ASSERT.that(table.columnKeySet()).hasContentsAnyOrder(1, 2, 3);
187  }
188
189  @GwtIncompatible("NullPointerTester")
190  public void testNullPointerInstance() throws Exception {
191    table = create(
192        "foo", 1, 'a', "bar", 1, 'b', "foo", 2, 'c', "bar", 3, 'd');
193    new NullPointerTester().testAllPublicInstanceMethods(table);
194  }
195}
196