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