/*
    * Copyright (C) 2008 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.truth.Truth.assertThat;
  
  import com.google.common.annotations.GwtCompatible;
  import com.google.common.annotations.GwtIncompatible;
  import com.google.common.base.Objects;
  import com.google.common.testing.EqualsTester;
  import com.google.common.testing.NullPointerTester;
  
  import junit.framework.TestCase;
  
  /**
   * Test cases for {@link Table} read operations.
   *
   * @author Jared Levy
   */
  @GwtCompatible(emulated = true)
  public abstract class AbstractTableReadTest extends TestCase {
    protected Table<String, Integer, Character> table;
  
    /**
     * Creates a table with the specified data.
     *
     * @param data the table data, repeating the sequence row key, column key,
     *     value once per mapping
     * @throws IllegalArgumentException if the size of {@code data} isn't a
     *     multiple of 3
     * @throws ClassCastException if a data element has the wrong type
     */
    protected abstract Table<String, Integer, Character>
        create(Object... data);
  
    protected void assertSize(int expectedSize) {
      assertEquals(expectedSize, table.size());
    }
  
    @Override public void setUp() throws Exception {
      super.setUp();
      table = create();
    }
  
    public void testContains() {
      table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
      assertTrue(table.contains("foo", 1));
      assertTrue(table.contains("bar", 1));
      assertTrue(table.contains("foo", 3));
      assertFalse(table.contains("foo", 2));
      assertFalse(table.contains("bar", 3));
      assertFalse(table.contains("cat", 1));
      assertFalse(table.contains("foo", null));
      assertFalse(table.contains(null, 1));
      assertFalse(table.contains(null, null));
    }
  
    public void testContainsRow() {
      table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
      assertTrue(table.containsRow("foo"));
      assertTrue(table.containsRow("bar"));
      assertFalse(table.containsRow("cat"));
      assertFalse(table.containsRow(null));
    }
  
    public void testContainsColumn() {
      table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
      assertTrue(table.containsColumn(1));
      assertTrue(table.containsColumn(3));
      assertFalse(table.containsColumn(2));
      assertFalse(table.containsColumn(null));
    }
  
    public void testContainsValue() {
      table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
      assertTrue(table.containsValue('a'));
      assertTrue(table.containsValue('b'));
      assertTrue(table.containsValue('c'));
      assertFalse(table.containsValue('x'));
      assertFalse(table.containsValue(null));
    }
  
    public void testGet() {
      table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
      assertEquals((Character) 'a', table.get("foo", 1));
     assertEquals((Character) 'b', table.get("bar", 1));
     assertEquals((Character) 'c', table.get("foo", 3));
     assertNull(table.get("foo", 2));
     assertNull(table.get("bar", 3));
     assertNull(table.get("cat", 1));
     assertNull(table.get("foo", null));
     assertNull(table.get(null, 1));
     assertNull(table.get(null, null));
   }
 
   public void testIsEmpty() {
     assertTrue(table.isEmpty());
     table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
     assertFalse(table.isEmpty());
   }
 
   public void testSize() {
     assertSize(0);
     table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
     assertSize(3);
   }
 
   public void testEquals() {
     table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
     Table<String, Integer, Character> hashCopy = HashBasedTable.create(table);
     Table<String, Integer, Character> reordered
         = create("foo", 3, 'c', "foo", 1, 'a', "bar", 1, 'b');
     Table<String, Integer, Character> smaller
         = create("foo", 1, 'a', "bar", 1, 'b');
     Table<String, Integer, Character> swapOuter
         = create("bar", 1, 'a', "foo", 1, 'b', "bar", 3, 'c');
     Table<String, Integer, Character> swapValues
         = create("foo", 1, 'c', "bar", 1, 'b', "foo", 3, 'a');
 
     new EqualsTester()
         .addEqualityGroup(table, hashCopy, reordered)
         .addEqualityGroup(smaller)
         .addEqualityGroup(swapOuter)
         .addEqualityGroup(swapValues)
         .testEquals();
   }
 
   public void testHashCode() {
     table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
     int expected = Objects.hashCode("foo", 1, 'a')
         + Objects.hashCode("bar", 1, 'b')
         + Objects.hashCode("foo", 3, 'c');
     assertEquals(expected, table.hashCode());
   }
 
   public void testToStringSize1() {
     table = create("foo", 1, 'a');
     assertEquals("{foo={1=a}}", table.toString());
   }
 
   public void testRow() {
     table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
     assertEquals(ImmutableMap.of(1, 'a', 3, 'c'), table.row("foo"));
   }
 
   // This test assumes that the implementation does not support null keys.
   public void testRowNull() {
     table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
     try {
       table.row(null);
       fail();
     } catch (NullPointerException expected) {}
   }
 
   public void testColumn() {
     table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
     assertEquals(ImmutableMap.of("foo", 'a', "bar", 'b'), table.column(1));
   }
 
   // This test assumes that the implementation does not support null keys.
   public void testColumnNull() {
     table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
     try {
       table.column(null);
       fail();
     } catch (NullPointerException expected) {}
   }
 
   public void testColumnSetPartialOverlap() {
     table = create(
         "foo", 1, 'a', "bar", 1, 'b', "foo", 2, 'c', "bar", 3, 'd');
     assertThat(table.columnKeySet()).has().exactly(1, 2, 3);
   }
 
   @GwtIncompatible("NullPointerTester")
   public void testNullPointerInstance() {
     table = create(
         "foo", 1, 'a', "bar", 1, 'b', "foo", 2, 'c', "bar", 3, 'd');
     new NullPointerTester().testAllPublicInstanceMethods(table);
   }
 }