--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/test/jdk/sanity/client/SwingSet/src/TableDemoTest.java Fri Mar 16 14:12:12 2018 +0530
@@ -0,0 +1,349 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import static com.sun.swingset3.demos.table.TableDemo.COLUMN1_NAME;
+import static com.sun.swingset3.demos.table.TableDemo.COLUMN2_NAME;
+import static com.sun.swingset3.demos.table.TableDemo.COLUMN3_NAME;
+import static com.sun.swingset3.demos.table.TableDemo.COLUMN4_NAME;
+import static com.sun.swingset3.demos.table.TableDemo.DEMO_TITLE;
+import static com.sun.swingset3.demos.table.TableDemo.ROW_HEIGHT;
+import static org.jemmy2ext.JemmyExt.EXACT_STRING_COMPARATOR;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.swing.JTable;
+
+import org.jtregext.GuiTestListener;
+import org.netbeans.jemmy.ClassReference;
+import org.netbeans.jemmy.operators.JCheckBoxOperator;
+import org.netbeans.jemmy.operators.JFrameOperator;
+import org.netbeans.jemmy.operators.JTableHeaderOperator;
+import org.netbeans.jemmy.operators.JTableOperator;
+import org.netbeans.jemmy.operators.JTextFieldOperator;
+import org.testng.annotations.Listeners;
+import org.testng.annotations.Test;
+
+import com.sun.swingset3.demos.table.OscarCandidate;
+import com.sun.swingset3.demos.table.OscarTableModel;
+import com.sun.swingset3.demos.table.TableDemo;
+
+/*
+ * @test
+ * @key headful
+ * @summary Verifies SwingSet3 TableDemo page by checking different properties
+ * of the JTable like number of row, number of columns and actions like
+ * selection of cell, sorting based on column, filtering based on text and
+ * moving of the column
+ *
+ * @library /sanity/client/lib/jemmy/src
+ * @library /sanity/client/lib/Extensions/src
+ * @library /sanity/client/lib/SwingSet3/src
+ * @modules java.desktop
+ * java.logging
+ * @build org.jemmy2ext.JemmyExt
+ * @build com.sun.swingset3.demos.table.TableDemo
+ * @run testng TableDemoTest
+ */
+@Listeners(GuiTestListener.class)
+public class TableDemoTest {
+
+ private final static int MAX_ROW_COUNT = 524;
+ private final static int MAX_COL_COUNT = 4;
+
+ private final static String FILTER_TEXT = "Sunrise";
+ private final static String FILTER_RESET_TEXT = "";
+
+ private final static int [] SELECT_ROW_INDICES ={10, 11, 18};
+
+ private final static int MOVE_COL_START_INDEX = 1;
+ private final static int MOVE_COL_END_INDEX = 2;
+ private final static String MOVE_COL_VAL_TEXT1 = "Sunrise";
+ private final static String MOVE_COL_VAL_TEXT2 = "Most Unique Artistic Picture";
+ private final static int MOVE_COL_VAL_ROW = 0;
+
+ private final static int SORT_COL = 1;
+ private final static int[] SORT_VAL_ROWS =new int[] {0, 250, 523};
+ private final static String[][] ASC_PRE_SORT_ROW_VAL = new String[][] {
+ {"1928", "Best Actor", "The Way of All Flesh", "[Emil Jannings]"},
+ {"1933", "Best Director", "Cavalcade", "[Frank Lloyd]"},
+ {"1936", "Best Engineering Effects", "My Man Godfrey", "[Eric Hatch, Morris Ryskind]"}};
+ private final static String[][] ASC_POST_SORT_ROW_VAL = new String[][] {
+ {"1928", "Best Actor", "The Way of All Flesh", "[Emil Jannings]"},
+ {"1936", "Best Director", "My Man Godfrey", "[Gregory La Cava]"},
+ {"1928", "Most Unique Artistic Picture", "The Crowd", "[]"}};
+ private final static String[][] DESC_POST_SORT_ROW_VAL = new String[][] {
+ {"1928", "Most Unique Artistic Picture", "Sunrise", "[]"},
+ {"1934", "Best Engineering Effects", "Viva Villa!", "[Ben Hecht]"},
+ {"1936", "Best Actor", "San Francisco", "[Spencer Tracy]"}};
+
+ /**
+ * Tests the different properties of JTable like number of rows, number
+ * of columns and actions like selection of cell, sorting based on column,
+ * filtering based on text and moving of the column.
+ *
+ * @throws Exception
+ */
+ @Test
+ public void test() throws Exception {
+
+ new ClassReference(TableDemo.class.getCanonicalName()).startApplication();
+
+ JFrameOperator frameOperator = new JFrameOperator(DEMO_TITLE);
+ frameOperator.setComparator(EXACT_STRING_COMPARATOR);
+ frameOperator.setVerification(true);
+ JTableOperator tableOperator = new JTableOperator(frameOperator);
+ JTableHeaderOperator tableHeaderOperator = new JTableHeaderOperator(frameOperator);
+
+ checkTableBasicProperties(tableOperator);
+ checkCellSelection(tableOperator);
+ checkSortTable(tableOperator, tableHeaderOperator);
+ checkMoveColumn(tableOperator, tableHeaderOperator);
+ checkFilterTable(frameOperator, tableOperator);
+ }
+
+ /**
+ * Verifies the table basic properties number of columns, rows and row height
+ *
+ * @param tableOperator
+ */
+ private void checkTableBasicProperties(JTableOperator tableOperator) {
+ tableOperator.waitStateOnQueue(comp
+ -> MAX_COL_COUNT == ((JTable)comp).getColumnCount());
+ waitRowCount(tableOperator, MAX_ROW_COUNT);
+ tableOperator.waitStateOnQueue(comp
+ -> ROW_HEIGHT == ((JTable)comp).getRowHeight());
+ }
+
+ /**
+ * Selects one table cell and verifies the selected cell's row number and column number
+ *
+ * @param tableOperator
+ */
+ private void checkCellSelection(JTableOperator tableOperator) {
+ int noOfColumns = tableOperator.getColumnCount();
+ for (int i = 0; i < SELECT_ROW_INDICES.length; i++) {
+ int rowIndex = SELECT_ROW_INDICES[i];
+ for (int j = 0; j < noOfColumns; j++) {
+ int colIndex = j;
+ tableOperator.clickOnCell(rowIndex, colIndex);
+ tableOperator.waitStateOnQueue(comp
+ -> rowIndex == ((JTable)comp).getSelectedRow() &&
+ colIndex == ((JTable)comp).getSelectedColumn());
+ }
+ }
+ }
+
+ /**
+ * Filter table based on specific text and winners check box, and verifies row count
+ *
+ * @param frameOperator
+ * @param tableOperator
+ */
+ private void checkFilterTable(JFrameOperator frameOperator,
+ JTableOperator tableOperator) {
+
+ int [] filterRowCount = getFilteredCount(tableOperator, FILTER_TEXT);
+ JTextFieldOperator filterField = new JTextFieldOperator(frameOperator);
+ JCheckBoxOperator winnersCheckbox = new JCheckBoxOperator(frameOperator);
+
+ // Filtering based on FILTER_TEXT
+ filterField.setText(FILTER_TEXT);
+ waitRowCount(tableOperator, filterRowCount[0]);
+
+ // Filtering based on WinnersCheckbox
+ winnersCheckbox.setSelected(true);
+ waitRowCount(tableOperator, filterRowCount[1]);
+
+ // Resets the winners check box
+ winnersCheckbox.setSelected(false);
+ waitRowCount(tableOperator, filterRowCount[0]);
+
+ // Resets the filter text field
+ filterField.setText(FILTER_RESET_TEXT);
+ waitRowCount(tableOperator, MAX_ROW_COUNT);
+
+ }
+
+ private int[] getFilteredCount(JTableOperator tableOperator, String filterText){
+ OscarTableModel tableModel = (OscarTableModel)tableOperator.getModel();
+ int noOfRows = tableModel.getRowCount();
+ int filteredRowCount = 0;
+ int filteredWinnersRowCount = 0;
+ for (int i = 0; i < noOfRows; i++) {
+ OscarCandidate candidate = tableModel.getCandidate(i);
+ if(isMovieOrPersonsContainsText(candidate, filterText)){
+ filteredRowCount++;
+ if(candidate.isWinner()) {
+ filteredWinnersRowCount++;
+ }
+ }
+ }
+ return new int[] {filteredRowCount, filteredWinnersRowCount};
+ }
+
+ private boolean isMovieOrPersonsContainsText(
+ OscarCandidate candidate, String filterText){
+ String movie = candidate.getMovieTitle();
+ if(movie != null && movie.contains(filterText)) {
+ return true;
+ } else {
+ List<String> persons = candidate.getPersons();
+ for (String person : persons) {
+ if(person != null && person.contains(filterText)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Moves to swap the columns, move again to reset back, verify column name
+ * and cell values in both the scenarios.
+ *
+ * @param tableOperator
+ * @param tableHeaderOperator
+ */
+ private void checkMoveColumn(JTableOperator tableOperator,
+ JTableHeaderOperator tableHeaderOperator) {
+
+ String[] columnNames = {COLUMN1_NAME, COLUMN3_NAME, COLUMN2_NAME, COLUMN4_NAME};
+ // Moving the column from 'start index' to 'end index'
+ moveColumn(tableOperator, tableHeaderOperator, columnNames,
+ MOVE_COL_START_INDEX, MOVE_COL_END_INDEX);
+
+ // Resets the columns to original position(from 'end index' to 'start index')
+ columnNames[1] = COLUMN2_NAME;
+ columnNames[2] = COLUMN3_NAME;
+ moveColumn(tableOperator, tableHeaderOperator, columnNames,
+ MOVE_COL_END_INDEX, MOVE_COL_START_INDEX);
+ }
+
+ /**
+ * Moves to swap the columns, verify column name and cell values.
+ *
+ * @param tableOperator
+ * @param tableHeaderOperator
+ * @param columnNames
+ * @param moveCol
+ * @param moveToCol
+ */
+ private void moveColumn(JTableOperator tableOperator, JTableHeaderOperator tableHeaderOperator,
+ String[] columnNames, int moveCol, int moveToCol){
+
+ tableHeaderOperator.moveColumn(moveCol, moveToCol);
+ checkColumnNames(tableOperator, columnNames);
+ tableOperator.waitCell(MOVE_COL_VAL_TEXT1, MOVE_COL_VAL_ROW, moveCol);
+ tableOperator.waitCell(MOVE_COL_VAL_TEXT2, MOVE_COL_VAL_ROW, moveToCol);
+ }
+
+ private void checkColumnNames(JTableOperator tableOperator, String[] columnNames) {
+ for (int i = 0; i < tableOperator.getColumnCount(); i++) {
+ int columnIndex = i;
+ tableOperator.waitStateOnQueue(comp -> columnNames[columnIndex].equals(
+ ((JTable)comp).getColumnModel().getColumn(columnIndex).getHeaderValue()));
+ }
+ }
+
+ /**
+ * Sorts the table based on one particular column in ascending and descending order,
+ * and verifies cell values
+ *
+ * @param tableOperator
+ * @param tableHeaderOperator
+ */
+ private void checkSortTable(JTableOperator tableOperator,
+ JTableHeaderOperator tableHeaderOperator) {
+
+ // Verifying the row values before sort
+ checkTableRows(tableOperator, ASC_PRE_SORT_ROW_VAL);
+
+ // Getting all award category values before stating the sort
+ // to prepare the expected result
+ ArrayList<String> awardCats = new ArrayList<>();
+ for (int i = 0; i < tableOperator.getRowCount(); i++) {
+ awardCats.add((String) tableOperator.getValueAt(i, SORT_COL));
+ }
+ // Sorting awardCats(expected result) in ascending order
+ awardCats.sort((s1, s2) -> s1.compareTo(s2));
+
+ // Sorting table based on column 'Award Category' in ascending order
+ sortTable(tableOperator, tableHeaderOperator, awardCats,
+ ASC_POST_SORT_ROW_VAL);
+
+ // Sorting awardCats(expected result) in descending order
+ awardCats.sort((s1, s2) -> s2.compareTo(s1));
+ // Sorting table based on column 'Award Category' in descending order
+ sortTable(tableOperator, tableHeaderOperator, awardCats,
+ DESC_POST_SORT_ROW_VAL);
+
+ }
+
+ private void checkColumnSorted(JTableOperator tableOperator,
+ ArrayList<String> awardCatExp){
+ ArrayList<String> awardCatActual = new ArrayList<>();
+ for (int i = 0; i < tableOperator.getRowCount(); i++) {
+ awardCatActual.add((String) tableOperator.getValueAt(i, SORT_COL));
+ }
+ tableOperator.waitStateOnQueue(comp -> awardCatExp.equals(awardCatActual));
+ }
+
+ private void checkTableRows(JTableOperator tableOperator, String[][] rowValues) {
+ for (int i = 0; i < SORT_VAL_ROWS.length; i++) {
+ tableOperator.waitCell(rowValues[i][0], SORT_VAL_ROWS[i], 0);
+ tableOperator.waitCell(rowValues[i][1], SORT_VAL_ROWS[i], 1);
+ tableOperator.waitCell(rowValues[i][2], SORT_VAL_ROWS[i], 2);
+ tableOperator.waitCell(rowValues[i][3], SORT_VAL_ROWS[i], 3);
+ }
+ }
+
+ /**
+ * Sorts the table based on one particular column and verifies cell values
+ *
+ * @param tableOperator
+ * @param tableHeaderOperator
+ * @param awardCatExp
+ * @param rowValues
+ */
+ private void sortTable(JTableOperator tableOperator, JTableHeaderOperator tableHeaderOperator,
+ ArrayList<String> awardCatExp, String[][] rowValues) {
+
+ tableHeaderOperator.selectColumn(SORT_COL);
+ checkColumnSorted(tableOperator, awardCatExp);
+ // Verifying the row values after sort
+ checkTableRows(tableOperator, rowValues);
+ }
+
+ /**
+ * Waits the number of rows on table equal to the count specified
+ *
+ * @param tableOperator
+ * @param count
+ */
+ private void waitRowCount(JTableOperator tableOperator, int count) {
+ tableOperator.waitStateOnQueue(comp
+ -> count == ((JTable)comp).getRowCount());
+ }
+
+}