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