1import unittest
2import collections
3
4
5class TestGroups(unittest.TestCase):
6
7    def getGroups_generic(self):
8        groups, _ = self.objectGenerator("groups")
9        groups.update({
10            "group 1": ["A", "B", "C"],
11            "group 2": ["x", "y", "z"],
12            "group 3": [],
13            "group 4": ["A"]
14        })
15        return groups
16
17    # ----
18    # repr
19    # ----
20
21    def test_reprContents(self):
22        font, _ = self.objectGenerator("font")
23        groups = font.groups
24        value = groups._reprContents()
25        self.assertIsInstance(value, list)
26        found = False
27        for i in value:
28            self.assertIsInstance(i, str)
29            if "for font" in value:
30                found = True
31        self.assertTrue(found)
32
33    def test_reprContents_noFont(self):
34        groups, _ = self.objectGenerator("groups")
35        value = groups._reprContents()
36        self.assertIsInstance(value, list)
37        self.assertEqual(value, [])
38
39
40    # -------
41    # Parents
42    # -------
43
44    def test_get_parent_font(self):
45        font, _ = self.objectGenerator("font")
46        groups = font.groups
47        self.assertIsNotNone(groups.font)
48        self.assertEqual(
49            groups.font,
50            font
51        )
52
53    def test_get_parent_font_none(self):
54        groups, _ = self.objectGenerator("groups")
55        self.assertIsNone(groups.font)
56
57    def test_set_parent_font(self):
58        font, _ = self.objectGenerator("font")
59        groups, _ = self.objectGenerator("groups")
60        groups.font = font
61        self.assertIsNotNone(groups.font)
62        self.assertEqual(
63            groups.font,
64            font
65        )
66
67    def test_set_parent_font_none(self):
68        groups, _ = self.objectGenerator("groups")
69        groups.font = None
70        self.assertIsNone(groups.font)
71
72    def test_set_parent_differentFont(self):
73        font, _ = self.objectGenerator("font")
74        fontB, _ = self.objectGenerator("font")
75        groups, _ = self.objectGenerator("groups")
76        groups.font = font
77        self.assertIsNotNone(groups.font)
78
79        with self.assertRaises(AssertionError):
80            groups.font = fontB
81
82    # ---
83    # len
84    # ---
85
86    def test_len_initial(self):
87        groups = self.getGroups_generic()
88        self.assertEqual(
89            len(groups),
90            4
91        )
92
93    def test_len_clear(self):
94        groups = self.getGroups_generic()
95        groups.clear()
96        self.assertEqual(
97            len(groups),
98            0
99        )
100
101    def test_len_add(self):
102        groups = self.getGroups_generic()
103        groups['group 5'] = ["D","E","F"]
104        self.assertEqual(
105            len(groups),
106            5
107        )
108
109    def test_len_subtract(self):
110        groups = self.getGroups_generic()
111        groups.pop('group 4')
112        self.assertEqual(
113            len(groups),
114            3
115        )
116
117
118
119    # ---
120    # Get
121    # ---
122
123    def test_get_fallback_default(self):
124        groups = self.getGroups_generic()
125        self.assertEqual(
126            groups.get("test"),
127            None
128        )
129
130    # -------
131    # Queries
132    # -------
133
134    def test_find_found(self):
135        groups = self.getGroups_generic()
136        found = groups.findGlyph("A")
137        found.sort()
138        self.assertEqual(
139            found,
140            [u"group 1", u"group 4"]
141        )
142
143    def test_find_not_found(self):
144        groups = self.getGroups_generic()
145        self.assertEqual(
146            groups.findGlyph("five"),
147            []
148        )
149
150    def test_find_invalid_key(self):
151        groups = self.getGroups_generic()
152        with self.assertRaises(TypeError):
153            groups.findGlyph(5)
154
155    def test_contains_found(self):
156        groups = self.getGroups_generic()
157        self.assertTrue("group 4" in groups)
158
159    def test_contains_not_found(self):
160        groups = self.getGroups_generic()
161        self.assertFalse("group five" in groups)
162
163    def test_get_found(self):
164        groups = self.getGroups_generic()
165        self.assertEqual(
166            groups["group 1"],
167            ("A", "B", "C")
168        )
169
170    def test_get_not_found(self):
171        groups = self.getGroups_generic()
172        with self.assertRaises(KeyError):
173            groups["group two"]
174
175    # --------------
176    # Kerning Groups
177    # --------------
178
179    def getGroups_kerning(self):
180        groups = self.getGroups_generic()
181        kerningGroups = {
182            "public.kern1.A": ["A", "Aacute"],
183            "public.kern1.O": ["O", "D"],
184            "public.kern2.A": ["A", "Aacute"],
185            "public.kern2.O": ["O", "C"]
186        }
187        groups.update(kerningGroups)
188        return groups
189
190    def test_side1KerningGroups(self):
191        groups = self.getGroups_kerning()
192        expected = {
193            "public.kern1.A": ("A", "Aacute"),
194            "public.kern1.O": ("O", "D")
195        }
196        self.assertEqual(groups.side1KerningGroups, expected)
197        # self.assertEqual(super(groups, self)._get_side1KerningGroups(), expected)
198
199    def test_get_side1KerningGroups(self):
200        groups = self.getGroups_kerning()
201        expected = {
202            "public.kern1.A": ["A", "Aacute"],
203            "public.kern1.O": ["O", "D"]
204        }
205        self.assertEqual(groups._get_side1KerningGroups(), expected)
206
207
208    def test_side2KerningGroups(self):
209        groups = self.getGroups_kerning()
210        expected = {
211            "public.kern2.A": ("A", "Aacute"),
212            "public.kern2.O": ("O", "C")
213        }
214        self.assertEqual(groups.side2KerningGroups, expected)
215
216    def test_get_side2KerningGroups(self):
217        groups = self.getGroups_kerning()
218        expected = {
219            "public.kern1.A": ["A", "Aacute"],
220            "public.kern1.O": ["O", "D"]
221        }
222        self.assertEqual(groups._get_side1KerningGroups(), expected)
223
224    # ----
225    # Hash
226    # ----
227
228    def test_hash(self):
229        groups = self.getGroups_generic()
230        self.assertEqual(
231            isinstance(groups, collections.Hashable),
232            True
233        )
234
235    # --------
236    # Equality
237    # --------
238
239    def test_object_equal_self(self):
240        groups_one = self.getGroups_generic()
241        self.assertEqual(
242            groups_one,
243            groups_one
244        )
245
246    def test_object_not_equal_other(self):
247        groups_one = self.getGroups_generic()
248        groups_two = self.getGroups_generic()
249        self.assertNotEqual(
250            groups_one,
251            groups_two
252        )
253
254    def test_object_equal_self_variable_assignment(self):
255        groups_one = self.getGroups_generic()
256        a = groups_one
257        self.assertEqual(
258            groups_one,
259            a
260        )
261
262    def test_object_not_equal_other_variable_assignment(self):
263        groups_one = self.getGroups_generic()
264        groups_two = self.getGroups_generic()
265        a = groups_one
266        self.assertNotEqual(
267            groups_two,
268            a
269        )
270
271    # ---------------------
272    # RoboFab Compatibility
273    # ---------------------
274
275    def test_remove(self):
276        groups = self.getGroups_generic()
277        groups.remove("group 2")
278        expected = {
279            "group 1": ("A", "B", "C"),
280            "group 3": (),
281            "group 4": ('A',)
282        }
283        self.assertEqual(groups.asDict(), expected)
284
285    def test_remove_twice(self):
286        groups = self.getGroups_generic()
287        groups.remove("group 1")
288        with self.assertRaises(KeyError):
289            groups.remove("group 1")
290
291    def test_remove_nonexistant_group(self):
292        groups = self.getGroups_generic()
293        with self.assertRaises(KeyError):
294            groups.remove("group 7")
295
296    def test_asDict(self):
297        groups = self.getGroups_generic()
298        expected = {
299            "group 1": ("A", "B", "C"),
300            "group 2": ("x", "y", "z"),
301            "group 3": (),
302            "group 4": ('A',)
303        }
304        self.assertEqual(groups.asDict(), expected)
305
306    # -------------------
307    # Inherited Functions
308    # -------------------
309
310    def test_iter(self):
311        groups = self.getGroups_generic()
312        expected = ["group 1","group 2","group 3", "group 4"]
313
314        listOfGroups = []
315        for groupName in groups:
316            listOfGroups.append(groupName)
317
318        self.assertEqual(listOfGroups.sort(), expected.sort())
319
320    def test_iter_remove(self):
321        groups = self.getGroups_generic()
322        expected = []
323
324        for groupName in groups:
325            groups.remove(groupName)
326
327        self.assertEqual(groups.keys(), expected)
328
329
330    def test_values(self):
331        groups = self.getGroups_generic()
332        expected = [("A", "B", "C"), ("x", "y", "z"),(),('A',)]
333        self.assertEqual(groups.values().sort(), expected.sort())
334