Пример #1
0
    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})
Пример #2
0
    def testStacktraceParsing(self, mock_get_dependency):
        """Test that ``stacktrace`` successfully parses a stacktrace."""
        mock_get_dependency.return_value = {
            'chrome': Dependency('chrome', 'https://repo', 'rev1')
        }

        uma_data = self._GetDummyUMAData()
        actual_stack_trace = uma_data.stacktrace

        stack_frame0 = stacktrace.ProfilerStackFrame(
            0, 0.1, float('inf'), False, 'chrome', 'wWinMain',
            'app/chrome_exe_main_win.cc', 'chrome/app/chrome_exe_main_win.cc',
            'https://repo', 484,
            (stacktrace.FunctionLine(line=490, sample_fraction=0.7),
             stacktrace.FunctionLine(line=511, sample_fraction=0.3)),
            (stacktrace.FunctionLine(line=490, sample_fraction=0.9),
             stacktrace.FunctionLine(line=511, sample_fraction=0.1)))
        stack_frame1 = stacktrace.ProfilerStackFrame(
            1, 0.2, 6.1, False, 'chrome',
            'MainDllLoader::Launch(HINSTANCE__ *)',
            'app/main_dll_loader_win.cc', 'chrome/app/main_dll_loader_win.cc',
            'https://repo', 117, None)
        frames0 = (stack_frame0, stack_frame1)

        stack_frame2 = stacktrace.ProfilerStackFrame(
            0, 0.3, float('inf'), False, 'chrome', 'wWinMain',
            'app/chrome_exe_main_win.cc', 'chrome/app/chrome_exe_main_win.cc',
            'https://repo', 484, None)
        frames1 = (stack_frame2, )

        call_stack0 = stacktrace.CallStack(
            0, frames0, stacktrace.CallStackFormatType.DEFAULT,
            stacktrace.LanguageType.CPP)
        call_stack1 = stacktrace.CallStack(
            0, frames1, stacktrace.CallStackFormatType.DEFAULT,
            stacktrace.LanguageType.CPP)
        stacks = (call_stack0, call_stack1)
        expected_stacktrace = stacktrace.Stacktrace(stacks, call_stack0)

        self._VerifyTwoStackFramesEqual(actual_stack_trace.stacks[0].frames[0],
                                        stack_frame0)
        self._VerifyTwoStacktracesEqual(actual_stack_trace,
                                        expected_stacktrace)
Пример #3
0
 def testDependencyRollsWhenRegressionRangeIsEmpty(self):
     """Tests that ``GetDependencyRolls`` is {} if regression_range is empty."""
     dep_data = self._GetDummyDependencyAnalyzer()
     stack = stacktrace.CallStack(0,
                                  frame_list=[
                                      stacktrace.StackFrame(
                                          0, 'src/', 'func', 'a.cc',
                                          'src/a.cc', [5])
                                  ])
     stacks_list = [stack]
     dep_data._regression_range = None
     self.assertEqual(dep_data.GetDependencyRolls(stacks_list), {})
Пример #4
0
    def testDependencies(self, mock_get_dependencies, mock_stacktrace):
        """Tests that ``dependencies``` calls GetDependencies."""
        uma_data = self._GetDummyUMAData()
        dependencies = {'src': Dependency('src', 'https://repo', 'rev')}
        mock_get_dependencies.return_value = dependencies
        stack = stacktrace.CallStack(0,
                                     frame_list=[
                                         stacktrace.StackFrame(
                                             0, 'src', 'func', 'a.cc',
                                             'src/a.cc', [5])
                                     ])
        stacktrace_field = stacktrace.Stacktrace([stack], stack)
        mock_stacktrace.return_value = stacktrace_field

        self.assertEqual(uma_data.dependencies, dependencies)
        mock_get_dependencies.assert_called_with(uma_data.stacktrace.stacks)
Пример #5
0
 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})