guava-gwt/test-super/com/google/common/collect/super/com/google/common/collect/ImmutableTableTest.java - external/guava-libraries - Git at Google

 /*
  * 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.truth.Truth.assertThat;

 import com.google.common.annotations.GwtCompatible;

 /**
  * Tests common methods in {@link ImmutableTable}
  *
  * @author Gregory Kick
  */
 @GwtCompatible(emulated = true)
 public class ImmutableTableTest extends AbstractTableReadTest {
   @Override protected Table<String, Integer, Character> create(Object... data) {
     ImmutableTable.Builder<String, Integer, Character> builder =
         ImmutableTable.builder();
     for (int i = 0; i < data.length; i = i + 3) {
       builder.put((String) data[i], (Integer) data[i + 1],
           (Character) data[i + 2]);
     }
     return builder.build();
   }

   public void testBuilder() {
     ImmutableTable.Builder<Character, Integer, String> builder =
         new ImmutableTable.Builder<Character, Integer, String>();
     assertEquals(ImmutableTable.of(), builder.build());
     assertEquals(ImmutableTable.of('a', 1, "foo"), builder
         .put('a', 1, "foo")
         .build());
     Table<Character, Integer, String> expectedTable = HashBasedTable.create();
     expectedTable.put('a', 1, "foo");
     expectedTable.put('b', 1, "bar");
     expectedTable.put('a', 2, "baz");
     Table<Character, Integer, String> otherTable = HashBasedTable.create();
     otherTable.put('b', 1, "bar");
     otherTable.put('a', 2, "baz");
     assertEquals(expectedTable, builder
         .putAll(otherTable)
         .build());
   }

   public void testBuilder_withImmutableCell() {
     ImmutableTable.Builder<Character, Integer, String> builder =
         new ImmutableTable.Builder<Character, Integer, String>();
     assertEquals(ImmutableTable.of('a', 1, "foo"), builder
         .put(Tables.immutableCell('a', 1, "foo"))
         .build());
   }

   public void testBuilder_withImmutableCellAndNullContents() {
     ImmutableTable.Builder<Character, Integer, String> builder =
         new ImmutableTable.Builder<Character, Integer, String>();
     try {
       builder.put(Tables.immutableCell((Character) null, 1, "foo"));
       fail();
     } catch (NullPointerException e) {
       // success
     }
     try {
       builder.put(Tables.immutableCell('a', (Integer) null, "foo"));
       fail();
     } catch (NullPointerException e) {
       // success
     }
     try {
       builder.put(Tables.immutableCell('a', 1, (String) null));
       fail();
     } catch (NullPointerException e) {
       // success
     }
   }

   private static class StringHolder {
     String string;
   }

   public void testBuilder_withMutableCell() {
     ImmutableTable.Builder<Character, Integer, String> builder =
         new ImmutableTable.Builder<Character, Integer, String>();

     final StringHolder holder = new StringHolder();
     holder.string = "foo";
     Table.Cell<Character, Integer, String> mutableCell =
         new Tables.AbstractCell<Character, Integer, String>() {
           @Override public Character getRowKey() {
             return 'K';
           }
           @Override public Integer getColumnKey() {
             return 42;
           }
           @Override public String getValue() {
             return holder.string;
           }
         };

     // Add the mutable cell to the builder
     builder.put(mutableCell);

     // Mutate the value
     holder.string = "bar";

     // Make sure it uses the original value.
     assertEquals(ImmutableTable.of('K', 42, "foo"), builder.build());
   }

   public void testBuilder_noDuplicates() {
     ImmutableTable.Builder<Character, Integer, String> builder =
         new ImmutableTable.Builder<Character, Integer, String>()
             .put('a', 1, "foo")
             .put('a', 1, "bar");
     try {
       builder.build();
       fail();
     } catch (IllegalArgumentException e) {
       // success
     }
   }

   public void testBuilder_noNulls() {
     ImmutableTable.Builder<Character, Integer, String> builder =
         new ImmutableTable.Builder<Character, Integer, String>();
     try {
       builder.put(null, 1, "foo");
       fail();
     } catch (NullPointerException e) {
       // success
     }
     try {
       builder.put('a', null, "foo");
       fail();
     } catch (NullPointerException e) {
       // success
     }
     try {
       builder.put('a', 1, null);
       fail();
     } catch (NullPointerException e) {
       // success
     }
   }

   private static <R, C, V> void validateTableCopies(Table<R, C, V> original) {
     Table<R, C, V> copy = ImmutableTable.copyOf(original);
     assertEquals(original, copy);
     validateViewOrdering(original, copy);

     Table<R, C, V> built
         = ImmutableTable.<R, C, V>builder().putAll(original).build();
     assertEquals(original, built);
     validateViewOrdering(original, built);
   }

   private static <R, C, V> void validateViewOrdering(
       Table<R, C, V> original, Table<R, C, V> copy) {
     assertTrue(Iterables.elementsEqual(original.cellSet(), copy.cellSet()));
     assertTrue(Iterables.elementsEqual(original.rowKeySet(), copy.rowKeySet()));
     assertTrue(Iterables.elementsEqual(original.values(), copy.values()));
   }

   public void testCopyOf() {
     Table<Character, Integer, String> table = TreeBasedTable.create();
     validateTableCopies(table);
     table.put('b', 2, "foo");
     validateTableCopies(table);
     table.put('b', 1, "bar");
     table.put('a', 2, "baz");
     validateTableCopies(table);
     // Even though rowKeySet, columnKeySet, and cellSet have the same
     // iteration ordering, row has an inconsistent ordering.
     assertThat(table.row('b').keySet()).has().exactly(1, 2).inOrder();
     assertThat(ImmutableTable.copyOf(table).row('b').keySet())
         .has().exactly(2, 1).inOrder();
   }

   public void testCopyOfSparse() {
     Table<Character, Integer, String> table = TreeBasedTable.create();
     table.put('x', 2, "foo");
     table.put('r', 1, "bar");
     table.put('c', 3, "baz");
     table.put('b', 7, "cat");
     table.put('e', 5, "dog");
     table.put('c', 0, "axe");
     table.put('e', 3, "tub");
     table.put('r', 4, "foo");
     table.put('x', 5, "bar");
     validateTableCopies(table);
   }

   public void testCopyOfDense() {
     Table<Character, Integer, String> table = TreeBasedTable.create();
     table.put('c', 3, "foo");
     table.put('c', 2, "bar");
     table.put('c', 1, "baz");
     table.put('b', 3, "cat");
     table.put('b', 1, "dog");
     table.put('a', 3, "foo");
     table.put('a', 2, "bar");
     table.put('a', 1, "baz");
     validateTableCopies(table);
   }

   public void testBuilder_orderRowsAndColumnsBy_putAll() {
     Table<Character, Integer, String> table = HashBasedTable.create();
     table.put('b', 2, "foo");
     table.put('b', 1, "bar");
     table.put('a', 2, "baz");
     ImmutableTable.Builder<Character, Integer, String> builder
         = ImmutableTable.builder();
     Table<Character, Integer, String> copy
         = builder.orderRowsBy(Ordering.natural())
             .orderColumnsBy(Ordering.natural())
             .putAll(table).build();
     assertThat(copy.rowKeySet()).has().exactly('a', 'b').inOrder();
     assertThat(copy.columnKeySet()).has().exactly(1, 2).inOrder();
     assertThat(copy.values()).has().exactly("baz", "bar", "foo").inOrder();
     assertThat(copy.row('b').keySet()).has().exactly(1, 2).inOrder();
   }

   public void testBuilder_orderRowsAndColumnsBy_sparse() {
     ImmutableTable.Builder<Character, Integer, String> builder
         = ImmutableTable.builder();
     builder.orderRowsBy(Ordering.natural());
     builder.orderColumnsBy(Ordering.natural());
     builder.put('x', 2, "foo");
     builder.put('r', 1, "bar");
     builder.put('c', 3, "baz");
     builder.put('b', 7, "cat");
     builder.put('e', 5, "dog");
     builder.put('c', 0, "axe");
     builder.put('e', 3, "tub");
     builder.put('r', 4, "foo");
     builder.put('x', 5, "bar");
     Table<Character, Integer, String> table = builder.build();
     assertThat(table.rowKeySet()).has().exactly('b', 'c', 'e', 'r', 'x').inOrder();
     assertThat(table.columnKeySet()).has().exactly(0, 1, 2, 3, 4, 5, 7).inOrder();
     assertThat(table.values()).has().exactly("cat", "axe", "baz", "tub",
         "dog", "bar", "foo", "foo", "bar").inOrder();
     assertThat(table.row('c').keySet()).has().exactly(0, 3).inOrder();
     assertThat(table.column(5).keySet()).has().exactly('e', 'x').inOrder();
   }

   public void testBuilder_orderRowsAndColumnsBy_dense() {
     ImmutableTable.Builder<Character, Integer, String> builder
         = ImmutableTable.builder();
     builder.orderRowsBy(Ordering.natural());
     builder.orderColumnsBy(Ordering.natural());
     builder.put('c', 3, "foo");
     builder.put('c', 2, "bar");
     builder.put('c', 1, "baz");
     builder.put('b', 3, "cat");
     builder.put('b', 1, "dog");
     builder.put('a', 3, "foo");
     builder.put('a', 2, "bar");
     builder.put('a', 1, "baz");
     Table<Character, Integer, String> table = builder.build();
     assertThat(table.rowKeySet()).has().exactly('a', 'b', 'c').inOrder();
     assertThat(table.columnKeySet()).has().exactly(1, 2, 3).inOrder();
     assertThat(table.values()).has().exactly("baz", "bar", "foo", "dog",
         "cat", "baz", "bar", "foo").inOrder();
     assertThat(table.row('c').keySet()).has().exactly(1, 2, 3).inOrder();
     assertThat(table.column(1).keySet()).has().exactly('a', 'b', 'c').inOrder();
   }

   public void testBuilder_orderRowsBy_sparse() {
     ImmutableTable.Builder<Character, Integer, String> builder
         = ImmutableTable.builder();
     builder.orderRowsBy(Ordering.natural());
     builder.put('x', 2, "foo");
     builder.put('r', 1, "bar");
     builder.put('c', 3, "baz");
     builder.put('b', 7, "cat");
     builder.put('e', 5, "dog");
     builder.put('c', 0, "axe");
     builder.put('e', 3, "tub");
     builder.put('r', 4, "foo");
     builder.put('x', 5, "bar");
     Table<Character, Integer, String> table = builder.build();
     assertThat(table.rowKeySet()).has().exactly('b', 'c', 'e', 'r', 'x').inOrder();
     assertThat(table.column(5).keySet()).has().exactly('e', 'x').inOrder();
   }

   public void testBuilder_orderRowsBy_dense() {
     ImmutableTable.Builder<Character, Integer, String> builder
         = ImmutableTable.builder();
     builder.orderRowsBy(Ordering.natural());
     builder.put('c', 3, "foo");
     builder.put('c', 2, "bar");
     builder.put('c', 1, "baz");
     builder.put('b', 3, "cat");
     builder.put('b', 1, "dog");
     builder.put('a', 3, "foo");
     builder.put('a', 2, "bar");
     builder.put('a', 1, "baz");
     Table<Character, Integer, String> table = builder.build();
     assertThat(table.rowKeySet()).has().exactly('a', 'b', 'c').inOrder();
     assertThat(table.column(1).keySet()).has().exactly('a', 'b', 'c').inOrder();
   }

   public void testBuilder_orderColumnsBy_sparse() {
     ImmutableTable.Builder<Character, Integer, String> builder
         = ImmutableTable.builder();
     builder.orderColumnsBy(Ordering.natural());
     builder.put('x', 2, "foo");
     builder.put('r', 1, "bar");
     builder.put('c', 3, "baz");
     builder.put('b', 7, "cat");
     builder.put('e', 5, "dog");
     builder.put('c', 0, "axe");
     builder.put('e', 3, "tub");
     builder.put('r', 4, "foo");
     builder.put('x', 5, "bar");
     Table<Character, Integer, String> table = builder.build();
     assertThat(table.columnKeySet()).has().exactly(0, 1, 2, 3, 4, 5, 7).inOrder();
     assertThat(table.row('c').keySet()).has().exactly(0, 3).inOrder();
   }

   public void testBuilder_orderColumnsBy_dense() {
     ImmutableTable.Builder<Character, Integer, String> builder
         = ImmutableTable.builder();
     builder.orderColumnsBy(Ordering.natural());
     builder.put('c', 3, "foo");
     builder.put('c', 2, "bar");
     builder.put('c', 1, "baz");
     builder.put('b', 3, "cat");
     builder.put('b', 1, "dog");
     builder.put('a', 3, "foo");
     builder.put('a', 2, "bar");
     builder.put('a', 1, "baz");
     Table<Character, Integer, String> table = builder.build();
     assertThat(table.columnKeySet()).has().exactly(1, 2, 3).inOrder();
     assertThat(table.row('c').keySet()).has().exactly(1, 2, 3).inOrder();
   }
 }
	/*
	* 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.truth.Truth.assertThat;

	import com.google.common.annotations.GwtCompatible;

	/**
	* Tests common methods in {@link ImmutableTable}
	*
	* @author Gregory Kick
	*/
	@GwtCompatible(emulated = true)
	public class ImmutableTableTest extends AbstractTableReadTest {
	@Override protected Table<String, Integer, Character> create(Object... data) {
	ImmutableTable.Builder<String, Integer, Character> builder =
	ImmutableTable.builder();
	for (int i = 0; i < data.length; i = i + 3) {
	builder.put((String) data[i], (Integer) data[i + 1],
	(Character) data[i + 2]);
	}
	return builder.build();
	}

	public void testBuilder() {
	ImmutableTable.Builder<Character, Integer, String> builder =
	new ImmutableTable.Builder<Character, Integer, String>();
	assertEquals(ImmutableTable.of(), builder.build());
	assertEquals(ImmutableTable.of('a', 1, "foo"), builder
	.put('a', 1, "foo")
	.build());
	Table<Character, Integer, String> expectedTable = HashBasedTable.create();
	expectedTable.put('a', 1, "foo");
	expectedTable.put('b', 1, "bar");
	expectedTable.put('a', 2, "baz");
	Table<Character, Integer, String> otherTable = HashBasedTable.create();
	otherTable.put('b', 1, "bar");
	otherTable.put('a', 2, "baz");
	assertEquals(expectedTable, builder
	.putAll(otherTable)
	.build());
	}

	public void testBuilder_withImmutableCell() {
	ImmutableTable.Builder<Character, Integer, String> builder =
	new ImmutableTable.Builder<Character, Integer, String>();
	assertEquals(ImmutableTable.of('a', 1, "foo"), builder
	.put(Tables.immutableCell('a', 1, "foo"))
	.build());
	}

	public void testBuilder_withImmutableCellAndNullContents() {
	ImmutableTable.Builder<Character, Integer, String> builder =
	new ImmutableTable.Builder<Character, Integer, String>();
	try {
	builder.put(Tables.immutableCell((Character) null, 1, "foo"));
	fail();
	} catch (NullPointerException e) {
	// success
	}
	try {
	builder.put(Tables.immutableCell('a', (Integer) null, "foo"));
	fail();
	} catch (NullPointerException e) {
	// success
	}
	try {
	builder.put(Tables.immutableCell('a', 1, (String) null));
	fail();
	} catch (NullPointerException e) {
	// success
	}
	}

	private static class StringHolder {
	String string;
	}

	public void testBuilder_withMutableCell() {
	ImmutableTable.Builder<Character, Integer, String> builder =
	new ImmutableTable.Builder<Character, Integer, String>();

	final StringHolder holder = new StringHolder();
	holder.string = "foo";
	Table.Cell<Character, Integer, String> mutableCell =
	new Tables.AbstractCell<Character, Integer, String>() {
	@Override public Character getRowKey() {
	return 'K';
	}
	@Override public Integer getColumnKey() {
	return 42;
	}
	@Override public String getValue() {
	return holder.string;
	}
	};

	// Add the mutable cell to the builder
	builder.put(mutableCell);

	// Mutate the value
	holder.string = "bar";

	// Make sure it uses the original value.
	assertEquals(ImmutableTable.of('K', 42, "foo"), builder.build());
	}

	public void testBuilder_noDuplicates() {
	ImmutableTable.Builder<Character, Integer, String> builder =
	new ImmutableTable.Builder<Character, Integer, String>()
	.put('a', 1, "foo")
	.put('a', 1, "bar");
	try {
	builder.build();
	fail();
	} catch (IllegalArgumentException e) {
	// success
	}
	}

	public void testBuilder_noNulls() {
	ImmutableTable.Builder<Character, Integer, String> builder =
	new ImmutableTable.Builder<Character, Integer, String>();
	try {
	builder.put(null, 1, "foo");
	fail();
	} catch (NullPointerException e) {
	// success
	}
	try {
	builder.put('a', null, "foo");
	fail();
	} catch (NullPointerException e) {
	// success
	}
	try {
	builder.put('a', 1, null);
	fail();
	} catch (NullPointerException e) {
	// success
	}
	}

	private static <R, C, V> void validateTableCopies(Table<R, C, V> original) {
	Table<R, C, V> copy = ImmutableTable.copyOf(original);
	assertEquals(original, copy);
	validateViewOrdering(original, copy);

	Table<R, C, V> built
	= ImmutableTable.<R, C, V>builder().putAll(original).build();
	assertEquals(original, built);
	validateViewOrdering(original, built);
	}

	private static <R, C, V> void validateViewOrdering(
	Table<R, C, V> original, Table<R, C, V> copy) {
	assertTrue(Iterables.elementsEqual(original.cellSet(), copy.cellSet()));
	assertTrue(Iterables.elementsEqual(original.rowKeySet(), copy.rowKeySet()));
	assertTrue(Iterables.elementsEqual(original.values(), copy.values()));
	}

	public void testCopyOf() {
	Table<Character, Integer, String> table = TreeBasedTable.create();
	validateTableCopies(table);
	table.put('b', 2, "foo");
	validateTableCopies(table);
	table.put('b', 1, "bar");
	table.put('a', 2, "baz");
	validateTableCopies(table);
	// Even though rowKeySet, columnKeySet, and cellSet have the same
	// iteration ordering, row has an inconsistent ordering.
	assertThat(table.row('b').keySet()).has().exactly(1, 2).inOrder();
	assertThat(ImmutableTable.copyOf(table).row('b').keySet())
	.has().exactly(2, 1).inOrder();
	}

	public void testCopyOfSparse() {
	Table<Character, Integer, String> table = TreeBasedTable.create();
	table.put('x', 2, "foo");
	table.put('r', 1, "bar");
	table.put('c', 3, "baz");
	table.put('b', 7, "cat");
	table.put('e', 5, "dog");
	table.put('c', 0, "axe");
	table.put('e', 3, "tub");
	table.put('r', 4, "foo");
	table.put('x', 5, "bar");
	validateTableCopies(table);
	}

	public void testCopyOfDense() {
	Table<Character, Integer, String> table = TreeBasedTable.create();
	table.put('c', 3, "foo");
	table.put('c', 2, "bar");
	table.put('c', 1, "baz");
	table.put('b', 3, "cat");
	table.put('b', 1, "dog");
	table.put('a', 3, "foo");
	table.put('a', 2, "bar");
	table.put('a', 1, "baz");
	validateTableCopies(table);
	}

	public void testBuilder_orderRowsAndColumnsBy_putAll() {
	Table<Character, Integer, String> table = HashBasedTable.create();
	table.put('b', 2, "foo");
	table.put('b', 1, "bar");
	table.put('a', 2, "baz");
	ImmutableTable.Builder<Character, Integer, String> builder
	= ImmutableTable.builder();
	Table<Character, Integer, String> copy
	= builder.orderRowsBy(Ordering.natural())
	.orderColumnsBy(Ordering.natural())
	.putAll(table).build();
	assertThat(copy.rowKeySet()).has().exactly('a', 'b').inOrder();
	assertThat(copy.columnKeySet()).has().exactly(1, 2).inOrder();
	assertThat(copy.values()).has().exactly("baz", "bar", "foo").inOrder();
	assertThat(copy.row('b').keySet()).has().exactly(1, 2).inOrder();
	}

	public void testBuilder_orderRowsAndColumnsBy_sparse() {
	ImmutableTable.Builder<Character, Integer, String> builder
	= ImmutableTable.builder();
	builder.orderRowsBy(Ordering.natural());
	builder.orderColumnsBy(Ordering.natural());
	builder.put('x', 2, "foo");
	builder.put('r', 1, "bar");
	builder.put('c', 3, "baz");
	builder.put('b', 7, "cat");
	builder.put('e', 5, "dog");
	builder.put('c', 0, "axe");
	builder.put('e', 3, "tub");
	builder.put('r', 4, "foo");
	builder.put('x', 5, "bar");
	Table<Character, Integer, String> table = builder.build();
	assertThat(table.rowKeySet()).has().exactly('b', 'c', 'e', 'r', 'x').inOrder();
	assertThat(table.columnKeySet()).has().exactly(0, 1, 2, 3, 4, 5, 7).inOrder();
	assertThat(table.values()).has().exactly("cat", "axe", "baz", "tub",
	"dog", "bar", "foo", "foo", "bar").inOrder();
	assertThat(table.row('c').keySet()).has().exactly(0, 3).inOrder();
	assertThat(table.column(5).keySet()).has().exactly('e', 'x').inOrder();
	}

	public void testBuilder_orderRowsAndColumnsBy_dense() {
	ImmutableTable.Builder<Character, Integer, String> builder
	= ImmutableTable.builder();
	builder.orderRowsBy(Ordering.natural());
	builder.orderColumnsBy(Ordering.natural());
	builder.put('c', 3, "foo");
	builder.put('c', 2, "bar");
	builder.put('c', 1, "baz");
	builder.put('b', 3, "cat");
	builder.put('b', 1, "dog");
	builder.put('a', 3, "foo");
	builder.put('a', 2, "bar");
	builder.put('a', 1, "baz");
	Table<Character, Integer, String> table = builder.build();
	assertThat(table.rowKeySet()).has().exactly('a', 'b', 'c').inOrder();
	assertThat(table.columnKeySet()).has().exactly(1, 2, 3).inOrder();
	assertThat(table.values()).has().exactly("baz", "bar", "foo", "dog",
	"cat", "baz", "bar", "foo").inOrder();
	assertThat(table.row('c').keySet()).has().exactly(1, 2, 3).inOrder();
	assertThat(table.column(1).keySet()).has().exactly('a', 'b', 'c').inOrder();
	}

	public void testBuilder_orderRowsBy_sparse() {
	ImmutableTable.Builder<Character, Integer, String> builder
	= ImmutableTable.builder();
	builder.orderRowsBy(Ordering.natural());
	builder.put('x', 2, "foo");
	builder.put('r', 1, "bar");
	builder.put('c', 3, "baz");
	builder.put('b', 7, "cat");
	builder.put('e', 5, "dog");
	builder.put('c', 0, "axe");
	builder.put('e', 3, "tub");
	builder.put('r', 4, "foo");
	builder.put('x', 5, "bar");
	Table<Character, Integer, String> table = builder.build();
	assertThat(table.rowKeySet()).has().exactly('b', 'c', 'e', 'r', 'x').inOrder();
	assertThat(table.column(5).keySet()).has().exactly('e', 'x').inOrder();
	}

	public void testBuilder_orderRowsBy_dense() {
	ImmutableTable.Builder<Character, Integer, String> builder
	= ImmutableTable.builder();
	builder.orderRowsBy(Ordering.natural());
	builder.put('c', 3, "foo");
	builder.put('c', 2, "bar");
	builder.put('c', 1, "baz");
	builder.put('b', 3, "cat");
	builder.put('b', 1, "dog");
	builder.put('a', 3, "foo");
	builder.put('a', 2, "bar");
	builder.put('a', 1, "baz");
	Table<Character, Integer, String> table = builder.build();
	assertThat(table.rowKeySet()).has().exactly('a', 'b', 'c').inOrder();
	assertThat(table.column(1).keySet()).has().exactly('a', 'b', 'c').inOrder();
	}

	public void testBuilder_orderColumnsBy_sparse() {
	ImmutableTable.Builder<Character, Integer, String> builder
	= ImmutableTable.builder();
	builder.orderColumnsBy(Ordering.natural());
	builder.put('x', 2, "foo");
	builder.put('r', 1, "bar");
	builder.put('c', 3, "baz");
	builder.put('b', 7, "cat");
	builder.put('e', 5, "dog");
	builder.put('c', 0, "axe");
	builder.put('e', 3, "tub");
	builder.put('r', 4, "foo");
	builder.put('x', 5, "bar");
	Table<Character, Integer, String> table = builder.build();
	assertThat(table.columnKeySet()).has().exactly(0, 1, 2, 3, 4, 5, 7).inOrder();
	assertThat(table.row('c').keySet()).has().exactly(0, 3).inOrder();
	}

	public void testBuilder_orderColumnsBy_dense() {
	ImmutableTable.Builder<Character, Integer, String> builder
	= ImmutableTable.builder();
	builder.orderColumnsBy(Ordering.natural());
	builder.put('c', 3, "foo");
	builder.put('c', 2, "bar");
	builder.put('c', 1, "baz");
	builder.put('b', 3, "cat");
	builder.put('b', 1, "dog");
	builder.put('a', 3, "foo");
	builder.put('a', 2, "bar");
	builder.put('a', 1, "baz");
	Table<Character, Integer, String> table = builder.build();
	assertThat(table.columnKeySet()).has().exactly(1, 2, 3).inOrder();
	assertThat(table.row('c').keySet()).has().exactly(1, 2, 3).inOrder();
	}
	}