1import unittest
2import collections
3
4
5class TestLayer(unittest.TestCase):
6
7    # ------
8    # Glyphs
9    # ------
10
11    def getLayer_glyphs(self):
12        layer, _ = self.objectGenerator("layer")
13        for name in "ABCD":
14            layer.newGlyph(name)
15        return layer
16
17    def test_len(self):
18        layer = self.getLayer_glyphs()
19        self.assertEqual(
20            len(layer),
21            4
22        )
23
24    def _testInsertGlyph(self, setGlyphName=True):
25        layer, _ = self.objectGenerator("layer")
26        glyph, _ = self.objectGenerator("glyph")
27        pen = glyph.getPen()
28        pen.moveTo((100, 0))
29        pen.lineTo((100, 500))
30        pen.lineTo((500, 500))
31        pen.closePath()
32        glyph.width = 600
33        if setGlyphName:
34            glyph.name = "test"
35        layer["test"] = glyph
36        self.assertTrue("test" in layer)
37        self.assertEqual(
38            layer["test"].bounds,
39            glyph.bounds
40        )
41
42    def test_set_glyph(self):
43        self._testInsertGlyph(setGlyphName=True)
44
45    def test_set_glyph_with_name_None(self):
46        self._testInsertGlyph(setGlyphName=False)
47
48    def test_get_glyph_in_font(self):
49        layer = self.getLayer_glyphs()
50        self.assertEqual(
51            layer["A"].name,
52            "A"
53        )
54
55    def test_get_glyph_not_in_font(self):
56        layer = self.getLayer_glyphs()
57        with self.assertRaises(KeyError):
58            layer["E"]
59
60    # ----
61    # Hash
62    # ----
63
64    def test_hash_object_self(self):
65        layer_one = self.getLayer_glyphs()
66        self.assertEqual(
67            hash(layer_one),
68            hash(layer_one)
69        )
70
71    def test_hash_object_other(self):
72        layer_one = self.getLayer_glyphs()
73        layer_two = self.getLayer_glyphs()
74        self.assertNotEqual(
75            hash(layer_one),
76            hash(layer_two)
77        )
78
79    def test_hash_object_self_variable_assignment(self):
80        layer_one = self.getLayer_glyphs()
81        a = layer_one
82        self.assertEqual(
83            hash(layer_one),
84            hash(a)
85        )
86
87    def test_hash_object_other_variable_assignment(self):
88        layer_one = self.getLayer_glyphs()
89        layer_two = self.getLayer_glyphs()
90        a = layer_one
91        self.assertNotEqual(
92            hash(layer_two),
93            hash(a)
94        )
95
96    def test_is_hashable(self):
97        layer_one = self.getLayer_glyphs()
98        self.assertTrue(
99            isinstance(layer_one, collections.Hashable)
100        )
101
102    # --------
103    # Equality
104    # --------
105
106    def test_object_equal_self(self):
107        layer_one = self.getLayer_glyphs()
108        self.assertEqual(
109            layer_one,
110            layer_one
111        )
112
113    def test_object_not_equal_other(self):
114        layer_one = self.getLayer_glyphs()
115        layer_two = self.getLayer_glyphs()
116        self.assertNotEqual(
117            layer_one,
118            layer_two
119        )
120
121    def test_object_equal_self_variable_assignment(self):
122        layer_one = self.getLayer_glyphs()
123        a = layer_one
124        self.assertEqual(
125            layer_one,
126            a
127        )
128
129    def test_object_not_equal_self_variable_assignment(self):
130        layer_one = self.getLayer_glyphs()
131        layer_two = self.getLayer_glyphs()
132        a = layer_one
133        self.assertNotEqual(
134            layer_two,
135            a
136        )
137
138    # ---------
139    # Selection
140    # ---------
141
142    def test_selected_true(self):
143        layer = self.getLayer_glyphs()
144        try:
145            layer.selected = False
146        except NotImplementedError:
147            return
148        layer.selected = True
149        self.assertEqual(
150            layer.selected,
151            True
152        )
153
154    def test_selected_false(self):
155        layer = self.getLayer_glyphs()
156        try:
157            layer.selected = False
158        except NotImplementedError:
159            return
160        self.assertEqual(
161            layer.selected,
162            False
163        )
164
165    # Glyphs
166
167    def test_selectedGlyphs_default(self):
168        layer = self.getLayer_glyphs()
169        try:
170            layer.selected = False
171        except NotImplementedError:
172            return
173        self.assertEqual(
174            layer.selectedGlyphs,
175            ()
176        )
177
178    def test_selectedGlyphs_setSubObject(self):
179        layer = self.getLayer_glyphs()
180        try:
181            layer.selected = False
182        except NotImplementedError:
183            return
184        glyph1 = layer["A"]
185        glyph2 = layer["B"]
186        glyph1.selected = True
187        glyph2.selected = True
188        self.assertEqual(
189            tuple(sorted(layer.selectedGlyphs, key=lambda glyph: glyph.name)),
190            (glyph1, glyph2)
191        )
192
193    def test_selectedGlyphs_setFilledList(self):
194        layer = self.getLayer_glyphs()
195        try:
196            layer.selected = False
197        except NotImplementedError:
198            return
199        glyph3 = layer["C"]
200        glyph4 = layer["D"]
201        layer.selectedGlyphs = [glyph3, glyph4]
202        self.assertEqual(
203            tuple(sorted(layer.selectedGlyphs, key=lambda glyph: glyph.name)),
204            (glyph3, glyph4)
205        )
206
207    def test_selectedGlyphs_setEmptyList(self):
208        layer = self.getLayer_glyphs()
209        try:
210            layer.selected = False
211        except NotImplementedError:
212            return
213        glyph1 = layer["A"]
214        glyph1.selected = True
215        layer.selectedGlyphs = []
216        self.assertEqual(
217            layer.selectedGlyphs,
218            ()
219        )
220
221    # Glyph Names
222
223    def test_selectedGlyphNames_default(self):
224        layer = self.getLayer_glyphs()
225        try:
226            layer.selected = False
227        except NotImplementedError:
228            return
229        self.assertEqual(
230            layer.selectedGlyphs,
231            ()
232        )
233
234    def test_selectedGlyphNames_setSubObject(self):
235        layer = self.getLayer_glyphs()
236        try:
237            layer.selected = False
238        except NotImplementedError:
239            return
240        glyph1 = layer["A"]
241        glyph2 = layer["B"]
242        glyph1.selected = True
243        glyph2.selected = True
244        self.assertEqual(
245            tuple(sorted(layer.selectedGlyphNames)),
246            ("A", "B")
247        )
248
249    def test_selectedGlyphNames_setFilledList(self):
250        layer = self.getLayer_glyphs()
251        try:
252            layer.selected = False
253        except NotImplementedError:
254            return
255        layer.selectedGlyphNames = ["C", "D"]
256        self.assertEqual(
257            tuple(sorted(layer.selectedGlyphNames)),
258            ("C", "D")
259        )
260
261    def test_selectedGlyphNames_setEmptyList(self):
262        layer = self.getLayer_glyphs()
263        try:
264            layer.selected = False
265        except NotImplementedError:
266            return
267        glyph1 = layer["A"]
268        glyph1.selected = True
269        layer.selectedGlyphNames = []
270        self.assertEqual(
271            layer.selectedGlyphNames,
272            ()
273        )
274