org.argeo.slc.core/src/main/java/org/argeo/slc/core/test/tree/TreeTestResult.java

   1 package org.argeo.slc.core.test.tree;
   2
   3 import java.util.Date;
   4 import java.util.List;
   5 import java.util.Map;
   6 import java.util.SortedMap;
   7 import java.util.TreeMap;
   8 import java.util.Vector;
   9
  10 import org.apache.commons.logging.Log;
  11 import org.apache.commons.logging.LogFactory;
  12
  13 import org.argeo.slc.core.SlcException;
  14 import org.argeo.slc.core.structure.SimpleSElement;
  15 import org.argeo.slc.core.structure.StructureAware;
  16 import org.argeo.slc.core.structure.StructureElement;
  17 import org.argeo.slc.core.structure.StructureRegistry;
  18 import org.argeo.slc.core.structure.tree.TreeSPath;
  19 import org.argeo.slc.core.test.TestResult;
  20 import org.argeo.slc.core.test.TestResultListener;
  21 import org.argeo.slc.core.test.TestResultPart;
  22 import org.argeo.slc.core.test.TestRun;
  23 import org.argeo.slc.core.test.TestRunAware;
  24
  25 /**
  26  * Complex implementation of a test result compatible with a tree based
  27  * structure.
  28  */
  29 public class TreeTestResult implements TestResult, StructureAware<TreeSPath>,
  30                 Comparable<TreeTestResult> {
  31         private Log log = LogFactory.getLog(TreeTestResult.class);
  32
  33         private List<TestResultListener<TreeTestResult>> listeners = new Vector<TestResultListener<TreeTestResult>>();
  34
  35         private TreeSPath currentPath;
  36         private TestRun currentTestRun;
  37
  38         private Map<String, String> rootTags = new TreeMap<String, String>();
  39
  40         private Date closeDate;
  41
  42         private boolean isClosed = false;
  43
  44         private String uuid;
  45
  46         private SortedMap<TreeSPath, PartSubList> resultParts = new TreeMap<TreeSPath, PartSubList>();
  47         private SortedMap<TreeSPath, StructureElement> elements = new TreeMap<TreeSPath, StructureElement>();
  48
  49         /** Sets the list of listeners. */
  50         public void setListeners(List<TestResultListener<TreeTestResult>> listeners) {
  51                 this.listeners = listeners;
  52         }
  53
  54         public void addResultPart(TestResultPart part) {
  55                 if (currentPath == null) {
  56                         throw new SlcException("No current path set.");
  57                 }
  58                 PartSubList subList = resultParts.get(currentPath);
  59                 if (subList == null) {
  60                         subList = new PartSubList();
  61                         resultParts.put(currentPath, subList);
  62                 }
  63                 if (part instanceof TestRunAware && currentTestRun != null) {
  64                         ((TestRunAware) part).notifyTestRun(currentTestRun);
  65                 }
  66                 subList.getParts().add(part);
  67
  68                 // notify listeners
  69                 synchronized (listeners) {
  70                         for (TestResultListener<TreeTestResult> listener : listeners) {
  71                                 listener.resultPartAdded(this, part);
  72                         }
  73                 }
  74         }
  75
  76         public void notifyCurrentPath(StructureRegistry<TreeSPath> registry,
  77                         TreeSPath path) {
  78                 if (registry != null) {
  79                         for (TreeSPath p : path.getHierarchyAsList()) {
  80                                 if (!elements.containsKey(p)) {
  81                                         StructureElement elem = registry.getElement(p);
  82                                         if (elem != null) {
  83
  84                                                 if(elements.size()==0 && (elem instanceof SimpleSElement)){
  85                                                         SimpleSElement sElem = ((SimpleSElement)elem).clone();
  86                                                         sElem.getTags().putAll(rootTags);
  87                                                         elem = sElem;
  88                                                 }
  89
  90                                                 elements.put(p, elem);
  91                                         }
  92                                 } else {
  93                                         if (log.isTraceEnabled())
  94                                                 log.trace("An element is already registered for path "
  95                                                                 + p + " and was not updated");
  96                                 }
  97
  98                         }
  99                 }
 100
 101                 currentPath = (TreeSPath) path;
 102         }
 103
 104         /** Gets the current path. */
 105         public TreeSPath getCurrentPath() {
 106                 return currentPath;
 107         }
 108
 109         /** Gets all the results structured as a map of <code>PartSubList<code>s. */
 110         public SortedMap<TreeSPath, PartSubList> getResultParts() {
 111                 return resultParts;
 112         }
 113
 114         /** Used by ORM systems. */
 115         void setResultParts(SortedMap<TreeSPath, PartSubList> resultParts) {
 116                 this.resultParts = resultParts;
 117         }
 118
 119         public void close() {
 120                 if (isClosed) {
 121                         throw new SlcException("Test Result #" + getUuid()
 122                                         + " alredy closed.");
 123                 }
 124                 closeDate = new Date();
 125
 126                 synchronized (listeners) {
 127                         for (TestResultListener<TreeTestResult> listener : listeners) {
 128                                 listener.close(this);
 129                         }
 130                         listeners.clear();
 131                 }
 132                 isClosed = true;
 133
 134                 log.info("Test Result #" + getUuid() + " closed.");
 135         }
 136
 137         public Date getCloseDate() {
 138                 return closeDate;
 139         }
 140
 141         /** Sets the close date (for ORM) */
 142         public void setCloseDate(Date closeDate) {
 143                 this.closeDate = closeDate;
 144         }
 145
 146         public void notifyTestRun(TestRun testRun) {
 147                 currentTestRun = testRun;
 148         }
 149
 150         public SortedMap<TreeSPath, StructureElement> getElements() {
 151                 return elements;
 152         }
 153
 154         public void setElements(SortedMap<TreeSPath, StructureElement> pathNames) {
 155                 this.elements = pathNames;
 156         }
 157
 158         public String getUuid() {
 159                 return uuid;
 160         }
 161
 162         public void setUuid(String uuid) {
 163                 this.uuid = uuid;
 164         }
 165
 166         public SortedMap<TreeSPath, StructureElement> getRelatedElements(
 167                         TreeSPath path) {
 168                 SortedMap<TreeSPath, StructureElement> relatedElements = new TreeMap<TreeSPath, StructureElement>();
 169                 List<TreeSPath> hierarchy = path.getHierarchyAsList();
 170                 for (TreeSPath currPath : elements.keySet()) {
 171                         if (hierarchy.contains(currPath)) {
 172                                 relatedElements.put(currPath, elements.get(currPath));
 173                         }
 174                 }
 175                 return relatedElements;
 176         }
 177
 178         public TestRun getCurrentTestRun() {
 179                 return currentTestRun;
 180         }
 181
 182         public int compareTo(TreeTestResult ttr2) {
 183                 TreeTestResult ttr1 = this;
 184                 if (ttr1.getCloseDate() != null && ttr2.getCloseDate() != null) {
 185                         return -ttr1.getCloseDate().compareTo(ttr2.getCloseDate());
 186                 } else if (ttr1.getCloseDate() != null && ttr2.getCloseDate() == null) {
 187                         return 1;
 188                 } else if (ttr1.getCloseDate() == null && ttr2.getCloseDate() != null) {
 189                         return -1;
 190                 } else {
 191                         return ttr1.getUuid().compareTo(ttr2.getUuid());
 192                 }
 193         }
 194
 195         public Map<String, String> getRootTags() {
 196                 return rootTags;
 197         }
 198
 199         public void setRootTags(Map<String, String> rootTags) {
 200                 this.rootTags = rootTags;
 201         }
 202
 203 }