webkitpy: Fix removing expectation lines.

third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/models/test_expectations.py

 # Copyright (C) 2010 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 232 matching lines @@
         self.comment = None
         self.matching_tests = []
         self.warnings = []
         self.is_extra_skipped_test = False
 
     def __str__(self):
         return 'TestExpectationLine{name=%s, matching_configurations=%s, original_string=%s}' % (
             self.name, self.matching_configurations, self.original_string)
 
     def __eq__(self, other):
-        return (self.original_string == other.original_string
+        return (isinstance(other, self.__class__)
+                and self.original_string == other.original_string
                 and self.filename == other.filename
                 and self.line_numbers == other.line_numbers
                 and self.name == other.name
                 and self.path == other.path
                 and self.bugs == other.bugs
                 and self.specifiers == other.specifiers
                 and self.parsed_specifiers == other.parsed_specifiers
                 and self.matching_configurations == other.matching_configurations
                 and self.expectations == other.expectations
                 and self.parsed_expectations == other.parsed_expectations
@@ skipping 424 matching lines @@
         return ' '.join(retval)
 
     def expectation_to_string(self, expectation):
         """Return the uppercased string equivalent of a given expectation."""
         for item in TestExpectations.EXPECTATIONS.items():
             if item[1] == expectation:
                 return item[0].upper()
         raise ValueError(expectation)
 
     def remove_expectation_line(self, test):
-        if not self.has_test(test):
+        if not self.has_test(test.name):
             return
         self._clear_expectations_for_test(test)
         del self._test_to_expectation_line[test]
 
     def add_expectation_line(self, expectation_line,
                              model_all_expectations=False):
         """Returns a list of warnings encountered while matching specifiers."""
 
         if expectation_line.is_invalid():
             return
@@ skipping 464 matching lines @@
         for test in self._expectations:
             if test.name and test.name in tests_to_skip:
                 test.warnings.append('%s:%s %s is also in a Skipped file.' % (test.filename, test.line_numbers, test.name))
 
         model = TestExpectationsModel(self._shorten_filename)
         for test_name in tests_to_skip:
             expectation_line = self._parser.expectation_for_skipped_test(test_name)
             model.add_expectation_line(expectation_line)
         self._model.merge_model(model)
 
-    def remove_tests(self, tests_to_remove):
+    def remove_tests_from_expectations(self, tests_to_remove):
         for test in self._expectations:
-            if test.name and test.name in tests_to_remove:
-                self.remove_expectation_line(test)
+            if not test.name:
+                continue
+            if test.name not in tests_to_remove:
+                continue
+            self._expectations.remove(test)
+            if not self._model.has_test(test.name):
+                continue
+            line = self._model.get_expectation_line(test.name)
+            self._model.remove_expectation_line(line)
 
     def add_expectations_from_bot(self):
         # FIXME: With mode 'very-flaky' and 'maybe-flaky', this will show the expectations entry in the flakiness
         # dashboard rows for each test to be whatever the bot thinks they should be. Is this a good thing?
         bot_expectations = self._port.bot_expectations()
         model = TestExpectationsModel(self._shorten_filename)
         for test_name in bot_expectations:
             expectation_line = self._parser.expectation_line_for_test(test_name, bot_expectations[test_name])
 
             # Unexpected results are merged into existing expectations.
             model.add_expectation_line(expectation_line)
         self._model.merge_model(model)
 
     def add_expectation_line(self, expectation_line):
         self._model.add_expectation_line(expectation_line)
         self._expectations += [expectation_line]
 
-    def remove_expectation_line(self, test):
-        if not self._model.has_test(test):
-            return
-        self._expectations.remove(self._model.get_expectation_line(test))
-        self._model.remove_expectation_line(test)
-
     @staticmethod
     def list_to_string(expectation_lines, test_configuration_converter=None, reconstitute_only_these=None):
         def serialize(expectation_line):
             # If reconstitute_only_these is an empty list, we want to return original_string.
             # So we need to compare reconstitute_only_these to None, not just check if it's falsey.
             if reconstitute_only_these is None or expectation_line in reconstitute_only_these:
                 return expectation_line.to_string(test_configuration_converter)
             return expectation_line.original_string
 
         def nones_out(expectation_line):
             return expectation_line is not None
 
         return '\n'.join(filter(nones_out, map(serialize, expectation_lines)))