| OLD | NEW |
|---|
| (Empty) | |
| 1 import unittest |
| 2 |
| 3 from rope.base import libutils |
| 4 from rope.base import pyobjects, builtins |
| 5 from ropetest import testutils |
| 6 |
| 7 |
| 8 class BuiltinTypesTest(unittest.TestCase): |
| 9 |
| 10 def setUp(self): |
| 11 super(BuiltinTypesTest, self).setUp() |
| 12 self.project = testutils.sample_project() |
| 13 self.pycore = self.project.pycore |
| 14 self.mod = testutils.create_module(self.project, 'mod') |
| 15 |
| 16 def tearDown(self): |
| 17 testutils.remove_project(self.project) |
| 18 super(BuiltinTypesTest, self).tearDown() |
| 19 |
| 20 def test_simple_case(self): |
| 21 self.mod.write('l = []\n') |
| 22 pymod = self.project.get_pymodule(self.mod) |
| 23 self.assertTrue('append' in pymod['l'].get_object()) |
| 24 |
| 25 def test_holding_type_information(self): |
| 26 self.mod.write('class C(object):\n pass\n' |
| 27 'l = [C()]\na_var = l.pop()\n') |
| 28 pymod = self.project.get_pymodule(self.mod) |
| 29 c_class = pymod['C'].get_object() |
| 30 a_var = pymod['a_var'].get_object() |
| 31 self.assertEquals(c_class, a_var.get_type()) |
| 32 |
| 33 def test_get_items(self): |
| 34 self.mod.write('class C(object):' |
| 35 '\n def __getitem__(self, i):\n return C()\n' |
| 36 'c = C()\na_var = c[0]') |
| 37 pymod = self.project.get_pymodule(self.mod) |
| 38 c_class = pymod['C'].get_object() |
| 39 a_var = pymod['a_var'].get_object() |
| 40 self.assertEquals(c_class, a_var.get_type()) |
| 41 |
| 42 def test_get_items_for_lists(self): |
| 43 self.mod.write('class C(object):\n pass\nl = [C()]\na_var = l[0]\n') |
| 44 pymod = self.project.get_pymodule(self.mod) |
| 45 c_class = pymod['C'].get_object() |
| 46 a_var = pymod['a_var'].get_object() |
| 47 self.assertEquals(c_class, a_var.get_type()) |
| 48 |
| 49 def test_get_items_from_slices(self): |
| 50 self.mod.write('class C(object):\n pass' |
| 51 '\nl = [C()]\na_var = l[:].pop()\n') |
| 52 pymod = self.project.get_pymodule(self.mod) |
| 53 c_class = pymod['C'].get_object() |
| 54 a_var = pymod['a_var'].get_object() |
| 55 self.assertEquals(c_class, a_var.get_type()) |
| 56 |
| 57 def test_simple_for_loops(self): |
| 58 self.mod.write('class C(object):\n pass\nl = [C()]\n' |
| 59 'for c in l:\n a_var = c\n') |
| 60 pymod = self.project.get_pymodule(self.mod) |
| 61 c_class = pymod['C'].get_object() |
| 62 a_var = pymod['a_var'].get_object() |
| 63 self.assertEquals(c_class, a_var.get_type()) |
| 64 |
| 65 def test_definition_location_for_loop_variables(self): |
| 66 self.mod.write('class C(object):\n pass\nl = [C()]\n' |
| 67 'for c in l:\n pass\n') |
| 68 pymod = self.project.get_pymodule(self.mod) |
| 69 c_var = pymod['c'] |
| 70 self.assertEquals((pymod, 4), c_var.get_definition_location()) |
| 71 |
| 72 def test_simple_case_for_dicts(self): |
| 73 self.mod.write('d = {}\n') |
| 74 pymod = self.project.get_pymodule(self.mod) |
| 75 self.assertTrue('get' in pymod['d'].get_object()) |
| 76 |
| 77 def test_get_item_for_dicts(self): |
| 78 self.mod.write('class C(object):\n pass\n' |
| 79 'd = {1: C()}\na_var = d[1]\n') |
| 80 pymod = self.project.get_pymodule(self.mod) |
| 81 c_class = pymod['C'].get_object() |
| 82 a_var = pymod['a_var'].get_object() |
| 83 self.assertEquals(c_class, a_var.get_type()) |
| 84 |
| 85 def test_popping_dicts(self): |
| 86 self.mod.write('class C(object):\n pass\n' |
| 87 'd = {1: C()}\na_var = d.pop(1)\n') |
| 88 pymod = self.project.get_pymodule(self.mod) |
| 89 c_class = pymod['C'].get_object() |
| 90 a_var = pymod['a_var'].get_object() |
| 91 self.assertEquals(c_class, a_var.get_type()) |
| 92 |
| 93 def test_getting_keys_from_dicts(self): |
| 94 self.mod.write('class C1(object):\n pass\n' |
| 95 'class C2(object):\n pass\n' |
| 96 'd = {C1(): C2()}\nfor c in d.keys():\n a_var = c\n') |
| 97 pymod = self.project.get_pymodule(self.mod) |
| 98 c_class = pymod['C1'].get_object() |
| 99 a_var = pymod['a_var'].get_object() |
| 100 self.assertEquals(c_class, a_var.get_type()) |
| 101 |
| 102 def test_getting_values_from_dicts(self): |
| 103 self.mod.write('class C1(object):\n pass\n' |
| 104 'class C2(object):\n pass\n' |
| 105 'd = {C1(): C2()}\nfor c in d.values():' |
| 106 '\n a_var = c\n') |
| 107 pymod = self.project.get_pymodule(self.mod) |
| 108 c_class = pymod['C2'].get_object() |
| 109 a_var = pymod['a_var'].get_object() |
| 110 self.assertEquals(c_class, a_var.get_type()) |
| 111 |
| 112 def test_getting_iterkeys_from_dicts(self): |
| 113 self.mod.write('class C1(object):\n pass' |
| 114 '\nclass C2(object):\n pass\n' |
| 115 'd = {C1(): C2()}\nfor c in d.keys():\n a_var = c\n') |
| 116 pymod = self.project.get_pymodule(self.mod) |
| 117 c_class = pymod['C1'].get_object() |
| 118 a_var = pymod['a_var'].get_object() |
| 119 self.assertEquals(c_class, a_var.get_type()) |
| 120 |
| 121 def test_getting_itervalues_from_dicts(self): |
| 122 self.mod.write('class C1(object):\n pass' |
| 123 '\nclass C2(object):\n pass\n' |
| 124 'd = {C1(): C2()}\nfor c in d.values():' |
| 125 '\n a_var = c\n') |
| 126 pymod = self.project.get_pymodule(self.mod) |
| 127 c_class = pymod['C2'].get_object() |
| 128 a_var = pymod['a_var'].get_object() |
| 129 self.assertEquals(c_class, a_var.get_type()) |
| 130 |
| 131 def test_using_copy_for_dicts(self): |
| 132 self.mod.write('class C1(object):\n pass' |
| 133 '\nclass C2(object):\n pass\n' |
| 134 'd = {C1(): C2()}\nfor c in d.copy():\n a_var = c\n') |
| 135 pymod = self.project.get_pymodule(self.mod) |
| 136 c_class = pymod['C1'].get_object() |
| 137 a_var = pymod['a_var'].get_object() |
| 138 self.assertEquals(c_class, a_var.get_type()) |
| 139 |
| 140 def test_tuple_assignments_for_items(self): |
| 141 self.mod.write('class C1(object):\n pass' |
| 142 '\nclass C2(object):\n pass\n' |
| 143 'd = {C1(): C2()}\nkey, value = d.items()[0]\n') |
| 144 pymod = self.project.get_pymodule(self.mod) |
| 145 c1_class = pymod['C1'].get_object() |
| 146 c2_class = pymod['C2'].get_object() |
| 147 key = pymod['key'].get_object() |
| 148 value = pymod['value'].get_object() |
| 149 self.assertEquals(c1_class, key.get_type()) |
| 150 self.assertEquals(c2_class, value.get_type()) |
| 151 |
| 152 def test_tuple_assignment_for_lists(self): |
| 153 self.mod.write('class C(object):\n pass\n' |
| 154 'l = [C(), C()]\na, b = l\n') |
| 155 pymod = self.project.get_pymodule(self.mod) |
| 156 c_class = pymod['C'].get_object() |
| 157 a_var = pymod['a'].get_object() |
| 158 b_var = pymod['b'].get_object() |
| 159 self.assertEquals(c_class, a_var.get_type()) |
| 160 self.assertEquals(c_class, b_var.get_type()) |
| 161 |
| 162 def test_tuple_assignments_for_iteritems_in_fors(self): |
| 163 self.mod.write('class C1(object):\n pass\n' |
| 164 'class C2(object):\n pass\n' |
| 165 'd = {C1(): C2()}\n' |
| 166 'for x, y in d.items():\n a = x;\n b = y\n') |
| 167 pymod = self.project.get_pymodule(self.mod) |
| 168 c1_class = pymod['C1'].get_object() |
| 169 c2_class = pymod['C2'].get_object() |
| 170 a_var = pymod['a'].get_object() |
| 171 b_var = pymod['b'].get_object() |
| 172 self.assertEquals(c1_class, a_var.get_type()) |
| 173 self.assertEquals(c2_class, b_var.get_type()) |
| 174 |
| 175 def test_simple_tuple_assignments(self): |
| 176 self.mod.write('class C1(object):' |
| 177 '\n pass\nclass C2(object):\n pass\n' |
| 178 'a, b = C1(), C2()\n') |
| 179 pymod = self.project.get_pymodule(self.mod) |
| 180 c1_class = pymod['C1'].get_object() |
| 181 c2_class = pymod['C2'].get_object() |
| 182 a_var = pymod['a'].get_object() |
| 183 b_var = pymod['b'].get_object() |
| 184 self.assertEquals(c1_class, a_var.get_type()) |
| 185 self.assertEquals(c2_class, b_var.get_type()) |
| 186 |
| 187 def test_overriding_builtin_names(self): |
| 188 self.mod.write('class C(object):\n pass\nlist = C\n') |
| 189 pymod = self.project.get_pymodule(self.mod) |
| 190 c_class = pymod['C'].get_object() |
| 191 list_var = pymod['list'].get_object() |
| 192 self.assertEquals(c_class, list_var) |
| 193 |
| 194 def test_simple_builtin_scope_test(self): |
| 195 self.mod.write('l = list()\n') |
| 196 pymod = self.project.get_pymodule(self.mod) |
| 197 self.assertTrue('append' in pymod['l'].get_object()) |
| 198 |
| 199 def test_simple_sets(self): |
| 200 self.mod.write('s = set()\n') |
| 201 pymod = self.project.get_pymodule(self.mod) |
| 202 self.assertTrue('add' in pymod['s'].get_object()) |
| 203 |
| 204 def test_making_lists_using_the_passed_argument_to_init(self): |
| 205 self.mod.write('class C(object):\n pass\nl1 = [C()]\n' |
| 206 'l2 = list(l1)\na_var = l2.pop()') |
| 207 pymod = self.project.get_pymodule(self.mod) |
| 208 c_class = pymod['C'].get_object() |
| 209 a_var = pymod['a_var'].get_object() |
| 210 self.assertEquals(c_class, a_var.get_type()) |
| 211 |
| 212 def test_making_tuples_using_the_passed_argument_to_init(self): |
| 213 self.mod.write('class C(object):\n pass\nl1 = [C()]\n' |
| 214 'l2 = tuple(l1)\na_var = l2[0]') |
| 215 pymod = self.project.get_pymodule(self.mod) |
| 216 c_class = pymod['C'].get_object() |
| 217 a_var = pymod['a_var'].get_object() |
| 218 self.assertEquals(c_class, a_var.get_type()) |
| 219 |
| 220 def test_making_sets_using_the_passed_argument_to_init(self): |
| 221 self.mod.write('class C(object):\n pass\nl1 = [C()]\n' |
| 222 'l2 = set(l1)\na_var = l2.pop()') |
| 223 pymod = self.project.get_pymodule(self.mod) |
| 224 c_class = pymod['C'].get_object() |
| 225 a_var = pymod['a_var'].get_object() |
| 226 self.assertEquals(c_class, a_var.get_type()) |
| 227 |
| 228 def test_making_dicts_using_the_passed_argument_to_init(self): |
| 229 self.mod.write('class C1(object):\n pass\n' |
| 230 'class C2(object):\n pass\n' |
| 231 'l1 = [(C1(), C2())]\n' |
| 232 'l2 = dict(l1)\na, b = l2.items()[0]') |
| 233 pymod = self.project.get_pymodule(self.mod) |
| 234 c1_class = pymod['C1'].get_object() |
| 235 c2_class = pymod['C2'].get_object() |
| 236 a_var = pymod['a'].get_object() |
| 237 b_var = pymod['b'].get_object() |
| 238 self.assertEquals(c1_class, a_var.get_type()) |
| 239 self.assertEquals(c2_class, b_var.get_type()) |
| 240 |
| 241 def test_range_builtin_function(self): |
| 242 self.mod.write('l = range(1)\n') |
| 243 pymod = self.project.get_pymodule(self.mod) |
| 244 l = pymod['l'].get_object() |
| 245 self.assertTrue('append' in l) |
| 246 |
| 247 def test_reversed_builtin_function(self): |
| 248 self.mod.write('class C(object):\n pass\nl = [C()]\n' |
| 249 'for x in reversed(l):\n a_var = x\n') |
| 250 pymod = self.project.get_pymodule(self.mod) |
| 251 c_class = pymod['C'].get_object() |
| 252 a_var = pymod['a_var'].get_object() |
| 253 self.assertEquals(c_class, a_var.get_type()) |
| 254 |
| 255 def test_sorted_builtin_function(self): |
| 256 self.mod.write('class C(object):\n pass\nl = [C()]\n' |
| 257 'a_var = sorted(l).pop()\n') |
| 258 pymod = self.project.get_pymodule(self.mod) |
| 259 c_class = pymod['C'].get_object() |
| 260 a_var = pymod['a_var'].get_object() |
| 261 self.assertEquals(c_class, a_var.get_type()) |
| 262 |
| 263 def test_super_builtin_function(self): |
| 264 self.mod.write( |
| 265 'class C(object):\n pass\n' |
| 266 'class A(object):\n def a_f(self):\n return C()\n' |
| 267 'class B(A):\n def b_f(self):\n ' |
| 268 'return super(B, self).a_f()\n' |
| 269 'a_var = B.b_f()\n') |
| 270 pymod = self.project.get_pymodule(self.mod) |
| 271 c_class = pymod['C'].get_object() |
| 272 a_var = pymod['a_var'].get_object() |
| 273 self.assertEquals(c_class, a_var.get_type()) |
| 274 |
| 275 def test_file_builtin_type(self): |
| 276 self.mod.write('for line in open("file.txt"):\n a_var = line\n') |
| 277 pymod = self.project.get_pymodule(self.mod) |
| 278 a_var = pymod['a_var'].get_object() |
| 279 self.assertTrue(isinstance(a_var.get_type(), builtins.Str)) |
| 280 |
| 281 def test_property_builtin_type(self): |
| 282 self.mod.write('p = property()\n') |
| 283 pymod = self.project.get_pymodule(self.mod) |
| 284 p_var = pymod['p'].get_object() |
| 285 self.assertTrue('fget' in p_var) |
| 286 |
| 287 def test_lambda_functions(self): |
| 288 self.mod.write('l = lambda: 1\n') |
| 289 pymod = self.project.get_pymodule(self.mod) |
| 290 l_var = pymod['l'].get_object() |
| 291 self.assertEquals(pyobjects.get_base_type('Function'), |
| 292 l_var.get_type()) |
| 293 |
| 294 def test_lambda_function_definition(self): |
| 295 self.mod.write('l = lambda x, y = 2, *a, **b: x + y\n') |
| 296 pymod = self.project.get_pymodule(self.mod) |
| 297 l_var = pymod['l'].get_object() |
| 298 self.assertTrue(l_var.get_name() is not None) |
| 299 self.assertEquals(len(l_var.get_param_names()), 4) |
| 300 self.assertEquals((pymod, 1), |
| 301 pymod['l'].get_definition_location()) |
| 302 |
| 303 def test_lambdas_that_return_unknown(self): |
| 304 self.mod.write('a_var = (lambda: None)()\n') |
| 305 pymod = self.project.get_pymodule(self.mod) |
| 306 a_var = pymod['a_var'].get_object() |
| 307 self.assertTrue(a_var is not None) |
| 308 |
| 309 def test_builtin_zip_function(self): |
| 310 self.mod.write( |
| 311 'class C1(object):\n pass\nclass C2(object):\n pass\n' |
| 312 'c1_list = [C1()]\nc2_list = [C2()]\n' |
| 313 'a, b = zip(c1_list, c2_list)[0]') |
| 314 pymod = self.project.get_pymodule(self.mod) |
| 315 c1_class = pymod['C1'].get_object() |
| 316 c2_class = pymod['C2'].get_object() |
| 317 a_var = pymod['a'].get_object() |
| 318 b_var = pymod['b'].get_object() |
| 319 self.assertEquals(c1_class, a_var.get_type()) |
| 320 self.assertEquals(c2_class, b_var.get_type()) |
| 321 |
| 322 def test_builtin_zip_function_with_more_than_two_args(self): |
| 323 self.mod.write( |
| 324 'class C1(object):\n pass\nclass C2(object):\n pass\n' |
| 325 'c1_list = [C1()]\nc2_list = [C2()]\n' |
| 326 'a, b, c = zip(c1_list, c2_list, c1_list)[0]') |
| 327 pymod = self.project.get_pymodule(self.mod) |
| 328 c1_class = pymod['C1'].get_object() |
| 329 c2_class = pymod['C2'].get_object() |
| 330 a_var = pymod['a'].get_object() |
| 331 b_var = pymod['b'].get_object() |
| 332 c_var = pymod['c'].get_object() |
| 333 self.assertEquals(c1_class, a_var.get_type()) |
| 334 self.assertEquals(c2_class, b_var.get_type()) |
| 335 self.assertEquals(c1_class, c_var.get_type()) |
| 336 |
| 337 def test_wrong_arguments_to_zip_function(self): |
| 338 self.mod.write( |
| 339 'class C1(object):\n pass\nc1_list = [C1()]\n' |
| 340 'a, b = zip(c1_list, 1)[0]') |
| 341 pymod = self.project.get_pymodule(self.mod) |
| 342 c1_class = pymod['C1'].get_object() |
| 343 a_var = pymod['a'].get_object() |
| 344 b_var = pymod['b'].get_object() # noqa |
| 345 self.assertEquals(c1_class, a_var.get_type()) |
| 346 |
| 347 def test_enumerate_builtin_function(self): |
| 348 self.mod.write('class C(object):\n pass\nl = [C()]\n' |
| 349 'for i, x in enumerate(l):\n a_var = x\n') |
| 350 pymod = self.project.get_pymodule(self.mod) |
| 351 c_class = pymod['C'].get_object() |
| 352 a_var = pymod['a_var'].get_object() |
| 353 self.assertEquals(c_class, a_var.get_type()) |
| 354 |
| 355 def test_builtin_class_get_name(self): |
| 356 self.assertEquals('object', |
| 357 builtins.builtins['object'].get_object().get_name()) |
| 358 self.assertEquals( |
| 359 'property', builtins.builtins['property'].get_object().get_name()) |
| 360 |
| 361 def test_star_args_and_double_star_args(self): |
| 362 self.mod.write('def func(p, *args, **kwds):\n pass\n') |
| 363 pymod = self.project.get_pymodule(self.mod) |
| 364 func_scope = pymod['func'].get_object().get_scope() |
| 365 args = func_scope['args'].get_object() |
| 366 kwds = func_scope['kwds'].get_object() |
| 367 self.assertTrue(isinstance(args.get_type(), builtins.List)) |
| 368 self.assertTrue(isinstance(kwds.get_type(), builtins.Dict)) |
| 369 |
| 370 def test_simple_list_comprehension_test(self): |
| 371 self.mod.write('a_var = [i for i in range(10)]\n') |
| 372 pymod = self.project.get_pymodule(self.mod) |
| 373 a_var = pymod['a_var'].get_object() |
| 374 self.assertTrue(isinstance(a_var.get_type(), builtins.List)) |
| 375 |
| 376 def test_simple_list_generator_expression(self): |
| 377 self.mod.write('a_var = (i for i in range(10))\n') |
| 378 pymod = self.project.get_pymodule(self.mod) |
| 379 a_var = pymod['a_var'].get_object() |
| 380 self.assertTrue(isinstance(a_var.get_type(), builtins.Iterator)) |
| 381 |
| 382 def test_iter_builtin_function(self): |
| 383 self.mod.write('class C(object):\n pass\nl = [C()]\n' |
| 384 'for c in iter(l):\n a_var = c\n') |
| 385 pymod = self.project.get_pymodule(self.mod) |
| 386 c_class = pymod['C'].get_object() |
| 387 a_var = pymod['a_var'].get_object() |
| 388 self.assertEquals(c_class, a_var.get_type()) |
| 389 |
| 390 def test_simple_int_type(self): |
| 391 self.mod.write('l = 1\n') |
| 392 pymod = self.project.get_pymodule(self.mod) |
| 393 self.assertEquals(builtins.builtins['int'].get_object(), |
| 394 pymod['l'].get_object().get_type()) |
| 395 |
| 396 def test_simple_float_type(self): |
| 397 self.mod.write('l = 1.0\n') |
| 398 pymod = self.project.get_pymodule(self.mod) |
| 399 self.assertEquals(builtins.builtins['float'].get_object(), |
| 400 pymod['l'].get_object().get_type()) |
| 401 |
| 402 def test_simple_float_type2(self): |
| 403 self.mod.write('l = 1e1\n') |
| 404 pymod = self.project.get_pymodule(self.mod) |
| 405 self.assertEquals(builtins.builtins['float'].get_object(), |
| 406 pymod['l'].get_object().get_type()) |
| 407 |
| 408 def test_simple_complex_type(self): |
| 409 self.mod.write('l = 1.0j\n') |
| 410 pymod = self.project.get_pymodule(self.mod) |
| 411 self.assertEquals(builtins.builtins['complex'].get_object(), |
| 412 pymod['l'].get_object().get_type()) |
| 413 |
| 414 def test_handling_unaryop_on_ints(self): |
| 415 self.mod.write('l = -(1)\n') |
| 416 pymod = self.project.get_pymodule(self.mod) |
| 417 self.assertEquals(builtins.builtins['int'].get_object(), |
| 418 pymod['l'].get_object().get_type()) |
| 419 |
| 420 def test_handling_binop_on_ints(self): |
| 421 self.mod.write('l = 1 + 1\n') |
| 422 pymod = self.project.get_pymodule(self.mod) |
| 423 self.assertEquals(builtins.builtins['int'].get_object(), |
| 424 pymod['l'].get_object().get_type()) |
| 425 |
| 426 def test_handling_compares(self): |
| 427 self.mod.write('l = 1 == 1\n') |
| 428 pymod = self.project.get_pymodule(self.mod) |
| 429 self.assertEquals(builtins.builtins['bool'].get_object(), |
| 430 pymod['l'].get_object().get_type()) |
| 431 |
| 432 def test_handling_boolops(self): |
| 433 self.mod.write('l = 1 and 2\n') |
| 434 pymod = self.project.get_pymodule(self.mod) |
| 435 self.assertEquals(builtins.builtins['int'].get_object(), |
| 436 pymod['l'].get_object().get_type()) |
| 437 |
| 438 def test_binary_or_left_value_unknown(self): |
| 439 code = 'var = (asdsd or 3)\n' |
| 440 pymod = libutils.get_string_module(self.project, code) |
| 441 self.assertEquals(builtins.builtins['int'].get_object(), |
| 442 pymod['var'].get_object().get_type()) |
| 443 |
| 444 def test_unknown_return_object(self): |
| 445 src = 'import sys\n' \ |
| 446 'def foo():\n' \ |
| 447 ' res = set(sys.builtin_module_names)\n' \ |
| 448 ' if foo: res.add(bar)\n' |
| 449 self.project.prefs['import_dynload_stdmods'] = True |
| 450 self.mod.write(src) |
| 451 self.project.pycore.analyze_module(self.mod) |
| 452 |
| 453 def test_abstractmethods_attribute(self): |
| 454 # see http://bugs.python.org/issue10006 for details |
| 455 src = 'class SubType(type): pass\nsubtype = SubType()\n' |
| 456 self.mod.write(src) |
| 457 self.project.pycore.analyze_module(self.mod) |
| 458 |
| 459 |
| 460 class BuiltinModulesTest(unittest.TestCase): |
| 461 |
| 462 def setUp(self): |
| 463 super(BuiltinModulesTest, self).setUp() |
| 464 self.project = testutils.sample_project( |
| 465 extension_modules=['time', 'invalid', 'invalid.sub']) |
| 466 self.mod = testutils.create_module(self.project, 'mod') |
| 467 |
| 468 def tearDown(self): |
| 469 testutils.remove_project(self.project) |
| 470 super(BuiltinModulesTest, self).tearDown() |
| 471 |
| 472 def test_simple_case(self): |
| 473 self.mod.write('import time') |
| 474 pymod = self.project.get_pymodule(self.mod) |
| 475 self.assertTrue('time' in pymod['time'].get_object()) |
| 476 |
| 477 def test_ignored_extensions(self): |
| 478 self.mod.write('import os') |
| 479 pymod = self.project.get_pymodule(self.mod) |
| 480 self.assertTrue('rename' not in pymod['os'].get_object()) |
| 481 |
| 482 def test_ignored_extensions_2(self): |
| 483 self.mod.write('import os') |
| 484 pymod = self.project.get_pymodule(self.mod) |
| 485 self.assertTrue('rename' not in pymod['os'].get_object()) |
| 486 |
| 487 def test_nonexistent_modules(self): |
| 488 self.mod.write('import invalid') |
| 489 pymod = self.project.get_pymodule(self.mod) |
| 490 pymod['invalid'].get_object() |
| 491 |
| 492 def test_nonexistent_modules_2(self): |
| 493 self.mod.write('import invalid\nimport invalid.sub') |
| 494 pymod = self.project.get_pymodule(self.mod) |
| 495 invalid = pymod['invalid'].get_object() |
| 496 self.assertTrue('sub' in invalid) |
| 497 |
| 498 def test_time_in_std_mods(self): |
| 499 import rope.base.stdmods |
| 500 self.assertTrue('time' in rope.base.stdmods.standard_modules()) |
| 501 |
| 502 |
| 503 def suite(): |
| 504 result = unittest.TestSuite() |
| 505 result.addTests(unittest.makeSuite(BuiltinTypesTest)) |
| 506 result.addTests(unittest.makeSuite(BuiltinModulesTest)) |
| 507 return result |
| 508 |
| 509 |
| 510 if __name__ == '__main__': |
| 511 unittest.main() |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1132103009:
Example of refactoring using rope library. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master