def createXMLNode(self, doc, tc):
t = doc.createElement("test")
tn = doc.createElement("name")
t.appendChild(tn)
n = doc.createTextNode(str(tc.basename))
tn.appendChild(n)
ts = doc.createElement("state")
t.appendChild(ts)
tst = doc.createTextNode(str(xenrt.resultDisplay(self.overall)))
ts.appendChild(tst)
for reason in self.reasons:
tr = doc.createElement("reason")
t.appendChild(tr)
trt = doc.createTextNode(str(reason))
tr.appendChild(trt)
for perf in self.perfdata:
p, v, u = perf
tr = doc.createElement("value")
tr.setAttribute("param", str(p))
if u:
tr.setAttribute("units", str(u))
t.appendChild(tr)
trt = doc.createTextNode(str(v))
tr.appendChild(trt)
for gn in self.groupsOrder:
g = self.groups[gn]
gnode = g.createXMLNode(doc)
t.appendChild(gnode)
return t
def byPriority(self, countblocked=True, counterror=False, afispass=True,
debugfd=None):
"""Summarise results by test priority. Returns a list of pass
rates by priority [P1, P2, ...]
@param countblocked: if C{True} causes blocked tests to be counted as
failures.
@param counterror: if C{True} causes blocked tests to be counted as
failures.
@param afispass: if C{True} causes allowed failures to be counted
as passes (otherwise they get ignored)
"""
tests = []
passes = []
maxp = 0
for r in self.gather():
# For some reason we're leaking None priorities
if r[5] == None:
r[5] = 1
# Extend counter arrays for this priority level
if r[5] >= maxp:
for i in range(1 + r[5] - maxp):
tests.append(0)
passes.append(0)
maxp = r[5]
# Increment counters
if r[4] == xenrt.RESULT_PASS or r[4] == xenrt.RESULT_PARTIAL:
tests[r[5]] = tests[r[5]] + 1
passes[r[5]] = passes[r[5]] + 1
elif r[4] == xenrt.RESULT_FAIL:
tests[r[5]] = tests[r[5]] + 1
elif r[4] == xenrt.RESULT_ERROR and counterror:
tests[r[5]] = tests[r[5]] + 1
elif r[4] == xenrt.RESULT_NOTRUN and countblocked:
tests[r[5]] = tests[r[5]] + 1
elif r[4] == xenrt.RESULT_ALLOWED and afispass:
tests[r[5]] = tests[r[5]] + 1
passes[r[5]] = passes[r[5]] + 1
# Print per-test summary
if debugfd:
d = []
for x in r[0:4]:
if x:
d.append(x)
debugfd.write("%-40s P%u %s\n" % (string.join(d, "/"),
r[5],
xenrt.resultDisplay(r[4])))
reply = []
for i in range(len(tests)):
if i == 0:
continue
if tests[i] > 0:
r = 100.0 * float(passes[i])/tests[i]
#print "P%u %5u/%5u %5.1f" % (i, passes[i], tests[i], r)
reply.append(r)
else:
reply.append(None)
return reply
def aggregate(self, topgroup, toptest):
"""Declare the test outcome based on testcase results."""
passed = True
errored = False
counters = []
for i in range(len(xenrt.RESULTS)):
counters.append(0)
for gn in self.groupsOrder:
g = self.groups[gn]
r = g.aggregate(counters, topgroup, toptest, self)
if r != xenrt.RESULT_PASS:
passed = False
if r == xenrt.RESULT_ERROR:
errored = True
# If we've previously set an outcome then we don't change it now
if self.overall == xenrt.RESULT_UNKNOWN:
if passed:
self.overall = xenrt.RESULT_PASS
elif errored:
self.overall = xenrt.RESULT_ERROR
else:
self.overall = xenrt.RESULT_FAIL
# A failure/error should override a partial result
elif self.overall == xenrt.RESULT_PARTIAL and not passed:
if errored:
self.overall = xenrt.RESULT_ERROR
else:
self.overall = xenrt.RESULT_FAIL
# Check if the entire test is allowed to pass
for i in range(len(xenrt.RESULTS)):
xenrt.TEC().comment("Testcases %s %u" % (xenrt.resultDisplay(i),
counters[i]))
def createXMLNode(self, doc):
t = doc.createElement("test")
tn = doc.createElement("name")
t.appendChild(tn)
n = doc.createTextNode(str(self.name))
tn.appendChild(n)
ts = doc.createElement("state")
t.appendChild(ts)
tst = doc.createTextNode(str(xenrt.resultDisplay(self.result)))
ts.appendChild(tst)
if self.result == xenrt.RESULT_FAIL and self.allowed:
ts = doc.createElement("allowed")
t.appendChild(ts)
tst = doc.createTextNode("yes")
ts.appendChild(tst)
if self.log:
tl = doc.createElement("log")
t.appendChild(tl)
tlt = doc.createTextNode(str(self.log))
tl.appendChild(tlt)
for reason in self.reasons:
tr = doc.createElement("reason")
t.appendChild(tr)
trt = doc.createTextNode(str(reason))
tr.appendChild(trt)
return t
def summary(self, fd, topgroup, toptest):
notes = []
if self.result == xenrt.RESULT_FAIL:
if self.allowed:
notes.append("allowed")
n = "%s/%s" % (self.group.name, self.name)
if self.priority == None:
p = " "
else:
p = "P%u" % (self.priority)
fd.write(" %-28s %s %s %s\n" % (n,
xenrt.resultDisplay(self.result),
p,
string.join(notes)))
def summary(self, fd, topgroup, toptest):
notes = []
if self.overall == xenrt.RESULT_FAIL:
if self.allowed:
notes.append("allowed")
if topgroup == '':
n = toptest
else:
n = "%s/%s" % (topgroup, toptest)
fd.write("%-30s %s P%u %s\n" % (n,
xenrt.resultDisplay(self.overall),
self.priority,
string.join(notes)))
for gn in self.groupsOrder:
g = self.groups[gn]
g.summary(fd, topgroup, toptest)
def debugPrint(self, fd):
fd.write(" Test %-30s %s\n" %
(self.name, xenrt.resultDisplay(self.result)))
def debugPrint(self, fd):
fd.write(" Test %-30s %s\n" %
(self.name, xenrt.resultDisplay(self.result)))
