def test_interpret_test_failures(self):
        test_dict = test_run_results._interpret_test_failures([
            test_failures.FailureReftestMismatchDidNotOccur(
                self._actual_output, self._expected_output,
                self.port.abspath_for_test(
                    'foo/reftest-expected-mismatch.html'))
        ])
        self.assertEqual(len(test_dict), 0)

        test_dict = test_run_results._interpret_test_failures([
            test_failures.FailureMissingAudio(self._actual_output,
                                              self._expected_output)
        ])
        self.assertIn('is_missing_audio', test_dict)

        test_dict = test_run_results._interpret_test_failures([
            test_failures.FailureMissingResult(self._actual_output,
                                               self._expected_output)
        ])
        self.assertIn('is_missing_text', test_dict)

        test_dict = test_run_results._interpret_test_failures([
            test_failures.FailureMissingImage(self._actual_output,
                                              self._expected_output)
        ])
        self.assertIn('is_missing_image', test_dict)

        test_dict = test_run_results._interpret_test_failures([
            test_failures.FailureMissingImageHash(self._actual_output,
                                                  self._expected_output)
        ])
        self.assertIn('is_missing_image', test_dict)
 def _compare_audio(self, expected_audio, actual_audio):
     failures = []
     if (expected_audio
             and actual_audio and self._port.do_audio_results_differ(
                 expected_audio, actual_audio)):
         failures.append(test_failures.FailureAudioMismatch())
     elif actual_audio and not expected_audio:
         failures.append(test_failures.FailureMissingAudio())
     return failures
示例#3
0
    def _check_extra_and_missing_baselines(self, expected_driver_output,
                                           driver_output):
        failures = []

        if driver_output.text:
            if self._is_all_pass_testharness_text_not_needing_baseline(
                    driver_output.text):
                if self._report_extra_baseline(
                        driver_output, '.txt',
                        'is a all-pass testharness test'):
                    # TODO(wangxianzhu): Make this a failure.
                    pass
            elif testharness_results.is_testharness_output(driver_output.text):
                # We only need -expected.txt for a testharness test when we
                # expect it to fail or produce additional console output (when
                # -expected.txt is optional), so don't report missing
                # -expected.txt for testharness tests.
                pass
            elif self._reference_files:
                # A reftest's -expected.txt is optional. TODO(wangxianzhu): May
                # let reftests use the standard baseline existence rule.
                pass
            elif not expected_driver_output.text:
                failures.append(test_failures.FailureMissingResult())
        elif self._report_extra_baseline(driver_output, '.txt',
                                         'does not produce text result'):
            failures.append(test_failures.FailureTextMismatch())

        if driver_output.image_hash:
            if self._reference_files:
                if self._report_extra_baseline(driver_output, '.png',
                                               'is a reftest'):
                    # TODO(wangxianzhu): Make this a failure.
                    pass
            else:
                if not expected_driver_output.image:
                    failures.append(test_failures.FailureMissingImage())
                if not expected_driver_output.image_hash:
                    failures.append(test_failures.FailureMissingImageHash())
        elif self._report_extra_baseline(driver_output, '.png',
                                         'does not produce image result'):
            failures.append(test_failures.FailureImageHashMismatch())

        if driver_output.audio:
            if not expected_driver_output.audio:
                failures.append(test_failures.FailureMissingAudio())
        elif self._report_extra_baseline(driver_output, '.wav',
                                         'does not produce audio result'):
            failures.append(test_failures.FailureAudioMismatch())

        return failures