Lines Matching full:self
57 def __init__(self, cases):
58 self.cases = cases
59 self.queue = Queue(len(cases))
61 self.queue.put_nowait(case)
62 self.succeeded = 0
63 self.remaining = len(cases)
64 self.total = len(cases)
65 self.failed = [ ]
66 self.crashed = 0
67 self.terminate = False
68 self.lock = threading.Lock()
70 def PrintFailureHeader(self, test):
81 def Run(self, tasks):
82 self.Starting()
88 thread = threading.Thread(target=self.RunSingle, args=[])
92 self.RunSingle()
100 self.terminate = True
103 self.Done()
104 return not self.failed
106 def RunSingle(self):
107 while not self.terminate:
109 test = self.queue.get_nowait()
113 self.lock.acquire()
114 self.AboutToRun(case)
115 self.lock.release()
121 assert self.terminate
123 if self.terminate:
125 self.lock.acquire()
127 self.failed.append(output)
129 self.crashed += 1
131 self.succeeded += 1
132 self.remaining -= 1
133 self.HasRun(output)
134 self.lock.release()
151 def Starting(self):
152 print 'Running %i tests' % len(self.cases)
154 def Done(self):
156 for failed in self.failed:
157 self.PrintFailureHeader(failed.test)
169 if len(self.failed) == 0:
176 print "=== %i tests failed" % len(self.failed)
177 if self.crashed > 0:
178 print "=== %i tests CRASHED" % self.crashed
184 def AboutToRun(self, case):
188 def HasRun(self, output):
201 def AboutToRun(self, case):
204 def HasRun(self, output):
205 total = self.succeeded + len(self.failed)
225 def __init__(self, cases, templates):
226 super(CompactProgressIndicator, self).__init__(cases)
227 self.templates = templates
228 self.last_status_length = 0
229 self.start_time = time.time()
231 def Starting(self):
234 def Done(self):
235 self.PrintProgress('Done')
237 def AboutToRun(self, case):
238 self.PrintProgress(case.GetLabel())
240 def HasRun(self, output):
242 self.ClearLine(self.last_status_length)
243 self.PrintFailureHeader(output.test)
246 print self.templates['stdout'] % stdout
249 print self.templates['stderr'] % stderr
256 def Truncate(self, str, length):
262 def PrintProgress(self, name):
263 self.ClearLine(self.last_status_length)
264 elapsed = time.time() - self.start_time
265 status = self.templates['status_line'] % {
266 'passed': self.succeeded,
267 'remaining': (((self.total - self.remaining) * 100) // self.total),
268 'failed': len(self.failed),
273 status = self.Truncate(status, 78)
274 self.last_status_length = len(status)
281 def __init__(self, cases):
287 super(ColorProgressIndicator, self).__init__(cases, templates)
289 def ClearLine(self, last_line_length):
295 def __init__(self, cases):
303 super(MonochromeProgressIndicator, self).__init__(cases, templates)
305 def ClearLine(self, last_line_length):
324 def __init__(self, exit_code, timed_out, stdout, stderr):
325 self.exit_code = exit_code
326 self.timed_out = timed_out
327 self.stdout = stdout
328 self.stderr = stderr
329 self.failed = None
334 def __init__(self, context, path):
335 self.path = path
336 self.context = context
337 self.duration = None
339 def IsNegative(self):
342 def CompareTime(self, other):
343 return cmp(other.duration, self.duration)
345 def DidFail(self, output):
347 output.failed = self.IsFailureOutput(output)
350 def IsFailureOutput(self, output):
353 def GetSource(self):
356 def RunCommand(self, command):
357 full_command = self.context.processor(command)
358 output = Execute(full_command, self.context, self.context.timeout)
359 self.Cleanup()
360 return TestOutput(self, full_command, output)
362 def BeforeRun(self):
365 def AfterRun(self):
368 def Run(self):
369 self.BeforeRun()
371 result = self.RunCommand(self.GetCommand())
373 self.AfterRun()
376 def Cleanup(self):
382 def __init__(self, test, command, output):
383 self.test = test
384 self.command = command
385 self.output = output
387 def UnexpectedOutput(self):
388 if self.HasCrashed():
390 elif self.HasTimedOut():
392 elif self.HasFailed():
396 return not outcome in self.test.outcomes
398 def HasCrashed(self):
400 return 0x80000000 & self.output.exit_code and not (0x3FFFFF00 & self.output.exit_code)
403 if self.output.timed_out:
405 return self.output.exit_code < 0 and \
406 self.output.exit_code != -signal.SIGABRT
408 def HasTimedOut(self):
409 return self.output.timed_out;
411 def HasFailed(self):
412 execution_failed = self.test.DidFail(self.output)
413 if self.test.IsNegative():
535 def __init__(self, context, root):
536 self.context = context
537 self.root = root
539 def Contains(self, path, file):
547 def GetTestStatus(self, sections, defs):
553 def __init__(self, name):
554 self.name = name
556 def GetName(self):
557 return self.name
562 def __init__(self, path):
564 super(TestRepository, self).__init__(basename(normalized_path))
565 self.path = normalized_path
566 self.is_loaded = False
567 self.config = None
569 def GetConfiguration(self, context):
570 if self.is_loaded:
571 return self.config
572 self.is_loaded = True
575 (file, pathname, description) = imp.find_module('testcfg', [ self.path ])
577 self.config = module.GetConfiguration(context, self.path)
581 return self.config
583 def GetBuildRequirements(self, path, context):
584 return self.GetConfiguration(context).GetBuildRequirements()
586 def ListTests(self, current_path, path, context, mode):
587 return self.GetConfiguration(context).ListTests(current_path, path, mode)
589 def GetTestStatus(self, context, sections, defs):
590 self.GetConfiguration(context).GetTestStatus(sections, defs)
595 def __init__(self
596 super(LiteralTestSuite, self).__init__('root')
597 self.tests = tests
599 def GetBuildRequirements(self, path, context):
602 for test in self.tests:
607 def ListTests(self, current_path, path, context, mode):
610 for test in self.tests:
617 def GetTestStatus(self, context, sections, defs):
618 for test in self.tests:
627 def __init__(self, workspace, buildspace, verbose, vm, timeout, processor, suppress_dialogs):
628 self.workspace = workspace
629 self.buildspace = buildspace
630 self.verbose = verbose
631 self.vm_root = vm
632 self.timeout = timeout
633 self.processor = processor
634 self.suppress_dialogs = suppress_dialogs
636 def GetVm(self, mode):
637 name = self.vm_root + SUFFIX[mode]
675 def __init__(self, value):
676 self.value = value
678 def Evaluate(self, env, defs):
679 return self.value
684 def __init__(self, name):
685 self.name = name
687 def GetOutcomes(self, env, defs):
688 if self.name in env: return ListSet([env[self.name]])
694 def __init__(self, name):
695 self.name = name
697 def GetOutcomes(self, env, defs):
698 if self.name in defs:
699 return defs[self.name].GetOutcomes(env, defs)
701 return ListSet([self.name])
710 def __init__(self, elms):
711 self.elms = elms
713 def __str__(self):
714 return "ListSet%s" % str(self.elms)
716 def Intersect(self, that):
718 return that.Intersect(self)
719 return ListSet([ x for x in self.elms if x in that.elms ])
721 def Union(self, that):
723 return that.Union(self)
724 return ListSet(self.elms + [ x for x in that.elms if x not in self.elms ])
726 def IsEmpty(self):
727 return len(self.elms) == 0
732 def Intersect(self, that):
735 def Union(self, that):
736 return self
738 def IsEmpty(self):
744 def Intersect(self, that):
745 return self
747 def Union(self, that):
750 def IsEmpty(self):
756 def __init__(self, left, op, right):
757 self.left = left
758 self.op = op
759 self.right = right
761 def Evaluate(self, env, defs):
762 if self.op == '||' or self.op == ',':
763 return self.left.Evaluate(env, defs) or self.right.Evaluate(env, defs)
764 elif self.op == 'if':
766 elif self.op == '==':
767 inter = self.left.GetOutcomes(env, defs).Intersect(self.right.GetOutcomes(env, defs))
770 assert self.op == '&&'
771 return self.left.Evaluate(env, defs) and self.right.Evaluate(env, defs)
773 def GetOutcomes(self, env, defs):
774 if self.op == '||' or self.op == ',':
775 return self.left.GetOutcomes(env, defs).Union(self.right.GetOutcomes(env, defs))
776 elif self.op == 'if':
777 if self.right.Evaluate(env, defs): return self.left.GetOutcomes(env, defs)
780 assert self.op == '&&'
781 return self.left.GetOutcomes(env, defs).Intersect(self.right.GetOutcomes(env, defs))
795 def __init__(self, expr):
796 self.index = 0
797 self.expr = expr
798 self.length = len(expr)
799 self.tokens = None
801 def Current(self, length = 1):
802 if not self.HasMore(length): return ""
803 return self.expr[self.index:self.index+length]
805 def HasMore(self, length = 1):
806 return self.index < self.length + (length - 1)
808 def Advance(self, count = 1):
809 self.index = self.index + count
811 def AddToken(self, token):
812 self.tokens.append(token)
814 def SkipSpaces(self):
815 while self.HasMore() and self.Current().isspace():
816 self.Advance()
818 def Tokenize(self):
819 self.tokens = [ ]
820 while self.HasMore():
821 self.SkipSpaces()
822 if not self.HasMore():
824 if self.Current() == '(':
825 self.AddToken('(')
826 self.Advance()
827 elif self.Current() == ')':
828 self.AddToken(')')
829 self.Advance()
830 elif self.Current() == '$':
831 self.AddToken('$')
832 self.Advance()
833 elif self.Current() == ',':
834 self.AddToken(',')
835 self.Advance()
836 elif IsAlpha(self.Current()):
838 while self.HasMore() and IsAlpha(self.Current()):
839 buf += self.Current()
840 self.Advance()
841 self.AddToken(buf)
842 elif self.Current(2) == '&&':
843 self.AddToken('&&')
844 self.Advance(2)
845 elif self.Current(2) == '||':
846 self.AddToken('||')
847 self.Advance(2)
848 elif self.Current(2) == '==':
849 self.AddToken('==')
850 self.Advance(2)
853 return self.tokens
859 def __init__(self, tokens):
860 self.tokens = tokens
861 self.length = len(tokens)
862 self.index = 0
864 def HasMore(self):
865 return self.index < self.length
867 def Current(self):
868 return self.tokens[self.index]
870 def Advance(self):
871 self.index = self.index + 1
962 def __init__(self, case, outcomes):
963 self.case = case
964 self.outcomes = outcomes
970 def __init__(self, sections, defs):
971 self.sections = sections
972 self.defs = defs
974 def ClassifyTests(self, cases, env):
975 sections = [s for s in self.sections if s.condition.Evaluate(env, self.defs)]
984 outcomes = outcomes.union(rule.GetOutcomes(env, self.defs))
998 def __init__(self, condition):
999 self.condition = condition
1000 self.rules = [ ]
1002 def AddRule(self, rule):
1003 self.rules.append(rule)
1010 def __init__(self, raw_path, path, value):
1011 self.raw_path = raw_path
1012 self.path = path
1013 self.value = value
1015 def GetOutcomes(self, env, defs):
1016 set = self.value.GetOutcomes(env, defs)
1020 def Contains(self, path):
1021 if len(self.path) > len(path):
1023 for i in xrange(len(self.path)):
1024 if not self.path[i].match(path[i]):
1184 def __init__(self, pattern):
1185 self.pattern = pattern
1186 self.compiled = None
1188 def match(self, str):
1189 if not self.compiled:
1190 pattern = "^" + self.pattern.replace('*', '.*') + "$"
1191 self.compiled = re.compile(pattern)
1192 return self.compiled.match(str)
1194 def __str__(self):
1195 return self.pattern
