X-Git-Url: http://git.argeo.org/?a=blobdiff_plain;f=org.argeo.slc.core%2Fsrc%2Fmain%2Fjava%2Forg%2Fargeo%2Fslc%2Fcore%2Ftest%2Ftree%2FTreeTestResult.java;h=f34561a9e3b33881d2bd9c425f2d7990b2795132;hb=7ffec52c590ce511b476f55be4ad123418268aa0;hp=3124b055fcb3339c3aff75c241faa58cd6dfcd91;hpb=faf680e212bf3e18837c4f798587856e061273b3;p=gpl%2Fargeo-slc.git diff --git a/org.argeo.slc.core/src/main/java/org/argeo/slc/core/test/tree/TreeTestResult.java b/org.argeo.slc.core/src/main/java/org/argeo/slc/core/test/tree/TreeTestResult.java index 3124b055f..f34561a9e 100644 --- a/org.argeo.slc.core/src/main/java/org/argeo/slc/core/test/tree/TreeTestResult.java +++ b/org.argeo.slc.core/src/main/java/org/argeo/slc/core/test/tree/TreeTestResult.java @@ -2,6 +2,7 @@ package org.argeo.slc.core.test.tree; import java.util.Date; import java.util.List; +import java.util.Map; import java.util.SortedMap; import java.util.TreeMap; import java.util.Vector; @@ -10,57 +11,43 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.argeo.slc.core.SlcException; +import org.argeo.slc.core.structure.SimpleSElement; import org.argeo.slc.core.structure.StructureAware; -import org.argeo.slc.core.structure.StructurePath; +import org.argeo.slc.core.structure.StructureElement; import org.argeo.slc.core.structure.StructureRegistry; import org.argeo.slc.core.structure.tree.TreeSPath; -import org.argeo.slc.core.test.NumericTRId; import org.argeo.slc.core.test.TestResult; -import org.argeo.slc.core.test.TestResultId; import org.argeo.slc.core.test.TestResultListener; import org.argeo.slc.core.test.TestResultPart; +import org.argeo.slc.core.test.TestRun; +import org.argeo.slc.core.test.TestRunAware; /** * Complex implementation of a test result compatible with a tree based * structure. */ -public class TreeTestResult implements TestResult, StructureAware { +public class TreeTestResult implements TestResult, StructureAware, + Comparable { private Log log = LogFactory.getLog(TreeTestResult.class); - /** For ORM */ - private Long tid; - private NumericTRId testResultId; - private List listeners = new Vector(); + private List> listeners = new Vector>(); private TreeSPath currentPath; + private TestRun currentTestRun; + + private Map rootTags = new TreeMap(); private Date closeDate; private boolean isClosed = false; - private SortedMap resultParts = new TreeMap(); - - private StructureRegistry registry; - - public TestResultId getTestResultId() { - return testResultId; - } - - /** - * Use of a NumericTRId is required by Hibernate. It may - * change in the future. - */ - public NumericTRId getNumericResultId() { - return testResultId; - } + private String uuid; - /** Sets the test result id as a numeric test result id. */ - public void setNumericResultId(NumericTRId testResultId) { - this.testResultId = testResultId; - } + private SortedMap resultParts = new TreeMap(); + private SortedMap elements = new TreeMap(); /** Sets the list of listeners. */ - public void setListeners(List listeners) { + public void setListeners(List> listeners) { this.listeners = listeners; } @@ -73,19 +60,47 @@ public class TreeTestResult implements TestResult, StructureAware { subList = new PartSubList(); resultParts.put(currentPath, subList); } + if (part instanceof TestRunAware && currentTestRun != null) { + ((TestRunAware) part).notifyTestRun(currentTestRun); + } subList.getParts().add(part); // notify listeners synchronized (listeners) { - for (TestResultListener listener : listeners) { + for (TestResultListener listener : listeners) { listener.resultPartAdded(this, part); } } } - public void notifyCurrentPath(StructureRegistry registry, StructurePath path) { + public void notifyCurrentPath(StructureRegistry registry, + TreeSPath path) { + if (registry != null) { + for (TreeSPath p : path.getHierarchyAsList()) { + if (!elements.containsKey(p)) { + StructureElement elem = registry.getElement(p); + if (elem != null) { + + if (elements.size() == 0 + && (elem instanceof SimpleSElement)) { + SimpleSElement sElem = ((SimpleSElement) elem) + .clone(); + sElem.getTags().putAll(rootTags); + elem = sElem; + } + + elements.put(p, elem); + } + } else { + if (log.isTraceEnabled()) + log.trace("An element is already registered for path " + + p + " and was not updated"); + } + + } + } + currentPath = (TreeSPath) path; - this.registry = registry; } /** Gets the current path. */ @@ -105,47 +120,87 @@ public class TreeTestResult implements TestResult, StructureAware { public void close() { if (isClosed) { - throw new SlcException("Test Result #" + getTestResultId() + throw new SlcException("Test Result #" + getUuid() + " alredy closed."); } closeDate = new Date(); synchronized (listeners) { - for (TestResultListener listener : listeners) { + for (TestResultListener listener : listeners) { listener.close(this); } listeners.clear(); } isClosed = true; - log.info("Test Result #" + getTestResultId() + " closed."); + if (log.isTraceEnabled()) + log.trace("Test Result " + getUuid() + " closed."); } - Long getTid() { - return tid; + public Date getCloseDate() { + return closeDate; } - void setTid(Long tid) { - this.tid = tid; + /** Sets the close date (for ORM) */ + public void setCloseDate(Date closeDate) { + this.closeDate = closeDate; } - /** Gets the related registry (can be null). */ - public StructureRegistry getRegistry() { - return registry; + public void notifyTestRun(TestRun testRun) { + currentTestRun = testRun; } - /** Sets the related registry. */ - public void setRegistry(StructureRegistry registry) { - this.registry = registry; + public SortedMap getElements() { + return elements; } - public Date getCloseDate() { - return closeDate; + public void setElements(SortedMap pathNames) { + this.elements = pathNames; } - /** Sets the close date (for ORM) */ - public void setCloseDate(Date closeDate) { - this.closeDate = closeDate; + public String getUuid() { + return uuid; + } + + public void setUuid(String uuid) { + this.uuid = uuid; + } + + public SortedMap getRelatedElements( + TreeSPath path) { + SortedMap relatedElements = new TreeMap(); + List hierarchy = path.getHierarchyAsList(); + for (TreeSPath currPath : elements.keySet()) { + if (hierarchy.contains(currPath)) { + relatedElements.put(currPath, elements.get(currPath)); + } + } + return relatedElements; + } + + public TestRun getCurrentTestRun() { + return currentTestRun; + } + + public int compareTo(TreeTestResult ttr2) { + TreeTestResult ttr1 = this; + if (ttr1.getCloseDate() != null && ttr2.getCloseDate() != null) { + return -ttr1.getCloseDate().compareTo(ttr2.getCloseDate()); + } else if (ttr1.getCloseDate() != null && ttr2.getCloseDate() == null) { + return 1; + } else if (ttr1.getCloseDate() == null && ttr2.getCloseDate() != null) { + return -1; + } else { + return ttr1.getUuid().compareTo(ttr2.getUuid()); + } + } + + public Map getRootTags() { + return rootTags; + } + + public void setRootTags(Map rootTags) { + this.rootTags = rootTags; } }