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)