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 }