moved api, parser and evaluate test directories to test_api, test_parser...

test/test_parser/test_fast_parser.py

@@ -0,0 +1,37 @@
+import jedi
+
+def test_add_to_end():
+    """
+    fast_parser doesn't parse everything again. It just updates with the
+    help of caches, this is an example that didn't work.
+    """
+
+    a = """
+class Abc():
+    def abc(self):
+        self.x = 3
+
+class Two(Abc):
+    def h(self):
+        self
+"""  #      ^ here is the first completion
+
+    b = "    def g(self):\n" \
+        "        self."
+    assert jedi.Script(a, 8, 12, 'example.py').completions()
+    assert  jedi.Script(a + b, path='example.py').completions()
+
+    a = a[:-1] + '.\n'
+    assert jedi.Script(a, 8, 13, 'example.py').completions()
+    assert  jedi.Script(a + b, path='example.py').completions()
+
+
+def test_class_in_docstr():
+    """
+    Regression test for a problem with classes in docstrings.
+    """
+    a = '"\nclasses\n"'
+    jedi.Script(a, 1, 0)._parser
+
+    b = a + '\nimport os'
+    assert jedi.Script(b, 4, 8).goto_assignments()

test/test_parser/test_parsing.py

@@ -0,0 +1,96 @@
+from jedi.parser import Parser
+from jedi.parser.user_context import UserContextParser
+from jedi.parser import representation as pr
+
+
+def test_user_statement_on_import():
+    """github #285"""
+    s = "from datetime import (\n" \
+        "    time)"
+
+    for pos in [(2, 1), (2, 4)]:
+        u = UserContextParser(s, None, pos, None).user_stmt()
+        assert isinstance(u, pr.Import)
+        assert u.defunct is False
+        assert [str(n) for n in u.get_defined_names()] == ['time']
+
+
+class TestCallAndName():
+    def get_call(self, source):
+        stmt = Parser(source, no_docstr=True).module.statements[0]
+        return stmt.expression_list()[0]
+
+    def test_name_and_call_positions(self):
+        call = self.get_call('name\nsomething_else')
+        assert str(call.name) == 'name'
+        assert call.name.start_pos == call.start_pos == (1, 0)
+        assert call.name.end_pos == call.end_pos == (1, 4)
+
+        call = self.get_call('1.0\n')
+        assert call.value == 1.0
+        assert call.start_pos == (1, 0)
+        assert call.end_pos == (1, 3)
+
+    def test_call_type(self):
+        call = self.get_call('hello')
+        assert isinstance(call, pr.Call)
+        assert type(call.name) == pr.Name
+
+    def test_literal_type(self):
+        literal = self.get_call('1.0')
+        assert isinstance(literal, pr.Literal)
+        assert type(literal.value) == float
+
+        literal = self.get_call('1')
+        assert isinstance(literal, pr.Literal)
+        assert type(literal.value) == int
+
+        literal = self.get_call('"hello"')
+        assert isinstance(literal, pr.Literal)
+        assert literal.value == 'hello'
+
+
+class TestSubscopes():
+    def get_sub(self, source):
+        return Parser(source).module.subscopes[0]
+
+    def test_subscope_names(self):
+        name = self.get_sub('class Foo: pass').name
+        assert name.start_pos == (1, len('class '))
+        assert name.end_pos == (1, len('class Foo'))
+        assert str(name) == 'Foo'
+
+        name = self.get_sub('def foo(): pass').name
+        assert name.start_pos == (1, len('def '))
+        assert name.end_pos == (1, len('def foo'))
+        assert str(name) == 'foo'
+
+
+class TestImports():
+    def get_import(self, source):
+        return Parser(source).module.imports[0]
+
+    def test_import_names(self):
+        imp = self.get_import('import math\n')
+        names = imp.get_defined_names()
+        assert len(names) == 1
+        assert str(names[0]) == 'math'
+        assert names[0].start_pos == (1, len('import '))
+        assert names[0].end_pos == (1, len('import math'))
+
+        assert imp.start_pos == (1, 0)
+        assert imp.end_pos == (1, len('import math'))
+
+
+def test_module():
+    module = Parser('asdf', 'example.py', no_docstr=True).module
+    name = module.name
+    assert str(name) == 'example'
+    assert name.start_pos == (0, 0)
+    assert name.end_pos == (0, 0)
+
+    module = Parser('asdf', no_docstr=True).module
+    name = module.name
+    assert str(name) == ''
+    assert name.start_pos == (0, 0)
+    assert name.end_pos == (0, 0)

test/test_parser/test_parsing_representation.py

@@ -0,0 +1,29 @@
+from jedi.parser import Parser
+
+def test_get_code():
+    """Use the same code that the parser also generates, to compare"""
+    s = \
+'''"""a docstring"""
+class SomeClass(object, mixin):
+    def __init__(self):
+        self.xy = 3.0
+        """statement docstr"""
+    def some_method(self):
+        return 1
+    def yield_method(self):
+        while hasattr(self, 'xy'):
+            yield True
+        for x in [1, 2]:
+            yield x
+    def empty(self):
+        pass
+class Empty:
+    pass
+class WithDocstring:
+    """class docstr"""
+    pass
+def method_with_docstring():
+    """class docstr"""
+    pass
+'''
+    assert Parser(s).module.get_code() == s

test/test_parser/test_token.py

@@ -0,0 +1,25 @@
+import jedi.parser as parser
+
+try:
+    import unittest2 as unittest
+except ImportError:  # pragma: no cover
+    import unittest
+
+
+class TokenTest(unittest.TestCase):
+    def test_end_pos_one_line(self):
+        parsed = parser.Parser('''
+def testit():
+    a = "huhu"
+''')
+        tok = parsed.top_module.subscopes[0].statements[0].token_list[2]
+        self.assertEqual(tok.end_pos, (3, 14))
+
+    def test_end_pos_multi_line(self):
+        parsed = parser.Parser('''
+def testit():
+    a = """huhu
+asdfasdf""" + "h"
+''')
+        tok = parsed.top_module.subscopes[0].statements[0].token_list[2]
+        self.assertEqual(tok.end_pos, (4, 11))