Attachment #245073 for bug #219466




/*******************************************************************************
 * Copyright (c) 2014 Sandra Lions and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Sandra Lions <sandra.lions-piron@oracle.com> - [JUnit] allow to sort by name and by execution time - https://bugs.eclipse.org/bugs/show_bug.cgi?id=219466
 *******************************************************************************/
package org.eclipse.jdt.junit.tests;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.eclipse.jdt.junit.JUnitCore;
import org.eclipse.jdt.junit.TestRunListener;

import org.eclipse.swt.widgets.Table;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.jdt.core.IType;

import org.eclipse.jdt.internal.junit.ui.JUnitPlugin;
import org.eclipse.jdt.internal.junit.ui.TestRunnerViewPart;
import org.eclipse.jdt.internal.junit.ui.TestRunnerViewPart.SortingCriterion;

public class TestSorting extends AbstractTestRunListenerTest {

	private String[] runSequenceTest(IType typeToLaunch) throws Exception {
		TestRunLog log= new TestRunLog();
		final TestRunListener testRunListener= new TestRunListeners.SequenceTest(log);
		JUnitCore.addTestRunListener(testRunListener);
		try {
			return launchJUnit(typeToLaunch, new TestRunLog());
		} finally {
			JUnitCore.removeTestRunListener(testRunListener);
		}
	}

	public void testSorting() throws Exception {

		IWorkbenchPage activePage= JUnitPlugin.getActivePage();
		TestRunnerViewPart testRunnerViewPart= (TestRunnerViewPart)activePage.showView(TestRunnerViewPart.NAME);
		testRunnerViewPart.setLayoutMode(TestRunnerViewPart.LAYOUT_FLAT); // TableViewer

		String source= "package pack;\n"
				+ "import junit.framework.TestCase;\n"
				+ "public class ATestCase extends TestCase {\n"
				+ "	private String fString;\n"
				+ "	public void testB_FirstTest() throws Exception {\n"
				+ "	    fString= \"first\";\n"
				+ "	    Thread.sleep(30);\n"
				+ "	}\n"
				+ "	public void testa_SecondTest() throws Exception {\n"
				+ "	    fString= \"second\";\n"
				+ "	    Thread.sleep(50);\n"
				+ "	}\n"
				+ "	public void testC_ThirdTest() throws Exception {\n"
				+ "	    fString= \"second\";\n"
				+ "	    Thread.sleep(50);\n"
				+ "	}\n"
				+ "	public void testA_FourthTest() throws Exception {\n"
				+ "	    fString= \"third\";\n"
				+ "	    Thread.sleep(40);\n"
				+ "	}\n"
				+ "}";

		IType aTestCase= createType(source, "pack", "ATestCase.java");
		runSequenceTest(aTestCase);

		Table table= ((TableViewer)testRunnerViewPart.getTestViewer().getActiveViewer()).getTable();
		assertEquals(4, table.getItemCount());

		List<String> testResults;

		testRunnerViewPart.setSortingCriterion(SortingCriterion.SORT_BY_NAME);
		testResults= new ArrayList<String>();
		for (int i= 0; i < table.getItems().length; i++) {
			String text= table.getItems()[i].getText();
			testResults.add(i, text.substring(0, text.indexOf("_")));
		}
		assertTrue(Arrays.deepEquals(new String[] { "testA", "testa", "testB", "testC" }, testResults.toArray()));

		testRunnerViewPart.setSortingCriterion(SortingCriterion.SORT_BY_EXECUTION_TIME);
		testResults= new ArrayList<String>();
		for (int i= 0; i < table.getItems().length; i++) {
			String text= table.getItems()[i].getText();
			testResults.add(0, text.substring(text.indexOf("(") + 1, text.length()));
		}
		String previousResult= null;
		for (int i= 0; i < testResults.size(); i++) {
			String testResult= testResults.get(i);
			if (previousResult != null) {
				assertTrue(previousResult.compareTo(testResult) <= 0);
			}
			previousResult= testResult;
		}
	}
}

Lines 9-14 Link Here

(-)a/org.eclipse.jdt.junit/src/org/eclipse/jdt/internal/junit/ui/JUnitMessages.java (+6 lines)
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* David Saff (saff@mit.edu) - bug 102632: [JUnit] Support for JUnit 4.	10	* David Saff (saff@mit.edu) - bug 102632: [JUnit] Support for JUnit 4.
11	* Robert Konigsberg <konigsberg@google.com> - [JUnit] Improve discoverability of the ability to run a single method under JUnit Tests - https://bugs.eclipse.org/bugs/show_bug.cgi?id=285637	11	* Robert Konigsberg <konigsberg@google.com> - [JUnit] Improve discoverability of the ability to run a single method under JUnit Tests - https://bugs.eclipse.org/bugs/show_bug.cgi?id=285637
		12	* Sandra Lions <sandra.lions-piron@oracle.com> - [JUnit] allow to sort by name and by execution time - https://bugs.eclipse.org/bugs/show_bug.cgi?id=219466
12	*******************************************************************************/	13	*******************************************************************************/
13	package org.eclipse.jdt.internal.junit.ui;	14	package org.eclipse.jdt.internal.junit.ui;
14		15
Lines 297-302 public final class JUnitMessages extends NLS { Link Here
297	public static String TestRunnerViewPart_show_failures_only;	298	public static String TestRunnerViewPart_show_failures_only;
298	public static String TestRunnerViewPart_hierarchical_layout;	299	public static String TestRunnerViewPart_hierarchical_layout;
299		300
		301	public static String TestRunnerViewPart_sort_by_menu;
		302	public static String TestRunnerViewPart_toggle_name_label;
		303	public static String TestRunnerViewPart_toggle_execution_order_label;
		304	public static String TestRunnerViewPart_toggle_execution_time_label;
		305
300	public static String TestSessionLabelProvider_testName_elapsedTimeInSeconds;	306	public static String TestSessionLabelProvider_testName_elapsedTimeInSeconds;
301		307
302	public static String TestSessionLabelProvider_testName_JUnitVersion;	308	public static String TestSessionLabelProvider_testName_JUnitVersion;

Lines 8-13 Link Here

(-)a/org.eclipse.jdt.junit/src/org/eclipse/jdt/internal/junit/ui/JUnitMessages.properties (+5 lines)
8	# Contributors:	8	# Contributors:
9	# IBM Corporation - initial API and implementation	9	# IBM Corporation - initial API and implementation
10	# Robert Konigsberg <konigsberg@google.com> - [JUnit] Improve discoverability of the ability to run a single method under JUnit Tests - https://bugs.eclipse.org/bugs/show_bug.cgi?id=285637	10	# Robert Konigsberg <konigsberg@google.com> - [JUnit] Improve discoverability of the ability to run a single method under JUnit Tests - https://bugs.eclipse.org/bugs/show_bug.cgi?id=285637
		11	# Sandra Lions <sandra.lions-piron@oracle.com> - [JUnit] allow to sort by name and by execution time - https://bugs.eclipse.org/bugs/show_bug.cgi?id=219466
11	###############################################################################	12	###############################################################################
12	CopyTrace_action_label=Copy Trace	13	CopyTrace_action_label=Copy Trace
13	CopyTraceAction_problem=Problem Copying to Clipboard	14	CopyTraceAction_problem=Problem Copying to Clipboard
Lines 75-80 TestRunnerViewPart_select_test_run=&Select a test run: Link Here
75	TestRunnerViewPart_stopaction_tooltip=Stop JUnit Test Run	76	TestRunnerViewPart_stopaction_tooltip=Stop JUnit Test Run
76	TestRunnerViewPart_show_execution_time=Show Execution &Time	77	TestRunnerViewPart_show_execution_time=Show Execution &Time
77	TestRunnerViewPart_show_failures_only=Show &Failures Only	78	TestRunnerViewPart_show_failures_only=Show &Failures Only
		79	TestRunnerViewPart_sort_by_menu=&Sort By
		80	TestRunnerViewPart_toggle_name_label=Name
		81	TestRunnerViewPart_toggle_execution_order_label=Execution Order
		82	TestRunnerViewPart_toggle_execution_time_label=Execution Time
78	TestRunnerViewPart_rerunaction_label=Rerun Test	83	TestRunnerViewPart_rerunaction_label=Rerun Test
79	TestRunnerViewPart_rerunaction_tooltip=Rerun Test	84	TestRunnerViewPart_rerunaction_tooltip=Rerun Test
80	TestRunnerViewPart_hierarchical_layout=Show Tests in &Hierarchy	85	TestRunnerViewPart_hierarchical_layout=Show Tests in &Hierarchy




/*******************************************************************************
 * Copyright (c) 2000, 2014 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 *     Andrew Eisenberg <andrew@eisenberg.as> - [JUnit] Rerun failed first does not work with JUnit4 - https://bugs.eclipse.org/bugs/show_bug.cgi?id=140392
 *     Thirumala Reddy Mutchukota <thirumala@google.com> - [JUnit] Avoid rerun test launch on UI thread - https://bugs.eclipse.org/bugs/show_bug.cgi?id=411841
 *     Andrew Eisenberg <andrew@eisenberg.as> - [JUnit] Add a monospace font option for the junit results view - https://bugs.eclipse.org/bugs/show_bug.cgi?id=411794
 *     Sandra Lions <sandra.lions-piron@oracle.com> - [JUnit] allow to sort by name and by execution time - https://bugs.eclipse.org/bugs/show_bug.cgi?id=219466
 *******************************************************************************/
package org.eclipse.jdt.internal.junit.ui;



	static final int REFRESH_INTERVAL= 200;

	public static final int LAYOUT_FLAT= 0;
	public static final int LAYOUT_HIERARCHICAL= 1;

	/**
	 * Whether the output scrolls and reveals tests as they are executed.

	 */
	private boolean fIsDisposed= false;

	public enum SortingCriterion {
		SORT_BY_NAME, SORT_BY_EXECUTION_ORDER, SORT_BY_EXECUTION_TIME
	}
	/**
	 * The current sorting criterion.
	 */
	private SortingCriterion fSortingCriterion= SortingCriterion.SORT_BY_EXECUTION_ORDER;

	/**
	 * Actions
	 */

	private ShowTimeAction fShowTimeAction;
	private ActivateOnErrorAction fActivateOnErrorAction;
	private IMenuListener fViewMenuListener;
	
	private MenuManager fSortByMenu;
	private ToggleSortingAction[] fToggleSortingActions;

	private TestRunSession fTestRunSession;
	private TestSessionListener fTestSessionListener;

	 */
	static final String TAG_SHOW_TIME= "time"; //$NON-NLS-1$

	static final String TAG_SORTING_CRITERION= "SortingCriterion"; //$NON-NLS-1$

	/**
	 * @since 3.5
	 */


			fStopAction.setEnabled(true);
			fRerunLastTestAction.setEnabled(true);
			
			getDisplay().asyncExec(new Runnable() {
				public void run() {
					setSortingCriterion(SortingCriterion.SORT_BY_EXECUTION_ORDER);
				}
			});
		}

		public void sessionEnded(long elapsedTime){

		}
	}

	private class ToggleSortingAction extends Action {
		private final SortingCriterion fActionSortingCriterion;

		public ToggleSortingAction(SortingCriterion sortingCriterion) {
			super("", AS_RADIO_BUTTON); //$NON-NLS-1$
			switch (sortingCriterion) {
				case SORT_BY_NAME:
					setText(JUnitMessages.TestRunnerViewPart_toggle_name_label);
					break;
				case SORT_BY_EXECUTION_ORDER:
					setText(JUnitMessages.TestRunnerViewPart_toggle_execution_order_label);
					break;
				case SORT_BY_EXECUTION_TIME:
					setText(JUnitMessages.TestRunnerViewPart_toggle_execution_time_label);
					break;
				default:
					break;
			}
			fActionSortingCriterion= sortingCriterion;
		}

		@Override
		public void run() {
			if (isChecked()) {
				setSortingCriterion(fActionSortingCriterion);
			}
		}

		public SortingCriterion getActionSortingCriterion() {
			return fActionSortingCriterion;
		}
	}

	public SortingCriterion getSortingCriterion() {
		return fSortingCriterion;
	}

	public void setSortingCriterion(SortingCriterion sortingCriterion) {
		fSortingCriterion= sortingCriterion;
		fTestViewer.setSortingCriterion(sortingCriterion);
		for (int i= 0; i < fToggleSortingActions.length; ++i) {
			fToggleSortingActions[i].setChecked(sortingCriterion == fToggleSortingActions[i].getActionSortingCriterion());
		}
	}

	private void updateSortByMenu() {
		if (fTestRunSession != null) {
			if (fTestRunSession.isStarting() || fTestRunSession.isRunning() || fTestRunSession.isKeptAlive()) {
				setSortingCriterion(SortingCriterion.SORT_BY_EXECUTION_ORDER);
				fSortByMenu.getMenu().setEnabled(false);
			} else {
				fSortByMenu.getMenu().setEnabled(true);
			}
		} else {
			setSortingCriterion(SortingCriterion.SORT_BY_EXECUTION_ORDER);
			fSortByMenu.getMenu().setEnabled(false);
		}
	}

	/**
	 * Listen for for modifications to Java elements
	 */

		memento.putString(TAG_FAILURES_ONLY, fFailuresOnlyFilterAction.isChecked() ? "true" : "false"); //$NON-NLS-1$ //$NON-NLS-2$
		memento.putInteger(TAG_LAYOUT, fLayout);
		memento.putString(TAG_SHOW_TIME, fShowTimeAction.isChecked() ? "true" : "false"); //$NON-NLS-1$ //$NON-NLS-2$
		memento.putString(TAG_SORTING_CRITERION, fSortingCriterion.name());
	}

	private void restoreLayoutState(IMemento memento) {

		boolean showTime= true;
		if (time != null)
			showTime= time.equals("true"); //$NON-NLS-1$
		
		SortingCriterion sortingCriterion= SortingCriterion.SORT_BY_EXECUTION_ORDER;
		String tagSortingCriterion= memento.getString(TAG_SORTING_CRITERION);
		if (tagSortingCriterion != null) {
			sortingCriterion= Enum.valueOf(SortingCriterion.class, tagSortingCriterion);
		}
		setSortingCriterion(sortingCriterion);

		setFilterAndLayout(showFailuresOnly, layoutValue);
		setShowExecutionTime(showTime);

				fStopAction.setEnabled(fTestRunSession.isKeptAlive());
				fTestViewer.expandFirstLevel();
			}
			
			updateSortByMenu();
		}
		return deactivatedSession;
	}

		viewMenu.add(fShowTestHierarchyAction);
		viewMenu.add(fShowTimeAction);
		viewMenu.add(new Separator());
		fToggleSortingActions=
				new ToggleSortingAction[] {
						new ToggleSortingAction(SortingCriterion.SORT_BY_EXECUTION_ORDER),
						new ToggleSortingAction(SortingCriterion.SORT_BY_EXECUTION_TIME),
						new ToggleSortingAction(SortingCriterion.SORT_BY_NAME)};
		fSortByMenu= new MenuManager(JUnitMessages.TestRunnerViewPart_sort_by_menu);
		for (int i= 0; i < fToggleSortingActions.length; ++i) {
			fSortByMenu.add(fToggleSortingActions[i]);
		}
		viewMenu.add(fSortByMenu);
		viewMenu.add(new Separator());

		MenuManager layoutSubMenu= new MenuManager(JUnitMessages.TestRunnerViewPart_layout_menu);
		for (int i = 0; i < fToggleOrientationActions.length; ++i) {

		fViewMenuListener= new IMenuListener() {
			public void menuAboutToShow(IMenuManager manager) {
				fActivateOnErrorAction.update();
				updateSortByMenu();
			}
		};


		return fFailureTrace;
	}

	public TestViewer getTestViewer() {
		return fTestViewer;
	}

	void setShowFailuresOnly(boolean failuresOnly) {
		setFilterAndLayout(failuresOnly, fLayout);
	}

	public void setLayoutMode(int mode) {
		setFilterAndLayout(fFailuresOnlyFilterAction.isChecked(), mode);
	}





 *     Brock Janiczak (brockj@tpg.com.au)
 *         - https://bugs.eclipse.org/bugs/show_bug.cgi?id=102236: [JUnit] display execution time next to each test
 *     Xavier Coulon <xcoulon@redhat.com> - https://bugs.eclipse.org/bugs/show_bug.cgi?id=102512 - [JUnit] test method name cut off before (
 *     Sandra Lions <sandra.lions-piron@oracle.com> - [JUnit] allow to sort by name and by execution time - https://bugs.eclipse.org/bugs/show_bug.cgi?id=219466
 *******************************************************************************/

package org.eclipse.jdt.internal.junit.ui;

import java.util.AbstractList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;

import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.jface.viewers.ViewerFilter;

import org.eclipse.ui.IWorkbenchActionConstants;

import org.eclipse.jdt.internal.junit.model.TestRoot;
import org.eclipse.jdt.internal.junit.model.TestRunSession;
import org.eclipse.jdt.internal.junit.model.TestSuiteElement;
import org.eclipse.jdt.internal.junit.ui.TestRunnerViewPart.SortingCriterion;

import org.eclipse.jdt.internal.ui.viewsupport.ColoringLabelProvider;
import org.eclipse.jdt.internal.ui.viewsupport.SelectionProviderMediator;

		}
	}

	public synchronized void setSortingCriterion(SortingCriterion sortingCriterion) {
		ViewerComparator viewComparator;
		switch (sortingCriterion) {
			case SORT_BY_EXECUTION_ORDER:
				viewComparator= null;
				break;
			case SORT_BY_EXECUTION_TIME:
				viewComparator= new TestExecutionTimeComparator();
				break;
			case SORT_BY_NAME:
				viewComparator= new TestNameComparator();
				break;
			default:
				viewComparator= null;
				break;
		}
		fTableViewer.setComparator(viewComparator);
		fTreeViewer.setComparator(viewComparator);
	}

	private final class TestNameComparator extends ViewerComparator {
		@Override
		public int compare(Viewer viewer, Object o1, Object o2) {
			return compareName(o1, o2);
		}
	}

	private final class TestExecutionTimeComparator extends ViewerComparator {
		@Override
		public int compare(Viewer viewer, Object o1, Object o2) {
			return compareElapsedTime(o1, o2);
		}
	}

	private Comparator<ITestElement> getComparator() {
		SortingCriterion sortingCriterion= fTestRunnerPart.getSortingCriterion();
		Comparator<ITestElement> comparator;
		switch (sortingCriterion) {
			case SORT_BY_EXECUTION_ORDER:
				comparator= null;
				break;
			case SORT_BY_EXECUTION_TIME:
				comparator= new Comparator<ITestElement>() {
					public int compare(ITestElement o1, ITestElement o2) {
						return compareElapsedTime(o1, o2);
					}
				};
				break;
			case SORT_BY_NAME:
				comparator= new Comparator<ITestElement>() {
					public int compare(ITestElement o1, ITestElement o2) {
						return compareName(o1, o2);
					}
				};
				break;
			default:
				comparator= null;
				break;
		}
		return comparator;
	}

	private int compareElapsedTime(Object o1, Object o2) {
		double elapsedTime1= ((TestElement)o1).getElapsedTimeInSeconds();
		double elapsedTime2= ((TestElement)o2).getElapsedTimeInSeconds();
		return Double.compare(elapsedTime2, elapsedTime1);
	}

	private int compareName(Object o1, Object o2) {
		String testName1= ((TestElement)o1).getTestName();
		String testName2= ((TestElement)o2).getTestName();
		return testName1.toLowerCase().compareTo(testName2.toLowerCase());
	}

	public synchronized void setShowFailuresOnly(boolean failuresOnly, int layoutMode) {
		/*
		 * Management of fTreeViewer and fTableViewer

			fTableHasFilter= filter;
	}

	public StructuredViewer getActiveViewer() {
		if (fLayoutMode == TestRunnerViewPart.LAYOUT_HIERARCHICAL)
			return fTreeViewer;
		else

		if (parent == null)
			return null;

		ITestElement[] elements= parent.getChildren();
		Comparator<ITestElement> comparator= getComparator();
		if (comparator != null) {
			Arrays.sort(elements, comparator);
		}
		List<ITestElement> siblings= Arrays.asList(elements);
		if (! showNext)
			siblings= new ReverseList<ITestElement>(siblings);


	}

	private TestCaseElement getNextChildFailure(TestSuiteElement root, boolean showNext) {
		ITestElement[] elements= root.getChildren();
		Comparator<ITestElement> comparator= getComparator();
		if (comparator != null) {
			Arrays.sort(elements, comparator);
		}
		List<ITestElement> children= Arrays.asList(elements);
		if (! showNext)
			children= new ReverseList<ITestElement>(children);
		for (int i= 0; i < children.size(); i++) {

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/junit/tests/JUnitJUnitTests.java (-1 / +5 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2005, 2010 IBM Corporation and others.	2	* Copyright (c) 2005, 2014 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 7-12 Link Here
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Sandra Lions <sandra.lions-piron@oracle.com> - [JUnit] allow to sort by name and by execution time - https://bugs.eclipse.org/bugs/show_bug.cgi?id=219466
10	*******************************************************************************/	11	*******************************************************************************/
11		12
12	package org.eclipse.jdt.junit.tests;	13	package org.eclipse.jdt.junit.tests;
Lines 37-42 public class JUnitJUnitTests { Link Here
37		38
38	suite.addTestSuite(JUnit3TestFinderTest.class);	39	suite.addTestSuite(JUnit3TestFinderTest.class);
39	suite.addTestSuite(JUnit4TestFinderTest.class);	40	suite.addTestSuite(JUnit4TestFinderTest.class);
		41
		42	suite.addTestSuite(TestSorting.class);
		43
40	//$JUnit-END$	44	//$JUnit-END$
41	return suite;	45	return suite;
42	}	46	}

Lines 36-42 public class TestSorting extends AbstractTestRunListenerTest { Link Here

(-)a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/junit/tests/TestSorting.java (-1 / +1 lines)
36	final TestRunListener testRunListener= new TestRunListeners.SequenceTest(log);	36	final TestRunListener testRunListener= new TestRunListeners.SequenceTest(log);
37	JUnitCore.addTestRunListener(testRunListener);	37	JUnitCore.addTestRunListener(testRunListener);
38	try {	38	try {
39	return launchJUnit(typeToLaunch, new TestRunLog());	39	return launchJUnit(typeToLaunch, log);
40	} finally {	40	} finally {
41	JUnitCore.removeTestRunListener(testRunListener);	41	JUnitCore.removeTestRunListener(testRunListener);
42	}	42	}

Return to bug 219466

Added Link Here

(-)a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/junit/tests/TestSorting.java (+104 lines)
1	/*******************************************************************************
2	* Copyright (c) 2014 Sandra Lions and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Sandra Lions <sandra.lions-piron@oracle.com> - [JUnit] allow to sort by name and by execution time - https://bugs.eclipse.org/bugs/show_bug.cgi?id=219466
10	*******************************************************************************/
11	package org.eclipse.jdt.junit.tests;
12
13	import java.util.ArrayList;
14	import java.util.Arrays;
15	import java.util.List;
16
17	import org.eclipse.jdt.junit.JUnitCore;
18	import org.eclipse.jdt.junit.TestRunListener;
19
20	import org.eclipse.swt.widgets.Table;
21
22	import org.eclipse.jface.viewers.TableViewer;
23
24	import org.eclipse.ui.IWorkbenchPage;
25
26	import org.eclipse.jdt.core.IType;
27
28	import org.eclipse.jdt.internal.junit.ui.JUnitPlugin;
29	import org.eclipse.jdt.internal.junit.ui.TestRunnerViewPart;
30	import org.eclipse.jdt.internal.junit.ui.TestRunnerViewPart.SortingCriterion;
31
32	public class TestSorting extends AbstractTestRunListenerTest {
33
34	private String[] runSequenceTest(IType typeToLaunch) throws Exception {
35	TestRunLog log= new TestRunLog();
36	final TestRunListener testRunListener= new TestRunListeners.SequenceTest(log);
37	JUnitCore.addTestRunListener(testRunListener);
38	try {
39	return launchJUnit(typeToLaunch, new TestRunLog());
40	} finally {
41	JUnitCore.removeTestRunListener(testRunListener);
42	}
43	}
44
45	public void testSorting() throws Exception {
46
47	IWorkbenchPage activePage= JUnitPlugin.getActivePage();
48	TestRunnerViewPart testRunnerViewPart= (TestRunnerViewPart)activePage.showView(TestRunnerViewPart.NAME);
49	testRunnerViewPart.setLayoutMode(TestRunnerViewPart.LAYOUT_FLAT); // TableViewer
50
51	String source= "package pack;\n"
52	+ "import junit.framework.TestCase;\n"
53	+ "public class ATestCase extends TestCase {\n"
54	+ " private String fString;\n"
55	+ " public void testB_FirstTest() throws Exception {\n"
56	+ " fString= \"first\";\n"
57	+ " Thread.sleep(30);\n"
58	+ " }\n"
59	+ " public void testa_SecondTest() throws Exception {\n"
60	+ " fString= \"second\";\n"
61	+ " Thread.sleep(50);\n"
62	+ " }\n"
63	+ " public void testC_ThirdTest() throws Exception {\n"
64	+ " fString= \"second\";\n"
65	+ " Thread.sleep(50);\n"
66	+ " }\n"
67	+ " public void testA_FourthTest() throws Exception {\n"
68	+ " fString= \"third\";\n"
69	+ " Thread.sleep(40);\n"
70	+ " }\n"
71	+ "}";
72
73	IType aTestCase= createType(source, "pack", "ATestCase.java");
74	runSequenceTest(aTestCase);
75
76	Table table= ((TableViewer)testRunnerViewPart.getTestViewer().getActiveViewer()).getTable();
77	assertEquals(4, table.getItemCount());
78
79	List<String> testResults;
80
81	testRunnerViewPart.setSortingCriterion(SortingCriterion.SORT_BY_NAME);
82	testResults= new ArrayList<String>();
83	for (int i= 0; i < table.getItems().length; i++) {
84	String text= table.getItems()[i].getText();
85	testResults.add(i, text.substring(0, text.indexOf("_")));
86	}
87	assertTrue(Arrays.deepEquals(new String[] { "testA", "testa", "testB", "testC" }, testResults.toArray()));
88
89	testRunnerViewPart.setSortingCriterion(SortingCriterion.SORT_BY_EXECUTION_TIME);
90	testResults= new ArrayList<String>();
91	for (int i= 0; i < table.getItems().length; i++) {
92	String text= table.getItems()[i].getText();
93	testResults.add(0, text.substring(text.indexOf("(") + 1, text.length()));
94	}
95	String previousResult= null;
96	for (int i= 0; i < testResults.size(); i++) {
97	String testResult= testResults.get(i);
98	if (previousResult != null) {
99	assertTrue(previousResult.compareTo(testResult) <= 0);
100	}
101	previousResult= testResult;
102	}
103	}
104	}

Lines 10-22 Link Here

(-)a/org.eclipse.jdt.junit/src/org/eclipse/jdt/internal/junit/ui/TestViewer.java (-4 / +91 lines)
10	* Brock Janiczak (brockj@tpg.com.au)	10	* Brock Janiczak (brockj@tpg.com.au)
11	* - https://bugs.eclipse.org/bugs/show_bug.cgi?id=102236: [JUnit] display execution time next to each test	11	* - https://bugs.eclipse.org/bugs/show_bug.cgi?id=102236: [JUnit] display execution time next to each test
12	* Xavier Coulon <xcoulon@redhat.com> - https://bugs.eclipse.org/bugs/show_bug.cgi?id=102512 - [JUnit] test method name cut off before (	12	* Xavier Coulon <xcoulon@redhat.com> - https://bugs.eclipse.org/bugs/show_bug.cgi?id=102512 - [JUnit] test method name cut off before (
13		13	* Sandra Lions <sandra.lions-piron@oracle.com> - [JUnit] allow to sort by name and by execution time - https://bugs.eclipse.org/bugs/show_bug.cgi?id=219466
14	*******************************************************************************/	14	*******************************************************************************/
15		15
16	package org.eclipse.jdt.internal.junit.ui;	16	package org.eclipse.jdt.internal.junit.ui;
17		17
18	import java.util.AbstractList;	18	import java.util.AbstractList;
19	import java.util.Arrays;	19	import java.util.Arrays;
		20	import java.util.Comparator;
20	import java.util.HashSet;	21	import java.util.HashSet;
21	import java.util.LinkedHashSet;	22	import java.util.LinkedHashSet;
22	import java.util.LinkedList;	23	import java.util.LinkedList;
Lines 48-53 import org.eclipse.jface.viewers.StructuredViewer; Link Here
48	import org.eclipse.jface.viewers.TableViewer;	49	import org.eclipse.jface.viewers.TableViewer;
49	import org.eclipse.jface.viewers.TreeViewer;	50	import org.eclipse.jface.viewers.TreeViewer;
50	import org.eclipse.jface.viewers.Viewer;	51	import org.eclipse.jface.viewers.Viewer;
		52	import org.eclipse.jface.viewers.ViewerComparator;
51	import org.eclipse.jface.viewers.ViewerFilter;	53	import org.eclipse.jface.viewers.ViewerFilter;
52		54
53	import org.eclipse.ui.IWorkbenchActionConstants;	55	import org.eclipse.ui.IWorkbenchActionConstants;
Lines 65-70 import org.eclipse.jdt.internal.junit.model.TestElement.Status; Link Here
65	import org.eclipse.jdt.internal.junit.model.TestRoot;	67	import org.eclipse.jdt.internal.junit.model.TestRoot;
66	import org.eclipse.jdt.internal.junit.model.TestRunSession;	68	import org.eclipse.jdt.internal.junit.model.TestRunSession;
67	import org.eclipse.jdt.internal.junit.model.TestSuiteElement;	69	import org.eclipse.jdt.internal.junit.model.TestSuiteElement;
		70	import org.eclipse.jdt.internal.junit.ui.TestRunnerViewPart.SortingCriterion;
68		71
69	import org.eclipse.jdt.internal.ui.viewsupport.ColoringLabelProvider;	72	import org.eclipse.jdt.internal.ui.viewsupport.ColoringLabelProvider;
70	import org.eclipse.jdt.internal.ui.viewsupport.SelectionProviderMediator;	73	import org.eclipse.jdt.internal.ui.viewsupport.SelectionProviderMediator;
Lines 324-329 public class TestViewer { Link Here
324	}	327	}
325	}	328	}
326		329
		330	public synchronized void setSortingCriterion(SortingCriterion sortingCriterion) {
		331	ViewerComparator viewComparator;
		332	switch (sortingCriterion) {
		333	case SORT_BY_EXECUTION_ORDER:
		334	viewComparator= null;
		335	break;
		336	case SORT_BY_EXECUTION_TIME:
		337	viewComparator= new TestExecutionTimeComparator();
		338	break;
		339	case SORT_BY_NAME:
		340	viewComparator= new TestNameComparator();
		341	break;
		342	default:
		343	viewComparator= null;
		344	break;
		345	}
		346	fTableViewer.setComparator(viewComparator);
		347	fTreeViewer.setComparator(viewComparator);
		348	}
		349
		350	private final class TestNameComparator extends ViewerComparator {
		351	@Override
		352	public int compare(Viewer viewer, Object o1, Object o2) {
		353	return compareName(o1, o2);
		354	}
		355	}
		356
		357	private final class TestExecutionTimeComparator extends ViewerComparator {
		358	@Override
		359	public int compare(Viewer viewer, Object o1, Object o2) {
		360	return compareElapsedTime(o1, o2);
		361	}
		362	}
		363
		364	private Comparator<ITestElement> getComparator() {
		365	SortingCriterion sortingCriterion= fTestRunnerPart.getSortingCriterion();
		366	Comparator<ITestElement> comparator;
		367	switch (sortingCriterion) {
		368	case SORT_BY_EXECUTION_ORDER:
		369	comparator= null;
		370	break;
		371	case SORT_BY_EXECUTION_TIME:
		372	comparator= new Comparator<ITestElement>() {
		373	public int compare(ITestElement o1, ITestElement o2) {
		374	return compareElapsedTime(o1, o2);
		375	}
		376	};
		377	break;
		378	case SORT_BY_NAME:
		379	comparator= new Comparator<ITestElement>() {
		380	public int compare(ITestElement o1, ITestElement o2) {
		381	return compareName(o1, o2);
		382	}
		383	};
		384	break;
		385	default:
		386	comparator= null;
		387	break;
		388	}
		389	return comparator;
		390	}
		391
		392	private int compareElapsedTime(Object o1, Object o2) {
		393	double elapsedTime1= ((TestElement)o1).getElapsedTimeInSeconds();
394	double elapsedTime2= ((TestElement)o2).getElapsedTimeInSeconds();
395	return Double.compare(elapsedTime2, elapsedTime1);
396	}
397
398	private int compareName(Object o1, Object o2) {
399	String testName1= ((TestElement)o1).getTestName();
400	String testName2= ((TestElement)o2).getTestName();
401	return testName1.toLowerCase().compareTo(testName2.toLowerCase());
402	}
403
327	public synchronized void setShowFailuresOnly(boolean failuresOnly, int layoutMode) {	404	public synchronized void setShowFailuresOnly(boolean failuresOnly, int layoutMode) {
328	/*	405	/*
329	* Management of fTreeViewer and fTableViewer	406	* Management of fTreeViewer and fTableViewer
Lines 399-405 public class TestViewer { Link Here
399	fTableHasFilter= filter;	476	fTableHasFilter= filter;
400	}	477	}
401		478
402	private StructuredViewer getActiveViewer() {	479	public StructuredViewer getActiveViewer() {
403	if (fLayoutMode == TestRunnerViewPart.LAYOUT_HIERARCHICAL)	480	if (fLayoutMode == TestRunnerViewPart.LAYOUT_HIERARCHICAL)
404	return fTreeViewer;	481	return fTreeViewer;
405	else	482	else
Lines 613-619 public class TestViewer { Link Here
613	if (parent == null)	690	if (parent == null)
614	return null;	691	return null;
615		692
616	List<ITestElement> siblings= Arrays.asList(parent.getChildren());	693	ITestElement[] elements= parent.getChildren();
		694	Comparator<ITestElement> comparator= getComparator();
		695	if (comparator != null) {
		696	Arrays.sort(elements, comparator);
		697	}
		698	List<ITestElement> siblings= Arrays.asList(elements);
617	if (! showNext)	699	if (! showNext)
618	siblings= new ReverseList<ITestElement>(siblings);	700	siblings= new ReverseList<ITestElement>(siblings);
619		701
Lines 632-638 public class TestViewer { Link Here
632	}	714	}
633		715
634	private TestCaseElement getNextChildFailure(TestSuiteElement root, boolean showNext) {	716	private TestCaseElement getNextChildFailure(TestSuiteElement root, boolean showNext) {
635	List<ITestElement> children= Arrays.asList(root.getChildren());	717	ITestElement[] elements= root.getChildren();
		718	Comparator<ITestElement> comparator= getComparator();
		719	if (comparator != null) {
		720	Arrays.sort(elements, comparator);
		721	}
		722	List<ITestElement> children= Arrays.asList(elements);
636	if (! showNext)	723	if (! showNext)
637	children= new ReverseList<ITestElement>(children);	724	children= new ReverseList<ITestElement>(children);
638	for (int i= 0; i < children.size(); i++) {	725	for (int i= 0; i < children.size(); i++) {