def testPassingMapScript(self):
events = [
{'pid': 1, 'tid': 2, 'ph': 'X', 'name': 'a', 'cat': 'c',
'ts': 0, 'dur': 10, 'args': {}},
{'pid': 1, 'tid': 2, 'ph': 'X', 'name': 'b', 'cat': 'c',
'ts': 3, 'dur': 5, 'args': {}}
]
trace_handle = file_handle.InMemoryFileHandle(
'/a.json', json.dumps(events))
results = results_module.Results()
with map_single_trace.TemporaryMapScript("""
pi.FunctionRegistry.register(
function MyMapFunction(results, model) {
var canonicalUrl = model.canonicalUrlThatCreatedThisTrace;
results.addValue(new tr.v.DictValue(
canonicalUrl,
'result', {
numProcesses: model.getAllProcesses().length
}));
});
""") as map_script:
map_single_trace.MapSingleTrace(results, trace_handle,
_Handle(map_script.filename))
self.assertFalse(results.failure_values)
v = results.FindValueNamed('result')
self.assertEquals(v['numProcesses'], 1)
def testMapperSkips(self):
events = [
{'pid': 1, 'tid': 2, 'ph': 'X', 'name': 'a', 'cat': 'c',
'ts': 0, 'dur': 10, 'args': {}},
{'pid': 1, 'tid': 2, 'ph': 'X', 'name': 'b', 'cat': 'c',
'ts': 3, 'dur': 5, 'args': {}}
]
trace_handle = file_handle.InMemoryFileHandle(
'/a.json', json.dumps(events))
results = results_module.Results()
with map_single_trace.TemporaryMapScript("""
pi.FunctionRegistry.register(
function MyMapFunction(results, model) {
var canonicalUrl = model.canonicalUrlThatCreatedThisTrace;
results.addValue(new tr.v.SkipValue(
canonicalUrl, 'SkippedFieldName',
{description: 'SkippedReason'}));
});
""") as map_script:
map_single_trace.MapSingleTrace(results, trace_handle,
_Handle(map_script.filename))
self.assertEquals(len(results.all_values), 1)
v = results.all_values[0]
self.assertIsInstance(v, value_module.SkipValue)
self.assertEquals(v.name, 'SkippedFieldName')
self.assertEquals(v.description, 'SkippedReason')
def _ProcessTrace(self, trace_handle):
run_info = trace_handle.run_info
subresults = results_module.Results()
run_reporter = self._progress_reporter.WillRun(run_info)
map_single_trace.MapSingleTrace(subresults, trace_handle,
self._map_function_handle)
for v in subresults.all_values:
run_reporter.DidAddValue(v)
self._result_queue.put(subresults)
had_failure = subresults.DoesRunContainFailure(run_info)
run_reporter.DidRun(had_failure)
if self._stop_on_error and had_failure:
self._failed_run_info_to_dump = run_info
self._abort = True
def _ProcessOneTrace(self, trace_handle):
canonical_url = trace_handle.canonical_url
subresults = results_module.Results()
run_reporter = self._progress_reporter.WillRun(canonical_url)
map_single_trace.MapSingleTrace(subresults, trace_handle,
self._map_function_handle)
had_failure = subresults.DoesRunContainFailure(canonical_url)
for v in subresults.all_values:
run_reporter.DidAddValue(v)
run_reporter.DidRun(had_failure)
self._wq.PostMainThreadTask(self._MergeResultsToIntoMaster,
trace_handle, subresults)
def _ProcessTrace(self, trace_handle):
run_info = trace_handle.run_info
subresults = results_module.Results()
# TODO: Modify ProgressReporter API to deal with interleaving runs so
# that we can use self._progress_reporter here.
progress_reporter = gtest_progress_reporter.GTestProgressReporter(
sys.stdout)
progress_reporter.WillRun(run_info)
map_single_trace.MapSingleTrace(subresults, trace_handle,
os.path.abspath(self._map_file))
self._result_queue.put(subresults)
had_failure = subresults.DoesRunContainFailure(run_info)
progress_reporter.DidRun(run_info, had_failure)
if self._stop_on_error and had_failure:
self._failed_run_info_to_dump = run_info
self._abort = True
def testTraceDidntImport(self):
trace_string = 'This is intentionally not a trace-formatted string.'
trace_handle = file_handle.InMemoryFileHandle(
'/a.json', trace_string)
results = results_module.Results()
with map_single_trace.TemporaryMapScript("""
pi.FunctionRegistry.register(
function MyMapFunction(results, model) {
});
""") as map_script:
map_single_trace.MapSingleTrace(results, trace_handle,
_Handle(map_script.filename))
self.assertEquals(len(results.all_values), 1)
v = results.all_values[0]
self.assertIsInstance(v, map_single_trace.TraceImportErrorValue)
def Run(self):
self._results = results_module.Results()
for trace_handle in self._trace_handles:
self._wq.PostAnyThreadTask(self._ProcessOneTrace, trace_handle)
err = self._wq.Run()
self._progress_reporter.DidFinishAllRuns(self._results)
for of in self._output_formatters:
of.Format(self._results)
if err:
self._PrintFailedRunInfo(err.run_info)
results = self._results
self._results = None
return results
def Run(self, jobs=1, output_formatters=None):
if jobs == AUTO_JOB_COUNT:
jobs = multiprocessing.cpu_count()
if jobs == 1:
self._WorkLoop()
else:
for _ in range(jobs):
t = threading.Thread(target=self._WorkLoop)
t.setDaemon(True)
t.start()
output_formatters = output_formatters or []
results = results_module.Results()
while True:
if not self._result_queue.empty():
subresults = self._result_queue.get()
results.Merge(subresults)
elif self._abort:
break
elif self._work_queue.empty():
self._work_queue.join()
self._abort = True
else:
time.sleep(0.1)
self._progress_reporter.DidFinishAllRuns(results)
for of in output_formatters:
of.Format(results)
if self._failed_run_info_to_dump:
sys.stderr.write('\n\nWhile mapping %s:\n' %
self._failed_run_info_to_dump.display_name)
failures = [
v for v in results.all_values
if (v.run_info == self._failed_run_info_to_dump
and isinstance(v, value_module.FailureValue))
]
for failure in failures:
sys.stderr.write(failure.GetGTestPrintString())
sys.stderr.write('\n')
return results
def testTraceDidntImport(self):
run_info = run_info_module.RunInfo('file:///a.json',
'/a.json',
metadata={'m': 1})
trace_string = 'This is intentionally not a trace-formatted string.'
trace_handle = in_memory_trace_handle.InMemoryTraceHandle(
run_info, trace_string)
results = results_module.Results()
with map_single_trace.TemporaryMapScript("""
pi.MapFunction.register(function MyMapFunction(results, run_info, model) {
});
""") as map_script:
map_single_trace.MapSingleTrace(results, trace_handle,
map_script.filename)
self.assertEquals(len(results.all_values), 1)
v = results.all_values[0]
self.assertIsInstance(v, map_single_trace.TraceImportErrorValue)
def testMapperSkips(self):
run_info = run_info_module.RunInfo('file:///a.json',
'/a.json',
metadata={'m': 1})
events = [{
'pid': 1,
'tid': 2,
'ph': 'X',
'name': 'a',
'cat': 'c',
'ts': 0,
'dur': 10,
'args': {}
}, {
'pid': 1,
'tid': 2,
'ph': 'X',
'name': 'b',
'cat': 'c',
'ts': 3,
'dur': 5,
'args': {}
}]
trace_handle = in_memory_trace_handle.InMemoryTraceHandle(
run_info, json.dumps(events))
results = results_module.Results()
with map_single_trace.TemporaryMapScript("""
pi.MapFunction.register(function MyMapFunction(results, run_info, model) {
results.addValue(new pi.v.SkipValue(
run_info, 'SkippedFieldName',
{description: 'SkippedReason'}));
});
""") as map_script:
map_single_trace.MapSingleTrace(results, trace_handle,
map_script.filename)
self.assertEquals(len(results.all_values), 1)
v = results.all_values[0]
self.assertIsInstance(v, value_module.SkipValue)
self.assertEquals(v.name, 'SkippedFieldName')
self.assertEquals(v.description, 'SkippedReason')
def testNoMapper(self):
events = [
{'pid': 1, 'tid': 2, 'ph': 'X', 'name': 'a', 'cat': 'c',
'ts': 0, 'dur': 10, 'args': {}},
{'pid': 1, 'tid': 2, 'ph': 'X', 'name': 'b', 'cat': 'c',
'ts': 3, 'dur': 5, 'args': {}}
]
trace_handle = file_handle.InMemoryFileHandle(
'/a.json', json.dumps(events))
results = results_module.Results()
with map_single_trace.TemporaryMapScript("""
""") as map_script:
map_single_trace.MapSingleTrace(results, trace_handle,
_Handle(map_script.filename))
self.assertEquals(len(results.all_values), 1)
v = results.all_values[0]
self.assertIsInstance(v, map_single_trace.FunctionNotDefinedErrorValue)
def testPassingMapScript(self):
run_info = run_info_module.RunInfo('file:///a.json',
'/a.json',
metadata={'m': 1})
events = [{
'pid': 1,
'tid': 2,
'ph': 'X',
'name': 'a',
'cat': 'c',
'ts': 0,
'dur': 10,
'args': {}
}, {
'pid': 1,
'tid': 2,
'ph': 'X',
'name': 'b',
'cat': 'c',
'ts': 3,
'dur': 5,
'args': {}
}]
trace_handle = in_memory_trace_handle.InMemoryTraceHandle(
run_info, json.dumps(events))
results = results_module.Results()
with map_single_trace.TemporaryMapScript("""
pi.MapFunction.register(function MyMapFunction(results, run_info, model) {
results.addValue(new pi.v.DictValue(
run_info,
'result', {
numProcesses: model.getAllProcesses().length
}));
});
""") as map_script:
map_single_trace.MapSingleTrace(results, trace_handle,
map_script.filename)
v = results.FindValueNamed('result')
self.assertEquals(v['numProcesses'], 1)
def testMapFunctionThatThrows(self):
run_info = run_info_module.RunInfo('file:///a.json',
'/a.json',
metadata={'m': 1})
events = [{
'pid': 1,
'tid': 2,
'ph': 'X',
'name': 'a',
'cat': 'c',
'ts': 0,
'dur': 10,
'args': {}
}, {
'pid': 1,
'tid': 2,
'ph': 'X',
'name': 'b',
'cat': 'c',
'ts': 3,
'dur': 5,
'args': {}
}]
trace_handle = in_memory_trace_handle.InMemoryTraceHandle(
run_info, json.dumps(events))
results = results_module.Results()
with map_single_trace.TemporaryMapScript("""
pi.MapFunction.register(function MyMapFunction(results, run_info, model) {
throw new Error('Expected error');
});
""") as map_script:
map_single_trace.MapSingleTrace(results, trace_handle,
map_script.filename)
self.assertEquals(len(results.all_values), 1)
v = results.all_values[0]
self.assertIsInstance(v, map_single_trace.MapFunctionErrorValue)
def testMapFunctionThatThrows(self):
events = [
{'pid': 1, 'tid': 2, 'ph': 'X', 'name': 'a', 'cat': 'c',
'ts': 0, 'dur': 10, 'args': {}},
{'pid': 1, 'tid': 2, 'ph': 'X', 'name': 'b', 'cat': 'c',
'ts': 3, 'dur': 5, 'args': {}}
]
trace_handle = file_handle.InMemoryFileHandle(
'/a.json', json.dumps(events))
results = results_module.Results()
with map_single_trace.TemporaryMapScript("""
pi.FunctionRegistry.register(
function MyMapFunction(results, model) {
throw new Error('Expected error');
});
""") as map_script:
map_single_trace.MapSingleTrace(results, trace_handle,
_Handle(map_script.filename))
self.assertEquals(len(results.all_values), 1)
v = results.all_values[0]
self.assertIsInstance(v, map_single_trace.MapFunctionErrorValue)
def testNoMapper(self):
run_info = run_info_module.RunInfo('file:///a.json',
'/a.json',
metadata={'m': 1})
events = [{
'pid': 1,
'tid': 2,
'ph': 'X',
'name': 'a',
'cat': 'c',
'ts': 0,
'dur': 10,
'args': {}
}, {
'pid': 1,
'tid': 2,
'ph': 'X',
'name': 'b',
'cat': 'c',
'ts': 3,
'dur': 5,
'args': {}
}]
trace_handle = in_memory_trace_handle.InMemoryTraceHandle(
run_info, json.dumps(events))
results = results_module.Results()
with map_single_trace.TemporaryMapScript("""
""") as map_script:
map_single_trace.MapSingleTrace(results, trace_handle,
map_script.filename)
self.assertEquals(len(results.all_values), 1)
v = results.all_values[0]
self.assertIsInstance(v,
map_single_trace.MapFunctionNotDefinedErrorValue)
