-
-
Notifications
You must be signed in to change notification settings - Fork 508
/
regression.py
executable file
·396 lines (329 loc) · 13.7 KB
/
regression.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import unittest
import time
import functools
import itertools
import os
from base import TestBase
import jedi
from jedi._compatibility import is_py25, utf8, unicode
from jedi import api
#jedi.set_debug_function(jedi.debug.print_to_stdout)
class TestRegression(TestBase):
def test_star_import_cache_duration(self):
new = 0.01
old, jedi.settings.star_import_cache_validity = \
jedi.settings.star_import_cache_validity, new
cache = api.cache
cache.star_import_cache = {} # first empty...
# path needs to be not-None (otherwise caching effects are not visible)
jedi.Script('', 1, 0, '').complete()
time.sleep(2 * new)
jedi.Script('', 1, 0, '').complete()
# reset values
jedi.settings.star_import_cache_validity = old
length = len(cache.star_import_cache)
cache.star_import_cache = {}
self.assertEqual(length, 1)
def test_part_parser(self):
""" test the get_in_function_call speedups """
s = '\n' * 100 + 'abs('
pos = 101, 4
self.get_in_function_call(s, pos)
assert self.get_in_function_call(s, pos)
def test_get_definition_cursor(self):
s = ("class A():\n"
" def _something(self):\n"
" return\n"
" def different_line(self,\n"
" b):\n"
" return\n"
"A._something\n"
"A.different_line"
)
in_name = 2, 9
under_score = 2, 8
cls = 2, 7
should1 = 7, 10
diff_line = 4, 10
should2 = 8, 10
get_def = lambda pos: [d.description for d in self.get_def(s, pos)]
in_name = get_def(in_name)
under_score = get_def(under_score)
should1 = get_def(should1)
should2 = get_def(should2)
diff_line = get_def(diff_line)
assert should1 == in_name
assert should1 == under_score
#print should2, diff_line
assert should2 == diff_line
self.assertRaises(jedi.NotFoundError, get_def, cls)
def test_keyword_doc(self):
r = list(self.get_def("or", (1, 1)))
assert len(r) == 1
if not is_py25:
assert len(r[0].doc) > 100
r = list(self.get_def("asfdasfd", (1, 1)))
assert len(r) == 0
def test_operator_doc(self):
r = list(self.get_def("a == b", (1, 3)))
assert len(r) == 1
if not is_py25:
assert len(r[0].doc) > 100
def test_get_definition_at_zero(self):
assert self.get_def("a", (1, 1)) == []
s = self.get_def("str", (1, 1))
assert len(s) == 1
assert list(s)[0].description == 'class str'
assert self.get_def("", (1, 0)) == []
def test_complete_at_zero(self):
s = self.complete("str", (1, 3))
assert len(s) == 1
assert list(s)[0].word == 'str'
s = self.complete("", (1, 0))
assert len(s) > 0
def test_get_definition_on_import(self):
assert self.get_def("import sys_blabla", (1, 8)) == []
assert len(self.get_def("import sys", (1, 8))) == 1
def test_complete_on_empty_import(self):
# should just list the files in the directory
assert 10 < len(self.complete("from .", path='')) < 30
assert 10 < len(self.complete("from . import", (1, 5), '')) < 30
assert 10 < len(self.complete("from . import classes",
(1, 5), '')) < 30
assert len(self.complete("import")) == 0
assert len(self.complete("import import", path='')) > 0
# 111
assert self.complete("from datetime import")[0].word == 'import'
assert self.complete("from datetime import ")
def test_get_in_function_call(self):
def check(call_def, name, index):
return call_def and call_def.call_name == name \
and call_def.index == index
# simple
s = "abs(a, str("
s2 = "abs(), "
s3 = "abs()."
# more complicated
s4 = 'abs(zip(), , set,'
s5 = "abs(1,\nif 2:\n def a():"
s6 = "str().center("
s7 = "str().upper().center("
s8 = "str(int[zip("
assert check(self.get_in_function_call(s, (1, 4)), 'abs', 0)
assert check(self.get_in_function_call(s, (1, 6)), 'abs', 1)
assert check(self.get_in_function_call(s, (1, 7)), 'abs', 1)
assert check(self.get_in_function_call(s, (1, 8)), 'abs', 1)
assert check(self.get_in_function_call(s, (1, 11)), 'str', 0)
assert check(self.get_in_function_call(s2, (1, 4)), 'abs', 0)
assert self.get_in_function_call(s2, (1, 5)) is None
assert self.get_in_function_call(s2) is None
assert self.get_in_function_call(s3, (1, 5)) is None
assert self.get_in_function_call(s3) is None
assert self.get_in_function_call(s4, (1, 3)) is None
assert check(self.get_in_function_call(s4, (1, 4)), 'abs', 0)
assert check(self.get_in_function_call(s4, (1, 8)), 'zip', 0)
assert check(self.get_in_function_call(s4, (1, 9)), 'abs', 0)
assert check(self.get_in_function_call(s4, (1, 10)), 'abs', 1)
assert check(self.get_in_function_call(s5, (1, 4)), 'abs', 0)
assert check(self.get_in_function_call(s5, (1, 6)), 'abs', 1)
assert check(self.get_in_function_call(s6), 'center', 0)
assert check(self.get_in_function_call(s6, (1, 4)), 'str', 0)
assert check(self.get_in_function_call(s7), 'center', 0)
assert check(self.get_in_function_call(s8), 'zip', 0)
assert check(self.get_in_function_call(s8, (1, 8)), 'str', 0)
s = "import time; abc = time; abc.sleep("
assert check(self.get_in_function_call(s), 'sleep', 0)
# jedi-vim #9
s = "with open("
assert check(self.get_in_function_call(s), 'open', 0)
# jedi-vim #11
s1 = "for sorted("
assert check(self.get_in_function_call(s1), 'sorted', 0)
s2 = "for s in sorted("
assert check(self.get_in_function_call(s2), 'sorted', 0)
# jedi #57
s = "def func(alpha, beta): pass\n" \
"func(alpha='101',"
assert check(self.get_in_function_call(s, (2, 13)), 'func', 0)
def test_get_in_function_call_complex(self):
def check(call_def, name, index):
return call_def and call_def.call_name == name \
and call_def.index == index
s = """
def abc(a,b):
pass
def a(self):
abc(
if 1:
pass
"""
assert check(self.get_in_function_call(s, (6, 24)), 'abc', 0)
s = """
import re
def huhu(it):
re.compile(
return it * 2
"""
assert check(self.get_in_function_call(s, (4, 31)), 'compile', 0)
# jedi-vim #70
s = """def foo("""
assert self.get_in_function_call(s) is None
def test_add_dynamic_mods(self):
api.settings.additional_dynamic_modules = ['dynamic.py']
# Fictional module that defines a function.
src1 = "def ret(a): return a"
# Other fictional modules in another place in the fs.
src2 = 'from .. import setup; setup.ret(1)'
# .parser to load the module
api.modules.Module(os.path.abspath('dynamic.py'), src2).parser
script = jedi.Script(src1, 1, len(src1), '../setup.py')
result = script.get_definition()
assert len(result) == 1
assert result[0].description == 'class int'
def test_named_import(self):
""" named import - jedi-vim issue #8 """
s = "import time as dt"
assert len(jedi.Script(s, 1, 15, '/').get_definition()) == 1
assert len(jedi.Script(s, 1, 10, '/').get_definition()) == 1
def test_unicode_script(self):
""" normally no unicode objects are being used. (<=2.7) """
s = unicode("import datetime; datetime.timedelta")
completions = self.complete(s)
assert len(completions)
assert type(completions[0].description) is unicode
s = utf8("author='öä'; author")
completions = self.complete(s)
assert type(completions[0].description) is unicode
s = utf8("#-*- coding: iso-8859-1 -*-\nauthor='öä'; author")
s = s.encode('latin-1')
completions = self.complete(s)
assert type(completions[0].description) is unicode
def test_multibyte_script(self):
""" `jedi.Script` must accept multi-byte string source. """
try:
code = unicode("import datetime; datetime.d")
comment = utf8("# multi-byte comment あいうえおä")
s = (unicode('%s\n%s') % (code, comment)).encode('utf-8')
except NameError:
pass # python 3 has no unicode method
else:
assert len(self.complete(s, (1, len(code))))
def test_os_nowait(self):
""" github issue #45 """
s = self.complete("import os; os.P_")
assert 'P_NOWAIT' in [i.word for i in s]
def test_follow_definition(self):
""" github issue #45 """
c = self.complete("from datetime import timedelta; timedelta")
# type can also point to import, but there will be additional
# attributes
objs = itertools.chain.from_iterable(r.follow_definition() for r in c)
types = [o.type for o in objs]
assert 'Import' not in types and 'Class' in types
def test_keyword_definition_doc(self):
""" github jedi-vim issue #44 """
defs = self.get_def("print")
assert [d.doc for d in defs]
defs = self.get_def("import")
assert len(defs) == 1
assert [d.doc for d in defs]
def test_goto_following_on_imports(self):
if is_py25:
return
g = self.goto("import multiprocessing.dummy; multiprocessing.dummy")
assert len(g) == 1
assert g[0].start_pos != (0, 0)
def test_points_in_completion(self):
"""At some point, points were inserted into the completions, this
caused problems, sometimes.
"""
c = self.complete("if IndentationErr")
assert c[0].word == 'IndentationError'
self.assertEqual(c[0].complete, 'or')
def test_docstrings_type_str(self):
s = """
def func(arg):
'''
:type arg: str
'''
arg."""
words = [c.word for c in self.complete(s)]
assert 'join' in words
def test_docstrings_type_dotted_import(self):
s = """
def func(arg):
'''
:type arg: threading.Thread
'''
arg."""
words = [c.word for c in self.complete(s)]
assert 'start' in words
class TestFeature(TestBase):
def test_full_name(self):
""" feature request #61"""
assert self.complete('import os; os.path.join')[0].full_name \
== 'os.path.join'
# issue #94
defs = self.get_def("""import os; os.path.join(""")
assert defs[0].full_name is None
def test_full_name_builtin(self):
self.assertEqual(self.complete('type')[0].full_name, 'type')
def test_full_name_tuple_mapping(self):
s = """
import re
any_re = re.compile('.*')
any_re"""
self.assertEqual(self.get_def(s)[0].full_name, 're.RegexObject')
def test_quick_completion(self):
sources = [
('import json; json.l', (1, 19)),
('import json; json.l ', (1, 19)),
('import json\njson.l', (2, 6)),
('import json\njson.l ', (2, 6)),
('import json\njson.l\n\n', (2, 6)),
('import json\njson.l \n\n', (2, 6)),
('import json\njson.l \n \n\n', (2, 6)),
]
for source, pos in sources:
# Run quick_complete
quick_completions = api._quick_complete(source)
# Run real completion
script = jedi.Script(source, pos[0], pos[1], '')
real_completions = script.complete()
# Compare results
quick_values = [(c.full_name, c.line, c.column) for c in quick_completions]
real_values = [(c.full_name, c.line, c.column) for c in real_completions]
self.assertEqual(quick_values, real_values)
class TestSpeed(TestBase):
def _check_speed(time_per_run, number=4, run_warm=True):
""" Speed checks should typically be very tolerant. Some machines are
faster than others, but the tests should still pass. These tests are
here to assure that certain effects that kill jedi performance are not
reintroduced to Jedi."""
def decorated(func):
@functools.wraps(func)
def wrapper(self):
if run_warm:
func(self)
first = time.time()
for i in range(number):
func(self)
single_time = (time.time() - first) / number
print('\nspeed', func, single_time)
assert single_time < time_per_run
return wrapper
return decorated
@_check_speed(0.1)
def test_os_path_join(self):
s = "from posixpath import join; join('', '')."
assert len(self.complete(s)) > 10 # is a str completion
@_check_speed(0.1)
def test_scipy_speed(self):
s = 'import scipy.weave; scipy.weave.inline('
script = jedi.Script(s, 1, len(s), '')
script.get_in_function_call()
#print(jedi.imports.imports_processed)
if __name__ == '__main__':
unittest.main()