Lines Matching refs:self
101 def __init__(self, cases, flaky_tests_mode, measure_flakiness):
102 self.cases = cases
103 self.serial_id = 0
104 self.flaky_tests_mode = flaky_tests_mode
105 self.measure_flakiness = measure_flakiness
106 self.parallel_queue = Queue(len(cases))
107 self.sequential_queue = Queue(len(cases))
110 self.parallel_queue.put_nowait(case)
112 self.sequential_queue.put_nowait(case)
113 self.succeeded = 0
114 self.remaining = len(cases)
115 self.total = len(cases)
116 self.failed = [ ]
117 self.flaky_failed = [ ]
118 self.crashed = 0
119 self.lock = threading.Lock()
120 self.shutdown_event = threading.Event()
122 def GetFailureOutput(self, failure):
138 def PrintFailureOutput(self, failure):
139 print(self.GetFailureOutput(failure))
141 def PrintFailureHeader(self, test):
152 def Run(self, tasks) -> Dict:
153 self.Starting()
159 thread = threading.Thread(target=self.RunSingle, args=[True, i + 1])
163 self.RunSingle(False, 0)
169 self.shutdown_event.set()
173 self.shutdown_event.set()
176 self.Done()
178 'allPassed': not self.failed,
179 'failed': self.failed,
182 def RunSingle(self, parallel, thread_id):
183 while not self.shutdown_event.is_set():
185 test = self.parallel_queue.get_nowait()
190 test = self.sequential_queue.get_nowait()
195 self.lock.acquire()
196 case.serial_id = self.serial_id
197 self.serial_id += 1
198 self.AboutToRun(case)
199 self.lock.release()
214 if self.shutdown_event.is_set():
216 self.lock.acquire()
218 if FLAKY in output.test.outcomes and self.flaky_tests_mode == DONTCARE:
219 self.flaky_failed.append(output)
220 elif FLAKY in output.test.outcomes and self.flaky_tests_mode == KEEP_RETRYING:
223 self.flaky_failed.append(output)
227 self.failed.append(output)
229 self.failed.append(output)
231 self.crashed += 1
232 if self.measure_flakiness:
233 outputs = [case.Run() for _ in range(self.measure_flakiness)]
235 print(" failed %d out of %d" % (len([i for i in outputs if i.UnexpectedOutput()]) + 1, self.measure_flakiness + 1))
237 self.succeeded += 1
238 self.remaining -= 1
239 self.HasRun(output)
240 self.lock.release()
257 def Starting(self):
258 print('Running %i tests' % len(self.cases))
260 def Done(self):
262 for failed in self.failed:
263 self.PrintFailureHeader(failed.test)
264 self.PrintFailureOutput(failed)
265 if len(self.failed) == 0:
272 print("=== %i tests failed" % len(self.failed))
273 if self.crashed > 0:
274 print("=== %i tests CRASHED" % self.crashed)
280 def AboutToRun(self, case):
284 def HasRun(self, output):
297 def AboutToRun(self, case):
300 def HasRun(self, output):
301 total = self.succeeded + len(self.failed)
319 def GetAnnotationInfo(self, test, output):
329 def PrintFailureOutput(self, failure):
330 output = self.GetFailureOutput(failure)
331 filename, line, column = self.GetAnnotationInfo(failure.test, failure.output)
336 def _printDiagnostic(self):
337 logger.info(' severity: %s', self.severity)
338 self.exitcode and logger.info(' exitcode: %s', self.exitcode)
341 for l in self.traceback.splitlines():
344 def Starting(self):
346 logger.info('1..%i' % len(self.cases))
347 self._done = 0
349 def AboutToRun(self, case):
352 def HasRun(self, output):
353 self._done += 1
354 self.traceback = ''
355 self.severity = 'ok'
356 self.exitcode = ''
366 status_line = 'not ok %i %s' % (self._done, command)
367 self.severity = 'fail'
368 self.exitcode = output.output.exit_code
369 self.traceback = output.output.stdout + output.output.stderr
371 if FLAKY in output.test.outcomes and self.flaky_tests_mode == DONTCARE:
373 self.severity = 'flaky'
378 self.severity = 'crashed'
381 self.severity = 'fail'
387 'ok %i %s # skip %s' % (self._done, command, skip.group(1)))
389 status_line = 'ok %i %s' % (self._done, command)
395 self.severity = 'ok'
397 self.traceback = '\n'.join(output.diagnostic)
399 self.traceback = output.diagnostic
405 if self.severity != 'ok' or self.traceback != '':
407 self.traceback = 'timeout\n' + output.output.stdout + output.output.stderr
408 self._printDiagnostic()
411 def Done(self):
416 def Starting(self):
419 def AboutToRun(self, case):
422 def HasRun(self, output):
440 self.failed.append(output)
443 def Done(self):
449 def __init__(self, cases, flaky_tests_mode, measure_flakiness, templates):
450 super(CompactProgressIndicator, self).__init__(cases, flaky_tests_mode, measure_flakiness)
451 self.templates = templates
452 self.last_status_length = 0
453 self.start_time = time.time()
455 def Starting(self):
458 def Done(self):
459 self.PrintProgress('Done\n')
461 def AboutToRun(self, case):
462 self.PrintProgress(case.GetLabel())
464 def HasRun(self, output):
466 self.ClearLine(self.last_status_length)
467 self.PrintFailureHeader(output.test)
470 print(self.templates['stdout'] % stdout)
473 print(self.templates['stderr'] % stderr)
481 def Truncate(self, str, length):
487 def PrintProgress(self, name):
488 self.ClearLine(self.last_status_length)
489 elapsed = time.time() - self.start_time
490 status = self.templates['status_line'] % {
491 'passed': self.succeeded,
492 'remaining': (((self.total - self.remaining) * 100) // self.total),
493 'failed': len(self.failed),
498 status = self.Truncate(status, 78)
499 self.last_status_length = len(status)
506 def __init__(self, cases, flaky_tests_mode, measure_flakiness):
512 super(ColorProgressIndicator, self).__init__(cases, flaky_tests_mode, measure_flakiness, templates)
514 def ClearLine(self, last_line_length):
520 def __init__(self, cases, flaky_tests_mode, measure_flakiness):
528 super(MonochromeProgressIndicator, self).__init__(cases, flaky_tests_mode, measure_flakiness, templates)
530 def ClearLine(self, last_line_length):
552 def __init__(self, exit_code, timed_out, stdout, stderr):
553 self.exit_code = exit_code
554 self.timed_out = timed_out
555 self.stdout = stdout
556 self.stderr = stderr
557 self.failed = None
562 def __init__(self, context, path, arch, mode):
563 self.path = path
564 self.context = context
565 self.duration = None
566 self.arch = arch
567 self.mode = mode
568 self.parallel = False
569 self.disable_core_files = False
570 self.serial_id = 0
571 self.thread_id = 0
573 def IsNegative(self):
574 return self.context.expect_fail
576 def DidFail(self, output):
578 output.failed = self.IsFailureOutput(output)
581 def IsFailureOutput(self, output):
584 def GetSource(self):
587 def RunCommand(self, command, env):
588 full_command = self.context.processor(command)
590 self.context,
591 self.context.GetTimeout(self.mode, self.config.section),
593 disable_core_files = self.disable_core_files)
594 return TestOutput(self,
597 self.context.store_unexpected_output)
599 def Run(self):
601 result = self.RunCommand(self.GetCommand(), {
602 "TEST_SERIAL_ID": "%d" % self.serial_id,
603 "TEST_THREAD_ID": "%d" % self.thread_id,
604 "TEST_PARALLEL" : "%d" % self.parallel
621 def __init__(self, test, command, output, store_unexpected_output):
622 self.test = test
623 self.command = command
624 self.output = output
625 self.store_unexpected_output = store_unexpected_output
626 self.diagnostic = []
628 def UnexpectedOutput(self):
629 if self.HasCrashed():
631 elif self.HasTimedOut():
633 elif self.HasFailed():
637 return not outcome in self.test.outcomes
639 def HasCrashed(self):
641 return 0x80000000 & self.output.exit_code and not (0x3FFFFF00 & self.output.exit_code)
644 if self.output.timed_out:
646 return self.output.exit_code < 0
648 def HasTimedOut(self):
649 return self.output.timed_out
651 def HasFailed(self):
652 execution_failed = self.test.DidFail(self.output)
653 if self.test.IsNegative():
812 def __init__(self, context, root, section):
813 self.context = context
814 self.root = root
815 self.section = section
817 def Contains(self, path, file):
825 def GetTestStatus(self, sections, defs):
826 status_file = join(self.root, '%s.status' % self.section)
833 def __init__(self, name):
834 self.name = name
836 def GetName(self):
837 return self.name
842 def __init__(self, path):
844 super(TestRepository, self).__init__(basename(normalized_path))
845 self.path = normalized_path
846 self.is_loaded = False
847 self.config = None
849 def GetConfiguration(self, context):
850 if self.is_loaded:
851 return self.config
852 self.is_loaded = True
854 module = get_module('testcfg', self.path)
855 self.config = module.GetConfiguration(context, self.path)
856 if hasattr(self.config, 'additional_flags'):
857 self.config.additional_flags += context.node_args
859 self.config.additional_flags = context.node_args
860 return self.config
862 def GetBuildRequirements(self, path, context):
863 return self.GetConfiguration(context).GetBuildRequirements()
865 def AddTestsToList(self, result, current_path, path, context, arch, mode):
866 tests = self.GetConfiguration(context).ListTests(current_path, path,
872 def GetTestStatus(self, context, sections, defs):
873 self.GetConfiguration(context).GetTestStatus(sections, defs)
877 def __init__(self, tests_repos, test_root):
878 super(LiteralTestSuite, self).__init__('root')
879 self.tests_repos = tests_repos
880 self.test_root = test_root
882 def GetBuildRequirements(self, path, context):
885 for test in self.tests_repos:
890 def ListTests(self, current_path, path, context, arch, mode):
893 for test in self.tests_repos:
901 def GetTestStatus(self, context, sections, defs):
903 root = TestConfiguration(context, self.test_root, 'root')
905 for tests_repos in self.tests_repos:
919 def __init__(self, workspace, verbose, vm, args, expect_fail,
922 self.workspace = workspace
923 self.verbose = verbose
924 self.vm = vm
925 self.node_args = args
926 self.expect_fail = expect_fail
927 self.timeout = timeout
928 self.processor = processor
929 self.suppress_dialogs = suppress_dialogs
930 self.store_unexpected_output = store_unexpected_output
931 self.repeat = repeat
932 self.abort_on_timeout = abort_on_timeout
933 self.v8_enable_inspector = True
934 self.node_has_crypto = True
936 def GetVm(self, arch, mode):
937 if self.vm is not None:
938 return self.vm
957 def GetTimeout(self, mode, section=''):
958 timeout = self.timeout * TIMEOUT_SCALEFACTOR[ARCH_GUESS or 'ia32'][mode]
996 def __init__(self, value):
997 self.value = value
999 def Evaluate(self, env, defs):
1000 return self.value
1005 def __init__(self, name):
1006 self.name = name
1008 def GetOutcomes(self, env, defs):
1009 if self.name in env: return set([env[self.name]])
1015 def __init__(self, name):
1016 self.name = name
1018 def GetOutcomes(self, env, defs):
1019 if self.name in defs:
1020 return defs[self.name].GetOutcomes(env, defs)
1022 return set([self.name])
1027 def __init__(self, left, op, right):
1028 self.left = left
1029 self.op = op
1030 self.right = right
1032 def Evaluate(self, env, defs):
1033 if self.op == '||' or self.op == ',':
1034 return self.left.Evaluate(env, defs) or self.right.Evaluate(env, defs)
1035 elif self.op == 'if':
1037 elif self.op == '==':
1038 inter = self.left.GetOutcomes(env, defs) & self.right.GetOutcomes(env, defs)
1041 assert self.op == '&&'
1042 return self.left.Evaluate(env, defs) and self.right.Evaluate(env, defs)
1044 def GetOutcomes(self, env, defs):
1045 if self.op == '||' or self.op == ',':
1046 return self.left.GetOutcomes(env, defs) | self.right.GetOutcomes(env, defs)
1047 elif self.op == 'if':
1048 if self.right.Evaluate(env, defs):
1049 return self.left.GetOutcomes(env, defs)
1053 assert self.op == '&&'
1054 return self.left.GetOutcomes(env, defs) & self.right.GetOutcomes(env, defs)
1068 def __init__(self, expr):
1069 self.index = 0
1070 self.expr = expr
1071 self.length = len(expr)
1072 self.tokens = None
1074 def Current(self, length = 1):
1075 if not self.HasMore(length): return ""
1076 return self.expr[self.index:self.index+length]
1078 def HasMore(self, length = 1):
1079 return self.index < self.length + (length - 1)
1081 def Advance(self, count = 1):
1082 self.index = self.index + count
1084 def AddToken(self, token):
1085 self.tokens.append(token)
1087 def SkipSpaces(self):
1088 while self.HasMore() and self.Current().isspace():
1089 self.Advance()
1091 def Tokenize(self):
1092 self.tokens = [ ]
1093 while self.HasMore():
1094 self.SkipSpaces()
1095 if not self.HasMore():
1097 if self.Current() == '(':
1098 self.AddToken('(')
1099 self.Advance()
1100 elif self.Current() == ')':
1101 self.AddToken(')')
1102 self.Advance()
1103 elif self.Current() == '$':
1104 self.AddToken('$')
1105 self.Advance()
1106 elif self.Current() == ',':
1107 self.AddToken(',')
1108 self.Advance()
1109 elif IsAlpha(self.Current()):
1111 while self.HasMore() and IsAlpha(self.Current()):
1112 buf += self.Current()
1113 self.Advance()
1114 self.AddToken(buf)
1115 elif self.Current(2) == '&&':
1116 self.AddToken('&&')
1117 self.Advance(2)
1118 elif self.Current(2) == '||':
1119 self.AddToken('||')
1120 self.Advance(2)
1121 elif self.Current(2) == '==':
1122 self.AddToken('==')
1123 self.Advance(2)
1126 return self.tokens
1132 def __init__(self, tokens):
1133 self.tokens = tokens
1134 self.length = len(tokens)
1135 self.index = 0
1137 def HasMore(self):
1138 return self.index < self.length
1140 def Current(self):
1141 return self.tokens[self.index]
1143 def Advance(self):
1144 self.index = self.index + 1
1236 def __init__(self, sections, defs):
1237 self.sections = sections
1238 self.defs = defs
1240 def ClassifyTests(self, cases, env):
1241 sections = [ s for s in self.sections if s.condition.Evaluate(env, self.defs) ]
1247 outcomes_list = [ r.GetOutcomes(env, self.defs) for r in matches ]
1262 def __init__(self, condition):
1263 self.condition = condition
1264 self.rules = [ ]
1266 def AddRule(self, rule):
1267 self.rules.append(rule)
1274 def __init__(self, raw_path, path, value):
1275 self.raw_path = raw_path
1276 self.path = path
1277 self.value = value
1279 def GetOutcomes(self, env, defs):
1280 return self.value.GetOutcomes(env, defs)
1282 def Contains(self, path):
1283 if len(self.path) > len(path):
1285 for i in range(len(self.path)):
1286 if not self.path[i].match(path[i]):
1475 def __init__(self, pattern):
1476 self.pattern = pattern
1477 self.compiled = None
1479 def match(self, str):
1480 if not self.compiled:
1481 pattern = "^" + self.pattern.replace('*', '.*') + "$"
1482 self.compiled = re.compile(pattern)
1483 return self.compiled.match(str)
1485 def __str__(self):
1486 return self.pattern