Introduce SpecifierSorter, a thing that knows how specifiers should be ordered.
[WebKit.git] / Tools / Scripts / webkitpy / layout_tests / models / test_configuration_unittest.py
1 # Copyright (C) 2011 Google Inc. All rights reserved.
2 #
3 # Redistribution and use in source and binary forms, with or without
4 # modification, are permitted provided that the following conditions are
5 # met:
6 #
7 #     * Redistributions of source code must retain the above copyright
8 # notice, this list of conditions and the following disclaimer.
9 #     * Redistributions in binary form must reproduce the above
10 # copyright notice, this list of conditions and the following disclaimer
11 # in the documentation and/or other materials provided with the
12 # distribution.
13 #     * Neither the Google name nor the names of its
14 # contributors may be used to endorse or promote products derived from
15 # this software without specific prior written permission.
16 #
17 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
29 import unittest
30
31 from webkitpy.layout_tests import port
32 from webkitpy.layout_tests.models.test_configuration import *
33
34
35 def make_mock_all_test_configurations_set():
36     all_test_configurations = set()
37     for version, architecture in (('snowleopard', 'x86'), ('xp', 'x86'), ('win7', 'x86'), ('lucid', 'x86'), ('lucid', 'x86_64')):
38         for build_type in ('debug', 'release'):
39             for graphics_type in ('cpu', 'gpu'):
40                 all_test_configurations.add(TestConfiguration(None, version, architecture, build_type, graphics_type))
41     return all_test_configurations
42
43 MOCK_MACROS = {
44     'mac': ['snowleopard'],
45     'win': ['xp', 'win7'],
46     'linux': ['lucid'],
47 }
48
49
50 class TestConfigurationTest(unittest.TestCase):
51     def test_items(self):
52         config = TestConfiguration(None, 'xp', 'x86', 'release', 'cpu')
53         result_config_dict = {}
54         for category, specifier in config.items():
55             result_config_dict[category] = specifier
56         self.assertEquals({'version': 'xp', 'architecture': 'x86', 'build_type': 'release', 'graphics_type': 'cpu'}, result_config_dict)
57
58     def test_keys(self):
59         config = TestConfiguration(None, 'xp', 'x86', 'release', 'cpu')
60         result_config_keys = []
61         for category in config.keys():
62             result_config_keys.append(category)
63         self.assertEquals(set(['graphics_type', 'version', 'architecture', 'build_type']), set(result_config_keys))
64
65     def test_str(self):
66         config = TestConfiguration(None, 'xp', 'x86', 'release', 'cpu')
67         self.assertEquals('<xp, x86, release, cpu>', str(config))
68
69     def test_repr(self):
70         config = TestConfiguration(None, 'xp', 'x86', 'release', 'cpu')
71         self.assertEquals("TestConfig(version='xp', architecture='x86', build_type='release', graphics_type='cpu')", repr(config))
72
73     def test_hash(self):
74         config_dict = {}
75         config_dict[TestConfiguration(None, 'xp', 'x86', 'release', 'cpu')] = True
76         self.assertTrue(TestConfiguration(None, 'xp', 'x86', 'release', 'cpu') in config_dict)
77         self.assertTrue(config_dict[TestConfiguration(None, 'xp', 'x86', 'release', 'cpu')])
78         config_dict[TestConfiguration(None, 'xp', 'x86', 'release', 'gpu')] = False
79         self.assertFalse(config_dict[TestConfiguration(None, 'xp', 'x86', 'release', 'gpu')])
80
81         def query_unknown_key():
82             config_dict[TestConfiguration(None, 'xp', 'x86', 'debug', 'gpu')]
83
84         self.assertRaises(KeyError, query_unknown_key)
85         self.assertTrue(TestConfiguration(None, 'xp', 'x86', 'release', 'gpu') in config_dict)
86         self.assertFalse(TestConfiguration(None, 'xp', 'x86', 'debug', 'gpu') in config_dict)
87         configs_list = [TestConfiguration(None, 'xp', 'x86', 'release', 'gpu'), TestConfiguration(None, 'xp', 'x86', 'debug', 'gpu'), TestConfiguration(None, 'xp', 'x86', 'debug', 'gpu')]
88         self.assertEquals(len(configs_list), 3)
89         self.assertEquals(len(set(configs_list)), 2)
90
91     def test_eq(self):
92         self.assertEquals(TestConfiguration(None, 'xp', 'x86', 'release', 'cpu'), TestConfiguration(None, 'xp', 'x86', 'release', 'cpu'))
93         self.assertEquals(TestConfiguration(port.get('test-win-xp', None)), TestConfiguration(None, 'xp', 'x86', 'release', 'cpu'))
94         self.assertNotEquals(TestConfiguration(None, 'xp', 'x86', 'release', 'gpu'), TestConfiguration(None, 'xp', 'x86', 'release', 'cpu'))
95         self.assertNotEquals(TestConfiguration(None, 'xp', 'x86', 'debug', 'cpu'), TestConfiguration(None, 'xp', 'x86', 'release', 'cpu'))
96
97     def test_values(self):
98         config = TestConfiguration(None, 'xp', 'x86', 'release', 'cpu')
99         result_config_values = []
100         for value in config.values():
101             result_config_values.append(value)
102         self.assertEquals(set(['xp', 'x86', 'release', 'cpu']), set(result_config_values))
103
104     def test_port_init(self):
105         config = TestConfiguration(port.get('test-win-xp', None))
106         self.assertEquals('<xp, x86, release, cpu>', str(config))
107
108
109 class SpecifierSorterTest(unittest.TestCase):
110     def __init__(self, testFunc):
111         self._all_test_configurations = make_mock_all_test_configurations_set()
112         unittest.TestCase.__init__(self, testFunc)
113
114     def test_init(self):
115         sorter = SpecifierSorter()
116         self.assertEquals(sorter.category_for_specifier('control'), None)
117         sorter = SpecifierSorter(self._all_test_configurations)
118         self.assertEquals(sorter.category_for_specifier('xp'), 'version')
119         sorter = SpecifierSorter(self._all_test_configurations, MOCK_MACROS)
120         self.assertEquals(sorter.category_for_specifier('mac'), 'version')
121
122     def test_add_specifier(self):
123         sorter = SpecifierSorter()
124         self.assertEquals(sorter.category_for_specifier('control'), None)
125         sorter.add_specifier('version', 'control')
126         self.assertEquals(sorter.category_for_specifier('control'), 'version')
127         sorter.add_specifier('version', 'one')
128         self.assertEquals(sorter.category_for_specifier('one'), 'version')
129         sorter.add_specifier('architecture', 'renaissance')
130         self.assertEquals(sorter.category_for_specifier('one'), 'version')
131         self.assertEquals(sorter.category_for_specifier('renaissance'), 'architecture')
132
133     def test_category_priority(self):
134         sorter = SpecifierSorter(self._all_test_configurations)
135         self.assertEquals(sorter.category_priority('version'), 0)
136         self.assertEquals(sorter.category_priority('build_type'), 2)
137
138     def test_specifier_priority(self):
139         sorter = SpecifierSorter(self._all_test_configurations)
140         self.assertEquals(sorter.specifier_priority('x86'), 1)
141         self.assertEquals(sorter.specifier_priority('gpu'), 3)
142         self.assertEquals(sorter.specifier_priority('snowleopard'), 0)
143
144     def test_sort_specifiers(self):
145         sorter = SpecifierSorter(self._all_test_configurations, MOCK_MACROS)
146         self.assertEquals(sorter.sort_specifiers(set()), [])
147         self.assertEquals(sorter.sort_specifiers(set(['x86'])), ['x86'])
148         self.assertEquals(sorter.sort_specifiers(set(['x86', 'win7'])), ['win7', 'x86'])
149         self.assertEquals(sorter.sort_specifiers(set(['gpu', 'x86', 'debug', 'win7'])), ['win7', 'x86', 'debug', 'gpu'])
150         self.assertEquals(sorter.sort_specifiers(set(['gpu', 'snowleopard', 'x86', 'debug', 'win7'])), ['snowleopard', 'win7', 'x86', 'debug', 'gpu'])
151         self.assertEquals(sorter.sort_specifiers(set(['gpu', 'x86', 'mac', 'debug', 'win7'])), ['mac', 'win7', 'x86', 'debug', 'gpu'])
152
153
154 class TestConfigurationConverterTest(unittest.TestCase):
155     def __init__(self, testFunc):
156         self._all_test_configurations = make_mock_all_test_configurations_set()
157         unittest.TestCase.__init__(self, testFunc)
158
159     def test_to_config_set(self):
160         converter = TestConfigurationConverter(self._all_test_configurations)
161
162         self.assertEquals(converter.to_config_set(set()), self._all_test_configurations)
163
164         self.assertEquals(converter.to_config_set(set(['foo'])), set())
165
166         self.assertEquals(converter.to_config_set(set(['xp', 'foo'])), set())
167
168         errors = []
169         self.assertEquals(converter.to_config_set(set(['xp', 'foo']), errors), set())
170         self.assertEquals(errors, ["Unrecognized modifier 'foo'"])
171
172         self.assertEquals(converter.to_config_set(set(['xp', 'x86_64'])), set())
173
174         configs_to_match = set([
175             TestConfiguration(None, 'xp', 'x86', 'release', 'gpu'),
176             TestConfiguration(None, 'xp', 'x86', 'release', 'cpu'),
177         ])
178         self.assertEquals(converter.to_config_set(set(['xp', 'release'])), configs_to_match)
179
180         configs_to_match = set([
181             TestConfiguration(None, 'snowleopard', 'x86', 'release', 'gpu'),
182             TestConfiguration(None, 'win7', 'x86', 'release', 'gpu'),
183             TestConfiguration(None, 'xp', 'x86', 'release', 'gpu'),
184             TestConfiguration(None, 'lucid', 'x86', 'release', 'gpu'),
185             TestConfiguration(None, 'lucid', 'x86_64', 'release', 'gpu'),
186        ])
187         self.assertEquals(converter.to_config_set(set(['gpu', 'release'])), configs_to_match)
188
189         configs_to_match = set([
190              TestConfiguration(None, 'lucid', 'x86_64', 'release', 'gpu'),
191              TestConfiguration(None, 'lucid', 'x86_64', 'debug', 'gpu'),
192              TestConfiguration(None, 'lucid', 'x86_64', 'release', 'cpu'),
193              TestConfiguration(None, 'lucid', 'x86_64', 'debug', 'cpu'),
194         ])
195         self.assertEquals(converter.to_config_set(set(['x86_64'])), configs_to_match)
196
197         configs_to_match = set([
198             TestConfiguration(None, 'lucid', 'x86_64', 'release', 'gpu'),
199             TestConfiguration(None, 'lucid', 'x86_64', 'debug', 'gpu'),
200             TestConfiguration(None, 'lucid', 'x86_64', 'release', 'cpu'),
201             TestConfiguration(None, 'lucid', 'x86_64', 'debug', 'cpu'),
202             TestConfiguration(None, 'lucid', 'x86', 'release', 'gpu'),
203             TestConfiguration(None, 'lucid', 'x86', 'debug', 'gpu'),
204             TestConfiguration(None, 'lucid', 'x86', 'release', 'cpu'),
205             TestConfiguration(None, 'lucid', 'x86', 'debug', 'cpu'),
206             TestConfiguration(None, 'snowleopard', 'x86', 'release', 'gpu'),
207             TestConfiguration(None, 'snowleopard', 'x86', 'debug', 'gpu'),
208             TestConfiguration(None, 'snowleopard', 'x86', 'release', 'cpu'),
209             TestConfiguration(None, 'snowleopard', 'x86', 'debug', 'cpu'),
210         ])
211         self.assertEquals(converter.to_config_set(set(['lucid', 'snowleopard'])), configs_to_match)
212
213         configs_to_match = set([
214             TestConfiguration(None, 'lucid', 'x86', 'release', 'gpu'),
215             TestConfiguration(None, 'lucid', 'x86', 'debug', 'gpu'),
216             TestConfiguration(None, 'lucid', 'x86', 'release', 'cpu'),
217             TestConfiguration(None, 'lucid', 'x86', 'debug', 'cpu'),
218             TestConfiguration(None, 'snowleopard', 'x86', 'release', 'gpu'),
219             TestConfiguration(None, 'snowleopard', 'x86', 'debug', 'gpu'),
220             TestConfiguration(None, 'snowleopard', 'x86', 'release', 'cpu'),
221             TestConfiguration(None, 'snowleopard', 'x86', 'debug', 'cpu'),
222         ])
223         self.assertEquals(converter.to_config_set(set(['lucid', 'snowleopard', 'x86'])), configs_to_match)
224
225         configs_to_match = set([
226             TestConfiguration(None, 'lucid', 'x86_64', 'release', 'cpu'),
227             TestConfiguration(None, 'lucid', 'x86', 'release', 'cpu'),
228             TestConfiguration(None, 'snowleopard', 'x86', 'release', 'cpu'),
229         ])
230         self.assertEquals(converter.to_config_set(set(['lucid', 'snowleopard', 'release', 'cpu'])), configs_to_match)
231
232     def test_macro_expansion(self):
233         converter = TestConfigurationConverter(self._all_test_configurations, MOCK_MACROS)
234
235         configs_to_match = set([
236             TestConfiguration(None, 'xp', 'x86', 'release', 'gpu'),
237             TestConfiguration(None, 'xp', 'x86', 'release', 'cpu'),
238             TestConfiguration(None, 'win7', 'x86', 'release', 'gpu'),
239             TestConfiguration(None, 'win7', 'x86', 'release', 'cpu'),
240         ])
241         self.assertEquals(converter.to_config_set(set(['win', 'release'])), configs_to_match)
242
243         configs_to_match = set([
244             TestConfiguration(None, 'xp', 'x86', 'release', 'gpu'),
245             TestConfiguration(None, 'win7', 'x86', 'release', 'gpu'),
246             TestConfiguration(None, 'lucid', 'x86', 'release', 'gpu'),
247             TestConfiguration(None, 'lucid', 'x86_64', 'release', 'gpu'),
248         ])
249         self.assertEquals(converter.to_config_set(set(['win', 'lucid', 'release', 'gpu'])), configs_to_match)
250
251         configs_to_match = set([
252             TestConfiguration(None, 'xp', 'x86', 'release', 'gpu'),
253             TestConfiguration(None, 'win7', 'x86', 'release', 'gpu'),
254             TestConfiguration(None, 'snowleopard', 'x86', 'release', 'gpu'),
255         ])
256         self.assertEquals(converter.to_config_set(set(['win', 'mac', 'release', 'gpu'])), configs_to_match)
257
258     def test_to_specifier_lists(self):
259         converter = TestConfigurationConverter(self._all_test_configurations)
260
261         self.assertEquals(converter.to_specifiers_list(set(self._all_test_configurations)), [])
262
263         configs_to_match = set([
264             TestConfiguration(None, 'xp', 'x86', 'release', 'gpu'),
265             TestConfiguration(None, 'xp', 'x86', 'release', 'cpu'),
266         ])
267         self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['release', 'xp'])])
268
269         configs_to_match = set([
270             TestConfiguration(None, 'xp', 'x86', 'release', 'gpu'),
271             TestConfiguration(None, 'xp', 'x86', 'release', 'cpu'),
272             TestConfiguration(None, 'xp', 'x86', 'debug', 'gpu'),
273             TestConfiguration(None, 'xp', 'x86', 'debug', 'cpu'),
274         ])
275         self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['xp'])])
276
277         configs_to_match = set([
278             TestConfiguration(None, 'xp', 'x86', 'release', 'gpu'),
279             TestConfiguration(None, 'lucid', 'x86_64', 'debug', 'cpu'),
280         ])
281         self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['debug', 'x86_64', 'lucid', 'cpu']), set(['release', 'gpu', 'xp'])])
282
283         configs_to_match = set([
284             TestConfiguration(None, 'xp', 'x86', 'release', 'gpu'),
285             TestConfiguration(None, 'xp', 'x86', 'release', 'cpu'),
286             TestConfiguration(None, 'lucid', 'x86_64', 'debug', 'cpu'),
287             TestConfiguration(None, 'lucid', 'x86', 'debug', 'cpu'),
288             TestConfiguration(None, 'lucid', 'x86_64', 'debug', 'gpu'),
289             TestConfiguration(None, 'lucid', 'x86', 'debug', 'gpu'),
290         ])
291         self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['release', 'xp']), set(['debug', 'lucid'])])
292
293         configs_to_match = set([
294             TestConfiguration(None, 'xp', 'x86', 'release', 'gpu'),
295             TestConfiguration(None, 'snowleopard', 'x86', 'release', 'gpu'),
296             TestConfiguration(None, 'win7', 'x86', 'release', 'gpu'),
297             TestConfiguration(None, 'lucid', 'x86', 'release', 'gpu'),
298             TestConfiguration(None, 'lucid', 'x86_64', 'release', 'gpu'),
299         ])
300         self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['release', 'gpu'])])
301
302         configs_to_match = set([
303             TestConfiguration(None, 'xp', 'x86', 'release', 'gpu'),
304             TestConfiguration(None, 'snowleopard', 'x86', 'release', 'gpu'),
305         ])
306         self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['xp', 'snowleopard', 'release', 'gpu'])])
307
308         configs_to_match = set([
309             TestConfiguration(None, 'xp', 'x86', 'release', 'gpu'),
310             TestConfiguration(None, 'snowleopard', 'x86', 'release', 'gpu'),
311             TestConfiguration(None, 'win7', 'x86', 'release', 'gpu'),
312             TestConfiguration(None, 'win7', 'x86', 'debug', 'gpu'),
313             TestConfiguration(None, 'lucid', 'x86', 'release', 'gpu'),
314         ])
315         self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['release', 'gpu', 'lucid', 'x86']), set(['gpu', 'win7']), set(['release', 'gpu', 'xp', 'snowleopard'])])
316
317     def test_macro_collapsing(self):
318         macros = {'foo': ['bar', 'baz'], 'people': ['bob', 'alice', 'john']}
319
320         specifiers_list = [set(['john', 'godzilla', 'bob', 'alice'])]
321         TestConfigurationConverter.collapse_macros(macros, specifiers_list)
322         self.assertEquals(specifiers_list, [set(['people', 'godzilla'])])
323
324         specifiers_list = [set(['john', 'godzilla', 'alice'])]
325         TestConfigurationConverter.collapse_macros(macros, specifiers_list)
326         self.assertEquals(specifiers_list, [set(['john', 'godzilla', 'alice', 'godzilla'])])
327
328         specifiers_list = [set(['bar', 'godzilla', 'baz', 'bob', 'alice', 'john'])]
329         TestConfigurationConverter.collapse_macros(macros, specifiers_list)
330         self.assertEquals(specifiers_list, [set(['foo', 'godzilla', 'people'])])
331
332         specifiers_list = [set(['bar', 'godzilla', 'baz', 'bob']), set(['bar', 'baz']), set(['people', 'alice', 'bob', 'john'])]
333         TestConfigurationConverter.collapse_macros(macros, specifiers_list)
334         self.assertEquals(specifiers_list, [set(['bob', 'foo', 'godzilla']), set(['foo']), set(['people'])])
335
336     def test_converter_macro_collapsing(self):
337         converter = TestConfigurationConverter(self._all_test_configurations, MOCK_MACROS)
338
339         configs_to_match = set([
340             TestConfiguration(None, 'xp', 'x86', 'release', 'gpu'),
341             TestConfiguration(None, 'xp', 'x86', 'release', 'cpu'),
342             TestConfiguration(None, 'win7', 'x86', 'release', 'gpu'),
343             TestConfiguration(None, 'win7', 'x86', 'release', 'cpu'),
344         ])
345         self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['win', 'release'])])
346
347         configs_to_match = set([
348             TestConfiguration(None, 'xp', 'x86', 'release', 'gpu'),
349             TestConfiguration(None, 'win7', 'x86', 'release', 'gpu'),
350             TestConfiguration(None, 'lucid', 'x86', 'release', 'gpu'),
351             TestConfiguration(None, 'lucid', 'x86_64', 'release', 'gpu'),
352         ])
353         self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['win', 'linux', 'release', 'gpu'])])
354
355         configs_to_match = set([
356             TestConfiguration(None, 'xp', 'x86', 'release', 'gpu'),
357             TestConfiguration(None, 'win7', 'x86', 'release', 'gpu'),
358             TestConfiguration(None, 'snowleopard', 'x86', 'release', 'gpu'),
359         ])
360         self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['win', 'mac', 'release', 'gpu'])])