def test_results(self):
     # Doesn't make sense to ask for the test_results until the tests have run at least once.
     assert(self._test_run_counter >= 0)
     failures_for_run = self._test_failure_plan[self._test_run_counter]
     results = LayoutTestResults(map(self._mock_test_result, failures_for_run))
     # This makes the results trustable by ExpectedFailures.
     results.set_failure_limit_count(10)
     return results

 def test_was_interrupted(self):
     self.assertTrue(
         LayoutTestResults.results_from_string('ADD_RESULTS({"tests":{},"interrupted":true});').run_was_interrupted()
     )
     self.assertFalse(
         LayoutTestResults.results_from_string(
             'ADD_RESULTS({"tests":{},"interrupted":false});'
         ).run_was_interrupted()
     )

        def builder_data():
            old_builder_data()
            # have prototype-chocolate only fail on "MOCK Leopard".
            self.command._builder_data['MOCK SnowLeopard'] = LayoutTestResults.results_from_string("""ADD_RESULTS({
    "tests": {
        "fast": {
            "dom": {
                "prototype-taco.html": {
                    "expected": "PASS",
                    "actual": "PASS TEXT",
                    "is_unexpected": true
                },
                "prototype-chocolate.html": {
                    "expected": "FAIL",
                    "actual": "PASS"
                },
                "prototype-strawberry.html": {
                    "expected": "PASS",
                    "actual": "IMAGE PASS",
                    "is_unexpected": true
                }
            }
        }
    }
});""")
            return self.command._builder_data

    def test_parse_layout_test_results(self):
        failures = [test_failures.FailureMissingResult(), test_failures.FailureMissingImageHash(), test_failures.FailureMissingImage()]
        testname = 'fast/repaint/no-caret-repaint-in-non-content-editable-element.html'
        expected_results = [test_results.TestResult(testname, failures)]

        results = LayoutTestResults._parse_results_html(self._example_results_html)
        self.assertEqual(expected_results, results)

    def fetch_layout_test_results(self, results_url):
        # FIXME: This should cache that the result was a 404 and stop hitting the network.
        results_file = NetworkTransaction(convert_404_to_None=True).run(lambda: self._fetch_file_from_results(results_url, "full_results.json"))
        if not results_file:
            results_file = NetworkTransaction(convert_404_to_None=True).run(lambda: self._fetch_file_from_results(results_url, "results.html"))

        # results_from_string accepts either ORWT html or NRWT json.
        return LayoutTestResults.results_from_string(results_file)

 def fetch_layout_test_results(self, results_url):
     """Returns a LayoutTestResults object for results fetched from a given URL."""
     results_file = NetworkTransaction(convert_404_to_None=True).run(
         lambda: self._fetch_file(results_url, "failing_results.json"))
     revision = NetworkTransaction(convert_404_to_None=True).run(
         lambda: self._fetch_file(results_url, "LAST_CHANGE"))
     if not revision:
         results_file = None
     return LayoutTestResults.results_from_string(results_file, revision)

 def test_unexpected_mismatch_results(self):
     results = LayoutTestResults.results_from_string(self.example_full_results_json)
     self.assertEqual(
         [r.test_name() for r in results.unexpected_mismatch_results()],
         [
             'fast/dom/prototype-inheritance.html',
             'fast/dom/prototype-taco.html',
             'svg/dynamic-updates/SVGFEDropShadowElement-dom-stdDeviation-attr.html'
         ])

 def test_didnt_run_as_expected_results(self):
     results = LayoutTestResults.results_from_string(self.example_full_results_json)
     self.assertEqual(
         [r.test_name() for r in results.didnt_run_as_expected_results()],
         [
             'fast/dom/prototype-banana.html',
             'fast/dom/prototype-crashy.html',
             'fast/dom/prototype-inheritance.html',
             'fast/dom/prototype-newtest.html',
             'fast/dom/prototype-strawberry.html',
             'fast/dom/prototype-taco.html',
             'svg/dynamic-updates/SVGFEDropShadowElement-dom-stdDeviation-attr.html',
         ])

    def _setup_mock_builder_data(self):
        data = LayoutTestResults.results_from_string("""ADD_RESULTS({
    "tests": {
        "userscripts": {
            "first-test.html": {
                "expected": "PASS",
                "actual": "IMAGE+TEXT"
            },
            "second-test.html": {
                "expected": "FAIL",
                "actual": "IMAGE+TEXT"
            }
        }
    }
});""")
        for builder in ['MOCK builder', 'MOCK builder (Debug)', 'WebKit Mac10.7']:
            self.command._builder_data[builder] = data

 def test_results_from_string(self):
     self.assertIsNone(LayoutTestResults.results_from_string(None))
     self.assertIsNone(LayoutTestResults.results_from_string(""))

 def _create_layout_test_results(self):
     results_path = self._tool.port().layout_tests_results_path()
     results_html = self._read_file_contents(results_path)
     if not results_html:
         return None
     return LayoutTestResults.results_from_string(results_html)

 def test_results_from_string(self):
     self.assertEqual(LayoutTestResults.results_from_string(None), None)
     self.assertEqual(LayoutTestResults.results_from_string(""), None)

 def layout_test_results(self):
     if not self._layout_test_results:
         # FIXME: This should cache that the result was a 404 and stop hitting the network.
         self._layout_test_results = LayoutTestResults.results_from_string(self._fetch_results_html())
     return self._layout_test_results

 def latest_layout_test_results(self):
     return LayoutTestResults.results_from_string(layouttestresults_unittest.LayoutTestResultsTest.example_full_results_json)

 def test_missing_baseline(self):
     results = LayoutTestResults.results_from_string(self.example_full_results_json)
     missing_results = results.missing_results()
     self.assertEqual(len(missing_results), 1)
     self.assertEqual(missing_results[0].test_name(), "fast/dom/prototype-newtest.html")

 def _create_layout_test_results(self):
     results_path = self._host.filesystem.join(self._results_directory, "full_results.json")
     results_html = self._read_file_contents(results_path)
     if not results_html:
         return None
     return LayoutTestResults.results_from_string(results_html)

    def print_unexpected_results(self, summarized_results, enabled_pixel_tests_in_retry=False):
        passes = {}
        flaky = {}
        regressions = {}

        def add_to_dict_of_lists(dict, key, value):
            dict.setdefault(key, []).append(value)

        def add_result(result):
            test = result.test_name()
            actual = result.actual_results().split(" ")
            expected = result.expected_results().split(" ")

            if result.did_run_as_expected():
                # Don't print anything for tests that ran as expected.
                return

            if actual == ['PASS']:
                if 'CRASH' in expected:
                    add_to_dict_of_lists(passes, 'Expected to crash, but passed', test)
                elif 'TIMEOUT' in expected:
                    add_to_dict_of_lists(passes, 'Expected to timeout, but passed', test)
                else:
                    add_to_dict_of_lists(passes, 'Expected to fail, but passed', test)
            elif enabled_pixel_tests_in_retry and actual == ['TEXT', 'IMAGE+TEXT']:
                add_to_dict_of_lists(regressions, actual[0], test)
            elif len(actual) > 1 and bool(set(actual[1:]) & set(expected)):
                # We group flaky tests by the first actual result we got.
                add_to_dict_of_lists(flaky, actual[0], test)
            else:
                add_to_dict_of_lists(regressions, actual[0], test)

        test_results = LayoutTestResults(summarized_results)
        test_results.for_each_test(add_result)

        if len(passes) or len(flaky) or len(regressions):
            self._print("")
        if len(passes):
            for key, tests in passes.iteritems():
                self._print("%s: (%d)" % (key, len(tests)))
                tests.sort()
                for test in tests:
                    self._print("  %s" % test)
                self._print("")
            self._print("")

        if len(flaky):
            descriptions = TestExpectations.EXPECTATION_DESCRIPTIONS
            for key, tests in flaky.iteritems():
                result_type = TestExpectations.EXPECTATIONS[key.lower()]
                self._print("Unexpected flakiness: %s (%d)" % (descriptions[result_type], len(tests)))
                tests.sort()

                for test in tests:
                    result = test_results.result_for_test(test)
                    actual = result.actual_results().split(" ")
                    expected = result.expected_results().split(" ")
                    # FIXME: clean this up once the old syntax is gone
                    new_expectations_list = [TestExpectationLine.inverted_expectation_tokens[exp]
                                             for exp in list(set(actual) | set(expected))]
                    self._print("  %s [ %s ]" % (test, " ".join(new_expectations_list)))
                self._print("")
            self._print("")

        if len(regressions):
            descriptions = TestExpectations.EXPECTATION_DESCRIPTIONS
            for key, tests in regressions.iteritems():
                result_type = TestExpectations.EXPECTATIONS[key.lower()]
                self._print("Regressions: Unexpected %s (%d)" % (descriptions[result_type], len(tests)))
                tests.sort()
                for test in tests:
                    result = test_results.result_for_test(test)
                    actual = result.actual_results().split(" ")
                    expected = result.expected_results().split(" ")
                    new_expectations_list = [TestExpectationLine.inverted_expectation_tokens[exp] for exp in actual]
                    self._print("  %s [ %s ]" % (test, " ".join(new_expectations_list)))
                self._print("")

        if len(summarized_results['tests']) and self.debug_logging:
            self._print("%s" % ("-" * 78))

 def test_tests_matching_failure_types(self):
     results = LayoutTestResults.results_from_string(ORWTResultsHTMLParserTest._example_results_html_with_failing_tests)
     failing_tests = results.tests_matching_failure_types([test_failures.FailureTextMismatch])
     self.assertEqual(len(results.failing_tests()), 2)

 def test_set_failure_limit_count(self):
     results = LayoutTestResults([])
     self.assertEquals(results.failure_limit_count(), None)
     results.set_failure_limit_count(10)
     self.assertEquals(results.failure_limit_count(), 10)

 def test_chromium_revision(self):
     self.assertEqual(LayoutTestResults.results_from_string(self.example_full_results_json).chromium_revision(), 1234)