import java.io.BufferedReader;
import java.io.StringReader;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.regex.Pattern;
-import java.util.regex.PatternSyntaxException;
+import java.util.stream.Collectors;
import org.eclipse.swt.graphics.Image;
import org.simantics.Simantics;
-import org.simantics.databoard.Bindings;
import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
import org.simantics.db.common.request.ReadRequest;
import org.simantics.layer0.Layer0;
import org.simantics.scl.compiler.commands.CommandSession;
import org.simantics.scl.compiler.commands.TestScriptExecutor;
-import org.simantics.scl.compiler.module.Module;
import org.simantics.scl.compiler.module.coverage.CombinedCoverage;
-import org.simantics.scl.compiler.module.coverage.CoverageBuilder;
-import org.simantics.scl.compiler.module.coverage.CoverageUtils;
import org.simantics.scl.compiler.module.options.ModuleCompilationOptions;
import org.simantics.scl.compiler.module.options.ModuleCompilationOptionsAdvisor;
import org.simantics.scl.compiler.module.repository.ModuleRepository;
-import org.simantics.scl.compiler.runtime.RuntimeModule;
import org.simantics.scl.osgi.SCLOsgi;
import org.simantics.scl.runtime.reporting.AbstractSCLReportingHandler;
import org.simantics.tests.modelled.ontology.TestsResource;
-import org.simantics.utils.strings.AlphanumComparator;
+import org.simantics.tests.modelled.utils.ModelledSTSSuite;
+import org.simantics.tests.modelled.utils.ModelledSTSTest;
+import org.simantics.tests.modelled.utils.STSSuiteTestCollector;
public class STSTestSuiteModel {
static class STSTest {
- private final Resource test;
+ private final ModelledSTSTest test;
+
private final STSSuite parent;
- private final String definition;
- private final String name;
private boolean executed = false;
private long duration;
private boolean failed = false;
private boolean isRunning = false;
private List<String> output = new ArrayList<>();
- private CombinedCoverage coverage;
- private int priority;
- public STSTest(Resource test, STSSuite parent, String definition, String name, int executionPrioprity) {
+ public STSTest(ModelledSTSTest test, STSSuite parent) {
this.test = test;
this.parent = parent;
- this.definition = definition;
- this.name = name;
- this.priority = executionPrioprity;
}
public String getName() {
- return name;
+ return test.getName();
}
public String getLabel() {
StringBuilder sb = new StringBuilder();
- sb.append(name);
+ sb.append(getName());
if (executed || failed)
sb.append(" (").append(duration).append(" ms)");
return sb.toString();
}
public String getDefinition() {
- return definition;
+ return test.getCode();
}
public STSSuite getParent() {
public void execute(CommandSession session) {
isRunning = true;
- TestScriptExecutor executor = new TestScriptExecutor(session, new BufferedReader(new StringReader(definition)), new AbstractSCLReportingHandler() {
+ TestScriptExecutor executor = new TestScriptExecutor(session, new BufferedReader(new StringReader(getDefinition())), new AbstractSCLReportingHandler() {
@Override
public void print(String text) {
public void printError(String error) {
appendOutput(error + "\n");
}
- });
+ }, true);
long start = System.currentTimeMillis();
try {
if (parent != null)
}
public void setCoverage(CombinedCoverage coverage) {
- this.coverage = coverage;
+ test.setCoverage(coverage);
}
public CombinedCoverage getCoverage() {
- return coverage;
+ return test.getCoverage();
}
-
+
+ public int getPriority() {
+ return test.getPriority();
+ }
+
@Override
public String toString() {
- return name + " [priority=" + priority + ", executed=" + executed + ", duration=" + duration + "]";
+ return getName() + " [priority=" + getPriority() + ", executed=" + executed + ", duration=" + duration + "]";
+ }
+
+ public boolean isIgnored() {
+ return test.isIgnored();
}
}
static class STSSuite {
-
- private List<Pattern> moduleNameFilterPatterns = new ArrayList<>();
- private final Resource suite;
- private final String name;
+
+ private ModelledSTSSuite suite;
private STSTest[] children;
private int startedCount;
private int errorCount;
private int failureCount;
- private CoverageBuilder coverageBuilder;
+ public int ignoredCount;
- public STSSuite(Resource suite, String name, String moduleNameFilter) {
+ public STSSuite(ModelledSTSSuite suite) {
this.suite = suite;
- this.name = name;
- for (String s : moduleNameFilter.split(",")) {
- try {
- s = s.trim().replaceAll("\\*", "\\\\w*").toLowerCase();
- moduleNameFilterPatterns.add(Pattern.compile(s));
- } catch (PatternSyntaxException e) {
- e.printStackTrace();
- }
- }
- }
-
- public void children(STSTest[] children) {
- this.children = children;
}
public STSTest[] getChildren() {
+ if (children == null)
+ children = suite.getSortedChildren().stream().map(modelledTest -> new STSTest(modelledTest, this)).collect(Collectors.toList()).toArray(new STSTest[suite.getChildren().size()]);
return children;
}
public String getName() {
- return name;
+ return suite.getName();
}
public String getLabel() {
StringBuilder sb = new StringBuilder();
- sb.append(name);
+ sb.append(getName());
long totalTime = 0;
- if (children != null) {
- for (STSTest test : children) {
+ if (getChildren() != null) {
+ for (STSTest test : getChildren()) {
if (test.executed || test.failed) {
totalTime += test.duration;
}
}
public boolean isRunning() {
- boolean running = false;
- if (children != null) {
- for (STSTest test: children) {
+ if (getChildren() != null) {
+ for (STSTest test: getChildren()) {
if (test.isRunning) {
- running = true;
- break;
+ return true;
}
}
}
- return running;
+ return false;
}
public boolean executed() {
- boolean executed = true;
- if (children != null) {
- for (STSTest test: children) {
+ if (getChildren() != null) {
+ for (STSTest test: getChildren()) {
if (!test.executed) {
- executed = false;
- break;
+ return false;
}
}
}
- return executed;
+ return true;
}
public boolean failed() {
- boolean failed = false;
- if (children != null) {
- for (STSTest test: children) {
+ if (getChildren() != null) {
+ for (STSTest test: getChildren()) {
if (test.failed) {
- failed = true;
- break;
+ return true;
}
}
}
- return failed;
- }
-
- public void addCoverage(List<Module> modules) {
- if (coverageBuilder == null) {
- coverageBuilder = new CoverageBuilder();
- }
- for (Module module : modules)
- coverageBuilder.addCoverage(module, true);
+ return false;
}
public CombinedCoverage getCoverage() {
- if (coverageBuilder == null)
- return null;
- return coverageBuilder.getCoverage();
+ return suite.getCoverage();
}
}
@Override
public ModuleCompilationOptions getOptions(String moduleName) {
boolean coverage = false;
- for (Pattern p : suite.moduleNameFilterPatterns) {
+ for (Pattern p : suite.suite.getModuleNameFilterPatterns()) {
if (p.matcher(moduleName.toLowerCase()).find()) {
coverage = true;
break;
}
private void executeSuite(CommandSession session) {
-
for (STSTest test : suite.getChildren()) {
- test.execute(session);
-
- Collection<RuntimeModule> runtimeModules = session.getRuntimeEnvironment().getRuntimeModules();
- List<Module> modules = new ArrayList<>(runtimeModules.size());
- for (RuntimeModule module : runtimeModules) {
- for (Pattern p : suite.moduleNameFilterPatterns) {
- if (p.matcher(module.getModule().getName().toLowerCase()).find()) {
- modules.add(module.getModule());
- }
- }
+ if (test.isIgnored()) {
+ testExecuted();
+ test.getParent().ignoredCount++;
+ continue;
}
- test.setCoverage(CoverageUtils.getCoverage(modules));
- suite.addCoverage(modules);
-
- CoverageUtils.resetCoverage(modules);
-
+ test.execute(session);
+ STSSuiteTestCollector.setSuiteCoverage(test.test, suite.suite, session);
testExecuted();
}
-
}
-
+
private void executeTest(CommandSession session) {
-
test.execute(session);
testExecuted();
-
- Collection<RuntimeModule> runtimeModules = session.getRuntimeEnvironment().getRuntimeModules();
- List<Module> modules = new ArrayList<>(runtimeModules.size());
- for (RuntimeModule module : runtimeModules) {
- modules.add(module.getModule());
- }
- test.setCoverage(CoverageUtils.getCoverage(modules));
-
- CoverageUtils.resetCoverage(modules);
-
+ STSSuiteTestCollector.setTestCoverage(test.test, session);
}
-
public boolean hasChildren(Object element) {
if (element instanceof STSTest) {
Layer0 L0 = Layer0.getInstance(graph);
TestsResource TESTS = TestsResource.getInstance(graph);
if (graph.isInstanceOf(root, TESTS.STSTest)) {
- String testName = graph.getRelatedValue2(root, L0.HasName, Bindings.STRING);
- String definition = graph.getRelatedValue2(root, TESTS.STSTest_definition, Bindings.STRING);
- Integer executionPrioprity = graph.getRelatedValue2(root, TESTS.STSTest_executionPriority, Bindings.INTEGER);
- test = new STSTest(root, null, definition, testName, executionPrioprity);
+ test = new STSTest(STSSuiteTestCollector.toModelledTest(graph, root), null);
} else if (graph.isInstanceOf(root, TESTS.STSSuite)) {
- String suiteName = graph.getRelatedValue2(root, L0.HasName, Bindings.STRING);
- String moduleNameFilter = graph.getPossibleRelatedValue2(root, TESTS.STSSuite_moduleNameFilter, Bindings.STRING);
- suite = new STSSuite(root, suiteName, moduleNameFilter);
- List<STSTest> tests = new ArrayList<>();
- for (Resource test : graph.getObjects(root, L0.ConsistsOf)) {
- String testName = graph.getRelatedValue2(test, L0.HasName, Bindings.STRING);
- String definition = graph.getRelatedValue2(test, TESTS.STSTest_definition, Bindings.STRING);
- Integer executionPrioprity = graph.getRelatedValue2(test, TESTS.STSTest_executionPriority, Bindings.INTEGER);
- tests.add(new STSTest(test, suite, definition, testName, executionPrioprity));
- }
- Collections.sort(tests, (o1, o2) -> {
- if (o1.priority < o2.priority)
- return -1;
- else if (o1.priority > o2.priority)
- return 1;
- else return AlphanumComparator.COMPARATOR.compare(o1.name, o2.name);
- });
- suite.children(tests.toArray(new STSTest[tests.size()]));
+ List<ModelledSTSTest> tests = new ArrayList<>();
+ for (Resource test : graph.getObjects(root, L0.ConsistsOf))
+ tests.add(STSSuiteTestCollector.toModelledTest(graph, test));
+
+ suite = new STSSuite(STSSuiteTestCollector.toModelledSuite(graph, root, tests));
} else {
throw new IllegalArgumentException(root.toString());
}
}
public int getIgnoredCount() {
+ if (suite != null)
+ return suite.ignoredCount;
return 0;
}
Code Review / simantics / platform.git / blobdiff