Tests failing using Python 3.7

[Apteryks]

This is probably related to proper Python 3.7 support in the process of being added (issue #1177), but there are no other issues mentioning it explicitly so I thought I'd report it here.

Using version 0.13.1, we get:

90 failed, 1621 passed, 30 skipped, 4 xfailed, 166 warnings in 123.17 seconds

For completeness, repeating the tests using the older 0.12.1 version, the summary reads like:

91 failed, 1591 passed, 30 skipped, 4 xfailed, 168 warnings, 4 error in 101.73 seconds

Here's a log excerpt for the 0.13.1 version:

=================================== FAILURES ===================================
____________________ test_completion[pep0526_variables:21] _____________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0526_variables.py:21 'with_typing_module[0]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffed76ba20>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0526_variables.py:21 'with_typing_module[0]'>
actual = set(), desired = {'builtins:instance float()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0526_variables.py:21 'with_typing_module[0]'> failed.
E         actual  = set()
E         desired = {'builtins:instance float()'}
E         
E       assert set() == {'builtins:instance float()'}
E         Extra items in the right set:
E         'builtins:instance float()'
E         Full diff:
E         - set()
E         + {'builtins:instance float()'}

../test/test_integration.py:16: AssertionError
_________________________ test_completion[arrays:163] __________________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/arrays.py:163 '(a)().replace()'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffececea20>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/arrays.py:163 '(a)().replace()'>
actual = set(), desired = {'builtins:instance str()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/arrays.py:163 '(a)().replace()'> failed.
E         actual  = set()
E         desired = {'builtins:instance str()'}
E         
E       assert set() == {'builtins:instance str()'}
E         Extra items in the right set:
E         'builtins:instance str()'
E         Full diff:
E         - set()
E         + {'builtins:instance str()'}

../test/test_integration.py:16: AssertionError
_________________________ test_completion[arrays:174] __________________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/arrays.py:174 'C().a'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffeced10f0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/arrays.py:174 'C().a'>
actual = set(), desired = {'builtins:instance str()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/arrays.py:174 'C().a'> failed.
E         actual  = set()
E         desired = {'builtins:instance str()'}
E         
E       assert set() == {'builtins:instance str()'}
E         Extra items in the right set:
E         'builtins:instance str()'
E         Full diff:
E         - set()
E         + {'builtins:instance str()'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:19] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:19 '    p.c'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeff9710>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:210: in run_completion
    return compare_cb(self, comp_str, set(literal_eval(self.correct)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:19 '    p.c'>
actual = set(), desired = {'count'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:19 '    p.c'> failed.
E         actual  = set()
E         desired = {'count'}
E         
E       assert set() == {'count'}
E         Extra items in the right set:
E         'count'
E         Full diff:
E         - set()
E         + {'count'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:21] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:21 '    p[1]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdefff780>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:21 '    p[1]'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:21 '    p[1]'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:23] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:23 '    q.c'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeff9518>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:210: in run_completion
    return compare_cb(self, comp_str, set(literal_eval(self.correct)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:23 '    q.c'>
actual = set(), desired = {'count'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:23 '    q.c'> failed.
E         actual  = set()
E         desired = {'count'}
E         
E       assert set() == {'count'}
E         Extra items in the right set:
E         'count'
E         Full diff:
E         - set()
E         + {'count'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:25] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:25 '    q[1]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdfce6a20>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:25 '    q[1]'>
actual = set(), desired = {'pep0484_typing:instance B()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:25 '    q[1]'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance B()'}
E         
E       assert set() == {'pep0484_typing:instance B()'}
E         Extra items in the right set:
E         'pep0484_typing:instance B()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance B()'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:27] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:27 '    r.c'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdfcff4a8>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:210: in run_completion
    return compare_cb(self, comp_str, set(literal_eval(self.correct)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:27 '    r.c'>
actual = set(), desired = {'count'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:27 '    r.c'> failed.
E         actual  = set()
E         desired = {'count'}
E         
E       assert set() == {'count'}
E         Extra items in the right set:
E         'count'
E         Full diff:
E         - set()
E         + {'count'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:29] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:29 '    r[1]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdf04e518>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:29 '    r[1]'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:29 '    r[1]'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:31] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:31 '    s.c'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdf06d550>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:210: in run_completion
    return compare_cb(self, comp_str, set(literal_eval(self.correct)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:31 '    s.c'>
actual = set(), desired = {'count'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:31 '    s.c'> failed.
E         actual  = set()
E         desired = {'count'}
E         
E       assert set() == {'count'}
E         Extra items in the right set:
E         'count'
E         Full diff:
E         - set()
E         + {'count'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:33] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:33 '    s[1]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffded8b518>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:33 '    s[1]'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:33 '    s[1]'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:37] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:37 '    t.a'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffded915c0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:210: in run_completion
    return compare_cb(self, comp_str, set(literal_eval(self.correct)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:37 '    t.a'>
actual = set(), desired = {'append'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:37 '    t.a'> failed.
E         actual  = set()
E         desired = {'append'}
E         
E       assert set() == {'append'}
E         Extra items in the right set:
E         'append'
E         Full diff:
E         - set()
E         + {'append'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:39] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:39 '    t[1]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdee1c6a0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:39 '    t[1]'>
actual = set(), desired = {'builtins:instance dict()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:39 '    t[1]'> failed.
E         actual  = set()
E         desired = {'builtins:instance dict()'}
E         
E       assert set() == {'builtins:instance dict()'}
E         Extra items in the right set:
E         'builtins:instance dict()'
E         Full diff:
E         - set()
E         + {'builtins:instance dict()'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:41] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:41 '    u.a'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffded3aa90>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:210: in run_completion
    return compare_cb(self, comp_str, set(literal_eval(self.correct)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:41 '    u.a'>
actual = set(), desired = {'append'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:41 '    u.a'> failed.
E         actual  = set()
E         desired = {'append'}
E         
E       assert set() == {'append'}
E         Extra items in the right set:
E         'append'
E         Full diff:
E         - set()
E         + {'append'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:43] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:43 '    u[1]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffded19f28>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:43 '    u[1]'>
actual = set(), desired = {'builtins:instance float()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:43 '    u[1]'> failed.
E         actual  = set()
E         desired = {'builtins:instance float()'}
E         
E       assert set() == {'builtins:instance float()'}
E         Extra items in the right set:
E         'builtins:instance float()'
E         Full diff:
E         - set()
E         + {'builtins:instance float()'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:54] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:54 '        p'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffded199e8>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:54 '        p'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:54 '        p'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:59] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:59 '    a'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffded51eb8>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:59 '    a'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:59 '    a'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:69] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:69 '        q'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeca4320>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:69 '        q'>
actual = set(), desired = {'builtins:instance str()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:69 '        q'> failed.
E         actual  = set()
E         desired = {'builtins:instance str()'}
E         
E       assert set() == {'builtins:instance str()'}
E         Extra items in the right set:
E         'builtins:instance str()'
E         Full diff:
E         - set()
E         + {'builtins:instance str()'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:71] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:71 '    next(qs)'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeca41d0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:71 '    next(qs)'>
actual = set(), desired = {'builtins:instance str()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:71 '    next(qs)'> failed.
E         actual  = set()
E         desired = {'builtins:instance str()'}
E         
E       assert set() == {'builtins:instance str()'}
E         Extra items in the right set:
E         'builtins:instance str()'
E         Full diff:
E         - set()
E         + {'builtins:instance str()'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:74] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:74 '        r'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdec8fa58>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:74 '        r'>
actual = set(), desired = {'pep0484_typing:instance ForwardReference()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:74 '        r'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance ForwardReference()'}
E         
E       assert set() == {'pep0484_typing:instance ForwardReference()'}
E         Extra items in the right set:
E         'pep0484_typing:instance ForwardReference()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance ForwardReference()'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:79] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:79 '        t'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdec09a90>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:79 '        t'>
actual = set(), desired = {'builtins:instance float()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:79 '        t'> failed.
E         actual  = set()
E         desired = {'builtins:instance float()'}
E         
E       assert set() == {'builtins:instance float()'}
E         Extra items in the right set:
E         'builtins:instance float()'
E         Full diff:
E         - set()
E         + {'builtins:instance float()'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:89] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:89 '    q.a'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeb0d4a8>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:210: in run_completion
    return compare_cb(self, comp_str, set(literal_eval(self.correct)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:89 '    q.a'>
actual = set(), desired = {'add'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:89 '    q.a'> failed.
E         actual  = set()
E         desired = {'add'}
E         
E       assert set() == {'add'}
E         Extra items in the right set:
E         'add'
E         Full diff:
E         - set()
E         + {'add'}

../test/test_integration.py:16: AssertionError
______________________ test_completion[pep0484_typing:98] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:98 '    p[0]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdea5c518>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:98 '    p[0]'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:98 '    p[0]'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:100] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:100 '    q[0]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeb1e860>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:100 '    q[0]'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:100 '    q[0]'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:102] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:102 '    q[1]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeb2e1d0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:102 '    q[1]'>
actual = set(), desired = {'builtins:instance str()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:102 '    q[1]'> failed.
E         actual  = set()
E         desired = {'builtins:instance str()'}
E         
E       assert set() == {'builtins:instance str()'}
E         Extra items in the right set:
E         'builtins:instance str()'
E         Full diff:
E         - set()
E         + {'builtins:instance str()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:104] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:104 '    q[2]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeb1e278>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:104 '    q[2]'>
actual = set(), desired = {'builtins:instance float()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:104 '    q[2]'> failed.
E         actual  = set()
E         desired = {'builtins:instance float()'}
E         
E       assert set() == {'builtins:instance float()'}
E         Extra items in the right set:
E         'builtins:instance float()'
E         Full diff:
E         - set()
E         + {'builtins:instance float()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:106] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:106 '    r[0]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeb121d0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:106 '    r[0]'>
actual = set(), desired = {'pep0484_typing:instance B()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:106 '    r[0]'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance B()'}
E         
E       assert set() == {'pep0484_typing:instance B()'}
E         Extra items in the right set:
E         'pep0484_typing:instance B()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance B()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:108] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:108 '    r[1]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdea404e0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:108 '    r[1]'>
actual = set(), desired = {'pep0484_typing:instance B()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:108 '    r[1]'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance B()'}
E         
E       assert set() == {'pep0484_typing:instance B()'}
E         Extra items in the right set:
E         'pep0484_typing:instance B()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance B()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:110] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:110 '    r[2]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdea68898>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:110 '    r[2]'>
actual = set(), desired = {'pep0484_typing:instance B()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:110 '    r[2]'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance B()'}
E         
E       assert set() == {'pep0484_typing:instance B()'}
E         Extra items in the right set:
E         'pep0484_typing:instance B()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance B()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:112] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:112 '    r[10000]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdea534e0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:112 '    r[10000]'>
actual = set(), desired = {'pep0484_typing:instance B()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:112 '    r[10000]'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance B()'}
E         
E       assert set() == {'pep0484_typing:instance B()'}
E         Extra items in the right set:
E         'pep0484_typing:instance B()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance B()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:115] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:115 '    i'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeb0deb8>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:115 '    i'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:115 '    i'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:144] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:144 '    q.setd'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdea0b5c0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:210: in run_completion
    return compare_cb(self, comp_str, set(literal_eval(self.correct)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:144 '    q.setd'>
actual = set(), desired = {'setdefault'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:144 '    q.setd'> failed.
E         actual  = set()
E         desired = {'setdefault'}
E         
E       assert set() == {'setdefault'}
E         Extra items in the right set:
E         'setdefault'
E         Full diff:
E         - set()
E         + {'setdefault'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:146] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:146 '    d.setd'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeb1e0b8>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:210: in run_completion
    return compare_cb(self, comp_str, set(literal_eval(self.correct)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:146 '    d.setd'>
actual = set(), desired = {'setdefault'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:146 '    d.setd'> failed.
E         actual  = set()
E         desired = {'setdefault'}
E         
E       assert set() == {'setdefault'}
E         Extra items in the right set:
E         'setdefault'
E         Full diff:
E         - set()
E         + {'setdefault'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:148] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:148 '    dd.setd'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeaba240>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:210: in run_completion
    return compare_cb(self, comp_str, set(literal_eval(self.correct)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:148 '    dd.setd'>
actual = set(), desired = {'setdefault'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:148 '    dd.setd'> failed.
E         actual  = set()
E         desired = {'setdefault'}
E         
E       assert set() == {'setdefault'}
E         Extra items in the right set:
E         'setdefault'
E         Full diff:
E         - set()
E         + {'setdefault'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:150] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:150 '    p[1]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdea29f98>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:150 '    p[1]'>
actual = set(), desired = {'pep0484_typing:instance Value()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:150 '    p[1]'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance Value()'}
E         
E       assert set() == {'pep0484_typing:instance Value()'}
E         Extra items in the right set:
E         'pep0484_typing:instance Value()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance Value()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:153] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:153 '        key'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdea0b4e0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:153 '        key'>
actual = set(), desired = {'pep0484_typing:instance Key()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:153 '        key'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance Key()'}
E         
E       assert set() == {'pep0484_typing:instance Key()'}
E         Extra items in the right set:
E         'pep0484_typing:instance Key()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance Key()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:156] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:156 '        key'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeb0dc88>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:156 '        key'>
actual = set(), desired = {'pep0484_typing:instance Key()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:156 '        key'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance Key()'}
E         
E       assert set() == {'pep0484_typing:instance Key()'}
E         Extra items in the right set:
E         'pep0484_typing:instance Key()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance Key()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:159] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:159 '        value'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde998828>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:159 '        value'>
actual = set(), desired = {'pep0484_typing:instance Value()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:159 '        value'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance Value()'}
E         
E       assert set() == {'pep0484_typing:instance Value()'}
E         Extra items in the right set:
E         'pep0484_typing:instance Value()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance Value()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:162] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:162 '        item[0]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdea6c208>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:162 '        item[0]'>
actual = set(), desired = {'pep0484_typing:instance Key()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:162 '        item[0]'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance Key()'}
E         
E       assert set() == {'pep0484_typing:instance Key()'}
E         Extra items in the right set:
E         'pep0484_typing:instance Key()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance Key()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:164] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:164 '        item[1]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeaf3668>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:164 '        item[1]'>
actual = set(), desired = {'pep0484_typing:instance Value()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:164 '        item[1]'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance Value()'}
E         
E       assert set() == {'pep0484_typing:instance Value()'}
E         Extra items in the right set:
E         'pep0484_typing:instance Value()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance Value()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:167] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:167 '        key'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeaddeb8>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:167 '        key'>
actual = set(), desired = {'pep0484_typing:instance Key()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:167 '        key'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance Key()'}
E         
E       assert set() == {'pep0484_typing:instance Key()'}
E         Extra items in the right set:
E         'pep0484_typing:instance Key()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance Key()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:169] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:169 '        value'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdea0e5c0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:169 '        value'>
actual = set(), desired = {'pep0484_typing:instance Value()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:169 '        value'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance Value()'}
E         
E       assert set() == {'pep0484_typing:instance Value()'}
E         Extra items in the right set:
E         'pep0484_typing:instance Value()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance Value()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:172] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:172 '        key'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdea29f98>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:172 '        key'>
actual = set(), desired = {'pep0484_typing:instance Key()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:172 '        key'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance Key()'}
E         
E       assert set() == {'pep0484_typing:instance Key()'}
E         Extra items in the right set:
E         'pep0484_typing:instance Key()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance Key()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:174] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:174 '        value'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde969748>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:174 '        value'>
actual = set(), desired = {'pep0484_typing:instance Value()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:174 '        value'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance Value()'}
E         
E       assert set() == {'pep0484_typing:instance Value()'}
E         Extra items in the right set:
E         'pep0484_typing:instance Value()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance Value()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:177] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:177 '        key'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdea29780>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:177 '        key'>
actual = set(), desired = {'pep0484_typing:instance Key()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:177 '        key'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance Key()'}
E         
E       assert set() == {'pep0484_typing:instance Key()'}
E         Extra items in the right set:
E         'pep0484_typing:instance Key()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance Key()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:180] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:180 '        value'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeafb198>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:180 '        value'>
actual = set(), desired = {'pep0484_typing:instance Value()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:180 '        value'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance Value()'}
E         
E       assert set() == {'pep0484_typing:instance Value()'}
E         Extra items in the right set:
E         'pep0484_typing:instance Value()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance Value()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:183] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:183 '        key'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde9496a0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:183 '        key'>
actual = set(), desired = {'pep0484_typing:instance Key()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:183 '        key'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance Key()'}
E         
E       assert set() == {'pep0484_typing:instance Key()'}
E         Extra items in the right set:
E         'pep0484_typing:instance Key()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance Key()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:185] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:185 '        value'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde924860>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:185 '        value'>
actual = set(), desired = {'pep0484_typing:instance Value()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:185 '        value'> failed.
E         actual  = set()
E         desired = {'pep0484_typing:instance Value()'}
E         
E       assert set() == {'pep0484_typing:instance Value()'}
E         Extra items in the right set:
E         'pep0484_typing:instance Value()'
E         Full diff:
E         - set()
E         + {'pep0484_typing:instance Value()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:196] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:196 '    p'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde9496a0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:196 '    p'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:196 '    p'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:198] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:198 '    q'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeaf66d8>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:198 '    q'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:198 '    q'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:200] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:200 '    r'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde949390>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:200 '    r'>
actual = set(), desired = {'builtins:instance int()', 'builtins:instance str()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:200 '    r'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()', 'builtins:instance str()'}
E         
E       assert set() == {'builtins:instance int()', 'builtins:instance str()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         'builtins:instance str()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()', 'builtins:instance str()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:202] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:202 '    s'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde938208>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:202 '    s'>
actual = set()
desired = {'builtins:instance dict()', 'builtins:instance float()', 'builtins:instance int()', 'builtins:instance str()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:202 '    s'> failed.
E         actual  = set()
E         desired = {'builtins:instance float()', 'builtins:instance int()', 'builtins:instance str()', 'builtins:instance dict()'}
E         
E       assert set() == {'builtins:instance dict()... 'builtins:instance str()'}
E         Extra items in the right set:
E         'builtins:instance float()'
E         'builtins:instance int()'
E         'builtins:instance str()'
E         'builtins:instance dict()'
E         Full diff:
E         - set()
E         + {'builtins:instance dict()',
E         +  'builtins:instance float()',
E         +  'builtins:instance int()',
E         +  'builtins:instance str()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:204] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:204 '    t'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde9bb710>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:204 '    t'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:204 '    t'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:214] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:214 '    p'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde9ad780>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:214 '    p'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:214 '    p'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:228] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:228 '    x.setd'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde8dde48>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:210: in run_completion
    return compare_cb(self, comp_str, set(literal_eval(self.correct)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:228 '    x.setd'>
actual = {'setdud'}, desired = {'setdefault', 'setdud'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:228 '    x.setd'> failed.
E         actual  = {'setdud'}
E         desired = {'setdefault', 'setdud'}
E         
E       assert {'setdud'} == {'setdefault', 'setdud'}
E         Extra items in the right set:
E         'setdefault'
E         Full diff:
E         - {'setdud'}
E         + {'setdefault', 'setdud'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:231] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:231 '        key'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeafb5f8>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:231 '        key'>
actual = set(), desired = {'builtins:instance str()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:231 '        key'> failed.
E         actual  = set()
E         desired = {'builtins:instance str()'}
E         
E       assert set() == {'builtins:instance str()'}
E         Extra items in the right set:
E         'builtins:instance str()'
E         Full diff:
E         - set()
E         + {'builtins:instance str()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:234] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:234 '        value'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde9bb940>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:234 '        value'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:234 '        value'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:238] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:238 'x.setd'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde8b98d0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:210: in run_completion
    return compare_cb(self, comp_str, set(literal_eval(self.correct)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:238 'x.setd'>
actual = {'setdud'}, desired = {'setdefault', 'setdud'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:238 'x.setd'> failed.
E         actual  = {'setdud'}
E         desired = {'setdefault', 'setdud'}
E         
E       assert {'setdud'} == {'setdefault', 'setdud'}
E         Extra items in the right set:
E         'setdefault'
E         Full diff:
E         - {'setdud'}
E         + {'setdefault', 'setdud'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:241] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:241 '    key'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde84e5c0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:241 '    key'>
actual = set(), desired = {'builtins:instance str()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:241 '    key'> failed.
E         actual  = set()
E         desired = {'builtins:instance str()'}
E         
E       assert set() == {'builtins:instance str()'}
E         Extra items in the right set:
E         'builtins:instance str()'
E         Full diff:
E         - set()
E         + {'builtins:instance str()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:244] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:244 '    value'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde948828>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:244 '    value'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:244 '    value'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:256] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:256 '    x.setd'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde91ac50>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:210: in run_completion
    return compare_cb(self, comp_str, set(literal_eval(self.correct)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:256 '    x.setd'>
actual = {'setdud'}, desired = {'setdefault', 'setdud'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:256 '    x.setd'> failed.
E         actual  = {'setdud'}
E         desired = {'setdefault', 'setdud'}
E         
E       assert {'setdud'} == {'setdefault', 'setdud'}
E         Extra items in the right set:
E         'setdefault'
E         Full diff:
E         - {'setdud'}
E         + {'setdefault', 'setdud'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:259] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:259 '        key'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde903518>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:259 '        key'>
actual = set(), desired = {'builtins:instance str()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:259 '        key'> failed.
E         actual  = set()
E         desired = {'builtins:instance str()'}
E         
E       assert set() == {'builtins:instance str()'}
E         Extra items in the right set:
E         'builtins:instance str()'
E         Full diff:
E         - set()
E         + {'builtins:instance str()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:262] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:262 '        value'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde903320>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:262 '        value'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:262 '        value'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:266] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:266 'x.setd'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde8f0ba8>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:210: in run_completion
    return compare_cb(self, comp_str, set(literal_eval(self.correct)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:266 'x.setd'>
actual = {'setdud'}, desired = {'setdefault', 'setdud'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:266 'x.setd'> failed.
E         actual  = {'setdud'}
E         desired = {'setdefault', 'setdud'}
E         
E       assert {'setdud'} == {'setdefault', 'setdud'}
E         Extra items in the right set:
E         'setdefault'
E         Full diff:
E         - {'setdud'}
E         + {'setdefault', 'setdud'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:269] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:269 '    key'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde88b668>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:269 '    key'>
actual = set(), desired = {'builtins:instance str()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:269 '    key'> failed.
E         actual  = set()
E         desired = {'builtins:instance str()'}
E         
E       assert set() == {'builtins:instance str()'}
E         Extra items in the right set:
E         'builtins:instance str()'
E         Full diff:
E         - set()
E         + {'builtins:instance str()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:272] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:272 '    value'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde89c748>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:272 '    value'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:272 '    value'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:283] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:283 '    x'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde88b978>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:283 '    x'>
actual = set(), desired = {'builtins:instance int()', 'builtins:instance str()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:283 '    x'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()', 'builtins:instance str()'}
E         
E       assert set() == {'builtins:instance int()', 'builtins:instance str()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         'builtins:instance str()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()', 'builtins:instance str()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:288] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:288 '    x'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde8cce80>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:288 '    x'>
actual = set(), desired = {'builtins:instance int()', 'builtins:instance str()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:288 '    x'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()', 'builtins:instance str()'}
E         
E       assert set() == {'builtins:instance int()', 'builtins:instance str()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         'builtins:instance str()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()', 'builtins:instance str()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_typing:293] ______________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:293 '    x'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde84e2b0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:293 '    x'>
actual = set(), desired = {'builtins:instance int()', 'builtins:instance str()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_typing.py:293 '    x'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()', 'builtins:instance str()'}
E         
E       assert set() == {'builtins:instance int()', 'builtins:instance str()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         'builtins:instance str()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()', 'builtins:instance str()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_comments:52] _____________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:52 'x[1]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdeff49b0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:52 'x[1]'>
actual = set(), desired = {'pep0484_comments:instance Employee()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:52 'x[1]'> failed.
E         actual  = set()
E         desired = {'pep0484_comments:instance Employee()'}
E         
E       assert set() == {'pep0484_comments:instance Employee()'}
E         Extra items in the right set:
E         'pep0484_comments:instance Employee()'
E         Full diff:
E         - set()
E         + {'pep0484_comments:instance Employee()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_comments:55] _____________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:55 'y[2]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdf0b04a8>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:55 'y[2]'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:55 'y[2]'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_comments:59] _____________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:59 '    zi'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdfce68d0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:59 '    zi'>
actual = set(), desired = {'pep0484_comments:instance BB()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:59 '    zi'> failed.
E         actual  = set()
E         desired = {'pep0484_comments:instance BB()'}
E         
E       assert set() == {'pep0484_comments:instance BB()'}
E         Extra items in the right set:
E         'pep0484_comments:instance BB()'
E         Full diff:
E         - set()
E         + {'pep0484_comments:instance BB()'}

../test/test_integration.py:16: AssertionError
_____________________ test_completion[pep0484_comments:67] _____________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:67 'x[1]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffdef394e0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:67 'x[1]'>
actual = {'builtins:instance int()'}, desired = {'builtins:instance str()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:67 'x[1]'> failed.
E         actual  = {'builtins:instance int()'}
E         desired = {'builtins:instance str()'}
E         
E       assert {'builtins:instance int()'} == {'builtins:instance str()'}
E         Extra items in the left set:
E         'builtins:instance int()'
E         Extra items in the right set:
E         'builtins:instance str()'
E         Full diff:
E         - {'builtins:instance int()'}
E         ?                     ^^
E         + {'builtins:instance str()'}
E         ?                     ^ +

../test/test_integration.py:16: AssertionError
____________________ test_completion[pep0484_comments:115] _____________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:115 '        friends[0][1]'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde801748>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:115 '        friends[0][1]'>
actual = set(), desired = {'pep0484_comments:instance Dog()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:115 '        friends[0][1]'> failed.
E         actual  = set()
E         desired = {'pep0484_comments:instance Dog()'}
E         
E       assert set() == {'pep0484_comments:instance Dog()'}
E         Extra items in the right set:
E         'pep0484_comments:instance Dog()'
E         Full diff:
E         - set()
E         + {'pep0484_comments:instance Dog()'}

../test/test_integration.py:16: AssertionError
____________________ test_completion[pep0484_comments:139] _____________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:139 'friend.bark()'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde9772e8>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:253: in run_goto_assignments
    return compare_cb(self, comp_str, self.correct)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:139 'friend.bark()'>
actual = '[]', desired = "['def bark']"

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:139 'friend.bark()'> failed.
E         actual  = []
E         desired = ['def bark']
E         
E       assert '[]' == "['def bark']"
E         - []
E         + ['def bark']

../test/test_integration.py:16: AssertionError
____________________ test_completion[pep0484_comments:143] _____________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:143 'friend.name'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde84a160>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:143 'friend.name'>
actual = set(), desired = {'builtins:instance str()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/pep0484_comments.py:143 'friend.name'> failed.
E         actual  = set()
E         desired = {'builtins:instance str()'}
E         
E       assert set() == {'builtins:instance str()'}
E         Extra items in the right set:
E         'builtins:instance str()'
E         Full diff:
E         - set()
E         + {'builtins:instance str()'}

../test/test_integration.py:16: AssertionError
_________________________ test_completion[keywords:20] _________________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/keywords.py:20 'c + brea'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde6ff1d0>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:210: in run_completion
    return compare_cb(self, comp_str, set(literal_eval(self.correct)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/keywords.py:20 'c + brea'>
actual = {'breakpoint'}, desired = set()

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/keywords.py:20 'c + brea'> failed.
E         actual  = {'breakpoint'}
E         desired = set()
E         
E       assert {'breakpoint'} == set()
E         Extra items in the left set:
E         'breakpoint'
E         Full diff:
E         - {'breakpoint'}
E         + set()

../test/test_integration.py:16: AssertionError
_________________________ test_completion[keywords:23] _________________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/keywords.py:23 'a + break'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde6f7550>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:210: in run_completion
    return compare_cb(self, comp_str, set(literal_eval(self.correct)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/keywords.py:23 'a + break'>
actual = {'breakpoint'}, desired = set()

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/keywords.py:23 'a + break'> failed.
E         actual  = {'breakpoint'}
E         desired = set()
E         
E       assert {'breakpoint'} == set()
E         Extra items in the left set:
E         'breakpoint'
E         Full diff:
E         - {'breakpoint'}
E         + set()

../test/test_integration.py:16: AssertionError
_________________________ test_completion[keywords:26] _________________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/keywords.py:26 'b; break'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde6fa780>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:210: in run_completion
    return compare_cb(self, comp_str, set(literal_eval(self.correct)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/keywords.py:26 'b; break'>
actual = {'break', 'breakpoint'}, desired = {'break'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/keywords.py:26 'b; break'> failed.
E         actual  = {'break', 'breakpoint'}
E         desired = {'break'}
E         
E       assert {'break', 'breakpoint'} == {'break'}
E         Extra items in the left set:
E         'breakpoint'
E         Full diff:
E         - {'break', 'breakpoint'}
E         + {'break'}

../test/test_integration.py:16: AssertionError
________________________ test_completion[docstring:197] ________________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/docstring.py:197 'd.upper()'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde6093c8>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/docstring.py:197 'd.upper()'>
actual = set(), desired = {'builtins:instance str()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/docstring.py:197 'd.upper()'> failed.
E         actual  = set()
E         desired = {'builtins:instance str()'}
E         
E       assert set() == {'builtins:instance str()'}
E         Extra items in the right set:
E         'builtins:instance str()'
E         Full diff:
E         - set()
E         + {'builtins:instance str()'}

../test/test_integration.py:16: AssertionError
__________________________ test_completion[types:47] ___________________________

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/types.py:47 'arr.count(1)'>
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7fffde217470>
environment = <Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>
has_typing = True

    def test_completion(case, monkeypatch, environment, has_typing):
        skip_reason = case.get_skip_reason(environment)
        if skip_reason is not None:
            pytest.skip(skip_reason)
    
        _CONTAINS_TYPING = ('pep0484_typing', 'pep0484_comments', 'pep0526_variables')
        if not has_typing and any(x in case.path for x in _CONTAINS_TYPING):
            pytest.skip('Needs the typing module installed to run this test.')
        repo_root = helpers.root_dir
        monkeypatch.chdir(os.path.join(repo_root, 'jedi'))
>       case.run(assert_case_equal, environment)

../test/test_integration.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../test/run.py:203: in run
    return testers[self.test_type](compare_cb, environment)
../test/run.py:248: in run_goto_definitions
    return compare_cb(self, is_str, should)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

case = <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/types.py:47 'arr.count(1)'>
actual = set(), desired = {'builtins:instance int()'}

    def assert_case_equal(case, actual, desired):
        """
        Assert ``actual == desired`` with formatted message.
    
        This is not needed for typical py.test use case, but as we need
        ``--assert=plain`` (see ../pytest.ini) to workaround some issue
        due to py.test magic, let's format the message by hand.
        """
>       assert actual == desired, """
    Test %r failed.
    actual  = %s
    desired = %s
    """ % (case, actual, desired)
E       AssertionError: 
E         Test <IntegrationTestCase: /tmp/guix-build-python-jedi-0.13.1.drv-0/jedi-0.13.1/test/completion/types.py:47 'arr.count(1)'> failed.
E         actual  = set()
E         desired = {'builtins:instance int()'}
E         
E       assert set() == {'builtins:instance int()'}
E         Extra items in the right set:
E         'builtins:instance int()'
E         Full diff:
E         - set()
E         + {'builtins:instance int()'}

../test/test_integration.py:16: AssertionError
______________________________ test_os_path_join _______________________________

Script = functools.partial(<class 'jedi.api.Script'>, environment=<Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>)
kwargs = {}, first = 1544300730.0048192, i = 3, single_time = 0.3591610789299011
message = 'speed issue <function test_os_path_join at 0x7ffff532b730>, 0.3591610789299011'
@py_assert1 = False, @py_format3 = '0.3591610789299011 < 0.3'
@py_format5 = 'speed issue <function test_os_path_join at 0x7ffff532b730>, 0.3591610789299011\n>assert 0.3591610789299011 < 0.3'

    @functools.wraps(func)
    def wrapper(Script, **kwargs):
        if run_warm:
            func(Script=Script, **kwargs)
        first = time.time()
        for i in range(number):
            func(Script=Script, **kwargs)
        single_time = (time.time() - first) / number
        message = 'speed issue %s, %s' % (func, single_time)
>       assert single_time < time_per_run, message
E       AssertionError: speed issue <function test_os_path_join at 0x7ffff532b730>, 0.3591610789299011
E       assert 0.3591610789299011 < 0.3

test/test_speed.py:28: AssertionError
___________________ TestCallSignatures.test_more_complicated ___________________

self = <test.test_api.test_call_signatures.TestCallSignatures testMethod=test_more_complicated>

    def test_more_complicated(self):
        run = self._run_simple
    
        s4 = 'abs(zip(), , set,'
        run(s4, None, column=3)
        run(s4, 'abs', 0, 4)
        run(s4, 'zip', 0, 8)
        run(s4, 'abs', 0, 9)
        run(s4, 'abs', None, 10)
    
        s5 = "sorted(1,\nif 2:\n def a():"
        run(s5, 'sorted', 0, 7)
        run(s5, 'sorted', 1, 9)
    
        s6 = "str().center("
        run(s6, 'center', 0)
        run(s6, 'str', 0, 4)
    
        s7 = "str().upper().center("
        s8 = "str(int[zip("
>       run(s7, 'center', 0)

test/test_api/test_call_signatures.py:78: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
test/test_api/test_call_signatures.py:36: in _run_simple
    assert_signature(self.Script, source, name, index, line, column)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

Script = functools.partial(<class 'jedi.api.Script'>, environment=<Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>)
source = 'str().upper().center(', expected_name = 'center', expected_index = 0
line = 1, column = None

    def assert_signature(Script, source, expected_name, expected_index=0, line=None, column=None):
        signatures = Script(source, line, column).call_signatures()
    
        assert len(signatures) <= 1
    
        if not signatures:
>           assert expected_name is None, \
                'There are no signatures, but `%s` expected.' % expected_name
E           AssertionError: There are no signatures, but `center` expected.
E           assert 'center' is None

test/test_api/test_call_signatures.py:18: AssertionError
_________________________________ test_simple __________________________________

evaluator = <jedi.evaluate.Evaluator object at 0x7fffdc4d8470>

    def test_simple(evaluator):
        obj = compiled.create_simple_object(evaluator, u'_str_')
        upper, = obj.py__getattribute__(u'upper')
        objs = list(upper.execute_evaluated())
>       assert len(objs) == 1
E       assert 0 == 1
E        +  where 0 = len([])

test/test_evaluate/test_compiled.py:11: AssertionError
_______________________ test_namedtuple_str[n-expected0] _______________________

letter = 'n', expected = ['name']
Script = functools.partial(<class 'jedi.api.Script'>, environment=<Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>)

    @pytest.mark.parametrize(['letter', 'expected'], [
        ('n', ['name']),
        ('s', ['smart']),
    ])
    def test_namedtuple_str(letter, expected, Script):
        source = dedent("""\
            import collections
            Person = collections.namedtuple('Person', 'name smart')
            dave = Person('Dave', False)
            dave.%s""") % letter
        result = Script(source).completions()
        completions = set(r.name for r in result)
>       assert completions == set(expected)
E       AssertionError: assert set() == {'name'}
E         Extra items in the right set:
E         'name'
E         Full diff:
E         - set()
E         + {'name'}

test/test_evaluate/test_stdlib.py:30: AssertionError
_______________________ test_namedtuple_str[s-expected1] _______________________

letter = 's', expected = ['smart']
Script = functools.partial(<class 'jedi.api.Script'>, environment=<Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>)

    @pytest.mark.parametrize(['letter', 'expected'], [
        ('n', ['name']),
        ('s', ['smart']),
    ])
    def test_namedtuple_str(letter, expected, Script):
        source = dedent("""\
            import collections
            Person = collections.namedtuple('Person', 'name smart')
            dave = Person('Dave', False)
            dave.%s""") % letter
        result = Script(source).completions()
        completions = set(r.name for r in result)
>       assert completions == set(expected)
E       AssertionError: assert set() == {'smart'}
E         Extra items in the right set:
E         'smart'
E         Full diff:
E         - set()
E         + {'smart'}

test/test_evaluate/test_stdlib.py:30: AssertionError
_____________________________ test_namedtuple_list _____________________________

Script = functools.partial(<class 'jedi.api.Script'>, environment=<Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>)

    def test_namedtuple_list(Script):
        source = dedent("""\
            import collections
            Cat = collections.namedtuple('Person', ['legs', u'length', 'large'])
            garfield = Cat(4, '85cm', True)
            garfield.l""")
        result = Script(source).completions()
        completions = set(r.name for r in result)
>       assert completions == {'legs', 'length', 'large'}
E       AssertionError: assert set() == {'large', 'legs', 'length'}
E         Extra items in the right set:
E         'length'
E         'large'
E         'legs'
E         Full diff:
E         - set()
E         + {'length', 'large', 'legs'}

test/test_evaluate/test_stdlib.py:41: AssertionError
___________________________ test_namedtuple_content ____________________________

Script = functools.partial(<class 'jedi.api.Script'>, environment=<Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>)

    def test_namedtuple_content(Script):
        source = dedent("""\
            import collections
            Foo = collections.namedtuple('Foo', ['bar', 'baz'])
            named = Foo(baz=4, bar=3.0)
            unnamed = Foo(4, '')
            """)
    
        def d(source):
            x, = Script(source).goto_definitions()
            return x.name
    
>       assert d(source + 'unnamed.bar') == 'int'

test/test_evaluate/test_stdlib.py:56: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

source = "import collections\nFoo = collections.namedtuple('Foo', ['bar', 'baz'])\nnamed = Foo(baz=4, bar=3.0)\nunnamed = Foo(4, '')\nunnamed.bar"

    def d(source):
>       x, = Script(source).goto_definitions()
E       ValueError: not enough values to unpack (expected 1, got 0)

test/test_evaluate/test_stdlib.py:53: ValueError
___________________________ test_nested_namedtuples ____________________________

Script = functools.partial(<class 'jedi.api.Script'>, environment=<Environment: 3.7.0 in /gnu/store/b7fqhszxl02g6pfm3vw6b3cjz472qrly-python-3.7.0>)

    def test_nested_namedtuples(Script):
        """
        From issue #730.
        """
        s = Script(dedent('''
            import collections
            Dataset = collections.namedtuple('Dataset', ['data'])
            Datasets = collections.namedtuple('Datasets', ['train'])
            train_x = Datasets(train=Dataset('data_value'))
            train_x.train.'''
        ))
>       assert 'data' in [c.name for c in s.completions()]
E       AssertionError: assert 'data' in []

test/test_evaluate/test_stdlib.py:73: AssertionError
_______________________ test_namedtuple_goto_definitions _______________________

Script = <class 'jedi.api.Script'>

    def test_namedtuple_goto_definitions(Script):
        source = dedent("""
            from collections import namedtuple

[Apteryks]

A more condensed report of the failures:

    494:test/test_integration.py::test_completion[pep0526_variables:21] FAILED   [ 27%]
    542:test/test_integration.py::test_completion[arrays:163] FAILED             [ 30%]
    545:test/test_integration.py::test_completion[arrays:174] FAILED             [ 30%]
   1003:test/test_integration.py::test_completion[pep0484_typing:19] FAILED      [ 56%]
   1004:test/test_integration.py::test_completion[pep0484_typing:21] FAILED      [ 56%]
   1005:test/test_integration.py::test_completion[pep0484_typing:23] FAILED      [ 57%]
   1006:test/test_integration.py::test_completion[pep0484_typing:25] FAILED      [ 57%]
   1007:test/test_integration.py::test_completion[pep0484_typing:27] FAILED      [ 57%]
   1008:test/test_integration.py::test_completion[pep0484_typing:29] FAILED      [ 57%]
   1009:test/test_integration.py::test_completion[pep0484_typing:31] FAILED      [ 57%]
   1010:test/test_integration.py::test_completion[pep0484_typing:33] FAILED      [ 57%]
   1012:test/test_integration.py::test_completion[pep0484_typing:37] FAILED      [ 57%]
   1013:test/test_integration.py::test_completion[pep0484_typing:39] FAILED      [ 57%]
   1014:test/test_integration.py::test_completion[pep0484_typing:41] FAILED      [ 57%]
   1015:test/test_integration.py::test_completion[pep0484_typing:43] FAILED      [ 57%]
   1016:test/test_integration.py::test_completion[pep0484_typing:54] FAILED      [ 57%]
   1018:test/test_integration.py::test_completion[pep0484_typing:59] FAILED      [ 57%]
   1020:test/test_integration.py::test_completion[pep0484_typing:69] FAILED      [ 57%]
   1021:test/test_integration.py::test_completion[pep0484_typing:71] FAILED      [ 57%]
   1022:test/test_integration.py::test_completion[pep0484_typing:74] FAILED      [ 57%]
   1024:test/test_integration.py::test_completion[pep0484_typing:79] FAILED      [ 58%]
   1026:test/test_integration.py::test_completion[pep0484_typing:89] FAILED      [ 58%]
   1027:test/test_integration.py::test_completion[pep0484_typing:98] FAILED      [ 58%]
   1028:test/test_integration.py::test_completion[pep0484_typing:100] FAILED     [ 58%]
   1029:test/test_integration.py::test_completion[pep0484_typing:102] FAILED     [ 58%]
   1030:test/test_integration.py::test_completion[pep0484_typing:104] FAILED     [ 58%]
   1031:test/test_integration.py::test_completion[pep0484_typing:106] FAILED     [ 58%]
   1032:test/test_integration.py::test_completion[pep0484_typing:108] FAILED     [ 58%]
   1033:test/test_integration.py::test_completion[pep0484_typing:110] FAILED     [ 58%]
   1034:test/test_integration.py::test_completion[pep0484_typing:112] FAILED     [ 58%]
   1035:test/test_integration.py::test_completion[pep0484_typing:115] FAILED     [ 58%]
   1039:test/test_integration.py::test_completion[pep0484_typing:144] FAILED     [ 58%]
   1040:test/test_integration.py::test_completion[pep0484_typing:146] FAILED     [ 59%]
   1041:test/test_integration.py::test_completion[pep0484_typing:148] FAILED     [ 59%]
   1042:test/test_integration.py::test_completion[pep0484_typing:150] FAILED     [ 59%]
   1043:test/test_integration.py::test_completion[pep0484_typing:153] FAILED     [ 59%]
   1044:test/test_integration.py::test_completion[pep0484_typing:156] FAILED     [ 59%]
   1045:test/test_integration.py::test_completion[pep0484_typing:159] FAILED     [ 59%]
   1046:test/test_integration.py::test_completion[pep0484_typing:162] FAILED     [ 59%]
   1047:test/test_integration.py::test_completion[pep0484_typing:164] FAILED     [ 59%]
   1048:test/test_integration.py::test_completion[pep0484_typing:167] FAILED     [ 59%]
   1049:test/test_integration.py::test_completion[pep0484_typing:169] FAILED     [ 59%]
   1050:test/test_integration.py::test_completion[pep0484_typing:172] FAILED     [ 59%]
   1051:test/test_integration.py::test_completion[pep0484_typing:174] FAILED     [ 59%]
   1052:test/test_integration.py::test_completion[pep0484_typing:177] FAILED     [ 59%]
   1053:test/test_integration.py::test_completion[pep0484_typing:180] FAILED     [ 59%]
   1054:test/test_integration.py::test_completion[pep0484_typing:183] FAILED     [ 59%]
   1055:test/test_integration.py::test_completion[pep0484_typing:185] FAILED     [ 59%]
   1056:test/test_integration.py::test_completion[pep0484_typing:196] FAILED     [ 59%]
   1057:test/test_integration.py::test_completion[pep0484_typing:198] FAILED     [ 60%]
   1058:test/test_integration.py::test_completion[pep0484_typing:200] FAILED     [ 60%]
   1059:test/test_integration.py::test_completion[pep0484_typing:202] FAILED     [ 60%]
   1060:test/test_integration.py::test_completion[pep0484_typing:204] FAILED     [ 60%]
   1061:test/test_integration.py::test_completion[pep0484_typing:214] FAILED     [ 60%]
   1062:test/test_integration.py::test_completion[pep0484_typing:228] FAILED     [ 60%]
   1063:test/test_integration.py::test_completion[pep0484_typing:231] FAILED     [ 60%]
   1064:test/test_integration.py::test_completion[pep0484_typing:234] FAILED     [ 60%]
   1065:test/test_integration.py::test_completion[pep0484_typing:238] FAILED     [ 60%]
   1066:test/test_integration.py::test_completion[pep0484_typing:241] FAILED     [ 60%]
   1067:test/test_integration.py::test_completion[pep0484_typing:244] FAILED     [ 60%]
   1068:test/test_integration.py::test_completion[pep0484_typing:256] FAILED     [ 60%]
   1069:test/test_integration.py::test_completion[pep0484_typing:259] FAILED     [ 60%]
   1070:test/test_integration.py::test_completion[pep0484_typing:262] FAILED     [ 60%]
   1071:test/test_integration.py::test_completion[pep0484_typing:266] FAILED     [ 60%]
   1072:test/test_integration.py::test_completion[pep0484_typing:269] FAILED     [ 60%]
   1073:test/test_integration.py::test_completion[pep0484_typing:272] FAILED     [ 60%]
   1074:test/test_integration.py::test_completion[pep0484_typing:283] FAILED     [ 60%]
   1075:test/test_integration.py::test_completion[pep0484_typing:288] FAILED     [ 61%]
   1076:test/test_integration.py::test_completion[pep0484_typing:293] FAILED     [ 61%]
   1144:test/test_integration.py::test_completion[pep0484_comments:52] FAILED    [ 64%]
   1145:test/test_integration.py::test_completion[pep0484_comments:55] FAILED    [ 65%]
   1146:test/test_integration.py::test_completion[pep0484_comments:59] FAILED    [ 65%]
   1147:test/test_integration.py::test_completion[pep0484_comments:67] FAILED    [ 65%]
   1157:test/test_integration.py::test_completion[pep0484_comments:115] FAILED   [ 65%]
   1160:test/test_integration.py::test_completion[pep0484_comments:139] FAILED   [ 65%]
   1161:test/test_integration.py::test_completion[pep0484_comments:143] FAILED   [ 65%]
   1227:test/test_integration.py::test_completion[keywords:20] FAILED            [ 69%]
   1228:test/test_integration.py::test_completion[keywords:23] FAILED            [ 69%]
   1229:test/test_integration.py::test_completion[keywords:26] FAILED            [ 69%]
   1271:test/test_integration.py::test_completion[docstring:197] FAILED          [ 72%]
   1374:test/test_integration.py::test_completion[types:47] FAILED               [ 78%]
   1431:test/test_speed.py::test_os_path_join FAILED                             [ 81%]
   1471:test/test_api/test_call_signatures.py::TestCallSignatures::test_more_complicated FAILED [ 83%]
   1627:test/test_evaluate/test_compiled.py::test_simple FAILED                  [ 92%]
   1730:test/test_evaluate/test_stdlib.py::test_namedtuple_str[n-expected0] FAILED [ 98%]
   1731:test/test_evaluate/test_stdlib.py::test_namedtuple_str[s-expected1] FAILED [ 98%]
   1732:test/test_evaluate/test_stdlib.py::test_namedtuple_list FAILED           [ 98%]
   1733:test/test_evaluate/test_stdlib.py::test_namedtuple_content FAILED        [ 98%]
   1734:test/test_evaluate/test_stdlib.py::test_nested_namedtuples FAILED        [ 98%]
   1735:test/test_evaluate/test_stdlib.py::test_namedtuple_goto_definitions FAILED [ 98%]

[davidhalter]

Tests have never passed for 3.7. Some things have changed (namely the removal of function signatures from docstrings for some functions).

Now the tests are passing in the typeshed branch. Please check it out. It's going to be merged to master soon anyway.

[ncopa]

This issue was closed but the 0.13.3 release still fails. Should I open a new issue or should we reopen this?

I think it should be kept open til typeshed branch is merged and issue fixed.

[davidhalter]

If master is failing, please open a new issue.

Typeshed is failing at the moment, but that's a different problem.

[Apteryks]

@davidhalter I'm not sure I understand; tests are failing on master, yes, but only if using Python 3.7. Do we want an issue for this until the typeshed branch gets merged in?

======== 89 failed, 1652 passed, 31 skipped, 4 xfailed, 162 warnings in 44.50 seconds ========

on master, v0.13.3-28-gb2f6758a

[davidhalter]

Tests are passing now, I merged the typeshed branch (or rather the ts2 branch). It's been quite some work (512 commits, 152 files changed, 6543 insertions(+), 3502 deletions(-)).

There's still some work to do to get travis to work with Python 3.7, but that's for another day, on my local machine, 3.7 is passing.