def _multiprocessing_transform():
    module = astroid.parse('''
    from multiprocessing.managers import SyncManager
    def Manager():
        return SyncManager()
    ''')
    if not PY34:
        return module

    # On Python 3.4, multiprocessing uses a getattr lookup inside contexts,
    # in order to get the attributes they need. Since it's extremely
    # dynamic, we use this approach to fake it.
    node = astroid.parse('''
    from multiprocessing.context import DefaultContext, BaseContext
    default = DefaultContext()
    base = BaseContext()
    ''')
    try:
        context = next(node['default'].infer())
        base = next(node['base'].infer())
    except exceptions.InferenceError:
        return module

    for node in (context, base):
        for key, value in node.locals.items():
            if key.startswith("_"):
                continue

            value = value[0]
            if isinstance(value, astroid.FunctionDef):
                # We need to rebound this, since otherwise
                # it will have an extra argument (self).
                value = astroid.BoundMethod(value, node)
            module[key] = value
    return module

 def test_absolute_import(self):
     module_import = astroid.parse(
         'from __future__ import absolute_import; import os')
     module_from = astroid.parse(
         'from __future__ import absolute_import; from os import path')
     with self.assertNoMessages():
         for module in (module_import, module_from):
             self.walk(module)

    def test_raise_python_2(self):
        first = 'raise'
        self.assertEqual(parse(first).as_string().strip(), first)

        second = 'raise 1, 2'
        self.assertEqual(parse(second).as_string().strip(), second)

        third = 'raise 1, 2, 3'
        self.assertEqual(parse(third).as_string().strip(), third)

 def test_modules_as_string(self):
     for name in (os.path.join(p, n) for p, _, ns in os.walk('astroid/') for n in ns if n.endswith('.py')):
         with open(name, 'r') as source_file:
             ast = parse(source_file.read())
             # if ast != parse(ast.as_string()):
             #     print(name)
             #     print(ast == ast)
             #     ast.print_tree()
             #     parse(ast.as_string()).print_tree()
             self.assertEqual(ast, parse(ast.as_string()))

    def test_module_level_names(self):
        assign = astroid.extract_node("""
        import collections
        Class = collections.namedtuple("a", ("b", "c")) #@
        """)
        with self.assertNoMessages():
            self.checker.visit_assignname(assign.targets[0])

        assign = astroid.extract_node("""
        class ClassA(object):
            pass
        ClassB = ClassA
        """)
        with self.assertNoMessages():
            self.checker.visit_assignname(assign.targets[0])

        module = astroid.parse("""
        def A():
          return 1, 2, 3
        CONSTA, CONSTB, CONSTC = A()
        CONSTD = A()""")
        with self.assertNoMessages():
            self.checker.visit_assignname(module.body[1].targets[0].elts[0])
            self.checker.visit_assignname(module.body[2].targets[0])

        assign = astroid.extract_node("""
        CONST = "12 34 ".rstrip().split()""")
        with self.assertNoMessages():
            self.checker.visit_assignname(assign.targets[0])

def _hashlib_transform():
    template = '''
    class %(name)s(object):
      def __init__(self, value=''): pass
      def digest(self):
        return %(digest)s
      def copy(self):
        return self
      def update(self, value): pass
      def hexdigest(self):
        return ''
      @property
      def name(self):
        return %(name)r
      @property
      def block_size(self):
        return 1
      @property
      def digest_size(self):
        return 1
    '''
    algorithms = ('md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512')
    classes = "".join(
        template % {'name': hashfunc, 'digest': 'b""' if six.PY3 else '""'}
        for hashfunc in algorithms)
    return astroid.parse(classes)

    def test_invalid_metaclass(self):
        module = astroid.parse(
            """
        import six

        class InvalidAsMetaclass(object):
            pass

        @six.add_metaclass(int)
        class FirstInvalid(object):
            pass

        @six.add_metaclass(InvalidAsMetaclass)
        class SecondInvalid(object):
            pass

        @six.add_metaclass(2)
        class ThirdInvalid(object):
            pass
        """
        )
        for class_obj, metaclass_name in (
            ("ThirdInvalid", "2"),
            ("SecondInvalid", "InvalidAsMetaclass"),
            ("FirstInvalid", "int"),
        ):
            classdef = module[class_obj]
            message = Message(
                "invalid-metaclass", node=classdef, args=(metaclass_name,)
            )
            with self.assertAddsMessages(message):
                self.checker.visit_classdef(classdef)

def numpy_core_numerictypes_transform():
    return astroid.parse('''
    # different types defined in numerictypes.py
    uint16 = type('uint16') 
    uint32 = type('uint32')
    uint64 = type('uint64')
    int128 = type('int128')
    uint128 = type('uint128')
    float16 = type('float16')
    float32 = type('float32')
    float64 = type('float64')
    float80 = type('float80')
    float96 = type('float96')
    float128 = type('float128')
    float256 = type('float256')
    complex32 = type('complex32')
    complex64 = type('complex64')
    complex128 = type('complex128')
    complex160 = type('complex160')
    complex192 = type('complex192')
    complex256 = type('complex256')
    complex512 = type('complex512')
    timedelta64 = type('timedelta64')
    datetime64 = type('datetime64')
    unicode_ = type('unicode_')
    string_ = type('string_')
    object_ = type('object_')
    ''')

    def test_invalid_metaclass(self):
        module = astroid.parse('''
        import six

        class InvalidAsMetaclass(object):
            pass

        @six.add_metaclass(int)
        class FirstInvalid(object):
            pass

        @six.add_metaclass(InvalidAsMetaclass)
        class SecondInvalid(object):
            pass

        @six.add_metaclass(2)
        class ThirdInvalid(object):
            pass
        ''')
        for class_obj, metaclass_name in (('ThirdInvalid', '2'),
                                          ('SecondInvalid', 'InvalidAsMetaclass'),
                                          ('FirstInvalid', 'int')):
            classdef = module[class_obj]
            message = Message('invalid-metaclass', node=classdef, args=(metaclass_name, ))
            with self.assertAddsMessages(message):
                self.checker.visit_classdef(classdef)

 def test_ignored_argument_names_starred_args(self):
     node = astroid.parse('''
     def fooby(*args, **kwargs):
         pass
     ''')
     with self.assertNoMessages():
         self.walk(node)

    def test_deprecated_methods(self):
        class Checker(object):
            def __init__(self):
                self.called = False

            @check_messages('first-message')
            def visit_assname(self, node):
                self.called = True

        linter = self.MockLinter({'first-message': True})
        walker = utils.PyLintASTWalker(linter)
        checker = Checker()
        walker.add_checker(checker)
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter('always')
            walker.walk(astroid.parse("x = 1"))

        if __pkginfo__.numversion < (2, 0):
            expected = ('Implemented method visit_assname instead of '
                        'visit_assignname. This will be supported until '
                        'Pylint 2.0.')
            self.assertEqual(len(w), 1)
            self.assertIsInstance(w[0].message, PendingDeprecationWarning)
            self.assertEqual(str(w[0].message), expected)
            self.assertTrue(checker.called)
        else:
            self.assertNotEqual(len(w), 1)
            self.assertFalse(checker.called)

def _collections_transform():
    return astroid.parse('''
    class defaultdict(dict):
        default_factory = None
        def __missing__(self, key): pass

    class deque(object):
        maxlen = 0
        def __init__(self, iterable=None, maxlen=None):
            self.iterable = iterable
        def append(self, x): pass
        def appendleft(self, x): pass
        def clear(self): pass
        def count(self, x): return 0
        def extend(self, iterable): pass
        def extendleft(self, iterable): pass
        def pop(self): pass
        def popleft(self): pass
        def remove(self, value): pass
        def reverse(self): pass
        def rotate(self, n): pass
        def __iter__(self): return self
        def __reversed__(self): return self.iterable[::-1]
        def __getitem__(self, index): pass
        def __setitem__(self, index, value): pass
        def __delitem__(self, index): pass
    ''')

 def test_check_messages(self):
     linter = self.MockLinter({"first-message": True, "second-message": False, "third-message": True})
     walker = utils.PyLintASTWalker(linter)
     checker = self.Checker()
     walker.add_checker(checker)
     walker.walk(astroid.parse("x = func()"))
     self.assertEqual(set(["module", "assname"]), checker.called)

 def test_func_signature_issue_185(self):
     code = textwrap.dedent('''
     def test(a, b, c=42, *, x=42, **kwargs):
         print(a, b, c, args)
     ''')
     node = parse(code)
     self.assertEqual(node.as_string().strip(), code.strip())

 def test_priority_to_local_defined_values(self):
     ast_node = astroid.parse('''
     __file__ = "mine"
     ''')
     file_value = next(ast_node.igetattr('__file__'))
     self.assertIsInstance(file_value, astroid.Const)
     self.assertEqual(file_value.value, "mine")

    def test_dict_methods_in_iterating_context(self):
        iterating_code = [
            'for x in {}: pass',
            '(x for x in {})',
            '[x for x in {}]',
            'func({})',
            'a, b = {}'
        ]
        non_iterating_code = [
            'x = __({}())',
            '__({}())[0]'
        ]

        for method in ('keys', 'items', 'values'):
            dict_method = '{{}}.{}'.format(method)

            for code in iterating_code:
                with_value = code.format(dict_method)
                module = astroid.parse(with_value)
                with self.assertNoMessages():
                    self.walk(module)

            for code in non_iterating_code:
                with_value = code.format(dict_method)
                node = astroid.extract_node(with_value)

                checker = 'dict-{}-not-iterating'.format(method)
                message = testutils.Message(checker, node=node)
                with self.assertAddsMessages(message):
                    self.checker.visit_call(node)

 def test_redefined_builtin_modname_not_ignored(self):
     node = astroid.parse('''
     from future.builtins import open
     ''')
     with self.assertAddsMessages(
             Message('redefined-builtin', node=node.body[0], args='open')):
         self.checker.visit_module(node)

 def test_dont_crash_on_invalid_format_string(self):
     node = astroid.parse(
         """
     import logging
     logging.error('0} - {1}'.format(1, 2))
     """
     )
     self.walk(node)

def _collections_transform():
    return astroid.parse('''
    class defaultdict(dict):
        default_factory = None
        def __missing__(self, key): pass
        def __getitem__(self, key): return default_factory

    ''' + _deque_mock() + _ordered_dict_mock())

 def test_redefined_builtin_custom_modules(self):
     node = astroid.parse(
         """
     from os import open
     """
     )
     with self.assertNoMessages():
         self.checker.visit_module(node)