platform/smRunner/src/com/intellij/execution/testframework/sm/runner/GeneralToSMTRunnerEventsConvertor.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2009 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.intellij.execution.testframework.sm.runner;

 import com.intellij.execution.process.ProcessOutputTypes;
 import com.intellij.execution.testframework.AbstractTestProxy;
 import com.intellij.execution.testframework.sm.SMTestRunnerConnectionUtil;
 import com.intellij.execution.testframework.sm.SMTestsRunnerBundle;
 import com.intellij.execution.testframework.sm.runner.events.*;
 import com.intellij.openapi.application.Application;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.testIntegration.TestLocationProvider;
 import com.intellij.util.ObjectUtils;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;

 import java.util.*;

 /**
  * @author: Roman Chernyatchik
  *
  * This class fires events to RTestUnitEventsListener in EventDispatch thread
  */
 public class GeneralToSMTRunnerEventsConvertor extends GeneralTestEventsProcessor {
   private static final Logger LOG = Logger.getInstance(GeneralToSMTRunnerEventsConvertor.class.getName());

   private final Map<String, SMTestProxy> myRunningTestsFullNameToProxy = new HashMap<String, SMTestProxy>();

   private final Set<AbstractTestProxy> myFailedTestsSet = new HashSet<AbstractTestProxy>();

   private final TestSuiteStack mySuitesStack = new TestSuiteStack();
   private final List<SMTRunnerEventsListener> myEventsListeners = ContainerUtil.createLockFreeCopyOnWriteList();
   private final SMTestProxy.SMRootTestProxy myTestsRootNode;
   private final String myTestFrameworkName;
   private boolean myIsTestingFinished;
   private TestLocationProvider myLocator = null;

   public GeneralToSMTRunnerEventsConvertor(@NotNull final SMTestProxy.SMRootTestProxy testsRootNode,
                                            @NotNull final String testFrameworkName) {
     myTestsRootNode = testsRootNode;
     myTestFrameworkName = testFrameworkName;
   }

   public void setLocator(@NotNull TestLocationProvider customLocator) {
     myLocator = customLocator;
   }

   public void addEventsListener(@NotNull final SMTRunnerEventsListener listener) {
     myEventsListeners.add(listener);
   }

   public void onStartTesting() {
     addToInvokeLater(new Runnable() {
       public void run() {
         mySuitesStack.pushSuite(myTestsRootNode);
         myTestsRootNode.setStarted();

         //fire
         fireOnTestingStarted();
       }
     });
   }

   @Override
   public void onTestsReporterAttached() {
     addToInvokeLater(new Runnable() {
       public void run() {
         myTestsRootNode.setTestsReporterAttached();
       }
     });
   }

   public void onFinishTesting() {
     addToInvokeLater(new Runnable() {
       public void run() {
         if (myIsTestingFinished) {
           // has been already invoked!
           return;
         }
         myIsTestingFinished = true;

         // We don't know whether process was destroyed by user
         // or it finished after all tests have been run
         // Lets assume, if at finish all suites except root suite are passed
         // then all is ok otherwise process was terminated by user
         if (!myTestsRootNode.equals(mySuitesStack.getCurrentSuite())) {
           myTestsRootNode.setTerminated();
           myRunningTestsFullNameToProxy.clear();
         }
         mySuitesStack.clear();
         myTestsRootNode.setFinished();


         //fire events
         fireOnTestingFinished();
       }
     });
   }

   @Override
   public void setPrinterProvider(@NotNull TestProxyPrinterProvider printerProvider) {
   }

   public void onTestStarted(@NotNull final TestStartedEvent testStartedEvent) {
     addToInvokeLater(new Runnable() {
       public void run() {
         final String testName = testStartedEvent.getName();
         final String locationUrl = testStartedEvent.getLocationUrl();
         final String fullName = getFullTestName(testName);

         if (myRunningTestsFullNameToProxy.containsKey(fullName)) {
           //Duplicated event
           logProblem("Test [" + fullName + "] has been already started");

           if (SMTestRunnerConnectionUtil.isInDebugMode()) {
             return;
           }
         }

         final SMTestProxy parentSuite = getCurrentSuite();

         // creates test
         final SMTestProxy testProxy = new SMTestProxy(testName, false, locationUrl);
         if (myLocator != null) {
           testProxy.setLocator(myLocator);
         }
         parentSuite.addChild(testProxy);
         // adds to running tests map
         myRunningTestsFullNameToProxy.put(fullName, testProxy);

         //Progress started
         testProxy.setStarted();

         //fire events
         fireOnTestStarted(testProxy);
       }
     });
   }

   public void onSuiteStarted(@NotNull final TestSuiteStartedEvent suiteStartedEvent) {
     addToInvokeLater(new Runnable() {
       public void run() {
         final String suiteName = suiteStartedEvent.getName();
         final String locationUrl = suiteStartedEvent.getLocationUrl();
         final SMTestProxy parentSuite = getCurrentSuite();
         //new suite
         final SMTestProxy newSuite = new SMTestProxy(suiteName, true, locationUrl);
         if (myLocator != null) {
           newSuite.setLocator(myLocator);
         }
         parentSuite.addChild(newSuite);

         mySuitesStack.pushSuite(newSuite);

         //Progress started
         newSuite.setStarted();

         //fire event
         fireOnSuiteStarted(newSuite);
       }
     });
   }

   public void onTestFinished(@NotNull final TestFinishedEvent testFinishedEvent) {
     addToInvokeLater(new Runnable() {
       public void run() {
         final String testName = testFinishedEvent.getName();
         final long duration = testFinishedEvent.getDuration();
         final String fullTestName = getFullTestName(testName);
         final SMTestProxy testProxy = getProxyByFullTestName(fullTestName);

         if (testProxy == null) {
           logProblem("Test wasn't started! TestFinished event: name = {" + testName + "}. " +
                      cannotFindFullTestNameMsg(fullTestName));
           return;
         }

         testProxy.setDuration(duration);
         testProxy.setFinished();
         myRunningTestsFullNameToProxy.remove(fullTestName);

         //fire events
         fireOnTestFinished(testProxy);
       }
     });
   }

   public void onSuiteFinished(@NotNull final TestSuiteFinishedEvent suiteFinishedEvent) {
     addToInvokeLater(new Runnable() {
       public void run() {
         final String suiteName = suiteFinishedEvent.getName();
         final SMTestProxy mySuite = mySuitesStack.popSuite(suiteName);
         if (mySuite != null) {
           mySuite.setFinished();

           //fire events
           fireOnSuiteFinished(mySuite);
         }
       }
     });
   }

   public void onUncapturedOutput(@NotNull final String text, final Key outputType) {
     addToInvokeLater(new Runnable() {
       public void run() {
         final SMTestProxy currentProxy = findCurrentTestOrSuite();

         if (ProcessOutputTypes.STDERR.equals(outputType)) {
           currentProxy.addStdErr(text);
         } else if (ProcessOutputTypes.SYSTEM.equals(outputType)) {
           currentProxy.addSystemOutput(text);
         } else {
           currentProxy.addStdOutput(text, outputType);
         }
       }
     });
   }

   public void onError(@NotNull final String localizedMessage,
                       @Nullable final String stackTrace,
                       final boolean isCritical) {
     addToInvokeLater(new Runnable() {
       public void run() {
         final SMTestProxy currentProxy = findCurrentTestOrSuite();
         currentProxy.addError(localizedMessage, stackTrace, isCritical);
       }
     });
   }

   public void onCustomProgressTestsCategory(@Nullable final String categoryName,
                                             final int testCount) {
     addToInvokeLater(new Runnable() {
       public void run() {
         fireOnCustomProgressTestsCategory(categoryName, testCount);
       }
     });
   }

   public void onCustomProgressTestStarted() {
     addToInvokeLater(new Runnable() {
       public void run() {
         fireOnCustomProgressTestStarted();
       }
     });
   }

   public void onCustomProgressTestFailed() {
     addToInvokeLater(new Runnable() {
       public void run() {
         fireOnCustomProgressTestFailed();
       }
     });
   }

   public void onTestFailure(@NotNull final TestFailedEvent testFailedEvent) {
     addToInvokeLater(new Runnable() {
       public void run() {
         final String testName = testFailedEvent.getName();
         if (testName == null) {
           logProblem("No test name specified in " + testFailedEvent);
           return;
         }
         final String localizedMessage = testFailedEvent.getLocalizedFailureMessage();
         final String stackTrace = testFailedEvent.getStacktrace();
         final boolean isTestError = testFailedEvent.isTestError();
         final String comparisionFailureActualText = testFailedEvent.getComparisonFailureActualText();
         final String comparisionFailureExpectedText = testFailedEvent.getComparisonFailureExpectedText();
         final boolean inDebugMode = SMTestRunnerConnectionUtil.isInDebugMode();

         final String fullTestName = getFullTestName(testName);
         SMTestProxy testProxy = getProxyByFullTestName(fullTestName);
         if (testProxy == null) {
           logProblem("Test wasn't started! TestFailure event: name = {" + testName + "}" +
                              ", message = {" + localizedMessage + "}" +
                              ", stackTrace = {" + stackTrace + "}. " +
                              cannotFindFullTestNameMsg(fullTestName));
           if (inDebugMode) {
             return;
           } else {
             // try to fix the problem:
             if (!myFailedTestsSet.contains(testProxy)) {
               // if hasn't been already reported
               // 1. report
               onTestStarted(new TestStartedEvent(testName, null));
               // 2. add failure
               testProxy = getProxyByFullTestName(fullTestName);
             }
           }
         }

         if (testProxy == null) {
           return;
         }

         if (comparisionFailureActualText != null && comparisionFailureExpectedText != null) {
           if (myFailedTestsSet.contains(testProxy)) {
             // duplicate message
             logProblem("Duplicate failure for test [" + fullTestName + "]: msg = " + localizedMessage + ", stacktrace = " + stackTrace);

             if (inDebugMode) {
               return;
             }
           }

           testProxy.setTestComparisonFailed(localizedMessage, stackTrace,
                                             comparisionFailureActualText, comparisionFailureExpectedText);
         } else if (comparisionFailureActualText == null && comparisionFailureExpectedText == null) {
           testProxy.setTestFailed(localizedMessage, stackTrace, isTestError);
         } else {
           logProblem("Comparison failure actual and expected texts should be both null or not null.\n"
                      + "Expected:\n"
                      + comparisionFailureExpectedText + "\n"
                      + "Actual:\n"
                      + comparisionFailureActualText);
         }

         myFailedTestsSet.add(testProxy);

         // fire event
         fireOnTestFailed(testProxy);
       }
     });
   }

   public void onTestIgnored(@NotNull final TestIgnoredEvent testIgnoredEvent) {
      addToInvokeLater(new Runnable() {
       public void run() {
         final String testName = ObjectUtils.assertNotNull(testIgnoredEvent.getName());
         String ignoreComment = testIgnoredEvent.getIgnoreComment();
         if (StringUtil.isEmpty(ignoreComment)) {
           ignoreComment = SMTestsRunnerBundle.message("sm.test.runner.states.test.is.ignored");
         }
         final String stackTrace = testIgnoredEvent.getStacktrace();
         final String fullTestName = getFullTestName(testName);
         SMTestProxy testProxy = getProxyByFullTestName(fullTestName);
         if (testProxy == null) {
           final boolean debugMode = SMTestRunnerConnectionUtil.isInDebugMode();
           logProblem("Test wasn't started! " +
                      "TestIgnored event: name = {" + testName + "}, " +
                      "message = {" + ignoreComment + "}. " +
                      cannotFindFullTestNameMsg(fullTestName));
           if (debugMode) {
             return;
           } else {
             // try to fix
             // 1. report test opened
             onTestStarted(new TestStartedEvent(testName, null));

             // 2. report failure
             testProxy = getProxyByFullTestName(fullTestName);
           }

         }
         if (testProxy == null) {
           return;
         }
         testProxy.setTestIgnored(ignoreComment, stackTrace);

         // fire event
         fireOnTestIgnored(testProxy);
       }
     });
   }

   public void onTestOutput(@NotNull final TestOutputEvent testOutputEvent) {
      addToInvokeLater(new Runnable() {
       public void run() {
         final String testName = testOutputEvent.getName();
         final String text = testOutputEvent.getText();
         final boolean stdOut = testOutputEvent.isStdOut();
         final String fullTestName = getFullTestName(testName);
         final SMTestProxy testProxy = getProxyByFullTestName(fullTestName);
         if (testProxy == null) {
           logProblem("Test wasn't started! TestOutput event: name = {" + testName + "}, " +
                      "isStdOut = " + stdOut + ", " +
                      "text = {" + text + "}. " +
                      cannotFindFullTestNameMsg(fullTestName));
           return;
         }

         if (stdOut) {
           testProxy.addStdOutput(text, ProcessOutputTypes.STDOUT);
         } else {
           testProxy.addStdErr(text);
         }
       }
     });
   }

   public void onTestsCountInSuite(final int count) {
      addToInvokeLater(new Runnable() {
       public void run() {
         fireOnTestsCountInSuite(count);
       }
     });
   }

   @NotNull
   protected final SMTestProxy getCurrentSuite() {
     final SMTestProxy currentSuite = mySuitesStack.getCurrentSuite();

     if (currentSuite != null) {
       return currentSuite;
     }

     // current suite shouldn't be null otherwise test runner isn't correct
     // or may be we are in debug mode
     logProblem("Current suite is undefined. Root suite will be used.");
     return myTestsRootNode;

   }

   protected String getFullTestName(final String testName) {
     // Test name should be unique
     return testName;
   }

   protected int getRunningTestsQuantity() {
     return myRunningTestsFullNameToProxy.size();
   }

   protected Set<AbstractTestProxy> getFailedTestsSet() {
     return Collections.unmodifiableSet(myFailedTestsSet);
   }

   @Nullable
   protected SMTestProxy getProxyByFullTestName(final String fullTestName) {
     return myRunningTestsFullNameToProxy.get(fullTestName);
   }

   @TestOnly
   protected void clearInternalSuitesStack() {
     mySuitesStack.clear();
   }

   private String cannotFindFullTestNameMsg(String fullTestName) {
     return "Cant find running test for ["
               + fullTestName
               + "]. Current running tests: {"
               + dumpRunningTestsNames() + "}";
   }

   private StringBuilder dumpRunningTestsNames() {
     final Set<String> names = myRunningTestsFullNameToProxy.keySet();
     final StringBuilder namesDump = new StringBuilder();
     for (String name : names) {
       namesDump.append('[').append(name).append(']').append(',');
     }
     return namesDump;
   }

   private void fireOnTestingStarted() {
     for (SMTRunnerEventsListener listener : myEventsListeners) {
       listener.onTestingStarted(myTestsRootNode);
     }
   }

   private void fireOnTestingFinished() {
     for (SMTRunnerEventsListener listener : myEventsListeners) {
       listener.onTestingFinished(myTestsRootNode);
     }
   }

   private void fireOnTestsCountInSuite(final int count) {
     for (SMTRunnerEventsListener listener : myEventsListeners) {
       listener.onTestsCountInSuite(count);
     }
   }


   private void fireOnTestStarted(final SMTestProxy test) {
     for (SMTRunnerEventsListener listener : myEventsListeners) {
       listener.onTestStarted(test);
     }
   }

   private void fireOnTestFinished(final SMTestProxy test) {
     for (SMTRunnerEventsListener listener : myEventsListeners) {
       listener.onTestFinished(test);
     }
   }

   private void fireOnTestFailed(final SMTestProxy test) {
     for (SMTRunnerEventsListener listener : myEventsListeners) {
       listener.onTestFailed(test);
     }
   }

   private void fireOnTestIgnored(final SMTestProxy test) {
     for (SMTRunnerEventsListener listener : myEventsListeners) {
       listener.onTestIgnored(test);
     }
   }

   private void fireOnSuiteStarted(final SMTestProxy suite) {
     for (SMTRunnerEventsListener listener : myEventsListeners) {
       listener.onSuiteStarted(suite);
     }
   }

   private void fireOnSuiteFinished(final SMTestProxy suite) {
     for (SMTRunnerEventsListener listener : myEventsListeners) {
       listener.onSuiteFinished(suite);
     }
   }


   private void fireOnCustomProgressTestsCategory(@Nullable final String categoryName, int testCount) {
     for (SMTRunnerEventsListener listener : myEventsListeners) {
       listener.onCustomProgressTestsCategory(categoryName, testCount);
     }
   }

   private void fireOnCustomProgressTestStarted() {
     for (SMTRunnerEventsListener listener : myEventsListeners) {
       listener.onCustomProgressTestStarted();
     }
   }

   private void fireOnCustomProgressTestFailed() {
     for (SMTRunnerEventsListener listener : myEventsListeners) {
       listener.onCustomProgressTestFailed();
     }
   }

   /*
    * Remove listeners,  etc
    */
   public void dispose() {
     super.dispose();
      addToInvokeLater(new Runnable() {
       public void run() {
         myEventsListeners.clear();

         if (!myRunningTestsFullNameToProxy.isEmpty()) {
           final Application application = ApplicationManager.getApplication();
           if (!application.isHeadlessEnvironment() && !application.isUnitTestMode()) {
             logProblem("Not all events were processed! " + dumpRunningTestsNames());
           }
         }
         myRunningTestsFullNameToProxy.clear();
         mySuitesStack.clear();
       }
     });
   }


   private SMTestProxy findCurrentTestOrSuite() {
     //if we can locate test - we will send output to it, otherwise to current test suite
     final SMTestProxy currentProxy;
     if (myRunningTestsFullNameToProxy.size() == 1) {
       //current test
       currentProxy = myRunningTestsFullNameToProxy.values().iterator().next();
     } else {
       //current suite
       //
       // ProcessHandler can fire output available event before processStarted event
       currentProxy = mySuitesStack.isEmpty() ? myTestsRootNode : getCurrentSuite();
     }
     return currentProxy;
   }

   public static String getTFrameworkPrefix(final String testFrameworkName) {
     return "[" + testFrameworkName + "]: ";
   }

   private void logProblem(final String msg) {
     logProblem(LOG, msg, myTestFrameworkName);
   }

   public static void logProblem(final Logger log, final String msg, final String testFrameworkName) {
     logProblem(log, msg, SMTestRunnerConnectionUtil.isInDebugMode(), testFrameworkName);
   }

   public static void logProblem(final Logger log, final String msg, boolean throwError, final String testFrameworkName) {
     final String text = getTFrameworkPrefix(testFrameworkName) + msg;
     if (throwError) {
       log.error(text);
     }
     else {
       log.warn(text);
     }
   }
 }
	/*
	* Copyright 2000-2009 JetBrains s.r.o.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.intellij.execution.testframework.sm.runner;

	import com.intellij.execution.process.ProcessOutputTypes;
	import com.intellij.execution.testframework.AbstractTestProxy;
	import com.intellij.execution.testframework.sm.SMTestRunnerConnectionUtil;
	import com.intellij.execution.testframework.sm.SMTestsRunnerBundle;
	import com.intellij.execution.testframework.sm.runner.events.*;
	import com.intellij.openapi.application.Application;
	import com.intellij.openapi.application.ApplicationManager;
	import com.intellij.openapi.diagnostic.Logger;
	import com.intellij.openapi.util.Key;
	import com.intellij.openapi.util.text.StringUtil;
	import com.intellij.testIntegration.TestLocationProvider;
	import com.intellij.util.ObjectUtils;
	import com.intellij.util.containers.ContainerUtil;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;
	import org.jetbrains.annotations.TestOnly;

	import java.util.*;

	/**
	* @author: Roman Chernyatchik
	*
	* This class fires events to RTestUnitEventsListener in EventDispatch thread
	*/
	public class GeneralToSMTRunnerEventsConvertor extends GeneralTestEventsProcessor {
	private static final Logger LOG = Logger.getInstance(GeneralToSMTRunnerEventsConvertor.class.getName());

	private final Map<String, SMTestProxy> myRunningTestsFullNameToProxy = new HashMap<String, SMTestProxy>();

	private final Set<AbstractTestProxy> myFailedTestsSet = new HashSet<AbstractTestProxy>();

	private final TestSuiteStack mySuitesStack = new TestSuiteStack();
	private final List<SMTRunnerEventsListener> myEventsListeners = ContainerUtil.createLockFreeCopyOnWriteList();
	private final SMTestProxy.SMRootTestProxy myTestsRootNode;
	private final String myTestFrameworkName;
	private boolean myIsTestingFinished;
	private TestLocationProvider myLocator = null;

	public GeneralToSMTRunnerEventsConvertor(@NotNull final SMTestProxy.SMRootTestProxy testsRootNode,
	@NotNull final String testFrameworkName) {
	myTestsRootNode = testsRootNode;
	myTestFrameworkName = testFrameworkName;
	}

	public void setLocator(@NotNull TestLocationProvider customLocator) {
	myLocator = customLocator;
	}

	public void addEventsListener(@NotNull final SMTRunnerEventsListener listener) {
	myEventsListeners.add(listener);
	}

	public void onStartTesting() {
	addToInvokeLater(new Runnable() {
	public void run() {
	mySuitesStack.pushSuite(myTestsRootNode);
	myTestsRootNode.setStarted();

	//fire
	fireOnTestingStarted();
	}
	});
	}

	@Override
	public void onTestsReporterAttached() {
	addToInvokeLater(new Runnable() {
	public void run() {
	myTestsRootNode.setTestsReporterAttached();
	}
	});
	}

	public void onFinishTesting() {
	addToInvokeLater(new Runnable() {
	public void run() {
	if (myIsTestingFinished) {
	// has been already invoked!
	return;
	}
	myIsTestingFinished = true;

	// We don't know whether process was destroyed by user
	// or it finished after all tests have been run
	// Lets assume, if at finish all suites except root suite are passed
	// then all is ok otherwise process was terminated by user
	if (!myTestsRootNode.equals(mySuitesStack.getCurrentSuite())) {
	myTestsRootNode.setTerminated();
	myRunningTestsFullNameToProxy.clear();
	}
	mySuitesStack.clear();
	myTestsRootNode.setFinished();


	//fire events
	fireOnTestingFinished();
	}
	});
	}

	@Override
	public void setPrinterProvider(@NotNull TestProxyPrinterProvider printerProvider) {
	}

	public void onTestStarted(@NotNull final TestStartedEvent testStartedEvent) {
	addToInvokeLater(new Runnable() {
	public void run() {
	final String testName = testStartedEvent.getName();
	final String locationUrl = testStartedEvent.getLocationUrl();
	final String fullName = getFullTestName(testName);

	if (myRunningTestsFullNameToProxy.containsKey(fullName)) {
	//Duplicated event
	logProblem("Test [" + fullName + "] has been already started");

	if (SMTestRunnerConnectionUtil.isInDebugMode()) {
	return;
	}
	}

	final SMTestProxy parentSuite = getCurrentSuite();

	// creates test
	final SMTestProxy testProxy = new SMTestProxy(testName, false, locationUrl);
	if (myLocator != null) {
	testProxy.setLocator(myLocator);
	}
	parentSuite.addChild(testProxy);
	// adds to running tests map
	myRunningTestsFullNameToProxy.put(fullName, testProxy);

	//Progress started
	testProxy.setStarted();

	//fire events
	fireOnTestStarted(testProxy);
	}
	});
	}

	public void onSuiteStarted(@NotNull final TestSuiteStartedEvent suiteStartedEvent) {
	addToInvokeLater(new Runnable() {
	public void run() {
	final String suiteName = suiteStartedEvent.getName();
	final String locationUrl = suiteStartedEvent.getLocationUrl();
	final SMTestProxy parentSuite = getCurrentSuite();
	//new suite
	final SMTestProxy newSuite = new SMTestProxy(suiteName, true, locationUrl);
	if (myLocator != null) {
	newSuite.setLocator(myLocator);
	}
	parentSuite.addChild(newSuite);

	mySuitesStack.pushSuite(newSuite);

	//Progress started
	newSuite.setStarted();

	//fire event
	fireOnSuiteStarted(newSuite);
	}
	});
	}

	public void onTestFinished(@NotNull final TestFinishedEvent testFinishedEvent) {
	addToInvokeLater(new Runnable() {
	public void run() {
	final String testName = testFinishedEvent.getName();
	final long duration = testFinishedEvent.getDuration();
	final String fullTestName = getFullTestName(testName);
	final SMTestProxy testProxy = getProxyByFullTestName(fullTestName);

	if (testProxy == null) {
	logProblem("Test wasn't started! TestFinished event: name = {" + testName + "}. " +
	cannotFindFullTestNameMsg(fullTestName));
	return;
	}

	testProxy.setDuration(duration);
	testProxy.setFinished();
	myRunningTestsFullNameToProxy.remove(fullTestName);

	//fire events
	fireOnTestFinished(testProxy);
	}
	});
	}

	public void onSuiteFinished(@NotNull final TestSuiteFinishedEvent suiteFinishedEvent) {
	addToInvokeLater(new Runnable() {
	public void run() {
	final String suiteName = suiteFinishedEvent.getName();
	final SMTestProxy mySuite = mySuitesStack.popSuite(suiteName);
	if (mySuite != null) {
	mySuite.setFinished();

	//fire events
	fireOnSuiteFinished(mySuite);
	}
	}
	});
	}

	public void onUncapturedOutput(@NotNull final String text, final Key outputType) {
	addToInvokeLater(new Runnable() {
	public void run() {
	final SMTestProxy currentProxy = findCurrentTestOrSuite();

	if (ProcessOutputTypes.STDERR.equals(outputType)) {
	currentProxy.addStdErr(text);
	} else if (ProcessOutputTypes.SYSTEM.equals(outputType)) {
	currentProxy.addSystemOutput(text);
	} else {
	currentProxy.addStdOutput(text, outputType);
	}
	}
	});
	}

	public void onError(@NotNull final String localizedMessage,
	@Nullable final String stackTrace,
	final boolean isCritical) {
	addToInvokeLater(new Runnable() {
	public void run() {
	final SMTestProxy currentProxy = findCurrentTestOrSuite();
	currentProxy.addError(localizedMessage, stackTrace, isCritical);
	}
	});
	}

	public void onCustomProgressTestsCategory(@Nullable final String categoryName,
	final int testCount) {
	addToInvokeLater(new Runnable() {
	public void run() {
	fireOnCustomProgressTestsCategory(categoryName, testCount);
	}
	});
	}

	public void onCustomProgressTestStarted() {
	addToInvokeLater(new Runnable() {
	public void run() {
	fireOnCustomProgressTestStarted();
	}
	});
	}

	public void onCustomProgressTestFailed() {
	addToInvokeLater(new Runnable() {
	public void run() {
	fireOnCustomProgressTestFailed();
	}
	});
	}

	public void onTestFailure(@NotNull final TestFailedEvent testFailedEvent) {
	addToInvokeLater(new Runnable() {
	public void run() {
	final String testName = testFailedEvent.getName();
	if (testName == null) {
	logProblem("No test name specified in " + testFailedEvent);
	return;
	}
	final String localizedMessage = testFailedEvent.getLocalizedFailureMessage();
	final String stackTrace = testFailedEvent.getStacktrace();
	final boolean isTestError = testFailedEvent.isTestError();
	final String comparisionFailureActualText = testFailedEvent.getComparisonFailureActualText();
	final String comparisionFailureExpectedText = testFailedEvent.getComparisonFailureExpectedText();
	final boolean inDebugMode = SMTestRunnerConnectionUtil.isInDebugMode();

	final String fullTestName = getFullTestName(testName);
	SMTestProxy testProxy = getProxyByFullTestName(fullTestName);
	if (testProxy == null) {
	logProblem("Test wasn't started! TestFailure event: name = {" + testName + "}" +
	", message = {" + localizedMessage + "}" +
	", stackTrace = {" + stackTrace + "}. " +
	cannotFindFullTestNameMsg(fullTestName));
	if (inDebugMode) {
	return;
	} else {
	// try to fix the problem:
	if (!myFailedTestsSet.contains(testProxy)) {
	// if hasn't been already reported
	// 1. report
	onTestStarted(new TestStartedEvent(testName, null));
	// 2. add failure
	testProxy = getProxyByFullTestName(fullTestName);
	}
	}
	}

	if (testProxy == null) {
	return;
	}

	if (comparisionFailureActualText != null && comparisionFailureExpectedText != null) {
	if (myFailedTestsSet.contains(testProxy)) {
	// duplicate message
	logProblem("Duplicate failure for test [" + fullTestName + "]: msg = " + localizedMessage + ", stacktrace = " + stackTrace);

	if (inDebugMode) {
	return;
	}
	}

	testProxy.setTestComparisonFailed(localizedMessage, stackTrace,
	comparisionFailureActualText, comparisionFailureExpectedText);
	} else if (comparisionFailureActualText == null && comparisionFailureExpectedText == null) {
	testProxy.setTestFailed(localizedMessage, stackTrace, isTestError);
	} else {
	logProblem("Comparison failure actual and expected texts should be both null or not null.\n"
	+ "Expected:\n"
	+ comparisionFailureExpectedText + "\n"
	+ "Actual:\n"
	+ comparisionFailureActualText);
	}

	myFailedTestsSet.add(testProxy);

	// fire event
	fireOnTestFailed(testProxy);
	}
	});
	}

	public void onTestIgnored(@NotNull final TestIgnoredEvent testIgnoredEvent) {
	addToInvokeLater(new Runnable() {
	public void run() {
	final String testName = ObjectUtils.assertNotNull(testIgnoredEvent.getName());
	String ignoreComment = testIgnoredEvent.getIgnoreComment();
	if (StringUtil.isEmpty(ignoreComment)) {
	ignoreComment = SMTestsRunnerBundle.message("sm.test.runner.states.test.is.ignored");
	}
	final String stackTrace = testIgnoredEvent.getStacktrace();
	final String fullTestName = getFullTestName(testName);
	SMTestProxy testProxy = getProxyByFullTestName(fullTestName);
	if (testProxy == null) {
	final boolean debugMode = SMTestRunnerConnectionUtil.isInDebugMode();
	logProblem("Test wasn't started! " +
	"TestIgnored event: name = {" + testName + "}, " +
	"message = {" + ignoreComment + "}. " +
	cannotFindFullTestNameMsg(fullTestName));
	if (debugMode) {
	return;
	} else {
	// try to fix
	// 1. report test opened
	onTestStarted(new TestStartedEvent(testName, null));

	// 2. report failure
	testProxy = getProxyByFullTestName(fullTestName);
	}

	}
	if (testProxy == null) {
	return;
	}
	testProxy.setTestIgnored(ignoreComment, stackTrace);

	// fire event
	fireOnTestIgnored(testProxy);
	}
	});
	}

	public void onTestOutput(@NotNull final TestOutputEvent testOutputEvent) {
	addToInvokeLater(new Runnable() {
	public void run() {
	final String testName = testOutputEvent.getName();
	final String text = testOutputEvent.getText();
	final boolean stdOut = testOutputEvent.isStdOut();
	final String fullTestName = getFullTestName(testName);
	final SMTestProxy testProxy = getProxyByFullTestName(fullTestName);
	if (testProxy == null) {
	logProblem("Test wasn't started! TestOutput event: name = {" + testName + "}, " +
	"isStdOut = " + stdOut + ", " +
	"text = {" + text + "}. " +
	cannotFindFullTestNameMsg(fullTestName));
	return;
	}

	if (stdOut) {
	testProxy.addStdOutput(text, ProcessOutputTypes.STDOUT);
	} else {
	testProxy.addStdErr(text);
	}
	}
	});
	}

	public void onTestsCountInSuite(final int count) {
	addToInvokeLater(new Runnable() {
	public void run() {
	fireOnTestsCountInSuite(count);
	}
	});
	}

	@NotNull
	protected final SMTestProxy getCurrentSuite() {
	final SMTestProxy currentSuite = mySuitesStack.getCurrentSuite();

	if (currentSuite != null) {
	return currentSuite;
	}

	// current suite shouldn't be null otherwise test runner isn't correct
	// or may be we are in debug mode
	logProblem("Current suite is undefined. Root suite will be used.");
	return myTestsRootNode;

	}

	protected String getFullTestName(final String testName) {
	// Test name should be unique
	return testName;
	}

	protected int getRunningTestsQuantity() {
	return myRunningTestsFullNameToProxy.size();
	}

	protected Set<AbstractTestProxy> getFailedTestsSet() {
	return Collections.unmodifiableSet(myFailedTestsSet);
	}

	@Nullable
	protected SMTestProxy getProxyByFullTestName(final String fullTestName) {
	return myRunningTestsFullNameToProxy.get(fullTestName);
	}

	@TestOnly
	protected void clearInternalSuitesStack() {
	mySuitesStack.clear();
	}

	private String cannotFindFullTestNameMsg(String fullTestName) {
	return "Cant find running test for ["
	+ fullTestName
	+ "]. Current running tests: {"
	+ dumpRunningTestsNames() + "}";
	}

	private StringBuilder dumpRunningTestsNames() {
	final Set<String> names = myRunningTestsFullNameToProxy.keySet();
	final StringBuilder namesDump = new StringBuilder();
	for (String name : names) {
	namesDump.append('[').append(name).append(']').append(',');
	}
	return namesDump;
	}

	private void fireOnTestingStarted() {
	for (SMTRunnerEventsListener listener : myEventsListeners) {
	listener.onTestingStarted(myTestsRootNode);
	}
	}

	private void fireOnTestingFinished() {
	for (SMTRunnerEventsListener listener : myEventsListeners) {
	listener.onTestingFinished(myTestsRootNode);
	}
	}

	private void fireOnTestsCountInSuite(final int count) {
	for (SMTRunnerEventsListener listener : myEventsListeners) {
	listener.onTestsCountInSuite(count);
	}
	}


	private void fireOnTestStarted(final SMTestProxy test) {
	for (SMTRunnerEventsListener listener : myEventsListeners) {
	listener.onTestStarted(test);
	}
	}

	private void fireOnTestFinished(final SMTestProxy test) {
	for (SMTRunnerEventsListener listener : myEventsListeners) {
	listener.onTestFinished(test);
	}
	}

	private void fireOnTestFailed(final SMTestProxy test) {
	for (SMTRunnerEventsListener listener : myEventsListeners) {
	listener.onTestFailed(test);
	}
	}

	private void fireOnTestIgnored(final SMTestProxy test) {
	for (SMTRunnerEventsListener listener : myEventsListeners) {
	listener.onTestIgnored(test);
	}
	}

	private void fireOnSuiteStarted(final SMTestProxy suite) {
	for (SMTRunnerEventsListener listener : myEventsListeners) {
	listener.onSuiteStarted(suite);
	}
	}

	private void fireOnSuiteFinished(final SMTestProxy suite) {
	for (SMTRunnerEventsListener listener : myEventsListeners) {
	listener.onSuiteFinished(suite);
	}
	}


	private void fireOnCustomProgressTestsCategory(@Nullable final String categoryName, int testCount) {
	for (SMTRunnerEventsListener listener : myEventsListeners) {
	listener.onCustomProgressTestsCategory(categoryName, testCount);
	}
	}

	private void fireOnCustomProgressTestStarted() {
	for (SMTRunnerEventsListener listener : myEventsListeners) {
	listener.onCustomProgressTestStarted();
	}
	}

	private void fireOnCustomProgressTestFailed() {
	for (SMTRunnerEventsListener listener : myEventsListeners) {
	listener.onCustomProgressTestFailed();
	}
	}

	/*
	* Remove listeners, etc
	*/
	public void dispose() {
	super.dispose();
	addToInvokeLater(new Runnable() {
	public void run() {
	myEventsListeners.clear();

	if (!myRunningTestsFullNameToProxy.isEmpty()) {
	final Application application = ApplicationManager.getApplication();
	if (!application.isHeadlessEnvironment() && !application.isUnitTestMode()) {
	logProblem("Not all events were processed! " + dumpRunningTestsNames());
	}
	}
	myRunningTestsFullNameToProxy.clear();
	mySuitesStack.clear();
	}
	});
	}


	private SMTestProxy findCurrentTestOrSuite() {
	//if we can locate test - we will send output to it, otherwise to current test suite
	final SMTestProxy currentProxy;
	if (myRunningTestsFullNameToProxy.size() == 1) {
	//current test
	currentProxy = myRunningTestsFullNameToProxy.values().iterator().next();
	} else {
	//current suite
	//
	// ProcessHandler can fire output available event before processStarted event
	currentProxy = mySuitesStack.isEmpty() ? myTestsRootNode : getCurrentSuite();
	}
	return currentProxy;
	}

	public static String getTFrameworkPrefix(final String testFrameworkName) {
	return "[" + testFrameworkName + "]: ";
	}

	private void logProblem(final String msg) {
	logProblem(LOG, msg, myTestFrameworkName);
	}

	public static void logProblem(final Logger log, final String msg, final String testFrameworkName) {
	logProblem(log, msg, SMTestRunnerConnectionUtil.isInDebugMode(), testFrameworkName);
	}

	public static void logProblem(final Logger log, final String msg, boolean throwError, final String testFrameworkName) {
	final String text = getTFrameworkPrefix(testFrameworkName) + msg;
	if (throwError) {
	log.error(text);
	}
	else {
	log.warn(text);
	}
	}
	}