def _huntLeaks(self, test): self.stream.flush() repcount = self.repetitions nwarmup = self.warmup rc_deltas = [0] * (repcount - nwarmup) alloc_deltas = [0] * (repcount - nwarmup) # Preallocate ints likely to be stored in rc_deltas and alloc_deltas, # to make sys.getallocatedblocks() less flaky. _int_pool = IntPool() for i in range(-200, 200): _int_pool[i] alloc_before = rc_before = 0 for i in range(repcount): # Use a pristine, silent result object to avoid recursion res = result.TestResult() test.run(res) # Poorly-written tests may fail when run several times. # In this case, abort the refleak run and report the failure. if not res.wasSuccessful(): self.failures.extend(res.failures) self.errors.extend(res.errors) raise AssertionError del res alloc_after, rc_after = _refleak_cleanup() if i >= nwarmup: rc_deltas[i - nwarmup] = _int_pool[rc_after - rc_before] alloc_deltas[i - nwarmup] = _int_pool[alloc_after - alloc_before] alloc_before, rc_before = alloc_after, rc_after return rc_deltas, alloc_deltas
def generateAmpPages(): if not os.path.exists('amp/generated'): os.makedirs('amp/generated/') test = TestEvent() test.testbed = testbed.Testbed() test.testbed.activate() r = result.TestResult() test.run(r) if r.errors or r.failures: logging.error('Error generating amp files:') for test, error in r.errors: logging.error('%s: %s', test, error) for test, fail in r.failures: logging.error('%s: %s', test, fail) raise Exception('Errors generating amp files!')
def test_request(self): """Run this request if it has not yet run. If there is a prior test in the sequence, run it first. """ if self.has_run: return if self.test_data['skip']: self.skipTest(self.test_data['skip']) if self.prior and not self.prior.has_run: # Use a different result so we don't count this test # in the results. self.prior.run(result.TestResult()) self._run_test()
def run_testcase(self, request, *args, **kwargs): instance = self.get_object() response = {} try: result = MyTestSuite(NeoRunner(), instance)(testresult.TestResult()) print(result) if result.errors: response.update( {'errors': data.errors[-1][-1].split('\n')[-2]}) if result.failures: response.update( {'failures': data.failures[-1][-1].split('\n')[-2]}) # name = data.get('name', None) # api = data.get('api', None) # request_header = data.get('request_header', None) # request_body = data.get('request_body', None) # response_header = data.get('response_header', None) # response_body = data.get('response_body', None) # elapsed_time = data.get('elapsed_time', None) # content_length = data.get('content_length', None) # result = data.get('result', None) # # response = {'name': name, 'api': api, 'request_header': request_header, 'request_body': request_body, # 'response_header': response_header, 'response_body': response_body, # 'elapsed_time': elapsed_time, # 'content_length': content_length, 'result': result} return Response(response, status=status.HTTP_201_CREATED) except HttpMethodError: self.errors = sysvalidate(self, Err_Http_02) return Response(self.errors, status=status.HTTP_405_METHOD_NOT_ALLOWED) except RequestException: self.errors = sysvalidate(self, Err_Http_01) return Response(self.errors, status=status.HTTP_400_BAD_REQUEST) except ValidationError as e: self.errors = sysvalidate(self, str(e)) return Response(self.errors, status=status.HTTP_400_BAD_REQUEST)
def defaultTestResult(self): return result.TestResult()
def __init__(self, methodName='runTest'): self.retry_count = 2 self._result = result.TestResult() super(RetryTestCase, self).__init__(methodName)