Exemplo n.º 1
0
 def _expect_port_for_expectations_path(self, expected_port_implementation, expectations_path):
     host = MockHost()
     checker = TestExpectationsChecker(expectations_path, ErrorCollector(), host=host)
     port = checker._determine_port_from_expectations_path(host, expectations_path)
     if port:
         self.assertTrue(port.name().startswith(expected_port_implementation))
     else:
         self.assertIsNone(expected_port_implementation)
Exemplo n.º 2
0
 def _expect_port_for_expectations_path(self, expected_port_implementation, expectations_path):
     host = MockHost()
     checker = TestExpectationsChecker(expectations_path, ErrorCollector(), host=host)
     port = checker._determine_port_from_expectations_path(host, expectations_path)
     if port:
         self.assertTrue(port.name().startswith(expected_port_implementation))
     else:
         self.assertEquals(None, expected_port_implementation)
Exemplo n.º 3
0
 def _expect_port_for_expectations_path(self, expected_port_or_port_class, expectations_path):
     host = MockHost()
     checker = TestExpectationsChecker(expectations_path, ErrorCollector(), host=host)
     port = checker._determine_port_from_exepectations_path(host, expectations_path)
     if port:
         self.assertEquals(port.__class__.__name__, expected_port_or_port_class)
     else:
         self.assertEquals(port, expected_port_or_port_class)
Exemplo n.º 4
0
 def assert_lines_lint(self, lines, expected):
     self._error_collector.reset_errors()
     checker = TestExpectationsChecker('test/test_expectations.txt',
                                       self._error_collector)
     checker.check_test_expectations(expectations_str='\n'.join(lines),
                                     tests=[self._test_file],
                                     overrides=None)
     checker.check_tabs(lines)
     self.assertEqual(expected, self._error_collector.get_errors())
 def _expect_port_for_expectations_path(self, expected_port_or_port_class,
                                        expectations_path):
     host = MockHost()
     checker = TestExpectationsChecker(expectations_path,
                                       ErrorCollector(),
                                       host=host)
     port = checker._determine_port_from_exepectations_path(
         host, expectations_path)
     if port:
         self.assertEquals(port.__class__.__name__,
                           expected_port_or_port_class)
     else:
         self.assertEquals(port, expected_port_or_port_class)
Exemplo n.º 6
0
 def assert_lines_lint(self, lines, should_pass, expected_output=None):
     self._error_collector.reset_errors()
     checker = TestExpectationsChecker('test/test_expectations.txt',
                                       self._error_collector, host=MockHost())
     checker.check_test_expectations(expectations_str='\n'.join(lines),
                                     tests=[self._test_file],
                                     overrides=None)
     checker.check_tabs(lines)
     if should_pass:
         self.assertEqual('', self._error_collector.get_errors())
     elif expected_output:
         self.assertEquals(expected_output, self._error_collector.get_errors())
     else:
         self.assertNotEquals('', self._error_collector.get_errors())
     self.assertTrue(self._error_collector.turned_off_filtering)
Exemplo n.º 7
0
    def assert_lines_lint(self, lines, should_pass, expected_output=None):
        self._error_collector.reset_errors()

        host = MockHost()
        checker = TestExpectationsChecker('test/TestExpectations',
                                          self._error_collector,
                                          host=host)

        # We should have failed to find a valid port object for that path.
        self.assertIsNone(checker._port_obj)

        # Now use a test port so we can check the lines.
        checker._port_obj = host.port_factory.get('test-mac-leopard')
        checker.check_test_expectations(expectations_str='\n'.join(lines),
                                        tests=[self._test_file])
        checker.check_tabs(lines)
        if should_pass:
            self.assertEqual('', self._error_collector.get_errors())
        elif expected_output:
            self.assertEqual(expected_output,
                             self._error_collector.get_errors())
        else:
            self.assertNotEquals('', self._error_collector.get_errors())

        # Note that a patch might change a line that introduces errors elsewhere, but we
        # don't want to lint the whole file (it can unfairly punish patches for pre-existing errors).
        # We rely on a separate lint-webkitpy step on the bots to keep the whole file okay.
        # FIXME: See https://bugs.webkit.org/show_bug.cgi?id=104712 .
        self.assertFalse(self._error_collector.turned_off_filtering)
    def assert_lines_lint(self, lines, should_pass, expected_output=None):
        self._error_collector.reset_errors()

        host = MockHost()
        checker = TestExpectationsChecker('test/test_expectations.txt',
                                          self._error_collector,
                                          host=host)

        # We should have failed to find a valid port object for that path.
        self.assertEquals(checker._port_obj, None)

        # Now use a test port so we can check the lines.
        checker._port_obj = host.port_factory.get('test-mac-leopard')
        checker.check_test_expectations(expectations_str='\n'.join(lines),
                                        tests=[self._test_file],
                                        overrides=None)
        checker.check_tabs(lines)
        if should_pass:
            self.assertEqual('', self._error_collector.get_errors())
        elif expected_output:
            self.assertEquals(expected_output,
                              self._error_collector.get_errors())
        else:
            self.assertNotEquals('', self._error_collector.get_errors())
        self.assertTrue(self._error_collector.turned_off_filtering)
Exemplo n.º 9
0
    def assert_lines_lint(self, lines, should_pass, expected_output=None):
        self._error_collector.reset_errors()

        host = MockHost()
        checker = TestExpectationsChecker('test/TestExpectations',
                                          self._error_collector, host=host)

        # We should have a valid port, but override it with a test port so we
        # can check the lines.
        self.assertIsNotNone(checker._port_obj)
        checker._port_obj = host.port_factory.get('test-mac-mac10.10')

        checker.check_test_expectations(expectations_str='\n'.join(lines),
                                        tests=[self._test_file])
        checker.check_tabs(lines)
        if should_pass:
            self.assertEqual('', self._error_collector.get_errors())
        elif expected_output:
            self.assertEqual(expected_output, self._error_collector.get_errors())
        else:
            self.assertNotEquals('', self._error_collector.get_errors())

        # Note that a patch might change a line that introduces errors elsewhere, but we
        # don't want to lint the whole file (it can unfairly punish patches for pre-existing errors).
        # We rely on a separate lint-webkitpy step on the bots to keep the whole file okay.
        # FIXME: See https://bugs.webkit.org/show_bug.cgi?id=104712 .
        self.assertFalse(self._error_collector.turned_off_filtering)
Exemplo n.º 10
0
    def _expect_port_for_expectations_path(self, expected_port_implementation,
                                           expectations_path):
        host = MockHost()
        checker = TestExpectationsChecker(expectations_path,
                                          ErrorCollector(),
                                          host=host)
        port = checker._determine_port_from_expectations_path(
            host, expectations_path)
        if port:
            self.assertTrue(
                port.name().startswith(expected_port_implementation))
        else:
            self.assertEquals(None, expected_port_implementation)

        host = MockHost()
        expectations_path = expectations_path.replace('TestExpectations',
                                                      'test_expectations.txt')
        if not expectations_path.startswith('/mock-checkout'):
            expectations_full_path = '/mock-checkout/' + expectations_path
        else:
            expectations_full_path = expectations_path
        host.filesystem.files[expectations_full_path] = 'some content'

        checker = TestExpectationsChecker(expectations_path,
                                          ErrorCollector(),
                                          host=host)
        port = checker._determine_port_from_expectations_path(
            host, expectations_path)
        if port:
            self.assertTrue(
                port.name().startswith(expected_port_implementation))
        else:
            self.assertEquals(None, expected_port_implementation)
Exemplo n.º 11
0
    def _expect_port_for_expectations_path(self, expected_port_implementation, expectations_path):
        host = MockHost()
        checker = TestExpectationsChecker(expectations_path, ErrorCollector(), host=host)
        port = checker._determine_port_from_expectations_path(host, expectations_path)
        if port:
            self.assertTrue(port.name().startswith(expected_port_implementation))
        else:
            self.assertEquals(None, expected_port_implementation)

        host = MockHost()
        expectations_path = expectations_path.replace('TestExpectations', 'test_expectations.txt')
        if not expectations_path.startswith('/mock-checkout'):
            expectations_full_path = '/mock-checkout/' + expectations_path
        else:
            expectations_full_path = expectations_path
        host.filesystem.files[expectations_full_path] = 'some content'

        checker = TestExpectationsChecker(expectations_path, ErrorCollector(), host=host)
        port = checker._determine_port_from_expectations_path(host, expectations_path)
        if port:
            self.assertTrue(port.name().startswith(expected_port_implementation))
        else:
            self.assertEquals(None, expected_port_implementation)
Exemplo n.º 12
0
 def assert_lines_lint(self, lines, expected):
     self._error_collector.reset_errors()
     checker = TestExpectationsChecker('test/test_expectations.txt',
                                       self._error_collector)
     checker.check_test_expectations(expectations_str='\n'.join(lines),
                                     tests=[self._test_file],
                                     overrides=None)
     checker.check_tabs(lines)
     self.assertEqual(expected, self._error_collector.get_errors())
Exemplo n.º 13
0
 def assert_lines_lint(self, lines, should_pass, expected_output=None):
     self._error_collector.reset_errors()
     checker = TestExpectationsChecker('test/test_expectations.txt',
                                       self._error_collector,
                                       host=MockHost())
     checker.check_test_expectations(expectations_str='\n'.join(lines),
                                     tests=[self._test_file],
                                     overrides=None)
     checker.check_tabs(lines)
     if should_pass:
         self.assertEqual('', self._error_collector.get_errors())
     elif expected_output:
         self.assertEquals(expected_output,
                           self._error_collector.get_errors())
     else:
         self.assertNotEquals('', self._error_collector.get_errors())
     self.assertTrue(self._error_collector.turned_off_filtering)
Exemplo n.º 14
0
    def assert_lines_lint(self, lines, should_pass, expected_output=None):
        self._error_collector.reset_errors()

        host = MockHost()
        checker = TestExpectationsChecker('test/TestExpectations',
                                          self._error_collector, host=host)

        # We should have failed to find a valid port object for that path.
        self.assertEquals(checker._port_obj, None)

        # Now use a test port so we can check the lines.
        checker._port_obj = host.port_factory.get('test-mac-leopard')
        checker.check_test_expectations(expectations_str='\n'.join(lines),
                                        tests=[self._test_file])
        checker.check_tabs(lines)
        if should_pass:
            self.assertEqual('', self._error_collector.get_errors())
        elif expected_output:
            self.assertEquals(expected_output, self._error_collector.get_errors())
        else:
            self.assertNotEquals('', self._error_collector.get_errors())
        self.assertTrue(self._error_collector.turned_off_filtering)
Exemplo n.º 15
0
 def process_expectations(self, expectations, overrides=None):
     self._checker = TestExpectationsChecker()