Clean up ChunkedUpdateDrawingAreaProxy
[WebKit-https.git] / WebKitTools / Scripts / webkitpy / style / filter_unittest.py
1 # Copyright (C) 2010 Chris Jerdonek (chris.jerdonek@gmail.com)
2 #
3 # Redistribution and use in source and binary forms, with or without
4 # modification, are permitted provided that the following conditions
5 # are met:
6 # 1.  Redistributions of source code must retain the above copyright
7 #     notice, this list of conditions and the following disclaimer.
8 # 2.  Redistributions in binary form must reproduce the above copyright
9 #     notice, this list of conditions and the following disclaimer in the
10 #     documentation and/or other materials provided with the distribution.
11 #
12 # THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
13 # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
14 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
15 # DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
16 # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
17 # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
18 # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
19 # ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
20 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
21 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22
23 """Unit tests for filter.py."""
24
25 import unittest
26
27 from filter import _CategoryFilter as CategoryFilter
28 from filter import validate_filter_rules
29 from filter import FilterConfiguration
30
31 # On Testing __eq__() and __ne__():
32 #
33 # In the tests below, we deliberately do not use assertEquals() or
34 # assertNotEquals() to test __eq__() or __ne__().  We do this to be
35 # very explicit about what we are testing, especially in the case
36 # of assertNotEquals().
37 #
38 # Part of the reason is that it is not immediately clear what
39 # expression the unittest module uses to assert "not equals" -- the
40 # negation of __eq__() or __ne__(), which are not necessarily
41 # equivalent expresions in Python.  For example, from Python's "Data
42 # Model" documentation--
43 #
44 #   "There are no implied relationships among the comparison
45 #    operators. The truth of x==y does not imply that x!=y is
46 #    false.  Accordingly, when defining __eq__(), one should
47 #    also define __ne__() so that the operators will behave as
48 #    expected."
49 #
50 #   (from http://docs.python.org/reference/datamodel.html#object.__ne__ )
51
52 class ValidateFilterRulesTest(unittest.TestCase):
53
54     """Tests validate_filter_rules() function."""
55
56     def test_validate_filter_rules(self):
57         all_categories = ["tabs", "whitespace", "build/include"]
58
59         bad_rules = [
60             "tabs",
61             "*tabs",
62             " tabs",
63             " +tabs",
64             "+whitespace/newline",
65             "+xxx",
66             ]
67
68         good_rules = [
69             "+tabs",
70             "-tabs",
71             "+build"
72             ]
73
74         for rule in bad_rules:
75             self.assertRaises(ValueError, validate_filter_rules,
76                               [rule], all_categories)
77
78         for rule in good_rules:
79             # This works: no error.
80             validate_filter_rules([rule], all_categories)
81
82
83 class CategoryFilterTest(unittest.TestCase):
84
85     """Tests CategoryFilter class."""
86
87     def test_init(self):
88         """Test __init__ method."""
89         # Test that the attributes are getting set correctly.
90         filter = CategoryFilter(["+"])
91         self.assertEquals(["+"], filter._filter_rules)
92
93     def test_init_default_arguments(self):
94         """Test __init__ method default arguments."""
95         filter = CategoryFilter()
96         self.assertEquals([], filter._filter_rules)
97
98     def test_str(self):
99         """Test __str__ "to string" operator."""
100         filter = CategoryFilter(["+a", "-b"])
101         self.assertEquals(str(filter), "+a,-b")
102
103     def test_eq(self):
104         """Test __eq__ equality function."""
105         filter1 = CategoryFilter(["+a", "+b"])
106         filter2 = CategoryFilter(["+a", "+b"])
107         filter3 = CategoryFilter(["+b", "+a"])
108
109         # See the notes at the top of this module about testing
110         # __eq__() and __ne__().
111         self.assertTrue(filter1.__eq__(filter2))
112         self.assertFalse(filter1.__eq__(filter3))
113
114     def test_ne(self):
115         """Test __ne__ inequality function."""
116         # By default, __ne__ always returns true on different objects.
117         # Thus, just check the distinguishing case to verify that the
118         # code defines __ne__.
119         #
120         # Also, see the notes at the top of this module about testing
121         # __eq__() and __ne__().
122         self.assertFalse(CategoryFilter().__ne__(CategoryFilter()))
123
124     def test_should_check(self):
125         """Test should_check() method."""
126         filter = CategoryFilter()
127         self.assertTrue(filter.should_check("everything"))
128         # Check a second time to exercise cache.
129         self.assertTrue(filter.should_check("everything"))
130
131         filter = CategoryFilter(["-"])
132         self.assertFalse(filter.should_check("anything"))
133         # Check a second time to exercise cache.
134         self.assertFalse(filter.should_check("anything"))
135
136         filter = CategoryFilter(["-", "+ab"])
137         self.assertTrue(filter.should_check("abc"))
138         self.assertFalse(filter.should_check("a"))
139
140         filter = CategoryFilter(["+", "-ab"])
141         self.assertFalse(filter.should_check("abc"))
142         self.assertTrue(filter.should_check("a"))
143
144
145 class FilterConfigurationTest(unittest.TestCase):
146
147     """Tests FilterConfiguration class."""
148
149     def _config(self, base_rules, path_specific, user_rules):
150         """Return a FilterConfiguration instance."""
151         return FilterConfiguration(base_rules=base_rules,
152                                    path_specific=path_specific,
153                                    user_rules=user_rules)
154
155     def test_init(self):
156         """Test __init__ method."""
157         # Test that the attributes are getting set correctly.
158         # We use parameter values that are different from the defaults.
159         base_rules = ["-"]
160         path_specific = [(["path"], ["+a"])]
161         user_rules = ["+"]
162
163         config = self._config(base_rules, path_specific, user_rules)
164
165         self.assertEquals(base_rules, config._base_rules)
166         self.assertEquals(path_specific, config._path_specific)
167         self.assertEquals(user_rules, config._user_rules)
168
169     def test_default_arguments(self):
170         # Test that the attributes are getting set correctly to the defaults.
171         config = FilterConfiguration()
172
173         self.assertEquals([], config._base_rules)
174         self.assertEquals([], config._path_specific)
175         self.assertEquals([], config._user_rules)
176
177     def test_eq(self):
178         """Test __eq__ method."""
179         # See the notes at the top of this module about testing
180         # __eq__() and __ne__().
181         self.assertTrue(FilterConfiguration().__eq__(FilterConfiguration()))
182
183         # Verify that a difference in any argument causes equality to fail.
184         config = FilterConfiguration()
185
186         # These parameter values are different from the defaults.
187         base_rules = ["-"]
188         path_specific = [(["path"], ["+a"])]
189         user_rules = ["+"]
190
191         self.assertFalse(config.__eq__(FilterConfiguration(
192                                            base_rules=base_rules)))
193         self.assertFalse(config.__eq__(FilterConfiguration(
194                                            path_specific=path_specific)))
195         self.assertFalse(config.__eq__(FilterConfiguration(
196                                            user_rules=user_rules)))
197
198     def test_ne(self):
199         """Test __ne__ method."""
200         # By default, __ne__ always returns true on different objects.
201         # Thus, just check the distinguishing case to verify that the
202         # code defines __ne__.
203         #
204         # Also, see the notes at the top of this module about testing
205         # __eq__() and __ne__().
206         self.assertFalse(FilterConfiguration().__ne__(FilterConfiguration()))
207
208     def test_base_rules(self):
209         """Test effect of base_rules on should_check()."""
210         base_rules = ["-b"]
211         path_specific = []
212         user_rules = []
213
214         config = self._config(base_rules, path_specific, user_rules)
215
216         self.assertTrue(config.should_check("a", "path"))
217         self.assertFalse(config.should_check("b", "path"))
218
219     def test_path_specific(self):
220         """Test effect of path_rules_specifier on should_check()."""
221         base_rules = ["-"]
222         path_specific = [(["path1"], ["+b"]),
223                          (["path2"], ["+c"])]
224         user_rules = []
225
226         config = self._config(base_rules, path_specific, user_rules)
227
228         self.assertFalse(config.should_check("c", "path1"))
229         self.assertTrue(config.should_check("c", "path2"))
230         # Test that first match takes precedence.
231         self.assertFalse(config.should_check("c", "path2/path1"))
232
233     def test_path_with_different_case(self):
234         """Test a path that differs only in case."""
235         base_rules = ["-"]
236         path_specific = [(["Foo/"], ["+whitespace"])]
237         user_rules = []
238
239         config = self._config(base_rules, path_specific, user_rules)
240
241         self.assertFalse(config.should_check("whitespace", "Fooo/bar.txt"))
242         self.assertTrue(config.should_check("whitespace", "Foo/bar.txt"))
243         # Test different case.
244         self.assertTrue(config.should_check("whitespace", "FOO/bar.txt"))
245
246     def test_user_rules(self):
247         """Test effect of user_rules on should_check()."""
248         base_rules = ["-"]
249         path_specific = []
250         user_rules = ["+b"]
251
252         config = self._config(base_rules, path_specific, user_rules)
253
254         self.assertFalse(config.should_check("a", "path"))
255         self.assertTrue(config.should_check("b", "path"))
256