LabeledTableTest.java

/*******************************************************************************
 * Mission Control Technologies, Copyright (c) 2009-2012, United States Government
 * as represented by the Administrator of the National Aeronautics and Space 
 * Administration. All rights reserved.
 *
 * The MCT platform is 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.
 *
 * MCT includes source code licensed under additional open source licenses. See 
 * the MCT Open Source Licenses file included with this distribution or the About 
 * MCT Licenses dialog available at runtime from the MCT Help menu for additional 
 * information. 
 *******************************************************************************/
package gov.nasa.arc.mct.table.gui;

import static org.mockito.Matchers.anyObject;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.testng.Assert.*;
import gov.nasa.arc.mct.table.model.AbbreviatingTableLabelingAlgorithm;
import gov.nasa.arc.mct.table.model.MockTableModel;
import gov.nasa.arc.mct.table.model.TableLabelingAlgorithm;
import gov.nasa.arc.mct.test.util.TestUtil;

import javax.swing.table.TableColumn;

import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

public class LabeledTableTest {

	@Mock private TableLayoutListener layoutListener;
	@Mock private TableSelectionListener selectionListener;
	
	MockTableModel model;
	TableLabelingAlgorithm algorithm;
	LabeledTable table;
	
	private final static String[][] identifiers = {
			{ "Ku_VBSP_Ch_1_Mode_Select", "Ku_VBSP_Ch_1_Field_Rate", "Ku_VBSP_Ch_1_Reserved_Bit",
				"Ku_VBSP_Ch_1_Fiber_Optic_Activity", "Ku_VBSP_Ch_1_PFM_Activity", "Ku_VBSP_Ch_1_Return_Link_Sync_Lock" },
			{ "Ku_VBSP_Ch_2_Mode_Select", "Ku_VBSP_Ch_2_Field_Rate", "Ku_VBSP_Ch_2_Reserved_Bit",
				"Ku_VBSP_Ch_2_Fiber_Optic_Activity", "Ku_VBSP_Ch_2_PFM_Activity", "Ku_VBSP_Ch_2_Return_Link_Sync_Lock" },
			{ "Ku_VBSP_Ch_3_Mode_Select", "Ku_VBSP_Ch_3_Field_Rate", "Ku_VBSP_Ch_3_Reserved_Bit",
				"Ku_VBSP_Ch_3_Fiber_Optic_Activity", "Ku_VBSP_Ch_3_PFM_Activity", "Ku_VBSP_Ch_3_Return_Link_Sync_Lock" },
			{ "Ku_VBSP_Ch_4_Mode_Select", "Ku_VBSP_Ch_4_Field_Rate", "Ku_VBSP_Ch_4_Reserved_Bit",
				"Ku_VBSP_Ch_4_Fiber_Optic_Activity", "Ku_VBSP_Ch_4_PFM_Activity", "Ku_VBSP_Ch_4_Return_Link_Sync_Lock" },
	};

	@BeforeMethod
	public void init() {
		MockitoAnnotations.initMocks(this);
		algorithm = new AbbreviatingTableLabelingAlgorithm();
		model = new MockTableModel(identifiers, algorithm);
		table = new LabeledTable(model);
	}
	
	@Test
	public void testLayoutListeners() {
		// Firing without a listener causes no interactions with the listener.
		table.fireTableLayoutChanged();
		verifyZeroInteractions(layoutListener);
		
		// Adding a listener and firing results in exactly one call.
		table.addTableLayoutListener(layoutListener);
		table.fireTableLayoutChanged();
		verify(layoutListener, times(1)).tableChanged(anyObject());
		
		// Adding a 2nd time and firing only causes one more call. (Proving it's
		// not added twice.)
		table.addTableLayoutListener(layoutListener);
		table.fireTableLayoutChanged();
		verify(layoutListener, times(2)).tableChanged(anyObject());
		
		// Removing the listener and firing does not result in another call.
		table.removeTableLayoutListener(layoutListener);
		table.fireTableLayoutChanged();
		verify(layoutListener, times(2)).tableChanged(anyObject());
	}
	
	@Test
	public void testSelectionChangeListeners() {
		// Firing without a listener causes no interactions with the listener.
		table.fireSelectionChanged();
		verifyZeroInteractions(selectionListener);
		
		// Adding a listener and firing results in exactly one call.
		table.addTableSelectionListener(selectionListener);
		table.fireSelectionChanged();
		verify(selectionListener, times(1)).selectionChanged(new int[0], new int[0]);
		
		// Adding a 2nd time and firing only causes one more call. (Proving it's
		// not added twice.)
		table.addTableSelectionListener(selectionListener);
		table.fireSelectionChanged();
		verify(selectionListener, times(2)).selectionChanged(new int[0], new int[0]);
		
		// Removing the listener and firing does not result in another call.
		table.removeTableSelectionListener(selectionListener);
		table.fireSelectionChanged();
		verify(selectionListener, times(2)).selectionChanged(new int[0], new int[0]);
	}
	
	@Test
	public void testSelectRow() {
		MySelectionChangeListener l = new MySelectionChangeListener();
		
		assertEquals(table.getSelectedRows().length, 0);
		assertEquals(table.getSelectedColumns().length, 0);
		
		table.addTableSelectionListener(l);

		// Test selection of row headers.
		table.getRowHeaders().setSelectedIndices(new int[] {0});
		sleep(LabeledTable.SELECTION_CHANGE_DELAY + 50);
		TestUtil.assertArraysEqual(l.getSelectedRows(), new int[] {0});
		TestUtil.assertArraysEqual(l.getSelectedColumns(), new int[] {0, 1, 2, 3, 4, 5});
		
		// Test selection of a portion of the table. Since we just had entire rows
		// selectedd, we have to select the columns first, or it looks like a
		// shift-select in the row headers, followed by a click within the table,
		// which will clear the row selection. This way it looks like a click
		// on (1,3), followed by a shift-click on (2,3) (or vice versa).
		table.getTable().setColumnSelectionInterval(3, 3);
		table.getTable().setRowSelectionInterval(1, 2);
		sleep(LabeledTable.SELECTION_CHANGE_DELAY + 50);
		TestUtil.assertArraysEqual(l.getSelectedRows(), new int[] {1, 2});
		TestUtil.assertArraysEqual(l.getSelectedColumns(), new int[] {3});
	}
	
	@Test
	public void testTableStructureChanged() {
		table.addTableLayoutListener(layoutListener);
		// Move column 0 to position 1.
		table.getTable().getColumnModel().moveColumn(0, 1);
		sleep(LabeledTable.TABLE_SAVE_DELAY + 50);
		
		verify(layoutListener).tableChanged(anyObject());
	}
	
	@Test
	public void testGetColumnWidths() {
		int[] origWidths = table.getColumnWidths();
		TableColumn col0 = table.getTable().getColumnModel().getColumn(0);
		col0.setPreferredWidth(origWidths[0] * 2);
		int[] newWidths = table.getColumnWidths();
		for (int i=0; i<table.getTable().getColumnCount(); ++i) {
			if (i == 0) {
				assertEquals(newWidths[i], origWidths[i] * 2);
			} else {
				assertEquals(newWidths[i], origWidths[i]);
			}
		}
		
		table.setColumnWidths(origWidths);
		TestUtil.assertArraysEqual(table.getColumnWidths(), origWidths);
	}
	
	@Test
	public void testGetColumnOrder() {
		TestUtil.assertArraysEqual(table.getColumnOrder(), new int[] {0, 1, 2, 3, 4, 5});
		table.getTable().getColumnModel().moveColumn(0, 1);
		TestUtil.assertArraysEqual(table.getColumnOrder(), new int[] {1, 0, 2, 3, 4, 5});
		
		table.setColumnOrder(new int[] {5, 4, 3, 2, 1, 0});
		TestUtil.assertArraysEqual(table.getColumnOrder(), new int[] {5, 4, 3, 2, 1, 0});
	}
	
	@Test
	public void testShowGrid() {
		table.getTable().setShowGrid(true);
		assertTrue(table.getShowGrid());
		
		table.getTable().setShowGrid(false);
		assertFalse(table.getShowGrid());
		
		table.setShowGrid(true);
		assertTrue(table.getTable().getShowHorizontalLines());
		assertTrue(table.getTable().getShowVerticalLines());
		
		table.setShowGrid(false);
		assertFalse(table.getTable().getShowHorizontalLines());
		assertFalse(table.getTable().getShowVerticalLines());
	}
	
	@Test
	public void testRowHeaderHeights() {
		assertTrue(table.getTable().getRowCount() > 0);
		assertEquals(table.getTable().getRowCount(), table.getRowHeaders().getModel().getSize());
		
		/* Set row header heights to unique values */
		for (int i = 0; i < table.getTable().getRowCount(); i++) {
			table.getTable().setRowHeight(i, 4 + i * 4);
		}
		for (int i = 0; i < table.getTable().getRowCount(); i++) {
			assertEquals(table.getTable().getRowHeight(i), 4 * (i + 1));
			assertEquals(table.getTable().getRowHeight(i), 4 * (i + 1));
		}
		
		/* Set them to the same value */
		for (int i = 0; i < table.getTable().getRowCount(); i++) {
			table.getTable().setRowHeight(i, 16);
		}
		for (int i = 0; i < table.getTable().getRowCount(); i++) {
			assertEquals(table.getTable().getRowHeight(i), 16);
			assertEquals(table.getTable().getRowHeight(i), 16);
		}
	}
	
	private void sleep(long millis) {
		try {
			Thread.sleep(millis);
		} catch (InterruptedException e) {
			// ignore
		}
	}
	
	private static class MySelectionChangeListener implements TableSelectionListener {
		
		int[] selectedRows = {};
		int[] selectedColumns = {};

		@Override
		public void selectionChanged(int[] selectedRows, int[] selectedColumns) {
			this.selectedRows = selectedRows.clone();
			this.selectedColumns = selectedColumns.clone();
		}

		public int[] getSelectedRows() {
			return selectedRows;
		}

		public int[] getSelectedColumns() {
			return selectedColumns;
		}
		
	}
	
}