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