use of net.n3.nanoxml.IXMLElement in project intellij-plugins by JetBrains.
the class FlexUnitExecutionTest method checkResults.
private static void checkResults(IXMLElement expectedRoot, AbstractTestProxy actualRoot) {
assertEquals("Wrong tests run status", expectedRoot.getAttribute("status", null), getStatusTitle(actualRoot.getMagnitude()));
assertEquals("Wrong tests suites count", expectedRoot.getChildrenCount(), actualRoot.getChildren().size());
for (int i = 0; i < actualRoot.getChildren().size(); i++) {
final AbstractTestProxy actualSuite = actualRoot.getChildren().get(i);
//assertTrue(actualSuite.getName() + " expected to be suite", actualSuite.);
IXMLElement expectedSuite = getChild(expectedRoot, actualSuite.getName());
if (expectedSuite == null) {
fail("Unexpected suite: " + actualSuite.getName());
}
assertEquals("Wrong expected node", "suite", expectedSuite.getName());
assertEquals("Wrong test suite status", expectedSuite.getAttribute("status", null), getStatusTitle(actualSuite.getMagnitude()));
assertEquals("Wrong tests count in suite " + actualSuite.getName(), expectedSuite.getChildrenCount(), actualSuite.getChildren().size());
for (int j = 0; j < actualSuite.getChildren().size(); j++) {
final AbstractTestProxy actualTest = actualSuite.getChildren().get(j);
//assertTrue(actualSuite.getName() + " expected to be suite", actualSuite.);
IXMLElement expectedTest = getChild(expectedSuite, actualTest.getName());
if (expectedTest == null) {
fail("Unexpected test: " + actualTest.getName());
}
assertEquals("Wrong expected node", "test", expectedTest.getName());
assertEquals("Wrong test " + actualSuite.getName() + "." + actualTest.getName() + "() status", expectedTest.getAttribute("status", null), getStatusTitle(actualTest.getMagnitude()));
assertEquals("Test children not allowed", 0, expectedTest.getChildrenCount());
assertEmpty("Test children not expected", actualTest.getChildren());
}
}
}
use of net.n3.nanoxml.IXMLElement in project intellij-plugins by JetBrains.
the class FlexUnitExecutionTest method doTest.
private AbstractTestProxy doTest(boolean debugNotRun, FlexUnitRunnerParameters.Scope testScope, String testClassOrPackage, @Nullable String testMethod, @Nullable String projectRoot, @Nullable FlexUnitRunnerParameters.OutputLogLevel outputLogLevel, String... files) throws Exception {
configureByFiles(projectRoot, files);
final Ref<IXMLElement> expected = new Ref<>();
UIUtil.invokeAndWaitIfNeeded((Runnable) () -> WriteAction.run(() -> {
try {
Collection<IXMLElement> collection = JSTestUtils.extractXml(myEditor.getDocument(), "testResults");
assertEquals("Invalid expected structure", 1, collection.size());
expected.set(collection.iterator().next());
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}));
UIUtil.invokeAndWaitIfNeeded((Runnable) () -> WriteAction.run(() -> FlexTestUtils.modifyBuildConfiguration(myModule, configuration -> configuration.setTargetPlatform(myTargetPlatform))));
final RunnerAndConfigurationSettings runnerAndConfigurationSettings = RunManager.getInstance(myProject).createRunConfiguration("test", FlexUnitRunConfigurationType.getFactory());
final FlexUnitRunConfiguration flexUnitRunConfig = (FlexUnitRunConfiguration) runnerAndConfigurationSettings.getConfiguration();
final FlexUnitRunnerParameters params = flexUnitRunConfig.getRunnerParameters();
params.setModuleName(myModule.getName());
params.setBCName(FlexBuildConfigurationManager.getInstance(myModule).getBuildConfigurations()[0].getName());
params.setOutputLogLevel(outputLogLevel);
params.setScope(testScope);
switch(testScope) {
case Class:
params.setClassName(testClassOrPackage);
break;
case Method:
params.setClassName(testClassOrPackage);
params.setMethodName(testMethod);
break;
case Package:
params.setPackageName(testClassOrPackage);
break;
default:
fail("Unknown scope: " + testScope);
}
flexUnitRunConfig.checkConfiguration();
final ProgramRunner runner = new FlexUnitTestRunner();
final Executor executor = debugNotRun ? DefaultDebugExecutor.getDebugExecutorInstance() : DefaultRunExecutor.getRunExecutorInstance();
final ExecutionEnvironment env = new ExecutionEnvironment(executor, runner, runnerAndConfigurationSettings, getProject());
final Semaphore compilation = new Semaphore();
compilation.down();
final Semaphore execution = new Semaphore();
execution.down();
final Semaphore startup = new Semaphore();
final ProcessListener listener = new ProcessListener() {
@Override
public void startNotified(ProcessEvent event) {
startup.up();
}
@Override
public void processTerminated(ProcessEvent event) {
execution.up();
}
@Override
public void processWillTerminate(ProcessEvent event, boolean willBeDestroyed) {
}
@Override
public void onTextAvailable(ProcessEvent event, Key outputType) {
System.out.println("FlexUnit: " + event.getText());
}
};
final Ref<ExecutionConsole> executionConsole = new Ref<>();
ApplicationManager.getApplication().invokeLater(() -> {
try {
runner.execute(env, new ProgramRunner.Callback() {
@Override
public void processStarted(RunContentDescriptor descriptor) {
compilation.up();
startup.down();
descriptor.getProcessHandler().addProcessListener(listener);
executionConsole.set(descriptor.getExecutionConsole());
}
});
} catch (Throwable t) {
t.printStackTrace();
fail(t.getMessage());
compilation.up();
startup.up();
execution.up();
}
});
if (!compilation.waitFor(COMPILATION_TIMEOUT * 1000)) {
fail("Compilation did not succeed in " + COMPILATION_TIMEOUT + " seconds. There was an error or it took too long\n" + FlexCompilerHandler.getInstance(myProject).getLastCompilationMessages());
}
if (!startup.waitFor(STARTUP_TIMEOUT * 1000)) {
fail("Process was not started in " + STARTUP_TIMEOUT + " seconds");
}
if (!execution.waitFor(EXECUTION_TIMEOUT * 1000)) {
fail("Execution did not finish in " + EXECUTION_TIMEOUT + " seconds");
}
// give tests tree some time to stabilize
Thread.sleep(200);
final AbstractTestProxy testRoot = ((SMTRunnerConsoleView) executionConsole.get()).getResultsViewer().getRoot();
checkResults(expected.get(), testRoot);
if (outputLogLevel == null) {
checkOutput(testRoot, outputLogLevel);
}
return testRoot;
}
Aggregations