def testDependencyRoll(self, mock_get_dependency_rolls):
"""Tests parsing dependency rolls from regression_range."""
dep_roll = DependencyRoll('src/', 'https://repo', 'rev1', 'rev6')
regression_rolls = {
dep_roll.path: dep_roll,
'src/dummy': DependencyRoll('src/dummy', 'https://r', 'rev2',
'rev4'),
'src/add': DependencyRoll('src/add', 'https://rr', None, 'rev5')
}
mock_get_dependency_rolls.return_value = regression_rolls
dep_data = self._GetDummyDependencyAnalyzer()
dep_data._regression_range = ('rev1', 'rev6')
chromium_dep = Dependency('src/', 'https://repo', 'rev1')
dep_data._regression_version_deps = {
chromium_dep.path: chromium_dep,
'src/dummy': Dependency('src/dummy', 'https://r', 'rev2')
}
stack = stacktrace.CallStack(0,
frame_list=[
stacktrace.StackFrame(
0, 'src/', 'func', 'a.cc',
'src/a.cc', [5])
])
stacks_list = [stack]
self.assertEqual(dep_data.GetDependencyRolls(stacks_list),
{dep_roll.path: dep_roll})
def testDependencyRoll(self):
"""Tests parsing ``regression_rolls`` from regression_range."""
dep_roll = DependencyRoll('src/', 'https://repo', 'rev1', 'rev6')
regression_rolls = {
dep_roll.path: dep_roll,
'src/dummy': DependencyRoll('src/dummy', 'https://r', 'rev2', 'rev4'),
'src/add': DependencyRoll('src/add', 'https://rr', None, 'rev5')
}
with mock.patch(
'libs.deps.chrome_dependency_fetcher.ChromeDependencyFetcher'
'.GetDependencyRollsDict') as mock_get_dependency_rolls:
mock_get_dependency_rolls.return_value = regression_rolls
crash_data = ChromeCrashData(
self.GetDummyChromeCrashData(),
ChromeDependencyFetcher(self.GetMockRepoFactory()))
crash_data._regression_range = ('rev1', 'rev6')
chromium_dep = Dependency('src/', 'https://repo', 'rev1')
crash_data._crashed_version_deps = {
chromium_dep.path: chromium_dep,
'src/dummy': Dependency('src/dummy', 'https://r', 'rev2')}
stack = CallStack(0, frame_list=[
StackFrame(0, 'src/', 'func', 'a.cc', 'src/a.cc', [5])])
stacktrace = Stacktrace([stack], stack)
crash_data._stacktrace = stacktrace
self.assertEqual(crash_data.dependency_rolls, {dep_roll.path: dep_roll})
def testDistanceBetweenTouchedFileAndFrameInfos(self):
"""Tests ``DistanceBetweenTouchedFileAndFrameInfos`` method."""
feature = min_distance.MinDistanceFeature(self._get_repository, _MAXIMUM)
frame1 = StackFrame(0, 'src/', 'func', 'a.cc', 'src/a.cc', [7],
repo_url='https://repo_url')
frame2 = StackFrame(0, 'src/', 'func', 'a.cc', 'src/a.cc', [17],
repo_url='https://repo_url')
touched_file = FileChangeInfo(ChangeType.MODIFY, 'file', 'file')
blame = Blame('rev', 'src/')
blame.AddRegions([Region(0, 10, 'rev', 'a1', 'e1', 't1'),
Region(11, 20, 'dummy_rev', 'a2', 'e2', 't2')])
url_to_blame = {'rev/file': blame}
def _MockGetBlame(path, revision):
revision_path = '%s/%s' % (revision, path)
return url_to_blame.get(revision_path)
with mock.patch('libs.gitiles.gitiles_repository.GitilesRepository.'
'GetBlame') as mock_get_blame:
mock_get_blame.side_effect = _MockGetBlame
distance_info = feature.DistanceBetweenTouchedFileAndFrameInfos(
'rev', touched_file, [FrameInfo(frame1, 0), FrameInfo(frame2, 0)],
Dependency('src/', 'https://repo', 'rev'))
self.assertEqual(distance_info, min_distance.Distance(0, frame1))
distance_info = feature.DistanceBetweenTouchedFileAndFrameInfos(
'wrong_rev', touched_file, [FrameInfo(frame1, 0),
FrameInfo(frame2, 0)],
Dependency('src/', 'https://repo', 'wrong_rev'))
self.assertIsNone(distance_info)
def testGetDependencyForChromeVersion(self):
src_path = 'src'
src_repo_url = 'https://chromium.googlesource.com/chromium/src.git'
os_platform = 'unix'
child1_dep = Dependency('src/a', 'https://a.git', '123a', 'DEPS')
child2_dep = Dependency('src/b', 'https://b.git', '123b', 'DEPS')
grand_child1 = Dependency('src/a/aa', 'https://aa.git', '123aa',
'DEPS')
expected_dependency_dict = {
'src/a': child1_dep,
'src/b': child2_dep,
'src/a/aa': grand_child1,
}
def DummyUpdateDependencyTree(root_dep, target_os_list, _):
self.assertEqual(src_path, root_dep.path)
self.assertEqual(src_repo_url, root_dep.repo_url)
self.assertEqual([os_platform], target_os_list)
expected_dependency_dict[root_dep.path] = root_dep
child1_dep.SetParent(root_dep)
child2_dep.SetParent(root_dep)
grand_child1.SetParent(child1_dep)
self.mock(deps_parser, 'UpdateDependencyTree',
DummyUpdateDependencyTree)
dependency_dict = self.chrome_dep_fetcher.GetDependency(
'50.0.1234.0', os_platform)
self.assertEqual(expected_dependency_dict, dependency_dict)
def GetDependency(self, *_):
if not self.none_deps:
return {
'src':
Dependency('src', 'https://chromium.git', 'master'),
'src/v8':
Dependency('src/v8', 'https://chromium.v8.git', 'master'),
}
return None
def testParentChild(self):
parent = Dependency('a/', 'https://cr.googlesource.com/cr/a.git',
'12a', 'DEPS')
child = Dependency('a/b/', 'https://cr.googlesource.com/cr/b.git',
'12b', 'DEPS')
child.SetParent(parent)
self.assertTrue(child.parent == parent)
self.assertIn(child.path, parent.children)
self.assertTrue(child == parent.children[child.path])
def testDependencies(self):
"""Tests that ``dependencies`` returns filtered ``_CrashedVersionDeps``."""
crash_data = ChromeCrashData(self.GetDummyChromeCrashData(), None)
chromium_dep = Dependency('src/', 'https://repo', 'rev1')
crash_data._crashed_version_deps = {
chromium_dep.path: chromium_dep,
'src/dummy': Dependency('src/dummy', 'https://r', 'rev2')}
stack = CallStack(0, frame_list=[
StackFrame(0, 'src/', 'func', 'a.cc', 'src/a.cc', [5])])
stacktrace = Stacktrace([stack], stack)
crash_data._stacktrace = stacktrace
self.assertEqual(crash_data.dependencies,
{chromium_dep.path: chromium_dep})
def MockGetDependency(revision, os_platform, _=False):
self.assertEqual('unix', os_platform)
if revision == 'rev2':
return {
'src':
Dependency('src', 'https://url_src', 'rev2', 'DEPS'),
'src/dep1':
Dependency('src/dep1', 'https://url_dep1', '9', 'DEPS'),
'src/dep2':
Dependency('src/dep2', 'https://url_dep2', '5', 'DEPS'),
'src/dep4':
Dependency('src/dep4', 'https://url_dep4', '1', 'DEPS'),
}
else:
self.assertEqual('rev1', revision)
return {
'src':
Dependency('src', 'https://url_src', 'rev1', 'DEPS'),
'src/dep1':
Dependency('src/dep1', 'https://url_dep1', '7', 'DEPS'),
'src/dep2':
Dependency('src/dep2', 'https://url_dep2', '5', 'DEPS'),
'src/dep3':
Dependency('src/dep3', 'https://url_dep3', '3', 'DEPS'),
}
def testClusterfuzzParserParseStacktrace(self):
parser = ClusterfuzzParser()
deps = {'src/': Dependency('src/', 'https://repo', '1')}
stacktrace_string = textwrap.dedent("""
Blabla...
==1==ERROR: AddressSanitizer: stack-overflow on address 0x7ffec59ebec0
#0 0x7f5b944a37bb in a::aa(p* d) src/a.h:225
#1 0x7f5b9449a880 in b::bb(p* d) src/b.h:266:1
#2 0x7f5b9449a880 in c::cc(p* d) src/c.h:281
""")
stacktrace = parser.Parse(stacktrace_string, deps, 'asan_job',
SanitizerType.ADDRESS_SANITIZER)
stack = CallStack(0,
frame_list=[
StackFrame(0, 'src/', 'a::aa(p* d)', 'a.h',
'src/a.h', [225]),
StackFrame(1, 'src/', 'b::bb(p* d)', 'b.h',
'src/b.h', [266, 267]),
StackFrame(2, 'src/', 'c::cc(p* d)', 'c.h',
'src/c.h', [281])
])
expected_stacktrace = Stacktrace([stack], stack)
self._VerifyTwoStacktracesEqual(stacktrace, expected_stacktrace)
def testReturnNoneForEmptyString(self):
parser = ClusterfuzzParser()
deps = {'src/': Dependency('src/', 'https://repo', '1')}
self.assertIsNone(
parser.Parse('', deps, 'asan_job',
SanitizerType.ADDRESS_SANITIZER))
def testChromeCrashParserParseLineMultipleCallstacks(self):
parser = ChromeCrashParser()
deps = {'src/': Dependency('src/', 'https://repo', '1')}
stacktrace_string = textwrap.dedent(
"""
CRASHED [EXC @ 0x66]
#0 0x7fee in a::b::c(p* &d) src/f0.cc:177
#1 0x4b6e in a::b::d(a* c) src/f1.cc:227
CRASHED [EXC @ 0x508]
#0 0x8fee in e::f::g(p* &d) src/f.cc:20:2
#1 0x1fae in h::i::j(p* &d) src/ff.cc:9:1
"""
)
stacktrace = parser.Parse(stacktrace_string, deps)
expected_callstack0 = CallStack(0, frame_list=[
StackFrame(0, 'src/', 'a::b::c(p* &d)', 'f0.cc', 'src/f0.cc', [177]),
StackFrame(1, 'src/', 'a::b::d(a* c)', 'f1.cc', 'src/f1.cc', [227])])
expected_callstack1 = CallStack(0, frame_list=[
StackFrame(
0, 'src/', 'e::f::g(p* &d)', 'f.cc', 'src/f.cc', [20, 21, 22]),
StackFrame(
1, 'src/', 'h::i::j(p* &d)', 'ff.cc', 'src/ff.cc', [9, 10])])
expected_stacktrace = Stacktrace([expected_callstack0, expected_callstack1],
expected_callstack0)
self._VerifyTwoStacktracesEqual(stacktrace, expected_stacktrace)
def testMinDistanceFeatureMiddling(self):
"""Test that the feature returns middling scores for middling distances."""
report = self._GetDummyReport(
deps={'src/': Dependency('src/', 'https://repo', '6')},
dep_rolls={
'src/': DependencyRoll('src/', 'https://repo', '0', '4')
})
frame = StackFrame(0, 'src/', 'func', 'f.cc', 'f.cc', [232],
'https://repo')
distance = 42.
crashed = CrashedFile('file')
matches = {
crashed:
CrashMatch(crashed,
[FileChangeInfo(ChangeType.MODIFY, 'file', 'file')],
[FrameInfo(frame, 0)])
}
with mock.patch(
'analysis.linear.changelist_features.'
'min_distance.MinDistanceFeature.'
'DistanceBetweenTouchedFileAndFrameInfos') as mock_distance:
mock_distance.return_value = min_distance.Distance(distance, frame)
self.assertEqual((_MAXIMUM - distance) / _MAXIMUM,
min_distance.MinDistanceFeature(
self._get_repository,
_MAXIMUM)(report)(self._GetMockSuspect(),
matches).value)
def testChromeCrashParserParseLineJavaCallstack(self):
parser = ChromeCrashParser()
deps = {'src/': Dependency('src/', 'https://repo', '1')}
stacktrace_string = textwrap.dedent(
"""
(JAVA) CRASHED [EXC @ 0x508]
#0 0x7fee in a.f0.c f0.java:177
#1 0x4b6e in org.chromium.chrome.browser.a.f1.d f1.java:227
#2 0x7ff9 in a.f2.e f2.java:87:1
"""
)
stacktrace = parser.Parse(stacktrace_string, deps)
stack = CallStack(0,
language_type=LanguageType.JAVA,
frame_list=[
StackFrame(0, '', 'a.f0.c', 'a/f0.java', 'a/f0.java', [177]),
StackFrame(
1, 'src/', 'org.chromium.chrome.browser.a.f1.d',
'chrome/android/java/src/org/chromium/chrome/browser/a/f1.java',
'src/chrome/android/java/src/org/chromium/chrome/'
'browser/a/f1.java',
[227]),
StackFrame(2, '', 'a.f2.e', 'a/f2.java', 'a/f2.java', [87, 88])])
expected_stacktrace = Stacktrace([stack], stack)
self._VerifyTwoStacktracesEqual(stacktrace, expected_stacktrace)
def testMinDistanceFeatureIsOverMax(self):
"""Test that we return log(0) when the min_distance is too large."""
report = self._GetDummyReport(
deps={'src/': Dependency('src/', 'https://repo', '6')},
dep_rolls={
'src/': DependencyRoll('src/', 'https://repo', '0', '4')
})
distance = _MAXIMUM + 1
frame = _MOCK_FRAME._replace(file_path='file')
crashed = CrashedFile('file')
matches = {
crashed:
CrashMatch(crashed,
[FileChangeInfo(ChangeType.MODIFY, 'file', 'file')],
[FrameInfo(frame, 0)])
}
with mock.patch(
'analysis.linear.changelist_features.'
'min_distance.MinDistanceFeature.'
'DistanceBetweenTouchedFileAndFrameInfos') as mock_distance:
mock_distance.return_value = min_distance.Distance(distance, None)
self.assertEqual(
0.0,
min_distance.MinDistanceFeature(
self._get_repository,
_MAXIMUM)(report)(self._GetMockSuspect(), matches).value)
def testMinDistanceChangedFiles(self):
"""Tests ``ChangedFile`` method."""
report = self._GetDummyReport(
deps={'src/': Dependency('src/', 'https://repo', '6')},
dep_rolls={'src/': DependencyRoll('src/', 'https://repo', '0', '4')})
distance = 42
crashed = CrashedFile(_MOCK_FRAME)
matches = {
crashed:
CrashMatch(crashed,
[FileChangeInfo(ChangeType.MODIFY, 'file', 'file')],
[FrameInfo(_MOCK_FRAME, 0)])
}
frame = StackFrame(0, 'src/', 'func', 'f.cc', 'f.cc', [7], 'https://repo')
with mock.patch('analysis.linear.changelist_features.min_distance.'
'MinDistanceFeature.'
'DistanceBetweenTouchedFileAndFrameInfos') as mock_distance:
mock_distance.return_value = min_distance.Distance(distance, frame)
self.assertEqual(
min_distance.MinDistanceFeature(
self._get_repository, _MAXIMUM)(report)(
self._GetMockSuspect(), matches).changed_files,
[ChangedFile(name='file',
blame_url=('%s/+blame/%s/f.cc#%d' %
(frame.repo_url,
report.crashed_version,
frame.crashed_line_numbers[0])),
reasons=['Distance between touched lines and crashed'
' lines is %d, in frame #%d' % (
distance, frame.index)])])
def testMinDistanceFeatureInfinityDistance(self):
"""Test that we return log(0) when the min_distance is infinity.
The infinity distance means the touched file get overwritten by other
cls, and the change didn't show in the final blame file.
"""
report = self._GetDummyReport(
deps={'src/': Dependency('src/', 'https://repo', '6')},
dep_rolls={'src/': DependencyRoll('src/', 'https://repo', '0', '4')})
suspect = self._GetMockSuspect()
crashed = CrashedFile(_MOCK_FRAME)
matches = {
crashed:
CrashMatch(crashed,
[FileChangeInfo(ChangeType.MODIFY, 'file', 'file')],
[FrameInfo(_MOCK_FRAME, 0)])
}
with mock.patch('analysis.linear.changelist_features.min_distance.'
'MinDistanceFeature.'
'DistanceBetweenTouchedFileAndFrameInfos') as mock_distance:
mock_distance.return_value = None
self.assertEqual(
0.0,
min_distance.MinDistanceFeature(
self._get_repository, _MAXIMUM)(report)(suspect, matches).value)
with mock.patch('analysis.linear.changelist_features.min_distance.'
'MinDistanceFeature.'
'DistanceBetweenTouchedFileAndFrameInfos') as mock_distance:
mock_distance.return_value = min_distance.Distance(float('inf'), None)
self.assertEqual(
0.0,
min_distance.MinDistanceFeature(self._get_repository, 100)(report)(
suspect, matches).value)
def testDependenciesAndDependencyRollsIsFrozenDict(self):
crash_report = CrashReport(
'rev', 'sig', 'win', None, ('1', '3'),
{'src/': Dependency('src/', 'http://repo', '5')},
{'src/': DependencyRoll('src/', 'http://repo', '1', '3')})
self.assertTrue(isinstance(crash_report.regression_range, tuple))
self.assertTrue(isinstance(crash_report.dependencies, _FrozenDict))
self.assertTrue(isinstance(crash_report.dependency_rolls, _FrozenDict))
def testRegressionVersionDeps(self, mock_get_dependency):
dep_data = self._GetDummyDependencyAnalyzer()
regression_version_deps = {
'src/': Dependency('src/', 'https://repo', 'rev')
}
mock_get_dependency.return_value = regression_version_deps
self.assertEqual(dep_data.regression_version_deps,
regression_version_deps)
def MockGetDependency(_, revision, os_platform):
self.assertEqual('unix', os_platform)
if revision == 'rev2':
return {
'src/':
Dependency('src/', 'https://url_src', 'rev2', 'DEPS'),
'src/dep1':
Dependency('src/dep1', 'https://url_dep1', '9', 'DEPS'),
}
else:
self.assertEqual('rev2^', revision)
return {
'src/':
Dependency('src/', 'https://url_src', 'rev2^', 'DEPS'),
'src/dep1':
Dependency('src/dep1', 'https://url_dep1', '7', 'DEPS'),
}
def testDependencies(self, mock_regression_version_deps):
"""Tests ``GetDependencies`` gets filtered ``regression_version_deps``."""
dep_data = self._GetDummyDependencyAnalyzer()
chromium_dep = Dependency('src/', 'https://repo', 'rev1')
mock_regression_version_deps.return_value = {
chromium_dep.path: chromium_dep,
'src/dummy': Dependency('src/dummy', 'https://r', 'rev2')
}
stack = stacktrace.CallStack(0,
frame_list=[
stacktrace.StackFrame(
0, 'src/', 'func', 'a.cc',
'src/a.cc', [5])
])
stacks_list = [stack]
self.assertEqual(dep_data.GetDependencies(stacks_list),
{chromium_dep.path: chromium_dep})
def testAreLogZerosWhenNoMatchedFile(self):
"""Test that feature values are log(0)s when there is no matched file."""
report = self._GetDummyReport(
deps={'src': Dependency('src/dep', 'https://repo', '6')})
feature_values = self._feature(report)(self._GetMockSuspect()).values()
for feature_value in feature_values:
self.assertEqual(0.0, feature_value.value)
def testGetDepPathAndNormalizedFilePath(self):
deps = {
'src': Dependency('src', 'https://repo', '1'),
'src/Upper': Dependency('src/Upper', 'https://repo_upper', '2')
}
self.assertEqual(
parse_util.GetDepPathAndNormalizedFilePath('out/r/gen/b.cc', deps),
('', 'out/r/gen/b.cc', None))
self.assertEqual(
parse_util.GetDepPathAndNormalizedFilePath('src/a/b.cc', deps),
('src', 'a/b.cc', 'https://repo'))
self.assertEqual(
parse_util.GetDepPathAndNormalizedFilePath('src/Upper/a/b.cc',
deps),
('src/Upper', 'a/b.cc', 'https://repo_upper'))
self.assertEqual(
parse_util.GetDepPathAndNormalizedFilePath('src/upper/a/b.cc',
deps),
('src/Upper', 'a/b.cc', 'https://repo_upper'))
self.assertEqual(
parse_util.GetDepPathAndNormalizedFilePath('Upper/a/b.cc', deps),
('src/Upper', 'a/b.cc', 'https://repo_upper'))
self.assertEqual(
parse_util.GetDepPathAndNormalizedFilePath('upper/a/b.cc', deps),
('src/Upper', 'a/b.cc', 'https://repo_upper'))
self.assertEqual(
parse_util.GetDepPathAndNormalizedFilePath(
'upperdummy/a/b.cc',
deps,
root_path='src_root',
root_repo_url='https://root'),
('src_root', 'upperdummy/a/b.cc', 'https://root'))
self.assertEqual(
parse_util.GetDepPathAndNormalizedFilePath('dummy/path/b.cc',
deps),
('src', 'dummy/path/b.cc', parse_util.CHROMIUM_REPO_URL))
self.assertEqual(
parse_util.GetDepPathAndNormalizedFilePath('a.java',
deps,
is_java=True),
('', 'a.java', None))
def testFracasCrashParserParseLineMalformatedCallstack(self):
parser = FracasCrashParser()
deps = {'src': Dependency('src', 'https://repo', '1')}
stacktrace_string = textwrap.dedent("""
CRASHED [EXC @ 0x508]
#0 [RESTRICTED]
#1 [RESTRICTED]
""")
self.assertIsNone(parser.Parse(stacktrace_string, deps))
def dependencies(self):
if self._dependencies:
return self._dependencies
self._dependencies = {
dep['dep_path']: Dependency(dep['dep_path'], dep['repo_url'],
dep['revision'])
for dep in self._raw_dependencies
}
return self._dependencies
def testDependencyForChromeVersion(self):
dep = Dependency('a/b/',
'https://cr.googlesource.com/cr/b.git',
'12b',
'DEPS',
deps_repo_url='https://chrome-internal',
deps_repo_revision='master')
self.assertEqual(dep.deps_repo_url, 'https://chrome-internal')
self.assertEqual(dep.deps_repo_revision, 'master')
def testDoNotIndexFramesWithNoneCrashedGroup(self):
"""Tests ``IndexFramesWithCrashedGroup`` function."""
frame = StackFrame(0, 'src/', 'func', '', '', [2], 'h://repo')
stack = CallStack(0, frame_list=[frame])
stack_trace = Stacktrace([stack], stack)
deps = {'src/': Dependency('src/', 'h://repo', 'rev3')}
indexed_frame_infos = crash_util.IndexFramesWithCrashedGroup(
stack_trace, Factory, deps)
self.assertEqual(indexed_frame_infos, {})
def testToJsonForNonEmptyDependencies(self):
"""Tests ``ToJson`` for non-empty self.dependencies."""
testcase_id = '1234'
job_type = 'asan'
analysis = ClusterfuzzAnalysis.Create(testcase_id)
analysis.testcase_id = testcase_id
analysis.job_type = job_type
analysis.dependencies = {
'src': Dependency('src', 'https://repo', 'rev'),
'src/v8': Dependency('src/v8', 'https://repo/v8', 'rev2')
}
dependencies_json = [{
'dep_path': 'src',
'repo_url': 'https://repo',
'revision': 'rev'
}, {
'dep_path': 'src/v8',
'repo_url': 'https://repo/v8',
'revision': 'rev2'
}]
expected_json = {
'regression_range': None,
'dependencies': dependencies_json,
'dependency_rolls': None,
'crash_type': None,
'crash_address': None,
'sanitizer': None,
'job_type': job_type,
'security_flag': False,
'testcase_id': testcase_id,
}
self.assertDictEqual(
analysis.ToJson(), {
'customized_data': expected_json,
'platform': None,
'stack_trace': None,
'crash_revision': None,
'signature': None,
'crash_identifiers': None,
'client_id': 'clusterfuzz'
})
def testParseFrame(self):
"""Tests successfully parsing a stacktrace with one frame."""
frame_dict = {
'difference':
0.01,
'log_change_factor':
-8.1,
'responsible':
False,
'filename':
'chrome/app/chrome_exe_main_win.cc',
'function_name':
'wWinMain',
'function_start_line':
484,
'lines': [[{
'line': 490,
'sample_fraction': 0.7
}, {
'line': 511,
'sample_fraction': 0.3
}],
[{
'line': 490,
'sample_fraction': 0.9
}, {
'line': 511,
'sample_fraction': 0.1
}]]
}
deps = {'chrome': Dependency('chrome', 'https://repo', '1')}
frame, language_type = ProfilerStackFrame.Parse(frame_dict, 1, deps)
self.assertEqual(frame.index, 1)
self.assertEqual(frame.difference, 0.01)
self.assertEqual(frame.log_change_factor, -8.1)
self.assertEqual(frame.responsible, False)
self.assertEqual(frame.dep_path, 'chrome')
self.assertEqual(frame.function, 'wWinMain')
self.assertEqual(frame.file_path, 'app/chrome_exe_main_win.cc')
self.assertEqual(frame.raw_file_path,
'chrome/app/chrome_exe_main_win.cc')
self.assertEqual(frame.repo_url, 'https://repo')
self.assertEqual(frame.function_start_line, 484)
expected_lines_old = (
FunctionLine(line=490, sample_fraction=0.7),
FunctionLine(line=511, sample_fraction=0.3),
)
expected_lines_new = (
FunctionLine(line=490, sample_fraction=0.9),
FunctionLine(line=511, sample_fraction=0.1),
)
self.assertEqual(frame.lines_old, expected_lines_old)
self.assertEqual(frame.lines_new, expected_lines_new)
self.assertEqual(language_type, LanguageType.CPP)
def testFilteringIncludesExtraFrameInShiftCase(self):
"""Tests that one extra frame is included in a 'shift' case.
In a 'shift' case (i.e. where execution time at the root has shifted
entirely from one function to another), the subtree and one extra frame
above it should be included.
"""
parser = UMASamplingProfilerParser()
frame1 = {
'difference': 0,
'log_change_factor': 0,
'responsible': False
}
frame2 = {
'difference': 0.1,
'log_change_factor': float('inf'),
'responsible': True
}
frame3 = {
'difference': 0.1,
'log_change_factor': float('-inf'),
'responsible': True
}
subtree_root_depth = 2
subtree_stacks = [
# In this case the root is the first ``frame2`` or ``frame3`` instance.
{
'frames': [frame1, frame1, frame2, frame2]
},
{
'frames': [frame1, frame1, frame3, frame3, frame3]
},
]
deps = {'chrome/': Dependency('chrome/', 'https://repo', '1')}
stacktrace = parser.Parse(subtree_stacks, subtree_root_depth, deps)
filtered_stacks = (
CallStack(
0,
[
ProfilerStackFrame(1, 0.0, 0.0, False), # extra node
ProfilerStackFrame(2, 0.1, float('inf'), True),
ProfilerStackFrame(3, 0.1, float('inf'), True),
]),
CallStack(
0,
[
ProfilerStackFrame(1, 0.0, 0.0, False), # extra node
ProfilerStackFrame(2, 0.1, float('-inf'), True),
ProfilerStackFrame(3, 0.1, float('-inf'), True),
ProfilerStackFrame(4, 0.1, float('-inf'), True),
]),
)
self.assertEqual(stacktrace.stacks, filtered_stacks)
def testDistanceBetweenTouchedFileAndFrameInfosWithDeletedFile(self):
"""Tests that this method returns None when the touched_file is deleted."""
feature = min_distance.MinDistanceFeature(self._get_repository,
_MAXIMUM)
touched_file = FileChangeInfo(ChangeType.DELETE, 'file', None)
distance_info = feature.DistanceBetweenTouchedFileAndFrameInfos(
'rev', touched_file, [FrameInfo(_MOCK_FRAME, 0)],
Dependency('src/', 'https://repo', 'rev'))
self.assertIsNone(distance_info)
