| OLD | NEW |
|---|
| (Empty) | |
| 1 try: |
| 2 import unittest2 as unittest |
| 3 except ImportError: |
| 4 import unittest |
| 5 |
| 6 import rope.base.oi |
| 7 import rope.base.libutils |
| 8 from ropetest import testutils |
| 9 |
| 10 |
| 11 class DynamicOITest(unittest.TestCase): |
| 12 |
| 13 def setUp(self): |
| 14 super(DynamicOITest, self).setUp() |
| 15 self.project = testutils.sample_project(validate_objectdb=True) |
| 16 self.pycore = self.project.pycore |
| 17 |
| 18 def tearDown(self): |
| 19 testutils.remove_project(self.project) |
| 20 super(DynamicOITest, self).tearDown() |
| 21 |
| 22 def test_simple_dti(self): |
| 23 mod = testutils.create_module(self.project, 'mod') |
| 24 code = 'def a_func(arg):\n return eval("arg")\n' \ |
| 25 'a_var = a_func(a_func)\n' |
| 26 mod.write(code) |
| 27 self.pycore.run_module(mod).wait_process() |
| 28 pymod = self.project.get_pymodule(mod) |
| 29 self.assertEquals(pymod['a_func'].get_object(), |
| 30 pymod['a_var'].get_object()) |
| 31 |
| 32 def test_module_dti(self): |
| 33 mod1 = testutils.create_module(self.project, 'mod1') |
| 34 mod2 = testutils.create_module(self.project, 'mod2') |
| 35 code = 'import mod1\ndef a_func(arg):\n return eval("arg")\n' \ |
| 36 'a_var = a_func(mod1)\n' |
| 37 mod2.write(code) |
| 38 self.pycore.run_module(mod2).wait_process() |
| 39 pymod2 = self.project.get_pymodule(mod2) |
| 40 self.assertEquals(self.project.get_pymodule(mod1), |
| 41 pymod2['a_var'].get_object()) |
| 42 |
| 43 def test_class_from_another_module_dti(self): |
| 44 mod1 = testutils.create_module(self.project, 'mod1') |
| 45 mod2 = testutils.create_module(self.project, 'mod2') |
| 46 code1 = 'class AClass(object):\n pass\n' |
| 47 code2 = 'from mod1 import AClass\n' \ |
| 48 '\ndef a_func(arg):\n return eval("arg")\n' \ |
| 49 'a_var = a_func(AClass)\n' |
| 50 mod1.write(code1) |
| 51 mod2.write(code2) |
| 52 self.pycore.run_module(mod2).wait_process() |
| 53 #pymod1 = self.project.get_pymodule(mod1) |
| 54 pymod2 = self.project.get_pymodule(mod2) |
| 55 self.assertEquals(pymod2['AClass'].get_object(), |
| 56 pymod2['a_var'].get_object()) |
| 57 |
| 58 def test_class_dti(self): |
| 59 mod = testutils.create_module(self.project, 'mod') |
| 60 code = 'class AClass(object):\n pass\n' \ |
| 61 '\ndef a_func(arg):\n return eval("arg")\n' \ |
| 62 'a_var = a_func(AClass)\n' |
| 63 mod.write(code) |
| 64 self.pycore.run_module(mod).wait_process() |
| 65 pymod = self.project.get_pymodule(mod) |
| 66 self.assertEquals(pymod['AClass'].get_object(), |
| 67 pymod['a_var'].get_object()) |
| 68 |
| 69 def test_instance_dti(self): |
| 70 mod = testutils.create_module(self.project, 'mod') |
| 71 code = 'class AClass(object):\n pass\n' \ |
| 72 '\ndef a_func(arg):\n return eval("arg()")\n' \ |
| 73 'a_var = a_func(AClass)\n' |
| 74 mod.write(code) |
| 75 self.pycore.run_module(mod).wait_process() |
| 76 pymod = self.project.get_pymodule(mod) |
| 77 self.assertEquals(pymod['AClass'].get_object(), |
| 78 pymod['a_var'].get_object().get_type()) |
| 79 |
| 80 def test_method_dti(self): |
| 81 mod = testutils.create_module(self.project, 'mod') |
| 82 code = 'class AClass(object):\n def a_method(self, arg):\n' \ |
| 83 ' return eval("arg()")\n' \ |
| 84 'an_instance = AClass()\n' \ |
| 85 'a_var = an_instance.a_method(AClass)\n' |
| 86 mod.write(code) |
| 87 self.pycore.run_module(mod).wait_process() |
| 88 pymod = self.project.get_pymodule(mod) |
| 89 self.assertEquals(pymod['AClass'].get_object(), |
| 90 pymod['a_var'].get_object().get_type()) |
| 91 |
| 92 def test_function_argument_dti(self): |
| 93 mod = testutils.create_module(self.project, 'mod') |
| 94 code = 'def a_func(arg):\n pass\n' \ |
| 95 'a_func(a_func)\n' |
| 96 mod.write(code) |
| 97 self.pycore.run_module(mod).wait_process() |
| 98 pyscope = self.project.get_pymodule(mod).get_scope() |
| 99 self.assertEquals(pyscope['a_func'].get_object(), |
| 100 pyscope.get_scopes()[0]['arg'].get_object()) |
| 101 |
| 102 def test_classes_with_the_same_name(self): |
| 103 mod = testutils.create_module(self.project, 'mod') |
| 104 code = 'def a_func(arg):\n class AClass(object):\n' \ |
| 105 ' pass\n return eval("arg")\n' \ |
| 106 'class AClass(object):\n pass\n' \ |
| 107 'a_var = a_func(AClass)\n' |
| 108 mod.write(code) |
| 109 self.pycore.run_module(mod).wait_process() |
| 110 pymod = self.project.get_pymodule(mod) |
| 111 self.assertEquals(pymod['AClass'].get_object(), |
| 112 pymod['a_var'].get_object()) |
| 113 |
| 114 def test_nested_classes(self): |
| 115 mod = testutils.create_module(self.project, 'mod') |
| 116 code = 'def a_func():\n class AClass(object):\n' \ |
| 117 ' pass\n return AClass\n' \ |
| 118 'def another_func(arg):\n return eval("arg")\n' \ |
| 119 'a_var = another_func(a_func())\n' |
| 120 mod.write(code) |
| 121 self.pycore.run_module(mod).wait_process() |
| 122 pyscope = self.project.get_pymodule(mod).get_scope() |
| 123 self.assertEquals(pyscope.get_scopes()[0]['AClass'].get_object(), |
| 124 pyscope['a_var'].get_object()) |
| 125 |
| 126 def test_function_argument_dti2(self): |
| 127 mod = testutils.create_module(self.project, 'mod') |
| 128 code = 'def a_func(arg, a_builtin_type):\n pass\n' \ |
| 129 'a_func(a_func, [])\n' |
| 130 mod.write(code) |
| 131 self.pycore.run_module(mod).wait_process() |
| 132 pyscope = self.project.get_pymodule(mod).get_scope() |
| 133 self.assertEquals(pyscope['a_func'].get_object(), |
| 134 pyscope.get_scopes()[0]['arg'].get_object()) |
| 135 |
| 136 def test_dti_and_concluded_data_invalidation(self): |
| 137 mod = testutils.create_module(self.project, 'mod') |
| 138 code = 'def a_func(arg):\n return eval("arg")\n' \ |
| 139 'a_var = a_func(a_func)\n' |
| 140 mod.write(code) |
| 141 pymod = self.project.get_pymodule(mod) |
| 142 pymod['a_var'].get_object() |
| 143 self.pycore.run_module(mod).wait_process() |
| 144 self.assertEquals(pymod['a_func'].get_object(), |
| 145 pymod['a_var'].get_object()) |
| 146 |
| 147 def test_list_objects_and_dynamicoi(self): |
| 148 mod = testutils.create_module(self.project, 'mod') |
| 149 code = 'class C(object):\n pass\n' \ |
| 150 'def a_func(arg):\n return eval("arg")\n' \ |
| 151 'a_var = a_func([C()])[0]\n' |
| 152 mod.write(code) |
| 153 self.pycore.run_module(mod).wait_process() |
| 154 pymod = self.project.get_pymodule(mod) |
| 155 c_class = pymod['C'].get_object() |
| 156 a_var = pymod['a_var'].get_object() |
| 157 self.assertEquals(c_class, a_var.get_type()) |
| 158 |
| 159 def test_for_loops_and_dynamicoi(self): |
| 160 mod = testutils.create_module(self.project, 'mod') |
| 161 code = 'class C(object):\n pass\n' \ |
| 162 'def a_func(arg):\n return eval("arg")\n' \ |
| 163 'for c in a_func([C()]):\n a_var = c\n' |
| 164 mod.write(code) |
| 165 self.pycore.run_module(mod).wait_process() |
| 166 pymod = self.project.get_pymodule(mod) |
| 167 c_class = pymod['C'].get_object() |
| 168 a_var = pymod['a_var'].get_object() |
| 169 self.assertEquals(c_class, a_var.get_type()) |
| 170 |
| 171 def test_dict_objects_and_dynamicoi(self): |
| 172 mod = testutils.create_module(self.project, 'mod') |
| 173 code = 'class C(object):\n pass\n' \ |
| 174 'def a_func(arg):\n return eval("arg")\n' \ |
| 175 'a_var = a_func({1: C()})[1]\n' |
| 176 mod.write(code) |
| 177 self.pycore.run_module(mod).wait_process() |
| 178 pymod = self.project.get_pymodule(mod) |
| 179 c_class = pymod['C'].get_object() |
| 180 a_var = pymod['a_var'].get_object() |
| 181 self.assertEquals(c_class, a_var.get_type()) |
| 182 |
| 183 def test_dict_keys_and_dynamicoi(self): |
| 184 mod = testutils.create_module(self.project, 'mod') |
| 185 code = 'class C(object):\n pass\n' \ |
| 186 'def a_func(arg):\n return eval("arg")\n' \ |
| 187 'a_var = a_func({C(): 1}).keys()[0]\n' |
| 188 mod.write(code) |
| 189 self.pycore.run_module(mod).wait_process() |
| 190 pymod = self.project.get_pymodule(mod) |
| 191 c_class = pymod['C'].get_object() |
| 192 a_var = pymod['a_var'].get_object() |
| 193 self.assertEquals(c_class, a_var.get_type()) |
| 194 |
| 195 def test_dict_keys_and_dynamicoi2(self): |
| 196 mod = testutils.create_module(self.project, 'mod') |
| 197 code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ |
| 198 'def a_func(arg):\n return eval("arg")\n' \ |
| 199 'a, b = a_func((C1(), C2()))\n' |
| 200 mod.write(code) |
| 201 self.pycore.run_module(mod).wait_process() |
| 202 pymod = self.project.get_pymodule(mod) |
| 203 c1_class = pymod['C1'].get_object() |
| 204 c2_class = pymod['C2'].get_object() |
| 205 a_var = pymod['a'].get_object() |
| 206 b_var = pymod['b'].get_object() |
| 207 self.assertEquals(c1_class, a_var.get_type()) |
| 208 self.assertEquals(c2_class, b_var.get_type()) |
| 209 |
| 210 def test_strs_and_dynamicoi(self): |
| 211 mod = testutils.create_module(self.project, 'mod') |
| 212 code = 'def a_func(arg):\n return eval("arg")\n' \ |
| 213 'a_var = a_func("hey")\n' |
| 214 mod.write(code) |
| 215 self.pycore.run_module(mod).wait_process() |
| 216 pymod = self.project.get_pymodule(mod) |
| 217 a_var = pymod['a_var'].get_object() |
| 218 self.assertTrue(isinstance(a_var.get_type(), rope.base.builtins.Str)) |
| 219 |
| 220 def test_textual_transformations(self): |
| 221 mod = testutils.create_module(self.project, 'mod') |
| 222 code = 'class C(object):\n pass\ndef f():' \ |
| 223 '\n pass\na_var = C()\n' \ |
| 224 'a_list = [C()]\na_str = "hey"\na_file = open("file.txt")\n' |
| 225 mod.write(code) |
| 226 to_pyobject = rope.base.oi.transform.TextualToPyObject(self.project) |
| 227 to_textual = rope.base.oi.transform.PyObjectToTextual(self.project) |
| 228 pymod = self.project.get_pymodule(mod) |
| 229 |
| 230 def complex_to_textual(pyobject): |
| 231 return to_textual.transform( |
| 232 to_pyobject.transform(to_textual.transform(pyobject))) |
| 233 for name in ('C', 'f', 'a_var', 'a_list', 'a_str', 'a_file'): |
| 234 var = pymod[name].get_object() |
| 235 self.assertEquals(to_textual.transform(var), |
| 236 complex_to_textual(var)) |
| 237 self.assertEquals(to_textual.transform(pymod), |
| 238 complex_to_textual(pymod)) |
| 239 enumerate_func = rope.base.builtins.builtins['enumerate'].get_object() |
| 240 self.assertEquals(to_textual.transform(enumerate_func), |
| 241 complex_to_textual(enumerate_func)) |
| 242 |
| 243 def test_arguments_with_keywords(self): |
| 244 mod = testutils.create_module(self.project, 'mod') |
| 245 code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ |
| 246 'def a_func(arg):\n return eval("arg")\n' \ |
| 247 'a = a_func(arg=C1())\nb = a_func(arg=C2())\n' |
| 248 mod.write(code) |
| 249 self.pycore.run_module(mod).wait_process() |
| 250 pymod = self.project.get_pymodule(mod) |
| 251 c1_class = pymod['C1'].get_object() |
| 252 c2_class = pymod['C2'].get_object() |
| 253 a_var = pymod['a'].get_object() |
| 254 b_var = pymod['b'].get_object() |
| 255 self.assertEquals(c1_class, a_var.get_type()) |
| 256 self.assertEquals(c2_class, b_var.get_type()) |
| 257 |
| 258 def test_a_function_with_different_returns(self): |
| 259 mod = testutils.create_module(self.project, 'mod') |
| 260 code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ |
| 261 'def a_func(arg):\n return eval("arg")\n' \ |
| 262 'a = a_func(C1())\nb = a_func(C2())\n' |
| 263 mod.write(code) |
| 264 self.pycore.run_module(mod).wait_process() |
| 265 pymod = self.project.get_pymodule(mod) |
| 266 c1_class = pymod['C1'].get_object() |
| 267 c2_class = pymod['C2'].get_object() |
| 268 a_var = pymod['a'].get_object() |
| 269 b_var = pymod['b'].get_object() |
| 270 self.assertEquals(c1_class, a_var.get_type()) |
| 271 self.assertEquals(c2_class, b_var.get_type()) |
| 272 |
| 273 def test_a_function_with_different_returns2(self): |
| 274 mod = testutils.create_module(self.project, 'mod') |
| 275 code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ |
| 276 'def a_func(p):\n if p == C1:\n return C1()\n' \ |
| 277 ' else:\n return C2()\n' \ |
| 278 'a = a_func(C1)\nb = a_func(C2)\n' |
| 279 mod.write(code) |
| 280 self.pycore.run_module(mod).wait_process() |
| 281 pymod = self.project.get_pymodule(mod) |
| 282 c1_class = pymod['C1'].get_object() |
| 283 c2_class = pymod['C2'].get_object() |
| 284 a_var = pymod['a'].get_object() |
| 285 b_var = pymod['b'].get_object() |
| 286 self.assertEquals(c1_class, a_var.get_type()) |
| 287 self.assertEquals(c2_class, b_var.get_type()) |
| 288 |
| 289 def test_ignoring_star_args(self): |
| 290 mod = testutils.create_module(self.project, 'mod') |
| 291 code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ |
| 292 'def a_func(p, *args):' \ |
| 293 '\n if p == C1:\n return C1()\n' \ |
| 294 ' else:\n return C2()\n' \ |
| 295 'a = a_func(C1, 1)\nb = a_func(C2, 2)\n' |
| 296 mod.write(code) |
| 297 self.pycore.run_module(mod).wait_process() |
| 298 pymod = self.project.get_pymodule(mod) |
| 299 c1_class = pymod['C1'].get_object() |
| 300 c2_class = pymod['C2'].get_object() |
| 301 a_var = pymod['a'].get_object() |
| 302 b_var = pymod['b'].get_object() |
| 303 self.assertEquals(c1_class, a_var.get_type()) |
| 304 self.assertEquals(c2_class, b_var.get_type()) |
| 305 |
| 306 def test_ignoring_double_star_args(self): |
| 307 mod = testutils.create_module(self.project, 'mod') |
| 308 code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ |
| 309 'def a_func(p, *kwds, **args):\n ' \ |
| 310 'if p == C1:\n return C1()\n' \ |
| 311 ' else:\n return C2()\n' \ |
| 312 'a = a_func(C1, kwd=1)\nb = a_func(C2, kwd=2)\n' |
| 313 mod.write(code) |
| 314 self.pycore.run_module(mod).wait_process() |
| 315 pymod = self.project.get_pymodule(mod) |
| 316 c1_class = pymod['C1'].get_object() |
| 317 c2_class = pymod['C2'].get_object() |
| 318 a_var = pymod['a'].get_object() |
| 319 b_var = pymod['b'].get_object() |
| 320 self.assertEquals(c1_class, a_var.get_type()) |
| 321 self.assertEquals(c2_class, b_var.get_type()) |
| 322 |
| 323 def test_invalidating_data_after_changing(self): |
| 324 mod = testutils.create_module(self.project, 'mod') |
| 325 code = 'def a_func(arg):\n return eval("arg")\n' \ |
| 326 'a_var = a_func(a_func)\n' |
| 327 mod.write(code) |
| 328 self.pycore.run_module(mod).wait_process() |
| 329 mod.write(code.replace('a_func', 'newfunc')) |
| 330 mod.write(code) |
| 331 pymod = self.project.get_pymodule(mod) |
| 332 self.assertNotEquals(pymod['a_func'].get_object(), |
| 333 pymod['a_var'].get_object()) |
| 334 |
| 335 def test_invalidating_data_after_moving(self): |
| 336 mod2 = testutils.create_module(self.project, 'mod2') |
| 337 mod2.write('class C(object):\n pass\n') |
| 338 mod = testutils.create_module(self.project, 'mod') |
| 339 code = 'import mod2\ndef a_func(arg):\n return eval(arg)\n' \ |
| 340 'a_var = a_func("mod2.C")\n' |
| 341 mod.write(code) |
| 342 self.pycore.run_module(mod).wait_process() |
| 343 mod.move('newmod.py') |
| 344 pymod = self.project.get_module('newmod') |
| 345 pymod2 = self.project.get_pymodule(mod2) |
| 346 self.assertEquals(pymod2['C'].get_object(), |
| 347 pymod['a_var'].get_object()) |
| 348 |
| 349 |
| 350 class NewStaticOITest(unittest.TestCase): |
| 351 |
| 352 def setUp(self): |
| 353 super(NewStaticOITest, self).setUp() |
| 354 self.project = testutils.sample_project(validate_objectdb=True) |
| 355 self.pycore = self.project.pycore |
| 356 self.mod = testutils.create_module(self.project, 'mod') |
| 357 |
| 358 def tearDown(self): |
| 359 testutils.remove_project(self.project) |
| 360 super(NewStaticOITest, self).tearDown() |
| 361 |
| 362 def test_static_oi_for_simple_function_calls(self): |
| 363 code = 'class C(object):\n pass\ndef f(p):\n pass\nf(C())\n' |
| 364 self.mod.write(code) |
| 365 self.pycore.analyze_module(self.mod) |
| 366 pymod = self.project.get_pymodule(self.mod) |
| 367 c_class = pymod['C'].get_object() |
| 368 f_scope = pymod['f'].get_object().get_scope() |
| 369 p_type = f_scope['p'].get_object().get_type() |
| 370 self.assertEquals(c_class, p_type) |
| 371 |
| 372 def test_static_oi_not_failing_when_callin_callables(self): |
| 373 code = 'class C(object):\n pass\nC()\n' |
| 374 self.mod.write(code) |
| 375 self.pycore.analyze_module(self.mod) |
| 376 |
| 377 def test_static_oi_for_nested_calls(self): |
| 378 code = 'class C(object):\n pass\ndef f(p):\n pass\n' \ |
| 379 'def g(p):\n return p\nf(g(C()))\n' |
| 380 self.mod.write(code) |
| 381 self.pycore.analyze_module(self.mod) |
| 382 pymod = self.project.get_pymodule(self.mod) |
| 383 c_class = pymod['C'].get_object() |
| 384 f_scope = pymod['f'].get_object().get_scope() |
| 385 p_type = f_scope['p'].get_object().get_type() |
| 386 self.assertEquals(c_class, p_type) |
| 387 |
| 388 def test_static_oi_class_methods(self): |
| 389 code = 'class C(object):\n def f(self, p):\n pass\n' \ |
| 390 'C().f(C())' |
| 391 self.mod.write(code) |
| 392 self.pycore.analyze_module(self.mod) |
| 393 pymod = self.project.get_pymodule(self.mod) |
| 394 c_class = pymod['C'].get_object() |
| 395 f_scope = c_class['f'].get_object().get_scope() |
| 396 p_type = f_scope['p'].get_object().get_type() |
| 397 self.assertEquals(c_class, p_type) |
| 398 |
| 399 def test_static_oi_preventing_soi_maximum_recursion_exceptions(self): |
| 400 code = 'item = {}\nfor item in item.keys():\n pass\n' |
| 401 self.mod.write(code) |
| 402 try: |
| 403 self.pycore.analyze_module(self.mod) |
| 404 except RuntimeError as e: |
| 405 self.fail(str(e)) |
| 406 |
| 407 def test_static_oi_for_infer_return_typs_from_funcs_based_on_params(self): |
| 408 code = 'class C(object):\n pass\ndef func(p):\n return p\n' \ |
| 409 'a_var = func(C())\n' |
| 410 self.mod.write(code) |
| 411 pymod = self.project.get_pymodule(self.mod) |
| 412 c_class = pymod['C'].get_object() |
| 413 a_var = pymod['a_var'].get_object() |
| 414 self.assertEquals(c_class, a_var.get_type()) |
| 415 |
| 416 def test_a_function_with_different_returns(self): |
| 417 code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ |
| 418 'def a_func(arg):\n return arg\n' \ |
| 419 'a = a_func(C1())\nb = a_func(C2())\n' |
| 420 self.mod.write(code) |
| 421 pymod = self.project.get_pymodule(self.mod) |
| 422 c1_class = pymod['C1'].get_object() |
| 423 c2_class = pymod['C2'].get_object() |
| 424 a_var = pymod['a'].get_object() |
| 425 b_var = pymod['b'].get_object() |
| 426 self.assertEquals(c1_class, a_var.get_type()) |
| 427 self.assertEquals(c2_class, b_var.get_type()) |
| 428 |
| 429 def test_not_reporting_out_of_date_information(self): |
| 430 code = 'class C1(object):\n pass\n' \ |
| 431 'def f(arg):\n return C1()\na_var = f('')\n' |
| 432 self.mod.write(code) |
| 433 pymod = self.project.get_pymodule(self.mod) |
| 434 c1_class = pymod['C1'].get_object() |
| 435 a_var = pymod['a_var'].get_object() |
| 436 self.assertEquals(c1_class, a_var.get_type()) |
| 437 |
| 438 self.mod.write(code.replace('C1', 'C2')) |
| 439 pymod = self.project.get_pymodule(self.mod) |
| 440 c2_class = pymod['C2'].get_object() |
| 441 a_var = pymod['a_var'].get_object() |
| 442 self.assertEquals(c2_class, a_var.get_type()) |
| 443 |
| 444 def test_invalidating_concluded_data_in_a_function(self): |
| 445 mod1 = testutils.create_module(self.project, 'mod1') |
| 446 mod2 = testutils.create_module(self.project, 'mod2') |
| 447 mod1.write('def func(arg):\n temp = arg\n return temp\n') |
| 448 mod2.write('import mod1\n' |
| 449 'class C1(object):\n pass\n' |
| 450 'class C2(object):\n pass\n' |
| 451 'a_var = mod1.func(C1())\n') |
| 452 pymod2 = self.project.get_pymodule(mod2) |
| 453 c1_class = pymod2['C1'].get_object() |
| 454 a_var = pymod2['a_var'].get_object() |
| 455 self.assertEquals(c1_class, a_var.get_type()) |
| 456 |
| 457 mod2.write(mod2.read()[:mod2.read().rfind('C1()')] + 'C2())\n') |
| 458 pymod2 = self.project.get_pymodule(mod2) |
| 459 c2_class = pymod2['C2'].get_object() |
| 460 a_var = pymod2['a_var'].get_object() |
| 461 self.assertEquals(c2_class, a_var.get_type()) |
| 462 |
| 463 def test_handling_generator_functions_for_strs(self): |
| 464 self.mod.write('class C(object):\n pass\ndef f(p):\n yield p()\n' |
| 465 'for c in f(C):\n a_var = c\n') |
| 466 pymod = self.project.get_pymodule(self.mod) |
| 467 c_class = pymod['C'].get_object() |
| 468 a_var = pymod['a_var'].get_object() |
| 469 self.assertEquals(c_class, a_var.get_type()) |
| 470 |
| 471 # TODO: Returning a generator for functions that yield unknowns |
| 472 @unittest.skip("Returning a generator that yields unknowns") |
| 473 def xxx_test_handl_generator_functions_when_unknown_type_is_yielded(self): |
| 474 self.mod.write('class C(object):\n pass' |
| 475 '\ndef f():\n yield eval("C()")\n' |
| 476 'a_var = f()\n') |
| 477 pymod = self.project.get_pymodule(self.mod) |
| 478 a_var = pymod['a_var'].get_object() |
| 479 self.assertTrue(isinstance(a_var.get_type(), |
| 480 rope.base.builtins.Generator)) |
| 481 |
| 482 def test_static_oi_for_lists_depending_on_append_function(self): |
| 483 code = 'class C(object):\n pass\nl = list()\n' \ |
| 484 'l.append(C())\na_var = l.pop()\n' |
| 485 self.mod.write(code) |
| 486 self.pycore.analyze_module(self.mod) |
| 487 pymod = self.project.get_pymodule(self.mod) |
| 488 c_class = pymod['C'].get_object() |
| 489 a_var = pymod['a_var'].get_object() |
| 490 self.assertEquals(c_class, a_var.get_type()) |
| 491 |
| 492 def test_static_oi_for_lists_per_object_for_get_item(self): |
| 493 code = 'class C(object):\n pass\nl = list()\n' \ |
| 494 'l.append(C())\na_var = l[0]\n' |
| 495 self.mod.write(code) |
| 496 self.pycore.analyze_module(self.mod) |
| 497 pymod = self.project.get_pymodule(self.mod) |
| 498 c_class = pymod['C'].get_object() |
| 499 a_var = pymod['a_var'].get_object() |
| 500 self.assertEquals(c_class, a_var.get_type()) |
| 501 |
| 502 def test_static_oi_for_lists_per_object_for_fields(self): |
| 503 code = 'class C(object):\n pass\n' \ |
| 504 'class A(object):\n ' \ |
| 505 'def __init__(self):\n self.l = []\n' \ |
| 506 ' def set(self):\n self.l.append(C())\n' \ |
| 507 'a = A()\na.set()\na_var = a.l[0]\n' |
| 508 self.mod.write(code) |
| 509 self.pycore.analyze_module(self.mod) |
| 510 pymod = self.project.get_pymodule(self.mod) |
| 511 c_class = pymod['C'].get_object() |
| 512 a_var = pymod['a_var'].get_object() |
| 513 self.assertEquals(c_class, a_var.get_type()) |
| 514 |
| 515 def test_static_oi_for_lists_per_object_for_set_item(self): |
| 516 code = 'class C(object):\n pass\nl = [None]\n' \ |
| 517 'l[0] = C()\na_var = l[0]\n' |
| 518 self.mod.write(code) |
| 519 self.pycore.analyze_module(self.mod) |
| 520 pymod = self.project.get_pymodule(self.mod) |
| 521 c_class = pymod['C'].get_object() |
| 522 a_var = pymod['a_var'].get_object() |
| 523 self.assertEquals(c_class, a_var.get_type()) |
| 524 |
| 525 def test_static_oi_for_lists_per_object_for_extending_lists(self): |
| 526 code = 'class C(object):\n pass\nl = []\n' \ |
| 527 'l.append(C())\nl2 = []\nl2.extend(l)\na_var = l2[0]\n' |
| 528 self.mod.write(code) |
| 529 self.pycore.analyze_module(self.mod) |
| 530 pymod = self.project.get_pymodule(self.mod) |
| 531 c_class = pymod['C'].get_object() |
| 532 a_var = pymod['a_var'].get_object() |
| 533 self.assertEquals(c_class, a_var.get_type()) |
| 534 |
| 535 def test_static_oi_for_lists_per_object_for_iters(self): |
| 536 code = 'class C(object):\n pass\n' \ |
| 537 'l = []\nl.append(C())\n' \ |
| 538 'for c in l:\n a_var = c\n' |
| 539 self.mod.write(code) |
| 540 self.pycore.analyze_module(self.mod) |
| 541 pymod = self.project.get_pymodule(self.mod) |
| 542 c_class = pymod['C'].get_object() |
| 543 a_var = pymod['a_var'].get_object() |
| 544 self.assertEquals(c_class, a_var.get_type()) |
| 545 |
| 546 def test_static_oi_for_dicts_depending_on_append_function(self): |
| 547 code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ |
| 548 'd = {}\nd[C1()] = C2()\na, b = d.popitem()\n' |
| 549 self.mod.write(code) |
| 550 self.pycore.analyze_module(self.mod) |
| 551 pymod = self.project.get_pymodule(self.mod) |
| 552 c1_class = pymod['C1'].get_object() |
| 553 c2_class = pymod['C2'].get_object() |
| 554 a_var = pymod['a'].get_object() |
| 555 b_var = pymod['b'].get_object() |
| 556 self.assertEquals(c1_class, a_var.get_type()) |
| 557 self.assertEquals(c2_class, b_var.get_type()) |
| 558 |
| 559 def test_static_oi_for_dicts_depending_on_for_loops(self): |
| 560 code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ |
| 561 'd = {}\nd[C1()] = C2()\n' \ |
| 562 'for k, v in d.items():\n a = k\n b = v\n' |
| 563 self.mod.write(code) |
| 564 self.pycore.analyze_module(self.mod) |
| 565 pymod = self.project.get_pymodule(self.mod) |
| 566 c1_class = pymod['C1'].get_object() |
| 567 c2_class = pymod['C2'].get_object() |
| 568 a_var = pymod['a'].get_object() |
| 569 b_var = pymod['b'].get_object() |
| 570 self.assertEquals(c1_class, a_var.get_type()) |
| 571 self.assertEquals(c2_class, b_var.get_type()) |
| 572 |
| 573 def test_static_oi_for_dicts_depending_on_update(self): |
| 574 code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ |
| 575 'd = {}\nd[C1()] = C2()\n' \ |
| 576 'd2 = {}\nd2.update(d)\na, b = d2.popitem()\n' |
| 577 self.mod.write(code) |
| 578 self.pycore.analyze_module(self.mod) |
| 579 pymod = self.project.get_pymodule(self.mod) |
| 580 c1_class = pymod['C1'].get_object() |
| 581 c2_class = pymod['C2'].get_object() |
| 582 a_var = pymod['a'].get_object() |
| 583 b_var = pymod['b'].get_object() |
| 584 self.assertEquals(c1_class, a_var.get_type()) |
| 585 self.assertEquals(c2_class, b_var.get_type()) |
| 586 |
| 587 def test_static_oi_for_dicts_depending_on_update_on_seqs(self): |
| 588 code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ |
| 589 'd = {}\nd.update([(C1(), C2())])\na, b = d.popitem()\n' |
| 590 self.mod.write(code) |
| 591 self.pycore.analyze_module(self.mod) |
| 592 pymod = self.project.get_pymodule(self.mod) |
| 593 c1_class = pymod['C1'].get_object() |
| 594 c2_class = pymod['C2'].get_object() |
| 595 a_var = pymod['a'].get_object() |
| 596 b_var = pymod['b'].get_object() |
| 597 self.assertEquals(c1_class, a_var.get_type()) |
| 598 self.assertEquals(c2_class, b_var.get_type()) |
| 599 |
| 600 def test_static_oi_for_sets_per_object_for_set_item(self): |
| 601 code = 'class C(object):\n pass\ns = set()\n' \ |
| 602 's.add(C())\na_var = s.pop() \n' |
| 603 self.mod.write(code) |
| 604 self.pycore.analyze_module(self.mod) |
| 605 pymod = self.project.get_pymodule(self.mod) |
| 606 c_class = pymod['C'].get_object() |
| 607 a_var = pymod['a_var'].get_object() |
| 608 self.assertEquals(c_class, a_var.get_type()) |
| 609 |
| 610 def test_properties_and_calling_get_property(self): |
| 611 code = 'class C1(object):\n pass\n' \ |
| 612 'class C2(object):\n c1 = C1()\n' \ |
| 613 ' def get_c1(self):\n return self.c1\n' \ |
| 614 ' p = property(get_c1)\nc2 = C2()\na_var = c2.p\n' |
| 615 self.mod.write(code) |
| 616 pymod = self.project.get_pymodule(self.mod) |
| 617 c1_class = pymod['C1'].get_object() |
| 618 a_var = pymod['a_var'].get_object() |
| 619 self.assertEquals(c1_class, a_var.get_type()) |
| 620 |
| 621 def test_soi_on_constructors(self): |
| 622 code = 'class C1(object):\n pass\n' \ |
| 623 'class C2(object):\n' \ |
| 624 ' def __init__(self, arg):\n self.attr = arg\n' \ |
| 625 'c2 = C2(C1())\na_var = c2.attr' |
| 626 self.mod.write(code) |
| 627 self.pycore.analyze_module(self.mod) |
| 628 pymod = self.project.get_pymodule(self.mod) |
| 629 c1_class = pymod['C1'].get_object() |
| 630 a_var = pymod['a_var'].get_object() |
| 631 self.assertEquals(c1_class, a_var.get_type()) |
| 632 |
| 633 def test_not_saving_unknown_function_returns(self): |
| 634 mod2 = testutils.create_module(self.project, 'mod2') |
| 635 self.mod.write('class C(object):\n pass\nl = []\nl.append(C())\n') |
| 636 mod2.write('import mod\ndef f():\n ' |
| 637 'return mod.l.pop()\na_var = f()\n') |
| 638 pymod = self.project.get_pymodule(self.mod) |
| 639 pymod2 = self.project.get_pymodule(mod2) |
| 640 c_class = pymod['C'].get_object() |
| 641 a_var = pymod2['a_var'] |
| 642 |
| 643 self.pycore.analyze_module(mod2) |
| 644 self.assertNotEquals(c_class, a_var.get_object().get_type()) |
| 645 |
| 646 self.pycore.analyze_module(self.mod) |
| 647 self.assertEquals(c_class, a_var.get_object().get_type()) |
| 648 |
| 649 def test_using_the_best_callinfo(self): |
| 650 code = 'class C1(object):\n pass\n' \ |
| 651 'def f(arg1, arg2, arg3):\n pass\n' \ |
| 652 'f("", None, C1())\nf("", C1(), None)\n' |
| 653 self.mod.write(code) |
| 654 self.pycore.analyze_module(self.mod) |
| 655 pymod = self.project.get_pymodule(self.mod) |
| 656 c1_class = pymod['C1'].get_object() |
| 657 f_scope = pymod['f'].get_object().get_scope() |
| 658 arg2 = f_scope['arg2'].get_object() |
| 659 self.assertEquals(c1_class, arg2.get_type()) |
| 660 |
| 661 def test_call_function_and_parameters(self): |
| 662 code = 'class A(object):\n def __call__(self, p):\n pass\n' \ |
| 663 'A()("")\n' |
| 664 self.mod.write(code) |
| 665 self.pycore.analyze_module(self.mod) |
| 666 scope = self.project.get_pymodule(self.mod).get_scope() |
| 667 p_object = scope.get_scopes()[0].get_scopes()[0]['p'].get_object() |
| 668 self.assertTrue(isinstance(p_object.get_type(), |
| 669 rope.base.builtins.Str)) |
| 670 |
| 671 def test_report_change_in_libutils(self): |
| 672 self.project.prefs['automatic_soa'] = True |
| 673 code = 'class C(object):\n pass\ndef f(p):\n pass\nf(C())\n' |
| 674 mod_file = open(self.mod.real_path, 'w') |
| 675 mod_file.write(code) |
| 676 mod_file.close() |
| 677 rope.base.libutils.report_change(self.project, self.mod.real_path, '') |
| 678 pymod = self.project.get_pymodule(self.mod) |
| 679 c_class = pymod['C'].get_object() |
| 680 f_scope = pymod['f'].get_object().get_scope() |
| 681 p_type = f_scope['p'].get_object().get_type() |
| 682 self.assertEquals(c_class, p_type) |
| 683 |
| 684 def test_report_libutils_and_analyze_all_modules(self): |
| 685 code = 'class C(object):\n pass\ndef f(p):\n pass\nf(C())\n' |
| 686 self.mod.write(code) |
| 687 rope.base.libutils.analyze_modules(self.project) |
| 688 pymod = self.project.get_pymodule(self.mod) |
| 689 c_class = pymod['C'].get_object() |
| 690 f_scope = pymod['f'].get_object().get_scope() |
| 691 p_type = f_scope['p'].get_object().get_type() |
| 692 self.assertEquals(c_class, p_type) |
| 693 |
| 694 def test_validation_problems_for_objectdb_retrievals(self): |
| 695 mod1 = testutils.create_module(self.project, 'mod1') |
| 696 mod2 = testutils.create_module(self.project, 'mod2') |
| 697 mod1.write('l = []\nvar = l.pop()\n') |
| 698 mod2.write('import mod1\n\nclass C(object):\n pass\n' |
| 699 'mod1.l.append(C())\n') |
| 700 self.pycore.analyze_module(mod2) |
| 701 |
| 702 pymod2 = self.project.get_pymodule(mod2) |
| 703 c_class = pymod2['C'].get_object() |
| 704 pymod1 = self.project.get_pymodule(mod1) |
| 705 var_pyname = pymod1['var'] |
| 706 self.assertEquals(c_class, var_pyname.get_object().get_type()) |
| 707 mod2.write('import mod1\n\nmod1.l.append("")\n') |
| 708 self.assertNotEquals(c_class, var_pyname.get_object().get_type(), |
| 709 'Class `C` no more exists') |
| 710 |
| 711 def test_validation_problems_for_changing_builtin_types(self): |
| 712 mod1 = testutils.create_module(self.project, 'mod1') |
| 713 mod1.write('l = []\nl.append("")\n') |
| 714 self.pycore.analyze_module(mod1) |
| 715 |
| 716 mod1.write('l = {}\nv = l["key"]\n') |
| 717 pymod1 = self.project.get_pymodule(mod1) # noqa |
| 718 var = pymod1['v'].get_object() # noqa |
| 719 |
| 720 def test_always_returning_containing_class_for_selfs(self): |
| 721 code = 'class A(object):\n def f(p):\n return p\n' \ |
| 722 'class B(object):\n pass\nb = B()\nb.f()\n' |
| 723 self.mod.write(code) |
| 724 self.pycore.analyze_module(self.mod) |
| 725 pymod = self.project.get_pymodule(self.mod) |
| 726 a_class = pymod['A'].get_object() |
| 727 f_scope = a_class.get_scope().get_scopes()[0] |
| 728 p_type = f_scope['p'].get_object().get_type() |
| 729 self.assertEquals(a_class, p_type) |
| 730 |
| 731 def test_following_function_calls_when_asked_to(self): |
| 732 code = 'class A(object):\n pass\n' \ |
| 733 'class C(object):\n' \ |
| 734 ' def __init__(self, arg):\n' \ |
| 735 ' self.attr = arg\n' \ |
| 736 'def f(p):\n return C(p)\n' \ |
| 737 'c = f(A())\nx = c.attr\n' |
| 738 self.mod.write(code) |
| 739 self.pycore.analyze_module(self.mod, followed_calls=1) |
| 740 pymod = self.project.get_pymodule(self.mod) |
| 741 a_class = pymod['A'].get_object() |
| 742 x_var = pymod['x'].get_object().get_type() |
| 743 self.assertEquals(a_class, x_var) |
| 744 |
| 745 |
| 746 def suite(): |
| 747 result = unittest.TestSuite() |
| 748 result.addTests(unittest.makeSuite(DynamicOITest)) |
| 749 result.addTests(unittest.makeSuite(NewStaticOITest)) |
| 750 return result |
| 751 |
| 752 |
| 753 if __name__ == '__main__': |
| 754 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