| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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 fvt.gui.sc.sort; |
| |
| import static org.junit.Assert.*; |
| import static org.openoffice.test.common.Testspace.*; |
| import static org.openoffice.test.vcl.Tester.*; |
| import static testlib.gui.AppTool.*; |
| import static testlib.gui.UIMap.*; |
| |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Ignore; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.openoffice.test.common.FileUtil; |
| import org.openoffice.test.common.Logger; |
| |
| import testlib.gui.AppTool; |
| import testlib.gui.SCTool; |
| |
| /** |
| * Test Data->Sort dialog setting |
| */ |
| public class SortDialogSetting { |
| |
| @Rule |
| public Logger log = Logger.getLogger(this); |
| |
| @Before |
| public void setUp() throws Exception { |
| app.start(true); |
| AppTool.newSpreadsheet(); |
| } |
| |
| @After |
| public void tearDown() throws Exception { |
| app.stop(); |
| } |
| |
| /** |
| * Test sort with options setting: case sensitive |
| * |
| * @throws Exception |
| */ |
| @Test |
| public void testSortOptionsCaseSensitive() throws Exception { |
| |
| // Input some data: A1~A6: 1ColumnName,D,C,B,A,a |
| String[][] data = new String[][] { { "D" }, { "C" }, { "B" }, { "A" }, { "a" }, }; |
| String[][] expectedSortedResult = new String[][] { { "a" }, { "A" }, { "B" }, { "C" }, { "D" }, }; |
| SCTool.selectRange("A1"); |
| typeKeys("1ColumnName<down>D<down>C<down>B<down>A<down>a<down>"); |
| SCTool.selectRange("A6"); |
| app.dispatch(".uno:ChangeCaseToLower"); |
| // In case SC capitalize first letter automatically |
| // "Data->Sort...", choose "Ascending", check "Case sensitive" |
| app.dispatch(".uno:DataSort"); |
| sortOptionsPage.select(); |
| sortOptionsPageCaseSensitive.check(); |
| sortOptionsPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Wrong Sorted result", expectedSortedResult, SCTool.getCellTexts("A2:A6")); |
| |
| // Uodo/redo |
| app.dispatch(".uno:Undo"); |
| assertArrayEquals("Wrong Undo sorted result", data, SCTool.getCellTexts("A2:A6")); |
| app.dispatch(".uno:Redo"); |
| assertArrayEquals("Wrong Redo sorted result", expectedSortedResult, SCTool.getCellTexts("A2:A6")); |
| |
| // Save and close document |
| String saveTo = getPath("temp/" + "RowsSortWithOptionsCaseSensitive.ods"); |
| FileUtil.deleteFile(saveTo); |
| saveAndReopen(saveTo); |
| calc.waitForExistence(10, 2); |
| assertArrayEquals("Saved sorted result", expectedSortedResult, SCTool.getCellTexts("A2:A6")); |
| } |
| |
| /** |
| * Test sort with options setting: copy sort result to |
| * |
| * @throws Exception |
| */ |
| @Ignore("Bug #119035 - Redo is not work when sort result to other postion") |
| public void testSortOptionsCopyResultTo() throws Exception { |
| |
| String[][] expectedSortedResult = new String[][] { { "1", "AB" }, { "2", "BC" }, { "3", "D" }, { "4", "E" }, { "5", "FLK" }, { "6", "GE" }, }; |
| SCTool.selectRange("A1"); |
| typeKeys("3<down>5<down>4<down>2<down>6<down>1"); |
| SCTool.selectRange("B1"); |
| typeKeys("D<down>FLK<down>E<down>BC<down>GE<down>AB"); |
| |
| // Data->Sort..., choose "Ascending", check "Copy sort results to:" |
| app.dispatch(".uno:DataSort"); |
| sortOptionsPage.select(); |
| sortOptionsPageCopyResultTo.check(); |
| sortOptionsPageCopyResultToEdit.setText("$Sheet3.$A4"); |
| sortOptionsPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Copy sorted result to", expectedSortedResult, SCTool.getCellTexts("$Sheet3.$A4:$B9")); |
| |
| // Uodo/redo |
| app.dispatch(".uno:Undo"); |
| assertEquals("Undo sorted result", "", SCTool.getCellText("$Sheet3.$A4")); |
| app.dispatch(".uno:Redo"); |
| assertArrayEquals("Redo sorted result", expectedSortedResult, SCTool.getCellTexts("$Sheet3.$A4:$B9")); |
| |
| // Move focus to sheet2 then select a cell range, |
| // Insert->Names->Define... |
| SCTool.selectRange("$Sheet2.$A1:$B3"); |
| app.dispatch(".uno:DefineName"); |
| defineNamesDlgNameEdit.setText("cellRange"); |
| defineNamesDlg.ok(); |
| |
| // Set focus to the original data, Data->Sort... |
| SCTool.selectRange("$Sheet1.$B1"); |
| app.dispatch(".uno:DataSort"); |
| sortOptionsPage.select(); |
| sortOptionsPageCopyResultTo.check(); |
| sortOptionsPageCopyResultToCellRange.select("cellRange"); |
| sortOptionsPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Copy sorted result to cell range", expectedSortedResult, SCTool.getCellTexts("$Sheet2.$A1:$B6")); |
| |
| // Uodo/redo |
| app.dispatch(".uno:Undo"); |
| assertEquals("Undo sorted result", "", SCTool.getCellText("$Sheet2.$A1")); |
| app.dispatch(".uno:Redo"); |
| assertArrayEquals("Redo sorted result", expectedSortedResult, SCTool.getCellTexts("$Sheet2.$A1:$B6")); |
| |
| // Save and close document |
| String saveTo = getPath("temp/" + "RowsSortWithOptionsCopyResultTo.ods"); |
| FileUtil.deleteFile(saveTo); |
| saveAndReopen(saveTo); |
| |
| calc.waitForExistence(10, 2); |
| assertArrayEquals("Saved sorted result", expectedSortedResult, SCTool.getCellTexts("$Sheet3.$A4:$B9")); |
| assertArrayEquals("Saved sorted result to cell range", expectedSortedResult, SCTool.getCellTexts("$Sheet2.$A1:$B6")); |
| } |
| |
| /** |
| * Test sort criteria: sort first by |
| * |
| * @throws Exception |
| */ |
| @Test |
| public void testSortCriteriaSortFirstBy() throws Exception { |
| |
| // Input some data |
| String[][] data = new String[][] { { "3", "D" }, { "5", "FLK" }, { "4", "E" }, { "2", "BC" }, { "6", "GE" }, { "1", "AB" }, }; |
| String[][] expectedResultSortByColumnBAscending = new String[][] { { "1", "AB" }, { "2", "BC" }, { "3", "D" }, { "4", "E" }, { "5", "FLK" }, { "6", "GE" }, }; |
| String[][] expectedResultSortByColumnADescending = new String[][] { { "6", "GE" }, { "5", "FLK" }, { "4", "E" }, { "3", "D" }, { "2", "BC" }, { "1", "AB" }, }; |
| SCTool.selectRange("A1"); |
| typeKeys("3<down>5<down>4<down>2<down>6<down>1"); |
| SCTool.selectRange("B1"); |
| typeKeys("D<down>FLK<down>E<down>BC<down>GE<down>AB"); |
| |
| // "Data->Sort...", choose "Ascending", sort first by Column B |
| app.dispatch(".uno:DataSort"); |
| sortPageAscending1.check(); |
| sortPageBy1.select(2); // "Column B" |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Sorted result", expectedResultSortByColumnBAscending, SCTool.getCellTexts("A1:B6")); |
| |
| // Uodo/redo |
| app.dispatch(".uno:Undo"); |
| assertArrayEquals("Undo sorted result", data, SCTool.getCellTexts("A1:B6")); |
| app.dispatch(".uno:Redo"); |
| assertArrayEquals("Redo sorted result", expectedResultSortByColumnBAscending, SCTool.getCellTexts("A1:B6")); |
| app.dispatch(".uno:Undo"); |
| |
| // Save and close document |
| String saveTo = getPath("temp/" + "SortCriteriaSortFirstBy.ods"); |
| FileUtil.deleteFile(saveTo); |
| saveAndReopen(saveTo); |
| |
| calc.waitForExistence(10, 2); |
| // "Data->Sort...", choose "Descending", sort first by Column A |
| app.dispatch(".uno:DataSort"); |
| sortPageDescending1.check(); |
| sortPageBy1.select(1); // "Column A" |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Saved sorted result", expectedResultSortByColumnADescending, SCTool.getCellTexts("A1:B6")); |
| } |
| |
| /** |
| * Test sort criteria: sort second by |
| * |
| * @throws Exception |
| */ |
| @Test |
| public void testSortCriteriaSortSecondBy() throws Exception { |
| |
| // Input some data |
| String[][] data = new String[][] { { "3", "D" }, { "5", "FLK" }, { "4", "E" }, { "1", "AB" }, { "6", "GE" }, { "2", "AB" }, }; |
| String[][] expectedResultSortFirstByB = new String[][] { { "1", "AB" }, { "2", "AB" }, { "3", "D" }, { "4", "E" }, { "5", "FLK" }, { "6", "GE" }, }; |
| String[][] expectedResultSortSecondByA = new String[][] { { "2", "AB" }, { "1", "AB" }, { "3", "D" }, { "4", "E" }, { "5", "FLK" }, { "6", "GE" }, }; |
| SCTool.selectRange("A1"); |
| typeKeys("3<down>5<down>4<down>1<down>6<down>2"); |
| SCTool.selectRange("B1"); |
| typeKeys("D<down>FLK<down>E<down>AB<down>GE<down>AB"); |
| |
| // "Data->Sort...", choose "Ascending", sort first by Column B |
| app.dispatch(".uno:DataSort"); |
| sortPageAscending1.check(); |
| sortPageBy1.select(2); // "Column B" |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Sorted result", expectedResultSortFirstByB, SCTool.getCellTexts("A1:B6")); |
| |
| // Uodo/redo |
| app.dispatch(".uno:Undo"); |
| assertArrayEquals("Undo sorted result", data, SCTool.getCellTexts("A1:B6")); |
| app.dispatch(".uno:Redo"); |
| assertArrayEquals("Redo sorted result", expectedResultSortFirstByB, SCTool.getCellTexts("A1:B6")); |
| app.dispatch(".uno:Undo"); |
| |
| // Save and close document |
| String saveTo = getPath("temp/" + "SortCriteriaSortSecondBy.ods"); |
| FileUtil.deleteFile(saveTo); |
| saveAndReopen(saveTo); |
| |
| // // "Data->Sort...", sort first by Column B "Ascending", sort |
| // // second by Column A "Descending" |
| calc.waitForExistence(10, 2); |
| app.dispatch(".uno:DataSort"); |
| sortPageBy1.select(2); // "Column B" |
| sortPageAscending1.check(); |
| sortPageBy2.select(1); // "Column A" |
| sortPageDescending2.check(); |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Saved sorted result", expectedResultSortSecondByA, SCTool.getCellTexts("A1:B6")); |
| } |
| |
| /** |
| * Test sort criteria: sort third by |
| * |
| * @throws Exception |
| */ |
| @Test |
| public void testSortCriteriaSortThirdBy() throws Exception { |
| |
| // Input some data |
| String[][] data = new String[][] { { "3", "AB", "2" }, { "8", "FLK", "5" }, { "6", "E", "4" }, { "1", "AB", "1" }, { "9", "GE", "6" }, { "2", "AB", "2" }, |
| { "7", "EFYU", "7" }, { "5", "DS", "8" }, { "4", "AB", "1" }, }; |
| String[][] expectedResultSortFirstByB = new String[][] { { "3", "AB", "2" }, { "1", "AB", "1" }, { "2", "AB", "2" }, { "4", "AB", "1" }, { "5", "DS", "8" }, |
| { "6", "E", "4" }, { "7", "EFYU", "7" }, { "8", "FLK", "5" }, { "9", "GE", "6" }, }; |
| String[][] expectedResultSortSecondByC = new String[][] { { "3", "AB", "2" }, { "2", "AB", "2" }, { "1", "AB", "1" }, { "4", "AB", "1" }, { "5", "DS", "8" }, |
| { "6", "E", "4" }, { "7", "EFYU", "7" }, { "8", "FLK", "5" }, { "9", "GE", "6" }, }; |
| String[][] expectedResultSortThirdByA = new String[][] { { "3", "AB", "2" }, { "2", "AB", "2" }, { "4", "AB", "1" }, { "1", "AB", "1" }, { "5", "DS", "8" }, |
| { "6", "E", "4" }, { "7", "EFYU", "7" }, { "8", "FLK", "5" }, { "9", "GE", "6" }, }; |
| SCTool.selectRange("A1"); |
| typeKeys("3<down>8<down>6<down>1<down>9<down>2<down>7<down>5<down>4"); |
| SCTool.selectRange("B1"); |
| typeKeys("AB<down>FLK<down>E<down>AB<down>GE<down>AB<down>EFYU<down>DS<down>AB"); |
| SCTool.selectRange("C1"); |
| typeKeys("2<down>5<down>4<down>1<down>6<down>2<down>7<down>8<down>1"); |
| |
| // "Data->Sort...", choose "Ascending", sort first by Column B |
| app.dispatch(".uno:DataSort"); |
| sortPageBy1.select(2); // "Column B" |
| sortPageAscending1.check(); |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Sorted result", expectedResultSortFirstByB, SCTool.getCellTexts("A1:C9")); |
| |
| // Uodo/redo |
| app.dispatch(".uno:Undo"); |
| assertArrayEquals("Undo sorted result", data, SCTool.getCellTexts("A1:C9")); |
| app.dispatch(".uno:Redo"); |
| assertArrayEquals("Redo sorted result", expectedResultSortFirstByB, SCTool.getCellTexts("A1:C9")); |
| app.dispatch(".uno:Undo"); |
| |
| // Save and close document |
| String saveTo = getPath("temp/" + "SortCriteriaSortThirdBy.ods"); |
| FileUtil.deleteFile(saveTo); |
| saveAndReopen(saveTo); |
| |
| // Reopen, "Data->Sort...", sort first by Column B "Ascending", sort |
| // second by Column C "Descending" |
| calc.waitForExistence(10, 2); |
| app.dispatch(".uno:DataSort"); |
| sortPageBy1.select(2); // "Column B" |
| sortPageAscending1.check(); |
| sortPageBy2.select(3); // "Column C" |
| sortPageDescending2.check(); |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Sorted result", expectedResultSortSecondByC, SCTool.getCellTexts("A1:C9")); |
| |
| // "Data->Sort...", sort first by Column B "Ascending", sort second by |
| // Column C "Descending", sort third by Column A "Descending" |
| app.dispatch(".uno:DataSort"); |
| sortPageBy1.select(2); // "Column B" |
| sortPageAscending1.check(); |
| sortPageBy2.select(3); // "Column C" |
| sortPageDescending2.check(); |
| sortPageBy3.select(1); // "Column A" |
| sortPageDescending3.check(); |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Sorted result", expectedResultSortThirdByA, SCTool.getCellTexts("A1:C9")); |
| |
| // Uodo/redo |
| app.dispatch(".uno:Undo"); |
| assertArrayEquals("Undo sorted result", expectedResultSortSecondByC, SCTool.getCellTexts("A1:C9")); |
| app.dispatch(".uno:Redo"); |
| assertArrayEquals("Redo sorted result", expectedResultSortThirdByA, SCTool.getCellTexts("A1:C9")); |
| |
| // Save and close document |
| saveTo = getPath("temp/" + "SortCriteriaSortThirdBy1.ods"); |
| FileUtil.deleteFile(saveTo); |
| saveAndReopen(saveTo); |
| |
| calc.waitForExistence(10, 2); |
| assertArrayEquals("Saved sorted result", expectedResultSortThirdByA, SCTool.getCellTexts("A1:C9")); |
| } |
| |
| /** |
| * Test sort options: custom sort order, predefined in preferences from copy |
| * list |
| * |
| * @throws Exception |
| */ |
| @Test |
| public void testSortOptionsCustomSortOrderPredefineFromCopyList() throws Exception { |
| |
| // Dependencies start |
| SCTool.selectRange("A1"); |
| typeKeys("red<down>yellow<down>blue<down>green<down>white<down>black"); |
| SCTool.selectRange("A1:A6"); |
| app.dispatch(".uno:ChangeCaseToLower"); // In case SC capitalize first |
| // letter automatically |
| |
| // Select the cell range, |
| // "Tools->Options...->OpenOffice.org Spreadsheets->Sort Lists" |
| SCTool.selectRange("A1:A6"); |
| app.dispatch(".uno:OptionsTreeDialog"); |
| optionsDlgList.collapseAll(); |
| // // Select "Sort Lists": start. Shrink the tree list and select |
| // OptionsDlgList.select(0); |
| // typeKeys("<left>"); |
| // for (int i=0; i<6; i++) { |
| // typeKeys("<down><left>"); |
| // } |
| optionsDlgList.expand(3); |
| // typeKeys("<right>"); |
| optionsDlgList.select(7); |
| // // Select "Sort Lists": end |
| |
| // Click "Copy" button, "OK", close the document |
| optionsDlgSortListsTabCopy.click(); |
| optionsDlg.ok(); |
| app.dispatch(".uno:CloseDoc"); |
| msgBox_AdditionalRowsNotSaved.no(); |
| // Dependencies end |
| |
| // Create a new spreadsheet document |
| app.dispatch("private:factory/scalc"); |
| |
| // Input some data |
| String[][] data = new String[][] { { "Color" }, { "black" }, { "yellow" }, { "blue" }, { "black" }, { "white" }, { "red" }, }; |
| String[][] expectedResultNoCustomSortOrder = new String[][] { { "Color" }, { "black" }, { "black" }, { "blue" }, { "red" }, { "white" }, { "yellow" }, }; |
| String[][] expectedResultCustomSortOrder = new String[][] { { "Color" }, { "red" }, { "yellow" }, { "blue" }, { "white" }, { "black" }, { "black" }, }; |
| SCTool.selectRange("A1"); |
| typeKeys("Color<down>black<down>yellow<down>blue<down>black<down>white<down>red"); |
| SCTool.selectRange("A2:A7"); |
| app.dispatch(".uno:ChangeCaseToLower"); // In case SC capitalize first |
| // letter automatically |
| |
| // "Data->Sort...", "Options" tab, check "Range contains column labels", |
| // no custom sort order, "Ascending", sort first by Color |
| SCTool.selectRange("A1:A7"); |
| app.dispatch(".uno:DataSort"); |
| sortOptionsPage.select(); |
| sortOptionsPageRangeContainsColumnLabels.check(); |
| sortOptionsPageCustomSortOrder.uncheck(); |
| sortPage.select(); |
| sortPageBy1.select(1); // "Color" |
| sortPageAscending1.check(); |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Sorted result without custom sort order", expectedResultNoCustomSortOrder, SCTool.getCellTexts("A1:A7")); |
| |
| // Uodo/redo |
| app.dispatch(".uno:Undo"); |
| assertArrayEquals("Undo sorted result", data, SCTool.getCellTexts("A1:A7")); |
| app.dispatch(".uno:Redo"); |
| assertArrayEquals("Redo sorted result", expectedResultNoCustomSortOrder, SCTool.getCellTexts("A1:A7")); |
| app.dispatch(".uno:Undo"); |
| |
| // Copy original data to sheet2 |
| SCTool.selectRange("A1:A7"); |
| app.dispatch(".uno:Copy"); |
| app.dispatch(".uno:SelectTables"); |
| scSheetsList.select(1); |
| scSelectSheetsDlg.ok(); |
| app.dispatch(".uno:Paste"); |
| |
| // "Data->Sort...", "Options" tab, check "Range contains column labels", |
| // choose custom sort order, "Ascending", sort first by Color |
| app.dispatch(".uno:DataSort"); |
| sortOptionsPage.select(); |
| sortOptionsPageRangeContainsColumnLabels.check(); |
| sortOptionsPageCustomSortOrder.check(); |
| sortOptionsPageCustomSortOrderList.select("red,yellow,blue,green,white,black"); |
| sortPage.select(); |
| sortPageBy1.select(1); // "Color" |
| sortPageAscending1.check(); |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Sorted result with custom sort order", expectedResultCustomSortOrder, SCTool.getCellTexts("A1:A7")); |
| |
| // Uodo/redo |
| app.dispatch(".uno:Undo"); |
| assertArrayEquals("Undo sorted result", data, SCTool.getCellTexts("A1:A7")); |
| app.dispatch(".uno:Redo"); |
| assertArrayEquals("Redo sorted result", expectedResultCustomSortOrder, SCTool.getCellTexts("A1:A7")); |
| |
| // Save and close document |
| String saveTo = getPath("temp/" + "SortOptionsCustomSortOrderPredefineFromCopyList.ods"); |
| FileUtil.deleteFile(saveTo); |
| saveAndReopen(saveTo); |
| |
| calc.waitForExistence(10, 2); |
| app.dispatch(".uno:SelectTables"); |
| scSheetsList.select(0); // Sheet 1 |
| scSelectSheetsDlg.ok(); |
| assertArrayEquals("Original data", data, SCTool.getCellTexts("$A1:$A7")); |
| app.dispatch(".uno:SelectTables"); |
| scSheetsList.select(1); // Sheet 2 |
| scSelectSheetsDlg.ok(); |
| assertArrayEquals("Saved sorted result", expectedResultCustomSortOrder, SCTool.getCellTexts("$A1:$A7")); |
| } |
| |
| /** |
| * Test sort options: custom sort order, predefined in preferences from new |
| * list |
| * |
| * @throws Exception |
| */ |
| @Test |
| public void testSortOptionsCustomSortOrderPredefineFromNewList() throws Exception { |
| |
| // Dependencies start |
| // "Tools->Options...->OpenOffice.org Spreadsheets->Sort Lists" |
| app.dispatch(".uno:OptionsTreeDialog"); |
| // Select "Sort Lists": start. Shrink the tree list and select |
| optionsDlgList.select(0); |
| typeKeys("<left>"); |
| for (int i = 0; i < 6; i++) { |
| typeKeys("<down><left>"); |
| } |
| optionsDlgList.select(3); |
| typeKeys("<right>"); |
| optionsDlgList.select(7); |
| // Select "Sort Lists": end |
| |
| // Click "New" button, input "white,red,yellow,blue,green,black", press |
| // "Add" and "OK", close the document |
| optionsDlgSortListsTabNew.click(); |
| typeKeys("white,red,yellow,blue,green,black"); |
| optionsDlgSortListsTabAdd.click(); |
| optionsDlg.ok(); |
| app.dispatch(".uno:CloseDoc"); |
| // Dependencies end |
| |
| AppTool.newSpreadsheet(); |
| |
| // Input some data |
| String[][] data = new String[][] { { "Color" }, { "black" }, { "yellow" }, { "blue" }, { "black" }, { "white" }, { "red" }, }; |
| String[][] expectedResultNoCustomSortOrder = new String[][] { { "Color" }, { "black" }, { "black" }, { "blue" }, { "red" }, { "white" }, { "yellow" }, }; |
| String[][] expectedResultCustomSortOrder = new String[][] { { "Color" }, { "white" }, { "red" }, { "yellow" }, { "blue" }, { "black" }, { "black" }, }; |
| SCTool.selectRange("A1"); |
| typeKeys("Color<down>black<down>yellow<down>blue<down>black<down>white<down>red"); |
| SCTool.selectRange("A2:A7"); |
| app.dispatch(".uno:ChangeCaseToLower"); // In case SC capitalize first |
| // letter automatically |
| |
| // "Data->Sort...", "Options" tab, check "Range contains column labels", |
| // no custom sort order, "Ascending", sort first by Color |
| SCTool.selectRange("A1:A7"); |
| app.dispatch(".uno:DataSort"); |
| sortOptionsPage.select(); |
| sortOptionsPageRangeContainsColumnLabels.check(); |
| sortOptionsPageCustomSortOrder.uncheck(); |
| sortPage.select(); |
| sortPageBy1.select(1); // "Color" |
| sortPageAscending1.check(); |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Sorted result without custom sort order", expectedResultNoCustomSortOrder, SCTool.getCellTexts("A1:A7")); |
| |
| // Uodo/redo |
| app.dispatch(".uno:Undo"); |
| assertArrayEquals("Undo sorted result", data, SCTool.getCellTexts("A1:A7")); |
| app.dispatch(".uno:Redo"); |
| assertArrayEquals("Redo sorted result", expectedResultNoCustomSortOrder, SCTool.getCellTexts("A1:A7")); |
| app.dispatch(".uno:Undo"); |
| |
| // Copy original data to sheet2 |
| SCTool.selectRange("A1:A7"); |
| app.dispatch(".uno:Copy"); |
| app.dispatch(".uno:SelectTables"); |
| scSheetsList.select(1); // Sheet 2 |
| scSelectSheetsDlg.ok(); |
| app.dispatch(".uno:Paste"); |
| |
| // "Data->Sort...", "Options" tab, check "Range contains column labels", |
| // choose custom sort order, "Ascending", sort first by Color |
| app.dispatch(".uno:DataSort"); |
| sortOptionsPage.select(); |
| sortOptionsPageRangeContainsColumnLabels.check(); |
| sortOptionsPageCustomSortOrder.check(); |
| sortOptionsPageCustomSortOrderList.select("white,red,yellow,blue,green,black"); |
| sortPage.select(); |
| sortPageBy1.select(1); // "Color" |
| sortPageAscending1.check(); |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Sorted result with custom sort order", expectedResultCustomSortOrder, SCTool.getCellTexts("A1:A7")); |
| |
| // Uodo/redo |
| app.dispatch(".uno:Undo"); |
| assertArrayEquals("Undo sorted result", data, SCTool.getCellTexts("A1:A7")); |
| app.dispatch(".uno:Redo"); |
| assertArrayEquals("Redo sorted result", expectedResultCustomSortOrder, SCTool.getCellTexts("A1:A7")); |
| |
| // Save and close document |
| String saveTo = getPath("temp/" + "SortOptionsCustomSortOrderPredefineFromNewList.ods"); |
| FileUtil.deleteFile(saveTo); |
| saveAndReopen(saveTo); |
| |
| calc.waitForExistence(10, 2); |
| app.dispatch(".uno:SelectTables"); |
| scSheetsList.select(0); // Sheet 1 |
| scSelectSheetsDlg.ok(); |
| assertArrayEquals("Original data", data, SCTool.getCellTexts("$A1:$A7")); |
| app.dispatch(".uno:SelectTables"); |
| scSheetsList.select(1); // Sheet 2 |
| scSelectSheetsDlg.ok(); |
| assertArrayEquals("Saved sorted result", expectedResultCustomSortOrder, SCTool.getCellTexts("$A1:$A7")); |
| } |
| |
| /** |
| * Test sort options: sort columns, direction "Left to right" |
| * |
| * @throws Exception |
| */ |
| @Test |
| public void testSortOptionsDirectionSortColumns() throws Exception { |
| |
| // Input some data |
| String[][] data = new String[][] { { "Units", "7", "27", "4", "12", "3", "6" }, }; |
| String[][] expectedSortedResult = new String[][] { { "Units", "3", "4", "6", "7", "12", "27" }, }; |
| SCTool.selectRange("A1"); |
| typeKeys("Units<right>7<right>27<right>4<right>12<right>3<right>6"); |
| sleep(1); // If no sleep, some strings lost |
| |
| // "Data->Sort...", check "Range contains column labels", |
| // "Left to right", sort first by"Units", "Ascending" |
| app.dispatch(".uno:DataSort"); |
| sortOptionsPage.select(); |
| sortOptionsPageRangeContainsColumnLabels.check(); |
| sortOptionsPageLeftToRight.check(); |
| sortPage.select(); |
| sortPageBy1.select(1); // Choose "Units" |
| sortPageAscending1.check(); |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Sorted result", expectedSortedResult, SCTool.getCellTexts("A1:G1")); |
| |
| // Uodo/redo |
| app.dispatch(".uno:Undo"); |
| assertArrayEquals("Undo sorted result", data, SCTool.getCellTexts("A1:G1")); |
| app.dispatch(".uno:Redo"); |
| assertArrayEquals("Redo sorted result", expectedSortedResult, SCTool.getCellTexts("A1:G1")); |
| |
| // Save and close document |
| String saveTo = getPath("temp/" + "SortOptionsDirectionSortColumns.ods"); |
| FileUtil.deleteFile(saveTo); |
| saveAndReopen(saveTo); |
| |
| calc.waitForExistence(10, 2); |
| assertArrayEquals("Saved sorted result", expectedSortedResult, SCTool.getCellTexts("A1:G1")); |
| } |
| |
| /** |
| * Test sort options: "Include formats" |
| * |
| * @throws Exception |
| */ |
| @Test |
| public void testSortOptionsIncludeFormats() throws Exception { |
| |
| String[][] dataWithCurrencyFormats = new String[][] { { "Units" }, { "$32.00" }, { "57.00 \u20ac" }, { "\u20a4 74" }, { "R$ 50.00" }, { "\u062c.\u0645. 27" }, |
| { "7.00 \u0440\u0443\u0431" }, }; |
| String[][] expectedSortedResultIncludeFormat = new String[][] { { "Units" }, { "7.00 \u0440\u0443\u0431" }, { "\u062c.\u0645. 27" }, { "$32.00" }, { "R$ 50.00" }, |
| { "57.00 \u20ac" }, { "\u20a4 74" }, }; |
| String[][] expectedSortedResultExcludeFormat = new String[][] { { "Units" }, { "$7.00" }, { "27.00 \u20ac" }, { "\u20a4 32" }, { "R$ 50.00" }, { "\u062c.\u0645. 57" }, |
| { "74.00 \u0440\u0443\u0431" }, }; |
| |
| // Open sample file to get source data |
| String file = prepareData("sc/SortOptionsIncludeFormats.ods"); |
| app.dispatch(".uno:Open", 3); |
| submitOpenDlg(file); |
| calc.waitForExistence(10, 2); |
| |
| assertArrayEquals("source", dataWithCurrencyFormats, SCTool.getCellTexts("A1:A7")); |
| |
| // "Data->Sort...", check "Range contains column labels", check |
| // "Include formats", sort first by "Units", "Ascending" |
| app.dispatch(".uno:DataSort"); |
| sortOptionsPage.select(); |
| sortOptionsPageRangeContainsColumnLabels.check(); |
| sortOptionsPageIncludeFormats.check(); |
| sortPage.select(); |
| sortPageBy1.select(1); // "Units" |
| sortPageAscending1.check(); |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Sorted result include formats", expectedSortedResultIncludeFormat, SCTool.getCellTexts("A1:A7")); |
| |
| // Uodo/redo |
| app.dispatch(".uno:Undo"); |
| assertArrayEquals("Undo sorted result", dataWithCurrencyFormats, SCTool.getCellTexts("A1:A7")); |
| app.dispatch(".uno:Redo"); |
| assertArrayEquals("Redo sorted result", expectedSortedResultIncludeFormat, SCTool.getCellTexts("A1:A7")); |
| app.dispatch(".uno:Undo"); |
| |
| // Copy the original data to sheet2 |
| SCTool.selectRange("A1:A7"); |
| app.dispatch(".uno:Copy"); |
| SCTool.selectRange("Sheet2.A1"); |
| app.dispatch(".uno:Paste"); |
| |
| // "Data->Sort...", check "Range contains column labels", uncheck |
| // "Include formats", sort first by "Units", "Ascending" |
| app.dispatch(".uno:DataSort"); |
| sortOptionsPage.select(); |
| sortOptionsPageRangeContainsColumnLabels.check(); |
| sortOptionsPageIncludeFormats.uncheck(); |
| sortPage.select(); |
| sortPageBy1.select(1); // "Units" |
| sortPageAscending1.check(); |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Sorted result exclude formats", expectedSortedResultExcludeFormat, SCTool.getCellTexts("A1:A7")); |
| |
| // Uodo/redo |
| app.dispatch(".uno:Undo"); |
| assertArrayEquals("Undo sorted result", dataWithCurrencyFormats, SCTool.getCellTexts("A1:A7")); |
| app.dispatch(".uno:Redo"); |
| assertArrayEquals("Redo sorted result", expectedSortedResultExcludeFormat, SCTool.getCellTexts("A1:A7")); |
| |
| // Save and close document |
| String saveTo = getPath("temp/" + "SortOptionsIncludeFormats.ods"); |
| FileUtil.deleteFile(saveTo); |
| saveAndReopen(saveTo); |
| |
| calc.waitForExistence(10, 2); |
| assertArrayEquals("Original data", dataWithCurrencyFormats, SCTool.getCellTexts("$Sheet1.$A1:$A7")); |
| assertArrayEquals("Saved sorted result exclude format", expectedSortedResultExcludeFormat, SCTool.getCellTexts("$Sheet2.$A1:$A7")); |
| } |
| |
| /** |
| * Test sort options: multiple sort, data overlap |
| * |
| * @throws Exception |
| */ |
| @Test |
| public void testSortOptionsMultipleSortDataOverlap() throws Exception { |
| |
| // Input some data |
| String[][] data1 = new String[][] { { "D" }, { "C" }, { "B" }, { "A" }, { "E" }, }; |
| String[][] expectedSortedResult1 = new String[][] { { "A" }, { "B" }, { "C" }, { "D" }, { "E" }, }; |
| String[][] data2 = new String[][] { { "4" }, { "2" }, { "5" }, { "1" }, { "3" }, }; |
| String[][] expectedSortedResultDataOverlap = new String[][] { { "A" }, { "B" }, { "C" }, { "1" }, { "2" }, { "3" }, { "4" }, { "5" }, }; |
| SCTool.selectRange("A1"); |
| typeKeys("D<down>C<down>B<down>A<down>E"); |
| sleep(1); // If no sleep, some strings lost |
| |
| // "Data->Sort...", uncheck "Range contains column labels", sort first |
| // by "Column A", "Ascending" |
| app.dispatch(".uno:DataSort"); |
| sortOptionsPage.select(); |
| sortOptionsPageRangeContainsColumnLabels.uncheck(); |
| sortPage.select(); |
| sortPageBy1.select(1); // "Column A" |
| sortPageAscending1.check(); |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Sorted result", expectedSortedResult1, SCTool.getCellTexts("A1:A5")); |
| |
| // Uodo/redo |
| app.dispatch(".uno:Undo"); |
| assertArrayEquals("Undo sorted result", data1, SCTool.getCellTexts("A1:A5")); |
| app.dispatch(".uno:Redo"); |
| assertArrayEquals("Redo sorted result", expectedSortedResult1, SCTool.getCellTexts("A1:A5")); |
| |
| // Input data2 into same sheet, data1 and data2 are not overlapped |
| SCTool.selectRange("G10"); |
| typeKeys("4<down>2<down>5<down>1<down>3"); |
| |
| // Focus on data2, "Data->Sort...", "Copy result to" partially overlap |
| // with data1, sort first by "Column G", "Ascending" |
| SCTool.selectRange("G10"); |
| app.dispatch(".uno:DataSort"); |
| sortOptionsPage.select(); |
| sortOptionsPageRangeContainsColumnLabels.uncheck(); |
| sortOptionsPageCopyResultTo.check(); |
| sortOptionsPageCopyResultToEdit.setText("A4"); |
| sortPage.select(); |
| sortPageBy1.select(1); // "Column G" |
| sortPageAscending1.check(); |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Sorted result data overlap", expectedSortedResultDataOverlap, SCTool.getCellTexts("A1:A8")); |
| |
| // Save and close document |
| String saveTo = getPath("temp/" + "SortOptionsMultipleSortDataOverlap.ods"); |
| FileUtil.deleteFile(saveTo); |
| saveAndReopen(saveTo); |
| |
| calc.waitForExistence(10, 2); |
| assertArrayEquals("Saved sorted result", expectedSortedResultDataOverlap, SCTool.getCellTexts("A1:A8")); |
| assertArrayEquals("Original data2", data2, SCTool.getCellTexts("G10:G14")); |
| } |
| |
| /** |
| * Test sort options: multiple sort, no data overlap, sort parameter saved |
| * correctly |
| * |
| * @throws Exception |
| */ |
| @Test |
| public void testSortOptionsMultipleSortSortParameterSaved() throws Exception { |
| |
| // Input some data |
| String[][] data1 = new String[][] { { "D" }, { "C" }, { "B" }, { "A" }, { "E" }, }; |
| String[][] expectedSortedResult1 = new String[][] { { "A" }, { "B" }, { "C" }, { "D" }, { "E" }, }; |
| String[][] data2 = new String[][] { { "Numbers" }, { "4" }, { "2" }, { "5" }, { "1" }, { "3" }, }; |
| String[][] expectedSortedResult2 = new String[][] { { "Numbers" }, { "1" }, { "2" }, { "3" }, { "4" }, { "5" }, }; |
| SCTool.selectRange("A1"); |
| typeKeys("D<down>C<down>B<down>A<down>E"); |
| sleep(1); // If no sleep, some strings lost |
| |
| // "Data->Sort...", uncheck "Range contains column labels", check |
| // "Case sensitive" and "Include formats", sort first by "Column A", |
| // "Ascending" |
| app.dispatch(".uno:DataSort"); |
| sortOptionsPage.select(); |
| sortOptionsPageRangeContainsColumnLabels.uncheck(); |
| sortOptionsPageCaseSensitive.check(); |
| sortOptionsPageIncludeFormats.check(); |
| sortPage.select(); |
| sortPageBy1.select(1); // "Column A" |
| sortPageAscending1.check(); |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Sorted result1", expectedSortedResult1, SCTool.getCellTexts("A1:A5")); |
| |
| // Uodo/redo |
| app.dispatch(".uno:Undo"); |
| assertArrayEquals("Undo sorted result", data1, SCTool.getCellTexts("A1:A5")); |
| app.dispatch(".uno:Redo"); |
| assertArrayEquals("Redo sorted result", expectedSortedResult1, SCTool.getCellTexts("A1:A5")); |
| |
| // Input data2 into same sheet, data1 and data2 are not overlapped |
| SCTool.selectRange("G10"); |
| typeKeys("Numbers<down>4<down>2<down>5<down>1<down>3"); |
| |
| // Focus on data2, "Data->Sort...", check |
| // "Range contains column labels", uncheck "Case sensitive" and |
| // "Include formats", sort first by "Numbers", "Ascending" |
| SCTool.selectRange("G10"); |
| app.dispatch(".uno:DataSort"); |
| sortOptionsPage.select(); |
| sortOptionsPageRangeContainsColumnLabels.check(); |
| sortOptionsPageCaseSensitive.uncheck(); |
| sortOptionsPageIncludeFormats.uncheck(); |
| sortPage.select(); |
| sortPageBy1.select(1); // "Numbers" |
| sortPageAscending1.check(); |
| sortPage.ok(); |
| |
| // Verify sorted result |
| assertArrayEquals("Sorted result2", expectedSortedResult2, SCTool.getCellTexts("G10:G15")); |
| |
| // Uodo/redo |
| app.dispatch(".uno:Undo"); |
| assertArrayEquals("Undo sorted result", data2, SCTool.getCellTexts("G10:G15")); |
| app.dispatch(".uno:Redo"); |
| assertArrayEquals("Redo sorted result", expectedSortedResult2, SCTool.getCellTexts("G10:G15")); |
| |
| // Open sort dialog, check its setting |
| app.dispatch(".uno:DataSort"); |
| sortOptionsPage.select(); |
| assertTrue("Range contains column labels should be checked", sortOptionsPageRangeContainsColumnLabels.isChecked()); |
| assertFalse("Case sensitive should not be checked", sortOptionsPageCaseSensitive.isChecked()); |
| assertFalse("Include formats should not be checked", sortOptionsPageIncludeFormats.isChecked()); |
| sortOptionsPage.ok(); |
| |
| // Save and close document |
| String saveTo = getPath("temp/" + "SortOptionsMultipleSortParameterSaved.ods"); |
| FileUtil.deleteFile(saveTo); |
| saveAndReopen(saveTo); |
| |
| calc.waitForExistence(10, 2); |
| assertArrayEquals("Saved sorted result1", expectedSortedResult1, SCTool.getCellTexts("A1:A5")); |
| assertArrayEquals("Saved sorted result2", expectedSortedResult2, SCTool.getCellTexts("G10:G15")); |
| app.dispatch(".uno:DataSort"); |
| sortOptionsPage.select(); |
| assertTrue("Range contains column labels should be checked", sortOptionsPageRangeContainsColumnLabels.isChecked()); |
| assertFalse("Case sensitive should not be checked", sortOptionsPageCaseSensitive.isChecked()); |
| assertFalse("Include formats should not be checked", sortOptionsPageIncludeFormats.isChecked()); |
| sortOptionsPage.ok(); |
| } |
| |
| |
| } |