Enhancements to modelled tests
[simantics/platform.git] / bundles / org.simantics.tests.modelled / src / org / simantics / tests / modelled / utils / ModelledSTSSuite.java
1 package org.simantics.tests.modelled.utils;
2
3 import java.util.ArrayList;
4 import java.util.Comparator;
5 import java.util.HashSet;
6 import java.util.LinkedList;
7 import java.util.List;
8 import java.util.Map;
9 import java.util.Set;
10 import java.util.TreeMap;
11 import java.util.regex.Pattern;
12 import java.util.regex.PatternSyntaxException;
13
14 import org.simantics.scl.compiler.module.Module;
15 import org.simantics.scl.compiler.module.coverage.CombinedCoverage;
16 import org.simantics.scl.compiler.module.coverage.CoverageBuilder;
17 import org.simantics.utils.strings.AlphanumComparator;
18
19 public class ModelledSTSSuite {
20
21     private String name;
22     private List<ModelledSTSTest> children;
23     private String moduleNameFilter;
24     private List<Pattern> moduleNameFilterPatterns = new ArrayList<>();
25
26     private CoverageBuilder coverageBuilder;
27     private Map<String, String> variables;
28
29     ModelledSTSSuite(String name, List<ModelledSTSTest> children, String moduleNameFilter, Map<String, String> variables) {
30         this.name = name;
31         this.children = children;
32         this.variables = variables;
33         this.moduleNameFilter = moduleNameFilter;
34         for (String s : moduleNameFilter.split(",")) {
35             try {
36                 s = s.trim().replaceAll("\\*", "\\\\w*").toLowerCase();
37                 getModuleNameFilterPatterns().add(Pattern.compile(s));
38             } catch (PatternSyntaxException e) {
39                 e.printStackTrace();
40             }
41         }
42     }
43
44     public String getName() {
45         return name;
46     }
47
48     public List<ModelledSTSTest> getChildren() {
49         return children;
50     }
51
52     static Comparator<ModelledSTSTest> comparator = (test1, test2) -> compareTests(test1, test2);
53     
54     public List<ModelledSTSTest> getSortedChildren() {
55         Set<ModelledSTSTest> testsWithDeps = new HashSet<>();
56         // This TreeMap sorts the tests with the comparator 
57         TreeMap<ModelledSTSTest, String> sortedTests = new TreeMap<>(comparator);
58         for (ModelledSTSTest test : getChildren()) {
59             Set<String> testDependencies = test.getDependencies();
60             if (testDependencies.isEmpty()) {
61                 // First tests that have no dependencies
62                 sortedTests.put(test, test.getName());
63             } else {
64                 // These are resolved later
65                 testsWithDeps.add(test);
66             }
67         }
68         
69         // Construct a LinkedList that is returned as a result
70         LinkedList<ModelledSTSTest> results = new LinkedList<>(sortedTests.keySet());
71         
72 //        Set<ModelledSTSTest> temp = new HashSet<>(testsWithDeps);
73         // Now resolve tests with dependencies
74         for (ModelledSTSTest testWithDep : testsWithDeps) {
75             boolean satisfied = true;
76             for (String dep : testWithDep.getDependencies()) {
77                 if (!sortedTests.containsValue(dep)) {
78                     satisfied = false;
79                 } else {
80                     testWithDep.resolveDependency(dep);
81                 }
82             }
83             if (satisfied) {
84                 results.addLast(testWithDep);
85                 sortedTests.put(testWithDep, testWithDep.getName());
86             } else {
87                 // Not satisfied
88                 System.out.println(testWithDep.getName() + " not satisfied");
89             }
90         }
91         return results;
92     }
93
94     private static int compareTests(ModelledSTSTest test1, ModelledSTSTest test2) {
95         if (test1.getPriority() < test2.getPriority())
96             return -1;
97         else if (test1.getPriority() > test2.getPriority())
98             return 1;
99         else
100             return AlphanumComparator.COMPARATOR.compare(test1.getName(), test2.getName());
101     }
102
103     public String getModuleNameFilter() {
104         return moduleNameFilter;
105     }
106
107     public void addCoverage(List<Module> modules) {
108         if (coverageBuilder == null)
109             coverageBuilder = new CoverageBuilder();
110         for (Module module : modules)
111             coverageBuilder.addCoverage(module, true);
112     }
113
114     public CombinedCoverage getCoverage() {
115         if (coverageBuilder == null)
116             return null;
117         return coverageBuilder.getCoverage();
118     }
119
120     public List<Pattern> getModuleNameFilterPatterns() {
121         return moduleNameFilterPatterns;
122     }
123
124 }