From 8f415ec09ed067ae9cc5ea3a7e11d47e7892cefc Mon Sep 17 00:00:00 2001 From: Roman Chernyatchik Date: Thu, 7 Aug 2008 18:55:32 +0400 Subject: [PATCH] Ruby Test Runner: tests errors should differ from assertion faults --- .../runner/GeneralTestEventsProcessor.java | 3 +- .../runner/GeneralToRTestUnitEventsConvertor.java | 5 +- .../testunit/runner/RTestUnitTestProxy.java | 76 ++++++---- .../server/OutputToGeneralTestEventsConverter.java | 11 +- .../testunit/runner/states/NotRunState.java | 4 + .../testunit/runner/states/SuiteFinishedState.java | 52 ++++++- .../runner/states/SuiteInProgressState.java | 4 + .../testunit/runner/states/TerminatedState.java | 4 + .../testunit/runner/states/TestErrorState.java | 20 +++ .../testunit/runner/states/TestFailedState.java | 4 + .../runner/states/TestInProgressState.java | 4 + .../testunit/runner/states/TestPassedState.java | 4 + .../testunit/runner/states/TestStateInfo.java | 29 ++++ .../testunit/runner/ui/TestsPresentationUtil.java | 57 ++++---- .../GeneralToRTestUnitEventsConvertorTest.java | 36 ++++- .../runner/RTestUnitConsoleOutputTest.java | 29 +++- .../testunit/runner/RTestUnitTestProxyTest.java | 162 ++++++++++++++++----- .../runner/ui/RTestUnitUIActionsHandlerTest.java | 94 ++++++++++-- .../runner/ui/TestsPresentationUtilTest.java | 46 +++++- 19 files changed, 513 insertions(+), 131 deletions(-) create mode 100644 plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestErrorState.java diff --git a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/GeneralTestEventsProcessor.java b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/GeneralTestEventsProcessor.java index 1c5e3f93d9..cda66e1484 100644 --- a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/GeneralTestEventsProcessor.java +++ b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/GeneralTestEventsProcessor.java @@ -13,7 +13,8 @@ public interface GeneralTestEventsProcessor extends Disposable { void onTestStarted(final String testName); void onTestFinished(final String testName); - void onTestFailure(final String testName, final String localizedMessage, final String stackTrace); + void onTestFailure(final String testName, final String localizedMessage, final String stackTrace, + final boolean testError); void onTestOutput(final String testName, final String text, final boolean stdOut); void onSuiteStarted(final String suiteName); diff --git a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/GeneralToRTestUnitEventsConvertor.java b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/GeneralToRTestUnitEventsConvertor.java index 311a776bea..73184067fe 100644 --- a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/GeneralToRTestUnitEventsConvertor.java +++ b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/GeneralToRTestUnitEventsConvertor.java @@ -180,7 +180,8 @@ public class GeneralToRTestUnitEventsConvertor implements GeneralTestEventsProce } public void onTestFailure(final String testName, - final String localizedMessage, final String stackTrace) { + final String localizedMessage, final String stackTrace, + final boolean isTestError) { addToInvokeLater(new Runnable() { public void run() { final String fullTestName = getFullTestName(testName); @@ -196,7 +197,7 @@ public class GeneralToRTestUnitEventsConvertor implements GeneralTestEventsProce return; } - testProxy.setTestFailed(localizedMessage, stackTrace); + testProxy.setTestFailed(localizedMessage, stackTrace, isTestError); myFailedTestsSet.add(testProxy); diff --git a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/RTestUnitTestProxy.java b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/RTestUnitTestProxy.java index a776249887..e313952217 100644 --- a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/RTestUnitTestProxy.java +++ b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/RTestUnitTestProxy.java @@ -19,16 +19,6 @@ import java.util.List; * @author: Roman Chernyatchik */ public class RTestUnitTestProxy extends CompositePrintable implements PrintableTestProxy { - public static final int SKIPPED_INDEX = 0; - public static final int COMPLETE_INDEX = 1; - public static final int NOT_RUN_INDEX = 2; - public static final int RUNNING_INDEX = 3; - public static final int TERMINATED_INDEX = 4; - public static final int IGNORED_INDEX = 5; - public static final int FAILED_INDEX = 6; - public static final int ERROR_INDEX = 8; - public static final int PASSED_INDEX = COMPLETE_INDEX; - private List myChildren; private RTestUnitTestProxy myParent; @@ -59,27 +49,16 @@ public class RTestUnitTestProxy extends CompositePrintable implements PrintableT return true; } - @Deprecated public int getMagnitude() { // Is used by some of Tests Filters //WARN: It is Hack, see PoolOfTestStates, API is necessary - //TODO ignored, error - final AbstractState state = myState; - - if (!state.isFinal()) { - if (!state.wasLaunched()) { - return NOT_RUN_INDEX; - } - return RUNNING_INDEX; - - } if (state.wasTerminated()) { - return TERMINATED_INDEX; + //TODO ignored + return getMagnitudeInfo().getValue(); + } - } else if (state.isDefect()) { - return FAILED_INDEX; - } - return PASSED_INDEX; + public TestStateInfo.Magnitude getMagnitudeInfo() { + return myState.getMagnitude(); } public boolean isLeaf() { @@ -160,17 +139,17 @@ public class RTestUnitTestProxy extends CompositePrintable implements PrintableT myState = TestPassedState.INSTACE; } else { //Test Suite - myState = isLeaf() - ? SuiteFinishedState.EMPTY_SUITE - : myState.isDefect() ? SuiteFinishedState.FAILED_SUITE : SuiteFinishedState.PASSED_SUITE; + myState = determineSuiteStateOnFinished(); } // prints final state additional info fireOnNewPrintable(myState); } public void setTestFailed(@NotNull final String localizedMessage, - @NotNull final String stackTrace) { - myState = new TestFailedState(localizedMessage, stackTrace); + @NotNull final String stackTrace, final boolean testError) { + myState = testError + ? new TestErrorState(localizedMessage, stackTrace) + : new TestFailedState(localizedMessage, stackTrace); fireOnNewPrintable(myState); } @@ -297,4 +276,39 @@ public class RTestUnitTestProxy extends CompositePrintable implements PrintableT public boolean wasTerminated() { return myState.wasTerminated(); } + + /** + * Check if suite contains error tests or suites + * @return True if contains + */ + private boolean containsErrorTests() { + final List children = getChildren(); + for (RTestUnitTestProxy child : children) { + if (child.getMagnitudeInfo() == TestStateInfo.Magnitude.ERROR_INDEX) { + return true; + } + } + return false; + } + + /** + * Determines site state after it has been finished + * @return New state + */ + private AbstractState determineSuiteStateOnFinished() { + final AbstractState state; + if (isLeaf()) { + state = SuiteFinishedState.EMPTY_SUITE; + } else { + if (isDefect()) { + // Test suit contains errors if at least one of its tests contains error + state = !containsErrorTests() + ? SuiteFinishedState.FAILED_SUITE + : SuiteFinishedState.ERROR_SUITE; + } else { + state = SuiteFinishedState.PASSED_SUITE; + } + } + return state; + } } diff --git a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/server/OutputToGeneralTestEventsConverter.java b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/server/OutputToGeneralTestEventsConverter.java index 95e932d132..d1e27a1675 100644 --- a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/server/OutputToGeneralTestEventsConverter.java +++ b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/server/OutputToGeneralTestEventsConverter.java @@ -109,11 +109,11 @@ public class OutputToGeneralTestEventsConverter implements ProcessOutputConsumer } } - private void fireOnTestFailure(final String testName, final String localizedMessage, - final String stackTrace) { + private void fireOnTestFailure(final String testName, final String localizedMessage, final String stackTrace, + final boolean isTestError) { for (GeneralTestEventsProcessor processor : myProcessors) { - processor.onTestFailure(testName, localizedMessage, stackTrace); + processor.onTestFailure(testName, localizedMessage, stackTrace, isTestError); } } @@ -155,6 +155,7 @@ public class OutputToGeneralTestEventsConverter implements ProcessOutputConsumer private class MyServiceMessageVisitor extends DefaultServiceMessageVisitor { @NonNls public static final String KEY_TESTS_COUNT = "testCount"; + @NonNls private static final String ATTR_KEY_TEST_ERROR = "error"; public void visitTestSuiteStarted(@NotNull final TestSuiteStarted suiteStarted) { fireOnSuiteStarted(suiteStarted.getSuiteName()); @@ -185,7 +186,9 @@ public class OutputToGeneralTestEventsConverter implements ProcessOutputConsumer } public void visitTestFailed(@NotNull final TestFailed testFailed) { - fireOnTestFailure(testFailed.getTestName(), testFailed.getFailureMessage(), testFailed.getStacktrace()); + final boolean isTestError = testFailed.getAttributes().get(ATTR_KEY_TEST_ERROR) != null; + + fireOnTestFailure(testFailed.getTestName(), testFailed.getFailureMessage(), testFailed.getStacktrace(), isTestError); } public void visitPublishArtifacts(@NotNull final PublishArtifacts publishArtifacts) { diff --git a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/NotRunState.java b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/NotRunState.java index 4f6b69698a..66e50206a2 100644 --- a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/NotRunState.java +++ b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/NotRunState.java @@ -39,6 +39,10 @@ public class NotRunState extends AbstractState { return false; } + public Magnitude getMagnitude() { + return Magnitude.NOT_RUN_INDEX; + } + @Override public String toString() { //noinspection HardCodedStringLiteral diff --git a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/SuiteFinishedState.java b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/SuiteFinishedState.java index 6736820c75..3e6429121f 100644 --- a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/SuiteFinishedState.java +++ b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/SuiteFinishedState.java @@ -8,16 +8,53 @@ import org.jetbrains.plugins.ruby.RBundle; /** * @author Roman Chernyatchik */ -public class SuiteFinishedState extends AbstractState { +public abstract class SuiteFinishedState extends AbstractState { //This states are common for all instances and doesn't contains //instance-specific information - public static SuiteFinishedState PASSED_SUITE = new SuiteFinishedState(); + public static SuiteFinishedState PASSED_SUITE = new SuiteFinishedState() { + public Magnitude getMagnitude() { + return Magnitude.PASSED_INDEX; + } + + @Override + public String toString() { + //noinspection HardCodedStringLiteral + return "SUITE PASSED"; + } + }; public static SuiteFinishedState FAILED_SUITE = new SuiteFinishedState() { @Override public boolean isDefect() { return true; } + + public Magnitude getMagnitude() { + return Magnitude.FAILED_INDEX; + } + + @Override + public String toString() { + //noinspection HardCodedStringLiteral + return "FAILED SUITE"; + } + }; + + public static SuiteFinishedState ERROR_SUITE = new SuiteFinishedState() { + @Override + public boolean isDefect() { + return true; + } + + public Magnitude getMagnitude() { + return Magnitude.ERROR_INDEX; + } + + @Override + public String toString() { + //noinspection HardCodedStringLiteral + return "ERROR SUITE"; + } }; /** @@ -38,6 +75,11 @@ public class SuiteFinishedState extends AbstractState { printer.print(msg, ConsoleViewContentType.SYSTEM_OUTPUT); } + + public Magnitude getMagnitude() { + return Magnitude.ERROR_INDEX; + } + @Override public String toString() { //noinspection HardCodedStringLiteral @@ -67,10 +109,4 @@ public class SuiteFinishedState extends AbstractState { public boolean wasTerminated() { return false; } - - @Override - public String toString() { - //noinspection HardCodedStringLiteral - return "SUITE FINISHED"; - } } diff --git a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/SuiteInProgressState.java b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/SuiteInProgressState.java index 55c9bb5125..3916cc8512 100644 --- a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/SuiteInProgressState.java +++ b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/SuiteInProgressState.java @@ -43,6 +43,10 @@ public class SuiteInProgressState extends TestInProgressState { return false; } + public Magnitude getMagnitude() { + return Magnitude.RUNNING_INDEX; + } + @Override public String toString() { //noinspection HardCodedStringLiteral diff --git a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TerminatedState.java b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TerminatedState.java index 2cc1c0fdcc..cd0e6477a1 100644 --- a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TerminatedState.java +++ b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TerminatedState.java @@ -29,6 +29,10 @@ public class TerminatedState extends AbstractState { return true; } + public Magnitude getMagnitude() { + return Magnitude.TERMINATED_INDEX; + } + @Override public String toString() { //noinspection HardCodedStringLiteral diff --git a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestErrorState.java b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestErrorState.java new file mode 100644 index 0000000000..897302c59e --- /dev/null +++ b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestErrorState.java @@ -0,0 +1,20 @@ +package org.jetbrains.plugins.ruby.testing.testunit.runner.states; + +/** + * @author Roman Chernyatchik + */ +public class TestErrorState extends TestFailedState { + public TestErrorState(final String localizedMessage, final String stackTrace) { + super(localizedMessage, stackTrace); + } + + public Magnitude getMagnitude() { + return Magnitude.ERROR_INDEX; + } + + @Override + public String toString() { + //noinspection HardCodedStringLiteral + return "TEST ERROR"; + } +} diff --git a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestFailedState.java b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestFailedState.java index 5f824360b6..1dd17bedf4 100644 --- a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestFailedState.java +++ b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestFailedState.java @@ -41,6 +41,10 @@ public class TestFailedState extends AbstractState { return false; } + public Magnitude getMagnitude() { + return Magnitude.FAILED_INDEX; + } + @Override public String toString() { //noinspection HardCodedStringLiteral diff --git a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestInProgressState.java b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestInProgressState.java index 9b80e8b4f4..536aafc590 100644 --- a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestInProgressState.java +++ b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestInProgressState.java @@ -33,6 +33,10 @@ public class TestInProgressState extends AbstractState { return false; } + public Magnitude getMagnitude() { + return Magnitude.RUNNING_INDEX; + } + @Override public String toString() { //noinspection HardCodedStringLiteral diff --git a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestPassedState.java b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestPassedState.java index 60f48a71ca..5d3ea245f1 100644 --- a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestPassedState.java +++ b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestPassedState.java @@ -31,6 +31,10 @@ public class TestPassedState extends AbstractState { return false; } + public Magnitude getMagnitude() { + return Magnitude.PASSED_INDEX; + } + @Override public String toString() { //noinspection HardCodedStringLiteral diff --git a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestStateInfo.java b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestStateInfo.java index 7af6388ec6..80267967fa 100644 --- a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestStateInfo.java +++ b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/states/TestStateInfo.java @@ -35,4 +35,33 @@ public interface TestStateInfo { * @return Was terminated by user */ boolean wasTerminated(); + + /** + * It's some magic parameter than describe state type. + * @return + */ + Magnitude getMagnitude(); + + //WARN: It is Hack, see PoolOfTestStates, API is necessary + enum Magnitude { + SKIPPED_INDEX(0), + COMPLETE_INDEX(1), + NOT_RUN_INDEX(2), + RUNNING_INDEX(3), + TERMINATED_INDEX(4), + IGNORED_INDEX(5), + FAILED_INDEX(6), + ERROR_INDEX(8), + PASSED_INDEX(COMPLETE_INDEX.myValue); + + private final int myValue; + + Magnitude(int value) { + myValue = value; + } + + public int getValue() { + return myValue; + } + } } diff --git a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/ui/TestsPresentationUtil.java b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/ui/TestsPresentationUtil.java index 479aa0bd71..f89ed9de5a 100644 --- a/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/ui/TestsPresentationUtil.java +++ b/plugins/ruby/src/org/jetbrains/plugins/ruby/testing/testunit/runner/ui/TestsPresentationUtil.java @@ -5,8 +5,9 @@ import com.intellij.execution.testframework.ui.TestsProgressAnimator; import com.intellij.ui.SimpleTextAttributes; import org.jetbrains.annotations.NonNls; import org.jetbrains.plugins.ruby.RBundle; -import org.jetbrains.plugins.ruby.testing.testunit.runner.RTestUnitTestProxy; import org.jetbrains.plugins.ruby.testing.testunit.runner.RTestUnitConsoleProperties; +import org.jetbrains.plugins.ruby.testing.testunit.runner.RTestUnitTestProxy; +import org.jetbrains.plugins.ruby.testing.testunit.runner.states.TestStateInfo; import javax.swing.*; import java.text.NumberFormat; @@ -56,10 +57,12 @@ public class TestsPresentationUtil { final RTestUnitTestTreeRenderer renderer) { renderer.setIcon(getIcon(testProxy, renderer.getConsoleProperties())); + final TestStateInfo.Magnitude magnitude = testProxy.getMagnitudeInfo(); + final String text; - if (testProxy.isInProgress()) { + if (magnitude == TestStateInfo.Magnitude.RUNNING_INDEX) { text = RBundle.message("ruby.test.runner.ui.tests.tree.presentation.labels.running.tests"); - } else if (testProxy.wasTerminated()) { + } else if (magnitude == TestStateInfo.Magnitude.TERMINATED_INDEX) { text = RBundle.message("ruby.test.runner.ui.tests.tree.presentation.labels.was.terminated"); } else { text = RBundle.message("ruby.test.runner.ui.tests.tree.presentation.labels.test.results"); @@ -69,15 +72,16 @@ public class TestsPresentationUtil { public static void formatRootNodeWithoutChildren(final RTestUnitTestProxy testProxy, final RTestUnitTestTreeRenderer renderer) { - if (testProxy.isInProgress()) { + final TestStateInfo.Magnitude magnitude = testProxy.getMagnitudeInfo(); + if (magnitude == TestStateInfo.Magnitude.RUNNING_INDEX) { renderer.setIcon(getIcon(testProxy, renderer.getConsoleProperties())); renderer.append(RBundle.message("ruby.test.runner.ui.tests.tree.presentation.labels.instantiating.tests"), SimpleTextAttributes.REGULAR_ATTRIBUTES); - } else if (!testProxy.wasLaunched()) { + } else if (magnitude == TestStateInfo.Magnitude.NOT_RUN_INDEX) { renderer.setIcon(PoolOfTestIcons.NOT_RAN); renderer.append(RBundle.message("ruby.test.runner.ui.tests.tree.presentation.labels.not.test.results"), SimpleTextAttributes.ERROR_ATTRIBUTES); - } else if (testProxy.wasTerminated()) { + } else if (magnitude == TestStateInfo.Magnitude.TERMINATED_INDEX) { renderer.setIcon(PoolOfTestIcons.TERMINATED_ICON); renderer.append(RBundle.message("ruby.test.runner.ui.tests.tree.presentation.labels.was.terminated"), SimpleTextAttributes.REGULAR_ATTRIBUTES); @@ -116,25 +120,28 @@ public class TestsPresentationUtil { private static Icon getIcon(final RTestUnitTestProxy testProxy, final RTestUnitConsoleProperties consoleProperties) { - if (testProxy.isInProgress()) { - return !consoleProperties.isPaused() - ? TestsProgressAnimator.getCurrentFrame() - : TestsProgressAnimator.PAUSED_ICON; - } - - if (!testProxy.wasLaunched()) { - return PoolOfTestIcons.NOT_RAN; + final TestStateInfo.Magnitude magnitude = testProxy.getMagnitudeInfo(); + switch (magnitude) { + case ERROR_INDEX: + return PoolOfTestIcons.ERROR_ICON; + case FAILED_INDEX: + return PoolOfTestIcons.FAILED_ICON; + case IGNORED_INDEX: + return PoolOfTestIcons.IGNORED_ICON; + case NOT_RUN_INDEX: + return PoolOfTestIcons.NOT_RAN; + case COMPLETE_INDEX: + case PASSED_INDEX: + return PoolOfTestIcons.PASSED_ICON; + case RUNNING_INDEX: + return !consoleProperties.isPaused() + ? TestsProgressAnimator.getCurrentFrame() + : TestsProgressAnimator.PAUSED_ICON; + case SKIPPED_INDEX: + return PoolOfTestIcons.SKIPPED_ICON; + case TERMINATED_INDEX: + return PoolOfTestIcons.TERMINATED_ICON; } - - if (testProxy.wasTerminated()) { - return PoolOfTestIcons.TERMINATED_ICON; - } - - if (testProxy.isDefect()) { - //TODO[romeo] ignored tests support - return PoolOfTestIcons.FAILED_ICON; - } - - return PoolOfTestIcons.PASSED_ICON; + return null; } } diff --git a/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/GeneralToRTestUnitEventsConvertorTest.java b/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/GeneralToRTestUnitEventsConvertorTest.java index 7a3b13c1b4..c718cb6ee9 100644 --- a/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/GeneralToRTestUnitEventsConvertorTest.java +++ b/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/GeneralToRTestUnitEventsConvertorTest.java @@ -89,7 +89,7 @@ public class GeneralToRTestUnitEventsConvertorTest extends BaseRUnitTestsTestCas public void testOnTestFailure() { onTestStarted("some_test"); - myEventsProcessor.onTestFailure("some_test", "", ""); + myEventsProcessor.onTestFailure("some_test", "", "", false); final String fullName = myEventsProcessor.getFullTestName("some_test"); final RTestUnitTestProxy proxy = myEventsProcessor.getProxyByFullTestName(fullName); @@ -100,12 +100,22 @@ public class GeneralToRTestUnitEventsConvertorTest extends BaseRUnitTestsTestCas public void testOnTestFailure_Twice() { onTestStarted("some_test"); - myEventsProcessor.onTestFailure("some_test", "", ""); - myEventsProcessor.onTestFailure("some_test", "", ""); + myEventsProcessor.onTestFailure("some_test", "", "", false); + myEventsProcessor.onTestFailure("some_test", "", "", false); assertEquals(1, myEventsProcessor.getRunningTestsQuantity()); assertEquals(1, myEventsProcessor.getFailedTestsSet().size()); + } + + public void testOnTestError() { + onTestStarted("some_test"); + myEventsProcessor.onTestFailure("some_test", "", "", true); + + final String fullName = myEventsProcessor.getFullTestName("some_test"); + final RTestUnitTestProxy proxy = myEventsProcessor.getProxyByFullTestName(fullName); + assertTrue(proxy.isDefect()); + assertFalse(proxy.isInProgress()); } public void testOnTestFinished() { @@ -154,9 +164,25 @@ public class GeneralToRTestUnitEventsConvertorTest extends BaseRUnitTestsTestCas assertTrue(rootProxy.isDefect()); } - public void testOnFinishedTesting_WithDefect() { + public void testOnFinishedTesting_WithFailure() { + onTestStarted("test"); + myEventsProcessor.onTestFailure("test", "", "", false); + myEventsProcessor.onTestFinished("test"); + myEventsProcessor.onFinishTesting(); + + //Tree + final Object rootTreeNode = myTreeModel.getRoot(); + assertEquals(1, myTreeModel.getChildCount(rootTreeNode)); + final RTestUnitTestProxy rootProxy = RTestUnitTestTreeView.getTestProxyFor(rootTreeNode); + assertNotNull(rootProxy); + + assertFalse(rootProxy.isInProgress()); + assertTrue(rootProxy.isDefect()); + } + + public void testOnFinishedTesting_WithError() { onTestStarted("test"); - myEventsProcessor.onTestFailure("test", "", ""); + myEventsProcessor.onTestFailure("test", "", "", true); myEventsProcessor.onTestFinished("test"); myEventsProcessor.onFinishTesting(); diff --git a/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/RTestUnitConsoleOutputTest.java b/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/RTestUnitConsoleOutputTest.java index 777e8760bc..49528b700d 100644 --- a/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/RTestUnitConsoleOutputTest.java +++ b/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/RTestUnitConsoleOutputTest.java @@ -158,7 +158,7 @@ public class RTestUnitConsoleOutputTest extends BaseRUnitTestsTestCase { public void testProcessor_OnFailure() { final RTestUnitTestProxy myTest1 = startTestWithPrinter("my_test"); - myEventsProcessor.onTestFailure("my_test", "error msg", "method1:1\nmethod2:2"); + myEventsProcessor.onTestFailure("my_test", "error msg", "method1:1\nmethod2:2", false); myEventsProcessor.onTestOutput("my_test", "stdout1 ", true); myEventsProcessor.onTestOutput("my_test", "stderr1 ", false); @@ -172,7 +172,32 @@ public class RTestUnitConsoleOutputTest extends BaseRUnitTestsTestCase { final RTestUnitTestProxy myTest2 = startTestWithPrinter("my_test2"); myEventsProcessor.onTestOutput("my_test2", "stdout1 ", true); myEventsProcessor.onTestOutput("my_test2", "stderr1 ", false); - myEventsProcessor.onTestFailure("my_test2", "error msg", "method1:1\nmethod2:2"); + myEventsProcessor.onTestFailure("my_test2", "error msg", "method1:1\nmethod2:2", false); + + assertAllOutputs(myMockResetablePrinter, "stdout1 ", "stderr1 \nerror msg\nmethod1:1\nmethod2:2\n", ""); + final MockPrinter mockPrinter2 = new MockPrinter(true); + mockPrinter2.onNewAvaliable(myTest2); + assertAllOutputs(mockPrinter2, "stdout1 ", "stderr1 \nerror msg\nmethod1:1\nmethod2:2\n", ""); + } + + public void testProcessor_OnError() { + final RTestUnitTestProxy myTest1 = startTestWithPrinter("my_test"); + + myEventsProcessor.onTestFailure("my_test", "error msg", "method1:1\nmethod2:2", true); + myEventsProcessor.onTestOutput("my_test", "stdout1 ", true); + myEventsProcessor.onTestOutput("my_test", "stderr1 ", false); + + assertAllOutputs(myMockResetablePrinter, "stdout1 ", "\nerror msg\nmethod1:1\nmethod2:2\nstderr1 ", ""); + + final MockPrinter mockPrinter1 = new MockPrinter(true); + mockPrinter1.onNewAvaliable(myTest1); + assertAllOutputs(mockPrinter1, "stdout1 ", "stderr1 \nerror msg\nmethod1:1\nmethod2:2\n", ""); + + //other output order + final RTestUnitTestProxy myTest2 = startTestWithPrinter("my_test2"); + myEventsProcessor.onTestOutput("my_test2", "stdout1 ", true); + myEventsProcessor.onTestOutput("my_test2", "stderr1 ", false); + myEventsProcessor.onTestFailure("my_test2", "error msg", "method1:1\nmethod2:2", true); assertAllOutputs(myMockResetablePrinter, "stdout1 ", "stderr1 \nerror msg\nmethod1:1\nmethod2:2\n", ""); final MockPrinter mockPrinter2 = new MockPrinter(true); diff --git a/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/RTestUnitTestProxyTest.java b/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/RTestUnitTestProxyTest.java index fff3e3f59f..84dd19d5f5 100644 --- a/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/RTestUnitTestProxyTest.java +++ b/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/RTestUnitTestProxyTest.java @@ -1,6 +1,8 @@ package org.jetbrains.plugins.ruby.testing.testunit.runner; import com.intellij.execution.testframework.Filter; +import static org.jetbrains.plugins.ruby.testing.testunit.runner.states.TestStateInfo.Magnitude.*; +import org.jetbrains.plugins.ruby.testing.testunit.runner.states.TestStateInfo; /** * @author Roman Chernyatchik @@ -143,18 +145,20 @@ public class RTestUnitTestProxyTest extends BaseRUnitTestsTestCase { public void testTestFailed() { mySimpleTest.setStarted(); - mySimpleTest.setTestFailed("", ""); + mySimpleTest.setTestFailed("", "", false); - assertTrue(mySimpleTest.wasLaunched()); assertFalse(mySimpleTest.isInProgress()); + assertTrue(mySimpleTest.wasLaunched()); assertTrue(mySimpleTest.isDefect()); + assertTrue(mySimpleTest.getMagnitudeInfo() == TestStateInfo.Magnitude.FAILED_INDEX); mySimpleTest.setFinished(); - assertTrue(mySimpleTest.wasLaunched()); assertFalse(mySimpleTest.isInProgress()); + assertTrue(mySimpleTest.wasLaunched()); assertTrue(mySimpleTest.isDefect()); - assertFalse(mySuite.wasTerminated()); + + assertTrue(mySimpleTest.getMagnitudeInfo() == TestStateInfo.Magnitude.FAILED_INDEX); } public void testTestFailed_InSuite() { @@ -162,11 +166,55 @@ public class RTestUnitTestProxyTest extends BaseRUnitTestsTestCase { mySuite.addChild(mySimpleTest); mySimpleTest.setStarted(); - mySimpleTest.setTestFailed("", ""); + mySimpleTest.setTestFailed("", "", false); + + assertFalse(mySimpleTest.isInProgress()); + assertTrue(mySuite.isInProgress()); + assertTrue(mySuite.isDefect()); + assertTrue(mySimpleTest.isDefect()); + + mySimpleTest.setFinished(); assertTrue(mySuite.isInProgress()); assertTrue(mySuite.isDefect()); + + mySuite.setFinished(); + + assertFalse(mySuite.isInProgress()); + assertTrue(mySuite.isDefect()); + + assertTrue(mySimpleTest.getMagnitudeInfo() == TestStateInfo.Magnitude.FAILED_INDEX); + assertTrue(mySuite.getMagnitudeInfo() == TestStateInfo.Magnitude.FAILED_INDEX); + } + + public void testTestError() { + mySimpleTest.setStarted(); + mySimpleTest.setTestFailed("", "", true); + assertFalse(mySimpleTest.isInProgress()); + assertTrue(mySimpleTest.wasLaunched()); + assertTrue(mySimpleTest.isDefect()); + assertTrue(mySimpleTest.getMagnitudeInfo() == TestStateInfo.Magnitude.ERROR_INDEX); + + mySimpleTest.setFinished(); + + assertFalse(mySimpleTest.isInProgress()); + assertTrue(mySimpleTest.wasLaunched()); + assertTrue(mySimpleTest.isDefect()); + + assertTrue(mySimpleTest.getMagnitudeInfo() == TestStateInfo.Magnitude.ERROR_INDEX); + } + + public void testTestError_InSuite() { + mySuite.setStarted(); + mySuite.addChild(mySimpleTest); + + mySimpleTest.setStarted(); + mySimpleTest.setTestFailed("", "", true); + + assertFalse(mySimpleTest.isInProgress()); + assertTrue(mySuite.isInProgress()); + assertTrue(mySuite.isDefect()); assertTrue(mySimpleTest.isDefect()); mySimpleTest.setFinished(); @@ -178,6 +226,9 @@ public class RTestUnitTestProxyTest extends BaseRUnitTestsTestCase { assertFalse(mySuite.isInProgress()); assertTrue(mySuite.isDefect()); + + assertTrue(mySimpleTest.getMagnitudeInfo() == TestStateInfo.Magnitude.ERROR_INDEX); + assertTrue(mySuite.getMagnitudeInfo() == TestStateInfo.Magnitude.ERROR_INDEX); } public void testSuiteTerminated() { @@ -228,7 +279,7 @@ public class RTestUnitTestProxyTest extends BaseRUnitTestsTestCase { mySuite.addChild(testFailed); testFailed.setStarted(); - testFailed.setTestFailed("", ""); + testFailed.setTestFailed("", "", false); testFailed.setFinished(); mySuite.addChild(testInProgress); @@ -257,68 +308,94 @@ public class RTestUnitTestProxyTest extends BaseRUnitTestsTestCase { } public void testMagnitude() { - assertEquals(RTestUnitTestProxy.NOT_RUN_INDEX, mySuite.getMagnitude()); + assertEquals(NOT_RUN_INDEX.getValue(), mySuite.getMagnitude()); final RTestUnitTestProxy passedTest = createTestProxy("passed"); final RTestUnitTestProxy failedTest = createTestProxy("failed"); mySuite.addChild(passedTest); mySuite.addChild(failedTest); - assertEquals(RTestUnitTestProxy.NOT_RUN_INDEX, mySuite.getMagnitude()); - assertEquals(RTestUnitTestProxy.NOT_RUN_INDEX, passedTest.getMagnitude()); - assertEquals(RTestUnitTestProxy.NOT_RUN_INDEX, failedTest.getMagnitude()); + assertEquals(NOT_RUN_INDEX.getValue(), mySuite.getMagnitude()); + assertEquals(NOT_RUN_INDEX.getValue(), passedTest.getMagnitude()); + assertEquals(NOT_RUN_INDEX.getValue(), failedTest.getMagnitude()); mySuite.setStarted(); - assertEquals(RTestUnitTestProxy.RUNNING_INDEX, mySuite.getMagnitude()); - assertEquals(RTestUnitTestProxy.NOT_RUN_INDEX, passedTest.getMagnitude()); - assertEquals(RTestUnitTestProxy.NOT_RUN_INDEX, failedTest.getMagnitude()); + assertEquals(RUNNING_INDEX.getValue(), mySuite.getMagnitude()); + assertEquals(NOT_RUN_INDEX.getValue(), passedTest.getMagnitude()); + assertEquals(NOT_RUN_INDEX.getValue(), failedTest.getMagnitude()); passedTest.setStarted(); - assertEquals(RTestUnitTestProxy.RUNNING_INDEX, mySuite.getMagnitude()); - assertEquals(RTestUnitTestProxy.RUNNING_INDEX, passedTest.getMagnitude()); - assertEquals(RTestUnitTestProxy.NOT_RUN_INDEX, failedTest.getMagnitude()); + assertEquals(RUNNING_INDEX.getValue(), mySuite.getMagnitude()); + assertEquals(RUNNING_INDEX.getValue(), passedTest.getMagnitude()); + assertEquals(NOT_RUN_INDEX.getValue(), failedTest.getMagnitude()); passedTest.setFinished(); - assertEquals(RTestUnitTestProxy.RUNNING_INDEX, mySuite.getMagnitude()); - assertEquals(RTestUnitTestProxy.PASSED_INDEX, passedTest.getMagnitude()); - assertEquals(RTestUnitTestProxy.NOT_RUN_INDEX, failedTest.getMagnitude()); + assertEquals(RUNNING_INDEX.getValue(), mySuite.getMagnitude()); + assertEquals(PASSED_INDEX.getValue(), passedTest.getMagnitude()); + assertEquals(NOT_RUN_INDEX.getValue(), failedTest.getMagnitude()); failedTest.setStarted(); - assertEquals(RTestUnitTestProxy.RUNNING_INDEX, mySuite.getMagnitude()); - assertEquals(RTestUnitTestProxy.PASSED_INDEX, passedTest.getMagnitude()); - assertEquals(RTestUnitTestProxy.RUNNING_INDEX, failedTest.getMagnitude()); + assertEquals(RUNNING_INDEX.getValue(), mySuite.getMagnitude()); + assertEquals(PASSED_INDEX.getValue(), passedTest.getMagnitude()); + assertEquals(RUNNING_INDEX.getValue(), failedTest.getMagnitude()); - failedTest.setTestFailed("", ""); - assertEquals(RTestUnitTestProxy.RUNNING_INDEX, mySuite.getMagnitude()); - assertEquals(RTestUnitTestProxy.PASSED_INDEX, passedTest.getMagnitude()); - assertEquals(RTestUnitTestProxy.FAILED_INDEX, failedTest.getMagnitude()); + failedTest.setTestFailed("", "", false); + assertEquals(RUNNING_INDEX.getValue(), mySuite.getMagnitude()); + assertEquals(PASSED_INDEX.getValue(), passedTest.getMagnitude()); + assertEquals(FAILED_INDEX.getValue(), failedTest.getMagnitude()); mySuite.setFinished(); - assertEquals(RTestUnitTestProxy.FAILED_INDEX, mySuite.getMagnitude()); - assertEquals(RTestUnitTestProxy.PASSED_INDEX, passedTest.getMagnitude()); - assertEquals(RTestUnitTestProxy.FAILED_INDEX, failedTest.getMagnitude()); + assertEquals(FAILED_INDEX.getValue(), mySuite.getMagnitude()); + assertEquals(PASSED_INDEX.getValue(), passedTest.getMagnitude()); + assertEquals(FAILED_INDEX.getValue(), failedTest.getMagnitude()); + } + + public void testMagnitude_Error() { + assertEquals(NOT_RUN_INDEX.getValue(), mySuite.getMagnitude()); + + final RTestUnitTestProxy passedTest = createTestProxy("passed"); + final RTestUnitTestProxy failedTest = createTestProxy("failed"); + final RTestUnitTestProxy errorTest = createTestProxy("error"); + mySuite.addChild(passedTest); + mySuite.addChild(failedTest); + mySuite.addChild(errorTest); + + mySuite.setStarted(); + passedTest.setStarted(); + passedTest.setFinished(); + failedTest.setStarted(); + failedTest.setTestFailed("", "", false); + failedTest.setFinished(); + errorTest.setStarted(); + errorTest.setTestFailed("", "", true); + errorTest.setFinished(); + + assertEquals(RUNNING_INDEX.getValue(), mySuite.getMagnitude()); + assertEquals(PASSED_INDEX.getValue(), passedTest.getMagnitude()); + assertEquals(FAILED_INDEX.getValue(), failedTest.getMagnitude()); + assertEquals(ERROR_INDEX.getValue(), errorTest.getMagnitude()); } public void testMagnitude_Terminated() { - assertEquals(RTestUnitTestProxy.NOT_RUN_INDEX, mySuite.getMagnitude()); + assertEquals(NOT_RUN_INDEX.getValue(), mySuite.getMagnitude()); final RTestUnitTestProxy testProxy = createTestProxy("failed"); mySuite.addChild(testProxy); - assertEquals(RTestUnitTestProxy.NOT_RUN_INDEX, mySuite.getMagnitude()); - assertEquals(RTestUnitTestProxy.NOT_RUN_INDEX, testProxy.getMagnitude()); + assertEquals(NOT_RUN_INDEX.getValue(), mySuite.getMagnitude()); + assertEquals(NOT_RUN_INDEX.getValue(), testProxy.getMagnitude()); mySuite.setStarted(); mySuite.setTerminated(); - assertEquals(RTestUnitTestProxy.TERMINATED_INDEX, mySuite.getMagnitude()); - assertEquals(RTestUnitTestProxy.TERMINATED_INDEX, testProxy.getMagnitude()); + assertEquals(TERMINATED_INDEX.getValue(), mySuite.getMagnitude()); + assertEquals(TERMINATED_INDEX.getValue(), testProxy.getMagnitude()); } public void testMagnitude_suiteWithoutTests() { final RTestUnitTestProxy noTests = createSuiteProxy("failedSuite"); noTests.setStarted(); noTests.setFinished(); - assertEquals(RTestUnitTestProxy.FAILED_INDEX, noTests.getMagnitude()); + assertEquals(ERROR_INDEX.getValue(), noTests.getMagnitude()); } public void testMagnitude_PassedSuite() { @@ -329,7 +406,7 @@ public class RTestUnitTestProxyTest extends BaseRUnitTestsTestCase { passedSuiteTest.setStarted(); passedSuiteTest.setFinished(); passedSuite.setFinished(); - assertEquals(RTestUnitTestProxy.PASSED_INDEX, passedSuite.getMagnitude()); + assertEquals(PASSED_INDEX.getValue(), passedSuite.getMagnitude()); } public void testLocation() { @@ -380,7 +457,7 @@ public class RTestUnitTestProxyTest extends BaseRUnitTestsTestCase { public void testShouldRun_FailedTest() { mySimpleTest.setStarted(); - mySimpleTest.setTestFailed("", ""); + mySimpleTest.setTestFailed("", "", false); assertTrue(mySimpleTest.shouldRun()); } @@ -388,7 +465,16 @@ public class RTestUnitTestProxyTest extends BaseRUnitTestsTestCase { mySuite.setStarted(); mySuite.addChild(mySimpleTest); mySimpleTest.setStarted(); - mySimpleTest.setTestFailed("", ""); + mySimpleTest.setTestFailed("", "", false); + + assertTrue(mySuite.shouldRun()); + } + + public void testShouldRun_ErrorSuite() { + mySuite.setStarted(); + mySuite.addChild(mySimpleTest); + mySimpleTest.setStarted(); + mySimpleTest.setTestFailed("", "", true); assertTrue(mySuite.shouldRun()); } diff --git a/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/ui/RTestUnitUIActionsHandlerTest.java b/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/ui/RTestUnitUIActionsHandlerTest.java index dab5044cd4..1196abbfc8 100644 --- a/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/ui/RTestUnitUIActionsHandlerTest.java +++ b/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/ui/RTestUnitUIActionsHandlerTest.java @@ -46,7 +46,7 @@ public class RTestUnitUIActionsHandlerTest extends BaseRUnitTestsTestCase { super.tearDown(); } - public void testSelectFirstDeffect() { + public void testSelectFirstDeffect_Failed() { TestConsoleProperties.SELECT_FIRST_DEFECT.set(myProperties, true); mySuite.setStarted(); @@ -56,20 +56,14 @@ public class RTestUnitUIActionsHandlerTest extends BaseRUnitTestsTestCase { // passed test final RTestUnitTestProxy testPassed1 = createTestProxy("testPassed1", testsSuite); testPassed1.setStarted(); - myUIActionsHandler.onTestNodeAdded(myResultsViewer, testPassed1); - assertNull(mySelectedTestProxy); - - testPassed1.setFinished(); - //myUIActionsHandler.onTestFinished(testPassed1); - assertNull(mySelectedTestProxy); - + //failed test final RTestUnitTestProxy testFailed1 = createTestProxy("testFailed1", testsSuite); testFailed1.setStarted(); myUIActionsHandler.onTestNodeAdded(myResultsViewer, testFailed1); assertNull(mySelectedTestProxy); - testFailed1.setTestFailed("", ""); + testFailed1.setTestFailed("", "", false); //myUIActionsHandler.onTestFinished(testFailed1); assertNull(mySelectedTestProxy); @@ -91,7 +85,7 @@ public class RTestUnitUIActionsHandlerTest extends BaseRUnitTestsTestCase { myUIActionsHandler.onTestNodeAdded(myResultsViewer, testFailed2); assertNull(mySelectedTestProxy); - testFailed2.setTestFailed("", ""); + testFailed2.setTestFailed("", "", false); //myUIActionsHandler.onTestFinished(testFailed2); assertNull(mySelectedTestProxy); @@ -107,6 +101,62 @@ public class RTestUnitUIActionsHandlerTest extends BaseRUnitTestsTestCase { assertEquals(testFailed1, mySelectedTestProxy); } + public void testSelectFirstDeffect_Error() { + TestConsoleProperties.SELECT_FIRST_DEFECT.set(myProperties, true); + mySuite.setStarted(); + + final RTestUnitTestProxy testsSuite = createSuiteProxy("my suite", mySuite); + testsSuite.setStarted(); + + // passed test + final RTestUnitTestProxy testPassed1 = createTestProxy("testPassed1", testsSuite); + testPassed1.setStarted(); + + //failed test + final RTestUnitTestProxy testError = createTestProxy("testError", testsSuite); + testError.setStarted(); + myUIActionsHandler.onTestNodeAdded(myResultsViewer, testError); + assertNull(mySelectedTestProxy); + + testError.setTestFailed("", "", true); + //myUIActionsHandler.onTestFinished(testFailed1); + assertNull(mySelectedTestProxy); + + // passed test numer 2 + mySelectedTestProxy = null; + final RTestUnitTestProxy testPassed2 = createTestProxy("testPassed2", testsSuite); + testPassed2.setStarted(); + myUIActionsHandler.onTestNodeAdded(myResultsViewer, testPassed2); + assertNull(mySelectedTestProxy); + + testPassed2.setFinished(); + //myUIActionsHandler.onTestFinished(testPassed2); + assertNull(mySelectedTestProxy); + + + //failed test + final RTestUnitTestProxy testFailed2 = createTestProxy("testFailed1", testsSuite); + testFailed2.setStarted(); + myUIActionsHandler.onTestNodeAdded(myResultsViewer, testFailed2); + assertNull(mySelectedTestProxy); + + testFailed2.setTestFailed("", "", false); + //myUIActionsHandler.onTestFinished(testFailed2); + assertNull(mySelectedTestProxy); + + // finish suite + testsSuite.setFinished(); + assertNull(mySelectedTestProxy); + + //testing finished + mySuite.setFinished(); + assertNull(mySelectedTestProxy); + + myUIActionsHandler.onTestingFinished(myResultsViewer); + assertEquals(testError, mySelectedTestProxy); + } + + public void testTrackRunningTest() { TestConsoleProperties.TRACK_RUNNING_TEST.set(myProperties, true); mySuite.setStarted(); @@ -131,10 +181,30 @@ public class RTestUnitUIActionsHandlerTest extends BaseRUnitTestsTestCase { myUIActionsHandler.onTestNodeAdded(myResultsViewer, testFailed1); assertEquals(testFailed1, mySelectedTestProxy); - testFailed1.setTestFailed("", ""); + testFailed1.setTestFailed("", "", false); //myUIActionsHandler.onTestFinished(testFailed1); assertEquals(testFailed1, mySelectedTestProxy); + //error test + final RTestUnitTestProxy testError = createTestProxy("testError", testsSuite); + testError.setStarted(); + myUIActionsHandler.onTestNodeAdded(myResultsViewer, testError); + assertEquals(testError, mySelectedTestProxy); + + testError.setTestFailed("", "", true); + //myUIActionsHandler.onTestFinished(testError); + assertEquals(testError, mySelectedTestProxy); + + //terminated test + final RTestUnitTestProxy testTerminated = createTestProxy("testTerimated", testsSuite); + testTerminated.setStarted(); + myUIActionsHandler.onTestNodeAdded(myResultsViewer, testTerminated); + assertEquals(testTerminated, mySelectedTestProxy); + + testTerminated.setTerminated(); + //myUIActionsHandler.onTestFinished(testError); + assertEquals(testTerminated, mySelectedTestProxy); + // passed test numer 2 mySelectedTestProxy = null; final RTestUnitTestProxy testPassed2 = createTestProxy("testPassed2", testsSuite); @@ -154,7 +224,7 @@ public class RTestUnitUIActionsHandlerTest extends BaseRUnitTestsTestCase { assertEquals(testFailed2, mySelectedTestProxy); final RTestUnitTestProxy lastSelectedTest = testFailed2; - testFailed2.setTestFailed("", ""); + testFailed2.setTestFailed("", "", false); //myUIActionsHandler.onTestFinished(testFailed2); assertEquals(lastSelectedTest, mySelectedTestProxy); diff --git a/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/ui/TestsPresentationUtilTest.java b/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/ui/TestsPresentationUtilTest.java index a56ac1ed97..eb1a1022d1 100644 --- a/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/ui/TestsPresentationUtilTest.java +++ b/plugins/ruby/testSrc/org/jetbrains/plugins/ruby/testing/testunit/runner/ui/TestsPresentationUtilTest.java @@ -98,7 +98,7 @@ public class TestsPresentationUtilTest extends BaseRUnitTestsTestCase { public void testFormatTestProxyTest_Failed() { mySimpleTest.setStarted(); - mySimpleTest.setTestFailed("", ""); + mySimpleTest.setTestFailed("", "", false); TestsPresentationUtil.formatTestProxy(mySimpleTest, myRenderer); assertEquals(PoolOfTestIcons.FAILED_ICON, myRenderer.getIcon()); @@ -111,6 +111,21 @@ public class TestsPresentationUtilTest extends BaseRUnitTestsTestCase { assertEquals(PoolOfTestIcons.FAILED_ICON, myRenderer.getIcon()); } + public void testFormatTestProxyTest_Error() { + mySimpleTest.setStarted(); + mySimpleTest.setTestFailed("", "", true); + TestsPresentationUtil.formatTestProxy(mySimpleTest, myRenderer); + + assertEquals(PoolOfTestIcons.ERROR_ICON, myRenderer.getIcon()); + assertOneElement(myRenderer.getFragments()); + assertEquals(FAKE_TEST_NAME, myRenderer.getFragmentAt(0)); + assertEquals(SimpleTextAttributes.REGULAR_ATTRIBUTES, myRenderer.getAttribsAt(0)); + + mySimpleTest.setFinished(); + TestsPresentationUtil.formatTestProxy(mySimpleTest, myRenderer); + assertEquals(PoolOfTestIcons.ERROR_ICON, myRenderer.getIcon()); + } + public void testFormatTestProxyTest_Terminated() { mySimpleTest.setStarted(); mySimpleTest.setTerminated(); @@ -143,9 +158,9 @@ public class TestsPresentationUtilTest extends BaseRUnitTestsTestCase { mySuite.addChild(mySimpleTest); mySuite.setStarted(); mySimpleTest.setStarted(); - mySimpleTest.setTestFailed("", ""); + mySimpleTest.setTestFailed("", "", false); mySimpleTest.setFinished(); - mySuite.setTestFailed("", ""); + mySuite.setFinished(); TestsPresentationUtil.formatRootNodeWithChildren(mySuite, renderer1); @@ -162,6 +177,31 @@ public class TestsPresentationUtilTest extends BaseRUnitTestsTestCase { assertEquals("Test Results.", renderer1.getFragmentAt(0)); } + public void testFormatRootNodeWithChildren_Error() { + final MyRenderer renderer1 = new MyRenderer(false); + + mySuite.addChild(mySimpleTest); + mySuite.setStarted(); + mySimpleTest.setStarted(); + mySimpleTest.setTestFailed("", "", true); + mySimpleTest.setFinished(); + mySuite.setFinished(); + + TestsPresentationUtil.formatRootNodeWithChildren(mySuite, renderer1); + + assertEquals(PoolOfTestIcons.ERROR_ICON, renderer1.getIcon()); + assertOneElement(renderer1.getFragments()); + assertEquals("Test Results.", renderer1.getFragmentAt(0)); + assertEquals(SimpleTextAttributes.REGULAR_ATTRIBUTES, renderer1.getAttribsAt(0)); + + final MyRenderer renderer2 = new MyRenderer(false); + TestsPresentationUtil.formatRootNodeWithChildren(mySuite, renderer2); + mySuite.setFinished(); + assertEquals(PoolOfTestIcons.ERROR_ICON, renderer1.getIcon()); + assertOneElement(renderer1.getFragments()); + assertEquals("Test Results.", renderer1.getFragmentAt(0)); + } + public void testFormatRootNodeWithChildren_Passed() { mySuite.addChild(mySimpleTest); mySuite.setStarted(); -- 2.11.4.GIT