Stopped installing tests with package

1063 files changed, 34459 insertions, 0 deletions

diff --git a/tests/acceptance/test_stdlib.py b/tests/acceptance/test_stdlib.py
new file mode 100644
index 000000000..1b97fd2ea
--- /dev/null
+++ b/tests/acceptance/test_stdlib.py
@@ -0,0 +1,54 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+import contextlib
+import io
+import os
+import sys
+
+import pytest
+
+import pylint.lint
+
+
+def is_module(filename):
+    return filename.endswith(".py")
+
+
+def is_package(filename, location):
+    return os.path.exists(os.path.join(location, filename, "__init__.py"))
+
+
+@contextlib.contextmanager
+def _patch_stdout(out):
+    sys.stdout = out
+    try:
+        yield
+    finally:
+        sys.stdout = sys.__stdout__
+
+
+LIB_DIRS = [os.path.dirname(os.__file__)]
+MODULES_TO_CHECK = [
+    (location, module)
+    for location in LIB_DIRS
+    for module in os.listdir(location)
+    if is_module(module) or is_package(module, location)
+]
+MODULES_NAMES = [m[1] for m in MODULES_TO_CHECK]
+
+
+@pytest.mark.acceptance
+@pytest.mark.parametrize(
+    ("test_module_location", "test_module_name"), MODULES_TO_CHECK, ids=MODULES_NAMES
+)
+def test_libmodule(test_module_location, test_module_name):
+    os.chdir(test_module_location)
+    with _patch_stdout(io.StringIO()):
+        try:
+            pylint.lint.Run([test_module_name, "--enable=all", "--ignore=test"])
+        except SystemExit as ex:
+            assert ex.code != 32
+            return
+
+        assert False, "shouldn't get there"
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 000000000..e2762091d
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,53 @@
+# pylint: disable=redefined-outer-name
+# pylint: disable=no-name-in-module
+import os
+
+import pytest
+
+from pylint import checkers
+from pylint.lint import PyLinter
+from pylint.testutils import MinimalTestReporter
+
+
+@pytest.fixture
+def linter(checker, register, enable, disable, reporter):
+    _linter = PyLinter()
+    _linter.set_reporter(reporter())
+    checkers.initialize(_linter)
+    if register:
+        register(_linter)
+    if checker:
+        _linter.register_checker(checker(_linter))
+    if disable:
+        for msg in disable:
+            _linter.disable(msg)
+    if enable:
+        for msg in enable:
+            _linter.enable(msg)
+    os.environ.pop("PYLINTRC", None)
+    return _linter
+
+
+@pytest.fixture(scope="module")
+def checker():
+    return None
+
+
+@pytest.fixture(scope="module")
+def register():
+    return None
+
+
+@pytest.fixture(scope="module")
+def enable():
+    return None
+
+
+@pytest.fixture(scope="module")
+def disable():
+    return None
+
+
+@pytest.fixture(scope="module")
+def reporter():
+    return MinimalTestReporter
diff --git a/tests/data/__init__.py b/tests/data/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/data/__init__.py
diff --git a/tests/data/ascript b/tests/data/ascript
new file mode 100755
index 000000000..f401ebc4b
--- /dev/null
+++ b/tests/data/ascript
@@ -0,0 +1,2 @@
+#!/usr/bin/python
+"""ttttttttttttttttttttoooooooooooooooooooooooooooooooooooooooooooooooooooooo lllllllllllooooooooooooooooooooooooooooonnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnngggggggggggggggggg"""
diff --git a/tests/data/classes_No_Name.dot b/tests/data/classes_No_Name.dot
new file mode 100644
index 000000000..8867b4e41
--- /dev/null
+++ b/tests/data/classes_No_Name.dot
@@ -0,0 +1,12 @@
+digraph "classes_No_Name" {
+charset="utf-8"
+rankdir=BT
+"0" [label="{Ancestor|attr : str\lcls_member\l|get_value()\lset_value(value)\l}", shape="record"];
+"1" [label="{DoNothing|\l|}", shape="record"];
+"2" [label="{Interface|\l|get_value()\lset_value(value)\l}", shape="record"];
+"3" [label="{Specialization|TYPE : str\lrelation\ltop : str\l|}", shape="record"];
+"3" -> "0" [arrowhead="empty", arrowtail="none"];
+"0" -> "2" [arrowhead="empty", arrowtail="node", style="dashed"];
+"1" -> "0" [arrowhead="diamond", arrowtail="none", fontcolor="green", label="cls_member", style="solid"];
+"1" -> "3" [arrowhead="diamond", arrowtail="none", fontcolor="green", label="relation", style="solid"];
+}
diff --git a/tests/data/clientmodule_test.py b/tests/data/clientmodule_test.py
new file mode 100644
index 000000000..40db2e77e
--- /dev/null
+++ b/tests/data/clientmodule_test.py
@@ -0,0 +1,29 @@
+""" docstring for file clientmodule.py """
+from data.suppliermodule_test import Interface, DoNothing
+
+class Ancestor:
+    """ Ancestor method """
+    __implements__ = (Interface,)
+    cls_member = DoNothing()
+
+    def __init__(self, value):
+        local_variable = 0
+        self.attr = 'this method shouldn\'t have a docstring'
+        self.__value = value
+
+    def get_value(self):
+        """ nice docstring ;-) """
+        return self.__value
+
+    def set_value(self, value):
+        self.__value = value
+        return 'this method shouldn\'t have a docstring'
+
+class Specialization(Ancestor):
+    TYPE = 'final class'
+    top = 'class'
+
+    def __init__(self, value, _id):
+        Ancestor.__init__(self, value)
+        self._id = _id
+        self.relation = DoNothing()
diff --git a/tests/data/packages_No_Name.dot b/tests/data/packages_No_Name.dot
new file mode 100644
index 000000000..1ceeb7242
--- /dev/null
+++ b/tests/data/packages_No_Name.dot
@@ -0,0 +1,8 @@
+digraph "packages_No_Name" {
+charset="utf-8"
+rankdir=BT
+"0" [label="data", shape="box"];
+"1" [label="data.clientmodule_test", shape="box"];
+"2" [label="data.suppliermodule_test", shape="box"];
+"1" -> "2" [arrowhead="open", arrowtail="none"];
+}
diff --git a/tests/data/suppliermodule_test.py b/tests/data/suppliermodule_test.py
new file mode 100644
index 000000000..24dc9a02f
--- /dev/null
+++ b/tests/data/suppliermodule_test.py
@@ -0,0 +1,10 @@
+""" file suppliermodule.py """
+
+class Interface:
+    def get_value(self):
+        raise NotImplementedError
+
+    def set_value(self, value):
+        raise NotImplementedError
+
+class DoNothing: pass
diff --git a/tests/extensions/__init__.py b/tests/extensions/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/extensions/__init__.py
diff --git a/tests/extensions/data/bad_builtin.py b/tests/extensions/data/bad_builtin.py
new file mode 100644
index 000000000..fd3e5c054
--- /dev/null
+++ b/tests/extensions/data/bad_builtin.py
@@ -0,0 +1,4 @@
+# pylint: disable=missing-docstring
+
+TEST = map(str, (1, 2, 3)) # [bad-builtin]
+TEST1 = filter(str, (1, 2, 3)) # [bad-builtin]
diff --git a/tests/extensions/data/broad_try_clause.py b/tests/extensions/data/broad_try_clause.py
new file mode 100644
index 000000000..4d65302c8
--- /dev/null
+++ b/tests/extensions/data/broad_try_clause.py
@@ -0,0 +1,14 @@
+# pylint: disable=missing-docstring, invalid-name
+
+MY_DICTIONARY = {"key_one": 1, "key_two": 2, "key_three": 3}
+
+try:  # [max-try-statements]
+    value = MY_DICTIONARY["key_one"]
+    value += 1
+except KeyError:
+    pass
+
+try:
+    value = MY_DICTIONARY["key_one"]
+except KeyError:
+    value = 0
diff --git a/tests/extensions/data/compare_to_zero.py b/tests/extensions/data/compare_to_zero.py
new file mode 100644
index 000000000..dfe6bbcb5
--- /dev/null
+++ b/tests/extensions/data/compare_to_zero.py
@@ -0,0 +1,28 @@
+# pylint: disable=literal-comparison,missing-docstring,misplaced-comparison-constant
+
+X = 123
+Y = len('test')
+
+if X is 0:  # [compare-to-zero]
+    pass
+
+if Y is not 0:  # [compare-to-zero]
+    pass
+
+if X == 0:  # [compare-to-zero]
+    pass
+
+if Y != 0:  # [compare-to-zero]
+    pass
+
+if X > 0:
+    pass
+
+if X < 0:
+    pass
+
+if 0 < X:
+    pass
+
+if 0 > X:
+    pass
diff --git a/tests/extensions/data/docstring.py b/tests/extensions/data/docstring.py
new file mode 100644
index 000000000..8f34c657f
--- /dev/null
+++ b/tests/extensions/data/docstring.py
@@ -0,0 +1,40 @@
+"""Checks of Dosctrings 'docstring-first-line-empty' 'bad-docstring-quotes'"""
+
+
+def check_messages(*messages):
+    """
+    docstring"""
+    return messages
+
+def function2():
+    """Test Ok"""
+
+class FFFF:
+    """
+    Test Docstring First Line Empty
+    """
+
+    def method1(self):
+        '''
+        Test Triple Single Quotes docstring
+        '''
+
+    def method2(self):
+        "bad docstring 1"
+
+    def method3(self):
+        'bad docstring 2'
+
+    def method4(self):
+        ' """bad docstring 3 '
+
+    @check_messages('bad-open-mode', 'redundant-unittest-assert',
+                    'deprecated-module')
+    def method5(self):
+        """Test OK 1 with decorators"""
+
+    def method6(self):
+        r"""Test OK 2 with raw string"""
+
+    def method7(self):
+        u"""Test OK 3 with unicode string"""
diff --git a/tests/extensions/data/elif.py b/tests/extensions/data/elif.py
new file mode 100644
index 000000000..22e79c1db
--- /dev/null
+++ b/tests/extensions/data/elif.py
@@ -0,0 +1,26 @@
+"""Checks use of "else if" triggers a refactor message"""
+
+def my_function():
+    """docstring"""
+    myint = 2
+    if myint > 5:
+        pass
+    else:
+        if myint <= 5:
+            pass
+        else:
+            myint = 3
+            if myint > 2:
+                if myint > 3:
+                    pass
+                elif myint == 3:
+                    pass
+                elif myint < 3:
+                    pass
+                else:
+                    if myint:
+                        pass
+            else:
+                if myint:
+                    pass
+                myint = 4
diff --git a/tests/extensions/data/empty_string_comparison.py b/tests/extensions/data/empty_string_comparison.py
new file mode 100644
index 000000000..c6dcf8ea8
--- /dev/null
+++ b/tests/extensions/data/empty_string_comparison.py
@@ -0,0 +1,16 @@
+# pylint: disable=literal-comparison,missing-docstring
+
+X = ''
+Y = 'test'
+
+if X is '':  # [compare-to-empty-string]
+    pass
+
+if Y is not "":  # [compare-to-empty-string]
+    pass
+
+if X == "":  # [compare-to-empty-string]
+    pass
+
+if Y != '':  # [compare-to-empty-string]
+    pass
diff --git a/tests/extensions/data/mccabe.py b/tests/extensions/data/mccabe.py
new file mode 100644
index 000000000..fdbdb5f0c
--- /dev/null
+++ b/tests/extensions/data/mccabe.py
@@ -0,0 +1,205 @@
+"""Checks use of "too-complex" check"""
+
+
+def f1():
+    """McCabe rating: 1"""
+    pass
+
+
+def f2(n):
+    """McCabe rating: 1"""
+    k = n + 4
+    s = k + n
+    return s
+
+
+def f3(n):
+    """McCabe rating: 3"""
+    if n > 3:
+        return "bigger than three"
+    elif n > 4:
+        return "is never executed"
+    else:
+        return "smaller than or equal to three"
+
+
+def f4():
+    """McCabe rating: 2"""
+    for i in range(10):
+        print(i)
+
+
+def f5(mylist):
+    """McCabe rating: 2"""
+    for i in mylist:
+        print(i)
+    else:
+        print(None)
+
+
+def f6(n):
+    """McCabe rating: 2"""
+    if n > 4:
+        return f(n - 1)
+    else:
+        return n
+
+
+def f7():
+    """McCabe rating: 3"""
+    def b():
+        """McCabe rating: 2"""
+        def c():
+            """McCabe rating: 1"""
+            pass
+        c()
+    b()
+
+
+def f8():
+    """McCabe rating: 4"""
+    try:
+        print(1)
+    except TypeA:
+        print(2)
+    except TypeB:
+        print(3)
+    else:
+        print(4)
+
+
+def f9():
+    """McCabe rating: 9"""
+    myint = 2
+    if myint > 5:
+        pass
+    else:
+        if myint <= 5:
+            pass
+        else:
+            myint = 3
+            if myint > 2:
+                if myint > 3:
+                    pass
+                elif myint == 3:
+                    pass
+                elif myint < 3:
+                    pass
+                else:
+                    if myint:
+                        pass
+            else:
+                if myint:
+                    pass
+                myint = 4
+
+
+def f10():
+    """McCabe rating: 11"""
+    myint = 2
+    if myint == 5:
+        return myint
+    elif myint == 6:
+        return myint
+    elif myint == 7:
+        return myint
+    elif myint == 8:
+        return myint
+    elif myint == 9:
+        return myint
+    elif myint == 10:
+        if myint == 8:
+            while True:
+                return True
+        elif myint == 8:
+            with myint:
+                return 8
+    else:
+        if myint == 2:
+            return myint
+        return myint
+    return myint
+
+
+class MyClass1(object):
+    """Class of example to test mccabe"""
+    _name = 'MyClass'  # To force a tail.node=None
+
+    def method1():
+        """McCabe rating: 1"""
+        pass
+
+    def method2(self, param1):
+        """McCabe rating: 18"""
+        if not param1:
+            pass
+        pass
+        if param1:
+            pass
+        else:
+            pass
+
+        pass
+
+        if param1:
+            pass
+        if param1:
+            pass
+        if param1:
+            pass
+        if param1:
+            pass
+        if param1:
+            pass
+        if param1:
+            pass
+        if param1:
+            for value in range(5):
+                pass
+
+        pass
+        for count in range(6):
+            with open('myfile') as fp:
+                count += 1
+            pass
+        pass
+        try:
+            pass
+            if not param1:
+                pass
+            else:
+                pass
+            if param1:
+                raise BaseException('Error')
+            with open('myfile2') as fp2:
+                pass
+            pass
+        finally:
+            if param1 is not None:
+                pass
+            for count2 in range(8):
+                try:
+                    pass
+                except BaseException('Error2'):
+                    pass
+        return param1
+
+
+for count in range(10):
+    if count == 1:
+        exit(0)
+    elif count == 2:
+        exit(1)
+    else:
+        exit(2)
+
+
+def method3(self):
+    try:
+        if True:
+            pass
+        else:
+            pass
+    finally:
+        pass
+    return True
diff --git a/tests/extensions/data/overlapping_exceptions.py b/tests/extensions/data/overlapping_exceptions.py
new file mode 100644
index 000000000..5ee50f314
--- /dev/null
+++ b/tests/extensions/data/overlapping_exceptions.py
@@ -0,0 +1,45 @@
+# pylint: disable=missing-docstring
+
+class SomeException(Exception):
+    pass
+
+class SubclassException(SomeException):
+    pass
+
+AliasException = SomeException
+
+try:
+    pass
+except (SomeException, SomeException): # [overlapping-except]
+    pass
+
+try:
+    pass
+except (SomeException, SubclassException): # [overlapping-except]
+    pass
+
+try:
+    pass
+except (SomeException, AliasException): # [overlapping-except]
+    pass
+
+try:
+    pass
+except (AliasException, SubclassException): # [overlapping-except]
+    pass
+
+try:
+    pass
+# +1:[overlapping-except, overlapping-except, overlapping-except]
+except (SomeException, AliasException, SubclassException):
+    pass
+
+try:
+    pass
+except (ArithmeticError, FloatingPointError): # [overlapping-except]
+    pass
+
+try:
+    pass
+except (ValueError, UnicodeDecodeError): # [overlapping-except]
+    pass
diff --git a/tests/extensions/data/overlapping_exceptions_py33.py b/tests/extensions/data/overlapping_exceptions_py33.py
new file mode 100644
index 000000000..16d5c30d1
--- /dev/null
+++ b/tests/extensions/data/overlapping_exceptions_py33.py
@@ -0,0 +1,18 @@
+# pylint: disable=missing-docstring
+
+import socket
+
+try:
+    pass
+except (IOError, OSError): # [overlapping-except]
+    pass
+
+try:
+    pass
+except (socket.error, OSError): # [overlapping-except]
+    pass
+
+try:
+    pass
+except (ConnectionError, socket.error): # [overlapping-except]
+    pass
diff --git a/tests/extensions/data/redefined.py b/tests/extensions/data/redefined.py
new file mode 100644
index 000000000..8829c4383
--- /dev/null
+++ b/tests/extensions/data/redefined.py
@@ -0,0 +1,85 @@
+"""Checks variable types aren't redefined within a method or a function"""
+
+# pylint: disable=too-few-public-methods,missing-docstring,unused-variable,invalid-name, useless-object-inheritance
+
+_OK = True
+
+class MyClass(object):
+
+    class Klass(object):
+        def __init__(self):
+            self.var2 = 'var'
+
+    def __init__(self):
+        self.var = True
+        self.var1 = 2
+        self.var2 = 1.
+        self.var1 = 2.  # [redefined-variable-type]
+        self.a_str = "hello"
+        a_str = False
+        (a_str, b_str) = (1, 2)  # no support for inference on tuple assignment
+        a_str = 2.0 if self.var else 1.0
+
+    def _getter(self):
+        return self.a_str
+    def _setter(self, val):
+        self.a_str = val
+    var2 = property(_getter, _setter)
+
+    def some_method(self):
+        def func():
+            var = 1
+            test = 'bar'
+            var = 'baz'  # [redefined-variable-type]
+        self.var = 1  # the rule checks for redefinitions in the scope of a function or method
+        test = 'foo'
+        myint = 2
+        myint = False  # [redefined-variable-type]
+
+_OK = "This is OK"  # [redefined-variable-type]
+
+if _OK:
+    SOME_FLOAT = 1.
+
+def dummy_function():
+    return 2
+
+def other_function():
+    instance = MyClass()
+    instance = True  # [redefined-variable-type]
+
+SOME_FLOAT = dummy_function()  # [redefined-variable-type]
+
+A_GLOB = None
+A_GLOB = [1, 2, 3]
+
+def func2(x):
+    if x:
+        var = 'foo'
+    else:
+        var = True
+
+    if x:
+        var2 = 'foo'
+    elif not x:
+        var2 = 2
+    else:
+        pass
+
+    if x:
+        var3 = 'foo'
+        var3 = 2  # [redefined-variable-type]
+    else:
+        pass
+
+    var = 2  # [redefined-variable-type]
+
+    if x:
+        pass
+    elif not x:
+        var4 = True
+    elif _OK:
+        pass
+    else:
+        var4 = 2.
+        var4 = 'baz'  # [redefined-variable-type]
diff --git a/tests/extensions/test_bad_builtin.py b/tests/extensions/test_bad_builtin.py
new file mode 100644
index 000000000..2fd8a95e6
--- /dev/null
+++ b/tests/extensions/test_bad_builtin.py
@@ -0,0 +1,42 @@
+# Copyright (c) 2016-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016-2017 Derek Gustafson <degustaf@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.bad_builtin
+"""
+
+import os.path as osp
+
+import pytest
+
+from pylint.extensions.bad_builtin import BadBuiltinChecker
+from pylint.lint import fix_import_path
+
+EXPECTED = [
+    "Used builtin function 'map'. Using a list comprehension can be clearer.",
+    "Used builtin function 'filter'. Using a list comprehension can be clearer.",
+]
+
+
+@pytest.fixture(scope='module')
+def checker(checker):
+    return BadBuiltinChecker
+
+
+@pytest.fixture(scope='module')
+def disable(disable):
+    return ['I']
+
+
+def test_types_redefined(linter):
+    elif_test = osp.join(osp.dirname(osp.abspath(__file__)), 'data',
+                         'bad_builtin.py')
+    with fix_import_path([elif_test]):
+        linter.check([elif_test])
+    msgs = sorted(linter.reporter.messages, key=lambda item: item.line)
+    assert len(msgs) == 2
+    for msg, expected in zip(msgs, EXPECTED):
+        assert msg.symbol == 'bad-builtin'
+        assert msg.msg == expected
diff --git a/tests/extensions/test_broad_try_clause.py b/tests/extensions/test_broad_try_clause.py
new file mode 100644
index 000000000..21b591dc1
--- /dev/null
+++ b/tests/extensions/test_broad_try_clause.py
@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2019 Tyler N. Thieding <python@thieding.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.broad_try_clause
+"""
+
+import os.path as osp
+import unittest
+
+from pylint import checkers
+from pylint.extensions.broad_try_clause import BroadTryClauseChecker
+from pylint.lint import PyLinter
+from pylint.reporters import BaseReporter
+
+
+class BroadTryClauseTestReporter(BaseReporter):
+    def handle_message(self, msg):
+        self.messages.append(msg)
+
+    def on_set_current_module(self, module, filepath):
+        self.messages = []
+
+
+class BroadTryClauseTC(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls._linter = PyLinter()
+        cls._linter.set_reporter(BroadTryClauseTestReporter())
+        checkers.initialize(cls._linter)
+        cls._linter.register_checker(BroadTryClauseChecker(cls._linter))
+        cls._linter.disable("I")
+
+    def test_broad_try_clause_message(self):
+        elif_test = osp.join(
+            osp.dirname(osp.abspath(__file__)), "data", "broad_try_clause.py"
+        )
+        self._linter.check([elif_test])
+        msgs = self._linter.reporter.messages
+        self.assertEqual(len(msgs), 1)
+
+        self.assertEqual(msgs[0].symbol, "too-many-try-statements")
+        self.assertEqual(
+            msgs[0].msg, "try clause contains 2 statements, expected at most 1"
+        )
+        self.assertEqual(msgs[0].line, 5)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/extensions/test_check_docs.py b/tests/extensions/test_check_docs.py
new file mode 100644
index 000000000..1eacc9387
--- /dev/null
+++ b/tests/extensions/test_check_docs.py
@@ -0,0 +1,2191 @@
+# Copyright (c) 2014-2015 Bruno Daniel <bruno.daniel@blue-yonder.com>
+# Copyright (c) 2015-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016-2018 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2016 Glenn Matthews <glmatthe@cisco.com>
+# Copyright (c) 2017 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017 Mitar <mitar.github@tnode.com>
+# Copyright (c) 2017 John Paraskevopoulos <io.paraskev@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Adrian Chirieac <chirieacam@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Unit tests for the pylint checkers in :mod:`pylint.extensions.check_docs`,
+in particular the parameter documentation checker `DocstringChecker`
+"""
+from __future__ import absolute_import, division, print_function
+
+import sys
+
+import astroid
+import pytest
+
+from pylint.extensions.docparams import DocstringParameterChecker
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+
+class TestParamDocChecker(CheckerTestCase):
+    """Tests for pylint_plugin.ParamDocChecker"""
+    CHECKER_CLASS = DocstringParameterChecker
+    CONFIG = {
+        'accept_no_param_doc': False,
+    }
+
+    def test_missing_func_params_in_sphinx_docstring(self):
+        """Example of a function with missing Sphinx parameter documentation in
+        the docstring
+        """
+        node = astroid.extract_node("""
+        def function_foo(x, y, z):
+            '''docstring ...
+
+            :param x: bla
+
+            :param int z: bar
+            '''
+            pass
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('y',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=node,
+                args=('x, y',))
+        ):
+            self.checker.visit_functiondef(node)
+
+    def test_missing_func_params_in_google_docstring(self):
+        """Example of a function with missing Google style parameter
+        documentation in the docstring
+        """
+        node = astroid.extract_node("""
+        def function_foo(x, y, z):
+            '''docstring ...
+
+            Args:
+                x: bla
+                z (int): bar
+
+            some other stuff
+            '''
+            pass
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('y',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=node,
+                args=('x, y',))
+        ):
+            self.checker.visit_functiondef(node)
+
+    def test_missing_func_params_with_annotations_in_google_docstring(self):
+        """Example of a function with missing Google style parameter
+        documentation in the docstring.
+        """
+        node = astroid.extract_node("""
+        def function_foo(x: int, y: bool, z):
+            '''docstring ...
+
+            Args:
+                x: bla
+                y: blah blah
+                z (int): bar
+
+            some other stuff
+            '''
+            pass
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_default_arg_with_annotations_in_google_docstring(self):
+        """Example of a function with missing Google style parameter
+        documentation in the docstring.
+        """
+        node = astroid.extract_node("""
+        def function_foo(x: int, y: bool, z: int = 786):
+            '''docstring ...
+
+            Args:
+                x: bla
+                y: blah blah
+                z: bar
+
+            some other stuff
+            '''
+            pass
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_missing_func_params_with_partial_annotations_in_google_docstring(self):
+        """Example of a function with missing Google style parameter
+        documentation in the docstring.
+        """
+        node = astroid.extract_node("""
+        def function_foo(x, y: bool, z):
+            '''docstring ...
+
+            Args:
+                x: bla
+                y: blah blah
+                z (int): bar
+
+            some other stuff
+            '''
+            pass
+        """)
+        with self.assertAddsMessages(
+                Message(
+                    msg_id='missing-type-doc',
+                    node=node,
+                    args=('x',))
+        ):
+            self.checker.visit_functiondef(node)
+
+    def test_non_builtin_annotations_in_google_docstring(self):
+        """Example of a function with missing Google style parameter
+        documentation in the docstring.
+        """
+        node = astroid.extract_node("""
+        def area(bottomleft: Point, topright: Point) -> float:
+            '''Calculate area of fake rectangle.
+                Args:
+                    bottomleft: bottom left point of rectangle
+                    topright: top right point of rectangle
+            '''
+            pass
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_non_builtin_annotations_for_returntype_in_google_docstring(self):
+        """Example of a function with missing Google style parameter
+        documentation in the docstring.
+        """
+        node = astroid.extract_node("""
+        def get_midpoint(bottomleft: Point, topright: Point) -> Point:
+            '''Calculate midpoint of fake rectangle.
+                Args:
+                    bottomleft: bottom left point of rectangle
+                    topright: top right point of rectangle
+            '''
+            pass
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_func_params_and_keyword_params_in_google_docstring(self):
+        """Example of a function with Google style parameter splitted
+        in Args and Keyword Args in the docstring
+        """
+        node = astroid.extract_node("""
+        def my_func(this, other, that=True):
+            '''Prints this, other and that
+
+                Args:
+                    this (str): Printed first
+                    other (int): Other args
+
+                Keyword Args:
+                    that (bool): Printed second
+            '''
+            print(this, that, other)
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_func_params_and_wrong_keyword_params_in_google_docstring(self):
+        """Example of a function with Google style parameter splitted
+        in Args and Keyword Args in the docstring but with wrong keyword args
+        """
+        node = astroid.extract_node("""
+        def my_func(this, other, that=True):
+            '''Prints this, other and that
+
+                Args:
+                    this (str): Printed first
+                    other (int): Other args
+
+                Keyword Args:
+                    these (bool): Printed second
+            '''
+            print(this, that, other)
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('that',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=node,
+                args=('that',)),
+            Message(
+                msg_id='differing-param-doc',
+                node=node,
+                args=('these',)),
+            Message(
+                msg_id='differing-type-doc',
+                node=node,
+                args=('these',))
+            ):
+            self.checker.visit_functiondef(node)
+
+    def test_missing_func_params_in_numpy_docstring(self):
+        """Example of a function with missing NumPy style parameter
+        documentation in the docstring
+        """
+        node = astroid.extract_node("""
+        def function_foo(x, y, z):
+            '''docstring ...
+
+            Parameters
+            ----------
+            x:
+                bla
+            z: int
+                bar
+
+            some other stuff
+            '''
+            pass
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('y',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=node,
+                args=('x, y',))
+        ):
+            self.checker.visit_functiondef(node)
+
+    @set_config(accept_no_param_doc=True)
+    def test_tolerate_no_param_documentation_at_all(self):
+        """Example of a function with no parameter documentation at all
+
+        No error message is emitted.
+        """
+        node = astroid.extract_node("""
+        def function_foo(x, y):
+            '''docstring ...
+
+            missing parameter documentation'''
+            pass
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_don_t_tolerate_no_param_documentation_at_all(self):
+        """Example of a function with no parameter documentation at all
+
+        Missing documentation error message is emitted.
+        """
+        node = astroid.extract_node("""
+        def function_foo(x, y):
+            '''docstring ...
+
+            missing parameter documentation'''
+            pass
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('x, y',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=node,
+                args=('x, y',))
+        ):
+            self.checker.visit_functiondef(node)
+
+    def test_see_tolerate_no_param_documentation_at_all(self):
+        """Example for the usage of "For the parameters, see"
+        to suppress missing-param warnings.
+        """
+        node = astroid.extract_node("""
+        def function_foo(x, y):
+            '''docstring ...
+
+            For the parameters, see :func:`blah`
+            '''
+            pass
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def _visit_methods_of_class(self, node):
+        """Visit all methods of a class node
+
+        :param node: class node
+        :type node: :class:`astroid.scoped_nodes.Class`
+        """
+        for body_item in node.body:
+            if (isinstance(body_item, astroid.FunctionDef)
+                    and hasattr(body_item, 'name')):
+                self.checker.visit_functiondef(body_item)
+
+    def test_missing_method_params_in_sphinx_docstring(self):
+        """Example of a class method with missing parameter documentation in
+        the Sphinx style docstring
+        """
+        node = astroid.extract_node("""
+        class Foo(object):
+            def method_foo(self, x, y):
+                '''docstring ...
+
+                missing parameter documentation
+
+                :param x: bla
+                '''
+                pass
+        """)
+        method_node = node.body[0]
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=method_node,
+                args=('y',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=method_node,
+                args=('x, y',))
+        ):
+            self._visit_methods_of_class(node)
+
+    def test_missing_method_params_in_google_docstring(self):
+        """Example of a class method with missing parameter documentation in
+        the Google style docstring
+        """
+        node = astroid.extract_node("""
+        class Foo(object):
+            def method_foo(self, x, y):
+                '''docstring ...
+
+                missing parameter documentation
+
+                Args:
+                    x: bla
+                '''
+                pass
+        """)
+        method_node = node.body[0]
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=method_node,
+                args=('y',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=method_node,
+                args=('x, y',))
+        ):
+            self._visit_methods_of_class(node)
+
+    def test_missing_method_params_in_numpy_docstring(self):
+        """Example of a class method with missing parameter documentation in
+        the Numpy style docstring
+        """
+        node = astroid.extract_node("""
+        class Foo(object):
+            def method_foo(self, x, y):
+                '''docstring ...
+
+                missing parameter documentation
+
+                Parameters
+                ----------
+                x:
+                    bla
+                '''
+                pass
+        """)
+        method_node = node.body[0]
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=method_node,
+                args=('y',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=method_node,
+                args=('x, y',))
+        ):
+            self._visit_methods_of_class(node)
+
+    def test_existing_func_params_in_sphinx_docstring(self):
+        """Example of a function with correctly documented parameters and
+        return values (Sphinx style)
+        """
+        node = astroid.extract_node("""
+        def function_foo(xarg, yarg, zarg, warg):
+            '''function foo ...
+
+            :param xarg: bla xarg
+            :type xarg: int
+
+            :parameter yarg: bla yarg
+            :type yarg: my.qualified.type
+
+            :arg int zarg: bla zarg
+
+            :keyword my.qualified.type warg: bla warg
+
+            :return: sum
+            :rtype: float
+            '''
+            return xarg + yarg
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_existing_func_params_in_google_docstring(self):
+        """Example of a function with correctly documented parameters and
+        return values (Google style)
+        """
+        node = astroid.extract_node("""
+        def function_foo(xarg, yarg, zarg, warg):
+            '''function foo ...
+
+            Args:
+                xarg (int): bla xarg
+                yarg (my.qualified.type): bla
+                    bla yarg
+
+                zarg (int): bla zarg
+                warg (my.qualified.type): bla warg
+
+            Returns:
+                float: sum
+            '''
+            return xarg + yarg
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_existing_func_params_in_numpy_docstring(self):
+        """Example of a function with correctly documented parameters and
+        return values (Numpy style)
+        """
+        node = astroid.extract_node("""
+        def function_foo(xarg, yarg, zarg, warg):
+            '''function foo ...
+
+            Parameters
+            ----------
+            xarg: int
+                bla xarg
+            yarg: my.qualified.type
+                bla yarg
+
+            zarg: int
+                bla zarg
+            warg: my.qualified.type
+                bla warg
+
+            Returns
+            -------
+            float
+                sum
+            '''
+            return xarg + yarg
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_wrong_name_of_func_params_in_sphinx_docstring(self):
+        """Example of functions with inconsistent parameter names in the
+        signature and in the Sphinx style documentation
+        """
+        node = astroid.extract_node("""
+        def function_foo(xarg, yarg, zarg):
+            '''function foo ...
+
+            :param xarg1: bla xarg
+            :type xarg: int
+
+            :param yarg: bla yarg
+            :type yarg1: float
+
+            :param str zarg1: bla zarg
+            '''
+            return xarg + yarg
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('xarg, zarg',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=node,
+                args=('yarg, zarg',)),
+            Message(
+                    msg_id='differing-param-doc',
+                    node=node,
+                    args=('xarg1, zarg1',)),
+            Message(
+                msg_id='differing-type-doc',
+                node=node,
+                args=('yarg1, zarg1',)),
+        ):
+            self.checker.visit_functiondef(node)
+
+        node = astroid.extract_node("""
+        def function_foo(xarg, yarg):
+            '''function foo ...
+
+            :param yarg1: bla yarg
+            :type yarg1: float
+
+            For the other parameters, see bla.
+            '''
+            return xarg + yarg
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='differing-param-doc',
+                node=node,
+                args=('yarg1',)),
+            Message(
+                msg_id='differing-type-doc',
+                node=node,
+                args=('yarg1',)),
+        ):
+            self.checker.visit_functiondef(node)
+
+    def test_wrong_name_of_func_params_in_google_docstring(self):
+        """Example of functions with inconsistent parameter names in the
+        signature and in the Google style documentation
+        """
+        node = astroid.extract_node("""
+        def function_foo(xarg, yarg, zarg):
+            '''function foo ...
+
+            Args:
+                xarg1 (int): bla xarg
+                yarg (float): bla yarg
+
+                zarg1 (str): bla zarg
+            '''
+            return xarg + yarg
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('xarg, zarg',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=node,
+                args=('xarg, zarg',)),
+            Message(
+                msg_id='differing-param-doc',
+                node=node,
+                args=('xarg1, zarg1',)),
+            Message(
+                msg_id='differing-type-doc',
+                node=node,
+                args=('xarg1, zarg1',)),
+        ):
+            self.checker.visit_functiondef(node)
+
+        node = astroid.extract_node("""
+        def function_foo(xarg, yarg):
+            '''function foo ...
+
+            Args:
+                yarg1 (float): bla yarg
+
+            For the other parameters, see bla.
+            '''
+            return xarg + yarg
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='differing-param-doc',
+                node=node,
+                args=('yarg1',)),
+            Message(
+                msg_id='differing-type-doc',
+                node=node,
+                args=('yarg1',))
+        ):
+            self.checker.visit_functiondef(node)
+
+    def test_wrong_name_of_func_params_in_numpy_docstring(self):
+        """Example of functions with inconsistent parameter names in the
+        signature and in the Numpy style documentation
+        """
+        node = astroid.extract_node("""
+        def function_foo(xarg, yarg, zarg):
+            '''function foo ...
+
+            Parameters
+            ----------
+            xarg1: int
+                bla xarg
+            yarg: float
+                bla yarg
+
+            zarg1: str
+                bla zarg
+            '''
+            return xarg + yarg
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('xarg, zarg',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=node,
+                args=('xarg, zarg',)),
+            Message(
+                msg_id='differing-param-doc',
+                node=node,
+                args=('xarg1, zarg1',)),
+            Message(
+                msg_id='differing-type-doc',
+                node=node,
+                args=('xarg1, zarg1',)),
+        ):
+            self.checker.visit_functiondef(node)
+
+        node = astroid.extract_node("""
+        def function_foo(xarg, yarg):
+            '''function foo ...
+
+            Parameters
+            ----------
+            yarg1: float
+                bla yarg
+
+            For the other parameters, see bla.
+            '''
+            return xarg + yarg
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='differing-param-doc',
+                node=node,
+                args=('yarg1',)),
+            Message(
+                msg_id='differing-type-doc',
+                node=node,
+                args=('yarg1',))
+        ):
+            self.checker.visit_functiondef(node)
+
+    def test_see_sentence_for_func_params_in_sphinx_docstring(self):
+        """Example for the usage of "For the other parameters, see" to avoid
+        too many repetitions, e.g. in functions or methods adhering to a
+        given interface (Sphinx style)
+        """
+        node = astroid.extract_node("""
+        def function_foo(xarg, yarg):
+            '''function foo ...
+
+            :param yarg: bla yarg
+            :type yarg: float
+
+            For the other parameters, see :func:`bla`
+            '''
+            return xarg + yarg
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_see_sentence_for_func_params_in_google_docstring(self):
+        """Example for the usage of "For the other parameters, see" to avoid
+        too many repetitions, e.g. in functions or methods adhering to a
+        given interface (Google style)
+        """
+        node = astroid.extract_node("""
+        def function_foo(xarg, yarg):
+            '''function foo ...
+
+            Args:
+                yarg (float): bla yarg
+
+            For the other parameters, see :func:`bla`
+            '''
+            return xarg + yarg
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_see_sentence_for_func_params_in_numpy_docstring(self):
+        """Example for the usage of "For the other parameters, see" to avoid
+        too many repetitions, e.g. in functions or methods adhering to a
+        given interface (Numpy style)
+        """
+        node = astroid.extract_node("""
+        def function_foo(xarg, yarg):
+            '''function foo ...
+
+            Parameters
+            ----------
+            yarg: float
+                bla yarg
+
+            For the other parameters, see :func:`bla`
+            '''
+            return xarg + yarg
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_constr_params_in_class_sphinx(self):
+        """Example of a class with missing constructor parameter documentation
+        (Sphinx style)
+
+        Everything is completely analogous to functions.
+        """
+        node = astroid.extract_node("""
+        class ClassFoo(object):
+            '''docstring foo
+
+            :param y: bla
+
+            missing constructor parameter documentation
+            '''
+
+            def __init__(self, x, y):
+                pass
+
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('x',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=node,
+                args=('x, y',))
+        ):
+            self._visit_methods_of_class(node)
+
+    def test_constr_params_in_class_google(self):
+        """Example of a class with missing constructor parameter documentation
+        (Google style)
+
+        Everything is completely analogous to functions.
+        """
+        node = astroid.extract_node("""
+        class ClassFoo(object):
+            '''docstring foo
+
+            Args:
+                y: bla
+
+            missing constructor parameter documentation
+            '''
+
+            def __init__(self, x, y):
+                pass
+
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('x',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=node,
+                args=('x, y',))
+        ):
+            self._visit_methods_of_class(node)
+
+    def test_constr_params_in_class_numpy(self):
+        """Example of a class with missing constructor parameter documentation
+        (Numpy style)
+
+        Everything is completely analogous to functions.
+        """
+        node = astroid.extract_node("""
+        class ClassFoo(object):
+            '''docstring foo
+
+            Parameters
+            ----------
+            y:
+                bla
+
+            missing constructor parameter documentation
+            '''
+
+            def __init__(self, x, y):
+                pass
+
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('x',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=node,
+                args=('x, y',))
+        ):
+            self._visit_methods_of_class(node)
+
+    def test_constr_params_and_attributes_in_class_numpy(self):
+        """Example of a class with correct constructor parameter documentation
+        and an attributes section (Numpy style)
+        """
+        node = astroid.extract_node("""
+        class ClassFoo(object):
+            '''
+            Parameters
+            ----------
+            foo : str
+                Something.
+
+            Attributes
+            ----------
+            bar : str
+                Something.
+            '''
+            def __init__(self, foo):
+                self.bar = None
+        """)
+        with self.assertNoMessages():
+            self._visit_methods_of_class(node)
+
+    def test_constr_params_in_init_sphinx(self):
+        """Example of a class with missing constructor parameter documentation
+        (Sphinx style)
+
+        Everything is completely analogous to functions.
+        """
+        node = astroid.extract_node("""
+        class ClassFoo(object):
+            def __init__(self, x, y):
+                '''docstring foo constructor
+
+                :param y: bla
+
+                missing constructor parameter documentation
+                '''
+
+                pass
+
+        """)
+        constructor_node = node.body[0]
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=constructor_node,
+                args=('x',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=constructor_node,
+                args=('x, y',))
+        ):
+            self._visit_methods_of_class(node)
+
+    def test_constr_params_in_init_google(self):
+        """Example of a class with missing constructor parameter documentation
+        (Google style)
+
+        Everything is completely analogous to functions.
+        """
+        node = astroid.extract_node("""
+        class ClassFoo(object):
+            def __init__(self, x, y):
+                '''docstring foo constructor
+
+                Args:
+                    y: bla
+
+                missing constructor parameter documentation
+                '''
+                pass
+
+        """)
+        constructor_node = node.body[0]
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=constructor_node,
+                args=('x',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=constructor_node,
+                args=('x, y',))
+        ):
+            self._visit_methods_of_class(node)
+
+    def test_constr_params_in_init_numpy(self):
+        """Example of a class with missing constructor parameter documentation
+        (Numpy style)
+
+        Everything is completely analogous to functions.
+        """
+        node = astroid.extract_node("""
+        class ClassFoo(object):
+            def __init__(self, x, y):
+                '''docstring foo constructor
+
+                Parameters
+                ----------
+                y:
+                    bla
+
+                missing constructor parameter documentation
+                '''
+                pass
+
+        """)
+        constructor_node = node.body[0]
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=constructor_node,
+                args=('x',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=constructor_node,
+                args=('x, y',))
+        ):
+            self._visit_methods_of_class(node)
+
+    def test_see_sentence_for_constr_params_in_class(self):
+        """Example usage of "For the parameters, see" in class docstring"""
+        node = astroid.extract_node("""
+        class ClassFoo(object):
+            '''docstring foo
+
+            For the parameters, see :func:`bla`
+            '''
+
+            def __init__(self, x, y):
+                '''init'''
+                pass
+
+        """)
+        with self.assertNoMessages():
+            self._visit_methods_of_class(node)
+
+    def test_see_sentence_for_constr_params_in_init(self):
+        """Example usage of "For the parameters, see" in init docstring"""
+        node = astroid.extract_node("""
+        class ClassFoo(object):
+            '''foo'''
+
+            def __init__(self, x, y):
+                '''docstring foo constructor
+
+                For the parameters, see :func:`bla`
+                '''
+                pass
+
+        """)
+        with self.assertNoMessages():
+            self._visit_methods_of_class(node)
+
+
+    def test_constr_params_in_class_and_init_sphinx(self):
+        """Example of a class with missing constructor parameter documentation
+        in both the init docstring and the class docstring
+        (Sphinx style)
+
+        Everything is completely analogous to functions.
+        """
+        node = astroid.extract_node("""
+        class ClassFoo(object):
+            '''docstring foo
+
+            :param y: None
+
+            missing constructor parameter documentation
+            '''
+
+            def __init__(self, x, y):
+                '''docstring foo
+
+                :param y: bla
+
+                missing constructor parameter documentation
+                '''
+                pass
+
+        """)
+        constructor_node = node.body[0]
+        with self.assertAddsMessages(
+            Message(
+                msg_id='multiple-constructor-doc',
+                node=node,
+                args=(node.name,)),
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('x',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=node,
+                args=('x, y',)),
+            Message(
+                msg_id='missing-param-doc',
+                node=constructor_node,
+                args=('x',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=constructor_node,
+                args=('x, y',)),
+        ):
+            self._visit_methods_of_class(node)
+
+    def test_constr_params_in_class_and_init_google(self):
+        """Example of a class with missing constructor parameter documentation
+        in both the init docstring and the class docstring
+        (Google style)
+
+        Everything is completely analogous to functions.
+        """
+        node = astroid.extract_node("""
+        class ClassFoo(object):
+            '''docstring foo
+
+            Args:
+                y: bla
+
+            missing constructor parameter documentation
+            '''
+
+            def __init__(self, x, y):
+                '''docstring foo
+
+                Args:
+                    y: bla
+
+                missing constructor parameter documentation
+                '''
+                pass
+
+        """)
+        constructor_node = node.body[0]
+        with self.assertAddsMessages(
+            Message(
+                msg_id='multiple-constructor-doc',
+                node=node,
+                args=(node.name,)),
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('x',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=node,
+                args=('x, y',)),
+            Message(
+                msg_id='missing-param-doc',
+                node=constructor_node,
+                args=('x',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=constructor_node,
+                args=('x, y',)),
+        ):
+            self._visit_methods_of_class(node)
+
+    def test_constr_params_in_class_and_init_numpy(self):
+        """Example of a class with missing constructor parameter documentation
+        in both the init docstring and the class docstring
+        (Numpy style)
+
+        Everything is completely analogous to functions.
+        """
+        node = astroid.extract_node("""
+        class ClassFoo(object):
+            '''docstring foo
+
+            Parameters
+            ----------
+            y:
+                bla
+
+            missing constructor parameter documentation
+            '''
+
+            def __init__(self, x, y):
+                '''docstring foo
+
+                Parameters
+                ----------
+                y:
+                    bla
+
+                missing constructor parameter documentation
+                '''
+                pass
+
+        """)
+        constructor_node = node.body[0]
+        with self.assertAddsMessages(
+            Message(
+                msg_id='multiple-constructor-doc',
+                node=node,
+                args=(node.name,)),
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('x',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=node,
+                args=('x, y',)),
+            Message(
+                msg_id='missing-param-doc',
+                node=constructor_node,
+                args=('x',)),
+            Message(
+                msg_id='missing-type-doc',
+                node=constructor_node,
+                args=('x, y',)),
+        ):
+            self._visit_methods_of_class(node)
+
+    @pytest.mark.skipif(sys.version_info[0] != 3, reason="Enabled on Python 3")
+    def test_kwonlyargs_are_taken_in_account(self):
+        node = astroid.extract_node('''
+        def my_func(arg, *, kwonly, missing_kwonly):
+            """The docstring
+
+            :param int arg: The argument.
+            :param bool kwonly: A keyword-arg.
+            """
+        ''')
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('missing_kwonly', )),
+            Message(
+                msg_id='missing-type-doc',
+                node=node,
+                args=('missing_kwonly', ))):
+            self.checker.visit_functiondef(node)
+
+    def test_warns_missing_args_sphinx(self):
+        node = astroid.extract_node('''
+        def my_func(named_arg, *args):
+            """The docstring
+
+            :param named_arg: Returned
+            :type named_arg: object
+            :returns: Maybe named_arg
+            :rtype: object or None
+            """
+            if args:
+                return named_arg
+        ''')
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('args',))):
+            self.checker.visit_functiondef(node)
+
+    def test_warns_missing_kwargs_sphinx(self):
+        node = astroid.extract_node('''
+        def my_func(named_arg, **kwargs):
+            """The docstring
+
+            :param named_arg: Returned
+            :type named_arg: object
+            :returns: Maybe named_arg
+            :rtype: object or None
+            """
+            if kwargs:
+                return named_arg
+        ''')
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('kwargs',))):
+            self.checker.visit_functiondef(node)
+
+    def test_warns_missing_args_google(self):
+        node = astroid.extract_node('''
+        def my_func(named_arg, *args):
+            """The docstring
+
+            Args:
+                named_arg (object): Returned
+
+            Returns:
+                object or None: Maybe named_arg
+            """
+            if args:
+                return named_arg
+        ''')
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('args',))):
+            self.checker.visit_functiondef(node)
+
+    def test_warns_missing_kwargs_google(self):
+        node = astroid.extract_node('''
+        def my_func(named_arg, **kwargs):
+            """The docstring
+
+            Args:
+                named_arg (object): Returned
+
+            Returns:
+                object or None: Maybe named_arg
+            """
+            if kwargs:
+                return named_arg
+        ''')
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('kwargs',))):
+            self.checker.visit_functiondef(node)
+
+    def test_warns_missing_args_numpy(self):
+        node = astroid.extract_node('''
+        def my_func(named_arg, *args):
+            """The docstring
+
+            Args
+            ----
+            named_arg : object
+                Returned
+
+            Returns
+            -------
+                object or None
+                    Maybe named_arg
+            """
+            if args:
+                return named_arg
+        ''')
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('args',))):
+            self.checker.visit_functiondef(node)
+
+    def test_warns_missing_kwargs_numpy(self):
+        node = astroid.extract_node('''
+        def my_func(named_arg, **kwargs):
+            """The docstring
+
+            Args
+            ----
+            named_arg : object
+                Returned
+
+            Returns
+            -------
+                object or None
+                    Maybe named_arg
+            """
+            if kwargs:
+                return named_arg
+        ''')
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-param-doc',
+                node=node,
+                args=('kwargs',))):
+            self.checker.visit_functiondef(node)
+
+    def test_finds_args_without_type_sphinx(self):
+        node = astroid.extract_node('''
+        def my_func(named_arg, *args):
+            """The docstring
+
+            :param named_arg: Returned
+            :type named_arg: object
+            :param args: Optional arguments
+            :returns: Maybe named_arg
+            :rtype: object or None
+            """
+            if args:
+                return named_arg
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_finds_kwargs_without_type_sphinx(self):
+        node = astroid.extract_node('''
+        def my_func(named_arg, **kwargs):
+            """The docstring
+
+            :param named_arg: Returned
+            :type named_arg: object
+            :param kwargs: Keyword arguments
+            :returns: Maybe named_arg
+            :rtype: object or None
+            """
+            if kwargs:
+                return named_arg
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_finds_args_without_type_google(self):
+        node = astroid.extract_node('''
+        def my_func(named_arg, *args):
+            """The docstring
+
+            Args:
+                named_arg (object): Returned
+                *args: Optional arguments
+
+            Returns:
+                object or None: Maybe named_arg
+            """
+            if args:
+                return named_arg
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_finds_kwargs_without_type_google(self):
+        node = astroid.extract_node('''
+        def my_func(named_arg, **kwargs):
+            """The docstring
+
+            Args:
+                named_arg (object): Returned
+                **kwargs: Keyword arguments
+
+            Returns:
+                object or None: Maybe named_arg
+            """
+            if kwargs:
+                return named_arg
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_finds_args_without_type_numpy(self):
+        node = astroid.extract_node('''
+        def my_func(named_arg, *args):
+            """The docstring
+
+            Args
+            ----
+            named_arg : object
+                Returned
+            args :
+                Optional Arguments
+
+            Returns
+            -------
+                object or None
+                    Maybe named_arg
+            """
+            if args:
+                return named_arg
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_finds_args_with_xref_type_google(self):
+        node = astroid.extract_node('''
+        def my_func(named_arg, **kwargs):
+            """The docstring
+
+            Args:
+                named_arg (`example.value`): Returned
+                **kwargs: Keyword arguments
+
+            Returns:
+                `example.value`: Maybe named_arg
+            """
+            if kwargs:
+                return named_arg
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_finds_args_with_xref_type_numpy(self):
+        node = astroid.extract_node('''
+        def my_func(named_arg, *args):
+            """The docstring
+
+            Args
+            ----
+            named_arg : `example.value`
+                Returned
+            args :
+                Optional Arguments
+
+            Returns
+            -------
+                `example.value`
+                    Maybe named_arg
+            """
+            if args:
+                return named_arg
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_finds_kwargs_without_type_numpy(self):
+        node = astroid.extract_node('''
+        def my_func(named_arg, **kwargs):
+            """The docstring
+
+            Args
+            ----
+            named_arg : object
+                Returned
+            kwargs :
+                Keyword arguments
+
+            Returns
+            -------
+                object or None
+                    Maybe named_arg
+            """
+            if kwargs:
+                return named_arg
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    CONTAINER_TYPES = [
+        'dict(str,str)',
+        'dict[str,str]',
+        'tuple(int)',
+        'list[tokenize.TokenInfo]',
+    ]
+
+    COMPLEX_TYPES = CONTAINER_TYPES + [
+        'dict(str, str)',
+        'dict[str, str]',
+        'int or str',
+        'tuple(int or str)',
+        'tuple(int) or list(int)',
+        'tuple(int or str) or list(int or str)',
+    ]
+
+    @pytest.mark.parametrize('complex_type', COMPLEX_TYPES)
+    def test_finds_multiple_types_sphinx(self, complex_type):
+        node = astroid.extract_node('''
+        def my_func(named_arg):
+            """The docstring
+
+            :param named_arg: Returned
+            :type named_arg: {0}
+
+            :returns: named_arg
+            :rtype: {0}
+            """
+            return named_arg
+        '''.format(complex_type))
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    @pytest.mark.parametrize('complex_type', COMPLEX_TYPES)
+    def test_finds_multiple_types_google(self, complex_type):
+        node = astroid.extract_node('''
+        def my_func(named_arg):
+            """The docstring
+
+            Args:
+                named_arg ({0}): Returned
+
+            Returns:
+                {0}: named_arg
+            """
+            return named_arg
+        '''.format(complex_type))
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    @pytest.mark.parametrize('complex_type', COMPLEX_TYPES)
+    def test_finds_multiple_types_numpy(self, complex_type):
+        node = astroid.extract_node('''
+        def my_func(named_arg):
+            """The docstring
+
+            Args
+            ----
+            named_arg : {0}
+                Returned
+
+            Returns
+            -------
+                {0}
+                    named_arg
+            """
+            return named_arg
+        '''.format(complex_type))
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    @pytest.mark.parametrize('container_type', CONTAINER_TYPES)
+    def test_finds_compact_container_types_sphinx(self, container_type):
+        node = astroid.extract_node('''
+        def my_func(named_arg):
+            """The docstring
+
+            :param {0} named_arg: Returned
+
+            :returns: named_arg
+            :rtype: {0}
+            """
+            return named_arg
+        '''.format(container_type))
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_ignores_optional_specifier_google(self):
+        node = astroid.extract_node('''
+        def do_something(param1, param2, param3=(), param4=[], param5=[], param6=True):
+            """Do something.
+
+            Args:
+                param1 (str): Description.
+                param2 (dict(str, int)): Description.
+                param3 (tuple(str), optional): Defaults to empty. Description.
+                param4 (List[str], optional): Defaults to empty. Description.
+                param5 (list[tuple(str)], optional): Defaults to empty. Description.
+                param6 (bool, optional): Defaults to True. Description.
+
+            Returns:
+                int: Description.
+            """
+            return param1, param2, param3, param4, param5, param6
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_ignores_optional_specifier_numpy(self):
+        node = astroid.extract_node('''
+        def do_something(param, param2='all'):
+            """Do something.
+
+            Parameters
+            ----------
+            param : str
+                Description.
+            param2 : str, optional
+                Description (the default is 'all').
+
+            Returns
+            -------
+            int
+                Description.
+            """
+            return param, param2
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_finds_short_name_exception(self):
+        node = astroid.extract_node('''
+        from fake_package import BadError
+
+        def do_something(): #@
+            """Do something.
+
+            Raises:
+                ~fake_package.exceptions.BadError: When something bad happened.
+            """
+            raise BadError("A bad thing happened.")
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_finds_missing_raises_from_setter_sphinx(self):
+        """Example of a setter having missing raises documentation in
+        the Sphinx style docstring of the property
+        """
+        property_node, node = astroid.extract_node("""
+        class Foo(object):
+            @property
+            def foo(self): #@
+                '''docstring ...
+
+                :type: int
+                '''
+                return 10
+
+            @foo.setter
+            def foo(self, value):
+                raise AttributeError() #@
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=property_node,
+                args=('AttributeError',)),
+        ):
+            self.checker.visit_raise(node)
+
+    def test_finds_missing_raises_from_setter_google(self):
+        """Example of a setter having missing raises documentation in
+        the Google style docstring of the property
+        """
+        property_node, node = astroid.extract_node("""
+        class Foo(object):
+            @property
+            def foo(self): #@
+                '''int: docstring
+
+                Include a "Raises" section so that this is identified
+                as a Google docstring and not a Numpy docstring.
+
+                Raises:
+                    RuntimeError: Always
+                '''
+                raise RuntimeError()
+                return 10
+
+            @foo.setter
+            def foo(self, value):
+                raises AttributeError() #@
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=property_node,
+                args=('AttributeError',)),
+        ):
+            self.checker.visit_raise(node)
+
+    def test_finds_missing_raises_from_setter_numpy(self):
+        """Example of a setter having missing raises documentation in
+        the Numpy style docstring of the property
+        """
+        property_node, node = astroid.extract_node("""
+        class Foo(object):
+            @property
+            def foo(self): #@
+                '''int: docstring
+
+                Include a "Raises" section so that this is identified
+                as a Numpy docstring and not a Google docstring.
+
+                Raises
+                ------
+                RuntimeError
+                    Always
+                '''
+                raise RuntimeError()
+                return 10
+
+            @foo.setter
+            def foo(self, value):
+                raises AttributeError() #@
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=property_node,
+                args=('AttributeError',)),
+        ):
+            self.checker.visit_raise(node)
+
+    def test_finds_missing_raises_in_setter_sphinx(self):
+        """Example of a setter having missing raises documentation in
+        its own Sphinx style docstring
+        """
+        setter_node, node = astroid.extract_node("""
+        class Foo(object):
+            @property
+            def foo(self):
+                '''docstring ...
+
+                :type: int
+                :raises RuntimeError: Always
+                '''
+                raise RuntimeError()
+                return 10
+
+            @foo.setter
+            def foo(self, value): #@
+                '''setter docstring ...
+
+                :type: None
+                '''
+                raise AttributeError() #@
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=setter_node,
+                args=('AttributeError',)),
+        ):
+            self.checker.visit_raise(node)
+
+    def test_finds_missing_raises_from_setter_google(self):
+        """Example of a setter having missing raises documentation in
+        its own Google style docstring of the property
+        """
+        setter_node, node = astroid.extract_node("""
+        class Foo(object):
+            @property
+            def foo(self):
+                '''int: docstring ...
+
+                Raises:
+                    RuntimeError: Always
+                '''
+                raise RuntimeError()
+                return 10
+
+            @foo.setter
+            def foo(self, value): #@
+                '''setter docstring ...
+
+                Raises:
+                    RuntimeError: Never
+                '''
+                if True:
+                    raise AttributeError() #@
+                raise RuntimeError()
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=setter_node,
+                args=('AttributeError',)),
+        ):
+            self.checker.visit_raise(node)
+
+    def test_finds_missing_raises_from_setter_numpy(self):
+        """Example of a setter having missing raises documentation in
+        its own Numpy style docstring of the property
+        """
+        setter_node, node = astroid.extract_node("""
+        class Foo(object):
+            @property
+            def foo(self):
+                '''int: docstring ...
+
+                Raises
+                ------
+                RuntimeError
+                    Always
+                '''
+                raise RuntimeError()
+                return 10
+
+            @foo.setter
+            def foo(self, value): #@
+                '''setter docstring ...
+
+                Raises
+                ------
+                RuntimeError
+                    Never
+                '''
+                if True:
+                    raise AttributeError() #@
+                raise RuntimeError()
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=setter_node,
+                args=('AttributeError',)),
+        ):
+            self.checker.visit_raise(node)
+
+    def test_finds_property_return_type_sphinx(self):
+        """Example of a property having return documentation in
+        a Sphinx style docstring
+        """
+        node = astroid.extract_node("""
+        class Foo(object):
+            @property
+            def foo(self): #@
+                '''docstring ...
+
+                :type: int
+                '''
+                return 10
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_finds_property_return_type_google(self):
+        """Example of a property having return documentation in
+        a Google style docstring
+        """
+        node = astroid.extract_node("""
+        class Foo(object):
+            @property
+            def foo(self): #@
+                '''int: docstring ...
+
+                Raises:
+                    RuntimeError: Always
+                '''
+                raise RuntimeError()
+                return 10
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_finds_property_return_type_numpy(self):
+        """Example of a property having return documentation in
+        a numpy style docstring
+        """
+        node = astroid.extract_node("""
+        class Foo(object):
+            @property
+            def foo(self): #@
+                '''int: docstring ...
+
+                Raises
+                ------
+                RuntimeError
+                    Always
+                '''
+                raise RuntimeError()
+                return 10
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_finds_annotation_property_return_type_sphinx(self):
+        """Example of a property having missing return documentation in
+        a Sphinx style docstring
+        """
+        property_node, node = astroid.extract_node("""
+        class Foo(object):
+            @property
+            def foo(self) -> int: #@
+                '''docstring ...
+
+                :raises RuntimeError: Always
+                '''
+                raise RuntimeError()
+                return 10 #@
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_return(node)
+
+    def test_finds_missing_property_return_type_sphinx(self):
+        """Example of a property having missing return documentation in
+        a Sphinx style docstring
+        """
+        property_node, node = astroid.extract_node("""
+        class Foo(object):
+            @property
+            def foo(self): #@
+                '''docstring ...
+
+                :raises RuntimeError: Always
+                '''
+                raise RuntimeError()
+                return 10 #@
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-return-type-doc',
+                node=property_node),
+        ):
+            self.checker.visit_return(node)
+
+    def test_finds_annotation_property_return_type_google(self):
+        """Example of a property having return documentation in
+        a Google style docstring
+        """
+        property_node, node = astroid.extract_node("""
+        class Foo(object):
+            @property
+            def foo(self) -> int: #@
+                '''docstring ...
+
+                Raises:
+                    RuntimeError: Always
+                '''
+                raise RuntimeError()
+                return 10 #@
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_return(node)
+
+    def test_finds_missing_property_return_type_google(self):
+        """Example of a property having return documentation in
+        a Google style docstring
+        """
+        property_node, node = astroid.extract_node("""
+        class Foo(object):
+            @property
+            def foo(self): #@
+                '''docstring ...
+
+                Raises:
+                    RuntimeError: Always
+                '''
+                raise RuntimeError()
+                return 10 #@
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-return-type-doc',
+                node=property_node),
+        ):
+            self.checker.visit_return(node)
+
+    def test_finds_missing_property_return_type_numpy(self):
+        """Example of a property having return documentation in
+        a numpy style docstring
+        """
+        property_node, node = astroid.extract_node("""
+        class Foo(object):
+            @property
+            def foo(self): #@
+                '''docstring ...
+
+                Raises
+                ------
+                RuntimeError
+                    Always
+                '''
+                raise RuntimeError()
+                return 10 #@
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-return-type-doc',
+                node=property_node),
+        ):
+            self.checker.visit_return(node)
+
+    def test_ignores_non_property_return_type_sphinx(self):
+        """Example of a class function trying to use `type` as return
+        documentation in a Sphinx style docstring
+        """
+        func_node, node = astroid.extract_node("""
+        class Foo(object):
+            def foo(self): #@
+                '''docstring ...
+
+                :type: int
+                '''
+                return 10 #@
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-return-doc',
+                node=func_node),
+            Message(
+                msg_id='missing-return-type-doc',
+                node=func_node),
+        ):
+            self.checker.visit_return(node)
+
+    def test_ignores_non_property_return_type_google(self):
+        """Example of a class function trying to use `type` as return
+        documentation in a Google style docstring
+        """
+        func_node, node = astroid.extract_node("""
+        class Foo(object):
+            def foo(self): #@
+                '''int: docstring ...
+
+                Raises:
+                    RuntimeError: Always
+                '''
+                raise RuntimeError()
+                return 10 #@
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-return-doc',
+                node=func_node),
+            Message(
+                msg_id='missing-return-type-doc',
+                node=func_node),
+        ):
+            self.checker.visit_return(node)
+
+    def test_ignores_non_property_return_type_numpy(self):
+        """Example of a class function trying to use `type` as return
+        documentation in a numpy style docstring
+        """
+        func_node, node = astroid.extract_node("""
+        class Foo(object):
+            def foo(self): #@
+                '''int: docstring ...
+
+                Raises
+                ------
+                RuntimeError
+                    Always
+                '''
+                raise RuntimeError()
+                return 10 #@
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-return-doc',
+                node=func_node),
+            Message(
+                msg_id='missing-return-type-doc',
+                node=func_node),
+        ):
+            self.checker.visit_return(node)
+
+    def test_non_property_annotation_return_type_numpy(self):
+        """Example of a class function trying to use `type` as return
+        documentation in a numpy style docstring
+        """
+        func_node, node = astroid.extract_node("""
+        class Foo(object):
+            def foo(self) -> int: #@
+                '''int: docstring ...
+
+                Raises
+                ------
+                RuntimeError
+                    Always
+                '''
+                raise RuntimeError()
+                return 10 #@
+        """)
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-return-doc',
+                node=func_node),
+        ):
+            self.checker.visit_return(node)
+
+    def test_ignores_return_in_abstract_method_sphinx(self):
+        """Example of an abstract method documenting the return type that an
+        implementation should return.
+        """
+        node = astroid.extract_node("""
+        import abc
+        class Foo(object):
+            @abc.abstractmethod
+            def foo(self): #@
+                '''docstring ...
+
+                :returns: Ten
+                :rtype: int
+                '''
+                return 10
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_ignores_return_in_abstract_method_google(self):
+        """Example of an abstract method documenting the return type that an
+        implementation should return.
+        """
+        node = astroid.extract_node("""
+        import abc
+        class Foo(object):
+            @abc.abstractmethod
+            def foo(self): #@
+                '''docstring ...
+
+                Returns:
+                    int: Ten
+                '''
+                return 10
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_ignores_return_in_abstract_method_numpy(self):
+        """Example of an abstract method documenting the return type that an
+        implementation should return.
+        """
+        node = astroid.extract_node("""
+        import abc
+        class Foo(object):
+            @abc.abstractmethod
+            def foo(self): #@
+                '''docstring ...
+
+                Returns
+                -------
+                int
+                    Ten
+                '''
+                return 10
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_ignores_raise_notimplementederror_sphinx(self):
+        """Example of an abstract
+        """
+        node = astroid.extract_node("""
+        class Foo(object):
+            def foo(self, arg): #@
+                '''docstring ...
+
+                :param arg: An argument.
+                :type arg: int
+                '''
+                raise NotImplementedError()
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_ignores_return_in_abstract_method_google(self):
+        """Example of a method documenting the return type that an
+        implementation should return.
+        """
+        node = astroid.extract_node("""
+        class Foo(object):
+            def foo(self, arg): #@
+                '''docstring ...
+
+                Args:
+                    arg (int): An argument.
+                '''
+                raise NotImplementedError()
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_ignores_return_in_abstract_method_numpy(self):
+        """Example of a method documenting the return type that an
+        implementation should return.
+        """
+        node = astroid.extract_node("""
+        class Foo(object):
+            def foo(self, arg): #@
+                '''docstring ...
+
+                Parameters
+                ----------
+                arg : int
+                    An argument.
+                '''
+                raise NotImplementedError()
+        """)
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
diff --git a/tests/extensions/test_check_docs_utils.py b/tests/extensions/test_check_docs_utils.py
new file mode 100644
index 000000000..26af9db9d
--- /dev/null
+++ b/tests/extensions/test_check_docs_utils.py
@@ -0,0 +1,111 @@
+# Copyright (c) 2016-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2018 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Unit tests for the pylint checkers in :mod:`pylint.extensions.check_docs`,
+in particular the parameter documentation checker `DocstringChecker`
+"""
+from __future__ import absolute_import, division, print_function
+
+import astroid
+import pytest
+
+import pylint.extensions._check_docs_utils as utils
+
+
+@pytest.mark.parametrize("string,count", [
+    ('abc',        0),
+    ('',           0),
+    ('  abc',      2),
+    ('\n  abc',    0),
+    ('   \n  abc', 3),
+])
+def test_space_indentation(string, count):
+    """Test for pylint_plugin.ParamDocChecker"""
+    assert utils.space_indentation(string) == count
+
+
+@pytest.mark.parametrize("raise_node,expected", [
+    (astroid.extract_node('''
+    def my_func():
+        raise NotImplementedError #@
+    '''), {"NotImplementedError"}),
+
+    (astroid.extract_node('''
+    def my_func():
+        raise NotImplementedError("Not implemented!") #@
+    '''), {"NotImplementedError"}),
+
+    (astroid.extract_node('''
+    def my_func():
+        try:
+            fake_func()
+        except RuntimeError:
+            raise #@
+    '''), {"RuntimeError"}),
+
+    (astroid.extract_node('''
+    def my_func():
+        try:
+            fake_func()
+        except RuntimeError:
+            if another_func():
+                raise #@
+    '''), {"RuntimeError"}),
+
+    (astroid.extract_node('''
+    def my_func():
+        try:
+            fake_func()
+        except RuntimeError:
+            try:
+                another_func()
+                raise #@
+            except NameError:
+                pass
+    '''), {"RuntimeError"}),
+
+    (astroid.extract_node('''
+    def my_func():
+        try:
+            fake_func()
+        except RuntimeError:
+            try:
+                another_func()
+            except NameError:
+                raise #@
+    '''), {"NameError"}),
+
+    (astroid.extract_node('''
+    def my_func():
+        try:
+            fake_func()
+        except:
+            raise #@
+    '''), set()),
+
+    (astroid.extract_node('''
+    def my_func():
+        try:
+            fake_func()
+        except (RuntimeError, ValueError):
+            raise #@
+    '''), {"RuntimeError", "ValueError"}),
+
+    (astroid.extract_node('''
+    import not_a_module
+    def my_func():
+        try:
+            fake_func()
+        except not_a_module.Error:
+            raise #@
+    '''), set()),
+
+])
+def test_exception(raise_node, expected):
+    found = utils.possible_exc_types(raise_node)
+    assert found == expected
diff --git a/tests/extensions/test_check_mccabe.py b/tests/extensions/test_check_mccabe.py
new file mode 100644
index 000000000..8ae42f5fd
--- /dev/null
+++ b/tests/extensions/test_check_mccabe.py
@@ -0,0 +1,63 @@
+# Copyright (c) 2016-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016-2017 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.check_mccabe
+"""
+
+import os.path as osp
+
+import pytest
+
+from pylint.extensions import mccabe
+
+EXPECTED_MSGS = [
+    "'f1' is too complex. The McCabe rating is 1",
+    "'f2' is too complex. The McCabe rating is 1",
+    "'f3' is too complex. The McCabe rating is 3",
+    "'f4' is too complex. The McCabe rating is 2",
+    "'f5' is too complex. The McCabe rating is 2",
+    "'f6' is too complex. The McCabe rating is 2",
+    "'f7' is too complex. The McCabe rating is 3",
+    "'f8' is too complex. The McCabe rating is 4",
+    "'f9' is too complex. The McCabe rating is 9",
+    "'method1' is too complex. The McCabe rating is 1",
+    "This 'for' is too complex. The McCabe rating is 4",
+    "'method3' is too complex. The McCabe rating is 2",
+    "'f10' is too complex. The McCabe rating is 11",
+    "'method2' is too complex. The McCabe rating is 18",
+]
+
+
+@pytest.fixture(scope="module")
+def enable(enable):
+    return ['too-complex']
+
+
+@pytest.fixture(scope="module")
+def disable(disable):
+    return ['all']
+
+
+@pytest.fixture(scope="module")
+def register(register):
+    return mccabe.register
+
+
+@pytest.fixture
+def fname_mccabe_example():
+    return osp.join(osp.dirname(osp.abspath(__file__)), 'data', 'mccabe.py')
+
+
+@pytest.mark.parametrize("complexity, expected", [
+    (0, EXPECTED_MSGS),
+    (9, EXPECTED_MSGS[-2:]),
+])
+def test_max_mccabe_rate(linter, fname_mccabe_example, complexity, expected):
+    linter.global_set_option('max-complexity', complexity)
+    linter.check([fname_mccabe_example])
+    real_msgs = [message.msg for message in linter.reporter.messages]
+    assert sorted(expected) == sorted(real_msgs)
diff --git a/tests/extensions/test_check_raise_docs.py b/tests/extensions/test_check_raise_docs.py
new file mode 100644
index 000000000..c51a1fdaa
--- /dev/null
+++ b/tests/extensions/test_check_raise_docs.py
@@ -0,0 +1,781 @@
+# Copyright (c) 2016-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2016 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2018 Adam Dangoor <adamdangoor@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Unit tests for the raised exception documentation checking in the
+`DocstringChecker` in :mod:`pylint.extensions.check_docs`
+"""
+from __future__ import absolute_import, division, print_function
+
+import astroid
+
+from pylint.extensions.docparams import DocstringParameterChecker
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+
+class TestDocstringCheckerRaise(CheckerTestCase):
+    """Tests for pylint_plugin.RaiseDocChecker"""
+    CHECKER_CLASS = DocstringParameterChecker
+
+    def test_ignores_no_docstring(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            raise RuntimeError('hi') #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_ignores_unknown_style(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring."""
+            raise RuntimeError('hi')
+        ''')
+        raise_node = node.body[0]
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    @set_config(accept_no_raise_doc=False)
+    def test_warns_unknown_style(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring."""
+            raise RuntimeError('hi')
+        ''')
+        raise_node = node.body[0]
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=node,
+                args=('RuntimeError', ))):
+            self.checker.visit_raise(raise_node)
+
+    def test_find_missing_sphinx_raises(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :raises NameError: Never
+            """
+            raise RuntimeError('hi')
+            raise NameError('hi')
+        ''')
+        raise_node = node.body[0]
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=node,
+                args=('RuntimeError', ))):
+            self.checker.visit_raise(raise_node)
+
+    def test_find_missing_google_raises(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Raises:
+                NameError: Never
+            """
+            raise RuntimeError('hi')
+            raise NameError('hi')
+        ''')
+        raise_node = node.body[0]
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=node,
+                args=('RuntimeError', ))):
+            self.checker.visit_raise(raise_node)
+
+    def test_find_google_attr_raises_exact_exc(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a google docstring.
+
+            Raises:
+                re.error: Sometimes
+            """
+            import re
+            raise re.error('hi')  #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+        pass
+
+    def test_find_google_attr_raises_substr_exc(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a google docstring.
+
+            Raises:
+                re.error: Sometimes
+            """
+            from re import error
+            raise error('hi')  #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_find_valid_missing_google_attr_raises(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a google docstring.
+
+            Raises:
+                re.anothererror: Sometimes
+            """
+            from re import error
+            raise error('hi')
+        ''')
+        raise_node = node.body[1]
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=node,
+                args=('error', ))):
+            self.checker.visit_raise(raise_node)
+
+    def test_find_invalid_missing_google_attr_raises(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a google docstring.
+
+            Raises:
+                bogusmodule.error: Sometimes
+            """
+            from re import error
+            raise error('hi') #@
+        ''')
+        # pylint allows this to pass since the comparison between Raises and
+        # raise are based on the class name, not the qualified name.
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    @set_config(accept_no_raise_doc=False)
+    def test_google_raises_with_prefix(self):
+        code_snippet = '''
+        def my_func(self):
+            """This is a google docstring.
+
+            Raises:
+                {prefix}re.error: Sometimes
+            """
+            import re
+            raise re.error('hi') #@
+        '''
+        for prefix in ["~", "!"]:
+            raise_node = astroid.extract_node(code_snippet.format(prefix=prefix))
+            with self.assertNoMessages():
+                self.checker.visit_raise(raise_node)
+
+    def test_find_missing_numpy_raises(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Raises
+            ------
+            NameError
+                Never
+            """
+            raise RuntimeError('hi')
+            raise NameError('hi')
+        ''')
+        raise_node = node.body[0]
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=node,
+                args=('RuntimeError', ))):
+            self.checker.visit_raise(raise_node)
+
+    def test_ignore_spurious_sphinx_raises(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :raises RuntimeError: Always
+            :except NameError: Never
+            :raise OSError: Never
+            :exception ValueError: Never
+            """
+            raise RuntimeError('Blah') #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_find_all_sphinx_raises(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :raises RuntimeError: Always
+            :except NameError: Never
+            :raise OSError: Never
+            :exception ValueError: Never
+            """
+            raise RuntimeError('hi') #@
+            raise NameError('hi')
+            raise OSError(2, 'abort!')
+            raise ValueError('foo')
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_find_all_google_raises(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Raises:
+                RuntimeError: Always
+                NameError: Never
+            """
+            raise RuntimeError('hi') #@
+            raise NameError('hi')
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_find_all_numpy_raises(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Raises
+            ------
+            RuntimeError
+                Always
+            NameError
+                Never
+            """
+            raise RuntimeError('hi') #@
+            raise NameError('hi')
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_finds_rethrown_sphinx_raises(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :raises NameError: Sometimes
+            """
+            try:
+                fake_func()
+            except RuntimeError:
+                raise #@
+
+            raise NameError('hi')
+        ''')
+        node = raise_node.frame()
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=node,
+                args=('RuntimeError', ))):
+            self.checker.visit_raise(raise_node)
+
+    def test_find_rethrown_google_raises(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Raises:
+                NameError: Sometimes
+            """
+            try:
+                fake_func()
+            except RuntimeError:
+                raise #@
+
+            raise NameError('hi')
+        ''')
+        node = raise_node.frame()
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=node,
+                args=('RuntimeError', ))):
+            self.checker.visit_raise(raise_node)
+
+    def test_find_rethrown_numpy_raises(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Raises
+            ------
+            NameError
+                Sometimes
+            """
+            try:
+                fake_func()
+            except RuntimeError:
+                raise #@
+
+            raise NameError('hi')
+        ''')
+        node = raise_node.frame()
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=node,
+                args=('RuntimeError', ))):
+            self.checker.visit_raise(raise_node)
+
+    def test_finds_rethrown_sphinx_multiple_raises(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :raises NameError: Sometimes
+            """
+            try:
+                fake_func()
+            except (RuntimeError, ValueError):
+                raise #@
+
+            raise NameError('hi')
+        ''')
+        node = raise_node.frame()
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=node,
+                args=('RuntimeError, ValueError', ))):
+            self.checker.visit_raise(raise_node)
+
+    def test_find_rethrown_google_multiple_raises(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Raises:
+                NameError: Sometimes
+            """
+            try:
+                fake_func()
+            except (RuntimeError, ValueError):
+                raise #@
+
+            raise NameError('hi')
+        ''')
+        node = raise_node.frame()
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=node,
+                args=('RuntimeError, ValueError', ))):
+            self.checker.visit_raise(raise_node)
+
+    def test_find_rethrown_numpy_multiple_raises(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Raises
+            ------
+            NameError
+                Sometimes
+            """
+            try:
+                fake_func()
+            except (RuntimeError, ValueError):
+                raise #@
+
+            raise NameError('hi')
+        ''')
+        node = raise_node.frame()
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=node,
+                args=('RuntimeError, ValueError', ))):
+            self.checker.visit_raise(raise_node)
+
+    def test_ignores_caught_sphinx_raises(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :raises NameError: Sometimes
+            """
+            try:
+                raise RuntimeError('hi') #@
+            except RuntimeError:
+                pass
+
+            raise NameError('hi')
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_ignores_caught_google_raises(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Raises:
+                NameError: Sometimes
+            """
+            try:
+                raise RuntimeError('hi') #@
+            except RuntimeError:
+                pass
+
+            raise NameError('hi')
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_ignores_caught_numpy_raises(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a numpy docstring.
+
+            Raises
+            ------
+            NameError
+                Sometimes
+            """
+            try:
+                raise RuntimeError('hi') #@
+            except RuntimeError:
+                pass
+
+            raise NameError('hi')
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_find_numpy_attr_raises_exact_exc(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a numpy docstring.
+
+            Raises
+            ------
+            re.error
+                Sometimes
+            """
+            import re
+            raise re.error('hi')  #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+        pass
+
+    def test_find_numpy_attr_raises_substr_exc(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a numpy docstring.
+
+            Raises
+            ------
+            re.error
+                Sometimes
+            """
+            from re import error
+            raise error('hi')  #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_find_valid_missing_numpy_attr_raises(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a numpy docstring.
+
+            Raises
+            ------
+            re.anothererror
+                Sometimes
+            """
+            from re import error
+            raise error('hi')
+        ''')
+        raise_node = node.body[1]
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=node,
+                args=('error', ))):
+            self.checker.visit_raise(raise_node)
+
+    def test_find_invalid_missing_numpy_attr_raises(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a numpy docstring.
+
+            Raises
+            ------
+            bogusmodule.error
+                Sometimes
+            """
+            from re import error
+            raise error('hi') #@
+        ''')
+        # pylint allows this to pass since the comparison between Raises and
+        # raise are based on the class name, not the qualified name.
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    @set_config(accept_no_raise_doc=False)
+    def test_numpy_raises_with_prefix(self):
+        code_snippet = '''
+        def my_func(self):
+            """This is a numpy docstring.
+
+            Raises
+            ------
+            {prefix}re.error
+                Sometimes
+            """
+            import re
+            raise re.error('hi') #@
+        '''
+        for prefix in ["~", "!"]:
+            raise_node = astroid.extract_node(code_snippet.format(prefix=prefix))
+            with self.assertNoMessages():
+                self.checker.visit_raise(raise_node)
+
+    def test_find_missing_sphinx_raises_infer_from_instance(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :raises NameError: Never
+            """
+            my_exception = RuntimeError('hi')
+            raise my_exception #@
+            raise NameError('hi')
+        ''')
+        node = raise_node.frame()
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=node,
+                args=('RuntimeError', ))):
+            self.checker.visit_raise(raise_node)
+
+    def test_find_missing_sphinx_raises_infer_from_function(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :raises NameError: Never
+            """
+            def ex_func(val):
+                return RuntimeError(val)
+            raise ex_func('hi') #@
+            raise NameError('hi')
+        ''')
+        node = raise_node.frame()
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=node,
+                args=('RuntimeError', ))):
+            self.checker.visit_raise(raise_node)
+
+    def test_find_sphinx_attr_raises_exact_exc(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a sphinx docstring.
+
+            :raises re.error: Sometimes
+            """
+            import re
+            raise re.error('hi')  #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_find_sphinx_attr_raises_substr_exc(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a sphinx docstring.
+
+            :raises re.error: Sometimes
+            """
+            from re import error
+            raise error('hi')  #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_find_valid_missing_sphinx_attr_raises(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a sphinx docstring.
+
+            :raises re.anothererror: Sometimes
+            """
+            from re import error
+            raise error('hi')
+        ''')
+        raise_node = node.body[1]
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=node,
+                args=('error', ))):
+            self.checker.visit_raise(raise_node)
+
+    def test_find_invalid_missing_sphinx_attr_raises(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a sphinx docstring.
+
+            :raises bogusmodule.error: Sometimes
+            """
+            from re import error
+            raise error('hi') #@
+        ''')
+        # pylint allows this to pass since the comparison between Raises and
+        # raise are based on the class name, not the qualified name.
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    @set_config(accept_no_raise_doc=False)
+    def test_sphinx_raises_with_prefix(self):
+        code_snippet = '''
+        def my_func(self):
+            """This is a sphinx docstring.
+
+            :raises {prefix}re.error: Sometimes
+            """
+            import re
+            raise re.error('hi') #@
+        '''
+        for prefix in ["~", "!"]:
+            raise_node = astroid.extract_node(code_snippet.format(prefix=prefix))
+            with self.assertNoMessages():
+                self.checker.visit_raise(raise_node)
+
+
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_ignores_raise_uninferable(self):
+        raise_node = astroid.extract_node('''
+        from unknown import Unknown
+
+        def my_func(self):
+            """This is a docstring.
+
+            :raises NameError: Never
+            """
+            raise Unknown('hi') #@
+            raise NameError('hi')
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_ignores_returns_from_inner_functions(self):
+        raise_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :raises NameError: Never
+            """
+            def ex_func(val):
+                def inner_func(value):
+                    return OSError(value)
+                return RuntimeError(val)
+            raise ex_func('hi') #@
+            raise NameError('hi')
+        ''')
+        node = raise_node.frame()
+        with self.assertAddsMessages(
+            Message(
+                msg_id='missing-raises-doc',
+                node=node,
+                args=('RuntimeError', ))):
+            # we do NOT expect a warning about the OSError in inner_func!
+            self.checker.visit_raise(raise_node)
+
+    def test_ignores_returns_use_only_names(self):
+        raise_node = astroid.extract_node('''
+        def myfunc():
+            """This is a docstring
+
+            :raises NameError: Never
+            """
+            def inner_func():
+                return 42
+
+            raise inner_func() #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_ignores_returns_use_only_exception_instances(self):
+        raise_node = astroid.extract_node('''
+        def myfunc():
+            """This is a docstring
+
+            :raises MyException: Never
+            """
+            class MyException(Exception):
+                pass
+            def inner_func():
+                return MyException
+
+            raise inner_func() #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_no_crash_when_inferring_handlers(self):
+        raise_node = astroid.extract_node('''
+        import collections
+
+        def test():
+           """raises
+
+           :raise U: pass
+           """
+           try:
+              pass
+           except collections.U as exc:
+              raise #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_no_crash_when_cant_find_exception(self):
+        raise_node = astroid.extract_node('''
+        import collections
+
+        def test():
+           """raises
+
+           :raise U: pass
+           """
+           try:
+              pass
+           except U as exc:
+              raise #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
+
+    def test_no_error_notimplemented_documented(self):
+        raise_node = astroid.extract_node('''
+        def my_func():
+            """
+            Raises:
+                NotImplementedError: When called.
+            """
+            raise NotImplementedError #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_raise(raise_node)
diff --git a/tests/extensions/test_check_return_docs.py b/tests/extensions/test_check_return_docs.py
new file mode 100644
index 000000000..a6d12e501
--- /dev/null
+++ b/tests/extensions/test_check_return_docs.py
@@ -0,0 +1,615 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2016-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2016 Ashley Whetter <ashley@awhetter.co.uk>
+# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Unit tests for the return documentation checking in the
+`DocstringChecker` in :mod:`pylint.extensions.check_docs`
+"""
+from __future__ import absolute_import, division, print_function
+
+import astroid
+
+from pylint.extensions.docparams import DocstringParameterChecker
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+
+class TestDocstringCheckerReturn(CheckerTestCase):
+    """Tests for pylint_plugin.RaiseDocChecker"""
+    CHECKER_CLASS = DocstringParameterChecker
+
+    def test_ignores_no_docstring(self):
+        return_node = astroid.extract_node('''
+        def my_func(self):
+            return False #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_return(return_node)
+
+    @set_config(accept_no_return_doc=False)
+    def test_warns_no_docstring(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            return False
+        ''')
+        return_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-return-doc', node=node),
+                Message(msg_id='missing-return-type-doc', node=node)):
+            self.checker.visit_return(return_node)
+
+    def test_ignores_unknown_style(self):
+        return_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring."""
+            return False #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_return(return_node)
+
+    def test_warn_partial_sphinx_returns(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :returns: Always False
+            """
+            return False
+        ''')
+        return_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-return-type-doc', node=node)):
+            self.checker.visit_return(return_node)
+
+    def test_sphinx_returns_annotations(self):
+        node = astroid.extract_node('''
+        def my_func(self) -> bool:
+            """This is a docstring.
+
+            :returns: Always False
+            """
+            return False
+        ''')
+        return_node = node.body[0]
+        with self.assertNoMessages():
+            self.checker.visit_return(return_node)
+
+    def test_sphinx_missing_return_type_with_annotations(self):
+        node = astroid.extract_node('''
+           def my_func(self) -> bool:
+               """This is a docstring.
+
+               :returns: Always False
+               """
+               return False
+           ''')
+        return_node = node.body[0]
+        with self.assertNoMessages():
+            self.checker.visit_return(return_node)
+
+
+    def test_warn_partial_sphinx_returns_type(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :rtype: bool
+            """
+            return False
+        ''')
+        return_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-return-doc', node=node)):
+            self.checker.visit_return(return_node)
+
+    def test_warn_missing_sphinx_returns(self):
+        node = astroid.extract_node('''
+        def my_func(self, doc_type):
+            """This is a docstring.
+
+            :param doc_type: Sphinx
+            :type doc_type: str
+            """
+            return False
+        ''')
+        return_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-return-doc', node=node),
+                Message(msg_id='missing-return-type-doc', node=node)):
+            self.checker.visit_return(return_node)
+
+    def test_warn_partial_google_returns(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns:
+                Always False
+            """
+            return False
+        ''')
+        return_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-return-type-doc', node=node)):
+            self.checker.visit_return(return_node)
+
+    def test_warn_partial_google_returns_type(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns:
+                bool:
+            """
+            return False
+        ''')
+        return_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-return-doc', node=node)):
+            self.checker.visit_return(return_node)
+
+    def test_warn_missing_google_returns(self):
+        node = astroid.extract_node('''
+        def my_func(self, doc_type):
+            """This is a docstring.
+
+            Parameters:
+                doc_type (str): Google
+            """
+            return False
+        ''')
+        return_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-return-doc', node=node),
+                Message(msg_id='missing-return-type-doc', node=node)):
+            self.checker.visit_return(return_node)
+
+    def test_warn_partial_numpy_returns_type(self):
+        node = astroid.extract_node('''
+        def my_func(self, doc_type):
+            """This is a docstring.
+
+            Arguments
+            ---------
+            doc_type : str
+                Numpy
+
+            Returns
+            -------
+            bool
+            """
+            return False
+        ''')
+        return_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-return-doc', node=node)):
+            self.checker.visit_return(return_node)
+
+    def test_warn_missing_numpy_returns(self):
+        node = astroid.extract_node('''
+        def my_func(self, doc_type):
+            """This is a docstring.
+
+            Arguments
+            ---------
+            doc_type : str
+                Numpy
+            """
+            return False
+        ''')
+        return_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-return-doc', node=node),
+                Message(msg_id='missing-return-type-doc', node=node)):
+            self.checker.visit_return(return_node)
+
+    def test_find_sphinx_returns(self):
+        return_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :return: Always False
+            :rtype: bool
+            """
+            return False #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_return(return_node)
+
+    def test_find_google_returns(self):
+        return_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns:
+                bool: Always False
+            """
+            return False #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_return(return_node)
+
+    def test_find_numpy_returns(self):
+        return_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns
+            -------
+            bool
+                Always False
+            """
+            return False #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_return(return_node)
+
+    def test_find_numpy_returns_with_of(self):
+        return_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns
+            -------
+            :obj:`list` of :obj:`str`
+                List of strings
+            """
+            return ["hi", "bye"] #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_return(return_node)
+
+    def test_ignores_sphinx_return_none(self):
+        return_node = astroid.extract_node('''
+        def my_func(self, doc_type):
+            """This is a docstring.
+
+            :param doc_type: Sphinx
+            :type doc_type: str
+            """
+            return #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_return(return_node)
+
+    def test_ignores_google_return_none(self):
+        return_node = astroid.extract_node('''
+        def my_func(self, doc_type):
+            """This is a docstring.
+
+            Args:
+                doc_type (str): Google
+            """
+            return #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_return(return_node)
+
+    def test_ignores_numpy_return_none(self):
+        return_node = astroid.extract_node('''
+        def my_func(self, doc_type):
+            """This is a docstring.
+
+            Arguments
+            ---------
+            doc_type : str
+                Numpy
+            """
+            return #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_return(return_node)
+
+    def test_finds_sphinx_return_custom_class(self):
+        return_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :returns: An object
+            :rtype: :class:`mymodule.Class`
+            """
+            return mymodule.Class() #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_return(return_node)
+
+    def test_finds_google_return_custom_class(self):
+        return_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns:
+                mymodule.Class: An object
+            """
+            return mymodule.Class() #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_return(return_node)
+
+    def test_finds_numpy_return_custom_class(self):
+        return_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns
+            -------
+                mymodule.Class
+                    An object
+            """
+            return mymodule.Class() #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_return(return_node)
+
+    def test_finds_sphinx_return_list_of_custom_class(self):
+        return_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :returns: An object
+            :rtype: list(:class:`mymodule.Class`)
+            """
+            return [mymodule.Class()] #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_return(return_node)
+
+    def test_finds_google_return_list_of_custom_class(self):
+        return_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns:
+                list(:class:`mymodule.Class`): An object
+            """
+            return [mymodule.Class()] #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_return(return_node)
+
+    def test_finds_numpy_return_list_of_custom_class(self):
+        return_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns
+            -------
+                list(:class:`mymodule.Class`)
+                    An object
+            """
+            return [mymodule.Class()] #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_return(return_node)
+
+    def test_warns_sphinx_return_list_of_custom_class_without_description(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :rtype: list(:class:`mymodule.Class`)
+            """
+            return [mymodule.Class()]
+        ''')
+        return_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-return-doc', node=node)):
+            self.checker.visit_return(return_node)
+
+    def test_warns_google_return_list_of_custom_class_without_description(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns:
+                list(:class:`mymodule.Class`):
+            """
+            return [mymodule.Class()]
+        ''')
+        return_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-return-doc', node=node)):
+            self.checker.visit_return(return_node)
+
+    def test_warns_numpy_return_list_of_custom_class_without_description(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns
+            -------
+                list(:class:`mymodule.Class`)
+            """
+            return [mymodule.Class()]
+        ''')
+        return_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-return-doc', node=node)):
+            self.checker.visit_return(return_node)
+
+    def test_warns_sphinx_redundant_return_doc(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :returns: One
+            """
+            return None
+        ''')
+        with self.assertAddsMessages(
+                Message(msg_id='redundant-returns-doc', node=node)):
+            self.checker.visit_functiondef(node)
+
+    def test_warns_sphinx_redundant_rtype_doc(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :rtype: int
+            """
+            return None
+        ''')
+        with self.assertAddsMessages(
+                Message(msg_id='redundant-returns-doc', node=node)):
+            self.checker.visit_functiondef(node)
+
+    def test_warns_google_redundant_return_doc(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns:
+                One
+            """
+            return None
+        ''')
+        with self.assertAddsMessages(
+                Message(msg_id='redundant-returns-doc', node=node)):
+            self.checker.visit_functiondef(node)
+
+    def test_warns_google_redundant_rtype_doc(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns:
+                int:
+            """
+            return None
+        ''')
+        with self.assertAddsMessages(
+                Message(msg_id='redundant-returns-doc', node=node)):
+            self.checker.visit_functiondef(node)
+
+    def test_warns_numpy_redundant_return_doc(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns
+            -------
+                int
+                    One
+            """
+            return None
+        ''')
+        with self.assertAddsMessages(
+                Message(msg_id='redundant-returns-doc', node=node)):
+            self.checker.visit_functiondef(node)
+
+    def test_warns_numpy_redundant_rtype_doc(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns
+            -------
+                int
+            """
+            return None
+        ''')
+        with self.assertAddsMessages(
+                Message(msg_id='redundant-returns-doc', node=node)):
+            self.checker.visit_functiondef(node)
+
+    def test_ignores_sphinx_redundant_return_doc_multiple_returns(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :returns: One
+            :rtype: int
+
+            :returns: None sometimes
+            :rtype: None
+            """
+            if a_func():
+                return None
+            return 1
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_ignores_google_redundant_return_doc_multiple_returns(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns:
+                int or None: One, or sometimes None.
+            """
+            if a_func():
+                return None
+            return 1
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_ignores_numpy_redundant_return_doc_multiple_returns(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns
+            -------
+                int
+                    One
+                None
+                    Sometimes
+            """
+            if a_func():
+                return None
+            return 1
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_ignore_sphinx_redundant_return_doc_yield(self):
+        node = astroid.extract_node('''
+        def my_func_with_yield(self):
+            """This is a docstring.
+
+            :returns: One
+            :rtype: generator
+            """
+            for value in range(3):
+                yield value
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_warns_google_redundant_return_doc_yield(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns:
+                int: One
+            """
+            yield 1
+        ''')
+        with self.assertAddsMessages(
+                Message(msg_id='redundant-returns-doc', node=node)):
+            self.checker.visit_functiondef(node)
+
+    def test_warns_numpy_redundant_return_doc_yield(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Returns
+            -------
+                int
+                    One
+            """
+            yield 1
+        ''')
+        with self.assertAddsMessages(
+                Message(msg_id='redundant-returns-doc', node=node)):
+            self.checker.visit_functiondef(node)
diff --git a/tests/extensions/test_check_yields_docs.py b/tests/extensions/test_check_yields_docs.py
new file mode 100644
index 000000000..85c75c02d
--- /dev/null
+++ b/tests/extensions/test_check_yields_docs.py
@@ -0,0 +1,397 @@
+# Copyright (c) 2016-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2016 Ashley Whetter <ashley@awhetter.co.uk>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Unit tests for the yield documentation checking in the
+`DocstringChecker` in :mod:`pylint.extensions.check_docs`
+"""
+from __future__ import absolute_import, division, print_function
+
+import astroid
+
+from pylint.extensions.docparams import DocstringParameterChecker
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+
+class TestDocstringCheckerYield(CheckerTestCase):
+    """Tests for pylint_plugin.RaiseDocChecker"""
+    CHECKER_CLASS = DocstringParameterChecker
+
+    def test_ignores_no_docstring(self):
+        yield_node = astroid.extract_node('''
+        def my_func(self):
+            yield False #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_yield(yield_node)
+
+    @set_config(accept_no_yields_doc=False)
+    def test_warns_no_docstring(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            yield False
+        ''')
+        yield_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-yield-doc', node=node),
+                Message(msg_id='missing-yield-type-doc', node=node)):
+            self.checker.visit_yield(yield_node)
+
+    def test_ignores_unknown_style(self):
+        yield_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring."""
+            yield False #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_yield(yield_node)
+
+    def test_warn_partial_sphinx_yields(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :returns: Always False
+            """
+            yield False
+        ''')
+        yield_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-yield-type-doc', node=node)):
+            self.checker.visit_yield(yield_node)
+
+    def test_warn_partial_sphinx_yields_type(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :rtype: bool
+            """
+            yield False
+        ''')
+        yield_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-yield-doc', node=node)):
+            self.checker.visit_yield(yield_node)
+
+    def test_warn_missing_sphinx_yields(self):
+        node = astroid.extract_node('''
+        def my_func(self, doc_type):
+            """This is a docstring.
+
+            :param doc_type: Sphinx
+            :type doc_type: str
+            """
+            yield False
+        ''')
+        yield_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-yield-doc', node=node),
+                Message(msg_id='missing-yield-type-doc', node=node)):
+            self.checker.visit_yield(yield_node)
+
+    def test_warn_partial_google_yields(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Yields:
+                Always False
+            """
+            yield False
+        ''')
+        yield_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-yield-type-doc', node=node)):
+            self.checker.visit_yield(yield_node)
+
+    def test_warn_partial_google_yields_type(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Yields:
+                bool:
+            """
+            yield False
+        ''')
+        yield_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-yield-doc', node=node)):
+            self.checker.visit_yield(yield_node)
+
+    def test_warn_missing_google_yields(self):
+        node = astroid.extract_node('''
+        def my_func(self, doc_type):
+            """This is a docstring.
+
+            Parameters:
+                doc_type (str): Google
+            """
+            yield False
+        ''')
+        yield_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-yield-doc', node=node),
+                Message(msg_id='missing-yield-type-doc', node=node)):
+            self.checker.visit_yield(yield_node)
+
+    def test_warn_missing_numpy_yields(self):
+        node = astroid.extract_node('''
+        def my_func(self, doc_type):
+            """This is a docstring.
+
+            Arguments
+            ---------
+            doc_type : str
+                Numpy
+            """
+            yield False
+        ''')
+        yield_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-yield-doc', node=node),
+                Message(msg_id='missing-yield-type-doc', node=node)):
+            self.checker.visit_yield(yield_node)
+
+    def test_find_sphinx_yields(self):
+        yield_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :return: Always False
+            :rtype: bool
+            """
+            yield False #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_yield(yield_node)
+
+    def test_find_google_yields(self):
+        yield_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Yields:
+                bool: Always False
+            """
+            yield False #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_yield(yield_node)
+
+    def test_find_numpy_yields(self):
+        yield_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Yields
+            -------
+            bool
+                Always False
+            """
+            yield False #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_yield(yield_node)
+
+    def test_finds_sphinx_yield_custom_class(self):
+        yield_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :returns: An object
+            :rtype: :class:`mymodule.Class`
+            """
+            yield mymodule.Class() #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_yield(yield_node)
+
+    def test_finds_google_yield_custom_class(self):
+        yield_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Yields:
+                mymodule.Class: An object
+            """
+            yield mymodule.Class() #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_yield(yield_node)
+
+    def test_finds_numpy_yield_custom_class(self):
+        yield_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Yields
+            -------
+                mymodule.Class
+                    An object
+            """
+            yield mymodule.Class() #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_yield(yield_node)
+
+    def test_finds_sphinx_yield_list_of_custom_class(self):
+        yield_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :returns: An object
+            :rtype: list(:class:`mymodule.Class`)
+            """
+            yield [mymodule.Class()] #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_yield(yield_node)
+
+    def test_finds_google_yield_list_of_custom_class(self):
+        yield_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Yields:
+                list(:class:`mymodule.Class`): An object
+            """
+            yield [mymodule.Class()] #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_yield(yield_node)
+
+    def test_finds_numpy_yield_list_of_custom_class(self):
+        yield_node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Yields
+            -------
+                list(:class:`mymodule.Class`)
+                    An object
+            """
+            yield [mymodule.Class()] #@
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_yield(yield_node)
+
+    def test_warns_sphinx_yield_list_of_custom_class_without_description(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            :rtype: list(:class:`mymodule.Class`)
+            """
+            yield [mymodule.Class()]
+        ''')
+        yield_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-yield-doc', node=node)):
+            self.checker.visit_yield(yield_node)
+
+    def test_warns_google_yield_list_of_custom_class_without_description(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Yields:
+                list(:class:`mymodule.Class`):
+            """
+            yield [mymodule.Class()]
+        ''')
+        yield_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-yield-doc', node=node)):
+            self.checker.visit_yield(yield_node)
+
+    def test_warns_numpy_yield_list_of_custom_class_without_description(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Yields
+            -------
+                list(:class:`mymodule.Class`)
+            """
+            yield [mymodule.Class()]
+        ''')
+        yield_node = node.body[0]
+        with self.assertAddsMessages(
+                Message(msg_id='missing-yield-doc', node=node)):
+            self.checker.visit_yield(yield_node)
+
+    # No such thing as redundant yield documentation for sphinx because it
+    # doesn't support yield documentation
+
+    def test_ignores_google_redundant_yield_doc_multiple_yields(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Yields:
+                int or None: One, or sometimes None.
+            """
+            if a_func():
+                yield None
+            yield 1
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_ignores_numpy_redundant_yield_doc_multiple_yields(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Yields
+            -------
+                int
+                    One
+                None
+                    Sometimes
+            """
+            if a_func():
+                yield None
+            yield 1
+        ''')
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    # No such thing as redundant yield documentation for sphinx because it
+    # doesn't support yield documentation
+
+    def test_warns_google_redundant_yield_doc_return(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Yields:
+                int: One
+            """
+            return 1
+        ''')
+        with self.assertAddsMessages(
+                Message(msg_id='redundant-yields-doc', node=node)):
+            self.checker.visit_functiondef(node)
+
+    def test_warns_numpy_redundant_yield_doc_return(self):
+        node = astroid.extract_node('''
+        def my_func(self):
+            """This is a docstring.
+
+            Yields
+            -------
+                int
+                    One
+            """
+            return 1
+        ''')
+        with self.assertAddsMessages(
+                Message(msg_id='redundant-yields-doc', node=node)):
+            self.checker.visit_functiondef(node)
diff --git a/tests/extensions/test_comparetozero.py b/tests/extensions/test_comparetozero.py
new file mode 100644
index 000000000..ebe4a466a
--- /dev/null
+++ b/tests/extensions/test_comparetozero.py
@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2016 Alexander Todorov <atodorov@otb.bg>
+# Copyright (c) 2016 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2017 Claudiu Popa <pcmanticore@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.emptystring
+"""
+
+import os
+import os.path as osp
+import unittest
+
+from pylint import checkers
+from pylint.extensions.comparetozero import CompareToZeroChecker
+from pylint.lint import PyLinter
+from pylint.reporters import BaseReporter
+
+
+class CompareToZeroTestReporter(BaseReporter):
+
+    def handle_message(self, msg):
+        self.messages.append(msg)
+
+    def on_set_current_module(self, module, filepath):
+        self.messages = []
+
+
+class CompareToZeroUsedTC(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls._linter = PyLinter()
+        cls._linter.set_reporter(CompareToZeroTestReporter())
+        checkers.initialize(cls._linter)
+        cls._linter.register_checker(CompareToZeroChecker(cls._linter))
+        cls._linter.disable('I')
+
+    def test_comparetozero_message(self):
+        elif_test = osp.join(osp.dirname(osp.abspath(__file__)), 'data',
+                             'compare_to_zero.py')
+        self._linter.check([elif_test])
+        msgs = self._linter.reporter.messages
+        self.assertEqual(len(msgs), 4)
+        for msg in msgs:
+            self.assertEqual(msg.symbol, 'compare-to-zero')
+            self.assertEqual(msg.msg, 'Avoid comparisons to zero')
+        self.assertEqual(msgs[0].line, 6)
+        self.assertEqual(msgs[1].line, 9)
+        self.assertEqual(msgs[2].line, 12)
+        self.assertEqual(msgs[3].line, 15)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/extensions/test_docstyle.py b/tests/extensions/test_docstyle.py
new file mode 100644
index 000000000..cad929d31
--- /dev/null
+++ b/tests/extensions/test_docstyle.py
@@ -0,0 +1,52 @@
+# Copyright (c) 2016-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016-2017 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Luis Escobar <lescobar@vauxoo.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.check_docstring
+"""
+
+from os.path import abspath, dirname, join
+
+import pytest
+
+from pylint.extensions.docstyle import DocStringStyleChecker
+
+EXPECTED_MSGS = [
+    'First line empty in function docstring',
+    'First line empty in class docstring',
+    'First line empty in method docstring',
+    'Bad docstring quotes in method, expected """, given \'\'\'',
+    'Bad docstring quotes in method, expected """, given "',
+    'Bad docstring quotes in method, expected """, given \'',
+    'Bad docstring quotes in method, expected """, given \'',
+]
+
+EXPECTED_SYMBOLS = [
+    'docstring-first-line-empty',
+    'docstring-first-line-empty',
+    'docstring-first-line-empty',
+    'bad-docstring-quotes',
+    'bad-docstring-quotes',
+    'bad-docstring-quotes',
+    'bad-docstring-quotes',
+]
+
+
+@pytest.fixture(scope="module")
+def checker(checker):
+    return DocStringStyleChecker
+
+
+def test_docstring_message(linter):
+    docstring_test = join(dirname(abspath(__file__)), 'data', 'docstring.py')
+    linter.check([docstring_test])
+    msgs = linter.reporter.messages
+    assert len(msgs) == 7
+    for msg, expected_symbol, expected_msg in zip(msgs,
+                                                  EXPECTED_SYMBOLS,
+                                                  EXPECTED_MSGS):
+        assert msg.symbol == expected_symbol
+        assert msg.msg == expected_msg
diff --git a/tests/extensions/test_elseif_used.py b/tests/extensions/test_elseif_used.py
new file mode 100644
index 000000000..44926689d
--- /dev/null
+++ b/tests/extensions/test_elseif_used.py
@@ -0,0 +1,33 @@
+# Copyright (c) 2015-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2016-2017 Derek Gustafson <degustaf@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.check_elif
+"""
+
+import os.path as osp
+
+import pytest
+
+from pylint.extensions.check_elif import ElseifUsedChecker
+
+
+@pytest.fixture(scope="module")
+def checker(checker):
+    return ElseifUsedChecker
+
+
+def test_elseif_message(linter):
+    elif_test = osp.join(osp.dirname(osp.abspath(__file__)), 'data',
+                         'elif.py')
+    linter.check([elif_test])
+    msgs = linter.reporter.messages
+    assert len(msgs) == 2
+    for msg in msgs:
+        assert msg.symbol == 'else-if-used'
+        assert msg.msg == 'Consider using "elif" instead of "else if"'
+    assert msgs[0].line == 9
+    assert msgs[1].line == 21
diff --git a/tests/extensions/test_emptystring.py b/tests/extensions/test_emptystring.py
new file mode 100644
index 000000000..c7ff30b50
--- /dev/null
+++ b/tests/extensions/test_emptystring.py
@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2016 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2016 Alexander Todorov <atodorov@otb.bg>
+# Copyright (c) 2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2017 Derek Gustafson <degustaf@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.emptystring
+"""
+
+import os.path as osp
+
+import pytest
+
+from pylint.extensions.emptystring import CompareToEmptyStringChecker
+
+
+@pytest.fixture(scope='module')
+def checker(checker):
+    return CompareToEmptyStringChecker
+
+
+@pytest.fixture(scope='module')
+def disable(disable):
+    return ['I']
+
+
+def test_emptystring_message(linter):
+    elif_test = osp.join(osp.dirname(osp.abspath(__file__)), 'data',
+                         'empty_string_comparison.py')
+    linter.check([elif_test])
+    msgs = linter.reporter.messages
+    expected_lineno = [6, 9, 12, 15]
+    assert len(msgs) == len(expected_lineno)
+    for msg, lineno in zip(msgs, expected_lineno):
+        assert msg.symbol == 'compare-to-empty-string'
+        assert msg.msg == 'Avoid comparisons to empty string'
+        assert msg.line == lineno
diff --git a/tests/extensions/test_overlapping_exceptions.py b/tests/extensions/test_overlapping_exceptions.py
new file mode 100644
index 000000000..d001b2053
--- /dev/null
+++ b/tests/extensions/test_overlapping_exceptions.py
@@ -0,0 +1,69 @@
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.overlapping_exceptions
+"""
+
+from os.path import dirname, join
+from sys import version_info
+
+import pytest
+
+from pylint.extensions.overlapping_exceptions import OverlappingExceptionsChecker
+
+
+@pytest.fixture(scope='module')
+def checker(checker):
+    return OverlappingExceptionsChecker
+
+
+@pytest.fixture(scope='module')
+def disable(disable):
+    return ['I']
+
+
+def test_overlapping_exceptions(linter):
+    test = join(dirname(__file__), 'data', 'overlapping_exceptions.py')
+    linter.check([test])
+    msgs = linter.reporter.messages
+
+    expected = [
+        (13, 'Overlapping exceptions (SomeException and SomeException are the same)'),
+        (18, 'Overlapping exceptions (SomeException is an ancestor class of SubclassException)'),
+        (23, 'Overlapping exceptions (SomeException and AliasException are the same)'),
+        (28, 'Overlapping exceptions (AliasException is an ancestor class of SubclassException)'),
+        (34, 'Overlapping exceptions (SomeException and AliasException are the same)'),
+        (34, 'Overlapping exceptions (SomeException is an ancestor class of SubclassException)'),
+        (34, 'Overlapping exceptions (AliasException is an ancestor class of SubclassException)'),
+        (39, 'Overlapping exceptions (ArithmeticError is an ancestor class of FloatingPointError)'),
+        (44, 'Overlapping exceptions (ValueError is an ancestor class of UnicodeDecodeError)')
+    ]
+
+    assert len(msgs) == len(expected)
+    for msg, exp in zip(msgs, expected):
+        assert msg.msg_id == 'W0714'
+        assert msg.symbol == 'overlapping-except'
+        assert msg.category == 'warning'
+        assert (msg.line, msg.msg) == exp
+
+
+@pytest.mark.skipif(version_info < (3, 3),
+                    reason="not relevant to Python version")
+def test_overlapping_exceptions_py33(linter):
+    """From Python 3.3 both IOError and socket.error are aliases for OSError."""
+    test = join(dirname(__file__), 'data', 'overlapping_exceptions_py33.py')
+    linter.check([test])
+    msgs = linter.reporter.messages
+
+    expected = [
+        (7,  'Overlapping exceptions (IOError and OSError are the same)'),
+        (12, 'Overlapping exceptions (socket.error and OSError are the same)'),
+        (17, 'Overlapping exceptions (socket.error is an ancestor class of ConnectionError)'),
+    ]
+
+    assert len(msgs) == len(expected)
+    for msg, exp in zip(msgs, expected):
+        assert msg.msg_id == 'W0714'
+        assert msg.symbol == 'overlapping-except'
+        assert msg.category == 'warning'
+        assert (msg.line, msg.msg) == exp
diff --git a/tests/extensions/test_redefined.py b/tests/extensions/test_redefined.py
new file mode 100644
index 000000000..da35b0625
--- /dev/null
+++ b/tests/extensions/test_redefined.py
@@ -0,0 +1,49 @@
+# Copyright (c) 2016-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016-2017 Derek Gustafson <degustaf@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Tests for the pylint checker in :mod:`pylint.extensions.check_elif
+"""
+
+import os.path as osp
+
+import pytest
+
+from pylint.extensions.redefined_variable_type import MultipleTypesChecker
+from pylint.lint import fix_import_path
+
+EXPECTED = [
+    "Redefinition of self.var1 type from int to float",
+    "Redefinition of a_str type from bool to float",
+    "Redefinition of var type from int to str",
+    "Redefinition of myint type from int to bool",
+    "Redefinition of _OK type from bool to str",
+    "Redefinition of instance type from redefined.MyClass to bool",
+    "Redefinition of SOME_FLOAT type from float to int",
+    "Redefinition of var3 type from str to int",
+    "Redefinition of var type from bool to int",
+    "Redefinition of var4 type from float to str",
+]
+
+
+@pytest.fixture(scope="module")
+def checker(checker):
+    return MultipleTypesChecker
+
+
+@pytest.fixture(scope="module")
+def disable(disable):
+    return ["I"]
+
+
+def test_types_redefined(linter):
+    elif_test = osp.join(osp.dirname(osp.abspath(__file__)), "data", "redefined.py")
+    with fix_import_path([elif_test]):
+        linter.check([elif_test])
+    msgs = sorted(linter.reporter.messages, key=lambda item: item.line)
+    assert len(msgs) == 10
+    for msg, expected in zip(msgs, EXPECTED):
+        assert msg.symbol == "redefined-variable-type"
+        assert msg.msg == expected
diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/__init__.py
diff --git a/tests/functional/abstract_abc_methods.py b/tests/functional/abstract_abc_methods.py
new file mode 100644
index 000000000..d174669a5
--- /dev/null
+++ b/tests/functional/abstract_abc_methods.py
@@ -0,0 +1,17 @@
+""" This should not warn about `prop` being abstract in Child """

+# pylint: disable=too-few-public-methods, no-absolute-import,metaclass-assignment, useless-object-inheritance

+

+import abc

+

+class Parent(object):

+    """Abstract Base Class """

+    __metaclass__ = abc.ABCMeta

+

+    @property

+    @abc.abstractmethod

+    def prop(self):

+        """ Abstract """

+

+class Child(Parent):

+    """ No warning for the following. """

+    prop = property(lambda self: 1)

diff --git a/tests/functional/abstract_class_instantiated_in_class.py b/tests/functional/abstract_class_instantiated_in_class.py
new file mode 100644
index 000000000..a91fde579
--- /dev/null
+++ b/tests/functional/abstract_class_instantiated_in_class.py
@@ -0,0 +1,20 @@
+"""Don't warn if the class is instantiated in its own body."""

+# pylint: disable=missing-docstring, useless-object-inheritance

+

+

+import abc

+

+import six

+

+

+@six.add_metaclass(abc.ABCMeta)

+class Ala(object):

+

+    @abc.abstractmethod

+    def bala(self):

+        pass

+

+    @classmethod

+    def portocala(cls):

+        instance = cls()

+        return instance

diff --git a/tests/functional/abstract_class_instantiated_py2.py b/tests/functional/abstract_class_instantiated_py2.py
new file mode 100644
index 000000000..ba34d2641
--- /dev/null
+++ b/tests/functional/abstract_class_instantiated_py2.py
@@ -0,0 +1,82 @@
+"""Check that instantiating a class with
+`abc.ABCMeta` as metaclass fails if it defines
+abstract methods.
+"""
+
+# pylint: disable=too-few-public-methods, missing-docstring, useless-object-inheritance
+# pylint: disable=no-absolute-import, metaclass-assignment
+# pylint: disable=abstract-method, import-error, wildcard-import
+
+import abc
+from abc import ABCMeta
+from lala import Bala
+
+
+class GoodClass(object):
+    __metaclass__ = abc.ABCMeta
+
+class SecondGoodClass(object):
+    __metaclass__ = abc.ABCMeta
+
+    def test(self):
+        """ do nothing. """
+
+class ThirdGoodClass(object):
+    __metaclass__ = abc.ABCMeta
+
+    def test(self):
+        raise NotImplementedError()
+
+class FourthGoodClass(object):
+    __metaclass__ = ABCMeta
+
+class BadClass(object):
+    __metaclass__ = abc.ABCMeta
+
+    @abc.abstractmethod
+    def test(self):
+        """ do nothing. """
+
+class SecondBadClass(object):
+    __metaclass__ = abc.ABCMeta
+
+    @property
+    @abc.abstractmethod
+    def test(self):
+        """ do nothing. """
+
+class ThirdBadClass(object):
+    __metaclass__ = ABCMeta
+
+    @abc.abstractmethod
+    def test(self):
+        pass
+
+class FourthBadClass(ThirdBadClass):
+    pass
+
+
+class SomeMetaclass(object):
+    __metaclass__ = ABCMeta
+
+    @abc.abstractmethod
+    def prop(self):
+        pass
+
+class FifthGoodClass(SomeMetaclass):
+    """Don't consider this abstract if some attributes are
+    there, but can't be inferred.
+    """
+    prop = Bala # missing
+
+
+def main():
+    """ do nothing """
+    GoodClass()
+    SecondGoodClass()
+    ThirdGoodClass()
+    FourthGoodClass()
+    BadClass() # [abstract-class-instantiated]
+    SecondBadClass() # [abstract-class-instantiated]
+    ThirdBadClass() # [abstract-class-instantiated]
+    FourthBadClass() # [abstract-class-instantiated]
diff --git a/tests/functional/abstract_class_instantiated_py2.rc b/tests/functional/abstract_class_instantiated_py2.rc
new file mode 100644
index 000000000..b11e16d54
--- /dev/null
+++ b/tests/functional/abstract_class_instantiated_py2.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/abstract_class_instantiated_py2.txt b/tests/functional/abstract_class_instantiated_py2.txt
new file mode 100644
index 000000000..1e4a72d09
--- /dev/null
+++ b/tests/functional/abstract_class_instantiated_py2.txt
@@ -0,0 +1,4 @@
+abstract-class-instantiated:79:main:Abstract class 'BadClass' with abstract methods instantiated

+abstract-class-instantiated:80:main:Abstract class 'SecondBadClass' with abstract methods instantiated

+abstract-class-instantiated:81:main:Abstract class 'ThirdBadClass' with abstract methods instantiated

+abstract-class-instantiated:82:main:Abstract class 'FourthBadClass' with abstract methods instantiated

diff --git a/tests/functional/abstract_class_instantiated_py3.py b/tests/functional/abstract_class_instantiated_py3.py
new file mode 100644
index 000000000..c027833e7
--- /dev/null
+++ b/tests/functional/abstract_class_instantiated_py3.py
@@ -0,0 +1,128 @@
+"""Check that instantiating a class with
+`abc.ABCMeta` as metaclass fails if it defines
+abstract methods.
+"""
+
+# pylint: disable=too-few-public-methods, missing-docstring
+# pylint: disable=abstract-method, import-error, useless-object-inheritance
+
+import abc
+import weakref
+from lala import Bala
+
+
+class GoodClass(object, metaclass=abc.ABCMeta):
+    pass
+
+class SecondGoodClass(object, metaclass=abc.ABCMeta):
+    def test(self):
+        """ do nothing. """
+
+class ThirdGoodClass(object, metaclass=abc.ABCMeta):
+    """ This should not raise the warning. """
+    def test(self):
+        raise NotImplementedError()
+
+class BadClass(object, metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def test(self):
+        """ do nothing. """
+
+class SecondBadClass(object, metaclass=abc.ABCMeta):
+    @property
+    @abc.abstractmethod
+    def test(self):
+        """ do nothing. """
+
+class ThirdBadClass(SecondBadClass):
+    pass
+
+
+class Structure(object, metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def __iter__(self):
+        pass
+    @abc.abstractmethod
+    def __len__(self):
+        pass
+    @abc.abstractmethod
+    def __contains__(self, _):
+        pass
+    @abc.abstractmethod
+    def __hash__(self):
+        pass
+
+class Container(Structure):
+    def __contains__(self, _):
+        pass
+
+class Sizable(Structure):
+    def __len__(self):
+        pass
+
+class Hashable(Structure):
+    __hash__ = 42
+
+
+class Iterator(Structure):
+    def keys(self): # pylint: disable=no-self-use
+        return iter([1, 2, 3])
+
+    __iter__ = keys
+
+class AbstractSizable(Structure):
+    @abc.abstractmethod
+    def length(self):
+        pass
+    __len__ = length
+
+class NoMroAbstractMethods(Container, Iterator, Sizable, Hashable):
+    pass
+
+class BadMroAbstractMethods(Container, Iterator, AbstractSizable):
+    pass
+
+class SomeMetaclass(metaclass=abc.ABCMeta):
+
+    @abc.abstractmethod
+    def prop(self):
+        pass
+
+class FourthGoodClass(SomeMetaclass):
+    """Don't consider this abstract if some attributes are
+    there, but can't be inferred.
+    """
+    prop = Bala # missing
+
+
+def main():
+    """ do nothing """
+    GoodClass()
+    SecondGoodClass()
+    ThirdGoodClass()
+    FourthGoodClass()
+    weakref.WeakKeyDictionary()
+    weakref.WeakValueDictionary()
+    NoMroAbstractMethods()
+
+    BadMroAbstractMethods() # [abstract-class-instantiated]
+    BadClass() # [abstract-class-instantiated]
+    SecondBadClass() # [abstract-class-instantiated]
+    ThirdBadClass() # [abstract-class-instantiated]
+
+
+if 1: # pylint: disable=using-constant-test
+    class FourthBadClass(object, metaclass=abc.ABCMeta):
+
+        def test(self):
+            pass
+else:
+    class FourthBadClass(object, metaclass=abc.ABCMeta):
+
+        @abc.abstractmethod
+        def test(self):
+            pass
+
+
+def main2():
+    FourthBadClass() # [abstract-class-instantiated]
diff --git a/tests/functional/abstract_class_instantiated_py3.rc b/tests/functional/abstract_class_instantiated_py3.rc
new file mode 100644
index 000000000..a2ab06c50
--- /dev/null
+++ b/tests/functional/abstract_class_instantiated_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/abstract_class_instantiated_py3.txt b/tests/functional/abstract_class_instantiated_py3.txt
new file mode 100644
index 000000000..585409091
--- /dev/null
+++ b/tests/functional/abstract_class_instantiated_py3.txt
@@ -0,0 +1,5 @@
+abstract-class-instantiated:108:main:Abstract class 'BadMroAbstractMethods' with abstract methods instantiated

+abstract-class-instantiated:109:main:Abstract class 'BadClass' with abstract methods instantiated

+abstract-class-instantiated:110:main:Abstract class 'SecondBadClass' with abstract methods instantiated

+abstract-class-instantiated:111:main:Abstract class 'ThirdBadClass' with abstract methods instantiated

+abstract-class-instantiated:128:main2:Abstract class 'FourthBadClass' with abstract methods instantiated

diff --git a/tests/functional/abstract_class_instantiated_py34.py b/tests/functional/abstract_class_instantiated_py34.py
new file mode 100644
index 000000000..e24ad28f1
--- /dev/null
+++ b/tests/functional/abstract_class_instantiated_py34.py
@@ -0,0 +1,19 @@
+"""

+Check that instantiating a class with `abc.ABCMeta` as ancestor fails if it

+defines abstract methods.

+"""

+

+# pylint: disable=too-few-public-methods, missing-docstring, no-init

+

+import abc

+

+

+

+class BadClass(abc.ABC):

+    @abc.abstractmethod

+    def test(self):

+        pass

+

+def main():

+    """ do nothing """

+    BadClass() # [abstract-class-instantiated]

diff --git a/tests/functional/abstract_class_instantiated_py34.rc b/tests/functional/abstract_class_instantiated_py34.rc
new file mode 100644
index 000000000..1fb7b8710
--- /dev/null
+++ b/tests/functional/abstract_class_instantiated_py34.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.4
\ No newline at end of file
diff --git a/tests/functional/abstract_class_instantiated_py34.txt b/tests/functional/abstract_class_instantiated_py34.txt
new file mode 100644
index 000000000..afee9756e
--- /dev/null
+++ b/tests/functional/abstract_class_instantiated_py34.txt
@@ -0,0 +1 @@
+abstract-class-instantiated:19:main:Abstract class 'BadClass' with abstract methods instantiated

diff --git a/tests/functional/abstract_method_py2.py b/tests/functional/abstract_method_py2.py
new file mode 100644
index 000000000..54fd1f952
--- /dev/null
+++ b/tests/functional/abstract_method_py2.py
@@ -0,0 +1,90 @@
+"""Test abstract-method warning."""
+from __future__ import print_function
+
+# pylint: disable=missing-docstring, no-init, no-self-use
+# pylint: disable=too-few-public-methods, useless-object-inheritance
+import abc
+
+class Abstract(object):
+    def aaaa(self):
+        """should be overridden in concrete class"""
+        raise NotImplementedError()
+
+    def bbbb(self):
+        """should be overridden in concrete class"""
+        raise NotImplementedError()
+
+
+class AbstractB(Abstract):
+    """Abstract class.
+
+    this class is checking that it does not output an error msg for
+    unimplemeted methods in abstract classes
+    """
+    def cccc(self):
+        """should be overridden in concrete class"""
+        raise NotImplementedError()
+
+class Concrete(Abstract): # [abstract-method]
+    """Concrete class"""
+
+    def aaaa(self):
+        """overidden form Abstract"""
+
+
+class Structure(object):
+    __metaclass__ = abc.ABCMeta
+
+    @abc.abstractmethod
+    def __iter__(self):
+        pass
+    @abc.abstractmethod
+    def __len__(self):
+        pass
+    @abc.abstractmethod
+    def __contains__(self, _):
+        pass
+    @abc.abstractmethod
+    def __hash__(self):
+        pass
+
+
+# +1: [abstract-method, abstract-method, abstract-method]
+class Container(Structure):
+    def __contains__(self, _):
+        pass
+
+
+# +1: [abstract-method, abstract-method, abstract-method]
+class Sizable(Structure):
+    def __len__(self):
+        pass
+
+
+# +1: [abstract-method, abstract-method, abstract-method]
+class Hashable(Structure):
+    __hash__ = 42
+
+
+# +1: [abstract-method, abstract-method, abstract-method]
+class Iterator(Structure):
+    def keys(self):
+        return iter([1, 2, 3])
+
+    __iter__ = keys
+
+
+class AbstractSizable(Structure):
+    @abc.abstractmethod
+    def length(self):
+        pass
+    __len__ = length
+
+
+class GoodComplexMRO(Container, Iterator, Sizable, Hashable):
+    pass
+
+
+# +1: [abstract-method, abstract-method, abstract-method]
+class BadComplexMro(Container, Iterator, AbstractSizable):
+    pass
diff --git a/tests/functional/abstract_method_py2.rc b/tests/functional/abstract_method_py2.rc
new file mode 100644
index 000000000..b11e16d54
--- /dev/null
+++ b/tests/functional/abstract_method_py2.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/abstract_method_py2.txt b/tests/functional/abstract_method_py2.txt
new file mode 100644
index 000000000..3f9d207e6
--- /dev/null
+++ b/tests/functional/abstract_method_py2.txt
@@ -0,0 +1,16 @@
+abstract-method:28:Concrete:"Method 'bbbb' is abstract in class 'Abstract' but is not overridden"

+abstract-method:53:Container:"Method '__hash__' is abstract in class 'Structure' but is not overridden"

+abstract-method:53:Container:"Method '__iter__' is abstract in class 'Structure' but is not overridden"

+abstract-method:53:Container:"Method '__len__' is abstract in class 'Structure' but is not overridden"

+abstract-method:59:Sizable:"Method '__contains__' is abstract in class 'Structure' but is not overridden"

+abstract-method:59:Sizable:"Method '__hash__' is abstract in class 'Structure' but is not overridden"

+abstract-method:59:Sizable:"Method '__iter__' is abstract in class 'Structure' but is not overridden"

+abstract-method:65:Hashable:"Method '__contains__' is abstract in class 'Structure' but is not overridden"

+abstract-method:65:Hashable:"Method '__iter__' is abstract in class 'Structure' but is not overridden"

+abstract-method:65:Hashable:"Method '__len__' is abstract in class 'Structure' but is not overridden"

+abstract-method:70:Iterator:"Method '__contains__' is abstract in class 'Structure' but is not overridden"

+abstract-method:70:Iterator:"Method '__hash__' is abstract in class 'Structure' but is not overridden"

+abstract-method:70:Iterator:"Method '__len__' is abstract in class 'Structure' but is not overridden"

+abstract-method:89:BadComplexMro:"Method '__hash__' is abstract in class 'Structure' but is not overridden"

+abstract-method:89:BadComplexMro:"Method '__len__' is abstract in class 'AbstractSizable' but is not overridden"

+abstract-method:89:BadComplexMro:"Method 'length' is abstract in class 'AbstractSizable' but is not overridden"

diff --git a/tests/functional/abstract_method_py3.py b/tests/functional/abstract_method_py3.py
new file mode 100644
index 000000000..f4e3dd568
--- /dev/null
+++ b/tests/functional/abstract_method_py3.py
@@ -0,0 +1,88 @@
+"""Test abstract-method warning."""
+from __future__ import print_function
+
+# pylint: disable=missing-docstring, no-init, no-self-use
+# pylint: disable=too-few-public-methods, useless-object-inheritance
+import abc
+
+class Abstract(object):
+    def aaaa(self):
+        """should be overridden in concrete class"""
+        raise NotImplementedError()
+
+    def bbbb(self):
+        """should be overridden in concrete class"""
+        raise NotImplementedError()
+
+
+class AbstractB(Abstract):
+    """Abstract class.
+
+    this class is checking that it does not output an error msg for
+    unimplemeted methods in abstract classes
+    """
+    def cccc(self):
+        """should be overridden in concrete class"""
+        raise NotImplementedError()
+
+class Concrete(Abstract): # [abstract-method]
+    """Concrete class"""
+
+    def aaaa(self):
+        """overidden form Abstract"""
+
+
+class Structure(object, metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def __iter__(self):
+        pass
+    @abc.abstractmethod
+    def __len__(self):
+        pass
+    @abc.abstractmethod
+    def __contains__(self, _):
+        pass
+    @abc.abstractmethod
+    def __hash__(self):
+        pass
+
+
+# +1: [abstract-method, abstract-method, abstract-method]
+class Container(Structure):
+    def __contains__(self, _):
+        pass
+
+
+# +1: [abstract-method, abstract-method, abstract-method]
+class Sizable(Structure):
+    def __len__(self):
+        pass
+
+
+# +1: [abstract-method, abstract-method, abstract-method]
+class Hashable(Structure):
+    __hash__ = 42
+
+
+# +1: [abstract-method, abstract-method, abstract-method]
+class Iterator(Structure):
+    def keys(self):
+        return iter([1, 2, 3])
+
+    __iter__ = keys
+
+
+class AbstractSizable(Structure):
+    @abc.abstractmethod
+    def length(self):
+        pass
+    __len__ = length
+
+
+class GoodComplexMRO(Container, Iterator, Sizable, Hashable):
+    pass
+
+
+# +1: [abstract-method, abstract-method, abstract-method]
+class BadComplexMro(Container, Iterator, AbstractSizable):
+    pass
diff --git a/tests/functional/abstract_method_py3.rc b/tests/functional/abstract_method_py3.rc
new file mode 100644
index 000000000..a2ab06c50
--- /dev/null
+++ b/tests/functional/abstract_method_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/abstract_method_py3.txt b/tests/functional/abstract_method_py3.txt
new file mode 100644
index 000000000..17f8abf4e
--- /dev/null
+++ b/tests/functional/abstract_method_py3.txt
@@ -0,0 +1,16 @@
+abstract-method:28:Concrete:"Method 'bbbb' is abstract in class 'Abstract' but is not overridden"

+abstract-method:51:Container:"Method '__hash__' is abstract in class 'Structure' but is not overridden"

+abstract-method:51:Container:"Method '__iter__' is abstract in class 'Structure' but is not overridden"

+abstract-method:51:Container:"Method '__len__' is abstract in class 'Structure' but is not overridden"

+abstract-method:57:Sizable:"Method '__contains__' is abstract in class 'Structure' but is not overridden"

+abstract-method:57:Sizable:"Method '__hash__' is abstract in class 'Structure' but is not overridden"

+abstract-method:57:Sizable:"Method '__iter__' is abstract in class 'Structure' but is not overridden"

+abstract-method:63:Hashable:"Method '__contains__' is abstract in class 'Structure' but is not overridden"

+abstract-method:63:Hashable:"Method '__iter__' is abstract in class 'Structure' but is not overridden"

+abstract-method:63:Hashable:"Method '__len__' is abstract in class 'Structure' but is not overridden"

+abstract-method:68:Iterator:"Method '__contains__' is abstract in class 'Structure' but is not overridden"

+abstract-method:68:Iterator:"Method '__hash__' is abstract in class 'Structure' but is not overridden"

+abstract-method:68:Iterator:"Method '__len__' is abstract in class 'Structure' but is not overridden"

+abstract-method:87:BadComplexMro:"Method '__hash__' is abstract in class 'Structure' but is not overridden"

+abstract-method:87:BadComplexMro:"Method '__len__' is abstract in class 'AbstractSizable' but is not overridden"

+abstract-method:87:BadComplexMro:"Method 'length' is abstract in class 'AbstractSizable' but is not overridden"

diff --git a/tests/functional/access_member_before_definition.py b/tests/functional/access_member_before_definition.py
new file mode 100644
index 000000000..d8a97b4c7
--- /dev/null
+++ b/tests/functional/access_member_before_definition.py
@@ -0,0 +1,40 @@
+# pylint: disable=missing-docstring,too-few-public-methods,invalid-name
+# pylint: disable=attribute-defined-outside-init, useless-object-inheritance
+
+class Aaaa(object):
+    """class with attributes defined in wrong order"""
+
+    def __init__(self):
+        var1 = self._var2 # [access-member-before-definition]
+        self._var2 = 3
+        self._var3 = var1
+
+
+class Bbbb(object):
+    A = 23
+    B = A
+
+    def __getattr__(self, attr):
+        try:
+            return self.__repo
+        except AttributeError:
+            self.__repo = attr
+            return attr
+
+
+    def catchme(self, attr):
+        """no AttributeError catched"""
+        try:
+            return self._repo # [access-member-before-definition]
+        except ValueError:
+            self._repo = attr
+            return attr
+
+
+class Mixin(object):
+
+    def test_mixin(self):
+        """Don't emit access-member-before-definition for mixin classes."""
+        if self.already_defined:
+            # pylint: disable=attribute-defined-outside-init
+            self.already_defined = None
diff --git a/tests/functional/access_member_before_definition.txt b/tests/functional/access_member_before_definition.txt
new file mode 100644
index 000000000..9b3ae697d
--- /dev/null
+++ b/tests/functional/access_member_before_definition.txt
@@ -0,0 +1,2 @@
+access-member-before-definition:8:Aaaa.__init__:Access to member '_var2' before its definition line 9

+access-member-before-definition:28:Bbbb.catchme:Access to member '_repo' before its definition line 30
\ No newline at end of file
diff --git a/tests/functional/access_to__name__.py b/tests/functional/access_to__name__.py
new file mode 100644
index 000000000..82dcdbe78
--- /dev/null
+++ b/tests/functional/access_to__name__.py
@@ -0,0 +1,21 @@
+# pylint: disable=too-few-public-methods, print-statement, useless-object-inheritance
+"""test access to __name__ gives undefined member on new/old class instances
+but not on new/old class object
+"""
+from __future__ import print_function
+
+class Aaaa:
+    """old class"""
+    def __init__(self):
+        print(self.__name__)  # [no-member]
+        print(self.__class__.__name__)
+
+class NewClass(object):
+    """new class"""
+
+    def __new__(cls, *args, **kwargs):
+        print('new', cls.__name__)
+        return object.__new__(cls, *args, **kwargs)
+
+    def __init__(self):
+        print('init', self.__name__)  # [no-member]
diff --git a/tests/functional/access_to__name__.txt b/tests/functional/access_to__name__.txt
new file mode 100644
index 000000000..29ec889fb
--- /dev/null
+++ b/tests/functional/access_to__name__.txt
@@ -0,0 +1,2 @@
+no-member:10:Aaaa.__init__:Instance of 'Aaaa' has no '__name__' member:INFERENCE
+no-member:21:NewClass.__init__:Instance of 'NewClass' has no '__name__' member:INFERENCE
diff --git a/tests/functional/access_to_protected_members.py b/tests/functional/access_to_protected_members.py
new file mode 100644
index 000000000..1c97a3b50
--- /dev/null
+++ b/tests/functional/access_to_protected_members.py
@@ -0,0 +1,59 @@
+# pylint: disable=too-few-public-methods, W0231, print-statement, useless-object-inheritance
+# pylint: disable=no-classmethod-decorator
+"""Test external access to protected class members."""
+from __future__ import print_function
+
+class MyClass(object):
+    """Class with protected members."""
+    _cls_protected = 5
+
+    def __init__(self, other):
+        MyClass._cls_protected = 6
+        self._protected = 1
+        self.public = other
+        self.attr = 0
+
+    def test(self):
+        """Docstring."""
+        self._protected += self._cls_protected
+        print(self.public._haha)  # [protected-access]
+
+    def clsmeth(cls):
+        """Docstring."""
+        cls._cls_protected += 1
+        print(cls._cls_protected)
+    clsmeth = classmethod(clsmeth)
+
+    def _private_method(self):
+        """Doing nothing."""
+
+
+class Subclass(MyClass):
+    """Subclass with protected members."""
+
+    def __init__(self):
+        MyClass._protected = 5
+        super(Subclass, self)._private_method()
+
+INST = Subclass()
+INST.attr = 1
+print(INST.attr)
+INST._protected = 2  # [protected-access]
+print(INST._protected)  # [protected-access]
+INST._cls_protected = 3  # [protected-access]
+print(INST._cls_protected)  # [protected-access]
+
+
+class Issue1031(object):
+    """Test for GitHub issue 1031"""
+    _attr = 1
+
+    def correct_access(self):
+        """Demonstrates correct access"""
+        return type(self)._attr
+
+    def incorrect_access(self):
+        """Demonstrates incorrect access"""
+        if self._attr == 1:
+            return type(INST)._protected  # [protected-access]
+        return None
diff --git a/tests/functional/access_to_protected_members.txt b/tests/functional/access_to_protected_members.txt
new file mode 100644
index 000000000..fb5c152e6
--- /dev/null
+++ b/tests/functional/access_to_protected_members.txt
@@ -0,0 +1,6 @@
+protected-access:19:MyClass.test:Access to a protected member _haha of a client class
+protected-access:41::Access to a protected member _protected of a client class
+protected-access:42::Access to a protected member _protected of a client class
+protected-access:43::Access to a protected member _cls_protected of a client class
+protected-access:44::Access to a protected member _cls_protected of a client class
+protected-access:58:Issue1031.incorrect_access:Access to a protected member _protected of a client class
diff --git a/tests/functional/anomalous_unicode_escape_py2.py b/tests/functional/anomalous_unicode_escape_py2.py
new file mode 100644
index 000000000..8f304fa47
--- /dev/null
+++ b/tests/functional/anomalous_unicode_escape_py2.py
@@ -0,0 +1,20 @@
+# pylint:disable=W0105, W0511
+"""Test for backslash escapes in byte vs unicode strings"""
+
+# Would be valid in Unicode, but probably not what you want otherwise
+BAD_UNICODE = b'\u0042'  # [anomalous-unicode-escape-in-string]
+BAD_LONG_UNICODE = b'\U00000042'  # [anomalous-unicode-escape-in-string]
+# +1:[anomalous-unicode-escape-in-string]
+BAD_NAMED_UNICODE = b'\N{GREEK SMALL LETTER ALPHA}'
+
+GOOD_UNICODE = u'\u0042'
+GOOD_LONG_UNICODE = u'\U00000042'
+GOOD_NAMED_UNICODE = u'\N{GREEK SMALL LETTER ALPHA}'
+
+
+# Valid raw strings
+RAW_BACKSLASHES = r'raw'
+RAW_UNICODE = ur"\u0062\n"
+
+# In a comment you can have whatever you want: \ \\ \n \m
+# even things that look like bad strings: "C:\Program Files"
diff --git a/tests/functional/anomalous_unicode_escape_py2.rc b/tests/functional/anomalous_unicode_escape_py2.rc
new file mode 100644
index 000000000..a2328edb7
--- /dev/null
+++ b/tests/functional/anomalous_unicode_escape_py2.rc
@@ -0,0 +1,2 @@
+[testoptions]

+max_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/anomalous_unicode_escape_py2.txt b/tests/functional/anomalous_unicode_escape_py2.txt
new file mode 100644
index 000000000..c242cb98f
--- /dev/null
+++ b/tests/functional/anomalous_unicode_escape_py2.txt
@@ -0,0 +1,3 @@
+anomalous-unicode-escape-in-string:5::"Anomalous Unicode escape in byte string: '\u'. String constant might be missing an r or u prefix."
+anomalous-unicode-escape-in-string:6::"Anomalous Unicode escape in byte string: '\U'. String constant might be missing an r or u prefix."
+anomalous-unicode-escape-in-string:8::"Anomalous Unicode escape in byte string: '\N'. String constant might be missing an r or u prefix."
diff --git a/tests/functional/anomalous_unicode_escape_py3.py b/tests/functional/anomalous_unicode_escape_py3.py
new file mode 100644
index 000000000..b8bfd0a96
--- /dev/null
+++ b/tests/functional/anomalous_unicode_escape_py3.py
@@ -0,0 +1,19 @@
+# pylint:disable=W0105, W0511
+"""Test for backslash escapes in byte vs unicode strings"""
+
+# Would be valid in Unicode, but probably not what you want otherwise
+BAD_UNICODE = b'\u0042'  # [anomalous-unicode-escape-in-string]
+BAD_LONG_UNICODE = b'\U00000042'  # [anomalous-unicode-escape-in-string]
+# +1:[anomalous-unicode-escape-in-string]
+BAD_NAMED_UNICODE = b'\N{GREEK SMALL LETTER ALPHA}'
+
+GOOD_UNICODE = u'\u0042'
+GOOD_LONG_UNICODE = u'\U00000042'
+GOOD_NAMED_UNICODE = u'\N{GREEK SMALL LETTER ALPHA}'
+
+
+# Valid raw strings
+RAW_BACKSLASHES = r'raw'
+
+# In a comment you can have whatever you want: \ \\ \n \m
+# even things that look like bad strings: "C:\Program Files"
diff --git a/tests/functional/anomalous_unicode_escape_py3.rc b/tests/functional/anomalous_unicode_escape_py3.rc
new file mode 100644
index 000000000..8c6eb56c4
--- /dev/null
+++ b/tests/functional/anomalous_unicode_escape_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]

+min_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/anomalous_unicode_escape_py3.txt b/tests/functional/anomalous_unicode_escape_py3.txt
new file mode 100644
index 000000000..d2c5d10ed
--- /dev/null
+++ b/tests/functional/anomalous_unicode_escape_py3.txt
@@ -0,0 +1,3 @@
+anomalous-unicode-escape-in-string:5::"Anomalous Unicode escape in byte string: '\u'. String constant might be missing an r or u prefix."
+anomalous-unicode-escape-in-string:6::"Anomalous Unicode escape in byte string: '\U'. String constant might be missing an r or u prefix."
+anomalous-unicode-escape-in-string:8::"Anomalous Unicode escape in byte string: '\N'. String constant might be missing an r or u prefix."
\ No newline at end of file
diff --git a/tests/functional/arguments.py b/tests/functional/arguments.py
new file mode 100644
index 000000000..d023244d6
--- /dev/null
+++ b/tests/functional/arguments.py
@@ -0,0 +1,237 @@
+# pylint: disable=too-few-public-methods, no-absolute-import,missing-docstring,import-error,wrong-import-position
+# pylint: disable=wrong-import-order, useless-object-inheritance
+
+def decorator(fun):
+    """Decorator"""
+    return fun
+
+
+class DemoClass(object):
+    """Test class for method invocations."""
+
+    @staticmethod
+    def static_method(arg):
+        """static method."""
+        return arg + arg
+
+    @classmethod
+    def class_method(cls, arg):
+        """class method"""
+        return arg + arg
+
+    def method(self, arg):
+        """method."""
+        return (self, arg)
+
+    @decorator
+    def decorated_method(self, arg):
+        """decorated method."""
+        return (self, arg)
+
+
+def function_1_arg(first_argument):
+    """one argument function"""
+    return first_argument
+
+def function_3_args(first_argument, second_argument, third_argument):
+    """three arguments function"""
+    return first_argument, second_argument, third_argument
+
+def function_default_arg(one=1, two=2):
+    """fonction with default value"""
+    return two, one
+
+
+function_1_arg(420)
+function_1_arg()  # [no-value-for-parameter]
+function_1_arg(1337, 347)  # [too-many-function-args]
+
+function_3_args(420, 789)  # [no-value-for-parameter]
+# +1:[no-value-for-parameter,no-value-for-parameter,no-value-for-parameter]
+function_3_args()
+function_3_args(1337, 347, 456)
+function_3_args('bab', 'bebe', None, 5.6)  # [too-many-function-args]
+
+function_default_arg(1, two=5)
+function_default_arg(two=5)
+
+function_1_arg(bob=4)  # [unexpected-keyword-arg,no-value-for-parameter]
+function_default_arg(1, 4, coin="hello")  # [unexpected-keyword-arg]
+
+function_default_arg(1, one=5)  # [redundant-keyword-arg]
+
+# Remaining tests are for coverage of correct names in messages.
+LAMBDA = lambda arg: 1
+
+LAMBDA()  # [no-value-for-parameter]
+
+def method_tests():
+    """Method invocations."""
+    demo = DemoClass()
+    demo.static_method()  # [no-value-for-parameter]
+    DemoClass.static_method()  # [no-value-for-parameter]
+
+    demo.class_method()  # [no-value-for-parameter]
+    DemoClass.class_method()  # [no-value-for-parameter]
+
+    demo.method()  # [no-value-for-parameter]
+    DemoClass.method(demo)  # [no-value-for-parameter]
+
+    demo.decorated_method()  # [no-value-for-parameter]
+    DemoClass.decorated_method(demo)  # [no-value-for-parameter]
+
+# Test a regression (issue #234)
+import sys
+
+class Text(object):
+    """ Regression """
+
+    if sys.version_info > (3,):
+        def __new__(cls):
+            """ empty """
+            return object.__new__(cls)
+    else:
+        def __new__(cls):
+            """ empty """
+            return object.__new__(cls)
+
+Text()
+
+class TestStaticMethod(object):
+
+    @staticmethod
+    def test(first, second=None, **kwargs):
+        return first, second, kwargs
+
+    def func(self):
+        self.test(42)
+        self.test(42, second=34)
+        self.test(42, 42)
+        self.test() # [no-value-for-parameter]
+        self.test(42, 42, 42) # [too-many-function-args]
+
+
+class TypeCheckConstructor(object):
+    def __init__(self, first, second):
+        self.first = first
+        self.second = second
+    def test(self):
+        type(self)(1, 2, 3) # [too-many-function-args]
+        # +1: [no-value-for-parameter,no-value-for-parameter]
+        type(self)()
+        type(self)(1, lala=2) # [no-value-for-parameter,unexpected-keyword-arg]
+        type(self)(1, 2)
+        type(self)(first=1, second=2)
+
+
+class Test(object):
+    """ lambda needs Test instance as first argument """
+    lam = lambda self, icon: (self, icon)
+
+    def test(self):
+        self.lam(42)
+        self.lam() # [no-value-for-parameter]
+        self.lam(1, 2, 3) # [too-many-function-args]
+
+Test().lam() # [no-value-for-parameter]
+
+# Don't emit a redundant-keyword-arg for this example,
+# it's perfectly valid
+
+class Issue642(object):
+    attr = 0
+    def __str__(self):
+        return "{self.attr}".format(self=self)
+
+# These should not emit anything regarding the number of arguments,
+# since they have something invalid.
+from ala_bala_portocola import unknown
+
+# pylint: disable=not-a-mapping,not-an-iterable
+
+function_1_arg(*unknown)
+function_1_arg(1, *2)
+function_1_arg(1, 2, 3, **unknown)
+function_1_arg(4, 5, **1)
+function_1_arg(5, 6, **{unknown: 1})
+function_1_arg(**{object: 1})
+function_1_arg(**{1: 2})
+
+def no_context_but_redefined(*args):
+    args = [1]
+    #+1: [no-value-for-parameter, no-value-for-parameter]
+    expect_three(*list(args))
+
+def no_context_one_elem(*args):
+    expect_three(args) # [no-value-for-parameter, no-value-for-parameter]
+
+# Don't emit no-value-for-parameter for this, since we
+# don't have the context at our disposal.
+def expect_three(one, two, three):
+    return one + two + three
+
+
+def no_context(*args):
+    expect_three(*args)
+
+def no_context_two(*args):
+    expect_three(*list(args))
+
+def no_context_three(*args):
+    expect_three(*set(args))
+
+def compare_prices(arg):
+    return set((arg, ))
+
+def find_problems2(prob_dates):
+    for fff in range(10):
+        prob_dates |= compare_prices(fff)
+
+
+from collections import namedtuple
+
+
+def namedtuple_replace_issue_1036():
+    cls = namedtuple('cls', 'a b c')
+    new_instance = cls(1, 2, 3)._replace(
+        a=24,
+        b=24,
+        c=42
+    )
+    # +1:[unexpected-keyword-arg,unexpected-keyword-arg]
+    new_bad_instance = cls(1, 2, 3)._replace(d=24, e=32)
+    return new_instance, new_bad_instance
+
+
+from functools import partial
+
+def some_func(first, second, third):
+    return first + second + third
+
+
+partial(some_func, 1, 2)(3)
+partial(some_func, third=1, second=2)(3)
+partial(some_func, 1, third=2)(second=3)
+partial(some_func, 1)(1)  # [no-value-for-parameter]
+partial(some_func, 1)(third=1)  # [no-value-for-parameter]
+partial(some_func, 1, 2)(third=1, fourth=4)  # [unexpected-keyword-arg]
+
+
+def mutation_decorator(fun):
+    """Decorator that changes a function's signature."""
+    def wrapper(*args, do_something=True, **kwargs):
+        if do_something:
+            return fun(*args, **kwargs)
+
+        return None
+
+    return wrapper
+
+
+@mutation_decorator
+def mutated_function(arg):
+    return arg
+
+
+mutated_function(do_something=False)
+mutated_function()
diff --git a/tests/functional/arguments.rc b/tests/functional/arguments.rc
new file mode 100644
index 000000000..bb6bf0e37
--- /dev/null
+++ b/tests/functional/arguments.rc
@@ -0,0 +1,2 @@
+[TYPECHECK]
+signature-mutators=functional.arguments.mutation_decorator
diff --git a/tests/functional/arguments.txt b/tests/functional/arguments.txt
new file mode 100644
index 000000000..03132ef9c
--- /dev/null
+++ b/tests/functional/arguments.txt
@@ -0,0 +1,39 @@
+no-value-for-parameter:46::No value for argument 'first_argument' in function call
+too-many-function-args:47::Too many positional arguments for function call
+no-value-for-parameter:49::No value for argument 'third_argument' in function call
+no-value-for-parameter:51::No value for argument 'first_argument' in function call
+no-value-for-parameter:51::No value for argument 'second_argument' in function call
+no-value-for-parameter:51::No value for argument 'third_argument' in function call
+too-many-function-args:53::Too many positional arguments for function call
+no-value-for-parameter:58::No value for argument 'first_argument' in function call
+unexpected-keyword-arg:58::Unexpected keyword argument 'bob' in function call
+unexpected-keyword-arg:59::Unexpected keyword argument 'coin' in function call
+redundant-keyword-arg:61::Argument 'one' passed by position and keyword in function call
+no-value-for-parameter:66::No value for argument 'arg' in lambda call
+no-value-for-parameter:71:method_tests:No value for argument 'arg' in staticmethod call
+no-value-for-parameter:72:method_tests:No value for argument 'arg' in staticmethod call
+no-value-for-parameter:74:method_tests:No value for argument 'arg' in classmethod call
+no-value-for-parameter:75:method_tests:No value for argument 'arg' in classmethod call
+no-value-for-parameter:77:method_tests:No value for argument 'arg' in method call
+no-value-for-parameter:78:method_tests:No value for argument 'arg' in unbound method call
+no-value-for-parameter:80:method_tests:No value for argument 'arg' in method call
+no-value-for-parameter:81:method_tests:No value for argument 'arg' in unbound method call
+no-value-for-parameter:110:TestStaticMethod.func:No value for argument 'first' in staticmethod call
+too-many-function-args:111:TestStaticMethod.func:Too many positional arguments for staticmethod call
+too-many-function-args:119:TypeCheckConstructor.test:Too many positional arguments for constructor call
+no-value-for-parameter:121:TypeCheckConstructor.test:No value for argument 'first' in constructor call
+no-value-for-parameter:121:TypeCheckConstructor.test:No value for argument 'second' in constructor call
+no-value-for-parameter:122:TypeCheckConstructor.test:No value for argument 'second' in constructor call
+unexpected-keyword-arg:122:TypeCheckConstructor.test:Unexpected keyword argument 'lala' in constructor call
+no-value-for-parameter:133:Test.test:No value for argument 'icon' in method call
+too-many-function-args:134:Test.test:Too many positional arguments for method call
+no-value-for-parameter:136::No value for argument 'icon' in method call
+no-value-for-parameter:163:no_context_but_redefined:No value for argument 'three' in function call
+no-value-for-parameter:163:no_context_but_redefined:No value for argument 'two' in function call
+no-value-for-parameter:166:no_context_one_elem:No value for argument 'three' in function call
+no-value-for-parameter:166:no_context_one_elem:No value for argument 'two' in function call
+unexpected-keyword-arg:202:namedtuple_replace_issue_1036:Unexpected keyword argument 'd' in method call
+unexpected-keyword-arg:202:namedtuple_replace_issue_1036:Unexpected keyword argument 'e' in method call
+no-value-for-parameter:215::No value for argument 'third' in function call
+no-value-for-parameter:216::No value for argument 'second' in function call
+unexpected-keyword-arg:217::Unexpected keyword argument 'fourth' in function call
\ No newline at end of file
diff --git a/tests/functional/arguments_differ.py b/tests/functional/arguments_differ.py
new file mode 100644
index 000000000..61959fd22
--- /dev/null
+++ b/tests/functional/arguments_differ.py
@@ -0,0 +1,210 @@
+"""Test that we are emitting arguments-differ when the arguments are different."""

+# pylint: disable=missing-docstring, too-few-public-methods, unused-argument,useless-super-delegation, useless-object-inheritance

+

+class Parent(object):

+

+    def test(self):

+        pass

+

+

+class Child(Parent):

+

+    def test(self, arg): # [arguments-differ]

+        pass

+

+

+class ParentDefaults(object):

+

+    def test(self, arg=None, barg=None):

+        pass

+

+class ChildDefaults(ParentDefaults):

+

+    def test(self, arg=None): # [arguments-differ]

+        pass

+

+

+class Classmethod(object):

+

+    @classmethod

+    def func(cls, data):

+        return data

+

+    @classmethod

+    def func1(cls):

+        return cls

+

+

+class ClassmethodChild(Classmethod):

+

+    @staticmethod

+    def func(): # [arguments-differ]

+        pass

+

+    @classmethod

+    def func1(cls):

+        return cls()

+

+

+class Builtins(dict):

+    """Ignore for builtins, for which we don't know the number of required args."""

+

+    @classmethod

+    def fromkeys(cls, arg, arg1):

+        pass

+

+

+class Varargs(object):

+

+    def has_kwargs(self, arg, **kwargs):

+        pass

+

+    def no_kwargs(self, args):

+        pass

+

+

+class VarargsChild(Varargs):

+

+    def has_kwargs(self, arg): # [arguments-differ]

+        "Not okay to lose capabilities."

+

+    def no_kwargs(self, arg, **kwargs): # [arguments-differ]

+        "Not okay to add extra capabilities."

+

+

+class Super(object):

+    def __init__(self):

+        pass

+

+    def __private(self):

+        pass

+

+    def __private2_(self):

+        pass

+

+    def ___private3(self):

+        pass

+

+    def method(self, param):

+        raise NotImplementedError

+

+

+class Sub(Super):

+

+    # pylint: disable=unused-argument

+    def __init__(self, arg):

+        super(Sub, self).__init__()

+

+    def __private(self, arg):

+        pass

+

+    def __private2_(self, arg):

+        pass

+

+    def ___private3(self, arg):

+        pass

+

+    def method(self, param='abc'):

+        pass

+

+

+class Staticmethod(object):

+

+    @staticmethod

+    def func(data):

+        return data

+

+

+class StaticmethodChild(Staticmethod):

+

+    @classmethod

+    def func(cls, data):

+        return data

+

+

+class Property(object):

+

+    @property

+    def close(self):

+        pass

+

+class PropertySetter(Property):

+

+    @property

+    def close(self):

+        pass

+

+    @close.setter

+    def close(self, attr):

+        return attr

+

+

+class StaticmethodChild2(Staticmethod):

+

+    def func(self, data):

+        super(StaticmethodChild2, self).func(data)

+

+

+class SuperClass(object):

+

+    @staticmethod

+    def impl(arg1, arg2, **kwargs):

+        return arg1 + arg2

+

+

+class MyClass(SuperClass):

+

+    def impl(self, *args, **kwargs): # [arguments-differ]

+

+        super(MyClass, self).impl(*args, **kwargs)

+

+

+class FirstHasArgs(object):

+

+    def test(self, *args):

+        pass

+

+

+class SecondChangesArgs(FirstHasArgs):

+

+    def test(self, first, second, *args): # [arguments-differ]

+        pass

+

+class Positional(object):

+

+    def test(self, first, second):

+        pass

+

+

+class PositionalChild(Positional):

+

+    def test(self, *args): # [arguments-differ]

+        """Accepts too many.

+

+        Why subclassing in the first case if the behavior is different?

+        """

+        super(PositionalChild, self).test(args[0], args[1])

+

+

+class HasSpecialMethod(object):

+

+    def __getitem__(self, key):

+        return key

+

+

+class OverridesSpecialMethod(HasSpecialMethod):

+

+    def __getitem__(self, cheie):

+        return cheie + 1

+

+

+class ParentClass(object):

+

+    def meth(self, arg, arg1):

+        raise NotImplementedError

+

+

+class ChildClass(ParentClass):

+

+    def meth(self, _arg, dummy):

+        pass

diff --git a/tests/functional/arguments_differ.txt b/tests/functional/arguments_differ.txt
new file mode 100644
index 000000000..1fc0e8421
--- /dev/null
+++ b/tests/functional/arguments_differ.txt
@@ -0,0 +1,8 @@
+arguments-differ:12:Child.test:Parameters differ from overridden 'test' method

+arguments-differ:23:ChildDefaults.test:Parameters differ from overridden 'test' method

+arguments-differ:41:ClassmethodChild.func:Parameters differ from overridden 'func' method

+arguments-differ:68:VarargsChild.has_kwargs:Parameters differ from overridden 'has_kwargs' method

+arguments-differ:71:VarargsChild.no_kwargs:Parameters differ from overridden 'no_kwargs' method

+arguments-differ:157:MyClass.impl:Parameters differ from overridden 'impl' method

+arguments-differ:170:SecondChangesArgs.test:Parameters differ from overridden 'test' method

+arguments-differ:181:PositionalChild.test:Parameters differ from overridden 'test' method
\ No newline at end of file
diff --git a/tests/functional/arguments_differ_py3.py b/tests/functional/arguments_differ_py3.py
new file mode 100644
index 000000000..0e07131cc
--- /dev/null
+++ b/tests/functional/arguments_differ_py3.py
@@ -0,0 +1,36 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+class AbstractFoo:
+
+    def kwonly_1(self, first, *, second, third):
+        "Normal positional with two positional only params."
+
+    def kwonly_2(self, *, first, second):
+        "Two positional only parameter."
+
+    def kwonly_3(self, *, first, second):
+        "Two positional only params."
+
+    def kwonly_4(self, *, first, second=None):
+        "One positional only and another with a default."
+
+    def kwonly_5(self, *, first, **kwargs):
+        "Keyword only and keyword variadics."
+
+
+class Foo(AbstractFoo):
+
+    def kwonly_1(self, first, *, second): # [arguments-differ]
+        "One positional and only one positional only param."
+
+    def kwonly_2(self, first): # [arguments-differ]
+        "Only one positional parameter instead of two positional only parameters."
+
+    def kwonly_3(self, first, second): # [arguments-differ]
+        "Two positional params."
+
+    def kwonly_4(self, first, second): # [arguments-differ]
+        "Two positional params."
+
+    def kwonly_5(self, *, first): # [arguments-differ]
+        "Keyword only, but no variadics."
+    
\ No newline at end of file
diff --git a/tests/functional/arguments_differ_py3.rc b/tests/functional/arguments_differ_py3.rc
new file mode 100644
index 000000000..a2ab06c50
--- /dev/null
+++ b/tests/functional/arguments_differ_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/arguments_differ_py3.txt b/tests/functional/arguments_differ_py3.txt
new file mode 100644
index 000000000..d494a5058
--- /dev/null
+++ b/tests/functional/arguments_differ_py3.txt
@@ -0,0 +1,5 @@
+arguments-differ:22:Foo.kwonly_1:Parameters differ from overridden 'kwonly_1' method
+arguments-differ:25:Foo.kwonly_2:Parameters differ from overridden 'kwonly_2' method
+arguments-differ:28:Foo.kwonly_3:Parameters differ from overridden 'kwonly_3' method
+arguments-differ:31:Foo.kwonly_4:Parameters differ from overridden 'kwonly_4' method
+arguments-differ:34:Foo.kwonly_5:Parameters differ from overridden 'kwonly_5' method
diff --git a/tests/functional/assert_on_tuple.py b/tests/functional/assert_on_tuple.py
new file mode 100644
index 000000000..e360737e6
--- /dev/null
+++ b/tests/functional/assert_on_tuple.py
@@ -0,0 +1,11 @@
+'''Assert check example'''
+
+# pylint: disable=misplaced-comparison-constant, comparison-with-itself
+assert (1 == 1, 2 == 2), "no error"
+assert (1 == 1, 2 == 2) # [assert-on-tuple]
+assert 1 == 1, "no error"
+assert (1 == 1, ), "no error"
+assert (1 == 1, )
+assert (1 == 1, 2 == 2, 3 == 5), "no error"
+assert ()
+assert (True, 'error msg') # [assert-on-tuple]
diff --git a/tests/functional/assert_on_tuple.txt b/tests/functional/assert_on_tuple.txt
new file mode 100644
index 000000000..52d1ca5da
--- /dev/null
+++ b/tests/functional/assert_on_tuple.txt
@@ -0,0 +1,2 @@
+assert-on-tuple:5::Assert called on a 2-uple. Did you mean 'assert x,y'?
+assert-on-tuple:11::Assert called on a 2-uple. Did you mean 'assert x,y'?
diff --git a/tests/functional/assigning_non_slot.py b/tests/functional/assigning_non_slot.py
new file mode 100644
index 000000000..6fd299f37
--- /dev/null
+++ b/tests/functional/assigning_non_slot.py
@@ -0,0 +1,175 @@
+""" Checks assigning attributes not found in class slots
+will trigger assigning-non-slot warning.
+"""
+# pylint: disable=too-few-public-methods, no-init, missing-docstring, no-absolute-import, import-error, useless-object-inheritance
+from collections import deque
+
+from missing import Unknown
+
+class Empty(object):
+    """ empty """
+
+class Bad(object):
+    """ missing not in slots. """
+
+    __slots__ = ['member']
+
+    def __init__(self):
+        self.missing = 42 # [assigning-non-slot]
+
+class Bad2(object):
+    """ missing not in slots """
+    __slots__ = [deque.__name__, 'member']
+
+    def __init__(self):
+        self.deque = 42
+        self.missing = 42 # [assigning-non-slot]
+
+class Bad3(Bad):
+    """ missing not found in slots """
+
+    __slots__ = ['component']
+
+    def __init__(self):
+        self.component = 42
+        self.member = 24
+        self.missing = 42 # [assigning-non-slot]
+        super(Bad3, self).__init__()
+
+class Good(Empty):
+    """ missing not in slots, but Empty doesn't
+    specify __slots__.
+    """
+    __slots__ = ['a']
+
+    def __init__(self):
+        self.missing = 42
+
+class Good2(object):
+    """ Using __dict__ in slots will be safe. """
+
+    __slots__ = ['__dict__', 'comp']
+
+    def __init__(self):
+        self.comp = 4
+        self.missing = 5
+
+class PropertyGood(object):
+    """ Using properties is safe. """
+
+    __slots__ = ['tmp', '_value']
+
+    @property
+    def test(self):
+        return self._value
+
+    @test.setter
+    def test(self, value):
+        # pylint: disable=attribute-defined-outside-init
+        self._value = value
+
+    def __init__(self):
+        self.test = 42
+
+class PropertyGood2(object):
+    """ Using properties in the body of the class is safe. """
+    __slots__ = ['_value']
+
+    def _getter(self):
+        return self._value
+
+    def _setter(self, value):
+        # pylint: disable=attribute-defined-outside-init
+        self._value = value
+
+    test = property(_getter, _setter)
+
+    def __init__(self):
+        self.test = 24
+
+class UnicodeSlots(object):
+    """Using unicode objects in __slots__ is okay.
+
+    On Python 3.3 onward, u'' is equivalent to '',
+    so this test should be safe for both versions.
+    """
+    __slots__ = (u'first', u'second')
+
+    def __init__(self):
+        self.first = 42
+        self.second = 24
+
+
+class DataDescriptor(object):
+    def __init__(self, name, default=''):
+        self.__name = name
+        self.__default = default
+
+    def __get__(self, inst, cls):
+        return getattr(inst, self.__name, self.__default)
+
+    def __set__(self, inst, value):
+        setattr(inst, self.__name, value)
+
+
+class NonDataDescriptor(object):
+    def __get__(self, inst, cls):
+        return 42
+
+
+class SlotsWithDescriptor(object):
+    __slots__ = ['_err']
+    data_descriptor = DataDescriptor('_err')
+    non_data_descriptor = NonDataDescriptor()
+    missing_descriptor = Unknown()
+
+
+def dont_emit_for_descriptors():
+    inst = SlotsWithDescriptor()
+    # This should not emit, because attr is
+    # a data descriptor
+    inst.data_descriptor = 'foo'
+    inst.non_data_descriptor = 'lala' # [assigning-non-slot]
+
+
+class ClassWithSlots(object):
+    __slots__ = ['foobar']
+
+
+class ClassReassigningDunderClass(object):
+    __slots__ = ['foobar']
+
+    def release(self):
+        self.__class__ = ClassWithSlots
+
+
+class ClassReassingingInvalidLayoutClass(object):
+    __slots__ = []
+
+    def release(self):
+        self.__class__ = ClassWithSlots # [assigning-non-slot]
+
+
+# pylint: disable=attribute-defined-outside-init
+class ClassHavingUnknownAncestors(Unknown):
+    __slots__ = ['yo']
+
+    def test(self):
+        self.not_yo = 42
+
+
+# pylint: disable=wrong-import-order, wrong-import-position
+from typing import (
+    Generic,
+    TypeVar,
+)
+
+TYPE = TypeVar('TYPE')
+
+
+class Cls(Generic[TYPE]):
+    """ Simple class with slots """
+    __slots__ = ['value']
+
+    def __init__(self, value):
+        self.value = value
diff --git a/tests/functional/assigning_non_slot.txt b/tests/functional/assigning_non_slot.txt
new file mode 100644
index 000000000..9d24a92eb
--- /dev/null
+++ b/tests/functional/assigning_non_slot.txt
@@ -0,0 +1,5 @@
+assigning-non-slot:18:Bad.__init__:Assigning to attribute 'missing' not defined in class slots

+assigning-non-slot:26:Bad2.__init__:Assigning to attribute 'missing' not defined in class slots

+assigning-non-slot:36:Bad3.__init__:Assigning to attribute 'missing' not defined in class slots

+assigning-non-slot:132:dont_emit_for_descriptors:Assigning to attribute 'non_data_descriptor' not defined in class slots

+assigning-non-slot:150:ClassReassingingInvalidLayoutClass.release:Assigning to attribute '__class__' not defined in class slots
\ No newline at end of file
diff --git a/tests/functional/assignment_from_no_return.py b/tests/functional/assignment_from_no_return.py
new file mode 100644
index 000000000..6991fe561
--- /dev/null
+++ b/tests/functional/assignment_from_no_return.py
@@ -0,0 +1,31 @@
+# pylint: disable=missing-docstring
+
+
+def some_func():
+    pass
+
+
+def decorate(func):
+    """Decorate *fn* to return ``self`` to enable chained method calls."""
+    def wrapper(self, *args, **kw):
+        func(self, *args, **kw)
+        return 42
+    return wrapper
+
+
+class Class:
+
+    def some_method(self):
+        pass
+
+    @decorate
+    def some_other_decorated_method(self):
+        pass
+
+    def some_other_method(self):
+        value = self.some_method()  # [assignment-from-no-return]
+        other_value = self.some_other_decorated_method()
+        return value + other_value
+
+
+VALUE = some_func() # [assignment-from-no-return]
diff --git a/tests/functional/assignment_from_no_return.txt b/tests/functional/assignment_from_no_return.txt
new file mode 100644
index 000000000..1972103a8
--- /dev/null
+++ b/tests/functional/assignment_from_no_return.txt
@@ -0,0 +1,2 @@
+assignment-from-no-return:26:Class.some_other_method:Assigning result of a function call, where the function has no return
+assignment-from-no-return:31::Assigning result of a function call, where the function has no return
\ No newline at end of file
diff --git a/tests/functional/assignment_from_no_return_py3.py b/tests/functional/assignment_from_no_return_py3.py
new file mode 100644
index 000000000..7b1abd59f
--- /dev/null
+++ b/tests/functional/assignment_from_no_return_py3.py
@@ -0,0 +1,36 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+
+import asyncio
+
+
+async def bla1():
+    await asyncio.sleep(1)
+
+
+async def bla2():
+    await asyncio.sleep(2)
+
+
+async def combining_coroutine1():
+    await bla1()
+    await bla2()
+
+
+class Coro:
+    async def func(self):
+        future1 = bla1()
+        future2 = bla2()
+        await asyncio.gather(future1, future2)
+
+
+async def combining_coroutine2():
+    future1 = bla1()
+    future2 = bla2()
+    future3 = Coro().func()
+    await asyncio.gather(future1, future2, future3)
+
+
+def do_stuff():
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(combining_coroutine1())
+    loop.run_until_complete(combining_coroutine2())
diff --git a/tests/functional/assignment_from_no_return_py3.rc b/tests/functional/assignment_from_no_return_py3.rc
new file mode 100644
index 000000000..1450ccc64
--- /dev/null
+++ b/tests/functional/assignment_from_no_return_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
\ No newline at end of file
diff --git a/tests/functional/assignment_from_no_return_py3.txt b/tests/functional/assignment_from_no_return_py3.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/assignment_from_no_return_py3.txt
diff --git a/tests/functional/async_functions.py b/tests/functional/async_functions.py
new file mode 100644
index 000000000..2f2252de8
--- /dev/null
+++ b/tests/functional/async_functions.py
@@ -0,0 +1,63 @@
+"""Check that Python 3.5's async functions are properly analyzed by Pylint."""
+# pylint: disable=missing-docstring,invalid-name,too-few-public-methods
+# pylint: disable=using-constant-test, useless-object-inheritance
+
+async def next(): # [redefined-builtin]
+    pass
+
+async def some_function(arg1, arg2): # [unused-argument]
+    await arg1
+
+
+class OtherClass(object):
+
+    @staticmethod
+    def test():
+        return 42
+
+
+class Class(object):
+
+    async def some_method(self):
+        super(OtherClass, self).test() # [bad-super-call]
+
+
+# +1: [too-many-arguments,too-many-return-statements, too-many-branches]
+async def complex_function(this, function, has, more, arguments, than,
+                           one, _, should, have):
+    if 1:
+        return this
+    if 1:
+        return function
+    if 1:
+        return has
+    if 1:
+        return more
+    if 1:
+        return arguments
+    if 1:
+        return than
+    try:
+        return one
+    finally:
+        pass
+    if 2:
+        return should
+    while True:
+        pass
+    if 1:
+        return have
+    if 2:
+        return function
+    if 3:
+        pass
+
+
+# +1: [duplicate-argument-name, duplicate-argument-name, dangerous-default-value]
+async def func(a, a, b=[]):
+    return a, b
+
+
+# +1: [empty-docstring, blacklisted-name]
+async def foo():
+    ""
diff --git a/tests/functional/async_functions.rc b/tests/functional/async_functions.rc
new file mode 100644
index 000000000..03004f2c2
--- /dev/null
+++ b/tests/functional/async_functions.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5
\ No newline at end of file
diff --git a/tests/functional/async_functions.txt b/tests/functional/async_functions.txt
new file mode 100644
index 000000000..e00c5bbfa
--- /dev/null
+++ b/tests/functional/async_functions.txt
@@ -0,0 +1,11 @@
+redefined-builtin:5:next:"Redefining built-in 'next'"
+unused-argument:8:some_function:"Unused argument 'arg2'"
+bad-super-call:22:Class.some_method:"Bad first argument 'OtherClass' given to super()"
+too-many-arguments:26:complex_function:Too many arguments (10/5)
+too-many-branches:26:complex_function:Too many branches (13/12)
+too-many-return-statements:26:complex_function:Too many return statements (10/6)
+dangerous-default-value:57:func:Dangerous default value [] as argument
+duplicate-argument-name:57:func:Duplicate argument name a in function definition
+duplicate-argument-name:57:func:Duplicate argument name a in function definition
+blacklisted-name:62:foo:Black listed name "foo"
+empty-docstring:62:foo:Empty function docstring
\ No newline at end of file
diff --git a/tests/functional/attribute_defined_outside_init.py b/tests/functional/attribute_defined_outside_init.py
new file mode 100644
index 000000000..ff31e955d
--- /dev/null
+++ b/tests/functional/attribute_defined_outside_init.py
@@ -0,0 +1,80 @@
+# pylint: disable=missing-docstring,too-few-public-methods,invalid-name, useless-object-inheritance
+
+class A(object):
+
+    def __init__(self):
+        self.x = 0
+        self.setUp()
+
+    def set_y(self, y):
+        self.y = y
+
+    def set_x(self, x):
+        self.x = x
+
+    def set_z(self, z):
+        self.z = z # [attribute-defined-outside-init]
+
+    def setUp(self):
+        self.x = 0
+        self.y = 0
+
+
+class B(A):
+
+    def test(self):
+        self.z = 44 # [attribute-defined-outside-init]
+
+
+class C(object):
+
+    def __init__(self):
+        self._init()
+
+    def _init(self):
+        self.z = 44
+
+
+class D(object):
+
+    def setUp(self):
+        self.set_z()
+
+    def set_z(self):
+        self.z = 42
+
+
+class E(object):
+
+    def __init__(self):
+        i = self._init
+        i()
+
+    def _init(self):
+        self.z = 44
+
+
+class Mixin(object):
+
+    def test_mixin(self):
+        """Don't emit attribute-defined-outside-init for mixin classes."""
+        if self.defined_already: # pylint: disable=access-member-before-definition
+            self.defined_already = None
+
+
+class F:
+    def func(self):
+        self.__dict__ = {'foo': 'bar'}
+
+
+class Mine:
+    def __init__(self, param):
+        self.prop = param
+
+    @property
+    def prop(self):
+        return self.__prop
+
+    @prop.setter
+    def prop(self, value):
+        self.__prop = value
diff --git a/tests/functional/attribute_defined_outside_init.txt b/tests/functional/attribute_defined_outside_init.txt
new file mode 100644
index 000000000..51456e30c
--- /dev/null
+++ b/tests/functional/attribute_defined_outside_init.txt
@@ -0,0 +1,2 @@
+attribute-defined-outside-init:16:A.set_z:Attribute 'z' defined outside __init__
+attribute-defined-outside-init:26:B.test:Attribute 'z' defined outside __init__
diff --git a/tests/functional/bad_continuation.py b/tests/functional/bad_continuation.py
new file mode 100644
index 000000000..1c73a1122
--- /dev/null
+++ b/tests/functional/bad_continuation.py
@@ -0,0 +1,232 @@
+"""Regression test case for bad-continuation."""
+# pylint: disable=print-statement,implicit-str-concat-in-sequence,using-constant-test,missing-docstring,wrong-import-position
+# Various alignment for brackets
+from __future__ import print_function
+
+LIST0 = [
+    1, 2, 3
+]
+LIST1 = [
+    1, 2, 3
+    ]
+LIST2 = [
+    1, 2, 3
+   ]  # [bad-continuation]
+
+# Alignment inside literals
+W0 = [1, 2, 3,
+      4, 5, 6,
+         7,  # [bad-continuation]
+      8, 9, 10,
+      11, 12, 13,
+      # and a comment
+      14, 15, 16]
+
+W1 = {
+    'a': 1,
+   'b': 2,  # [bad-continuation]
+    'c': 3,
+    }
+
+W2 = {
+    'a': 1,
+   'b': 2,  # [bad-continuation]
+    'c': 3,
+    }
+
+W2 = ['some', 'contents'  # with a continued comment that may be aligned
+                          # under the previous comment (optionally)
+      'and',
+      'more',             # but this
+                             # [bad-continuation] is not accepted
+                          'contents', # [bad-continuation] nor this.
+     ]
+
+# Values in dictionaries should be indented 4 spaces further if they are on a
+# different line than their key
+W4 = {
+    'key1':
+    'value1',  # Grandfather in the old style
+    'key2':
+      'value2',  # [bad-continuation]
+    'key3':
+        'value3',  # Comma here
+    }
+
+# And should follow the same rules as continuations within parens
+W5 = {
+    'key1': 'long value'
+            'long continuation',
+    'key2': 'breaking'
+        'wrong',  # [bad-continuation]
+    'key3': 2*(
+        2+2),
+    'key4': ('parenthesis',
+             'continuation')  # No comma here
+    }
+
+# Allow values to line up with their keys when the key is next to the brace
+W6 = {'key1':
+      'value1',
+      'key2':
+      'value2',
+     }
+
+# Or allow them to be indented
+W7 = {'key1':
+          'value1',
+      'key2':
+          'value2'
+     }
+
+# Bug that caused a warning on the previous two cases permitted these odd
+# incorrect indentations
+W8 = {'key1':
+'value1',  # [bad-continuation]
+     }
+
+W9 = {'key1':
+    'value1',  # [bad-continuation]
+     }
+
+# Alignment of arguments in function definitions
+def continue1(some_arg,
+              some_other_arg):
+    """A function with well-aligned arguments."""
+    print(some_arg, some_other_arg)
+
+
+def continue2(
+        some_arg,
+        some_other_arg):
+    """A function with well-aligned arguments."""
+    print(some_arg, some_other_arg)
+
+def continue3(
+    some_arg,         # [bad-continuation]
+    some_other_arg):  # [bad-continuation]
+    """A function with misaligned arguments"""
+    print(some_arg, some_other_arg)
+
+def continue4(  # pylint:disable=missing-docstring
+    arg1,
+    arg2): print(arg1, arg2)
+
+
+def callee(*args):
+    """noop"""
+    print(args)
+
+
+callee(
+    "a",
+    "b"
+    )
+
+callee("a",
+    "b")  # [bad-continuation]
+
+callee(5, {'a': 'b',
+           'c': 'd'})
+
+if (
+    1
+    ): pass
+
+if (
+    1
+): pass
+if (
+    1
+   ): pass  # [bad-continuation]
+
+if (1 and
+    2):  # [bad-continuation]
+    pass
+
+while (1 and
+       2):
+    pass
+
+while (1 and
+         2 and  # [bad-continuation]
+       3):
+    pass
+
+if (
+  2): pass  # [bad-continuation]
+
+if (1 or
+    2 or
+    3): pass
+
+if (1 or
+     2 or  # [bad-continuation]
+    3): print(1, 2)
+
+if (1 and
+  2): pass  # [bad-continuation]
+
+if (
+    2): pass
+
+if (
+  2):  # [bad-continuation]
+    pass
+
+L1 = (lambda a,
+             b: a + b)
+
+if not (1 and
+        2):
+    print(3)
+
+if not (1 and
+    2):  # [bad-continuation]
+    print(3)
+
+continue2("foo",
+          some_other_arg="this "
+                         "is "
+                         "fine")
+
+from contextlib import contextmanager
+@contextmanager
+def mycontext(*args):
+    yield args
+
+with mycontext(
+        "this is",
+        "great stuff",
+        "mane"):
+    pass
+
+# pylint: disable=using-constant-test
+# More indentation included to distinguish this from the rest.
+def long_function_name(
+        var_one, var_two, var_three,
+        var_four):
+    print(var_one, var_two, var_three, var_four)
+
+
+def short_func_name(first, second, third):
+    # Add some extra indentation on the conditional continuation line.
+    if (first
+            and second == first == 'some_big_long_statement_that_should_not_trigger'):
+        third()
+
+
+# Some normal multi-line statements with double-indented continuation lines.
+LARGE_COLLECTION = [
+        "spam",
+        "eggs",
+        "beans",
+        ]
+
+long_function_name(
+        "1", "2", "3", "4")
+
+CONCATENATED_TEXT = (
+        "spam"
+        "eggs"
+        "beans")
diff --git a/tests/functional/bad_continuation.txt b/tests/functional/bad_continuation.txt
new file mode 100644
index 000000000..672f0afd4
--- /dev/null
+++ b/tests/functional/bad_continuation.txt
@@ -0,0 +1,63 @@
+bad-continuation:14::"Wrong hanging indentation.
+   ]  # [bad-continuation]
+|  ^|"
+bad-continuation:19::"Wrong continued indentation (remove 3 spaces).
+         7,  # [bad-continuation]
+      |  ^"
+bad-continuation:27::"Wrong hanging indentation (add 1 space).
+   'b': 2,  # [bad-continuation]
+   ^|"
+bad-continuation:33::"Wrong hanging indentation (add 1 space).
+   'b': 2,  # [bad-continuation]
+   ^|"
+bad-continuation:41::"Wrong continued indentation.
+                             # [bad-continuation] is not accepted
+      |                   |  ^"
+bad-continuation:42::"Wrong continued indentation (remove 20 spaces).
+                          'contents', # [bad-continuation] nor this.
+      |                   ^"
+bad-continuation:51::"Wrong hanging indentation in dict value.
+      'value2',  # [bad-continuation]
+    | ^ |"
+bad-continuation:61::"Wrong continued indentation (add 4 spaces).
+        'wrong',  # [bad-continuation]
+        ^   |"
+bad-continuation:85::"Wrong hanging indentation in dict value.
+'value1',  # [bad-continuation]
+^     |   |"
+bad-continuation:89::"Wrong hanging indentation in dict value.
+    'value1',  # [bad-continuation]
+    ^ |   |"
+bad-continuation:106::"Wrong hanging indentation before block (add 4 spaces).
+    some_arg,         # [bad-continuation]
+    ^   |"
+bad-continuation:107::"Wrong hanging indentation before block (add 4 spaces).
+    some_other_arg):  # [bad-continuation]
+    ^   |"
+bad-continuation:127::"Wrong continued indentation (add 3 spaces).
+    ""b"")  # [bad-continuation]
+    ^  |"
+bad-continuation:141::"Wrong hanging indentation before block.
+   ): pass  # [bad-continuation]
+|  ^|"
+bad-continuation:144::"Wrong continued indentation before block (add 4 spaces).
+    2):  # [bad-continuation]
+    ^   |"
+bad-continuation:152::"Wrong continued indentation (remove 2 spaces).
+         2 and  # [bad-continuation]
+       | ^"
+bad-continuation:157::"Wrong hanging indentation before block.
+  2): pass  # [bad-continuation]
+  ^ |   |"
+bad-continuation:164::"Wrong continued indentation before block.
+     2 or  # [bad-continuation]
+    |^  |"
+bad-continuation:168::"Wrong continued indentation before block.
+  2): pass  # [bad-continuation]
+  ^ |   |"
+bad-continuation:174::"Wrong hanging indentation before block.
+  2):  # [bad-continuation]
+  ^ |   |"
+bad-continuation:185::"Wrong continued indentation (add 4 spaces).
+    2):  # [bad-continuation]
+    ^   |"
diff --git a/tests/functional/bad_continuation_py36.py b/tests/functional/bad_continuation_py36.py
new file mode 100644
index 000000000..172a9c5a6
--- /dev/null
+++ b/tests/functional/bad_continuation_py36.py
@@ -0,0 +1,8 @@
+# pylint: disable=missing-docstring, unused-argument
+
+async def upload_post(
+        content: bytes,
+        source: str,
+        tags: dict) -> dict:
+    # regression test for https://github.com/PyCQA/pylint/issues/1415
+    raise NotImplementedError('Not implemented')
diff --git a/tests/functional/bad_continuation_py36.rc b/tests/functional/bad_continuation_py36.rc
new file mode 100644
index 000000000..1450ccc64
--- /dev/null
+++ b/tests/functional/bad_continuation_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
\ No newline at end of file
diff --git a/tests/functional/bad_continuation_tabs.py b/tests/functional/bad_continuation_tabs.py
new file mode 100644
index 000000000..a668dc704
--- /dev/null
+++ b/tests/functional/bad_continuation_tabs.py
@@ -0,0 +1,52 @@
+"""Regression test case for bad-continuation with tabs"""
+# pylint: disable=too-few-public-methods,missing-docstring,invalid-name,unused-variable, useless-object-inheritance
+# Various alignment for brackets
+
+# Issue 638
+TEST1 = ["foo",
+         "bar",
+         "baz"
+         ]
+
+MY_LIST = [
+	1, 2, 3,
+	4, 5, 6
+	]
+
+# Issue 1148
+class Abc(object):
+	def b(self, c):
+		# bock indentation
+		self.d(
+			c)  # (is: tabs only)
+
+	def d(self, e):
+		# bad hanging indentation
+		self.b(
+		       e)  # [bad-continuation] (is: 2 tabs + 7 spaces)
+
+	def f(self):
+		# block indentiation (is: all tabs only)
+		return [
+			self.b,
+			self.d
+		]
+
+	def g(self):
+		# bad hanging indentation
+		# the closing ] requires 7 - 8 more spcaes; see h(), i()
+		return [self.b,
+		        self.d  # (is: 2 tabs + 8 spaces)
+		]  # [bad-continuation] (is: tabs only)
+
+	def h(self):
+		# hanging indentation: all lined up with first token 'self.b'
+		return [self.b,
+		        self.d # (is: 2 tabs + 8 spaces)
+		        ] # (is: 2 tabs + 8 spaces)
+
+	def i(self):
+		# hangin identation: closing ] lined up with opening [
+		return [self.b,
+		        self.d   # (2 tabs + 8 spaces)
+		       ]  # (2 tabs + 7 spaces)
diff --git a/tests/functional/bad_continuation_tabs.rc b/tests/functional/bad_continuation_tabs.rc
new file mode 100644
index 000000000..bebda3809
--- /dev/null
+++ b/tests/functional/bad_continuation_tabs.rc
@@ -0,0 +1,3 @@
+[FORMAT]
+indent-string='\t'
+indent-after-paren=1
diff --git a/tests/functional/bad_continuation_tabs.txt b/tests/functional/bad_continuation_tabs.txt
new file mode 100644
index 000000000..8fff7bbfb
--- /dev/null
+++ b/tests/functional/bad_continuation_tabs.txt
@@ -0,0 +1,6 @@
+bad-continuation:26::"Wrong hanging indentation (add 1 space).
+		       e)  # [bad-continuation] (is: 2 tabs + 7 spaces)
+                       ^|"
+bad-continuation:40::"Wrong continued indentation.
+		]  # [bad-continuation] (is: tabs only)
+                ^      ||"
diff --git a/tests/functional/bad_except_order.py b/tests/functional/bad_except_order.py
new file mode 100644
index 000000000..4f2fa3ea8
--- /dev/null
+++ b/tests/functional/bad_except_order.py
@@ -0,0 +1,45 @@
+# pylint: disable=missing-docstring, bare-except, broad-except
+
+__revision__ = 1
+
+try:
+    __revision__ += 1
+except Exception:
+    __revision__ = 0
+except TypeError: # [bad-except-order]
+    __revision__ = 0
+
+try:
+    __revision__ += 1
+except LookupError:
+    __revision__ = 0
+except IndexError: # [bad-except-order]
+    __revision__ = 0
+
+try:
+    __revision__ += 1
+except (LookupError, NameError):
+    __revision__ = 0
+except (IndexError, UnboundLocalError): # [bad-except-order, bad-except-order]
+    __revision__ = 0
+
+try: # [bad-except-order]
+    __revision__ += 1
+except:
+    pass
+except Exception:
+    pass
+
+try:
+    __revision__ += 1
+except TypeError:
+    __revision__ = 0
+except:
+    __revision__ = 0
+
+try:
+    __revision__ += 1
+except Exception:
+    pass
+except:
+    pass
diff --git a/tests/functional/bad_except_order.txt b/tests/functional/bad_except_order.txt
new file mode 100644
index 000000000..1199d6790
--- /dev/null
+++ b/tests/functional/bad_except_order.txt
@@ -0,0 +1,5 @@
+bad-except-order:9::Bad except clauses order (Exception is an ancestor class of TypeError)
+bad-except-order:16::Bad except clauses order (LookupError is an ancestor class of IndexError)
+bad-except-order:23::Bad except clauses order (LookupError is an ancestor class of IndexError)
+bad-except-order:23::Bad except clauses order (NameError is an ancestor class of UnboundLocalError)
+bad-except-order:26::Bad except clauses order (empty except clause should always appear last)
diff --git a/tests/functional/bad_exception_context.py b/tests/functional/bad_exception_context.py
new file mode 100644
index 000000000..af3e4fb9f
--- /dev/null
+++ b/tests/functional/bad_exception_context.py
@@ -0,0 +1,24 @@
+"""Check that raise ... from .. uses a proper exception context """
+
+# pylint: disable=unreachable, import-error, multiple-imports
+
+import socket, unknown
+
+__revision__ = 0
+
+class ExceptionSubclass(Exception):
+    """ subclass """
+
+def test():
+    """ docstring """
+    raise IndexError from 1 # [bad-exception-context]
+    raise IndexError from None
+    raise IndexError from ZeroDivisionError
+    raise IndexError from object() # [bad-exception-context]
+    raise IndexError from ExceptionSubclass
+    raise IndexError from socket.error
+    raise IndexError() from None
+    raise IndexError() from ZeroDivisionError
+    raise IndexError() from ZeroDivisionError()
+    raise IndexError() from object() # [bad-exception-context]
+    raise IndexError() from unknown
diff --git a/tests/functional/bad_exception_context.rc b/tests/functional/bad_exception_context.rc
new file mode 100644
index 000000000..8c6eb56c4
--- /dev/null
+++ b/tests/functional/bad_exception_context.rc
@@ -0,0 +1,2 @@
+[testoptions]

+min_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/bad_exception_context.txt b/tests/functional/bad_exception_context.txt
new file mode 100644
index 000000000..f403a39b2
--- /dev/null
+++ b/tests/functional/bad_exception_context.txt
@@ -0,0 +1,3 @@
+bad-exception-context:14:test:Exception context set to something which is not an exception, nor None

+bad-exception-context:17:test:Exception context set to something which is not an exception, nor None

+bad-exception-context:23:test:Exception context set to something which is not an exception, nor None
\ No newline at end of file
diff --git a/tests/functional/bad_indentation.py b/tests/functional/bad_indentation.py
new file mode 100644
index 000000000..4c50eae0b
--- /dev/null
+++ b/tests/functional/bad_indentation.py
@@ -0,0 +1,19 @@
+# pylint: disable=missing-docstring, pointless-statement
+from __future__ import print_function
+
+
+def totoo():
+ print('malindented') # [bad-indentation]
+
+def tutuu():
+    print('good indentation')
+
+def titii():
+     1  # and this. # [bad-indentation]
+
+def tataa(kdict):
+    for key in ['1', '2', '3']:
+        key = key.lower()
+
+        if key in kdict:
+            del kdict[key]
diff --git a/tests/functional/bad_indentation.txt b/tests/functional/bad_indentation.txt
new file mode 100644
index 000000000..c5c00bb12
--- /dev/null
+++ b/tests/functional/bad_indentation.txt
@@ -0,0 +1,2 @@
+bad-indentation:6::Bad indentation. Found 1 spaces, expected 4
+bad-indentation:12::Bad indentation. Found 5 spaces, expected 4
diff --git a/tests/functional/bad_inline_option.py b/tests/functional/bad_inline_option.py
new file mode 100644
index 000000000..be6e24081
--- /dev/null
+++ b/tests/functional/bad_inline_option.py
@@ -0,0 +1,5 @@
+"""errors-only is not usable as an inline option"""
+# +1: [bad-inline-option]
+# pylint: errors-only
+
+CONST = "This is not a pylint: inline option."
diff --git a/tests/functional/bad_inline_option.rc b/tests/functional/bad_inline_option.rc
new file mode 100644
index 000000000..b211d7254
--- /dev/null
+++ b/tests/functional/bad_inline_option.rc
@@ -0,0 +1,2 @@
+[Messages Control]
+enable=I
diff --git a/tests/functional/bad_inline_option.txt b/tests/functional/bad_inline_option.txt
new file mode 100644
index 000000000..91ac1af35
--- /dev/null
+++ b/tests/functional/bad_inline_option.txt
@@ -0,0 +1 @@
+bad-inline-option:3::Unable to consider inline option 'errors-only'
diff --git a/tests/functional/bad_open_mode.py b/tests/functional/bad_open_mode.py
new file mode 100644
index 000000000..6b749de03
--- /dev/null
+++ b/tests/functional/bad_open_mode.py
@@ -0,0 +1,37 @@
+"""Warnings for using open() with an invalid mode string."""
+
+open('foo.bar', 'w', 2)
+open('foo.bar', 'rw')  # [bad-open-mode]
+open(name='foo.bar', buffering=10, mode='rw')  # [bad-open-mode]
+open(mode='rw', name='foo.bar')  # [bad-open-mode]
+open('foo.bar', 'U+')
+open('foo.bar', 'rb+')
+open('foo.bar', 'Uw')  # [bad-open-mode]
+open('foo.bar', 2)  # [bad-open-mode]
+open('foo.bar', buffering=2)
+WRITE_MODE = 'w'
+open('foo.bar', 'U' + WRITE_MODE + 'z')  # [bad-open-mode]
+open('foo.bar', 'br')  # [bad-open-mode]
+open('foo.bar', 'wU')  # [bad-open-mode]
+open('foo.bar', 'r+b')
+open('foo.bar', 'r+')
+open('foo.bar', 'w+')
+open('foo.bar', 'xb')  # [bad-open-mode]
+open('foo.bar', 'rx')  # [bad-open-mode]
+open('foo.bar', 'Ur')
+open('foo.bar', 'rU')
+open('foo.bar', 'rUb')
+open('foo.bar', 'rUb+')
+open('foo.bar', 'rU+b')
+open('foo.bar', 'r+Ub')
+open('foo.bar', '+rUb')  # [bad-open-mode]
+open('foo.bar', 'ab+')
+open('foo.bar', 'a+b')
+open('foo.bar', 'aU')  # [bad-open-mode]
+open('foo.bar', 'U+b')
+open('foo.bar', '+Ub')
+open('foo.bar', 'b+U')
+open('foo.bar', 'Urb+')
+open('foo.bar', 'Ur+b')
+open('foo.bar', 'Ubr')  # [bad-open-mode]
+open('foo.bar', 'Ut')  # [bad-open-mode]
diff --git a/tests/functional/bad_open_mode.rc b/tests/functional/bad_open_mode.rc
new file mode 100644
index 000000000..b9ab97702
--- /dev/null
+++ b/tests/functional/bad_open_mode.rc
@@ -0,0 +1,2 @@
+[testoptions]

+max_pyver=3.0

diff --git a/tests/functional/bad_open_mode.txt b/tests/functional/bad_open_mode.txt
new file mode 100644
index 000000000..b0222863e
--- /dev/null
+++ b/tests/functional/bad_open_mode.txt
@@ -0,0 +1,14 @@
+bad-open-mode:4::"""rw"" is not a valid mode for open."
+bad-open-mode:5::"""rw"" is not a valid mode for open."
+bad-open-mode:6::"""rw"" is not a valid mode for open."
+bad-open-mode:9::"""Uw"" is not a valid mode for open."
+bad-open-mode:10::"""2"" is not a valid mode for open."
+bad-open-mode:13::"""Uwz"" is not a valid mode for open."
+bad-open-mode:14::"""br"" is not a valid mode for open."
+bad-open-mode:15::"""wU"" is not a valid mode for open."
+bad-open-mode:19::"""xb"" is not a valid mode for open."
+bad-open-mode:20::"""rx"" is not a valid mode for open."
+bad-open-mode:27::"""+rUb"" is not a valid mode for open."
+bad-open-mode:30::"""aU"" is not a valid mode for open."
+bad-open-mode:36::"""Ubr"" is not a valid mode for open."
+bad-open-mode:37::"""Ut"" is not a valid mode for open."
diff --git a/tests/functional/bad_open_mode_py3.py b/tests/functional/bad_open_mode_py3.py
new file mode 100644
index 000000000..0812f5a21
--- /dev/null
+++ b/tests/functional/bad_open_mode_py3.py
@@ -0,0 +1,23 @@
+"""Warnings for using open() with an invalid mode string."""

+

+NAME = "foo.bar"

+open(NAME, "wb")

+open(NAME, "w")

+open(NAME, "rb")

+open(NAME, "x")

+open(NAME, "br")

+open(NAME, "+r")

+open(NAME, "xb")

+open(NAME, "rwx")  # [bad-open-mode]

+open(NAME, "rr")  # [bad-open-mode]

+open(NAME, "+")  # [bad-open-mode]

+open(NAME, "xw")  # [bad-open-mode]

+open(NAME, "ab+")

+open(NAME, "a+b")

+open(NAME, "+ab")

+open(NAME, "+rUb")

+open(NAME, "x+b")

+open(NAME, "Ua")  # [bad-open-mode]

+open(NAME, "Ur++")  # [bad-open-mode]

+open(NAME, "Ut")

+open(NAME, "Ubr")

diff --git a/tests/functional/bad_open_mode_py3.rc b/tests/functional/bad_open_mode_py3.rc
new file mode 100644
index 000000000..55bbcdde3
--- /dev/null
+++ b/tests/functional/bad_open_mode_py3.rc
@@ -0,0 +1,3 @@
+[testoptions]

+min_pyver=3.0

+except_implementations=PyPy
\ No newline at end of file
diff --git a/tests/functional/bad_open_mode_py3.txt b/tests/functional/bad_open_mode_py3.txt
new file mode 100644
index 000000000..0be0ea84e
--- /dev/null
+++ b/tests/functional/bad_open_mode_py3.txt
@@ -0,0 +1,6 @@
+bad-open-mode:11::"""rwx"" is not a valid mode for open."

+bad-open-mode:12::"""rr"" is not a valid mode for open."

+bad-open-mode:13::"""+"" is not a valid mode for open."

+bad-open-mode:14::"""xw"" is not a valid mode for open."

+bad-open-mode:20::"""Ua"" is not a valid mode for open."

+bad-open-mode:21::"""Ur++"" is not a valid mode for open."

diff --git a/tests/functional/bad_reversed_sequence.py b/tests/functional/bad_reversed_sequence.py
new file mode 100644
index 000000000..6cfac5bed
--- /dev/null
+++ b/tests/functional/bad_reversed_sequence.py
@@ -0,0 +1,84 @@
+""" Checks that reversed() receive proper argument """
+# pylint: disable=missing-docstring, useless-object-inheritance
+# pylint: disable=too-few-public-methods,no-self-use,no-absolute-import
+from collections import deque
+
+__revision__ = 0
+
+class GoodReversed(object):
+    """ Implements __reversed__ """
+    def __reversed__(self):
+        return [1, 2, 3]
+
+class SecondGoodReversed(object):
+    """ Implements __len__ and __getitem__ """
+    def __len__(self):
+        return 3
+
+    def __getitem__(self, index):
+        return index
+
+class BadReversed(object):
+    """ implements only len() """
+    def __len__(self):
+        return 3
+
+class SecondBadReversed(object):
+    """ implements only __getitem__ """
+    def __getitem__(self, index):
+        return index
+
+class ThirdBadReversed(dict):
+    """ dict subclass """
+
+def uninferable(seq):
+    """ This can't be infered at this moment,
+    make sure we don't have a false positive.
+    """
+    return reversed(seq)
+
+def test(path):
+    """ test function """
+    seq = reversed() # No argument given
+    seq = reversed(None) # [bad-reversed-sequence]
+    seq = reversed([1, 2, 3])
+    seq = reversed((1, 2, 3))
+    seq = reversed(set()) # [bad-reversed-sequence]
+    seq = reversed({'a': 1, 'b': 2}) # [bad-reversed-sequence]
+    seq = reversed(iter([1, 2, 3])) # [bad-reversed-sequence]
+    seq = reversed(GoodReversed())
+    seq = reversed(SecondGoodReversed())
+    seq = reversed(BadReversed()) # [bad-reversed-sequence]
+    seq = reversed(SecondBadReversed()) # [bad-reversed-sequence]
+    seq = reversed(range(100))
+    seq = reversed(ThirdBadReversed()) # [bad-reversed-sequence]
+    seq = reversed(lambda: None) # [bad-reversed-sequence]
+    seq = reversed(deque([]))
+    seq = reversed("123")
+    seq = uninferable([1, 2, 3])
+    seq = reversed(path.split("/"))
+    return seq
+
+def test_dict_ancestor_and_reversed():
+    """Don't emit for subclasses of dict, with __reversed__ implemented."""
+    from collections import OrderedDict
+
+    class Child(dict):
+        def __reversed__(self):
+            return reversed(range(10))
+
+    seq = reversed(OrderedDict())
+    return reversed(Child()), seq
+
+
+def test_dont_emit_for_reversing_enums():
+    """Don't emit when reversing enum classes"""
+    from enum import IntEnum
+
+    class Color(IntEnum):
+        RED = 1
+        GREEN = 2
+        BLUE = 3
+
+    for color in reversed(Color):
+        yield color
diff --git a/tests/functional/bad_reversed_sequence.txt b/tests/functional/bad_reversed_sequence.txt
new file mode 100644
index 000000000..dd0c6f96d
--- /dev/null
+++ b/tests/functional/bad_reversed_sequence.txt
@@ -0,0 +1,8 @@
+bad-reversed-sequence:43:test:The first reversed() argument is not a sequence

+bad-reversed-sequence:46:test:The first reversed() argument is not a sequence

+bad-reversed-sequence:47:test:The first reversed() argument is not a sequence

+bad-reversed-sequence:48:test:The first reversed() argument is not a sequence

+bad-reversed-sequence:51:test:The first reversed() argument is not a sequence

+bad-reversed-sequence:52:test:The first reversed() argument is not a sequence

+bad-reversed-sequence:54:test:The first reversed() argument is not a sequence

+bad-reversed-sequence:55:test:The first reversed() argument is not a sequence

diff --git a/tests/functional/bad_staticmethod_argument.py b/tests/functional/bad_staticmethod_argument.py
new file mode 100644
index 000000000..e73bf3dcd
--- /dev/null
+++ b/tests/functional/bad_staticmethod_argument.py
@@ -0,0 +1,16 @@
+# pylint: disable=missing-docstring, no-staticmethod-decorator, useless-object-inheritance
+
+class Abcd(object):
+
+    def method1(self): # [bad-staticmethod-argument]
+        pass
+
+    method1 = staticmethod(method1)
+
+    def method2(cls): # [bad-staticmethod-argument]
+        pass
+
+    method2 = staticmethod(method2)
+
+    def __init__(self):
+        pass
diff --git a/tests/functional/bad_staticmethod_argument.txt b/tests/functional/bad_staticmethod_argument.txt
new file mode 100644
index 000000000..a9d5b468e
--- /dev/null
+++ b/tests/functional/bad_staticmethod_argument.txt
@@ -0,0 +1,2 @@
+bad-staticmethod-argument:5:Abcd.method1:Static method with 'self' as first argument
+bad-staticmethod-argument:10:Abcd.method2:Static method with 'cls' as first argument
\ No newline at end of file
diff --git a/tests/functional/bad_thread_instantiation.py b/tests/functional/bad_thread_instantiation.py
new file mode 100644
index 000000000..e7e02eaed
--- /dev/null
+++ b/tests/functional/bad_thread_instantiation.py
@@ -0,0 +1,8 @@
+# pylint: disable=missing-docstring
+import threading
+
+
+threading.Thread(lambda: None).run()  # [bad-thread-instantiation]
+threading.Thread(None, lambda: None)
+threading.Thread(group=None, target=lambda: None).run()
+threading.Thread() # [bad-thread-instantiation]
diff --git a/tests/functional/bad_thread_instantiation.txt b/tests/functional/bad_thread_instantiation.txt
new file mode 100644
index 000000000..81fb8405b
--- /dev/null
+++ b/tests/functional/bad_thread_instantiation.txt
@@ -0,0 +1,2 @@
+bad-thread-instantiation:5::threading.Thread needs the target function
+bad-thread-instantiation:8::threading.Thread needs the target function
diff --git a/tests/functional/bad_whitespace.py b/tests/functional/bad_whitespace.py
new file mode 100644
index 000000000..9b32087e2
--- /dev/null
+++ b/tests/functional/bad_whitespace.py
@@ -0,0 +1,7 @@
+# pylint: disable = invalid-name,missing-docstring,unused-variable,unused-argument
+def function(hello):
+    x, y, z = (1,2,3,) # [bad-whitespace, bad-whitespace]
+
+AAA =1  # [bad-whitespace]
+BBB =  2  # [bad-whitespace]
+CCC= 1  # [bad-whitespace]
diff --git a/tests/functional/bad_whitespace.txt b/tests/functional/bad_whitespace.txt
new file mode 100644
index 000000000..14431c04c
--- /dev/null
+++ b/tests/functional/bad_whitespace.txt
@@ -0,0 +1,15 @@
+bad-whitespace:3::"Exactly one space required after comma
+    x, y, z = (1,2,3,) # [bad-whitespace, bad-whitespace]
+                  ^"
+bad-whitespace:3::"Exactly one space required after comma
+    x, y, z = (1,2,3,) # [bad-whitespace, bad-whitespace]
+                ^"
+bad-whitespace:5::"Exactly one space required after assignment
+AAA =1  # [bad-whitespace]
+    ^"
+bad-whitespace:6::"Exactly one space required after assignment
+BBB =  2  # [bad-whitespace]
+    ^"
+bad-whitespace:7::"Exactly one space required before assignment
+CCC= 1  # [bad-whitespace]
+   ^"
diff --git a/tests/functional/bare_except.py b/tests/functional/bare_except.py
new file mode 100644
index 000000000..47a207920
--- /dev/null
+++ b/tests/functional/bare_except.py
@@ -0,0 +1,6 @@
+# pylint: disable=missing-docstring, import-error
+
+try:
+    1 + "2"
+except: # [bare-except]
+    pass
diff --git a/tests/functional/bare_except.txt b/tests/functional/bare_except.txt
new file mode 100644
index 000000000..ccb7ba90d
--- /dev/null
+++ b/tests/functional/bare_except.txt
@@ -0,0 +1 @@
+bare-except:5::No exception type(s) specified
\ No newline at end of file
diff --git a/tests/functional/blacklisted_name.py b/tests/functional/blacklisted_name.py
new file mode 100644
index 000000000..b62c6d276
--- /dev/null
+++ b/tests/functional/blacklisted_name.py
@@ -0,0 +1,4 @@
+# pylint: disable=missing-docstring
+
+def baz(): # [blacklisted-name]
+    pass
diff --git a/tests/functional/blacklisted_name.txt b/tests/functional/blacklisted_name.txt
new file mode 100644
index 000000000..f0fc9c20c
--- /dev/null
+++ b/tests/functional/blacklisted_name.txt
@@ -0,0 +1 @@
+blacklisted-name:3:baz:Black listed name "baz"
diff --git a/tests/functional/boolean_datetime.py b/tests/functional/boolean_datetime.py
new file mode 100644
index 000000000..5afc5a42e
--- /dev/null
+++ b/tests/functional/boolean_datetime.py
@@ -0,0 +1,30 @@
+""" Checks for boolean uses of datetime.time. """

+# pylint: disable=superfluous-parens,print-statement,no-absolute-import,consider-using-ternary,simplifiable-if-expression

+import datetime

+

+if datetime.time(0, 0, 0): # [boolean-datetime]

+    print("datetime.time(0,0,0) is not a bug!")

+else:

+    print("datetime.time(0,0,0) is a bug!")

+

+if not datetime.time(0, 0, 1): # [boolean-datetime]

+    print("datetime.time(0,0,1) is not a bug!")

+else:

+    print("datetime.time(0,0,1) is a bug!")

+

+DATA = not datetime.time(0, 0, 0) # [boolean-datetime]

+DATA1 = True if datetime.time(0, 0, 0) else False # [boolean-datetime]

+DATA2 = datetime.time(0, 0, 0) or True # [boolean-datetime]

+DATA3 = datetime.time(0, 0, 0) and True # [boolean-datetime]

+DATA4 = False or True or datetime.time(0, 0, 0) # [boolean-datetime]

+DATA5 = False and datetime.time(0, 0, 0) or True # [boolean-datetime]

+

+

+def cant_infer(data):

+    """ Can't infer what data is """

+    hophop = not data

+    troptrop = True if data else False

+    toptop = data or True

+    return hophop, troptrop, toptop

+

+cant_infer(datetime.time(0, 0, 0))

diff --git a/tests/functional/boolean_datetime.rc b/tests/functional/boolean_datetime.rc
new file mode 100644
index 000000000..abe8fdf16
--- /dev/null
+++ b/tests/functional/boolean_datetime.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max_pyver=3.5
\ No newline at end of file
diff --git a/tests/functional/boolean_datetime.txt b/tests/functional/boolean_datetime.txt
new file mode 100644
index 000000000..f3287d4f7
--- /dev/null
+++ b/tests/functional/boolean_datetime.txt
@@ -0,0 +1,8 @@
+boolean-datetime:5::Using datetime.time in a boolean context.
+boolean-datetime:10::Using datetime.time in a boolean context.
+boolean-datetime:15::Using datetime.time in a boolean context.
+boolean-datetime:16::Using datetime.time in a boolean context.
+boolean-datetime:17::Using datetime.time in a boolean context.
+boolean-datetime:18::Using datetime.time in a boolean context.
+boolean-datetime:19::Using datetime.time in a boolean context.
+boolean-datetime:20::Using datetime.time in a boolean context.
diff --git a/tests/functional/broad_except.py b/tests/functional/broad_except.py
new file mode 100644
index 000000000..24c839951
--- /dev/null
+++ b/tests/functional/broad_except.py
@@ -0,0 +1,14 @@
+# pylint: disable=missing-docstring
+from __future__ import print_function
+__revision__ = 0
+
+try:
+    __revision__ += 1
+except Exception: # [broad-except]
+    print('error')
+
+
+try:
+    __revision__ += 1
+except BaseException: # [broad-except]
+    print('error')
diff --git a/tests/functional/broad_except.txt b/tests/functional/broad_except.txt
new file mode 100644
index 000000000..5a46b03be
--- /dev/null
+++ b/tests/functional/broad_except.txt
@@ -0,0 +1,2 @@
+broad-except:7::Catching too general exception Exception
+broad-except:13::Catching too general exception BaseException
diff --git a/tests/functional/bugfix_local_scope_metaclass_1177.py b/tests/functional/bugfix_local_scope_metaclass_1177.py
new file mode 100644
index 000000000..8904f6fb2
--- /dev/null
+++ b/tests/functional/bugfix_local_scope_metaclass_1177.py
@@ -0,0 +1,56 @@
+# pylint: disable=missing-docstring,too-few-public-methods,import-error
+from UNINFERABLE import ImportedMetaclass
+
+
+class Meta(type):
+    pass
+
+
+class Class(metaclass=Meta):
+    pass
+
+
+def func_scope():
+    class Meta2(type):
+        pass
+
+    class Class2(metaclass=Meta2):
+        pass
+
+    return Class2
+
+
+class ClassScope:
+    class Meta3(type):
+        pass
+
+    class Class3(metaclass=Meta3):
+        pass
+
+    instance = Class3()
+
+
+def mixed_scopes():
+    class ClassM(metaclass=Meta):
+        pass
+
+    return ClassM
+
+
+def imported_and_nested_scope1():
+    class ClassImp1(metaclass=ImportedMetaclass):
+        pass
+
+    class ClassImp2(metaclass=ImportedMetaclass):
+        pass
+
+    return ClassImp1, ClassImp2
+
+
+def imported_and_nested_scope2():
+    from UNINFERABLE import ImportedMetaclass2
+
+    class ClassImp3(metaclass=ImportedMetaclass2):
+        pass
+
+    return ClassImp3
diff --git a/tests/functional/bugfix_local_scope_metaclass_1177.rc b/tests/functional/bugfix_local_scope_metaclass_1177.rc
new file mode 100644
index 000000000..c093be204
--- /dev/null
+++ b/tests/functional/bugfix_local_scope_metaclass_1177.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/cellvar_escaping_loop.py b/tests/functional/cellvar_escaping_loop.py
new file mode 100644
index 000000000..23c6b4b2e
--- /dev/null
+++ b/tests/functional/cellvar_escaping_loop.py
@@ -0,0 +1,120 @@
+# pylint: disable=print-statement
+"""Tests for loopvar-in-closure."""
+from __future__ import print_function
+
+def good_case():
+    """No problems here."""
+    lst = []
+    for i in range(10):
+        lst.append(i)
+
+
+def good_case2():
+    """No problems here."""
+    return [i for i in range(10)]
+
+
+def good_case3():
+    """No problems here."""
+    lst = []
+    for i in range(10):
+        lst.append(lambda i=i: i)
+
+
+def good_case4():
+    """No problems here."""
+    lst = []
+    for i in range(10):
+        print(i)
+        lst.append(lambda i: i)
+
+
+def good_case5():
+    """No problems here."""
+    return (i for i in range(10))
+
+
+def good_case6():
+    """Accept use of the variable inside return."""
+    for i in range(10):
+        if i == 8:
+            return lambda: i
+    return lambda: -1
+
+
+def good_case7():
+    """Lambda defined and called in loop."""
+    for i in range(10):
+        print((lambda x: i + x)(1))
+
+
+def good_case8():
+    """Another eager binding of the cell variable."""
+    funs = []
+    for i in range(10):
+        def func(bound_i=i):
+            """Ignore."""
+            return bound_i
+        funs.append(func)
+    return funs
+
+
+def bad_case():
+    """Closing over a loop variable."""
+    lst = []
+    for i in range(10):
+        print(i)
+        lst.append(lambda: i)  # [cell-var-from-loop]
+
+
+def bad_case2():
+    """Closing over a loop variable."""
+    return [lambda: i for i in range(10)]  # [cell-var-from-loop]
+
+
+def bad_case3():
+    """Closing over variable defined in loop."""
+    lst = []
+    for i in range(10):
+        j = i * i
+        lst.append(lambda: j)  # [cell-var-from-loop]
+    return lst
+
+
+def bad_case4():
+    """Closing over variable defined in loop."""
+    lst = []
+    for i in range(10):
+        def nested():
+            """Nested function."""
+            return i**2  # [cell-var-from-loop]
+        lst.append(nested)
+    return lst
+
+
+def bad_case5():
+    """Problematic case.
+
+    If this function is used as
+
+    >>> [x() for x in bad_case5()]
+
+    it behaves 'as expected', i.e. the result is range(10).
+
+    If it's used with
+
+    >>> lst = list(bad_case5())
+    >>> [x() for x in lst]
+
+    the result is [9] * 10 again.
+    """
+    return (lambda: i for i in range(10))  # [cell-var-from-loop]
+
+
+def bad_case6():
+    """Closing over variable defined in loop."""
+    lst = []
+    for i, j in zip(range(10), range(10, 20)):
+        print(j)
+        lst.append(lambda: i)  # [cell-var-from-loop]
+    return lst
diff --git a/tests/functional/cellvar_escaping_loop.txt b/tests/functional/cellvar_escaping_loop.txt
new file mode 100644
index 000000000..2ac0b58ef
--- /dev/null
+++ b/tests/functional/cellvar_escaping_loop.txt
@@ -0,0 +1,6 @@
+cell-var-from-loop:67:bad_case.<lambda>:Cell variable i defined in loop
+cell-var-from-loop:72:bad_case2.<lambda>:Cell variable i defined in loop
+cell-var-from-loop:80:bad_case3.<lambda>:Cell variable j defined in loop
+cell-var-from-loop:90:bad_case4.nested:Cell variable i defined in loop
+cell-var-from-loop:111:bad_case5.<lambda>:Cell variable i defined in loop
+cell-var-from-loop:119:bad_case6.<lambda>:Cell variable i defined in loop
diff --git a/tests/functional/class_members_py27.py b/tests/functional/class_members_py27.py
new file mode 100644
index 000000000..584faa5e8
--- /dev/null
+++ b/tests/functional/class_members_py27.py
@@ -0,0 +1,70 @@
+""" Various tests for class members access. """

+# pylint: disable=R0903,print-statement,no-absolute-import, metaclass-assignment,import-error,no-init,missing-docstring, wrong-import-order,wrong-import-position, useless-object-inheritance

+from missing import Missing

+class MyClass(object):

+    """class docstring"""

+

+    def __init__(self):

+        """init"""

+        self.correct = 1

+

+    def test(self):

+        """test"""

+        self.correct += 2

+        self.incorrect += 2 # [no-member]

+        del self.havenot # [no-member]

+        self.nonexistent1.truc() # [no-member]

+        self.nonexistent2[1] = 'hehe' # [no-member]

+

+class XYZMixin(object):

+    """access to undefined members should be ignored in mixin classes by

+    default

+    """

+    def __init__(self):

+        print self.nonexistent

+

+

+class NewClass(object):

+    """use object.__setattr__"""

+    def __init__(self):

+        self.__setattr__('toto', 'tutu')

+

+from abc import ABCMeta

+

+class TestMetaclass(object):

+    """ Test attribute access for metaclasses. """

+    __metaclass__ = ABCMeta

+

+class Metaclass(type):

+    """ metaclass """

+    @classmethod

+    def test(cls):

+        """ classmethod """

+

+class UsingMetaclass(object):

+    """ empty """

+    __metaclass__ = Metaclass

+

+TestMetaclass.register(int)

+UsingMetaclass.test()

+TestMetaclass().register(int) # [no-member]

+UsingMetaclass().test() # [no-member]

+

+

+class NoKnownBases(Missing):

+    """Don't emit no-member if we don't know the bases of a class."""

+

+NoKnownBases().lalala()

+

+

+class MetaClass(object):

+    """Look some methods in the implicit metaclass."""

+

+    @classmethod

+    def whatever(cls):

+        return cls.mro() + cls.missing() # [no-member]

+

+from collections import namedtuple

+

+Tuple = namedtuple("Tuple", "field other")

+Tuple.field.__doc__ = "A doc for the field."

diff --git a/tests/functional/class_members_py27.rc b/tests/functional/class_members_py27.rc
new file mode 100644
index 000000000..80170b777
--- /dev/null
+++ b/tests/functional/class_members_py27.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=2.7

+max_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/class_members_py27.txt b/tests/functional/class_members_py27.txt
new file mode 100644
index 000000000..3a3be0ede
--- /dev/null
+++ b/tests/functional/class_members_py27.txt
@@ -0,0 +1,7 @@
+no-member:14:MyClass.test:Instance of 'MyClass' has no 'incorrect' member:INFERENCE
+no-member:15:MyClass.test:Instance of 'MyClass' has no 'havenot' member:INFERENCE
+no-member:16:MyClass.test:Instance of 'MyClass' has no 'nonexistent1' member:INFERENCE
+no-member:17:MyClass.test:Instance of 'MyClass' has no 'nonexistent2' member:INFERENCE
+no-member:50::Instance of 'TestMetaclass' has no 'register' member:INFERENCE
+no-member:51::Instance of 'UsingMetaclass' has no 'test' member:INFERENCE
+no-member:65:MetaClass.whatever:Class 'MetaClass' has no 'missing' member:INFERENCE
diff --git a/tests/functional/class_members_py30.py b/tests/functional/class_members_py30.py
new file mode 100644
index 000000000..49eb93a2a
--- /dev/null
+++ b/tests/functional/class_members_py30.py
@@ -0,0 +1,68 @@
+""" Various tests for class members access. """

+# pylint: disable=R0903,import-error,no-init,missing-docstring, wrong-import-position,wrong-import-order, useless-object-inheritance

+from missing import Missing

+class MyClass(object):

+    """class docstring"""

+

+    def __init__(self):

+        """init"""

+        self.correct = 1

+

+    def test(self):

+        """test"""

+        self.correct += 2

+        self.incorrect += 2 # [no-member]

+        del self.havenot # [no-member]

+        self.nonexistent1.truc() # [no-member]

+        self.nonexistent2[1] = 'hehe' # [no-member]

+

+class XYZMixin(object):

+    """access to undefined members should be ignored in mixin classes by

+    default

+    """

+    def __init__(self):

+        print(self.nonexistent)

+

+

+class NewClass(object):

+    """use object.__setattr__"""

+    def __init__(self):

+        self.__setattr__('toto', 'tutu')

+

+from abc import ABCMeta

+

+class TestMetaclass(object, metaclass=ABCMeta):

+    """ Test attribute access for metaclasses. """

+

+class Metaclass(type):

+    """ metaclass """

+    @classmethod

+    def test(cls):

+        """ classmethod """

+

+class UsingMetaclass(object, metaclass=Metaclass):

+    """ empty """

+

+TestMetaclass.register(int)

+UsingMetaclass.test()

+TestMetaclass().register(int) # [no-member]

+UsingMetaclass().test() # [no-member]

+

+

+class NoKnownBases(Missing):

+    """Don't emit no-member if we don't know the bases of a class."""

+

+NoKnownBases().lalala()

+

+

+class MetaClass(object):

+    """Look some methods in the implicit metaclass."""

+

+    @classmethod

+    def whatever(cls):

+        return cls.mro() + cls.missing() # [no-member]

+

+from collections import namedtuple

+

+Tuple = namedtuple("Tuple", "field other")

+Tuple.field.__doc__ = "A doc for the field."

diff --git a/tests/functional/class_members_py30.rc b/tests/functional/class_members_py30.rc
new file mode 100644
index 000000000..8c6eb56c4
--- /dev/null
+++ b/tests/functional/class_members_py30.rc
@@ -0,0 +1,2 @@
+[testoptions]

+min_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/class_members_py30.txt b/tests/functional/class_members_py30.txt
new file mode 100644
index 000000000..d9163ec73
--- /dev/null
+++ b/tests/functional/class_members_py30.txt
@@ -0,0 +1,7 @@
+no-member:14:MyClass.test:Instance of 'MyClass' has no 'incorrect' member:INFERENCE

+no-member:15:MyClass.test:Instance of 'MyClass' has no 'havenot' member:INFERENCE

+no-member:16:MyClass.test:Instance of 'MyClass' has no 'nonexistent1' member:INFERENCE

+no-member:17:MyClass.test:Instance of 'MyClass' has no 'nonexistent2' member:INFERENCE

+no-member:48::Instance of 'TestMetaclass' has no 'register' member:INFERENCE

+no-member:49::Instance of 'UsingMetaclass' has no 'test' member:INFERENCE

+no-member:63:MetaClass.whatever:Class 'MetaClass' has no 'missing' member:INFERENCE
\ No newline at end of file
diff --git a/tests/functional/class_scope.py b/tests/functional/class_scope.py
new file mode 100644
index 000000000..309ebd6da
--- /dev/null
+++ b/tests/functional/class_scope.py
@@ -0,0 +1,22 @@
+# pylint: disable=R0903,W0232, useless-object-inheritance
+"""check for scope problems"""
+
+__revision__ = None
+
+class Well(object):
+    """well"""
+    attr = 42
+    get_attr = lambda arg=attr: arg * 24
+    # +1: [used-before-assignment]
+    get_attr_bad = lambda arg=revattr: revattr * 42
+    revattr = 24
+    bad_lambda = lambda: get_attr_bad # [undefined-variable]
+
+    class Data(object):
+        """base hidden class"""
+    class Sub(Data):
+        """whaou, is Data found???"""
+        attr = Data() # [undefined-variable]
+    def func(self):
+        """check Sub is not defined here"""
+        return Sub(), self # [undefined-variable]
diff --git a/tests/functional/class_scope.txt b/tests/functional/class_scope.txt
new file mode 100644
index 000000000..ea6c45abf
--- /dev/null
+++ b/tests/functional/class_scope.txt
@@ -0,0 +1,4 @@
+used-before-assignment:11:Well.<lambda>:Using variable 'revattr' before assignment
+undefined-variable:13:Well.<lambda>:Undefined variable 'get_attr_bad'
+undefined-variable:19:Well.Sub:Undefined variable 'Data'
+undefined-variable:22:Well.func:Undefined variable 'Sub'
diff --git a/tests/functional/comparison_with_callable.py b/tests/functional/comparison_with_callable.py
new file mode 100644
index 000000000..ea7024c1b
--- /dev/null
+++ b/tests/functional/comparison_with_callable.py
@@ -0,0 +1,60 @@
+# pylint: disable = blacklisted-name, missing-docstring, useless-return, misplaced-comparison-constant, invalid-name, no-self-use, line-too-long, useless-object-inheritance
+def foo():
+    return None
+
+def goo():
+    return None
+
+if foo == 786:  # [comparison-with-callable]
+    pass
+
+if 666 == goo:  # [comparison-with-callable]
+    pass
+
+if foo == goo:
+    pass
+
+if foo() == goo():
+    pass
+
+
+class FakeClass(object):
+    def __init__(self):
+        self._fake_prop = 'fake it till you make it!!'
+
+    def fake_method(self):
+        return '666 - The Number of the Beast'
+
+    @property
+    def fake_property(self):
+        return self._fake_prop
+
+    @fake_property.setter
+    def fake_property(self, prop):
+        self._fake_prop = prop
+
+obj1 = FakeClass()
+obj2 = FakeClass()
+
+if obj1.fake_method == obj2.fake_method:
+    pass
+
+if obj1.fake_property != obj2.fake_property:    # property although is function but is called without parenthesis
+    pass
+
+if obj1.fake_method != foo:
+    pass
+
+if obj1.fake_method != 786: # [comparison-with-callable]
+    pass
+
+if obj1.fake_method != obj2.fake_property: # [comparison-with-callable]
+    pass
+
+if 666 == 786:
+    pass
+
+a = 666
+b = 786
+if a == b:
+    pass
diff --git a/tests/functional/comparison_with_callable.txt b/tests/functional/comparison_with_callable.txt
new file mode 100644
index 000000000..87eefb181
--- /dev/null
+++ b/tests/functional/comparison_with_callable.txt
@@ -0,0 +1,5 @@
+comparison-with-callable:8::Comparing against a callable, did you omit the parenthesis?
+comparison-with-callable:11::Comparing against a callable, did you omit the parenthesis?
+comparison-with-callable:45::Comparing against a callable, did you omit the parenthesis?
+comparison-with-callable:48::Comparing against a callable, did you omit the parenthesis?
+comparison-with-callable:51::Comparing against a callable, did you omit the parenthesis?
diff --git a/tests/functional/confidence_filter.py b/tests/functional/confidence_filter.py
new file mode 100644
index 000000000..42351998d
--- /dev/null
+++ b/tests/functional/confidence_filter.py
@@ -0,0 +1,16 @@
+"""Test for the confidence filter."""
+from __future__ import print_function
+# pylint: disable=useless-object-inheritance
+
+class Client(object):
+    """use provider class"""
+
+    def __init__(self):
+        self.set_later = 0
+
+    def set_set_later(self, value):
+        """set set_later attribute (introduce an inference ambiguity)"""
+        self.set_later = value
+
+print(Client().set_later.lower())
+print(Client().foo)  # [no-member]
diff --git a/tests/functional/confidence_filter.rc b/tests/functional/confidence_filter.rc
new file mode 100644
index 000000000..74953b686
--- /dev/null
+++ b/tests/functional/confidence_filter.rc
@@ -0,0 +1,3 @@
+[Messages Control]
+disable=no-init,too-few-public-methods,undefined-variable,print-statement
+confidence=INFERENCE,HIGH,UNDEFINED
diff --git a/tests/functional/confidence_filter.txt b/tests/functional/confidence_filter.txt
new file mode 100644
index 000000000..3dbb2eaf2
--- /dev/null
+++ b/tests/functional/confidence_filter.txt
@@ -0,0 +1 @@
+no-member:16::Instance of 'Client' has no 'foo' member:INFERENCE
diff --git a/tests/functional/confusing_with_statement.py b/tests/functional/confusing_with_statement.py
new file mode 100644
index 000000000..7b8d494e4
--- /dev/null
+++ b/tests/functional/confusing_with_statement.py
@@ -0,0 +1,27 @@
+# pylint: disable=undefined-variable,not-context-manager,missing-docstring
+
+# both context managers are named
+with one as first, two as second:
+    pass
+
+# first matched as tuple; this is ok
+with one as (first, second), third:
+    pass
+
+# the first context manager doesn't have as name
+with one, two as second:
+    pass
+
+# the second is a function call; this is ok
+with one as first, two():
+    pass
+
+# nested with statements; make sure no message is emitted
+# this could be a false positive on Py2
+with one as first:
+    with two:
+        pass
+
+# ambiguous looking with statement
+with one as first, two:  # [confusing-with-statement]
+    pass
diff --git a/tests/functional/confusing_with_statement.txt b/tests/functional/confusing_with_statement.txt
new file mode 100644
index 000000000..750ad714f
--- /dev/null
+++ b/tests/functional/confusing_with_statement.txt
@@ -0,0 +1 @@
+confusing-with-statement:26::Following "as" with another context manager looks like a tuple.
diff --git a/tests/functional/consider_iterating_dictionary.py b/tests/functional/consider_iterating_dictionary.py
new file mode 100644
index 000000000..180ee3bd3
--- /dev/null
+++ b/tests/functional/consider_iterating_dictionary.py
@@ -0,0 +1,38 @@
+# pylint: disable=missing-docstring, expression-not-assigned, too-few-public-methods, no-member, import-error, no-self-use, line-too-long, useless-object-inheritance
+
+from unknown import Unknown
+
+
+class CustomClass(object):
+    def keys(self):
+        return []
+
+for key in Unknown().keys():
+    pass
+for key in Unknown.keys():
+    pass
+for key in dict.keys():
+    pass
+for key in {}.values():
+    pass
+for key in {}.key():
+    pass
+for key in CustomClass().keys():
+    pass
+
+[key for key in {}.keys()] # [consider-iterating-dictionary]
+(key for key in {}.keys()) # [consider-iterating-dictionary]
+{key for key in {}.keys()} # [consider-iterating-dictionary]
+{key: key for key in {}.keys()} # [consider-iterating-dictionary]
+COMP1 = [key for key in {}.keys()] # [consider-iterating-dictionary]
+COMP2 = (key for key in {}.keys()) # [consider-iterating-dictionary]
+COMP3 = {key for key in {}.keys()} # [consider-iterating-dictionary]
+COMP4 = {key: key for key in {}.keys()} # [consider-iterating-dictionary]
+for key in {}.keys(): # [consider-iterating-dictionary]
+    pass
+
+# Issue #1247
+DICT = {'a': 1, 'b': 2}
+COMP1 = [k * 2 for k in DICT.keys()] + [k * 3 for k in DICT.keys()]  # [consider-iterating-dictionary,consider-iterating-dictionary]
+COMP2, COMP3 = [k * 2 for k in DICT.keys()], [k * 3 for k in DICT.keys()]  # [consider-iterating-dictionary,consider-iterating-dictionary]
+SOME_TUPLE = ([k * 2 for k in DICT.keys()], [k * 3 for k in DICT.keys()])  # [consider-iterating-dictionary,consider-iterating-dictionary]
diff --git a/tests/functional/consider_iterating_dictionary.txt b/tests/functional/consider_iterating_dictionary.txt
new file mode 100644
index 000000000..bd596eb6b
--- /dev/null
+++ b/tests/functional/consider_iterating_dictionary.txt
@@ -0,0 +1,15 @@
+consider-iterating-dictionary:23::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:24::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:25::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:26::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:27::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:28::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:29::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:30::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:31::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:36::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:36::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:37::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:37::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:38::Consider iterating the dictionary directly instead of calling .keys()
+consider-iterating-dictionary:38::Consider iterating the dictionary directly instead of calling .keys()
diff --git a/tests/functional/consider_join.py b/tests/functional/consider_join.py
new file mode 100644
index 000000000..24cd6dd49
--- /dev/null
+++ b/tests/functional/consider_join.py
@@ -0,0 +1,126 @@
+# pylint: disable=missing-docstring,invalid-name,undefined-variable,multiple-statements
+
+# Variations of 'result'
+result = ''
+for number in ['1', '2', '3']:
+    result += number  # [consider-using-join]
+
+result = 'header'
+for number in ['1', '2', '3']:
+    result += number  # [consider-using-join]
+
+result = another_result = ''
+for number in ['1', '2', '3']:
+    result += number  # [consider-using-join]
+
+another_result = result = ''
+for number in ['1', '2', '3']:
+    result += number  # [consider-using-join]
+
+result = 0  # result is not a string
+for number in ['1', '2', '3']:
+    result += number
+
+RESULT = ''  # wrong name / initial variable missing
+for number in ['1', '2', '3']:
+    result += [number]
+
+string_variable = ''
+result = string_variable  # type of 'result' not obviously a string
+for number in ['1', '2', '3']:
+    result += number
+
+result = ''
+another_result = ''  # result defined too early
+for number in ['1', '2', '3']:
+    result += [number]
+
+for number in ['1', '2', '3']:  # 'result'-definition missing
+    result += number
+
+
+# Variations of 'number'
+result = ''  # no concatenation (iterator-name differs)
+for name in ['1', '2', '3']:
+    result += number
+
+result = ''  # no concatenation (iterator-name differs)
+for _ in ['1', '2', '3']:
+    result += number
+# 'exprlist' is not a single name
+for index, number in ['1', '2', '3']:
+    result += number
+
+
+# Variations of 'iterable'
+result = ''
+for number in []:
+    result += number  # [consider-using-join]
+
+result = ''
+for number in "a text":
+    result += number  # [consider-using-join]
+
+result = ''
+for number in [1, 2, 3]:
+    result += number  # [consider-using-join]
+
+a_list = [1, 2, 3]
+result = ''
+for number in a_list:
+    result += number  # [consider-using-join]
+
+result = ''
+for number in ['1', '2', '3']:
+    result += number  # [consider-using-join]
+
+result = ''
+for number in undefined_iterable:
+    result += number  # [consider-using-join]
+
+
+# Variations of loop-body
+result = ''  # addition is not the only part of the body
+for number in ['1', '2', '3']:
+    print(number)
+    result += number
+
+result = ''  # addition is not the only part of the body
+for number in ['1', '2', '3']:
+    result += number
+    print(number)
+
+result = ''  # augmented addition is not a simple one
+for number in ['1', '2', '3']:
+    result += '4' + number
+
+result = ''  # assignment is not augmented
+for number in ['1', '2', '3']:
+    result = number
+
+result = ''  # augmented assignment is not an addition
+for number in ['1', '2', '3']:
+    result -= number
+
+result = ''  # addition is not the 'number'-iterable
+for number in ['1', '2', '3']:
+    result += another_number
+
+result = ''
+for number in ['1', '2', '3']: result += number  # [consider-using-join]
+
+result = ''
+for number in ['1']:
+    result.result += number
+
+# Does not emit if the body is more complex
+result = {'context': 1}
+result['context'] = 0
+for number in ['1']:
+    result1 = 42 + int(number)
+    result['context'] += result1 * 24
+
+# Does not crash if the previous sibling does not have AssignNames
+result['context'] = 0
+for number in ['1']:
+    result['context'] += 24
diff --git a/tests/functional/consider_join.txt b/tests/functional/consider_join.txt
new file mode 100644
index 000000000..e550b2b0d
--- /dev/null
+++ b/tests/functional/consider_join.txt
@@ -0,0 +1,11 @@
+consider-using-join:6::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:10::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:14::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:18::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:58::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:62::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:66::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:71::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:75::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:79::Consider using str.join(sequence) for concatenating strings from an iterable
+consider-using-join:110::Consider using str.join(sequence) for concatenating strings from an iterable
\ No newline at end of file
diff --git a/tests/functional/consider_merging_isinstance.py b/tests/functional/consider_merging_isinstance.py
new file mode 100644
index 000000000..34068d9b7
--- /dev/null
+++ b/tests/functional/consider_merging_isinstance.py
@@ -0,0 +1,37 @@
+"""Checks use of consider-merging-isinstance"""
+# pylint:disable=line-too-long
+
+
+def isinstances():
+    "Examples of isinstances"
+    var = range(10)
+
+    # merged
+    if isinstance(var[1], (int, float)):
+        pass
+    result = isinstance(var[2], (int, float))
+
+    # not merged
+    if isinstance(var[3], int) or isinstance(var[3], float) or isinstance(var[3], list) and True:  # [consider-merging-isinstance]
+        pass
+    result = isinstance(var[4], int) or isinstance(var[4], float) or isinstance(var[5], list) and False  # [consider-merging-isinstance]
+
+    result = isinstance(var[5], int) or True or isinstance(var[5], float)  # [consider-merging-isinstance]
+
+    infered_isinstance = isinstance
+    result = infered_isinstance(var[6], int) or infered_isinstance(var[6], float) or infered_isinstance(var[6], list) and False   # [consider-merging-isinstance]
+    result = isinstance(var[10], str) or isinstance(var[10], int) and var[8] * 14 or isinstance(var[10], float) and var[5] * 14.4 or isinstance(var[10], list)   # [consider-merging-isinstance]
+    result = isinstance(var[11], int) or isinstance(var[11], int) or isinstance(var[11], float)   # [consider-merging-isinstance]
+
+    result = isinstance(var[20])
+    result = isinstance()
+
+    # Combination merged and not merged
+    result = isinstance(var[12], (int, float)) or isinstance(var[12], list)  # [consider-merging-isinstance]
+
+    # not merged but valid
+    result = isinstance(var[5], int) and var[5] * 14 or isinstance(var[5], float) and var[5] * 14.4
+    result = isinstance(var[7], int) or not isinstance(var[7], float)
+    result = isinstance(var[6], int) or isinstance(var[7], float)
+    result = isinstance(var[6], int) or isinstance(var[7], int)
+    return result
diff --git a/tests/functional/consider_merging_isinstance.txt b/tests/functional/consider_merging_isinstance.txt
new file mode 100644
index 000000000..a2c5338f7
--- /dev/null
+++ b/tests/functional/consider_merging_isinstance.txt
@@ -0,0 +1,7 @@
+consider-merging-isinstance:15:isinstances:Consider merging these isinstance calls to isinstance(var[3], (float, int))
+consider-merging-isinstance:17:isinstances:Consider merging these isinstance calls to isinstance(var[4], (float, int))
+consider-merging-isinstance:19:isinstances:Consider merging these isinstance calls to isinstance(var[5], (float, int))
+consider-merging-isinstance:22:isinstances:Consider merging these isinstance calls to isinstance(var[6], (float, int))
+consider-merging-isinstance:23:isinstances:Consider merging these isinstance calls to isinstance(var[10], (list, str))
+consider-merging-isinstance:24:isinstances:Consider merging these isinstance calls to isinstance(var[11], (float, int))
+consider-merging-isinstance:30:isinstances:Consider merging these isinstance calls to isinstance(var[12], (float, int, list))
diff --git a/tests/functional/consider_swap_variables.py b/tests/functional/consider_swap_variables.py
new file mode 100644
index 000000000..e3320773f
--- /dev/null
+++ b/tests/functional/consider_swap_variables.py
@@ -0,0 +1,25 @@
+# pylint: disable=missing-docstring,invalid-name,using-constant-test
+
+a, b, c, d = 'a b c d'.split()
+
+temp = a # [consider-swap-variables]
+a = b
+b = temp
+
+temp = a  # only simple swaps are reported
+a = b
+if True:
+    b = a
+
+temp = a  # this is no swap
+a = b
+b = a
+
+temp = a, b  # complex swaps are ignored
+a, b = c, d
+c, d = temp
+
+temp = a # [consider-swap-variables]
+a = b  # longer swap circles are only reported once
+b = temp
+temp = a
diff --git a/tests/functional/consider_swap_variables.txt b/tests/functional/consider_swap_variables.txt
new file mode 100644
index 000000000..3a232fdd0
--- /dev/null
+++ b/tests/functional/consider_swap_variables.txt
@@ -0,0 +1,2 @@
+consider-swap-variables:5::Consider using tuple unpacking for swapping variables
+consider-swap-variables:22::Consider using tuple unpacking for swapping variables
\ No newline at end of file
diff --git a/tests/functional/consider_using_dict_comprehension.py b/tests/functional/consider_using_dict_comprehension.py
new file mode 100644
index 000000000..da0be6d5a
--- /dev/null
+++ b/tests/functional/consider_using_dict_comprehension.py
@@ -0,0 +1,12 @@
+# pylint: disable=missing-docstring, invalid-name

+

+numbers = [1, 2, 3, 4, 5, 6]

+

+dict()

+

+dict([])

+

+dict([(number, number*2) for number in numbers])  # [consider-using-dict-comprehension]

+

+# Cannot emit as this cannot be written as a comprehension

+dict([value.split("=") for value in ["a=b", "c=d"]])

diff --git a/tests/functional/consider_using_dict_comprehension.txt b/tests/functional/consider_using_dict_comprehension.txt
new file mode 100644
index 000000000..206351e6e
--- /dev/null
+++ b/tests/functional/consider_using_dict_comprehension.txt
@@ -0,0 +1 @@
+consider-using-dict-comprehension:9::Consider using a dictionary comprehension
\ No newline at end of file
diff --git a/tests/functional/consider_using_enumerate.py b/tests/functional/consider_using_enumerate.py
new file mode 100644
index 000000000..758375c37
--- /dev/null
+++ b/tests/functional/consider_using_enumerate.py
@@ -0,0 +1,67 @@
+"""Emit a message for iteration through range and len is encountered."""

+

+# pylint: disable=missing-docstring, import-error, useless-object-inheritance, unsubscriptable-object, too-few-public-methods

+

+def bad():

+    iterable = [1, 2, 3]

+    for obj in range(len(iterable)): # [consider-using-enumerate]

+        yield iterable[obj]

+    for obj in range(0, len(iterable)): # [consider-using-enumerate]

+        yield iterable[obj]

+

+

+class Bad(object):

+

+    def __iter__(self):

+        iterable = [1, 2, 3]

+        for i in range(len(iterable)): # [consider-using-enumerate]

+            yield iterable[i]

+

+    def test(self):

+        for i in range(len(self)): # [consider-using-enumerate]

+            yield self[i]

+

+

+def good():

+    iterable = other_obj = [1, 2, 3]

+    total = 0

+    for obj in range(len(iterable)):

+        total += obj

+        yield total

+        yield iterable[obj + 1: 2]

+        yield iterable[len(obj)]

+    for obj in iterable:

+        yield iterable[obj - 1]

+

+    for index, obj in enumerate(iterable):

+        yield iterable[index]

+    for index in range(0, 10):

+        yield iterable[index + 1]

+    for index in range(10):

+        yield iterable[index]

+    for index in range(len([1, 2, 3, 4])):

+        yield index

+    for index in range(1, len(iterable)):

+        yield index

+    for index in range(len(iterable)):

+        yield [1, 2, 3][index]

+        yield len([1, 2, 3])

+    for index in range(len(iterable)):

+        yield other_obj[index]

+

+    from unknown import unknown

+    for index in range(unknown(iterable)):

+        yield iterable[index]

+

+    for index in range(len(iterable)):

+        def test(iterable):

+            return iterable[index]

+        yield test([1, 2, 3])

+

+

+class Good(object):

+

+    def __iter__(self):

+        # Should not suggest enumerate on self

+        for i in range(len(self)):

+            yield self[i]

diff --git a/tests/functional/consider_using_enumerate.txt b/tests/functional/consider_using_enumerate.txt
new file mode 100644
index 000000000..9cbf330fb
--- /dev/null
+++ b/tests/functional/consider_using_enumerate.txt
@@ -0,0 +1,4 @@
+consider-using-enumerate:7:bad:Consider using enumerate instead of iterating with range and len
+consider-using-enumerate:9:bad:Consider using enumerate instead of iterating with range and len
+consider-using-enumerate:17:Bad.__iter__:Consider using enumerate instead of iterating with range and len
+consider-using-enumerate:21:Bad.test:Consider using enumerate instead of iterating with range and len
diff --git a/tests/functional/consider_using_get.py b/tests/functional/consider_using_get.py
new file mode 100644
index 000000000..8c5c68901
--- /dev/null
+++ b/tests/functional/consider_using_get.py
@@ -0,0 +1,90 @@
+# pylint: disable=missing-docstring,invalid-name,using-constant-test,invalid-sequence-index,undefined-variable
+dictionary = dict()
+key = 'key'
+
+if 'key' in dictionary:  # [consider-using-get]
+    variable = dictionary['key']
+
+if 'key' in dictionary:  # [consider-using-get]
+    variable = dictionary['key']
+else:
+    variable = 'default'
+
+if key in dictionary:  # [consider-using-get]
+    variable = dictionary[key]
+
+if 'key' in dictionary:  # not accessing the dictionary in assignment
+    variable = "string"
+
+if 'key' in dictionary:  # is a match, but not obvious and we ignore it for now
+    variable = dictionary[key]
+
+if 'key1' in dictionary:  # dictionary querried for wrong key
+    variable = dictionary['key2']
+
+if 'key' in dictionary:  # body is not pure
+    variable = dictionary['key']
+    print('found')
+
+if 'key' in dictionary:  # body is not pure
+    variable = dictionary['key']
+    print('found')
+else:
+    variable = 'default'
+
+if 'key' in dictionary1:  # different dictionaries
+    variable = dictionary2['key']
+else:
+    variable = 'default'
+
+if 'key' in dictionary:  # body is not pure
+    variable = dictionary['key']
+else:
+    variable = 'default'
+    print('found')
+
+if 'key' in dictionary:  # different variables
+    variable1 = dictionary['key']
+else:
+    variable2 = 'default'
+
+if 'key' in dictionary:  # assignment is not simple
+    variable1 = variable2 = dictionary['key']
+
+if 'key' in dictionary:  # assignment is not simple
+    variable1 = dictionary['key']
+else:
+    variable1 = variable2 = "default"
+
+if 'word' in 'text':
+    variable = 'text'['word']  # already bogus, but to assert that this only works with dictionaries
+
+if 'word' in dictionary:
+    variable = 'dictionary'['word']
+
+if 'key1' in dictionary:  # not the simple case
+    variable = dictionary['key1']
+elif 'key2' in dictionary:  # [consider-using-get]
+    variable = dictionary['key2']
+else:
+    variable = 'default'
+
+if 'key' in dictionary and bool(key):  # not a simple compare
+    variable = dictionary['key1']
+else:
+    variable = 'default'
+
+if bool(key) and 'key' in dictionary:  # not a simple compare
+    variable = dictionary['key1']
+else:
+    variable = 'default'
+
+
+d1 = {'foo': None}
+d2 = {}
+# Cannot be represented as using .get()
+if 'foo' in d1:
+    d2['bar'] = d1['foo']
+
+if 'key' in dictionary:
+    variable = dictionary[1:]
diff --git a/tests/functional/consider_using_get.txt b/tests/functional/consider_using_get.txt
new file mode 100644
index 000000000..012ba0a77
--- /dev/null
+++ b/tests/functional/consider_using_get.txt
@@ -0,0 +1,4 @@
+consider-using-get:5::Consider using dict.get for getting values from a dict if a key is present or a default if not
+consider-using-get:8::Consider using dict.get for getting values from a dict if a key is present or a default if not
+consider-using-get:13::Consider using dict.get for getting values from a dict if a key is present or a default if not
+consider-using-get:67::Consider using dict.get for getting values from a dict if a key is present or a default if not
diff --git a/tests/functional/consider_using_in.py b/tests/functional/consider_using_in.py
new file mode 100644
index 000000000..fb68ac5e6
--- /dev/null
+++ b/tests/functional/consider_using_in.py
@@ -0,0 +1,46 @@
+# pylint: disable=missing-docstring, invalid-name, pointless-statement, misplaced-comparison-constant, undefined-variable, literal-comparison, line-too-long, unneeded-not
+
+value = value1 = 1
+value2 = 2
+a_set = {1, 2, 3}
+a_list = [1, 2, 3]
+a_str = '1'
+
+# Positive
+value == 1 or value == 1  # [consider-using-in]
+value == 1 or value == 2  # [consider-using-in]
+'value' == value or 'value' == value  # [consider-using-in]
+value == 1 or value == undef_value  # [consider-using-in]
+value == 1 or value == 2 or value == 3  # [consider-using-in]
+value == '2' or value == 1  # [consider-using-in]
+1 == value or 2 == value  # [consider-using-in]
+1 == value or value == 2  # [consider-using-in]
+value == 1 or value == a_list  # [consider-using-in]
+value == a_set or value == a_list or value == a_str  # [consider-using-in]
+value != 1 and value != 2  # [consider-using-in]
+value1 == value2 or value2 == value1  # [consider-using-in]
+a_list == [1, 2, 3] or a_list == []  # [consider-using-in]
+
+# Negative
+value != 1 or value != 2  # not a "not in"-case because of "or"
+value == 1 and value == 2  # not a "in"-case because of "and"
+value == 1 and value == 2 or value == 3  # not only 'or's
+value == 1 or value == 2 or 3 < value < 4  # not only '=='
+value == 1  # value not checked against multiple values
+value == 1 or value == 2 or value == 3 and value == 4  # not all checks are concatenated with 'or'
+value == 1 or 2 < value < 3  # length of 'ops' != 1 for second check
+value is 1 or value is 2  # 'in' compares using '==' not 'is' and therefore not considered
+not value == 1 and not value == 2
+value1 == 1 or value2 == 2  # different variables and only one comparison for each
+value1 == value2 == 1 or value1 == 2  # not checking multi-compares for '=='
+value1 != 1 == value2 and value2 != value1 != 2  # not checking multi-compares for '!='
+value1 == 1 or value1 == value2 or value2 == 3  # value1 or value2 do not occur in every check
+value1 == 1 or value1 == 2 or value2 == 1 or value2 == 2  # value1 or value2 do not occur in every check
+'value' == 1 or 'value' == 2  # only detect variables for now
+
+
+def oops():
+    return 5 / 0
+
+
+some_value = value == 4 or value == 5 or value == oops() # We only look for names and constants
diff --git a/tests/functional/consider_using_in.txt b/tests/functional/consider_using_in.txt
new file mode 100644
index 000000000..1093ea25a
--- /dev/null
+++ b/tests/functional/consider_using_in.txt
@@ -0,0 +1,13 @@
+consider-using-in:10::Consider merging these comparisons with "in" to 'value in (1,)'
+consider-using-in:11::Consider merging these comparisons with "in" to 'value in (1, 2)'
+consider-using-in:12::Consider merging these comparisons with "in" to "value in ('value',)"
+consider-using-in:13::Consider merging these comparisons with "in" to 'value in (1, undef_value)'
+consider-using-in:14::Consider merging these comparisons with "in" to 'value in (1, 2, 3)'
+consider-using-in:15::Consider merging these comparisons with "in" to "value in ('2', 1)"
+consider-using-in:16::Consider merging these comparisons with "in" to 'value in (1, 2)'
+consider-using-in:17::Consider merging these comparisons with "in" to 'value in (1, 2)'
+consider-using-in:18::Consider merging these comparisons with "in" to 'value in (1, a_list)'
+consider-using-in:19::Consider merging these comparisons with "in" to 'value in (a_set, a_list, a_str)'
+consider-using-in:20::Consider merging these comparisons with "in" to 'value not in (1, 2)'
+consider-using-in:21::Consider merging these comparisons with "in" to 'value1 in (value2,)'
+consider-using-in:22::Consider merging these comparisons with "in" to 'a_list in ([1, 2, 3], [])'
diff --git a/tests/functional/consider_using_set_comprehension.py b/tests/functional/consider_using_set_comprehension.py
new file mode 100644
index 000000000..2c42ef2fd
--- /dev/null
+++ b/tests/functional/consider_using_set_comprehension.py
@@ -0,0 +1,9 @@
+# pylint: disable=missing-docstring, invalid-name
+
+numbers = [1, 2, 3, 4, 5, 6]
+
+set()
+
+set([])
+
+set([number for number in numbers])  # [consider-using-set-comprehension]
diff --git a/tests/functional/consider_using_set_comprehension.txt b/tests/functional/consider_using_set_comprehension.txt
new file mode 100644
index 000000000..225d37ae8
--- /dev/null
+++ b/tests/functional/consider_using_set_comprehension.txt
@@ -0,0 +1 @@
+consider-using-set-comprehension:9::Consider using a set comprehension
\ No newline at end of file
diff --git a/tests/functional/continue_in_finally.py b/tests/functional/continue_in_finally.py
new file mode 100644
index 000000000..89e1affb1
--- /dev/null
+++ b/tests/functional/continue_in_finally.py
@@ -0,0 +1,24 @@
+"""Test that `continue` is catched when met inside a `finally` clause."""

+

+# pylint: disable=missing-docstring, lost-exception, broad-except

+

+while True:

+    try:

+        pass

+    finally:

+        continue # [continue-in-finally]

+

+while True:

+    try:

+        pass

+    finally:

+        break

+

+while True:

+    try:

+        pass

+    except Exception:

+        pass

+    else:

+        continue

+   
\ No newline at end of file
diff --git a/tests/functional/continue_in_finally.txt b/tests/functional/continue_in_finally.txt
new file mode 100644
index 000000000..cb2ee168b
--- /dev/null
+++ b/tests/functional/continue_in_finally.txt
@@ -0,0 +1 @@
+continue-in-finally:9::'continue' not supported inside 'finally' clause
diff --git a/tests/functional/control_pragmas.py b/tests/functional/control_pragmas.py
new file mode 100644
index 000000000..993f9a5dd
--- /dev/null
+++ b/tests/functional/control_pragmas.py
@@ -0,0 +1,19 @@
+# pylint: disable=missing-docstring
+
+
+def test_pragma():
+    """Test that the control pragmas are not too eager to consume the entire line
+
+    We should stop either at:
+    - ; or #
+    - or at the end of line
+    """
+    # noqa: E501 # pylint: disable=unused-variable #nosec
+    variable = 1
+
+    # noqa # pylint: disable=undefined-variable,no-member; don't trigger
+    other_variable = some_variable + variable.member
+
+    # noqa # pylint: disable=unbalanced-tuple-unpacking,no-member # no trigger
+    first, second = some_other_variable
+    return first + other_variable.method()
diff --git a/tests/functional/control_pragmas.txt b/tests/functional/control_pragmas.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/control_pragmas.txt
diff --git a/tests/functional/crash_missing_module_type.py b/tests/functional/crash_missing_module_type.py
new file mode 100644
index 000000000..308606ff4
--- /dev/null
+++ b/tests/functional/crash_missing_module_type.py
@@ -0,0 +1,18 @@
+""" Test for a crash found in

+https://bitbucket.org/logilab/astroid/issue/45/attributeerror-module-object-has-no#comment-11944673

+"""

+# pylint: disable=no-init, invalid-name, too-few-public-methods, redefined-outer-name, useless-object-inheritance

+def decor(trop):

+    """ decorator """

+    return trop

+

+class Foo(object):

+    """ Class """

+    @decor

+    def prop(self):

+        """ method """

+        return self

+

+if __name__ == '__main__':

+    trop = Foo()

+    trop.prop = 42

diff --git a/tests/functional/crash_missing_module_type.txt b/tests/functional/crash_missing_module_type.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/crash_missing_module_type.txt
diff --git a/tests/functional/ctor_arguments.py b/tests/functional/ctor_arguments.py
new file mode 100644
index 000000000..d9a9944a6
--- /dev/null
+++ b/tests/functional/ctor_arguments.py
@@ -0,0 +1,104 @@
+"""Test function argument checker on __init__
+
+Based on test/functional/arguments.py
+"""
+# pylint: disable=C0111,R0903,W0231, useless-object-inheritance
+
+
+class Class1Arg(object):
+    def __init__(self, first_argument):
+        """one argument function"""
+
+class Class3Arg(object):
+    def __init__(self, first_argument, second_argument, third_argument):
+        """three arguments function"""
+
+class ClassDefaultArg(object):
+    def __init__(self, one=1, two=2):
+        """function with default value"""
+
+class Subclass1Arg(Class1Arg):
+    pass
+
+class ClassAllArgs(Class1Arg):
+    def __init__(self, *args, **kwargs):
+        pass
+
+class ClassMultiInheritance(Class1Arg, Class3Arg):
+    pass
+
+class ClassNew(object):
+    def __new__(cls, first_argument, kwarg=None):
+        return first_argument, kwarg
+
+Class1Arg(420)
+Class1Arg()  # [no-value-for-parameter]
+Class1Arg(1337, 347)  # [too-many-function-args]
+
+Class3Arg(420, 789)  # [no-value-for-parameter]
+# +1:[no-value-for-parameter,no-value-for-parameter,no-value-for-parameter]
+Class3Arg()
+Class3Arg(1337, 347, 456)
+Class3Arg('bab', 'bebe', None, 5.6)  # [too-many-function-args]
+
+ClassDefaultArg(1, two=5)
+ClassDefaultArg(two=5)
+
+Class1Arg(bob=4)  # [no-value-for-parameter,unexpected-keyword-arg]
+ClassDefaultArg(1, 4, coin="hello")  # [unexpected-keyword-arg]
+
+ClassDefaultArg(1, one=5)  # [redundant-keyword-arg]
+
+Subclass1Arg(420)
+Subclass1Arg()  # [no-value-for-parameter]
+Subclass1Arg(1337, 347)  # [too-many-function-args]
+
+ClassAllArgs()
+ClassAllArgs(1, 2, 3, even=4, more=5)
+
+ClassMultiInheritance(1)
+ClassMultiInheritance(1, 2, 3)  # [too-many-function-args]
+
+ClassNew(1, kwarg=1)
+ClassNew(1, 2, 3)  # [too-many-function-args]
+ClassNew(one=2)  # [no-value-for-parameter,unexpected-keyword-arg]
+
+
+class Metaclass(type):
+    def __new__(cls, name, bases, namespace):
+        return type.__new__(cls, name, bases, namespace)
+
+def with_metaclass(meta, base=object):
+    """Create a new type that can be used as a metaclass."""
+    return meta("NewBase", (base, ), {})
+
+class ClassWithMeta(with_metaclass(Metaclass)):
+    pass
+
+ClassWithMeta()
+
+
+class BuiltinExc(Exception):
+    def __init__(self, val=True):
+        self.val = val
+
+BuiltinExc(42, 24, badarg=1) # [too-many-function-args,unexpected-keyword-arg]
+
+
+class Clsmethod(object):
+    def __init__(self, first, second):
+        self.first = first
+        self.second = second
+
+    @classmethod
+    def from_nothing(cls):
+        return cls(1, 2, 3, 4) # [too-many-function-args]
+
+    @classmethod
+    def from_nothing1(cls):
+        return cls() # [no-value-for-parameter,no-value-for-parameter]
+
+    @classmethod
+    def from_nothing2(cls):
+        # +1: [no-value-for-parameter,unexpected-keyword-arg]
+        return cls(1, not_argument=2)
diff --git a/tests/functional/ctor_arguments.txt b/tests/functional/ctor_arguments.txt
new file mode 100644
index 000000000..639e92ce1
--- /dev/null
+++ b/tests/functional/ctor_arguments.txt
@@ -0,0 +1,24 @@
+no-value-for-parameter:35::No value for argument 'first_argument' in constructor call
+too-many-function-args:36::Too many positional arguments for constructor call
+no-value-for-parameter:38::No value for argument 'third_argument' in constructor call
+no-value-for-parameter:40::No value for argument 'first_argument' in constructor call
+no-value-for-parameter:40::No value for argument 'second_argument' in constructor call
+no-value-for-parameter:40::No value for argument 'third_argument' in constructor call
+too-many-function-args:42::Too many positional arguments for constructor call
+no-value-for-parameter:47::No value for argument 'first_argument' in constructor call
+unexpected-keyword-arg:47::Unexpected keyword argument 'bob' in constructor call
+unexpected-keyword-arg:48::Unexpected keyword argument 'coin' in constructor call
+redundant-keyword-arg:50::Argument 'one' passed by position and keyword in constructor call
+no-value-for-parameter:53::No value for argument 'first_argument' in constructor call
+too-many-function-args:54::Too many positional arguments for constructor call
+too-many-function-args:60::Too many positional arguments for constructor call
+too-many-function-args:63::Too many positional arguments for constructor call
+no-value-for-parameter:64::No value for argument 'first_argument' in constructor call
+unexpected-keyword-arg:64::Unexpected keyword argument 'one' in constructor call
+too-many-function-args:85::Too many positional arguments for constructor call
+unexpected-keyword-arg:85::Unexpected keyword argument 'badarg' in constructor call
+too-many-function-args:95:Clsmethod.from_nothing:Too many positional arguments for constructor call
+no-value-for-parameter:99:Clsmethod.from_nothing1:"No value for argument 'first' in constructor call"
+no-value-for-parameter:99:Clsmethod.from_nothing1:"No value for argument 'second' in constructor call"
+no-value-for-parameter:104:Clsmethod.from_nothing2:"No value for argument 'second' in constructor call"
+unexpected-keyword-arg:104:Clsmethod.from_nothing2:"Unexpected keyword argument 'not_argument' in constructor call"
\ No newline at end of file
diff --git a/tests/functional/dangerous_default_value.py b/tests/functional/dangerous_default_value.py
new file mode 100644
index 000000000..58a22f443
--- /dev/null
+++ b/tests/functional/dangerous_default_value.py
@@ -0,0 +1,79 @@
+# pylint: disable=missing-docstring
+
+
+HEHE = {}
+
+def function1(value=[]): # [dangerous-default-value]
+    """docstring"""
+    return value
+
+def function2(value=HEHE): # [dangerous-default-value]
+    """docstring"""
+    return value
+
+def function3(value):
+    """docstring"""
+    return value
+
+def function4(value=set()): # [dangerous-default-value]
+    """set is mutable and dangerous."""
+    return value
+
+def function5(value=frozenset()):
+    """frozenset is immutable and safe."""
+    return value
+
+GLOBAL_SET = set()
+
+def function6(value=GLOBAL_SET): # [dangerous-default-value]
+    """set is mutable and dangerous."""
+    return value
+
+def function7(value=dict()): # [dangerous-default-value]
+    """dict is mutable and dangerous."""
+    return value
+
+def function8(value=list()):  # [dangerous-default-value]
+    """list is mutable and dangerous."""
+    return value
+
+def function9(value=[1, 2, 3, 4]): # [dangerous-default-value]
+    """list with items should not output item values in error message"""
+    return value
+
+def function10(value={'a': 1, 'b': 2}): # [dangerous-default-value]
+    """dictionaries with items should not output item values in error message"""
+    return value
+
+def function11(value=list([1, 2, 3])): # [dangerous-default-value]
+    """list with items should not output item values in error message"""
+    return value
+
+def function12(value=dict([('a', 1), ('b', 2)])): # [dangerous-default-value]
+    """dictionaries with items should not output item values in error message"""
+    return value
+
+OINK = {
+    'a': 1,
+    'b': 2
+}
+
+def function13(value=OINK): # [dangerous-default-value]
+    """dictionaries with items should not output item values in error message"""
+    return value
+
+def function14(value=dict([(1, 2), (1, 2, 3)])): # [dangerous-default-value]
+    """a dictionary which will not be inferred to a syntax AST, but to an
+    astroid.Instance.
+    """
+    return value
+
+INVALID_DICT = dict([(1, 2), (1, 2, 3)])
+
+def function15(value=INVALID_DICT): # [dangerous-default-value]
+    """The same situation as function14."""
+    return value
+
+def function16(value={1}): # [dangerous-default-value]
+    """set literal as default value"""
+    return value
diff --git a/tests/functional/dangerous_default_value.rc b/tests/functional/dangerous_default_value.rc
new file mode 100644
index 000000000..a2328edb7
--- /dev/null
+++ b/tests/functional/dangerous_default_value.rc
@@ -0,0 +1,2 @@
+[testoptions]

+max_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/dangerous_default_value.txt b/tests/functional/dangerous_default_value.txt
new file mode 100644
index 000000000..92180e90f
--- /dev/null
+++ b/tests/functional/dangerous_default_value.txt
@@ -0,0 +1,14 @@
+dangerous-default-value:6:function1:Dangerous default value [] as argument
+dangerous-default-value:10:function2:Dangerous default value HEHE (__builtin__.dict) as argument
+dangerous-default-value:18:function4:Dangerous default value set() (__builtin__.set) as argument
+dangerous-default-value:28:function6:Dangerous default value GLOBAL_SET (__builtin__.set) as argument
+dangerous-default-value:32:function7:Dangerous default value dict() (__builtin__.dict) as argument
+dangerous-default-value:36:function8:Dangerous default value list() (__builtin__.list) as argument
+dangerous-default-value:40:function9:Dangerous default value [] as argument
+dangerous-default-value:44:function10:Dangerous default value {} as argument
+dangerous-default-value:48:function11:Dangerous default value list() (__builtin__.list) as argument
+dangerous-default-value:52:function12:Dangerous default value dict() (__builtin__.dict) as argument
+dangerous-default-value:61:function13:Dangerous default value OINK (__builtin__.dict) as argument
+dangerous-default-value:65:function14:Dangerous default value dict() (__builtin__.dict) as argument
+dangerous-default-value:73:function15:Dangerous default value INVALID_DICT (__builtin__.dict) as argument
+dangerous-default-value:77:function16:Dangerous default value set() as argument
diff --git a/tests/functional/dangerous_default_value_py30.py b/tests/functional/dangerous_default_value_py30.py
new file mode 100644
index 000000000..58a22f443
--- /dev/null
+++ b/tests/functional/dangerous_default_value_py30.py
@@ -0,0 +1,79 @@
+# pylint: disable=missing-docstring
+
+
+HEHE = {}
+
+def function1(value=[]): # [dangerous-default-value]
+    """docstring"""
+    return value
+
+def function2(value=HEHE): # [dangerous-default-value]
+    """docstring"""
+    return value
+
+def function3(value):
+    """docstring"""
+    return value
+
+def function4(value=set()): # [dangerous-default-value]
+    """set is mutable and dangerous."""
+    return value
+
+def function5(value=frozenset()):
+    """frozenset is immutable and safe."""
+    return value
+
+GLOBAL_SET = set()
+
+def function6(value=GLOBAL_SET): # [dangerous-default-value]
+    """set is mutable and dangerous."""
+    return value
+
+def function7(value=dict()): # [dangerous-default-value]
+    """dict is mutable and dangerous."""
+    return value
+
+def function8(value=list()):  # [dangerous-default-value]
+    """list is mutable and dangerous."""
+    return value
+
+def function9(value=[1, 2, 3, 4]): # [dangerous-default-value]
+    """list with items should not output item values in error message"""
+    return value
+
+def function10(value={'a': 1, 'b': 2}): # [dangerous-default-value]
+    """dictionaries with items should not output item values in error message"""
+    return value
+
+def function11(value=list([1, 2, 3])): # [dangerous-default-value]
+    """list with items should not output item values in error message"""
+    return value
+
+def function12(value=dict([('a', 1), ('b', 2)])): # [dangerous-default-value]
+    """dictionaries with items should not output item values in error message"""
+    return value
+
+OINK = {
+    'a': 1,
+    'b': 2
+}
+
+def function13(value=OINK): # [dangerous-default-value]
+    """dictionaries with items should not output item values in error message"""
+    return value
+
+def function14(value=dict([(1, 2), (1, 2, 3)])): # [dangerous-default-value]
+    """a dictionary which will not be inferred to a syntax AST, but to an
+    astroid.Instance.
+    """
+    return value
+
+INVALID_DICT = dict([(1, 2), (1, 2, 3)])
+
+def function15(value=INVALID_DICT): # [dangerous-default-value]
+    """The same situation as function14."""
+    return value
+
+def function16(value={1}): # [dangerous-default-value]
+    """set literal as default value"""
+    return value
diff --git a/tests/functional/dangerous_default_value_py30.rc b/tests/functional/dangerous_default_value_py30.rc
new file mode 100644
index 000000000..8c6eb56c4
--- /dev/null
+++ b/tests/functional/dangerous_default_value_py30.rc
@@ -0,0 +1,2 @@
+[testoptions]

+min_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/dangerous_default_value_py30.txt b/tests/functional/dangerous_default_value_py30.txt
new file mode 100644
index 000000000..7571c00f7
--- /dev/null
+++ b/tests/functional/dangerous_default_value_py30.txt
@@ -0,0 +1,14 @@
+dangerous-default-value:6:function1:Dangerous default value [] as argument
+dangerous-default-value:10:function2:Dangerous default value HEHE (builtins.dict) as argument
+dangerous-default-value:18:function4:Dangerous default value set() (builtins.set) as argument
+dangerous-default-value:28:function6:Dangerous default value GLOBAL_SET (builtins.set) as argument
+dangerous-default-value:32:function7:Dangerous default value dict() (builtins.dict) as argument
+dangerous-default-value:36:function8:Dangerous default value list() (builtins.list) as argument
+dangerous-default-value:40:function9:Dangerous default value [] as argument
+dangerous-default-value:44:function10:Dangerous default value {} as argument
+dangerous-default-value:48:function11:Dangerous default value list() (builtins.list) as argument
+dangerous-default-value:52:function12:Dangerous default value dict() (builtins.dict) as argument
+dangerous-default-value:61:function13:Dangerous default value OINK (builtins.dict) as argument
+dangerous-default-value:65:function14:Dangerous default value dict() (builtins.dict) as argument
+dangerous-default-value:73:function15:Dangerous default value INVALID_DICT (builtins.dict) as argument
+dangerous-default-value:77:function16:Dangerous default value set() as argument
\ No newline at end of file
diff --git a/tests/functional/defined_and_used_on_same_line.py b/tests/functional/defined_and_used_on_same_line.py
new file mode 100644
index 000000000..a61bcd760
--- /dev/null
+++ b/tests/functional/defined_and_used_on_same_line.py
@@ -0,0 +1,29 @@
+"""Check for definitions and usage happening on the same line."""
+#pylint: disable=missing-docstring,multiple-statements,no-absolute-import,parameter-unpacking,wrong-import-position
+from __future__ import print_function
+print([index
+       for index in range(10)])
+
+print((index
+       for index in range(10)))
+
+FILTER_FUNC = lambda x: not x
+
+def func(xxx): return xxx
+
+def func2(xxx): return xxx + func2(1)
+
+import sys; print(sys.exc_info())
+
+for i in range(10): print(i)
+
+j = 4; LAMB = lambda x: x+j
+
+FUNC4 = lambda a, b: a != b
+
+# test http://www.logilab.org/ticket/6954:
+
+with open('f') as f: print(f.read())
+
+with open('f') as f, open(f.read()) as g:
+    print(g.read())
diff --git a/tests/functional/deprecated_lambda.py b/tests/functional/deprecated_lambda.py
new file mode 100644
index 000000000..92a2e84ab
--- /dev/null
+++ b/tests/functional/deprecated_lambda.py
@@ -0,0 +1,23 @@
+# pylint: disable=missing-docstring,invalid-name,no-absolute-import
+
+import functools
+
+# Don't do this, use a comprehension instead.
+assert map(lambda x: x*2, [1, 2, 3]) == [2, 4, 6] # [deprecated-lambda]
+
+assert filter(lambda x: x != 1, [1, 2, 3]) == [2, 3] # [deprecated-lambda]
+
+# It's still ok to use map and filter with anything but an inline lambda.
+double = lambda x: x * 2
+assert map(double, [1, 2, 3]) == [2, 4, 6]
+
+# It's also ok to pass lambdas to other functions.
+assert functools.reduce(lambda x, y: x * y, [1, 2, 3, 4]) == 24
+
+# Or to an undefined function or one with varargs
+def f(*a):
+    return len(a)
+
+f(lambda x, y: x + y, [1, 2, 3])
+
+undefined_function(lambda: 2)  # pylint: disable=undefined-variable
diff --git a/tests/functional/deprecated_lambda.rc b/tests/functional/deprecated_lambda.rc
new file mode 100644
index 000000000..a65023393
--- /dev/null
+++ b/tests/functional/deprecated_lambda.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max_pyver=3.0
diff --git a/tests/functional/deprecated_lambda.txt b/tests/functional/deprecated_lambda.txt
new file mode 100644
index 000000000..78cd9fbfb
--- /dev/null
+++ b/tests/functional/deprecated_lambda.txt
@@ -0,0 +1,2 @@
+deprecated-lambda:6::map/filter on lambda could be replaced by comprehension
+deprecated-lambda:8::map/filter on lambda could be replaced by comprehension
diff --git a/tests/functional/deprecated_method_getmoduleinfo.py b/tests/functional/deprecated_method_getmoduleinfo.py
new file mode 100644
index 000000000..3338c2456
--- /dev/null
+++ b/tests/functional/deprecated_method_getmoduleinfo.py
@@ -0,0 +1,4 @@
+"""Test that getmoduleinfo is deprecated."""
+import inspect
+
+inspect.getmoduleinfo(inspect) # [deprecated-method]
diff --git a/tests/functional/deprecated_method_getmoduleinfo.rc b/tests/functional/deprecated_method_getmoduleinfo.rc
new file mode 100644
index 000000000..a444ca6b8
--- /dev/null
+++ b/tests/functional/deprecated_method_getmoduleinfo.rc
@@ -0,0 +1,3 @@
+[testoptions]
+max_pyver=3.6
+min_pyver=3.3
diff --git a/tests/functional/deprecated_method_getmoduleinfo.txt b/tests/functional/deprecated_method_getmoduleinfo.txt
new file mode 100644
index 000000000..9009bbf4c
--- /dev/null
+++ b/tests/functional/deprecated_method_getmoduleinfo.txt
@@ -0,0 +1 @@
+deprecated-method:4::Using deprecated method getmoduleinfo()
\ No newline at end of file
diff --git a/tests/functional/deprecated_methods_py2.py b/tests/functional/deprecated_methods_py2.py
new file mode 100644
index 000000000..ceba1e4f9
--- /dev/null
+++ b/tests/functional/deprecated_methods_py2.py
@@ -0,0 +1,9 @@
+""" Functional test for deprecated methods in Python 2 """
+# pylint: disable=no-member
+import os
+import xml.etree.ElementTree
+
+os.popen2('')     # [deprecated-method]
+os.popen3('')     # [deprecated-method]
+os.popen4('')     # [deprecated-method]
+xml.etree.ElementTree.Element('elem').getchildren()     # [deprecated-method]
diff --git a/tests/functional/deprecated_methods_py2.rc b/tests/functional/deprecated_methods_py2.rc
new file mode 100644
index 000000000..a65023393
--- /dev/null
+++ b/tests/functional/deprecated_methods_py2.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max_pyver=3.0
diff --git a/tests/functional/deprecated_methods_py2.txt b/tests/functional/deprecated_methods_py2.txt
new file mode 100644
index 000000000..e1038185c
--- /dev/null
+++ b/tests/functional/deprecated_methods_py2.txt
@@ -0,0 +1,4 @@
+deprecated-method:6::Using deprecated method popen2()
+deprecated-method:7::Using deprecated method popen3()
+deprecated-method:8::Using deprecated method popen4()
+deprecated-method:9::Using deprecated method getchildren()
diff --git a/tests/functional/deprecated_methods_py3.py b/tests/functional/deprecated_methods_py3.py
new file mode 100644
index 000000000..d390c8d79
--- /dev/null
+++ b/tests/functional/deprecated_methods_py3.py
@@ -0,0 +1,50 @@
+""" Functional tests for method deprecation. """
+# pylint: disable=missing-docstring, super-init-not-called, not-callable
+import base64
+import cgi
+import inspect
+import logging
+import nntplib
+import platform
+import unittest
+import xml.etree.ElementTree
+
+
+class MyTest(unittest.TestCase):
+    def test(self):
+        self.assert_(True)  # [deprecated-method]
+
+xml.etree.ElementTree.Element('tag').getchildren()  # [deprecated-method]
+xml.etree.ElementTree.Element('tag').getiterator()  # [deprecated-method]
+xml.etree.ElementTree.XMLParser('tag', None, None).doctype(None, None, None)  # [deprecated-method]
+nntplib.NNTP(None).xpath(None) # [deprecated-method]
+
+
+inspect.getargspec(None) # [deprecated-method]
+logging.warn("a") # [deprecated-method]
+platform.popen([]) # [deprecated-method]
+base64.encodestring("42") # [deprecated-method]
+base64.decodestring("42") # [deprecated-method]
+cgi.escape("a") # [deprecated-method]
+
+
+class SuperCrash(unittest.TestCase):
+
+    def __init__(self):
+        # should not crash.
+        super(SuperCrash, self)()
+
+xml.etree.ElementTree.iterparse(None)
+
+
+class Tests(unittest.TestCase):
+
+    def test_foo(self):
+        self.assertEquals(2 + 2, 4)  # [deprecated-method]
+        self.assertNotEquals(2 + 2, 4)  # [deprecated-method]
+        self.assertAlmostEquals(2 + 2, 4)  # [deprecated-method]
+        self.assertNotAlmostEquals(2 + 2, 4)  # [deprecated-method]
+        self.assert_("abc" == "2")  # [deprecated-method]
+
+        self.assertRaisesRegex(ValueError, "exception")
+        self.assertRegex("something", r".+")
diff --git a/tests/functional/deprecated_methods_py3.rc b/tests/functional/deprecated_methods_py3.rc
new file mode 100644
index 000000000..6c3e72704
--- /dev/null
+++ b/tests/functional/deprecated_methods_py3.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.3
+max_pyver=3.7
diff --git a/tests/functional/deprecated_methods_py3.txt b/tests/functional/deprecated_methods_py3.txt
new file mode 100644
index 000000000..ad588341d
--- /dev/null
+++ b/tests/functional/deprecated_methods_py3.txt
@@ -0,0 +1,16 @@
+deprecated-method:15:MyTest.test:Using deprecated method assert_()
+deprecated-method:17::Using deprecated method getchildren()
+deprecated-method:18::Using deprecated method getiterator()
+deprecated-method:19::Using deprecated method doctype()
+deprecated-method:20::Using deprecated method xpath()
+deprecated-method:23::Using deprecated method getargspec()
+deprecated-method:24::Using deprecated method warn()
+deprecated-method:25::Using deprecated method popen()
+deprecated-method:26::Using deprecated method encodestring()
+deprecated-method:27::Using deprecated method decodestring()
+deprecated-method:28::Using deprecated method escape()
+deprecated-method:43:Tests.test_foo:Using deprecated method assertEquals()
+deprecated-method:44:Tests.test_foo:Using deprecated method assertNotEquals()
+deprecated-method:45:Tests.test_foo:Using deprecated method assertAlmostEquals()
+deprecated-method:46:Tests.test_foo:Using deprecated method assertNotAlmostEquals()
+deprecated-method:47:Tests.test_foo:Using deprecated method assert_()
diff --git a/tests/functional/deprecated_methods_py36.py b/tests/functional/deprecated_methods_py36.py
new file mode 100644
index 000000000..f416a144c
--- /dev/null
+++ b/tests/functional/deprecated_methods_py36.py
@@ -0,0 +1,7 @@
+""" Functional tests for method deprecation. """
+# pylint: disable=no-value-for-parameter
+import unittest
+from importlib.machinery import SourceFileLoader, SourcelessFileLoader
+
+SourceFileLoader('unittest', unittest.__file__).load_module() # [deprecated-method]
+SourcelessFileLoader('unittest', unittest.__file__).load_module() # [deprecated-method]
diff --git a/tests/functional/deprecated_methods_py36.rc b/tests/functional/deprecated_methods_py36.rc
new file mode 100644
index 000000000..0ba2b6333
--- /dev/null
+++ b/tests/functional/deprecated_methods_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/deprecated_methods_py36.txt b/tests/functional/deprecated_methods_py36.txt
new file mode 100644
index 000000000..e5ae124ac
--- /dev/null
+++ b/tests/functional/deprecated_methods_py36.txt
@@ -0,0 +1,2 @@
+deprecated-method:6::Using deprecated method load_module()
+deprecated-method:7::Using deprecated method load_module()
diff --git a/tests/functional/deprecated_methods_py38.py b/tests/functional/deprecated_methods_py38.py
new file mode 100644
index 000000000..4ca5e5197
--- /dev/null
+++ b/tests/functional/deprecated_methods_py38.py
@@ -0,0 +1,45 @@
+""" Functional tests for method deprecation. """
+# pylint: disable=missing-docstring, super-init-not-called, not-callable
+import base64
+import inspect
+import logging
+import nntplib
+import unittest
+import xml.etree.ElementTree
+
+
+class MyTest(unittest.TestCase):
+    def test(self):
+        self.assert_(True)  # [deprecated-method]
+
+xml.etree.ElementTree.Element('tag').getchildren()  # [deprecated-method]
+xml.etree.ElementTree.Element('tag').getiterator()  # [deprecated-method]
+nntplib.NNTP(None).xpath(None) # [deprecated-method]
+
+
+inspect.getargspec(None) # [deprecated-method]
+logging.warn("a") # [deprecated-method]
+base64.encodestring("42") # [deprecated-method]
+base64.decodestring("42") # [deprecated-method]
+
+
+class SuperCrash(unittest.TestCase):
+
+    def __init__(self):
+        # should not crash.
+        super(SuperCrash, self)()
+
+xml.etree.ElementTree.iterparse(None)
+
+
+class Tests(unittest.TestCase):
+
+    def test_foo(self):
+        self.assertEquals(2 + 2, 4)  # [deprecated-method]
+        self.assertNotEquals(2 + 2, 4)  # [deprecated-method]
+        self.assertAlmostEquals(2 + 2, 4)  # [deprecated-method]
+        self.assertNotAlmostEquals(2 + 2, 4)  # [deprecated-method]
+        self.assert_("abc" == "2")  # [deprecated-method]
+
+        self.assertRaisesRegex(ValueError, "exception")
+        self.assertRegex("something", r".+")
diff --git a/tests/functional/deprecated_methods_py38.rc b/tests/functional/deprecated_methods_py38.rc
new file mode 100644
index 000000000..85fc502b3
--- /dev/null
+++ b/tests/functional/deprecated_methods_py38.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.8
diff --git a/tests/functional/deprecated_methods_py38.txt b/tests/functional/deprecated_methods_py38.txt
new file mode 100644
index 000000000..819d4420b
--- /dev/null
+++ b/tests/functional/deprecated_methods_py38.txt
@@ -0,0 +1,13 @@
+deprecated-method:13:MyTest.test:Using deprecated method assert_()
+deprecated-method:15::Using deprecated method getchildren()
+deprecated-method:16::Using deprecated method getiterator()
+deprecated-method:17::Using deprecated method xpath()
+deprecated-method:20::Using deprecated method getargspec()
+deprecated-method:21::Using deprecated method warn()
+deprecated-method:22::Using deprecated method encodestring()
+deprecated-method:23::Using deprecated method decodestring()
+deprecated-method:38:Tests.test_foo:Using deprecated method assertEquals()
+deprecated-method:39:Tests.test_foo:Using deprecated method assertNotEquals()
+deprecated-method:40:Tests.test_foo:Using deprecated method assertAlmostEquals()
+deprecated-method:41:Tests.test_foo:Using deprecated method assertNotAlmostEquals()
+deprecated-method:42:Tests.test_foo:Using deprecated method assert_()
diff --git a/tests/functional/deprecated_module_py2.py b/tests/functional/deprecated_module_py2.py
new file mode 100644
index 000000000..b0d186540
--- /dev/null
+++ b/tests/functional/deprecated_module_py2.py
@@ -0,0 +1,8 @@
+"""Test deprecated modules."""
+# pylint: disable=unused-import,no-name-in-module,import-error,ungrouped-imports
+
+import Bastion # [deprecated-module]
+import rexec # [deprecated-module]
+
+from Bastion import bastion_module # [deprecated-module]
+from rexec import rexec_module # [deprecated-module]
diff --git a/tests/functional/deprecated_module_py2.rc b/tests/functional/deprecated_module_py2.rc
new file mode 100644
index 000000000..a65023393
--- /dev/null
+++ b/tests/functional/deprecated_module_py2.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max_pyver=3.0
diff --git a/tests/functional/deprecated_module_py2.txt b/tests/functional/deprecated_module_py2.txt
new file mode 100644
index 000000000..54f555505
--- /dev/null
+++ b/tests/functional/deprecated_module_py2.txt
@@ -0,0 +1,4 @@
+deprecated-module:4::Uses of a deprecated module 'Bastion'
+deprecated-module:5::Uses of a deprecated module 'rexec'
+deprecated-module:7::Uses of a deprecated module 'Bastion'
+deprecated-module:8::Uses of a deprecated module 'rexec'
diff --git a/tests/functional/deprecated_module_py3.py b/tests/functional/deprecated_module_py3.py
new file mode 100644
index 000000000..308d400e7
--- /dev/null
+++ b/tests/functional/deprecated_module_py3.py
@@ -0,0 +1,4 @@
+"""Test deprecated modules."""
+# pylint: disable=unused-import
+
+import optparse # [deprecated-module]
diff --git a/tests/functional/deprecated_module_py3.rc b/tests/functional/deprecated_module_py3.rc
new file mode 100644
index 000000000..46343d2f1
--- /dev/null
+++ b/tests/functional/deprecated_module_py3.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.0
+max_pyver=3.6
diff --git a/tests/functional/deprecated_module_py3.txt b/tests/functional/deprecated_module_py3.txt
new file mode 100644
index 000000000..c41bf3b61
--- /dev/null
+++ b/tests/functional/deprecated_module_py3.txt
@@ -0,0 +1 @@
+deprecated-module:4::Uses of a deprecated module 'optparse'
diff --git a/tests/functional/deprecated_module_py36.py b/tests/functional/deprecated_module_py36.py
new file mode 100644
index 000000000..c49f9f0bc
--- /dev/null
+++ b/tests/functional/deprecated_module_py36.py
@@ -0,0 +1,4 @@
+"""Test deprecated modules from Python 3.6."""
+# pylint: disable=unused-import,import-error
+
+import optparse # [deprecated-module]
diff --git a/tests/functional/deprecated_module_py36.rc b/tests/functional/deprecated_module_py36.rc
new file mode 100644
index 000000000..0ba2b6333
--- /dev/null
+++ b/tests/functional/deprecated_module_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/deprecated_module_py36.txt b/tests/functional/deprecated_module_py36.txt
new file mode 100644
index 000000000..c41bf3b61
--- /dev/null
+++ b/tests/functional/deprecated_module_py36.txt
@@ -0,0 +1 @@
+deprecated-module:4::Uses of a deprecated module 'optparse'
diff --git a/tests/functional/deprecated_module_py4.py b/tests/functional/deprecated_module_py4.py
new file mode 100644
index 000000000..3cad959e7
--- /dev/null
+++ b/tests/functional/deprecated_module_py4.py
@@ -0,0 +1,4 @@
+"""Test deprecated modules."""
+
+from deprecated import foo  # [deprecated-module]
+import deprecated  # [deprecated-module]
diff --git a/tests/functional/deprecated_module_py4.rc b/tests/functional/deprecated_module_py4.rc
new file mode 100644
index 000000000..6fbd3407e
--- /dev/null
+++ b/tests/functional/deprecated_module_py4.rc
@@ -0,0 +1,4 @@
+[Messages Control]
+deprecated-modules=deprecated
+disable=all
+enable=deprecated-module
diff --git a/tests/functional/deprecated_module_py4.txt b/tests/functional/deprecated_module_py4.txt
new file mode 100644
index 000000000..74062f7b5
--- /dev/null
+++ b/tests/functional/deprecated_module_py4.txt
@@ -0,0 +1,2 @@
+deprecated-module:3::Uses of a deprecated module 'deprecated'
+deprecated-module:4::Uses of a deprecated module 'deprecated'
diff --git a/tests/functional/deprecated_module_uninstalled.py b/tests/functional/deprecated_module_uninstalled.py
new file mode 100644
index 000000000..52d55fa84
--- /dev/null
+++ b/tests/functional/deprecated_module_uninstalled.py
@@ -0,0 +1,5 @@
+"""Test deprecated modules uninstalled."""
+# pylint: disable=unused-import,no-name-in-module,import-error
+
+from uninstalled import uninstalled_module # [deprecated-module]
+import uninstalled # [deprecated-module]
diff --git a/tests/functional/deprecated_module_uninstalled.rc b/tests/functional/deprecated_module_uninstalled.rc
new file mode 100644
index 000000000..05973daa7
--- /dev/null
+++ b/tests/functional/deprecated_module_uninstalled.rc
@@ -0,0 +1,2 @@
+[Messages Control]
+deprecated-modules=uninstalled
\ No newline at end of file
diff --git a/tests/functional/deprecated_module_uninstalled.txt b/tests/functional/deprecated_module_uninstalled.txt
new file mode 100644
index 000000000..6f14ddd24
--- /dev/null
+++ b/tests/functional/deprecated_module_uninstalled.txt
@@ -0,0 +1,2 @@
+deprecated-module:4::Uses of a deprecated module 'uninstalled'
+deprecated-module:5::Uses of a deprecated module 'uninstalled'
diff --git a/tests/functional/dict_iter_missing_items.py b/tests/functional/dict_iter_missing_items.py
new file mode 100644
index 000000000..333f58990
--- /dev/null
+++ b/tests/functional/dict_iter_missing_items.py
@@ -0,0 +1,23 @@
+# pylint: disable=invalid-name, consider-iterating-dictionary, missing-docstring, import-error
+from unknown import Uninferable
+
+d = {1: 1, 2: 2}
+l = [1, 2]
+s1 = {1, 2}
+s2 = {1, 2, 3}
+
+# Positive
+for k, v in d:  # [dict-iter-missing-items]
+    pass
+
+# Negative
+for k, v in d.items():
+    pass
+for k in d.keys():
+    pass
+for i, v in enumerate(l):
+    pass
+for i, v in s1.intersection(s2):
+    pass
+for k, v in Uninferable:
+    pass
diff --git a/tests/functional/dict_iter_missing_items.txt b/tests/functional/dict_iter_missing_items.txt
new file mode 100644
index 000000000..0e939ee33
--- /dev/null
+++ b/tests/functional/dict_iter_missing_items.txt
@@ -0,0 +1 @@
+dict-iter-missing-items:10::Unpacking a dictionary in iteration without calling .items()
diff --git a/tests/functional/disable_msg_github_issue_1389.py b/tests/functional/disable_msg_github_issue_1389.py
new file mode 100644
index 000000000..5c7ad1e5d
--- /dev/null
+++ b/tests/functional/disable_msg_github_issue_1389.py
@@ -0,0 +1,15 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+
+from typing import Dict, NamedTuple, NewType, Set
+
+UserId = NewType('UserId', str)  # pylint: disable=invalid-name
+PlaceId = NewType('PlaceId', str)  # pylint: disable=invalid-name
+
+
+class Bar(NamedTuple):
+    place: PlaceId
+    name: str
+
+
+class Foo(NamedTuple):
+    user: Dict[UserId, Set[Bar]]
diff --git a/tests/functional/disable_msg_github_issue_1389.rc b/tests/functional/disable_msg_github_issue_1389.rc
new file mode 100644
index 000000000..1450ccc64
--- /dev/null
+++ b/tests/functional/disable_msg_github_issue_1389.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
\ No newline at end of file
diff --git a/tests/functional/disable_ungrouped_imports.py b/tests/functional/disable_ungrouped_imports.py
new file mode 100644
index 000000000..836c76d1a
--- /dev/null
+++ b/tests/functional/disable_ungrouped_imports.py
@@ -0,0 +1,10 @@
+"""Checks that disabling 'ungrouped-imports' on an import prevents subsequent
+imports from being considered ungrouped in respect to it."""
+# pylint: disable=unused-import,relative-import,wrong-import-position,wrong-import-order,using-constant-test
+# pylint: disable=import-error
+from os.path import basename
+import logging.config  # pylint: disable=ungrouped-imports
+import os.path
+import logging
+from os.path import join  # [ungrouped-imports]
+import logging.handlers  # [ungrouped-imports]
diff --git a/tests/functional/disable_ungrouped_imports.txt b/tests/functional/disable_ungrouped_imports.txt
new file mode 100644
index 000000000..9f2fa443f
--- /dev/null
+++ b/tests/functional/disable_ungrouped_imports.txt
@@ -0,0 +1,2 @@
+ungrouped-imports:9::Imports from package os are not grouped
+ungrouped-imports:10::Imports from package logging are not grouped
diff --git a/tests/functional/disable_wrong_import_order.py b/tests/functional/disable_wrong_import_order.py
new file mode 100644
index 000000000..1fdf83fb1
--- /dev/null
+++ b/tests/functional/disable_wrong_import_order.py
@@ -0,0 +1,11 @@
+"""Checks that disabling 'wrong-import-order' on an import prevents subsequent
+imports from being considered out-of-order in respect to it but does not prevent
+it from being considered for 'ungrouped-imports'."""
+# pylint: disable=unused-import,import-error,no-name-in-module
+
+from first_party.foo import bar # pylint: disable=wrong-import-order
+import logging
+import os.path
+import sys
+from astroid import are_exclusive
+from first_party.bar import foo # [ungrouped-imports]
diff --git a/tests/functional/disable_wrong_import_order.txt b/tests/functional/disable_wrong_import_order.txt
new file mode 100644
index 000000000..df71711fc
--- /dev/null
+++ b/tests/functional/disable_wrong_import_order.txt
@@ -0,0 +1 @@
+ungrouped-imports:11::Imports from package first_party are not grouped
diff --git a/tests/functional/disable_wrong_import_position.py b/tests/functional/disable_wrong_import_position.py
new file mode 100644
index 000000000..0703325a9
--- /dev/null
+++ b/tests/functional/disable_wrong_import_position.py
@@ -0,0 +1,7 @@
+"""Checks that disabling 'wrong-import-position' on a statement prevents it from
+invalidating subsequent imports."""
+# pylint: disable=unused-import
+
+CONSTANT = True  # pylint: disable=wrong-import-position
+
+import sys
diff --git a/tests/functional/docstrings.py b/tests/functional/docstrings.py
new file mode 100644
index 000000000..8168167c5
--- /dev/null
+++ b/tests/functional/docstrings.py
@@ -0,0 +1,90 @@
+# pylint: disable=R0201, useless-object-inheritance, unnecessary-pass

+# -1: [missing-docstring]

+from __future__ import print_function

+

+# +1: [empty-docstring]

+def function0():

+    """"""

+

+# +1: [missing-docstring]

+def function1(value):

+    # missing docstring

+    print(value)

+

+def function2(value):

+    """docstring"""

+    print(value)

+

+def function3(value):

+    """docstring"""

+    print(value)

+

+# +1: [missing-docstring]

+class AAAA(object):

+    # missing docstring

+

+##     class BBBB:

+##         # missing docstring

+##         pass

+

+##     class CCCC:

+##         """yeah !"""

+##         def method1(self):

+##             pass

+

+##         def method2(self):

+##             """ yeah !"""

+##             pass

+

+    # +1: [missing-docstring]

+    def method1(self):

+        pass

+

+    def method2(self):

+        """ yeah !"""

+        pass

+

+    # +1: [empty-docstring]

+    def method3(self):

+        """"""

+        pass

+

+    def __init__(self):

+        pass

+

+class DDDD(AAAA):

+    """yeah !"""

+

+    def __init__(self):

+        AAAA.__init__(self)

+

+    # +1: [empty-docstring]

+    def method2(self):

+        """"""

+        pass

+

+    def method3(self):

+        pass

+

+    # +1: [missing-docstring]

+    def method4(self):

+        pass

+

+# pylint: disable=missing-docstring

+def function4():

+    pass

+

+# pylint: disable=empty-docstring

+def function5():

+    """"""

+    pass

+

+def function6():

+    """ I am a {} docstring.""".format("good")

+

+def function7():

+    """docstring"""

+    def inner():

+        # Not documented

+        return 42

+    return inner()

diff --git a/tests/functional/docstrings.txt b/tests/functional/docstrings.txt
new file mode 100644
index 000000000..e30e4629c
--- /dev/null
+++ b/tests/functional/docstrings.txt
@@ -0,0 +1,8 @@
+missing-docstring:1::Missing module docstring
+empty-docstring:6:function0:Empty function docstring
+missing-docstring:10:function1:Missing function docstring
+missing-docstring:23:AAAA:Missing class docstring
+missing-docstring:40:AAAA.method1:Missing method docstring:INFERENCE
+empty-docstring:48:AAAA.method3:Empty method docstring:INFERENCE
+empty-docstring:62:DDDD.method2:Empty method docstring:INFERENCE
+missing-docstring:70:DDDD.method4:Missing method docstring:INFERENCE
diff --git a/tests/functional/duplicate_argument_name.py b/tests/functional/duplicate_argument_name.py
new file mode 100644
index 000000000..c60b11784
--- /dev/null
+++ b/tests/functional/duplicate_argument_name.py
@@ -0,0 +1,14 @@
+"""Check for duplicate function arguments."""
+
+
+def foo1(_, _): # [duplicate-argument-name, duplicate-argument-name]
+    """Function with duplicate argument name."""
+
+def foo2(_abc, *, _abc): # [duplicate-argument-name, duplicate-argument-name]
+    """Function with duplicate argument name."""
+
+def foo3(_, _=3): # [duplicate-argument-name, duplicate-argument-name]
+    """Function with duplicate argument name."""
+
+def foo4(_, *, _): # [duplicate-argument-name, duplicate-argument-name]
+    """Function with duplicate argument name."""
diff --git a/tests/functional/duplicate_argument_name.txt b/tests/functional/duplicate_argument_name.txt
new file mode 100644
index 000000000..d60d1eb28
--- /dev/null
+++ b/tests/functional/duplicate_argument_name.txt
@@ -0,0 +1,8 @@
+duplicate-argument-name:4:foo1:Duplicate argument name _ in function definition
+duplicate-argument-name:4:foo1:Duplicate argument name _ in function definition
+duplicate-argument-name:7:foo2:Duplicate argument name _abc in function definition
+duplicate-argument-name:7:foo2:Duplicate argument name _abc in function definition
+duplicate-argument-name:10:foo3:Duplicate argument name _ in function definition
+duplicate-argument-name:10:foo3:Duplicate argument name _ in function definition
+duplicate-argument-name:13:foo4:Duplicate argument name _ in function definition
+duplicate-argument-name:13:foo4:Duplicate argument name _ in function definition
\ No newline at end of file
diff --git a/tests/functional/duplicate_argument_name_py3.py b/tests/functional/duplicate_argument_name_py3.py
new file mode 100644
index 000000000..c7fbe3478
--- /dev/null
+++ b/tests/functional/duplicate_argument_name_py3.py
@@ -0,0 +1,5 @@
+"""Check for duplicate function keywordonly arguments."""
+
+
+def foo1(_, *_, _=3): # [duplicate-argument-name, duplicate-argument-name]
+    """Function with duplicate argument name."""
diff --git a/tests/functional/duplicate_argument_name_py3.rc b/tests/functional/duplicate_argument_name_py3.rc
new file mode 100644
index 000000000..a2ab06c50
--- /dev/null
+++ b/tests/functional/duplicate_argument_name_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/duplicate_argument_name_py3.txt b/tests/functional/duplicate_argument_name_py3.txt
new file mode 100644
index 000000000..d86631746
--- /dev/null
+++ b/tests/functional/duplicate_argument_name_py3.txt
@@ -0,0 +1,2 @@
+duplicate-argument-name:4:foo1:Duplicate argument name _ in function definition
+duplicate-argument-name:4:foo1:Duplicate argument name _ in function definition
\ No newline at end of file
diff --git a/tests/functional/duplicate_bases.py b/tests/functional/duplicate_bases.py
new file mode 100644
index 000000000..974f97584
--- /dev/null
+++ b/tests/functional/duplicate_bases.py
@@ -0,0 +1,15 @@
+"""Test duplicate bases error."""

+# pylint: disable=missing-docstring,too-few-public-methods,no-init

+

+

+class Duplicates(str, str): # [duplicate-bases]

+    pass

+

+

+class Alpha(str):

+    pass

+

+

+class NotDuplicates(Alpha, str):

+    """The error should not be emitted for this case, since the

+    other same base comes from the ancestors."""

diff --git a/tests/functional/duplicate_bases.txt b/tests/functional/duplicate_bases.txt
new file mode 100644
index 000000000..beb91b53f
--- /dev/null
+++ b/tests/functional/duplicate_bases.txt
@@ -0,0 +1 @@
+duplicate-bases:5:Duplicates:Duplicate bases for class 'Duplicates'
\ No newline at end of file
diff --git a/tests/functional/duplicate_dict_literal_key.py b/tests/functional/duplicate_dict_literal_key.py
new file mode 100644
index 000000000..726a2591e
--- /dev/null
+++ b/tests/functional/duplicate_dict_literal_key.py
@@ -0,0 +1,17 @@
+"""Check multiple key definition"""
+# pylint: disable=C0103,pointless-statement
+
+correct_dict = {
+    'tea': 'for two',
+    'two': 'for tea',
+}
+
+wrong_dict = {  # [duplicate-key]
+    'tea': 'for two',
+    'two': 'for tea',
+    'tea': 'time',
+
+}
+
+{1: b'a', 1: u'a'} # [duplicate-key]
+{1: 1, 1.0: 2} # [duplicate-key]
diff --git a/tests/functional/duplicate_dict_literal_key.txt b/tests/functional/duplicate_dict_literal_key.txt
new file mode 100644
index 000000000..060d9dc63
--- /dev/null
+++ b/tests/functional/duplicate_dict_literal_key.txt
@@ -0,0 +1,3 @@
+duplicate-key:9::Duplicate key 'tea' in dictionary
+duplicate-key:16::Duplicate key 1 in dictionary
+duplicate-key:17::Duplicate key 1.0 in dictionary
diff --git a/tests/functional/duplicate_except.py b/tests/functional/duplicate_except.py
new file mode 100644
index 000000000..c68cf7a24
--- /dev/null
+++ b/tests/functional/duplicate_except.py
@@ -0,0 +1,12 @@
+"""Test for duplicate-check."""
+
+def main():
+    """The second ValueError should be flagged."""
+    try:
+        raise ValueError('test')
+    except ValueError:
+        return 1
+    except ValueError:  # [duplicate-except]
+        return 2
+    except (OSError, TypeError):
+        return 3
diff --git a/tests/functional/duplicate_except.txt b/tests/functional/duplicate_except.txt
new file mode 100644
index 000000000..a037948e9
--- /dev/null
+++ b/tests/functional/duplicate_except.txt
@@ -0,0 +1 @@
+duplicate-except:9:main:Catching previously caught exception type ValueError
diff --git a/tests/functional/duplicate_string_formatting_argument.py b/tests/functional/duplicate_string_formatting_argument.py
new file mode 100644
index 000000000..b012f98e0
--- /dev/null
+++ b/tests/functional/duplicate_string_formatting_argument.py
@@ -0,0 +1,15 @@
+# pylint: disable=missing-docstring
+
+NAME = 42
+OTHER_NAME = 24
+OTHER_OTHER_NAME = 2
+
+# +1: [duplicate-string-formatting-argument,duplicate-string-formatting-argument]
+CONST = "some value {} some other value {} {} {} {} {}".format(
+    NAME,
+    NAME,
+    OTHER_NAME,
+    OTHER_NAME,
+    OTHER_NAME,
+    OTHER_OTHER_NAME,
+)
diff --git a/tests/functional/duplicate_string_formatting_argument.txt b/tests/functional/duplicate_string_formatting_argument.txt
new file mode 100644
index 000000000..6d352eb2e
--- /dev/null
+++ b/tests/functional/duplicate_string_formatting_argument.txt
@@ -0,0 +1,2 @@
+duplicate-string-formatting-argument:8::Duplicate string formatting argument 'NAME', consider passing as named argument
+duplicate-string-formatting-argument:8::Duplicate string formatting argument 'OTHER_NAME', consider passing as named argument
diff --git a/tests/functional/eval_used.py b/tests/functional/eval_used.py
new file mode 100644
index 000000000..d03dad7ca
--- /dev/null
+++ b/tests/functional/eval_used.py
@@ -0,0 +1,10 @@
+"""test for eval usage"""
+
+eval('os.listdir(".")') # [eval-used]
+eval('os.listdir(".")', globals={})  # [eval-used]
+
+eval('os.listdir(".")', globals=globals())  # [eval-used]
+
+def func():
+    """ eval in local scope"""
+    eval('b = 1')  # [eval-used]
diff --git a/tests/functional/eval_used.txt b/tests/functional/eval_used.txt
new file mode 100644
index 000000000..7f0e04143
--- /dev/null
+++ b/tests/functional/eval_used.txt
@@ -0,0 +1,4 @@
+eval-used:3::Use of eval

+eval-used:4::Use of eval

+eval-used:6::Use of eval

+eval-used:10:func:Use of eval
\ No newline at end of file
diff --git a/tests/functional/exception_is_binary_op.py b/tests/functional/exception_is_binary_op.py
new file mode 100644
index 000000000..f71163d1f
--- /dev/null
+++ b/tests/functional/exception_is_binary_op.py
@@ -0,0 +1,12 @@
+"""Warn about binary operations used as exceptions."""
+from __future__ import print_function
+try:
+    pass
+except Exception or BaseException:  # [binary-op-exception]
+    print("caught1")
+except Exception and BaseException:  # [binary-op-exception]
+    print("caught2")
+except Exception or BaseException:  # [binary-op-exception]
+    print("caught3")
+except (Exception or BaseException) as exc:  # [binary-op-exception]
+    print("caught4")
diff --git a/tests/functional/exception_is_binary_op.txt b/tests/functional/exception_is_binary_op.txt
new file mode 100644
index 000000000..e6512c968
--- /dev/null
+++ b/tests/functional/exception_is_binary_op.txt
@@ -0,0 +1,4 @@
+binary-op-exception:5::"Exception to catch is the result of a binary ""or"" operation"
+binary-op-exception:7::"Exception to catch is the result of a binary ""and"" operation"
+binary-op-exception:9::"Exception to catch is the result of a binary ""or"" operation"
+binary-op-exception:11::"Exception to catch is the result of a binary ""or"" operation"
diff --git a/tests/functional/exception_message.py b/tests/functional/exception_message.py
new file mode 100644
index 000000000..da95c78f7
--- /dev/null
+++ b/tests/functional/exception_message.py
@@ -0,0 +1,41 @@
+"""
+Check accessing Exception.message
+"""
+# pylint: disable=import-error, no-absolute-import, broad-except
+
+from unknown import ExtensionException
+__revision__ = 0
+
+class SubException(IndexError):
+    """ empty """
+
+_ = IndexError("test").message # [exception-message-attribute]
+_ = ZeroDivisionError("error").message # [exception-message-attribute]
+_ = ExtensionException("error").message
+_ = SubException("error").message # [exception-message-attribute]
+
+try:
+    raise Exception('e')
+except Exception as exception:
+    _ = exception.message # [exception-message-attribute]
+    del exception.message # [exception-message-attribute]
+    exception.message += 'hello world' # [exception-message-attribute]
+    exception.message = 'hello world'
+
+
+class CompatException(Exception):
+    """An exception which should work on py2 and py3."""
+
+    def __init__(self, message=''):
+        super(CompatException, self).__init__()
+        self.message = message
+
+    def __repr__(self):
+        result = 'CompatException %s' % self.message
+        return result.encode('utf-8')
+
+
+try:
+    raise CompatException('message here')
+except CompatException as error:
+    _ = error.message
diff --git a/tests/functional/exception_message.rc b/tests/functional/exception_message.rc
new file mode 100644
index 000000000..9540bc95e
--- /dev/null
+++ b/tests/functional/exception_message.rc
@@ -0,0 +1,5 @@
+[testoptions]
+max_pyver=3.0
+
+[Messages Control]
+enable=python3
\ No newline at end of file
diff --git a/tests/functional/exception_message.txt b/tests/functional/exception_message.txt
new file mode 100644
index 000000000..b2a993bdf
--- /dev/null
+++ b/tests/functional/exception_message.txt
@@ -0,0 +1,6 @@
+exception-message-attribute:12::Exception.message removed in Python 3

+exception-message-attribute:13::Exception.message removed in Python 3

+exception-message-attribute:15::Exception.message removed in Python 3

+exception-message-attribute:20::Exception.message removed in Python 3

+exception-message-attribute:21::Exception.message removed in Python 3

+exception-message-attribute:22::Exception.message removed in Python 3

diff --git a/tests/functional/exec_used_py2.py b/tests/functional/exec_used_py2.py
new file mode 100644
index 000000000..8f7f07d90
--- /dev/null
+++ b/tests/functional/exec_used_py2.py
@@ -0,0 +1,10 @@
+# pylint: disable=missing-docstring
+
+exec 'a = __revision__' # [exec-used]
+VALUES = {}
+exec 'a = 1' in VALUES # [exec-used]
+
+exec 'a = 1' in globals() # [exec-used]
+
+def func():
+    exec 'b = 1' # [exec-used]
diff --git a/tests/functional/exec_used_py2.rc b/tests/functional/exec_used_py2.rc
new file mode 100644
index 000000000..a65023393
--- /dev/null
+++ b/tests/functional/exec_used_py2.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max_pyver=3.0
diff --git a/tests/functional/exec_used_py2.txt b/tests/functional/exec_used_py2.txt
new file mode 100644
index 000000000..6b0e7d1a2
--- /dev/null
+++ b/tests/functional/exec_used_py2.txt
@@ -0,0 +1,4 @@
+exec-used:3::Use of exec

+exec-used:5::Use of exec

+exec-used:7::Use of exec

+exec-used:10:func:Use of exec
\ No newline at end of file
diff --git a/tests/functional/exec_used_py3.py b/tests/functional/exec_used_py3.py
new file mode 100644
index 000000000..5f849480e
--- /dev/null
+++ b/tests/functional/exec_used_py3.py
@@ -0,0 +1,9 @@
+# pylint: disable=missing-docstring
+
+exec('a = __revision__') # [exec-used]
+exec('a = 1', globals={}) # [exec-used]
+
+exec('a = 1', globals=globals()) # [exec-used]
+
+def func():
+    exec('b = 1') # [exec-used]
diff --git a/tests/functional/exec_used_py3.rc b/tests/functional/exec_used_py3.rc
new file mode 100644
index 000000000..c093be204
--- /dev/null
+++ b/tests/functional/exec_used_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/exec_used_py3.txt b/tests/functional/exec_used_py3.txt
new file mode 100644
index 000000000..67885745a
--- /dev/null
+++ b/tests/functional/exec_used_py3.txt
@@ -0,0 +1,4 @@
+exec-used:3::Use of exec

+exec-used:4::Use of exec

+exec-used:6::Use of exec

+exec-used:9:func:Use of exec
\ No newline at end of file
diff --git a/tests/functional/fallback_import_disabled.py b/tests/functional/fallback_import_disabled.py
new file mode 100644
index 000000000..321eb1158
--- /dev/null
+++ b/tests/functional/fallback_import_disabled.py
@@ -0,0 +1,10 @@
+# pylint: disable=missing-docstring,unused-import
+try:
+    import urllib2 as urllib_request #@
+    import urllib2 as urllib_error
+    from urlparse import urlparse
+except ImportError:
+    # python2
+    from urllib import request as urllib_request
+    from urllib import error as urllib_error
+    from urllib.parse import urlparseq
diff --git a/tests/functional/fallback_import_disabled.txt b/tests/functional/fallback_import_disabled.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/fallback_import_disabled.txt
diff --git a/tests/functional/fallback_import_enabled.py b/tests/functional/fallback_import_enabled.py
new file mode 100644
index 000000000..9420830ff
--- /dev/null
+++ b/tests/functional/fallback_import_enabled.py
@@ -0,0 +1,5 @@
+# pylint: disable=missing-docstring,unused-import
+try:
+    import collections.missing # [no-name-in-module]
+except ImportError:
+    from collections import missing # [no-name-in-module]
diff --git a/tests/functional/fallback_import_enabled.rc b/tests/functional/fallback_import_enabled.rc
new file mode 100644
index 000000000..204ce11b6
--- /dev/null
+++ b/tests/functional/fallback_import_enabled.rc
@@ -0,0 +1,2 @@
+[IMPORTS]
+analyse-fallback-blocks=yes
\ No newline at end of file
diff --git a/tests/functional/fallback_import_enabled.txt b/tests/functional/fallback_import_enabled.txt
new file mode 100644
index 000000000..e795b82c0
--- /dev/null
+++ b/tests/functional/fallback_import_enabled.txt
@@ -0,0 +1,2 @@
+no-name-in-module:3::No name 'missing' in module 'collections'
+no-name-in-module:5::No name 'missing' in module 'collections'
\ No newline at end of file
diff --git a/tests/functional/fixme.py b/tests/functional/fixme.py
new file mode 100644
index 000000000..298355d4a
--- /dev/null
+++ b/tests/functional/fixme.py
@@ -0,0 +1,24 @@
+# -*- encoding=utf-8 -*-
+# pylint: disable=missing-docstring, unused-variable
+
+# +1: [fixme]
+# FIXME: beep
+
+
+def function():
+    variable = "FIXME: Ignore me!"
+    # +1: [fixme]
+    test = "text"  # FIXME: Valid test
+
+    # +1: [fixme]
+    # TODO: Do something with the variables
+    # +1: [fixme]
+    xxx = "n/a"  # XXX: Fix this later
+    # +1: [fixme]
+    #FIXME: no space after hash
+    # +1: [fixme]
+    #todo: no space after hash
+    #FIXME: in fact nothing to fix #pylint: disable=fixme
+    #TODO: in fact nothing to do #pylint: disable=fixme
+    #TODO: in fact nothing to do #pylint: disable=line-too-long, fixme
+    # Todoist API mentioned should not result in a message.
diff --git a/tests/functional/fixme.txt b/tests/functional/fixme.txt
new file mode 100644
index 000000000..d281646e6
--- /dev/null
+++ b/tests/functional/fixme.txt
@@ -0,0 +1,6 @@
+fixme:5::"FIXME: beep"
+fixme:11::"FIXME: Valid test"
+fixme:14::"TODO: Do something with the variables"
+fixme:16::"XXX: Fix this later"
+fixme:18::"FIXME: no space after hash"
+fixme:20::"todo: no space after hash"
\ No newline at end of file
diff --git a/tests/functional/fixme_bad_formatting_1139.py b/tests/functional/fixme_bad_formatting_1139.py
new file mode 100644
index 000000000..33030ed4c
--- /dev/null
+++ b/tests/functional/fixme_bad_formatting_1139.py
@@ -0,0 +1,6 @@
+"""

+Test for issue ##1139 - when CRLF newline characters are used,

+\r is left in msg section. As a result, output line in cmdline

+is overwritten with text after msg"""

+

+# TODO Lorem ipsum dolor sit amet consectetur adipiscing elit  # [fixme]

diff --git a/tests/functional/fixme_bad_formatting_1139.rc b/tests/functional/fixme_bad_formatting_1139.rc
new file mode 100644
index 000000000..554bb3013
--- /dev/null
+++ b/tests/functional/fixme_bad_formatting_1139.rc
@@ -0,0 +1,2 @@
+[MESSAGES CONTROL]
+msg-template={C}:{line:3d},{column:2d}: {obj}: {msg} ({symbol}, {msg_id})
diff --git a/tests/functional/fixme_bad_formatting_1139.txt b/tests/functional/fixme_bad_formatting_1139.txt
new file mode 100644
index 000000000..62ea8b887
--- /dev/null
+++ b/tests/functional/fixme_bad_formatting_1139.txt
@@ -0,0 +1 @@
+fixme:6::TODO Lorem ipsum dolor sit amet consectetur adipiscing elit  # [fixme]:HIGH
diff --git a/tests/functional/formatted_string_literal_with_if_py36.py b/tests/functional/formatted_string_literal_with_if_py36.py
new file mode 100644
index 000000000..8feb4e293
--- /dev/null
+++ b/tests/functional/formatted_string_literal_with_if_py36.py
@@ -0,0 +1,8 @@
+"""Test that `if` in formatted string literal won't break Pylint."""
+# pylint: disable=missing-docstring, pointless-statement, using-constant-test
+
+f'{"+" if True else "-"}'
+if True:
+    pass
+elif True:
+    pass
diff --git a/tests/functional/formatted_string_literal_with_if_py36.rc b/tests/functional/formatted_string_literal_with_if_py36.rc
new file mode 100644
index 000000000..0ba2b6333
--- /dev/null
+++ b/tests/functional/formatted_string_literal_with_if_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/formatting.txt b/tests/functional/formatting.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/formatting.txt
diff --git a/tests/functional/function_redefined.py b/tests/functional/function_redefined.py
new file mode 100644
index 000000000..ba2832894
--- /dev/null
+++ b/tests/functional/function_redefined.py
@@ -0,0 +1,109 @@
+# pylint: disable=R0201,missing-docstring,using-constant-test,unused-import,wrong-import-position,reimported, useless-object-inheritance, unnecessary-pass
+from __future__ import division
+__revision__ = ''
+
+class AAAA(object):
+    """docstring"""
+    def __init__(self):
+        pass
+    def method1(self):
+        """docstring"""
+
+    def method2(self):
+        """docstring"""
+
+    def method2(self): # [function-redefined]
+        """docstring"""
+
+class AAAA(object): # [function-redefined]
+    """docstring"""
+    def __init__(self):
+        pass
+    def yeah(self):
+        """hehehe"""
+    def yoo(self):
+        """yoo"""
+def func1():
+    """docstring"""
+
+def func2():
+    """docstring"""
+
+def func2(): # [function-redefined]
+    """docstring"""
+    __revision__ = 1 # [redefined-outer-name]
+    return __revision__
+
+if __revision__:
+    def exclusive_func():
+        "docstring"
+else:
+    def exclusive_func():
+        "docstring"
+
+try:
+    def exclusive_func2():
+        "docstring"
+except TypeError:
+    def exclusive_func2():
+        "docstring"
+else:
+    def exclusive_func2(): # [function-redefined]
+        "this one redefine the one defined line 42"
+
+
+def with_inner_function_1():
+    """docstring"""
+    def callback():
+        """callback docstring"""
+        pass
+    return callback
+
+def with_inner_function_2():
+    """docstring"""
+    def callback():
+        """does not redefine callback returned by with_inner_function_1"""
+        pass
+    return callback
+
+def some_func():
+    """Don't emit if we defined a variable with the same name as a
+    __future__ directive.
+    """
+    division = 2
+    return division
+
+def dummy_func():
+    """First dummy function"""
+    pass
+
+def dummy_func():
+    """Second dummy function, don't emit function-redefined message
+    because of the dummy name"""
+    pass
+
+from math import ceil
+def ceil(): # [function-redefined]
+    pass
+
+import math
+def math(): # [function-redefined]
+    pass
+
+import math as _
+def _():
+    pass
+
+# pylint: disable=too-few-public-methods
+class ObjectProxy:
+    """ABC"""
+
+    # We actually *redefine* these attributes, but these shouldn't
+    # be considered actual redefinitions. Issue #2451
+    @property
+    def __module__(self):
+        return "actual.module"
+
+    @property
+    def __doc__(self):
+        return "Docstring"
diff --git a/tests/functional/function_redefined.txt b/tests/functional/function_redefined.txt
new file mode 100644
index 000000000..fcd3c0ef2
--- /dev/null
+++ b/tests/functional/function_redefined.txt
@@ -0,0 +1,7 @@
+function-redefined:15:AAAA.method2:method already defined line 12
+function-redefined:18:AAAA:class already defined line 5
+function-redefined:32:func2:function already defined line 29
+redefined-outer-name:34:func2:Redefining name '__revision__' from outer scope (line 3)
+function-redefined:51:exclusive_func2:function already defined line 45
+function-redefined:86:ceil:function already defined line 85
+function-redefined:90:math:function already defined line 89
diff --git a/tests/functional/future_import.py b/tests/functional/future_import.py
new file mode 100644
index 000000000..e4d3785a1
--- /dev/null
+++ b/tests/functional/future_import.py
@@ -0,0 +1,3 @@
+"""a docstring"""
+
+from __future__ import generators
diff --git a/tests/functional/future_unicode_literals.py b/tests/functional/future_unicode_literals.py
new file mode 100644
index 000000000..30c2bd6b3
--- /dev/null
+++ b/tests/functional/future_unicode_literals.py
@@ -0,0 +1,6 @@
+"""Unicode literals in Python 2.*"""
+from __future__ import unicode_literals
+
+
+BAD_STRING = b'\u1234'  # >= 2.7.4:[anomalous-unicode-escape-in-string]
+GOOD_STRING = '\u1234'
diff --git a/tests/functional/future_unicode_literals.rc b/tests/functional/future_unicode_literals.rc
new file mode 100644
index 000000000..58b5a9413
--- /dev/null
+++ b/tests/functional/future_unicode_literals.rc
@@ -0,0 +1 @@
+[testoptions]
diff --git a/tests/functional/future_unicode_literals.txt b/tests/functional/future_unicode_literals.txt
new file mode 100644
index 000000000..60d291e72
--- /dev/null
+++ b/tests/functional/future_unicode_literals.txt
@@ -0,0 +1 @@
+anomalous-unicode-escape-in-string:5::"Anomalous Unicode escape in byte string: '\u'. String constant might be missing an r or u prefix."
diff --git a/tests/functional/generated_members.py b/tests/functional/generated_members.py
new file mode 100644
index 000000000..802ebaf8f
--- /dev/null
+++ b/tests/functional/generated_members.py
@@ -0,0 +1,18 @@
+"""Test the generated-members config option."""
+# pylint: disable=pointless-statement, invalid-name, useless-object-inheritance
+from __future__ import print_function
+from astroid import node_classes
+from pylint import checkers
+
+class Klass(object):
+    """A class with a generated member."""
+
+print(Klass().DoesNotExist)
+print(Klass().aBC_set1)
+node_classes.Tuple.does.not_.exist
+checkers.base.doesnotexist()
+
+session = Klass()
+SESSION = Klass()
+session.rollback()
+SESSION.rollback()
diff --git a/tests/functional/generated_members.rc b/tests/functional/generated_members.rc
new file mode 100644
index 000000000..177eca955
--- /dev/null
+++ b/tests/functional/generated_members.rc
@@ -0,0 +1,5 @@
+[Messages Control]
+disable=too-few-public-methods,print-statement
+
+[typecheck]
+generated-members=DoesNotExist,"[a-zA-Z]+_set{1,2}",node_classes.Tuple.*,checkers.*?base,(session|SESSION).rollback
diff --git a/tests/functional/genexp_in_class_scope.py b/tests/functional/genexp_in_class_scope.py
new file mode 100644
index 000000000..868cf6b79
--- /dev/null
+++ b/tests/functional/genexp_in_class_scope.py
@@ -0,0 +1,6 @@
+# pylint: disable=W0232,R0903, missing-docstring, useless-object-inheritance
+"""Class scope must be handled correctly in genexps"""
+
+class MyClass(object):
+    var1 = []
+    var2 = list(value*2 for value in var1)
diff --git a/tests/functional/genexp_in_class_scope.txt b/tests/functional/genexp_in_class_scope.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/genexp_in_class_scope.txt
diff --git a/tests/functional/genexpr_variable_scope.py b/tests/functional/genexpr_variable_scope.py
new file mode 100644
index 000000000..a00d72d32
--- /dev/null
+++ b/tests/functional/genexpr_variable_scope.py
@@ -0,0 +1,5 @@
+"""test name defined in generator expression are not available
+outside the genexpr scope
+"""
+from __future__ import print_function
+print(n)  # [undefined-variable]
diff --git a/tests/functional/genexpr_variable_scope.txt b/tests/functional/genexpr_variable_scope.txt
new file mode 100644
index 000000000..3cfa6c5e0
--- /dev/null
+++ b/tests/functional/genexpr_variable_scope.txt
@@ -0,0 +1 @@
+undefined-variable:5::Undefined variable 'n'
diff --git a/tests/functional/globals.py b/tests/functional/globals.py
new file mode 100644
index 000000000..1a24ff736
--- /dev/null
+++ b/tests/functional/globals.py
@@ -0,0 +1,32 @@
+"""Warnings about global statements and usage of global variables."""
+from __future__ import print_function
+
+global CSTE  # [global-at-module-level]
+print(CSTE)  # [undefined-variable]
+
+CONSTANT = 1
+
+def fix_contant(value):
+    """all this is ok, but try not using global ;)"""
+    global CONSTANT  # [global-statement]
+    print(CONSTANT)
+    CONSTANT = value
+
+
+def other():
+    """global behaviour test"""
+    global HOP  # [global-variable-not-assigned]
+    print(HOP)  # [undefined-variable]
+
+
+def define_constant():
+    """ok but somevar is not defined at the module scope"""
+    global SOMEVAR  # [global-variable-undefined]
+    SOMEVAR = 2
+
+
+# pylint: disable=invalid-name
+def global_with_import():
+    """should only warn for global-statement"""
+    global sys  # [global-statement]
+    import sys
diff --git a/tests/functional/globals.txt b/tests/functional/globals.txt
new file mode 100644
index 000000000..0ce528daf
--- /dev/null
+++ b/tests/functional/globals.txt
@@ -0,0 +1,7 @@
+global-at-module-level:4::Using the global statement at the module level
+undefined-variable:5::Undefined variable 'CSTE'
+global-statement:11:fix_contant:Using the global statement
+global-variable-not-assigned:18:other:Using global for 'HOP' but no assignment is done
+undefined-variable:19:other:Undefined variable 'HOP'
+global-variable-undefined:24:define_constant:Global variable 'SOMEVAR' undefined at the module level
+global-statement:31:global_with_import:Using the global statement
diff --git a/tests/functional/implicit_str_concat_in_sequence.py b/tests/functional/implicit_str_concat_in_sequence.py
new file mode 100644
index 000000000..8c4b5cb46
--- /dev/null
+++ b/tests/functional/implicit_str_concat_in_sequence.py
@@ -0,0 +1,26 @@
+#pylint: disable=bad-continuation,invalid-name,missing-docstring
+
+# Basic test with a list
+TEST_LIST1 = ['a' 'b']  # [implicit-str-concat-in-sequence]
+# Testing with unicode strings in a tuple, with a comma AFTER concatenation
+TEST_LIST2 = (u"a" u"b", u"c")  # [implicit-str-concat-in-sequence]
+# Testing with raw strings in a set, with a comma BEFORE concatenation
+TEST_LIST3 = {r'''a''', r'''b''' r'''c'''}  # [implicit-str-concat-in-sequence]
+# Testing that only ONE warning is generated when string concatenation happens
+# in the middle of a list
+TEST_LIST4 = ["""a""", """b""" """c""", """d"""]  # [implicit-str-concat-in-sequence]
+
+# The following shouldn't raise a warning because it is a function call
+print('a', 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'ccc')
+
+# The following shouldn't raise a warning because string literals are
+# on different lines
+TEST_LIST5 = ('a', 'b'
+              'c')
+
+# The following shouldn't raise a warning because of the escaped newline
+TEST_LIST6 = ('a' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb \
+              ccc')
+
+# No warning for bytes
+TEST_LIST7 = [b'A' b'B']
diff --git a/tests/functional/implicit_str_concat_in_sequence.txt b/tests/functional/implicit_str_concat_in_sequence.txt
new file mode 100644
index 000000000..b9e1cbba9
--- /dev/null
+++ b/tests/functional/implicit_str_concat_in_sequence.txt
@@ -0,0 +1,4 @@
+implicit-str-concat-in-sequence:4::Implicit string concatenation found in list
+implicit-str-concat-in-sequence:6::Implicit string concatenation found in tuple
+implicit-str-concat-in-sequence:8::Implicit string concatenation found in set
+implicit-str-concat-in-sequence:11::Implicit string concatenation found in list
diff --git a/tests/functional/implicit_str_concat_in_sequence_latin1.py b/tests/functional/implicit_str_concat_in_sequence_latin1.py
new file mode 100644
index 000000000..44a2a94cb
--- /dev/null
+++ b/tests/functional/implicit_str_concat_in_sequence_latin1.py
@@ -0,0 +1,4 @@
+# coding: latin_1
+#pylint: disable=bad-continuation,invalid-name,missing-docstring
+
+TOTO = ('Caf�', 'Caf�', 'Caf�')
diff --git a/tests/functional/implicit_str_concat_in_sequence_latin1.txt b/tests/functional/implicit_str_concat_in_sequence_latin1.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/implicit_str_concat_in_sequence_latin1.txt
diff --git a/tests/functional/implicit_str_concat_in_sequence_multiline.py b/tests/functional/implicit_str_concat_in_sequence_multiline.py
new file mode 100755
index 000000000..0f8d1fcdf
--- /dev/null
+++ b/tests/functional/implicit_str_concat_in_sequence_multiline.py
@@ -0,0 +1,4 @@
+#pylint: disable=bad-continuation,missing-docstring
+
+TEST_TUPLE = ('a', 'b'  # [implicit-str-concat-in-sequence]
+              'c')
diff --git a/tests/functional/implicit_str_concat_in_sequence_multiline.rc b/tests/functional/implicit_str_concat_in_sequence_multiline.rc
new file mode 100755
index 000000000..e5b344774
--- /dev/null
+++ b/tests/functional/implicit_str_concat_in_sequence_multiline.rc
@@ -0,0 +1,2 @@
+[STRING_CONSTANT]

+check-str-concat-over-line-jumps=yes

diff --git a/tests/functional/implicit_str_concat_in_sequence_multiline.txt b/tests/functional/implicit_str_concat_in_sequence_multiline.txt
new file mode 100755
index 000000000..b37cf624b
--- /dev/null
+++ b/tests/functional/implicit_str_concat_in_sequence_multiline.txt
@@ -0,0 +1 @@
+implicit-str-concat-in-sequence:3::Implicit string concatenation found in tuple
\ No newline at end of file
diff --git a/tests/functional/implicit_str_concat_in_sequence_utf8.py b/tests/functional/implicit_str_concat_in_sequence_utf8.py
new file mode 100644
index 000000000..fa996e90c
--- /dev/null
+++ b/tests/functional/implicit_str_concat_in_sequence_utf8.py
@@ -0,0 +1,3 @@
+#pylint: disable=bad-continuation,invalid-name,missing-docstring
+
+TOTO = ('Café', 'Café', 'Café')
diff --git a/tests/functional/implicit_str_concat_in_sequence_utf8.txt b/tests/functional/implicit_str_concat_in_sequence_utf8.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/implicit_str_concat_in_sequence_utf8.txt
diff --git a/tests/functional/import_error.py b/tests/functional/import_error.py
new file mode 100644
index 000000000..69fd15be1
--- /dev/null
+++ b/tests/functional/import_error.py
@@ -0,0 +1,29 @@
+""" Test that import errors are detected. """
+# pylint: disable=invalid-name, unused-import, no-absolute-import, bare-except, broad-except, wrong-import-order, wrong-import-position
+import totally_missing # [import-error]
+
+try:
+    import maybe_missing
+except ImportError:
+    maybe_missing = None
+
+try:
+    import maybe_missing_1
+except (ImportError, SyntaxError):
+    maybe_missing_1 = None
+
+try:
+    import maybe_missing_2 # [import-error]
+except ValueError:
+    maybe_missing_2 = None
+
+
+try:
+    if maybe_missing:
+        import really_missing
+except ImportError:
+    pass
+
+from .collections import missing # [import-error]
+
+from .syntax_error import toto # [syntax-error]
diff --git a/tests/functional/import_error.rc b/tests/functional/import_error.rc
new file mode 100644
index 000000000..de78a17ce
--- /dev/null
+++ b/tests/functional/import_error.rc
@@ -0,0 +1,2 @@
+[Messages Control]
+disable=C,R,W
diff --git a/tests/functional/import_error.txt b/tests/functional/import_error.txt
new file mode 100644
index 000000000..493e79a01
--- /dev/null
+++ b/tests/functional/import_error.txt
@@ -0,0 +1,4 @@
+import-error:3::"Unable to import 'totally_missing'"
+import-error:16::"Unable to import 'maybe_missing_2'"
+import-error:27::"Unable to import 'functional.collections'"
+syntax-error:29::"Cannot import 'syntax_error' due to syntax error 'invalid syntax (<unknown>, line 1)'"
diff --git a/tests/functional/inconsistent_mro.py b/tests/functional/inconsistent_mro.py
new file mode 100644
index 000000000..0b65068d7
--- /dev/null
+++ b/tests/functional/inconsistent_mro.py
@@ -0,0 +1,9 @@
+"""Tests for inconsistent-mro."""

+# pylint: disable=missing-docstring,too-few-public-methods,no-init

+

+class Str(str):

+    pass

+

+

+class Inconsistent(str, Str): # [inconsistent-mro]

+    pass

diff --git a/tests/functional/inconsistent_mro.txt b/tests/functional/inconsistent_mro.txt
new file mode 100644
index 000000000..1ae9687d5
--- /dev/null
+++ b/tests/functional/inconsistent_mro.txt
@@ -0,0 +1 @@
+inconsistent-mro:8:Inconsistent:Inconsistent method resolution order for class 'Inconsistent'
diff --git a/tests/functional/inconsistent_returns.py b/tests/functional/inconsistent_returns.py
new file mode 100644
index 000000000..619165611
--- /dev/null
+++ b/tests/functional/inconsistent_returns.py
@@ -0,0 +1,264 @@
+#pylint: disable=missing-docstring, no-else-return, invalid-name, unused-variable, superfluous-parens, try-except-raise
+"""Testing inconsistent returns"""
+import math
+import sys
+
+# These ones are consistent
+def explicit_returns(var):
+    if var >= 0:
+        return math.sqrt(var)
+    else:
+        return None
+
+def explicit_returns2(var):
+    if var < 0:
+        return None
+    return math.sqrt(var)
+
+def empty_implicit_returns(var):
+    if var < 0:
+        return
+
+def returns_in_exceptions():
+    try:
+        raise ValueError('test')
+    except ValueError:
+        return 1
+    except (OSError, TypeError):
+        return 2
+
+def returns_and_exceptions(var):
+    if var < 10:
+        return var**2
+    else:
+        raise ValueError("Incorrect value")
+
+def returns_and_exceptions_issue1770(var):
+    try:
+        if var == 1:
+            return 'a'
+        elif var == 2:
+            return 'b'
+        else:
+            raise ValueError
+    except AssertionError:
+        return None
+
+def explicit_returns3(arg):
+    if arg:
+        return False
+    else:
+        if arg < 3:
+            print('arg < 3')
+        return True
+
+def explicit_returns4(arg):
+    if arg:
+        if arg > 2:
+            print('arg > 2')
+        return False
+    else:
+        if arg < 3:
+            print('arg < 3')
+        return True
+
+def explicit_returns5(arg):
+    if arg:
+        if arg > 2:
+            print('arg > 2')
+        return False
+    else:
+        return True
+
+def nested_function():
+    def dummy_return():
+        return True
+    return dummy_return
+
+def explicit_returns6(x, y, z):
+    if x:  # pylint: disable=no-else-return
+        a = 1
+        if y:  # pylint: disable=no-else-return
+            b = 2
+            return y
+        else:
+            c = 3
+            return x
+    else:
+        d = 4
+        return z
+
+def explicit_returns7(arg):
+    if arg < 0:
+        arg = 2 * arg
+        return 'below 0'
+    elif arg == 0:
+        print("Null arg")
+        return '0'
+    else:
+        arg = 3 * arg
+        return 'above 0'
+
+def bug_1772():
+    """Don't check inconsistent return statements inside while loop"""
+    counter = 1
+    while True:
+        counter += 1
+        if counter == 100:
+            return 7
+
+def bug_1771(var):
+    if var == 1:
+        sys.exit(1)
+    else:
+        return var * 2
+
+def bug_1771_with_user_config(var):
+    # sys.getdefaultencoding is considered as a never
+    # returning function in the inconsistent_returns.rc file.
+    if var == 1:
+        sys.getdefaultencoding()
+    else:
+        return var * 2
+
+def bug_1794_inner_func_in_if(var):
+    # pylint: disable = no-else-return,useless-return
+    if var:
+        def _inner():
+            return None
+        return None
+    else:
+        return None
+
+try:
+    import ConfigParser as configparser
+except ImportError:
+    import configparser
+
+# Due to the try/except import above, astroid cannot safely
+# infer the exception type. It doesn't matter here, because
+# as the raise statement is not inside a try/except one, there
+# is no need to infer the exception type. It is just an exception
+# that is raised.
+def bug_1794(a):
+    for x in range(a):
+        if x == 100:
+            return a
+    raise configparser.NoSectionError('toto')
+
+#pylint: disable = no-else-return
+def bug_1782_bis(val=3):
+    if val == 3:
+        while True:
+            break
+        return True
+    else:
+        raise RuntimeError()
+
+# Next ones are not consistent
+def explicit_implicit_returns(var): # [inconsistent-return-statements]
+    if var >= 0:
+        return math.sqrt(var)
+
+def empty_explicit_returns(var): # [inconsistent-return-statements]
+    if var < 0:
+        return
+    return math.sqrt(var)
+
+def explicit_implicit_returns2(arg): # [inconsistent-return-statements]
+    if arg:
+        if arg > 2:
+            print('arg > 2')
+            return False
+    else:
+        return True
+
+def explicit_implicit_returns3(arg): # [inconsistent-return-statements]
+    if arg:
+        if arg > 2:
+            print('arg > 2')
+            return False
+        else:
+            return True
+
+def returns_missing_in_catched_exceptions(arg): # [inconsistent-return-statements]
+    try:
+        arg = arg**2
+        raise ValueError('test')
+    except ValueError:
+        print('ValueError')
+        arg = 0
+    except (OSError, TypeError):
+        return 2
+
+def complex_func(arg): # [inconsistent-return-statements]
+    for i in range(arg):
+        if i > arg / 2:
+            break
+        else:
+            return arg
+
+def inconsistent_returns_in_nested_function():
+    def not_consistent_returns_inner(arg): # [inconsistent-return-statements]
+        for i in range(arg):
+            if i > arg / 2:
+                break
+            else:
+                return arg
+    return not_consistent_returns_inner
+
+def bug_1771_counter_example(var): # [inconsistent-return-statements]
+    if var == 1:
+        inconsistent_returns_in_nested_function()
+    else:
+        return var * 2
+
+class BlargException(Exception):
+    pass
+
+
+def blarg(someval):
+    try:
+        if someval:
+            raise BlargException()
+        return 5
+    except BlargException:
+        raise
+
+def bug_1772_counter_example(): # [inconsistent-return-statements]
+    counter = 1
+    if counter == 1:
+        while True:
+            counter += 1
+            if counter == 100:
+                return 7
+
+def bug_1794_inner_func_in_if_counter_example_1(var): # [inconsistent-return-statements]
+    # pylint: disable = no-else-return,useless-return
+    if var:
+        def _inner():
+            return None
+        return None
+    else:
+        return
+
+def bug_1794_inner_func_in_if_counter_example_2(var): # [inconsistent-return-statements]
+    # pylint: disable = no-else-return,useless-return
+    if var:
+        def _inner():
+            return
+        return None
+    else:
+        return
+
+def bug_1794_inner_func_in_if_counter_example_3(var): # [inconsistent-return-statements]
+    # pylint: disable = no-else-return,useless-return
+    if var:
+        def _inner():
+            return None
+        return None
+    else:
+        def _inner2(var_bis): # [inconsistent-return-statements]
+            if var_bis:
+                return True
+            return
diff --git a/tests/functional/inconsistent_returns.rc b/tests/functional/inconsistent_returns.rc
new file mode 100644
index 000000000..dd6cbb598
--- /dev/null
+++ b/tests/functional/inconsistent_returns.rc
@@ -0,0 +1,2 @@
+[REFACTORING]
+never-returning-functions=sys.exit,sys.getdefaultencoding
diff --git a/tests/functional/inconsistent_returns.txt b/tests/functional/inconsistent_returns.txt
new file mode 100644
index 000000000..d2d70e653
--- /dev/null
+++ b/tests/functional/inconsistent_returns.txt
@@ -0,0 +1,13 @@
+inconsistent-return-statements:159:explicit_implicit_returns:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:163:empty_explicit_returns:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:168:explicit_implicit_returns2:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:176:explicit_implicit_returns3:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:184:returns_missing_in_catched_exceptions:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:194:complex_func:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:202:inconsistent_returns_in_nested_function.not_consistent_returns_inner:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:210:bug_1771_counter_example:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:228:bug_1772_counter_example:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:236:bug_1794_inner_func_in_if_counter_example_1:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:245:bug_1794_inner_func_in_if_counter_example_2:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:254:bug_1794_inner_func_in_if_counter_example_3:Either all return statements in a function should return an expression, or none of them should.
+inconsistent-return-statements:261:bug_1794_inner_func_in_if_counter_example_3._inner2:Either all return statements in a function should return an expression, or none of them should.
diff --git a/tests/functional/indexing_exception.py b/tests/functional/indexing_exception.py
new file mode 100644
index 000000000..9ac1a7c68
--- /dev/null
+++ b/tests/functional/indexing_exception.py
@@ -0,0 +1,15 @@
+"""
+Check for indexing exceptions.
+"""
+# pylint: disable=import-error, no-absolute-import
+
+from unknown import ExtensionException
+__revision__ = 0
+
+class SubException(IndexError):
+    """ empty """
+
+_ = IndexError("test")[0] # [indexing-exception]
+_ = ZeroDivisionError("error")[0] # [indexing-exception]
+_ = ExtensionException("error")[0]
+_ = SubException("error")[1] # [indexing-exception]
diff --git a/tests/functional/indexing_exception.rc b/tests/functional/indexing_exception.rc
new file mode 100644
index 000000000..9540bc95e
--- /dev/null
+++ b/tests/functional/indexing_exception.rc
@@ -0,0 +1,5 @@
+[testoptions]
+max_pyver=3.0
+
+[Messages Control]
+enable=python3
\ No newline at end of file
diff --git a/tests/functional/indexing_exception.txt b/tests/functional/indexing_exception.txt
new file mode 100644
index 000000000..9f3067803
--- /dev/null
+++ b/tests/functional/indexing_exception.txt
@@ -0,0 +1,3 @@
+indexing-exception:12::Indexing exceptions will not work on Python 3

+indexing-exception:13::Indexing exceptions will not work on Python 3

+indexing-exception:15::Indexing exceptions will not work on Python 3
\ No newline at end of file
diff --git a/tests/functional/inherit_non_class.py b/tests/functional/inherit_non_class.py
new file mode 100644
index 000000000..ee9ef508c
--- /dev/null
+++ b/tests/functional/inherit_non_class.py
@@ -0,0 +1,81 @@
+"""Test that inheriting from something which is not

+a class emits a warning. """

+

+# pylint: disable=no-init, import-error, invalid-name, using-constant-test, useless-object-inheritance

+# pylint: disable=missing-docstring, too-few-public-methods, no-absolute-import

+

+from missing import Missing

+

+if 1:

+    Ambiguous = None

+else:

+    Ambiguous = int

+

+class Empty(object):

+    """ Empty class. """

+

+def return_class():

+    """ Return a class. """

+    return Good3

+

+class Bad(1): # [inherit-non-class]

+    """ Can't inherit from instance. """

+

+class Bad1(lambda abc: 42): # [inherit-non-class]

+    """ Can't inherit from lambda. """

+

+class Bad2(object()): # [inherit-non-class]

+    """ Can't inherit from an instance of object. """

+

+class Bad3(return_class): # [inherit-non-class]

+    """ Can't inherit from function. """

+

+class Bad4(Empty()): # [inherit-non-class]

+    """ Can't inherit from instance. """

+

+class Good(object):

+    pass

+

+class Good1(int):

+    pass

+

+class Good2(type):

+    pass

+

+class Good3(type(int)):

+    pass

+

+class Good4(return_class()):

+    pass

+

+class Good5(Good4, int, object):

+    pass

+

+class Good6(Ambiguous):

+    """ Inherits from something ambiguous.

+

+    This could emit a warning when we will have

+    flow detection.

+    """

+

+class Unknown(Missing):

+    pass

+

+class Unknown1(Good5 if True else Bad1):

+    pass

+

+

+class NotInheritableBool(bool): # [inherit-non-class]

+    pass

+

+

+class NotInheritableRange(range): # [inherit-non-class]

+    pass

+

+

+class NotInheritableSlice(slice): # [inherit-non-class]

+    pass

+

+

+class NotInheritableMemoryView(memoryview): # [inherit-non-class]

+    pass

diff --git a/tests/functional/inherit_non_class.txt b/tests/functional/inherit_non_class.txt
new file mode 100644
index 000000000..3be70cb9d
--- /dev/null
+++ b/tests/functional/inherit_non_class.txt
@@ -0,0 +1,9 @@
+inherit-non-class:21:Bad:Inheriting '1', which is not a class.
+inherit-non-class:24:Bad1:"Inheriting 'lambda abc: 42', which is not a class."
+inherit-non-class:27:Bad2:Inheriting 'object()', which is not a class.
+inherit-non-class:30:Bad3:Inheriting 'return_class', which is not a class.
+inherit-non-class:33:Bad4:Inheriting 'Empty()', which is not a class.
+inherit-non-class:68:NotInheritableBool:Inheriting 'bool', which is not a class.
+inherit-non-class:72:NotInheritableRange:Inheriting 'range', which is not a class.
+inherit-non-class:76:NotInheritableSlice:Inheriting 'slice', which is not a class.
+inherit-non-class:80:NotInheritableMemoryView:Inheriting 'memoryview', which is not a class.
\ No newline at end of file
diff --git a/tests/functional/init_is_generator.py b/tests/functional/init_is_generator.py
new file mode 100644
index 000000000..17f96db30
--- /dev/null
+++ b/tests/functional/init_is_generator.py
@@ -0,0 +1,5 @@
+# pylint: disable=missing-docstring,too-few-public-methods, useless-object-inheritance
+
+class SomeClass(object):
+    def __init__(self): # [init-is-generator]
+        yield None
diff --git a/tests/functional/init_is_generator.txt b/tests/functional/init_is_generator.txt
new file mode 100644
index 000000000..5d2132a1f
--- /dev/null
+++ b/tests/functional/init_is_generator.txt
@@ -0,0 +1 @@
+init-is-generator:4:SomeClass.__init__:__init__ method is a generator
diff --git a/tests/functional/init_not_called.py b/tests/functional/init_not_called.py
new file mode 100644
index 000000000..282306489
--- /dev/null
+++ b/tests/functional/init_not_called.py
@@ -0,0 +1,64 @@
+# pylint: disable=R0903,import-error,missing-docstring,wrong-import-position,useless-super-delegation, useless-object-inheritance, unnecessary-pass
+"""test for __init__ not called
+"""
+from __future__ import print_function
+
+class AAAA:
+    """ancestor 1"""
+
+    def __init__(self):
+        print('init', self)
+
+class BBBB:
+    """ancestor 2"""
+
+    def __init__(self):
+        print('init', self)
+
+class CCCC:
+    """ancestor 3"""
+
+
+class ZZZZ(AAAA, BBBB, CCCC):
+    """derived class"""
+
+    def __init__(self):  # [super-init-not-called]
+        AAAA.__init__(self)
+
+class NewStyleA(object):
+    """new style class"""
+    def __init__(self):
+        super(NewStyleA, self).__init__()
+        print('init', self)
+
+class NewStyleB(NewStyleA):
+    """derived new style class"""
+    def __init__(self):
+        super(NewStyleB, self).__init__()
+
+class NoInit(object):
+    """No __init__ defined"""
+
+class Init(NoInit):
+    """Don't complain for not calling the super __init__"""
+
+    def __init__(self, arg):
+        self.arg = arg
+
+class NewStyleC(object):
+    """__init__ defined by assignment."""
+    def xx_init(self):
+        """Initializer."""
+        pass
+
+    __init__ = xx_init
+
+class AssignedInit(NewStyleC):
+    """No init called."""
+    def __init__(self):  # [super-init-not-called]
+        self.arg = 0
+
+from missing import Missing
+
+class UnknownBases(Missing):
+    """Don't emit no-init if the bases aren't known."""
diff --git a/tests/functional/init_not_called.txt b/tests/functional/init_not_called.txt
new file mode 100644
index 000000000..955d4181b
--- /dev/null
+++ b/tests/functional/init_not_called.txt
@@ -0,0 +1,3 @@
+no-init:18:CCCC:Class has no __init__ method
+super-init-not-called:25:ZZZZ.__init__:__init__ method from base class 'BBBB' is not called
+super-init-not-called:58:AssignedInit.__init__:__init__ method from base class 'NewStyleC' is not called
diff --git a/tests/functional/init_subclass_classmethod_py36.py b/tests/functional/init_subclass_classmethod_py36.py
new file mode 100644
index 000000000..ad379705d
--- /dev/null
+++ b/tests/functional/init_subclass_classmethod_py36.py
@@ -0,0 +1,16 @@
+# pylint: disable=too-few-public-methods, missing-docstring,no-init, useless-object-inheritance
+
+class PluginBase(object):
+    subclasses = []
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        cls.subclasses.append(cls)
+
+
+class Plugin1(PluginBase):
+    pass
+
+
+class Plugin2(PluginBase):
+    pass
diff --git a/tests/functional/init_subclass_classmethod_py36.rc b/tests/functional/init_subclass_classmethod_py36.rc
new file mode 100644
index 000000000..1450ccc64
--- /dev/null
+++ b/tests/functional/init_subclass_classmethod_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
\ No newline at end of file
diff --git a/tests/functional/invalid_all_object.py b/tests/functional/invalid_all_object.py
new file mode 100644
index 000000000..4468c987b
--- /dev/null
+++ b/tests/functional/invalid_all_object.py
@@ -0,0 +1,6 @@
+# pylint: disable=missing-docstring

+__all__ = (

+    1, # [invalid-all-object]

+    lambda: None, # [invalid-all-object]

+    None, # [invalid-all-object]

+)

diff --git a/tests/functional/invalid_all_object.txt b/tests/functional/invalid_all_object.txt
new file mode 100644
index 000000000..b25efc8f6
--- /dev/null
+++ b/tests/functional/invalid_all_object.txt
@@ -0,0 +1,3 @@
+invalid-all-object:3::Invalid object '1' in __all__, must contain only strings

+invalid-all-object:4:<lambda>:"Invalid object 'lambda: None' in __all__, must contain only strings"

+invalid-all-object:5::Invalid object 'None' in __all__, must contain only strings

diff --git a/tests/functional/invalid_encoded_data.py b/tests/functional/invalid_encoded_data.py
new file mode 100644
index 000000000..743031cef
--- /dev/null
+++ b/tests/functional/invalid_encoded_data.py
@@ -0,0 +1,5 @@
+# coding: utf-8
+"""Test data file with encoding errors."""
+
+
+STR = 'Су�ествительное'  # [invalid-encoded-data]
diff --git a/tests/functional/invalid_encoded_data.rc b/tests/functional/invalid_encoded_data.rc
new file mode 100644
index 000000000..a65023393
--- /dev/null
+++ b/tests/functional/invalid_encoded_data.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max_pyver=3.0
diff --git a/tests/functional/invalid_encoded_data.txt b/tests/functional/invalid_encoded_data.txt
new file mode 100644
index 000000000..c6e69dc1f
--- /dev/null
+++ b/tests/functional/invalid_encoded_data.txt
@@ -0,0 +1 @@
+invalid-encoded-data:5::"Cannot decode using encoding ""utf-8"", unexpected byte at position 11"
diff --git a/tests/functional/invalid_encoding_py27.py b/tests/functional/invalid_encoding_py27.py
new file mode 100644
index 000000000..fb6b2de16
--- /dev/null
+++ b/tests/functional/invalid_encoding_py27.py
@@ -0,0 +1,3 @@
+"""Test data file with wrong encoding and if coding is not first line."""
+# coding: utd-8 # [syntax-error]
+STR = 'some text'
diff --git a/tests/functional/invalid_encoding_py27.rc b/tests/functional/invalid_encoding_py27.rc
new file mode 100644
index 000000000..eca2dd95a
--- /dev/null
+++ b/tests/functional/invalid_encoding_py27.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=2.7.10
+max_pyver=3.0
diff --git a/tests/functional/invalid_encoding_py27.txt b/tests/functional/invalid_encoding_py27.txt
new file mode 100644
index 000000000..856a1a1db
--- /dev/null
+++ b/tests/functional/invalid_encoding_py27.txt
@@ -0,0 +1 @@
+syntax-error:2::Cannot decode using encoding "utd-8", bad encoding
diff --git a/tests/functional/invalid_envvar_value.py b/tests/functional/invalid_envvar_value.py
new file mode 100644
index 000000000..3c1a8882b
--- /dev/null
+++ b/tests/functional/invalid_envvar_value.py
@@ -0,0 +1,84 @@
+# pylint: disable=useless-return,missing-docstring
+from os import getenv
+
+
+def function_returning_list():
+    return []
+
+def function_returning_none():
+    return None
+
+def function_returning_string():
+    return "Result"
+
+def function_returning_bytes():
+    return b"Result"
+
+def deep_function_returning_string():
+    return function_returning_string()
+
+def deep_function_returning_bytes():
+    return function_returning_bytes()
+
+
+# --------------------------------------------------------------------------- #
+#                               Testing getenv                                #
+# --------------------------------------------------------------------------- #
+
+getenv()   # pylint: disable=no-value-for-parameter
+
+getenv(b"TEST")  # [invalid-envvar-value]
+getenv("TEST")
+getenv(None)   # [invalid-envvar-value]
+getenv(["Crap"])   # [invalid-envvar-value]
+getenv(function_returning_bytes())   # [invalid-envvar-value]
+getenv(deep_function_returning_bytes())   # [invalid-envvar-value]
+getenv(function_returning_list())   # [invalid-envvar-value]
+getenv(function_returning_none())   # [invalid-envvar-value]
+getenv(function_returning_string())
+getenv(deep_function_returning_string())
+
+getenv(b"TEST", "default")   # [invalid-envvar-value]
+getenv("TEST", "default")
+getenv(None, "default")  # [invalid-envvar-value]
+getenv(["Crap"], "default")   # [invalid-envvar-value]
+getenv(function_returning_bytes(), "default")   # [invalid-envvar-value]
+getenv(function_returning_list(), "default")   # [invalid-envvar-value]
+getenv(function_returning_none(), "default")   # [invalid-envvar-value]
+getenv(function_returning_string(), "default")
+
+getenv(key=b"TEST")   # [invalid-envvar-value]
+getenv(key="TEST")
+getenv(key=None)    # [invalid-envvar-value]
+getenv(key=["Crap"])   # [invalid-envvar-value]
+getenv(key=function_returning_bytes())   # [invalid-envvar-value]
+getenv(key=function_returning_list())   # [invalid-envvar-value]
+getenv(key=function_returning_none())   # [invalid-envvar-value]
+getenv(key=function_returning_string())
+
+getenv('TEST', "value")
+getenv('TEST', [])  # [invalid-envvar-default]
+getenv('TEST', None)
+getenv('TEST', b"123")  # [invalid-envvar-default]
+getenv('TEST', function_returning_list()) # [invalid-envvar-default]
+getenv('TEST', function_returning_none())
+getenv('TEST', function_returning_string())
+getenv('TEST', function_returning_bytes())   # [invalid-envvar-default]
+
+getenv('TEST', default="value")
+getenv('TEST', default=[])  # [invalid-envvar-default]
+getenv('TEST', default=None)
+getenv('TEST', default=b"123")  # [invalid-envvar-default]
+getenv('TEST', default=function_returning_list())  # [invalid-envvar-default]
+getenv('TEST', default=function_returning_none())
+getenv('TEST', default=function_returning_string())
+getenv('TEST', default=function_returning_bytes())  # [invalid-envvar-default]
+
+getenv(key='TEST')
+getenv(key='TEST', default="value")
+getenv(key='TEST', default=b"value")  # [invalid-envvar-default]
+getenv(key='TEST', default=["Crap"])  # [invalid-envvar-default]
+getenv(key='TEST', default=function_returning_list())  # [invalid-envvar-default]
+getenv(key='TEST', default=function_returning_none())
+getenv(key='TEST', default=function_returning_string())
+getenv(key='TEST', default=function_returning_bytes())  # [invalid-envvar-default]
diff --git a/tests/functional/invalid_envvar_value.txt b/tests/functional/invalid_envvar_value.txt
new file mode 100644
index 000000000..824d20e3f
--- /dev/null
+++ b/tests/functional/invalid_envvar_value.txt
@@ -0,0 +1,31 @@
+invalid-envvar-value:30::os.getenv does not support builtins.bytes type argument
+invalid-envvar-value:32::os.getenv does not support builtins.NoneType type argument
+invalid-envvar-value:33::os.getenv does not support builtins.list type argument
+invalid-envvar-value:34::os.getenv does not support builtins.bytes type argument
+invalid-envvar-value:35::os.getenv does not support builtins.bytes type argument
+invalid-envvar-value:36::os.getenv does not support builtins.list type argument
+invalid-envvar-value:37::os.getenv does not support builtins.NoneType type argument
+invalid-envvar-value:41::os.getenv does not support builtins.bytes type argument
+invalid-envvar-value:43::os.getenv does not support builtins.NoneType type argument
+invalid-envvar-value:44::os.getenv does not support builtins.list type argument
+invalid-envvar-value:45::os.getenv does not support builtins.bytes type argument
+invalid-envvar-value:46::os.getenv does not support builtins.list type argument
+invalid-envvar-value:47::os.getenv does not support builtins.NoneType type argument
+invalid-envvar-value:50::os.getenv does not support builtins.bytes type argument
+invalid-envvar-value:52::os.getenv does not support builtins.NoneType type argument
+invalid-envvar-value:53::os.getenv does not support builtins.list type argument
+invalid-envvar-value:54::os.getenv does not support builtins.bytes type argument
+invalid-envvar-value:55::os.getenv does not support builtins.list type argument
+invalid-envvar-value:56::os.getenv does not support builtins.NoneType type argument
+invalid-envvar-default:60::os.getenv default type is builtins.list. Expected str or None.
+invalid-envvar-default:62::os.getenv default type is builtins.bytes. Expected str or None.
+invalid-envvar-default:63::os.getenv default type is builtins.list. Expected str or None.
+invalid-envvar-default:66::os.getenv default type is builtins.bytes. Expected str or None.
+invalid-envvar-default:69::os.getenv default type is builtins.list. Expected str or None.
+invalid-envvar-default:71::os.getenv default type is builtins.bytes. Expected str or None.
+invalid-envvar-default:72::os.getenv default type is builtins.list. Expected str or None.
+invalid-envvar-default:75::os.getenv default type is builtins.bytes. Expected str or None.
+invalid-envvar-default:79::os.getenv default type is builtins.bytes. Expected str or None.
+invalid-envvar-default:80::os.getenv default type is builtins.list. Expected str or None.
+invalid-envvar-default:81::os.getenv default type is builtins.list. Expected str or None.
+invalid-envvar-default:84::os.getenv default type is builtins.bytes. Expected str or None.
diff --git a/tests/functional/invalid_exceptions_caught.py b/tests/functional/invalid_exceptions_caught.py
new file mode 100644
index 000000000..252643446
--- /dev/null
+++ b/tests/functional/invalid_exceptions_caught.py
@@ -0,0 +1,135 @@
+# pylint: disable=missing-docstring, too-few-public-methods, useless-object-inheritance
+# pylint: disable=too-many-ancestors, no-absolute-import, import-error, multiple-imports,wrong-import-position
+from __future__ import print_function
+
+import socket, binascii, abc, six
+
+class MyException(object):
+    """Custom 'exception'."""
+
+class MySecondException(object):
+    """Custom 'exception'."""
+
+class MyGoodException(Exception):
+    """Custom exception."""
+
+class MySecondGoodException(MyGoodException):
+    """Custom exception."""
+
+class SkipException(socket.error):
+    """Not an exception for Python 2, but one in 3."""
+
+class SecondSkipException(SkipException):
+    """Also a good exception."""
+
+try:
+    1 + 1
+except MyException:  # [catching-non-exception]
+    print("caught")
+
+try:
+    1 + 2
+# +1:[catching-non-exception,catching-non-exception]
+except (MyException, MySecondException):
+    print("caught")
+
+try:
+    1 + 3
+except MyGoodException:
+    print("caught")
+
+try:
+    1 + 3
+except (MyGoodException, MySecondGoodException):
+    print("caught")
+
+try:
+    1 + 3
+except (SkipException, SecondSkipException):
+    print("caught")
+
+try:
+    1 + 42
+# +1:[catching-non-exception,catching-non-exception]
+except (None, list()):
+    print("caught")
+
+try:
+    1 + 24
+except None: # [catching-non-exception]
+    print("caught")
+
+EXCEPTION = None
+EXCEPTION = ZeroDivisionError
+try:
+    1 + 46
+except EXCEPTION:
+    print("caught")
+
+try:
+    1 + 42
+# +1:[catching-non-exception,catching-non-exception,catching-non-exception]
+except (list([4, 5, 6]), None, ZeroDivisionError, 4):
+    print("caught")
+
+EXCEPTION_TUPLE = (ZeroDivisionError, OSError)
+NON_EXCEPTION_TUPLE = (ZeroDivisionError, OSError, 4)
+
+try:
+    1 + 42
+except EXCEPTION_TUPLE:
+    print("caught")
+
+try:
+    1 + 42
+except NON_EXCEPTION_TUPLE: # [catching-non-exception]
+    print("caught")
+
+from missing_import import UnknownError
+UNKNOWN_COMPONENTS = (ZeroDivisionError, UnknownError)
+
+try:
+    1 + 42
+except UNKNOWN_COMPONENTS:
+    print("caught")
+
+try:
+    1 + 42
+except binascii.Error:
+    print('builtin and detected')
+
+try:
+    1 + 45
+except object: # [catching-non-exception]
+    print('caught')
+
+try:
+    1 + 42
+except range: # [catching-non-exception]
+    print('caught')
+
+
+class HasErrorInMRO(six.with_metaclass(abc.ABCMeta, Exception)):
+    pass
+
+
+class Second(HasErrorInMRO):
+    pass
+
+
+try:
+    raise Second
+except Second:
+    pass
+
+
+class SomeBase(UnknownError):
+    pass
+
+
+EXCEPTIONS = (SomeBase, ValueError)
+
+try:
+    raise ValueError
+except EXCEPTIONS:
+    pass
diff --git a/tests/functional/invalid_exceptions_caught.txt b/tests/functional/invalid_exceptions_caught.txt
new file mode 100644
index 000000000..e51030b69
--- /dev/null
+++ b/tests/functional/invalid_exceptions_caught.txt
@@ -0,0 +1,12 @@
+catching-non-exception:27::"Catching an exception which doesn't inherit from Exception: MyException"
+catching-non-exception:33::"Catching an exception which doesn't inherit from Exception: MyException"
+catching-non-exception:33::"Catching an exception which doesn't inherit from Exception: MySecondException"
+catching-non-exception:54::"Catching an exception which doesn't inherit from Exception: None"
+catching-non-exception:54::"Catching an exception which doesn't inherit from Exception: list()"
+catching-non-exception:59::"Catching an exception which doesn't inherit from Exception: None"
+catching-non-exception:72::"Catching an exception which doesn't inherit from Exception: 4"
+catching-non-exception:72::"Catching an exception which doesn't inherit from Exception: None"
+catching-non-exception:72::"Catching an exception which doesn't inherit from Exception: list([4, 5, 6])"
+catching-non-exception:85::"Catching an exception which doesn't inherit from Exception: NON_EXCEPTION_TUPLE"
+catching-non-exception:103::"Catching an exception which doesn't inherit from Exception: object"
+catching-non-exception:108::"Catching an exception which doesn't inherit from Exception: range"
diff --git a/tests/functional/invalid_exceptions_raised.py b/tests/functional/invalid_exceptions_raised.py
new file mode 100644
index 000000000..78e6b65a0
--- /dev/null
+++ b/tests/functional/invalid_exceptions_raised.py
@@ -0,0 +1,105 @@
+# pylint:disable=too-few-public-methods,no-init,import-error,missing-docstring, not-callable, useless-object-inheritance
+"""test pb with exceptions and old/new style classes"""
+
+
+class ValidException(Exception):
+    """Valid Exception."""
+
+class OldStyleClass:
+    """Not an exception."""
+
+class NewStyleClass(object):
+    """Not an exception."""
+
+
+def good_case():
+    """raise"""
+    raise ValidException('hop')
+
+def good_case1():
+    """zlib.error is defined in C module."""
+    import zlib
+    raise zlib.error(4)
+
+def good_case2():
+    """decimal.DivisionByZero is defined in C on Python 3."""
+    import decimal
+    raise decimal.DivisionByZero(4)
+
+def good_case3():
+    """io.BlockingIOError is defined in C."""
+    import io
+    raise io.BlockingIOError
+
+def bad_case0():
+    """raise"""
+    # +2:<3.0:[nonstandard-exception]
+    # +1:>=3.0:[raising-non-exception]
+    raise OldStyleClass('hop')
+
+def bad_case1():
+    """raise"""
+    raise NewStyleClass()  # [raising-non-exception]
+
+def bad_case2():
+    """raise"""
+    # +2:<3.0:[nonstandard-exception]
+    # +1:>=3.0:[raising-non-exception]
+    raise OldStyleClass('hop')
+
+def bad_case3():
+    """raise"""
+    raise NewStyleClass  # [raising-non-exception]
+
+def bad_case4():
+    """raise"""
+    raise NotImplemented('hop')  # [notimplemented-raised]
+
+def bad_case5():
+    """raise"""
+    raise 1  # [raising-bad-type]
+
+def bad_case6():
+    """raise"""
+    raise None  # [raising-bad-type]
+
+def bad_case7():
+    """raise list"""
+    raise list # [raising-non-exception]
+
+def bad_case8():
+    """raise tuple"""
+    raise tuple # [raising-non-exception]
+
+def bad_case9():
+    """raise dict"""
+    raise dict # [raising-non-exception]
+
+def unknown_bases():
+    """Don't emit when we don't know the bases."""
+    from lala import bala
+    class MyException(bala):
+        pass
+    raise MyException
+
+
+def exception_instance_regression():
+    """Exceptions have a particular class type"""
+    try:
+        int("9a")
+    except ValueError as exc:
+        raise exc
+
+
+def reusing_same_name_picks_the_latest_raised_value():
+    class Error(Exception):
+        """some error"""
+
+    exceptions = tuple([ValueError, TypeError])
+    try:
+        raise ValueError
+    except exceptions as exc:  # pylint: disable=catching-non-exception
+        # https://github.com/PyCQA/pylint/issues/1756
+        exc = Error(exc)
+        if exc:
+            raise exc
diff --git a/tests/functional/invalid_exceptions_raised.txt b/tests/functional/invalid_exceptions_raised.txt
new file mode 100644
index 000000000..47eb0fec2
--- /dev/null
+++ b/tests/functional/invalid_exceptions_raised.txt
@@ -0,0 +1,12 @@
+nonstandard-exception:38:bad_case0:"Exception doesn't inherit from standard ""Exception"" class"
+raising-non-exception:38:bad_case0:Raising a new style class which doesn't inherit from BaseException
+raising-non-exception:42:bad_case1:Raising a new style class which doesn't inherit from BaseException
+nonstandard-exception:48:bad_case2:"Exception doesn't inherit from standard ""Exception"" class"
+raising-non-exception:48:bad_case2:Raising a new style class which doesn't inherit from BaseException
+raising-non-exception:52:bad_case3:Raising a new style class which doesn't inherit from BaseException
+notimplemented-raised:56:bad_case4:NotImplemented raised - should raise NotImplementedError
+raising-bad-type:60:bad_case5:Raising int while only classes or instances are allowed
+raising-bad-type:64:bad_case6:Raising NoneType while only classes or instances are allowed
+raising-non-exception:68:bad_case7:Raising a new style class which doesn't inherit from BaseException
+raising-non-exception:72:bad_case8:Raising a new style class which doesn't inherit from BaseException
+raising-non-exception:76:bad_case9:Raising a new style class which doesn't inherit from BaseException
\ No newline at end of file
diff --git a/tests/functional/invalid_length_returned.py b/tests/functional/invalid_length_returned.py
new file mode 100644
index 000000000..e57db5290
--- /dev/null
+++ b/tests/functional/invalid_length_returned.py
@@ -0,0 +1,64 @@
+"""Check invalid value returned by __len__ """
+
+# pylint: disable=too-few-public-methods,missing-docstring,no-self-use,import-error, useless-object-inheritance
+import sys
+
+import six
+
+from missing import Missing
+
+
+class FirstGoodLen(object):
+    """__len__ returns <type 'int'>"""
+
+    def __len__(self):
+        return 0
+
+
+class SecondGoodLen(object):
+    """__len__ returns <type 'long'>"""
+
+    def __len__(self):
+        return sys.maxsize + 1
+
+
+class LenMetaclass(type):
+    def __len__(cls):
+        return 1
+
+
+@six.add_metaclass(LenMetaclass)
+class ThirdGoodLen(object):
+    """Length through the metaclass."""
+
+
+class FirstBadLen(object):
+    """ __len__ returns a negative integer """
+
+    def __len__(self):  # [invalid-length-returned]
+        return -1
+
+
+class SecondBadLen(object):
+    """ __len__ returns non-int """
+
+    def __len__(self):  # [invalid-length-returned]
+        return 3.0
+
+
+class ThirdBadLen(object):
+    """ __len__ returns node which does not have 'value' in AST """
+
+    def __len__(self):  # [invalid-length-returned]
+        return lambda: 3
+
+
+class AmbigousLen(object):
+    """ Uninferable return value """
+    __len__ = lambda self: Missing
+
+
+class AnotherAmbiguousLen(object):
+    """Potential uninferable return value"""
+    def __len__(self):
+        return int(Missing)
diff --git a/tests/functional/invalid_length_returned.txt b/tests/functional/invalid_length_returned.txt
new file mode 100644
index 000000000..6febeb612
--- /dev/null
+++ b/tests/functional/invalid_length_returned.txt
@@ -0,0 +1,3 @@
+invalid-length-returned:38:FirstBadLen.__len__:__len__ does not return non-negative integer
+invalid-length-returned:45:SecondBadLen.__len__:__len__ does not return non-negative integer
+invalid-length-returned:52:ThirdBadLen.__len__:__len__ does not return non-negative integer
diff --git a/tests/functional/invalid_metaclass.py b/tests/functional/invalid_metaclass.py
new file mode 100644
index 000000000..c0e9d74be
--- /dev/null
+++ b/tests/functional/invalid_metaclass.py
@@ -0,0 +1,34 @@
+# pylint: disable=missing-docstring, too-few-public-methods, import-error,unused-argument, useless-object-inheritance
+
+import abc
+
+import six
+from unknown import Unknown
+
+
+class InvalidAsMetaclass(object):
+    pass
+
+
+class ValidAsMetaclass(type):
+    pass
+
+
+@six.add_metaclass(type)
+class FirstGood(object):
+    pass
+
+
+@six.add_metaclass(abc.ABCMeta)
+class SecondGood(object):
+    pass
+
+
+@six.add_metaclass(Unknown)
+class ThirdGood(object):
+    pass
+
+
+@six.add_metaclass(ValidAsMetaclass)
+class FourthGood(object):
+    pass
diff --git a/tests/functional/invalid_metaclass.txt b/tests/functional/invalid_metaclass.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/invalid_metaclass.txt
diff --git a/tests/functional/invalid_metaclass_py3.py b/tests/functional/invalid_metaclass_py3.py
new file mode 100644
index 000000000..2fc458f5c
--- /dev/null
+++ b/tests/functional/invalid_metaclass_py3.py
@@ -0,0 +1,19 @@
+# pylint: disable=missing-docstring, too-few-public-methods, import-error,unused-argument
+
+from unknown import Unknown
+
+
+def valid_metaclass_1(name, _, attrs):
+    return type
+
+
+def valid_metaclass_2(_name, _bases, _attrs):
+    return Unknown
+
+
+class GoodMetaclass(metaclass=valid_metaclass_1):
+    pass
+
+
+class SecondGoodMetaclass(metaclass=valid_metaclass_2):
+    pass
diff --git a/tests/functional/invalid_metaclass_py3.rc b/tests/functional/invalid_metaclass_py3.rc
new file mode 100644
index 000000000..c093be204
--- /dev/null
+++ b/tests/functional/invalid_metaclass_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/invalid_metaclass_py3.txt b/tests/functional/invalid_metaclass_py3.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/invalid_metaclass_py3.txt
diff --git a/tests/functional/invalid_name.py b/tests/functional/invalid_name.py
new file mode 100644
index 000000000..1a949904e
--- /dev/null
+++ b/tests/functional/invalid_name.py
@@ -0,0 +1,39 @@
+""" Tests for invalid-name checker. """

+# pylint: disable=unused-import, no-absolute-import, wrong-import-position

+

+AAA = 24

+try:

+    import collections

+except ImportError:

+    collections = None

+

+aaa = 42 # [invalid-name]

+try:

+    import time

+except ValueError:

+    time = None # [invalid-name]

+

+try:

+    from sys import argv, executable as python

+except ImportError:

+    argv = 42

+    python = 24

+

+def test():

+    """ Shouldn't emit an invalid-name here. """

+    try:

+        import re

+    except ImportError:

+        re = None

+    return re

+

+def a(): # [invalid-name]

+    """yo"""

+

+

+def _generate_cmdline_tests():

+    TestCase = collections.namedtuple('TestCase', 'cmd, valid')

+    valid = ['leave-mode', 'hint all']

+    # Valid command only -> valid

+    for item in valid:

+        yield TestCase(''.join(item), True)

diff --git a/tests/functional/invalid_name.txt b/tests/functional/invalid_name.txt
new file mode 100644
index 000000000..25d3a56f0
--- /dev/null
+++ b/tests/functional/invalid_name.txt
@@ -0,0 +1,3 @@
+invalid-name:10::"Constant name ""aaa"" doesn't conform to UPPER_CASE naming style"
+invalid-name:14::"Constant name ""time"" doesn't conform to UPPER_CASE naming style"
+invalid-name:30:a:"Function name ""a"" doesn't conform to snake_case naming style"
diff --git a/tests/functional/invalid_sequence_index.py b/tests/functional/invalid_sequence_index.py
new file mode 100644
index 000000000..d11155c02
--- /dev/null
+++ b/tests/functional/invalid_sequence_index.py
@@ -0,0 +1,242 @@
+"""Errors for invalid sequence indices"""
+# pylint: disable=too-few-public-methods, no-self-use, import-error, missing-docstring, useless-object-inheritance, unnecessary-pass
+import six
+from unknown import Unknown
+
+TESTLIST = [1, 2, 3]
+TESTTUPLE = (1, 2, 3)
+TESTSTR = '123'
+
+# getitem tests with bad indices
+def function1():
+    """list index is a function"""
+    return TESTLIST[id] # [invalid-sequence-index]
+
+def function2():
+    """list index is None"""
+    return TESTLIST[None] # [invalid-sequence-index]
+
+def function3():
+    """list index is a float expression"""
+    return TESTLIST[float(0)] # [invalid-sequence-index]
+
+def function4():
+    """list index is a str constant"""
+    return TESTLIST['0'] # [invalid-sequence-index]
+
+def function5():
+    """list index does not implement __index__"""
+    class NonIndexType(object):
+        """Class without __index__ method"""
+        pass
+
+    return TESTLIST[NonIndexType()] # [invalid-sequence-index]
+
+def function6():
+    """Tuple index is None"""
+    return TESTTUPLE[None] # [invalid-sequence-index]
+
+def function7():
+    """String index is None"""
+    return TESTSTR[None] # [invalid-sequence-index]
+
+def function8():
+    """Index of subclass of tuple is None"""
+    class TupleTest(tuple):
+        """Subclass of tuple"""
+        pass
+    return TupleTest()[None] # [invalid-sequence-index]
+
+# getitem tests with good indices
+def function9():
+    """list index is an int constant"""
+    return TESTLIST[0]  # no error
+
+def function10():
+    """list index is an integer expression"""
+    return TESTLIST[int(0.0)] # no error
+
+def function11():
+    """list index is a slice"""
+    return TESTLIST[slice(1, 2, 3)] # no error
+
+def function12():
+    """list index implements __index__"""
+    class IndexType(object):
+        """Class with __index__ method"""
+        def __index__(self):
+            """Allow objects of this class to be used as slice indices"""
+            return 0
+
+    return TESTLIST[IndexType()] # no error
+
+def function13():
+    """list index implements __index__ in a superclass"""
+    class IndexType(object):
+        """Class with __index__ method"""
+        def __index__(self):
+            """Allow objects of this class to be used as slice indices"""
+            return 0
+
+    class IndexSubType(IndexType):
+        """Class with __index__ in parent"""
+        pass
+
+    return TESTLIST[IndexSubType()] # no error
+
+def function14():
+    """Tuple index is an int constant"""
+    return TESTTUPLE[0]
+
+def function15():
+    """String index is an int constant"""
+    return TESTSTR[0]
+
+def function16():
+    """Index of subclass of tuple is an int constant"""
+    class TupleTest(tuple):
+        """Subclass of tuple"""
+        pass
+    return TupleTest()[0] # no error
+
+def function17():
+    """Index of subclass of tuple with custom __getitem__ is None"""
+    class TupleTest(tuple):
+        """Subclass of tuple with custom __getitem__"""
+        def __getitem__(self, index):
+            """Allow non-integer indices"""
+            return 0
+    return TupleTest()[None] # no error
+
+def function18():
+    """Index of subclass of tuple with __getitem__ in superclass is None"""
+    class TupleTest(tuple):
+        """Subclass of tuple with custom __getitem__"""
+        def __getitem__(self, index):
+            """Allow non-integer indices"""
+            return 0
+
+    class SubTupleTest(TupleTest):
+        """Subclass of a subclass of tuple"""
+        pass
+
+    return SubTupleTest()[None] # no error
+
+# Test with set and delete statements
+def function19():
+    """Set with None and integer indices"""
+    TESTLIST[None] = 0 # [invalid-sequence-index]
+    TESTLIST[0] = 0 # no error
+
+def function20():
+    """Delete with None and integer indicies"""
+    del TESTLIST[None] # [invalid-sequence-index]
+    del TESTLIST[0] # no error
+
+def function21():
+    """Set and delete on a subclass of list"""
+    class ListTest(list):
+        """Inherit all list get/set/del handlers"""
+        pass
+    test = ListTest()
+
+    # Set and delete with invalid indices
+    test[None] = 0 # [invalid-sequence-index]
+    del test[None] # [invalid-sequence-index]
+
+    # Set and delete with valid indices
+    test[0] = 0 # no error
+    del test[0] # no error
+
+def function22():
+    """Get, set, and delete on a subclass of list that overrides __setitem__"""
+    class ListTest(list):
+        """Override setitem but not get or del"""
+        def __setitem__(self, key, value):
+            pass
+    test = ListTest()
+
+    # failure on the getitem with None
+    test[None][0] = 0 # [invalid-sequence-index]
+    # failure on the getitem with None
+    del test[None] # [invalid-sequence-index]
+
+    test[0][0] = 0 # getitem with int and setitem with int, no error
+    test[None] = 0 # setitem overridden, no error
+    test[0] = 0 # setitem with int, no error
+    del test[0] # delitem with int, no error
+
+def function23():
+    """Get, set, and delete on a subclass of list that overrides __delitem__"""
+    class ListTest(list):
+        """Override delitem but not get or set"""
+        def __delitem__(self, key):
+            pass
+    test = ListTest()
+
+    # failure on the getitem with None
+    test[None][0] = 0 # [invalid-sequence-index]
+    # setitem with invalid index
+    test[None] = 0  # [invalid-sequence-index]
+
+    test[0][0] = 0 # getitem with int and setitem with int, no error
+    test[0] = 0 # setitem with int, no error
+    del test[None] # delitem overridden, no error
+    del test[0] # delitem with int, no error
+
+def function24():
+    """Get, set, and delete on a subclass of list that overrides __getitem__"""
+    class ListTest(list):
+        """Override gelitem but not del or set"""
+        def __getitem__(self, key):
+            pass
+    test = ListTest()
+
+    # setitem with invalid index
+    test[None] = 0 # [invalid-sequence-index]
+    # delitem with invalid index
+    del test[None] # [invalid-sequence-index]
+
+    test[None][0] = 0 # getitem overridden, no error
+    test[0][0] = 0 # getitem with int and setitem with int, no error
+    test[0] = 0 # setitem with int, no error
+    del test[0] # delitem with int, no error
+
+# Teest ExtSlice usage
+def function25():
+    """Extended slice used with a list"""
+    return TESTLIST[..., 0] # [invalid-sequence-index]
+
+def function26():
+    """Extended slice used with an object that implements __getitem__"""
+    class ExtSliceTest(object):
+        """Permit extslice syntax by implementing __getitem__"""
+        def __getitem__(self, index):
+            return 0
+    return ExtSliceTest()[..., 0] # no error
+
+def function27():
+    """Don't warn in the case where the indexed object has unknown base classes."""
+    class UnknownBase(Unknown):
+        pass
+    slices = UnknownBase["aaaa"] + UnknownBase()[object]
+    ext_slices = UnknownBase[..., 0] + UnknownBase()[..., 0]
+    return slices, ext_slices
+
+
+def function28():
+    """Don't emit for classes with the right implementation."""
+
+    class Meta(type):
+        def __getitem__(cls, arg):
+            return 24
+
+    @six.add_metaclass(Meta)
+    class Works(object):
+        pass
+
+    @six.add_metaclass(Meta)
+    class Error(list):
+        pass
+
+    return Works['hello'] + Error['hello']
diff --git a/tests/functional/invalid_sequence_index.txt b/tests/functional/invalid_sequence_index.txt
new file mode 100644
index 000000000..204aebc9f
--- /dev/null
+++ b/tests/functional/invalid_sequence_index.txt
@@ -0,0 +1,20 @@
+invalid-sequence-index:13:function1:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:17:function2:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:21:function3:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:25:function4:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:33:function5:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:37:function6:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:41:function7:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:48:function8:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:128:function19:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:133:function20:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:144:function21:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:145:function21:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:159:function22:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:160:function22:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:162:function22:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:178:function23:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:180:function23:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:196:function24:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:198:function24:Sequence index is not an int, slice, or instance with __index__
+invalid-sequence-index:208:function25:Sequence index is not an int, slice, or instance with __index__
\ No newline at end of file
diff --git a/tests/functional/invalid_slice_index.py b/tests/functional/invalid_slice_index.py
new file mode 100644
index 000000000..1eb2fda9c
--- /dev/null
+++ b/tests/functional/invalid_slice_index.py
@@ -0,0 +1,71 @@
+"""Errors for invalid slice indices"""
+# pylint: disable=too-few-public-methods, no-self-use,missing-docstring,expression-not-assigned, useless-object-inheritance, unnecessary-pass
+
+
+TESTLIST = [1, 2, 3]
+
+# Invalid indices
+def function1():
+    """functions used as indices"""
+    return TESTLIST[id:id:]  # [invalid-slice-index,invalid-slice-index]
+
+def function2():
+    """strings used as indices"""
+    return TESTLIST['0':'1':]  # [invalid-slice-index,invalid-slice-index]
+
+def function3():
+    """class without __index__ used as index"""
+
+    class NoIndexTest(object):
+        """Class with no __index__ method"""
+        pass
+
+    return TESTLIST[NoIndexTest()::]  # [invalid-slice-index]
+
+# Valid indices
+def function4():
+    """integers used as indices"""
+    return TESTLIST[0:0:0] # no error
+
+def function5():
+    """None used as indices"""
+    return TESTLIST[None:None:None] # no error
+
+def function6():
+    """class with __index__ used as index"""
+    class IndexTest(object):
+        """Class with __index__ method"""
+        def __index__(self):
+            """Allow objects of this class to be used as slice indices"""
+            return 0
+
+    return TESTLIST[IndexTest():None:None] # no error
+
+def function7():
+    """class with __index__ in superclass used as index"""
+    class IndexType(object):
+        """Class with __index__ method"""
+        def __index__(self):
+            """Allow objects of this class to be used as slice indices"""
+            return 0
+
+    class IndexSubType(IndexType):
+        """Class with __index__ in parent"""
+        pass
+
+    return TESTLIST[IndexSubType():None:None] # no error
+
+def function8():
+    """slice object used as index"""
+    return TESTLIST[slice(1, 2, 3)] # no error
+
+
+def function9():
+    """Use a custom class that knows how to handle string slices"""
+    class StringSlice:
+        def __getitem__(self, item):
+            return item
+
+    StringSlice()["a":"b":"c"]
+    StringSlice()["a":"b":"c", "a":"b"]
+    StringSlice()[slice("a", "b", "c")]
diff --git a/tests/functional/invalid_slice_index.txt b/tests/functional/invalid_slice_index.txt
new file mode 100644
index 000000000..cd4dc6e9c
--- /dev/null
+++ b/tests/functional/invalid_slice_index.txt
@@ -0,0 +1,5 @@
+invalid-slice-index:10:function1:Slice index is not an int, None, or instance with __index__
+invalid-slice-index:10:function1:Slice index is not an int, None, or instance with __index__
+invalid-slice-index:14:function2:Slice index is not an int, None, or instance with __index__
+invalid-slice-index:14:function2:Slice index is not an int, None, or instance with __index__
+invalid-slice-index:23:function3:Slice index is not an int, None, or instance with __index__
diff --git a/tests/functional/invalid_star_assignment_target.py b/tests/functional/invalid_star_assignment_target.py
new file mode 100644
index 000000000..452f9a728
--- /dev/null
+++ b/tests/functional/invalid_star_assignment_target.py
@@ -0,0 +1,4 @@
+"""Test for *a = b """

+

+*FIRST = [1, 2, 3] # [invalid-star-assignment-target]

+(*FIRST, ) = [1, 2, 3]

diff --git a/tests/functional/invalid_star_assignment_target.rc b/tests/functional/invalid_star_assignment_target.rc
new file mode 100644
index 000000000..c093be204
--- /dev/null
+++ b/tests/functional/invalid_star_assignment_target.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/invalid_star_assignment_target.txt b/tests/functional/invalid_star_assignment_target.txt
new file mode 100644
index 000000000..7a4c232f1
--- /dev/null
+++ b/tests/functional/invalid_star_assignment_target.txt
@@ -0,0 +1 @@
+invalid-star-assignment-target:3::Starred assignment target must be in a list or tuple

diff --git a/tests/functional/invalid_unary_operand_type.py b/tests/functional/invalid_unary_operand_type.py
new file mode 100644
index 000000000..f2a0124f6
--- /dev/null
+++ b/tests/functional/invalid_unary_operand_type.py
@@ -0,0 +1,51 @@
+"""Detect problems with invalid operands used on invalid objects."""

+# pylint: disable=missing-docstring,too-few-public-methods,invalid-name

+# pylint: disable=unused-variable, useless-object-inheritance

+

+import collections

+

+

+class Implemented(object):

+    def __invert__(self):

+        return 42

+    def __pos__(self):

+        return 42

+    def __neg__(self):

+        return 42

+

+

+def these_are_good():

+    negative = -1

+    negative1 = -1.0

+    positive = +1

+    positive2 = +1.0

+    inverted = ~1

+    not_int = not 1

+    not_float = not 2.0

+    not_string = not ""

+    not_list = not []

+    not_dict = not {}

+    not_tuple = not (1, 2)

+    inverted_instance = ~Implemented()

+    positive_instance = +Implemented()

+    negative_instance = -Implemented()

+    not_instance = not Implemented()

+

+

+def these_are_bad():

+    invert_list = ~[] # [invalid-unary-operand-type]

+    invert_tuple = ~() # [invalid-unary-operand-type]

+    invert_dict = ~dict() # [invalid-unary-operand-type]

+    invert_dict_1 = ~{} # [invalid-unary-operand-type]

+    invert_set = ~set() # [invalid-unary-operand-type]

+    neg_set = -set() # [invalid-unary-operand-type]

+    neg_str = -"" # [invalid-unary-operand-type]

+    invert_str = ~"" # [invalid-unary-operand-type]

+    pos_str = +"" # [invalid-unary-operand-type]

+    class A(object):

+        pass

+    invert_func = ~(lambda: None) # [invalid-unary-operand-type]

+    invert_class = ~A # [invalid-unary-operand-type]

+    invert_instance = ~A() # [invalid-unary-operand-type]

+    invert_module = ~collections # [invalid-unary-operand-type]

+    invert_float = ~2.0 # [invalid-unary-operand-type]

diff --git a/tests/functional/invalid_unary_operand_type.txt b/tests/functional/invalid_unary_operand_type.txt
new file mode 100644
index 000000000..22fa72711
--- /dev/null
+++ b/tests/functional/invalid_unary_operand_type.txt
@@ -0,0 +1,14 @@
+invalid-unary-operand-type:36:these_are_bad:"bad operand type for unary ~: list"

+invalid-unary-operand-type:37:these_are_bad:"bad operand type for unary ~: tuple"

+invalid-unary-operand-type:38:these_are_bad:"bad operand type for unary ~: dict"

+invalid-unary-operand-type:39:these_are_bad:"bad operand type for unary ~: dict"

+invalid-unary-operand-type:40:these_are_bad:"bad operand type for unary ~: set"

+invalid-unary-operand-type:41:these_are_bad:"bad operand type for unary -: set"

+invalid-unary-operand-type:42:these_are_bad:"bad operand type for unary -: str"

+invalid-unary-operand-type:43:these_are_bad:"bad operand type for unary ~: str"

+invalid-unary-operand-type:44:these_are_bad:"bad operand type for unary +: str"

+invalid-unary-operand-type:47:these_are_bad:"bad operand type for unary ~: <lambda>"

+invalid-unary-operand-type:48:these_are_bad:"bad operand type for unary ~: A"

+invalid-unary-operand-type:49:these_are_bad:"bad operand type for unary ~: A"

+invalid-unary-operand-type:50:these_are_bad:"bad operand type for unary ~: collections"

+invalid-unary-operand-type:51:these_are_bad:"bad operand type for unary ~: float"
\ No newline at end of file
diff --git a/tests/functional/iterable_context.py b/tests/functional/iterable_context.py
new file mode 100644
index 000000000..abe5cc6f3
--- /dev/null
+++ b/tests/functional/iterable_context.py
@@ -0,0 +1,192 @@
+"""
+Checks that primitive values are not used in an
+iterating/mapping context.
+"""
+# pylint: disable=missing-docstring,invalid-name,too-few-public-methods,no-init,no-self-use,import-error,unused-argument,bad-mcs-method-argument,wrong-import-position,no-else-return, useless-object-inheritance
+from __future__ import print_function
+
+# primitives
+numbers = [1, 2, 3]
+
+for i in numbers:
+    pass
+
+for i in iter(numbers):
+    pass
+
+for i in "123":
+    pass
+
+for i in u"123":
+    pass
+
+for i in b"123":
+    pass
+
+for i in bytearray(b"123"):
+    pass
+
+for i in set(numbers):
+    pass
+
+for i in frozenset(numbers):
+    pass
+
+for i in dict(a=1, b=2):
+    pass
+
+# comprehensions
+for i in [x for x in range(10)]:
+    pass
+
+for i in {x for x in range(1, 100, 2)}:
+    pass
+
+for i in {x: 10 - x for x in range(10)}:
+    pass
+
+# generators
+def powers_of_two():
+    k = 0
+    while k < 10:
+        yield 2 ** k
+        k += 1
+
+for i in powers_of_two():
+    pass
+
+for i in powers_of_two:  # [not-an-iterable]
+    pass
+
+# check for custom iterators
+class A(object):
+    pass
+
+class B(object):
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return 1
+
+    def next(self):
+        return 1
+
+class C(object):
+    "old-style iterator"
+    def __getitem__(self, k):
+        if k > 10:
+            raise IndexError
+        return k + 1
+
+    def __len__(self):
+        return 10
+
+for i in C():
+    print(i)
+
+
+def test(*args):
+    print(args)
+
+
+test(*A())  # [not-an-iterable]
+test(*B())
+test(*B)  # [not-an-iterable]
+for i in A():  # [not-an-iterable]
+    pass
+for i in B():
+    pass
+for i in B:  # [not-an-iterable]
+    pass
+
+for i in range:  # [not-an-iterable]
+    pass
+
+# check that primitive non-iterable types are caught
+for i in True:  # [not-an-iterable]
+    pass
+
+for i in None:  # [not-an-iterable]
+    pass
+
+for i in 8.5:  # [not-an-iterable]
+    pass
+
+for i in 10:  # [not-an-iterable]
+    pass
+
+
+# skip uninferable instances
+from some_missing_module import Iterable
+
+class MyClass(Iterable):
+    pass
+
+m = MyClass()
+for i in m:
+    print(i)
+
+# skip checks if statement is inside mixin/base/abstract class
+class ManagedAccessViewMixin(object):
+    access_requirements = None
+
+    def get_access_requirements(self):
+        return self.access_requirements
+
+    def dispatch(self, *_args, **_kwargs):
+        klasses = self.get_access_requirements()
+
+        # no error should be emitted here
+        for requirement in klasses:
+            print(requirement)
+
+class BaseType(object):
+    valid_values = None
+
+    def validate(self, value):
+        if self.valid_values is None:
+            return True
+        else:
+            # error should not be emitted here
+            for v in self.valid_values:
+                if value == v:
+                    return True
+            return False
+
+class AbstractUrlMarkManager(object):
+    def __init__(self):
+        self._lineparser = None
+        self._init_lineparser()
+        # error should not be emitted here
+        for line in self._lineparser:
+            print(line)
+
+    def _init_lineparser(self):
+        raise NotImplementedError
+
+# class is not named as abstract
+# but still is deduceably abstract
+class UrlMarkManager(object):
+    def __init__(self):
+        self._lineparser = None
+        self._init_lineparser()
+        # error should not be emitted here
+        for line in self._lineparser:
+            print(line)
+
+    def _init_lineparser(self):
+        raise NotImplementedError
+
+
+class HasDynamicGetattr(object):
+
+    def __init__(self):
+        self._obj = []
+
+    def __getattr__(self, attr):
+        return getattr(self._obj, attr)
+
+
+for elem in HasDynamicGetattr():
+    pass
diff --git a/tests/functional/iterable_context.txt b/tests/functional/iterable_context.txt
new file mode 100644
index 000000000..fbe143327
--- /dev/null
+++ b/tests/functional/iterable_context.txt
@@ -0,0 +1,10 @@
+not-an-iterable:58::Non-iterable value powers_of_two is used in an iterating context
+not-an-iterable:93::Non-iterable value A() is used in an iterating context
+not-an-iterable:95::Non-iterable value B is used in an iterating context
+not-an-iterable:96::Non-iterable value A() is used in an iterating context
+not-an-iterable:100::Non-iterable value B is used in an iterating context
+not-an-iterable:103::Non-iterable value range is used in an iterating context
+not-an-iterable:107::Non-iterable value True is used in an iterating context
+not-an-iterable:110::Non-iterable value None is used in an iterating context
+not-an-iterable:113::Non-iterable value 8.5 is used in an iterating context
+not-an-iterable:116::Non-iterable value 10 is used in an iterating context
diff --git a/tests/functional/iterable_context_py2.py b/tests/functional/iterable_context_py2.py
new file mode 100644
index 000000000..22c60c174
--- /dev/null
+++ b/tests/functional/iterable_context_py2.py
@@ -0,0 +1,18 @@
+"""
+Checks that iterable metaclasses are recognized by pylint.
+"""
+# pylint: disable=missing-docstring,too-few-public-methods,no-init,no-self-use,unused-argument,bad-mcs-method-argument, useless-object-inheritance
+
+# metaclasses as iterables
+class Meta(type):
+    def __iter__(self):
+        return iter((1, 2, 3))
+
+class SomeClass(object):
+    __metaclass__ = Meta
+
+
+for i in SomeClass:
+    print i
+for i in SomeClass():  # [not-an-iterable]
+    print i
diff --git a/tests/functional/iterable_context_py2.rc b/tests/functional/iterable_context_py2.rc
new file mode 100644
index 000000000..a65023393
--- /dev/null
+++ b/tests/functional/iterable_context_py2.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max_pyver=3.0
diff --git a/tests/functional/iterable_context_py2.txt b/tests/functional/iterable_context_py2.txt
new file mode 100644
index 000000000..8de579a3f
--- /dev/null
+++ b/tests/functional/iterable_context_py2.txt
@@ -0,0 +1 @@
+not-an-iterable:17::Non-iterable value SomeClass() is used in an iterating context
diff --git a/tests/functional/iterable_context_py3.py b/tests/functional/iterable_context_py3.py
new file mode 100644
index 000000000..34047eda0
--- /dev/null
+++ b/tests/functional/iterable_context_py3.py
@@ -0,0 +1,55 @@
+"""
+Checks that iterable metaclasses are recognized by pylint.
+"""
+# pylint: disable=missing-docstring,too-few-public-methods,no-init,no-self-use,unused-argument,bad-mcs-method-argument
+# pylint: disable=wrong-import-position
+# metaclasses as iterables
+class Meta(type):
+    def __iter__(self):
+        return iter((1, 2, 3))
+
+class SomeClass(metaclass=Meta):
+    pass
+
+
+for i in SomeClass:
+    print(i)
+for i in SomeClass():  # [not-an-iterable]
+    print(i)
+
+
+import asyncio
+
+
+@asyncio.coroutine
+def coroutine_function_return_none():
+    return
+
+
+@asyncio.coroutine
+def coroutine_function_return_object():
+    return 12
+
+
+@asyncio.coroutine
+def coroutine_function_return_future():
+    return asyncio.Future()
+
+
+@asyncio.coroutine
+def coroutine_function_pass():
+    pass
+
+
+@asyncio.coroutine
+def coroutine_generator():
+    yield
+
+
+@asyncio.coroutine
+def main():
+    yield from coroutine_function_return_none()
+    yield from coroutine_function_return_object()
+    yield from coroutine_function_return_future()
+    yield from coroutine_function_pass()
+    yield from coroutine_generator()
diff --git a/tests/functional/iterable_context_py3.rc b/tests/functional/iterable_context_py3.rc
new file mode 100644
index 000000000..9bf6df0ed
--- /dev/null
+++ b/tests/functional/iterable_context_py3.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.0
+
diff --git a/tests/functional/iterable_context_py3.txt b/tests/functional/iterable_context_py3.txt
new file mode 100644
index 000000000..8de579a3f
--- /dev/null
+++ b/tests/functional/iterable_context_py3.txt
@@ -0,0 +1 @@
+not-an-iterable:17::Non-iterable value SomeClass() is used in an iterating context
diff --git a/tests/functional/iterable_context_py36.py b/tests/functional/iterable_context_py36.py
new file mode 100644
index 000000000..cc2e8e7df
--- /dev/null
+++ b/tests/functional/iterable_context_py36.py
@@ -0,0 +1,41 @@
+# pylint: disable=missing-docstring,too-few-public-methods,unused-variable
+import asyncio
+
+class AIter:
+    async def __aiter__(self):
+        for value in range(20):
+            yield value
+
+    async def to_list(self):
+        values = [m async for m in self]
+        other_values = [m for m in self] # [not-an-iterable]
+        for value in self: # [not-an-iterable]
+            yield value
+        async for value in self:
+            yield value
+
+
+async def some_iter_func(number):
+    """ emits 1 number per second  """
+    for i in range(1, number):
+        yield i
+        await asyncio.sleep(1)
+
+
+async def count_to(number):
+    """ counts to n in async manner"""
+    async for i in some_iter_func(number):
+        print(i)
+
+
+async def gen_values(num_values):
+    for value in range(num_values):
+        yield value
+
+
+async def do_some_comprehensions():
+    sets = {elem async for elem in gen_values(10)}
+    lists = [elem async for elem in gen_values(10)]
+    dicts = {elem: elem async for elem in gen_values(10)}
+    gen = (elem async for elem in gen_values(10))
+    return sets, lists, dicts, gen
diff --git a/tests/functional/iterable_context_py36.rc b/tests/functional/iterable_context_py36.rc
new file mode 100644
index 000000000..1450ccc64
--- /dev/null
+++ b/tests/functional/iterable_context_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
\ No newline at end of file
diff --git a/tests/functional/iterable_context_py36.txt b/tests/functional/iterable_context_py36.txt
new file mode 100644
index 000000000..877323cb2
--- /dev/null
+++ b/tests/functional/iterable_context_py36.txt
@@ -0,0 +1,2 @@
+not-an-iterable:11:AIter.to_list:Non-iterable value self is used in an iterating context
+not-an-iterable:12:AIter.to_list:Non-iterable value self is used in an iterating context
diff --git a/tests/functional/keyword_arg_before_vararg.py b/tests/functional/keyword_arg_before_vararg.py
new file mode 100644
index 000000000..119287410
--- /dev/null
+++ b/tests/functional/keyword_arg_before_vararg.py
@@ -0,0 +1,35 @@
+"""Unittests for W1125 (kw args before *args)"""
+from __future__ import absolute_import, print_function
+
+# pylint: disable=unused-argument, useless-object-inheritance, unnecessary-pass
+def check_kwargs_before_args(param1, param2=2, *args): # [keyword-arg-before-vararg]
+    """docstring"""
+    pass
+
+check_kwargs_before_args(5)
+
+# pylint: disable=too-few-public-methods, invalid-name
+class AAAA(object):
+    """class AAAA"""
+    def func_in_class(self, param1, param2=2, *args): # [keyword-arg-before-vararg]
+        "method in class AAAA"
+        pass
+
+    @staticmethod
+    def static_method_in_class(param1, param2=3, *args): # [keyword-arg-before-vararg]
+        "static method in class AAAA"
+        pass
+
+    @classmethod
+    def class_method_in_class(cls, param1, param2=4, *args): # [keyword-arg-before-vararg]
+        "class method in class AAAA"
+        pass
+
+some_var = AAAA()
+some_var.func_in_class(3)
+
+some_var.static_method_in_class(4)
+AAAA.static_method_in_class(4)
+
+some_var.class_method_in_class(5)
+AAAA.class_method_in_class(5)
diff --git a/tests/functional/keyword_arg_before_vararg.txt b/tests/functional/keyword_arg_before_vararg.txt
new file mode 100644
index 000000000..c83ff733d
--- /dev/null
+++ b/tests/functional/keyword_arg_before_vararg.txt
@@ -0,0 +1,4 @@
+keyword-arg-before-vararg:5:check_kwargs_before_args:Keyword argument before variable positional arguments list in the definition of check_kwargs_before_args function
+keyword-arg-before-vararg:14:AAAA.func_in_class:Keyword argument before variable positional arguments list in the definition of func_in_class function
+keyword-arg-before-vararg:19:AAAA.static_method_in_class:Keyword argument before variable positional arguments list in the definition of static_method_in_class function
+keyword-arg-before-vararg:24:AAAA.class_method_in_class:Keyword argument before variable positional arguments list in the definition of class_method_in_class function
diff --git a/tests/functional/len_checks.py b/tests/functional/len_checks.py
new file mode 100644
index 000000000..e8e61afad
--- /dev/null
+++ b/tests/functional/len_checks.py
@@ -0,0 +1,101 @@
+# pylint: disable=too-few-public-methods,import-error, no-absolute-import,missing-docstring, misplaced-comparison-constant
+# pylint: disable=useless-super-delegation,wrong-import-position,invalid-name, wrong-import-order
+
+if len('TEST'):  # [len-as-condition]
+    pass
+
+if not len('TEST'):  # [len-as-condition]
+    pass
+
+z = False
+if z and len(['T', 'E', 'S', 'T']):  # [len-as-condition]
+    pass
+
+if True or len('TEST'):  # [len-as-condition]
+    pass
+
+if len('TEST') == 0:  # Should be fine
+    pass
+
+if len('TEST') < 1:  # Should be fine
+    pass
+
+if len('TEST') <= 0:  # Should be fine
+    pass
+
+if 1 > len('TEST'):  # Should be fine
+    pass
+
+if 0 >= len('TEST'):  # Should be fine
+    pass
+
+if z and len('TEST') == 0:  # Should be fine
+    pass
+
+if 0 == len('TEST') < 10:  # Should be fine
+    pass
+
+if 0 < 1 <= len('TEST') < 10:  # Should be fine
+    pass
+
+if 10 > len('TEST') != 0:  # Should be fine
+    pass
+
+if 10 > len('TEST') > 1 > 0:  # Should be fine
+    pass
+
+if 0 <= len('TEST') < 100:  # Should be fine
+    pass
+
+if z or 10 > len('TEST') != 0:  # Should be fine
+    pass
+
+if z:
+    pass
+elif len('TEST'):  # [len-as-condition]
+    pass
+
+if z:
+    pass
+elif not len('TEST'):  # [len-as-condition]
+    pass
+
+while len('TEST'):  # [len-as-condition]
+    pass
+
+while not len('TEST'):  # [len-as-condition]
+    pass
+
+while z and len('TEST'):  # [len-as-condition]
+    pass
+
+while not len('TEST') and z:  # [len-as-condition]
+    pass
+
+assert len('TEST') > 0  # Should be fine
+
+x = 1 if len('TEST') != 0 else 2  # Should be fine
+
+f_o_o = len('TEST') or 42  # Should be fine
+
+a = x and len(x)  # Should be fine
+
+def some_func():
+    return len('TEST') > 0  # Should be fine
+
+def github_issue_1325():
+    l = [1, 2, 3]
+    length = len(l) if l else 0  # Should be fine
+    return length
+
+def github_issue_1331(*args):
+    assert False, len(args)  # Should be fine
+
+def github_issue_1331_v2(*args):
+    assert len(args), args  # [len-as-condition]
+
+def github_issue_1331_v3(*args):
+    assert len(args) or z, args  # [len-as-condition]
+
+def github_issue_1331_v4(*args):
+    assert z and len(args), args  # [len-as-condition]
diff --git a/tests/functional/len_checks.txt b/tests/functional/len_checks.txt
new file mode 100644
index 000000000..9dc2969f6
--- /dev/null
+++ b/tests/functional/len_checks.txt
@@ -0,0 +1,13 @@
+len-as-condition:4::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:7::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:11::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:14::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:55::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:60::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:63::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:66::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:69::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:72::Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:95:github_issue_1331_v2:Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:98:github_issue_1331_v3:Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
+len-as-condition:101:github_issue_1331_v4:Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty
diff --git a/tests/functional/line_endings.py b/tests/functional/line_endings.py
new file mode 100644
index 000000000..0b6e795e3
--- /dev/null
+++ b/tests/functional/line_endings.py
@@ -0,0 +1,3 @@
+"mixing line endings are not welcome"
+# +1: [unexpected-line-ending-format, mixed-line-endings]
+CONST = 1

diff --git a/tests/functional/line_endings.rc b/tests/functional/line_endings.rc
new file mode 100644
index 000000000..95532ea80
--- /dev/null
+++ b/tests/functional/line_endings.rc
@@ -0,0 +1,2 @@
+[Format]
+expected-line-ending-format=LF
diff --git a/tests/functional/line_endings.txt b/tests/functional/line_endings.txt
new file mode 100644
index 000000000..a18a87237
--- /dev/null
+++ b/tests/functional/line_endings.txt
@@ -0,0 +1,2 @@
+mixed-line-endings:3::Mixed line endings LF and CRLF
+unexpected-line-ending-format:3::Unexpected line ending format. There is 'CRLF' while it should be 'LF'.
diff --git a/tests/functional/line_too_long.py b/tests/functional/line_too_long.py
new file mode 100644
index 000000000..e2affd609
--- /dev/null
+++ b/tests/functional/line_too_long.py
@@ -0,0 +1,45 @@
+# pylint: disable=invalid-encoded-data, fixme, unnecessary-pass

+# +1: [line-too-long]

+#####################################################################################################

+# +1: [line-too-long]

+""" that one is too long tooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo loooooong"""

+

+# The next line is exactly 80 characters long.

+A = "--------------------------------------------------------------------------"

+

+# Do not trigger the line-too-long warning if the only token that makes the

+# line longer than 80 characters is a trailing pylint disable.

+# pylint:disable=invalid-name

+var = (

+    "This line has a disable pragma and whitespace trailing beyond 80 chars. "

+)

+

+# +1: [line-too-long]

+badname = "This line is already longer than 100 characters even without the pragma. Trust me. Please."  # pylint:disable=invalid-name

+

+# http://example.com/this/is/a/very/long/url?but=splitting&urls=is&a=pain&so=they&can=be&long

+

+

+# +1: [line-too-long]

+# This line is toooooooooooooooooooooooooooooooooooooooooooooooo looooooooooooooooooooooooooooooooooooooooong #pylint: disable=fixme

+

+# +1: [line-too-long]

+# TODO: This line is toooooooooooooooooooooooooooooooooooooooooooooooo looooooooooooooooooooooooooooooooooooooooong #pylint: disable=fixme

+

+

+def function():

+    # +3: [line-too-long]

+    """This is a docstring.

+

+    That contains a very, very long line that exceeds the 100 characters limit by a good margin. So good?

+    """

+    pass

+

+

+# Don't crash when the line is in a docstring

+def func_with_long(parameter):

+    """

+    # pylint: disable=line-too-long

+    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccc

+    """

+    return parameter

diff --git a/tests/functional/line_too_long.txt b/tests/functional/line_too_long.txt
new file mode 100644
index 000000000..22c218117
--- /dev/null
+++ b/tests/functional/line_too_long.txt
@@ -0,0 +1,6 @@
+line-too-long:3::Line too long (101/100)
+line-too-long:5::Line too long (104/100)
+line-too-long:18::Line too long (102/100)
+line-too-long:24::Line too long (109/100)
+line-too-long:27::Line too long (115/100)
+line-too-long:34::Line too long (105/100)
diff --git a/tests/functional/line_too_long_end_of_module.py b/tests/functional/line_too_long_end_of_module.py
new file mode 100644
index 000000000..21cb75655
--- /dev/null
+++ b/tests/functional/line_too_long_end_of_module.py
@@ -0,0 +1,7 @@
+#pylint: disable=missing-docstring, line-too-long

+

+# Hey this is a very long commented line just to trigger pylint's line-too-long message. It is just above a dummy function with a very long code line.

+def dummy_function():

+    print("What a beautiful dummy function with such a very long line inside that it should trigger pylint's line-too-long message ")

+

+# Hey this is a very long commented line at the end of the module. It is just here to trigger pylint's line-too-long message.

diff --git a/tests/functional/literal_comparison.py b/tests/functional/literal_comparison.py
new file mode 100644
index 000000000..646e57eec
--- /dev/null
+++ b/tests/functional/literal_comparison.py
@@ -0,0 +1,50 @@
+# pylint: disable=missing-docstring, comparison-with-itself
+
+
+if 2 is 2: # [literal-comparison]
+    pass
+
+if "a" is b"a": # [literal-comparison]
+    pass
+
+if 2.0 is 3.0: # [literal-comparison]
+    pass
+
+if () is (1, 2, 3): # [literal-comparison]
+    pass
+
+if () is {1:2, 2:3}: # [literal-comparison]
+    pass
+
+if [] is [4, 5, 6]: # [literal-comparison]
+    pass
+
+if () is {1, 2, 3}: # [literal-comparison]
+    pass
+
+if () is not {1:2, 2:3}: # [literal-comparison]
+    pass
+
+if [] is not [4, 5, 6]: # [literal-comparison]
+    pass
+
+if () is not {1, 2, 3}: # [literal-comparison]
+    pass
+
+
+CONST = 24
+
+
+if CONST is 0: # [literal-comparison]
+    pass
+
+if CONST is 1: # [literal-comparison]
+    pass
+
+if CONST is 42: # [literal-comparison]
+    pass
+
+# We do not do inference for this check, since the comparing
+# object might be used as a sentinel.
+if () is CONST:
+    pass
diff --git a/tests/functional/literal_comparison.txt b/tests/functional/literal_comparison.txt
new file mode 100644
index 000000000..5026deceb
--- /dev/null
+++ b/tests/functional/literal_comparison.txt
@@ -0,0 +1,13 @@
+literal-comparison:4::Comparison to literal
+literal-comparison:7::Comparison to literal
+literal-comparison:10::Comparison to literal
+literal-comparison:13::Comparison to literal
+literal-comparison:16::Comparison to literal
+literal-comparison:19::Comparison to literal
+literal-comparison:22::Comparison to literal
+literal-comparison:25::Comparison to literal
+literal-comparison:28::Comparison to literal
+literal-comparison:31::Comparison to literal
+literal-comparison:38::Comparison to literal
+literal-comparison:41::Comparison to literal
+literal-comparison:44::Comparison to literal
diff --git a/tests/functional/logging_format_interpolation.py b/tests/functional/logging_format_interpolation.py
new file mode 100644
index 000000000..5f61d6baf
--- /dev/null
+++ b/tests/functional/logging_format_interpolation.py
@@ -0,0 +1,39 @@
+# pylint: disable=E1101, no-absolute-import, import-error,line-too-long, missing-docstring,wrong-import-order,wrong-import-position
+# pylint: disable=invalid-name
+try:
+    import __builtin__ as builtins
+except ImportError:
+    import builtins
+
+# Muck up the names in an effort to confuse...
+import logging as renamed_logging
+import os as logging
+from uninferable import UNINFERABLE
+
+FORMAT_STR = '{0}, {1}'
+
+# Statements that should be flagged:
+renamed_logging.debug('{0}, {1}'.format(4, 5)) # [logging-format-interpolation]
+renamed_logging.log(renamed_logging.DEBUG, 'msg: {}'.format('Run!')) # [logging-format-interpolation]
+renamed_logging.debug(FORMAT_STR.format(4, 5)) # [logging-format-interpolation]
+renamed_logging.log(renamed_logging.DEBUG, FORMAT_STR.format(4, 5)) # [logging-format-interpolation]
+renamed_logging.info("Read {l} rows".format(l=123456789)) # [logging-format-interpolation]
+
+# Statements that should not be flagged:
+renamed_logging.debug(format(66, 'x'))
+renamed_logging.debug(builtins.format(66, 'x'))
+renamed_logging.log(renamed_logging.DEBUG, 'msg: Run!'.upper())
+logging.debug('{0}, {1}'.format(4, 5))
+logging.log(logging.DEBUG, 'msg: {}'.format('Run!'))
+renamed_logging.info("Read {l:,d} rows".format(l=123456789))
+renamed_logging.info(UNINFERABLE.format(l=123456789))
+
+
+class Logger(renamed_logging.Logger):
+    pass
+
+custom_logger = Logger('three')
+
+# Currently disabled until we get this in https://github.com/PyCQA/astroid/pull/637
+# custom_logger.info('testing {0}'.format('info'))
+# custom_logger.info('testing %s' % 'info')
diff --git a/tests/functional/logging_format_interpolation.txt b/tests/functional/logging_format_interpolation.txt
new file mode 100644
index 000000000..36051253c
--- /dev/null
+++ b/tests/functional/logging_format_interpolation.txt
@@ -0,0 +1,5 @@
+logging-format-interpolation:16::Use % formatting in logging functions and pass the % parameters as arguments
+logging-format-interpolation:17::Use % formatting in logging functions and pass the % parameters as arguments
+logging-format-interpolation:18::Use % formatting in logging functions and pass the % parameters as arguments
+logging-format-interpolation:19::Use % formatting in logging functions and pass the % parameters as arguments
+logging-format-interpolation:20::Use % formatting in logging functions and pass the % parameters as arguments
diff --git a/tests/functional/logging_format_interpolation_py36.py b/tests/functional/logging_format_interpolation_py36.py
new file mode 100644
index 000000000..f6af9f563
--- /dev/null
+++ b/tests/functional/logging_format_interpolation_py36.py
@@ -0,0 +1,5 @@
+"""Test logging-format-interpolation for Python 3.6"""
+import logging as renamed_logging
+
+
+renamed_logging.info(f'Read {renamed_logging} from globals')  # [logging-fstring-interpolation]
diff --git a/tests/functional/logging_format_interpolation_py36.rc b/tests/functional/logging_format_interpolation_py36.rc
new file mode 100644
index 000000000..0ba2b6333
--- /dev/null
+++ b/tests/functional/logging_format_interpolation_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/logging_format_interpolation_py36.txt b/tests/functional/logging_format_interpolation_py36.txt
new file mode 100644
index 000000000..ec7e5b90f
--- /dev/null
+++ b/tests/functional/logging_format_interpolation_py36.txt
@@ -0,0 +1 @@
+logging-fstring-interpolation:5::Use % formatting in logging functions and pass the % parameters as arguments
\ No newline at end of file
diff --git a/tests/functional/logging_fstring_interpolation_py36.py b/tests/functional/logging_fstring_interpolation_py36.py
new file mode 100644
index 000000000..5aebb7dd2
--- /dev/null
+++ b/tests/functional/logging_fstring_interpolation_py36.py
@@ -0,0 +1,21 @@
+"""Test logging-fstring-interpolation for Python 3.6"""
+# pylint: disable=invalid-name
+
+from datetime import datetime
+
+import logging as renamed_logging
+
+
+local_var_1 = 4
+local_var_2 = "run!"
+
+pi = 3.14159265
+
+may_14 = datetime(year=2018, month=5, day=14)
+
+# Statements that should be flagged:
+renamed_logging.debug(f'{local_var_1} {local_var_2}') # [logging-fstring-interpolation]
+renamed_logging.log(renamed_logging.DEBUG, f'msg: {local_var_2}') # [logging-fstring-interpolation]
+renamed_logging.log(renamed_logging.DEBUG, f'pi: {pi:.3f}') # [logging-fstring-interpolation]
+renamed_logging.info(f"{local_var_2.upper()}") # [logging-fstring-interpolation]
+renamed_logging.info(f"{may_14:'%b %d: %Y'}") # [logging-fstring-interpolation]
diff --git a/tests/functional/logging_fstring_interpolation_py36.rc b/tests/functional/logging_fstring_interpolation_py36.rc
new file mode 100644
index 000000000..0ba2b6333
--- /dev/null
+++ b/tests/functional/logging_fstring_interpolation_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/logging_fstring_interpolation_py36.txt b/tests/functional/logging_fstring_interpolation_py36.txt
new file mode 100644
index 000000000..e2469d665
--- /dev/null
+++ b/tests/functional/logging_fstring_interpolation_py36.txt
@@ -0,0 +1,5 @@
+logging-fstring-interpolation:17::Use % formatting in logging functions and pass the % parameters as arguments
+logging-fstring-interpolation:18::Use % formatting in logging functions and pass the % parameters as arguments
+logging-fstring-interpolation:19::Use % formatting in logging functions and pass the % parameters as arguments
+logging-fstring-interpolation:20::Use % formatting in logging functions and pass the % parameters as arguments
+logging-fstring-interpolation:21::Use % formatting in logging functions and pass the % parameters as arguments
\ No newline at end of file
diff --git a/tests/functional/logging_not_lazy.py b/tests/functional/logging_not_lazy.py
new file mode 100644
index 000000000..c0634327f
--- /dev/null
+++ b/tests/functional/logging_not_lazy.py
@@ -0,0 +1,23 @@
+# pylint: disable=missing-docstring,no-member,deprecated-method,invalid-name
+
+# Muck up the names in an effort to confuse...
+import logging as renamed_logging
+import os as logging
+
+var = "123"
+var_name = 'Var:'
+# Statements that should be flagged:
+renamed_logging.warn('%s, %s' % (4, 5))             # [logging-not-lazy]
+renamed_logging.exception('%s' % 'Exceptional!')    # [logging-not-lazy]
+renamed_logging.log(renamed_logging.INFO, 'msg: %s' % 'Run!')  # [logging-not-lazy]
+renamed_logging.log(renamed_logging.INFO, "Var: " + var)  # [logging-not-lazy]
+renamed_logging.warn('%s' + ' the rest of a single string') # [logging-not-lazy]
+renamed_logging.log(renamed_logging.INFO, var_name + var) # [logging-not-lazy]
+
+var_name = 'Var:'
+# Statements that should not be flagged:
+renamed_logging.warn('%s, %s', 4, 5)
+renamed_logging.log(renamed_logging.INFO, 'msg: %s', 'Run!')
+logging.warn('%s, %s' % (4, 5))
+logging.log(logging.INFO, 'msg: %s' % 'Run!')
+logging.log("Var: " + var)
diff --git a/tests/functional/logging_not_lazy.txt b/tests/functional/logging_not_lazy.txt
new file mode 100644
index 000000000..31e7cc448
--- /dev/null
+++ b/tests/functional/logging_not_lazy.txt
@@ -0,0 +1,6 @@
+logging-not-lazy:10::Specify string format arguments as logging function parameters
+logging-not-lazy:11::Specify string format arguments as logging function parameters
+logging-not-lazy:12::Specify string format arguments as logging function parameters
+logging-not-lazy:13::Specify string format arguments as logging function parameters
+logging-not-lazy:14::Specify string format arguments as logging function parameters
+logging-not-lazy:15::Specify string format arguments as logging function parameters
diff --git a/tests/functional/logical_tautology.py b/tests/functional/logical_tautology.py
new file mode 100644
index 000000000..ca7ebb0cc
--- /dev/null
+++ b/tests/functional/logical_tautology.py
@@ -0,0 +1,40 @@
+"""Check for logical tautology, when a value is compared against itself."""
+# pylint: disable=missing-docstring, blacklisted-name, singleton-comparison, too-many-return-statements, inconsistent-return-statements, no-else-return, too-many-branches, bad-whitespace, literal-comparison
+
+def foo():
+    arg = 786
+    if arg == arg: # [comparison-with-itself]
+        return True
+    elif arg != arg: # [comparison-with-itself]
+        return True
+    elif arg > arg: # [comparison-with-itself]
+        return True
+    elif arg <= arg: # [comparison-with-itself]
+        return True
+    elif None == None: # [comparison-with-itself]
+        return None
+    elif 786 == 786: # [comparison-with-itself]
+        return True
+    elif 786 is 786: # [comparison-with-itself]
+        return True
+    elif 786 is not 786: # [comparison-with-itself]
+        return True
+    elif arg is arg: # [comparison-with-itself]
+        return True
+    elif arg is not arg: # [comparison-with-itself]
+        return True
+    elif True is True: # [comparison-with-itself]
+        return True
+    elif 666 == 786:
+        return False
+    else:
+        return None
+
+
+def bar():
+    arg = 666
+    return 666 if arg != arg else 786 # [comparison-with-itself]
+
+def foobar():
+    arg = 786
+    return arg > 786
diff --git a/tests/functional/logical_tautology.txt b/tests/functional/logical_tautology.txt
new file mode 100644
index 000000000..4422c8559
--- /dev/null
+++ b/tests/functional/logical_tautology.txt
@@ -0,0 +1,12 @@
+comparison-with-itself:6:foo:Redundant comparison - arg == arg
+comparison-with-itself:8:foo:Redundant comparison - arg != arg
+comparison-with-itself:10:foo:Redundant comparison - arg > arg
+comparison-with-itself:12:foo:Redundant comparison - arg <= arg
+comparison-with-itself:14:foo:Redundant comparison - None == None
+comparison-with-itself:16:foo:Redundant comparison - 786 == 786
+comparison-with-itself:18:foo:Redundant comparison - 786 is 786
+comparison-with-itself:20:foo:Redundant comparison - 786 is not 786
+comparison-with-itself:22:foo:Redundant comparison - arg is arg
+comparison-with-itself:24:foo:Redundant comparison - arg is not arg
+comparison-with-itself:26:foo:Redundant comparison - True is True
+comparison-with-itself:36:bar:Redundant comparison - arg != arg
diff --git a/tests/functional/long_lines_with_utf8.py b/tests/functional/long_lines_with_utf8.py
new file mode 100644
index 000000000..a1d90edcc
--- /dev/null
+++ b/tests/functional/long_lines_with_utf8.py
@@ -0,0 +1,7 @@
+# coding: utf-8
+"""Test data file files with non-ASCII content."""
+
+
+THIS_IS_A_LONG_VARIABLE_NAME = 'Существительное Частица'  # but the line is okay
+
+THIS_IS_A_VERY_LONG_VARIABLE_NAME = 'Существительное Частица'  # and the line is not okay  # [line-too-long]
diff --git a/tests/functional/long_lines_with_utf8.txt b/tests/functional/long_lines_with_utf8.txt
new file mode 100644
index 000000000..42a7976a7
--- /dev/null
+++ b/tests/functional/long_lines_with_utf8.txt
@@ -0,0 +1 @@
+line-too-long:7::Line too long (108/100)
diff --git a/tests/functional/long_utf8_lines.py b/tests/functional/long_utf8_lines.py
new file mode 100644
index 000000000..815759fe5
--- /dev/null
+++ b/tests/functional/long_utf8_lines.py
@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+"""this utf-8 doc string have some     non ASCII caracters like 'é', or '¢»ß'"""
+### check also comments with some     more non ASCII caracters like 'é' or '¢»ß'
+
+__revision__ = 1100
+
+ASCII = "----------------------------------------------------------------------"
+UTF_8 = "--------------------------------------------------------------------éé"
diff --git a/tests/functional/long_utf8_lines.txt b/tests/functional/long_utf8_lines.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/long_utf8_lines.txt
diff --git a/tests/functional/lost_exception.py b/tests/functional/lost_exception.py
new file mode 100644
index 000000000..fe7deddb7
--- /dev/null
+++ b/tests/functional/lost_exception.py
@@ -0,0 +1,41 @@
+# pylint: disable=missing-docstring, using-constant-test,cell-var-from-loop
+
+def insidious_break_and_return():
+    for i in range(0, -5, -1):
+        my_var = 0
+
+        try:
+            my_var += 1.0/i
+            if i < -3:
+                break
+            else:
+                return my_var
+        finally:
+            if i > -2:
+                break # [lost-exception]
+            else:
+                return my_var # [lost-exception]
+    return None
+
+
+def break_and_return():
+    for i in range(0, -5, -1):
+        my_var = 0
+        if i:
+            break
+        try:
+            my_var += 1.0/i
+        finally:
+            for _ in range(2):
+                if True:
+                    break
+            else:
+                def strange():
+                    if True:
+                        return my_var
+                    return None
+                strange()
+        if i:
+            break
+        else:
+            return
diff --git a/tests/functional/lost_exception.txt b/tests/functional/lost_exception.txt
new file mode 100644
index 000000000..4fb37ec84
--- /dev/null
+++ b/tests/functional/lost_exception.txt
@@ -0,0 +1,2 @@
+lost-exception:15:insidious_break_and_return:break statement in finally block may swallow exception
+lost-exception:17:insidious_break_and_return:return statement in finally block may swallow exception
\ No newline at end of file
diff --git a/tests/functional/mapping_context.py b/tests/functional/mapping_context.py
new file mode 100644
index 000000000..6b3a13573
--- /dev/null
+++ b/tests/functional/mapping_context.py
@@ -0,0 +1,109 @@
+"""
+Checks that only valid values are used in a mapping context.
+"""
+# pylint: disable=missing-docstring,invalid-name,too-few-public-methods,no-self-use,import-error,wrong-import-position, useless-object-inheritance
+from __future__ import print_function
+
+
+def test(**kwargs):
+    print(kwargs)
+
+
+# dictionary value/comprehension
+dict_value = dict(a=1, b=2, c=3)
+dict_comp = {chr(x): x for x in range(256)}
+test(**dict_value)
+test(**dict_comp)
+
+
+# in order to be used in kwargs custom mapping class should define
+# __iter__(), __getitem__(key) and keys().
+class CustomMapping(object):
+    def __init__(self):
+        self.data = dict(a=1, b=2, c=3, d=4, e=5)
+
+    def __getitem__(self, key):
+        return self.data[key]
+
+    def keys(self):
+        return self.data.keys()
+
+test(**CustomMapping())
+test(**CustomMapping)  # [not-a-mapping]
+
+class NotMapping(object):
+    pass
+
+test(**NotMapping())  # [not-a-mapping]
+
+# skip checks if statement is inside mixin/base/abstract class
+class SomeMixin(object):
+    kwargs = None
+
+    def get_kwargs(self):
+        return self.kwargs
+
+    def run(self, **kwargs):
+        print(kwargs)
+
+    def dispatch(self):
+        kws = self.get_kwargs()
+        self.run(**kws)
+
+class AbstractThing(object):
+    kwargs = None
+
+    def get_kwargs(self):
+        return self.kwargs
+
+    def run(self, **kwargs):
+        print(kwargs)
+
+    def dispatch(self):
+        kws = self.get_kwargs()
+        self.run(**kws)
+
+class BaseThing(object):
+    kwargs = None
+
+    def get_kwargs(self):
+        return self.kwargs
+
+    def run(self, **kwargs):
+        print(kwargs)
+
+    def dispatch(self):
+        kws = self.get_kwargs()
+        self.run(**kws)
+
+# abstract class
+class Thing(object):
+    def get_kwargs(self):
+        raise NotImplementedError
+
+    def run(self, **kwargs):
+        print(kwargs)
+
+    def dispatch(self):
+        kwargs = self.get_kwargs()
+        self.run(**kwargs)
+
+# skip uninferable instances
+from some_missing_module import Mapping
+
+class MyClass(Mapping):
+    pass
+
+test(**MyClass())
+
+
+class HasDynamicGetattr(object):
+
+    def __init__(self):
+        self._obj = {}
+
+    def __getattr__(self, attr):
+        return getattr(self._obj, attr)
+
+
+test(**HasDynamicGetattr())
diff --git a/tests/functional/mapping_context.txt b/tests/functional/mapping_context.txt
new file mode 100644
index 000000000..201da1a6e
--- /dev/null
+++ b/tests/functional/mapping_context.txt
@@ -0,0 +1,2 @@
+not-a-mapping:32::Non-mapping value CustomMapping is used in a mapping context
+not-a-mapping:37::Non-mapping value NotMapping() is used in a mapping context
diff --git a/tests/functional/mapping_context_py2.py b/tests/functional/mapping_context_py2.py
new file mode 100644
index 000000000..f5cdc753d
--- /dev/null
+++ b/tests/functional/mapping_context_py2.py
@@ -0,0 +1,19 @@
+# pylint: disable=missing-docstring,invalid-name,too-few-public-methods,no-self-use,bad-mcs-method-argument, useless-object-inheritance
+from __future__ import print_function
+
+
+def test(**kwargs):
+    print(kwargs)
+
+# metaclasses as mappings
+class Meta(type):
+    def __getitem__(self, key):
+        return ord(key)
+    def keys(self):
+        return ['a', 'b', 'c']
+
+class SomeClass(object):
+    __metaclass__ = Meta
+
+test(**SomeClass)
+test(**SomeClass())  # [not-a-mapping]
diff --git a/tests/functional/mapping_context_py2.rc b/tests/functional/mapping_context_py2.rc
new file mode 100644
index 000000000..a65023393
--- /dev/null
+++ b/tests/functional/mapping_context_py2.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max_pyver=3.0
diff --git a/tests/functional/mapping_context_py2.txt b/tests/functional/mapping_context_py2.txt
new file mode 100644
index 000000000..59cca6c42
--- /dev/null
+++ b/tests/functional/mapping_context_py2.txt
@@ -0,0 +1 @@
+not-a-mapping:19::Non-mapping value SomeClass() is used in a mapping context
diff --git a/tests/functional/mapping_context_py3.py b/tests/functional/mapping_context_py3.py
new file mode 100644
index 000000000..042d4d02d
--- /dev/null
+++ b/tests/functional/mapping_context_py3.py
@@ -0,0 +1,19 @@
+# pylint: disable=missing-docstring,invalid-name,too-few-public-methods,no-self-use
+from __future__ import print_function
+
+def test(**kwargs):
+    print(kwargs)
+
+# metaclasses as mappings
+class Meta(type):
+    def __getitem__(cls, key):
+        return ord(key)
+
+    def keys(cls):
+        return ['a', 'b', 'c']
+
+class SomeClass(metaclass=Meta):
+    pass
+
+test(**SomeClass)
+test(**SomeClass())  # [not-a-mapping]
diff --git a/tests/functional/mapping_context_py3.rc b/tests/functional/mapping_context_py3.rc
new file mode 100644
index 000000000..9bf6df0ed
--- /dev/null
+++ b/tests/functional/mapping_context_py3.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.0
+
diff --git a/tests/functional/mapping_context_py3.txt b/tests/functional/mapping_context_py3.txt
new file mode 100644
index 000000000..59cca6c42
--- /dev/null
+++ b/tests/functional/mapping_context_py3.txt
@@ -0,0 +1 @@
+not-a-mapping:19::Non-mapping value SomeClass() is used in a mapping context
diff --git a/tests/functional/member_checks.py b/tests/functional/member_checks.py
new file mode 100644
index 000000000..cb6062676
--- /dev/null
+++ b/tests/functional/member_checks.py
@@ -0,0 +1,209 @@
+# pylint: disable=print-statement,missing-docstring,no-self-use,too-few-public-methods,bare-except,broad-except, useless-object-inheritance
+# pylint: disable=using-constant-test,expression-not-assigned, assigning-non-slot, unused-variable,pointless-statement, wrong-import-order, wrong-import-position
+from __future__ import print_function
+import six
+class Provider(object):
+    """provide some attributes and method"""
+    cattr = 4
+    def __init__(self):
+        self.attr = 4
+    def method(self, val):
+        """impressive method"""
+        return self.attr * val
+    def hophop(self):
+        """hop method"""
+        print('hop hop hop', self)
+
+
+class Client(object):
+    """use provider class"""
+
+    def __init__(self):
+        self._prov = Provider()
+        self._prov_attr = Provider.cattr
+        self._prov_attr2 = Provider.cattribute  # [no-member]
+        self.set_later = 0
+
+    def set_set_later(self, value):
+        """set set_later attribute (introduce an inference ambiguity)"""
+        self.set_later = value
+
+    def use_method(self):
+        """use provider's method"""
+        self._prov.hophop()
+        self._prov.hophophop()  # [no-member]
+
+    def use_attr(self):
+        """use provider's attr"""
+        print(self._prov.attr)
+        print(self._prov.attribute)  # [no-member]
+
+    def debug(self):
+        """print debug information"""
+        print(self.__class__.__name__)
+        print(self.__doc__)
+        print(self.__dict__)
+        print(self.__module__)
+
+    def test_bt_types(self):
+        """test access to unexistant member of builtin types"""
+        lis = []
+        lis.apppend(self)  # [no-member]
+        dic = {}
+        dic.set(self)  # [no-member]
+        tup = ()
+        tup.append(self)  # [no-member]
+        string = 'toto'
+        print(string.loower())  # [no-member]
+        integer = 1
+        print(integer.whatever)  # [no-member]
+
+    def test_no_false_positives(self):
+        none = None
+        print(none.whatever)
+        # No misssing in the parents.
+        super(Client, self).misssing() # [no-member]
+
+
+class Mixin(object):
+    """No no-member should be emitted for mixins."""
+
+class Getattr(object):
+    """no-member shouldn't be emitted for classes with dunder getattr."""
+
+    def __getattr__(self, attr):
+        return self.__dict__[attr]
+
+
+class Getattribute(object):
+    """no-member shouldn't be emitted for classes with dunder getattribute."""
+
+    def __getattribute__(self, attr):
+        return 42
+
+print(object.__init__)
+print(property.__init__)
+print(Client().set_later.lower())
+print(Mixin().nanana())
+print(Getattr().nananan())
+print(Getattribute().batman())
+
+try:
+    Client().missing_method()
+except AttributeError:
+    pass
+
+try:
+    Client().indeed() # [no-member]
+except ImportError:
+    pass
+
+try:
+    Client.missing()
+except AttributeError:
+    Client.missing() # [no-member]
+
+try:
+    Client.missing()
+except AttributeError:
+    try:
+        Client.missing() # [no-member]
+    except ValueError:
+        pass
+
+try:
+    if Client:
+        Client().missing()
+except AttributeError:
+    pass
+
+try:
+    Client().indeed()
+except AttributeError:
+    try:
+        Client.missing() # [no-member]
+    except Exception:
+        pass
+
+
+class SuperChecks(str, str): # pylint: disable=duplicate-bases
+    """Don't fail when the MRO is invalid."""
+    def test(self):
+        super(SuperChecks, self).lalala()
+
+type(Client()).ala # [no-member]
+type({}).bala # [no-member]
+type('').portocala # [no-member]
+
+
+def socket_false_positive():
+    """Test a regression
+    Version used:
+
+    - Pylint 0.10.0
+    - Logilab common 0.15.0
+    - Logilab astroid 0.15.1
+
+    False E1101 positive, line 23:
+    Instance of '_socketobject' has no 'connect' member
+    """
+
+    import socket
+    sckt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    sckt.connect(('127.0.0.1', 80))
+    sckt.close()
+
+
+def no_conjugate_member(magic_flag):
+    """should not raise E1101 on something.conjugate"""
+    if magic_flag:
+        something = 1.0
+    else:
+        something = 1.0j
+    if isinstance(something, float):
+        return something
+    return something.conjugate()
+
+
+class NoDunderNameInInstance(object):
+    """Emit a warning when accessing __name__ from an instance."""
+    def __init__(self):
+        self.var = self.__name__ # [no-member]
+
+
+class InvalidAccessBySlots(object):
+    __slots__ = ('a', )
+    def __init__(self):
+        var = self.teta # [no-member]
+        self.teta = 24
+
+
+class MetaWithDynamicGetattr(type):
+
+    def __getattr__(cls, attr):
+        return attr
+
+@six.add_metaclass(MetaWithDynamicGetattr)
+class SomeClass(object):
+    pass
+
+
+SomeClass.does_not_exist
+
+class ClassWithMangledAttribute(object):
+    def __init__(self):
+        self.name = 'Bug1643'
+    def __bar(self):
+        print(self.name + "xD")
+
+ClassWithMangledAttribute()._ClassWithMangledAttribute__bar()  # pylint: disable=protected-access
+
+
+import enum
+
+
+class Cls(enum.IntEnum):
+    Bar = 0
+
+
+SOME_VALUE = Cls.Baz  # [no-member]
diff --git a/tests/functional/member_checks.txt b/tests/functional/member_checks.txt
new file mode 100644
index 000000000..dd2c927b9
--- /dev/null
+++ b/tests/functional/member_checks.txt
@@ -0,0 +1,19 @@
+no-member:24:Client.__init__:Class 'Provider' has no 'cattribute' member:INFERENCE
+no-member:34:Client.use_method:Instance of 'Provider' has no 'hophophop' member:INFERENCE
+no-member:39:Client.use_attr:Instance of 'Provider' has no 'attribute' member:INFERENCE
+no-member:51:Client.test_bt_types:Instance of 'list' has no 'apppend' member; maybe 'append'?:INFERENCE
+no-member:53:Client.test_bt_types:Instance of 'dict' has no 'set' member; maybe 'get'?:INFERENCE
+no-member:55:Client.test_bt_types:Instance of 'tuple' has no 'append' member:INFERENCE
+no-member:57:Client.test_bt_types:Instance of 'str' has no 'loower' member; maybe 'lower'?:INFERENCE
+no-member:59:Client.test_bt_types:Instance of 'int' has no 'whatever' member:INFERENCE
+no-member:65:Client.test_no_false_positives:Super of 'Client' has no 'misssing' member:INFERENCE
+no-member:97::Instance of 'Client' has no 'indeed' member:INFERENCE
+no-member:104::Class 'Client' has no 'missing' member:INFERENCE
+no-member:110::Class 'Client' has no 'missing' member:INFERENCE
+no-member:124::Class 'Client' has no 'missing' member:INFERENCE
+no-member:134::Class 'Client' has no 'ala' member:INFERENCE
+no-member:135::Class 'dict' has no 'bala' member:INFERENCE
+no-member:136::Class 'str' has no 'portocala' member:INFERENCE
+no-member:171:NoDunderNameInInstance.__init__:Instance of 'NoDunderNameInInstance' has no '__name__' member:INFERENCE
+no-member:177:InvalidAccessBySlots.__init__:Instance of 'InvalidAccessBySlots' has no 'teta' member:INFERENCE
+no-member:209::Class 'Cls' has no 'Baz' member; maybe 'Bar'?:INFERENCE
diff --git a/tests/functional/member_checks_hints.py b/tests/functional/member_checks_hints.py
new file mode 100644
index 000000000..407c522b5
--- /dev/null
+++ b/tests/functional/member_checks_hints.py
@@ -0,0 +1,27 @@
+# pylint: disable=missing-docstring, too-few-public-methods, pointless-statement, useless-object-inheritance
+
+
+class Parent(object):
+
+    def __init__(self):
+        self._parent = 42
+        self._registry = {}
+        self._similar1 = 24
+        self._similar2 = 23
+        self._similar3 = 24
+        self._really_similar1 = 23
+        self._really_similar2 = 42
+
+
+class Child(Parent):
+
+    def __init__(self):
+        super(Child, self).__init__()
+
+        self._similar # [no-member]
+        self._really_similar # [no-member]
+        self._paren # [no-member]
+        # Distance is too big
+        self._registryyyy # [no-member]
+        # Nothing close.
+        self._pretty_sure_this_wont_match # [no-member]
diff --git a/tests/functional/member_checks_hints.rc b/tests/functional/member_checks_hints.rc
new file mode 100644
index 000000000..311e05184
--- /dev/null
+++ b/tests/functional/member_checks_hints.rc
@@ -0,0 +1,3 @@
+[TYPECHECK]
+missing-member-max-choices = 3
+missing-member-hint-distance = 1
\ No newline at end of file
diff --git a/tests/functional/member_checks_hints.txt b/tests/functional/member_checks_hints.txt
new file mode 100644
index 000000000..27f1e3d11
--- /dev/null
+++ b/tests/functional/member_checks_hints.txt
@@ -0,0 +1,5 @@
+no-member:21:Child.__init__:Instance of 'Child' has no '_similar' member; maybe one of '_similar1', '_similar2' or '_similar3'?:INFERENCE
+no-member:22:Child.__init__:Instance of 'Child' has no '_really_similar' member; maybe one of '_really_similar1' or '_really_similar2'?:INFERENCE
+no-member:23:Child.__init__:Instance of 'Child' has no '_paren' member; maybe '_parent'?:INFERENCE
+no-member:25:Child.__init__:Instance of 'Child' has no '_registryyyy' member:INFERENCE
+no-member:27:Child.__init__:Instance of 'Child' has no '_pretty_sure_this_wont_match' member:INFERENCE
\ No newline at end of file
diff --git a/tests/functional/member_checks_ignore_none.py b/tests/functional/member_checks_ignore_none.py
new file mode 100644
index 000000000..06f01cb6a
--- /dev/null
+++ b/tests/functional/member_checks_ignore_none.py
@@ -0,0 +1,7 @@
+# pylint: disable=missing-docstring, useless-return
+
+def func():
+    return None
+
+
+SOME_VAR = func().DOES_NOT_EXIST # [no-member]
diff --git a/tests/functional/member_checks_ignore_none.rc b/tests/functional/member_checks_ignore_none.rc
new file mode 100644
index 000000000..dd365acd5
--- /dev/null
+++ b/tests/functional/member_checks_ignore_none.rc
@@ -0,0 +1,2 @@
+[TYPECHECK]
+ignore-none=no
\ No newline at end of file
diff --git a/tests/functional/member_checks_ignore_none.txt b/tests/functional/member_checks_ignore_none.txt
new file mode 100644
index 000000000..61ef7e86e
--- /dev/null
+++ b/tests/functional/member_checks_ignore_none.txt
@@ -0,0 +1 @@
+no-member:7::Instance of 'NoneType' has no 'DOES_NOT_EXIST' member:INFERENCE
\ No newline at end of file
diff --git a/tests/functional/member_checks_inference_improvements.py b/tests/functional/member_checks_inference_improvements.py
new file mode 100644
index 000000000..6eefa7958
--- /dev/null
+++ b/tests/functional/member_checks_inference_improvements.py
@@ -0,0 +1,11 @@
+# pylint: disable=missing-docstring
+
+
+def test_oserror_has_strerror():
+    # https://github.com/PyCQA/pylint/issues/2553
+    try:
+        raise OSError()
+    except OSError as exc:
+        if exc.strerror is not None:
+            return exc.strerror.lower()
+        return None
diff --git a/tests/functional/member_checks_no_hints.py b/tests/functional/member_checks_no_hints.py
new file mode 100644
index 000000000..407c522b5
--- /dev/null
+++ b/tests/functional/member_checks_no_hints.py
@@ -0,0 +1,27 @@
+# pylint: disable=missing-docstring, too-few-public-methods, pointless-statement, useless-object-inheritance
+
+
+class Parent(object):
+
+    def __init__(self):
+        self._parent = 42
+        self._registry = {}
+        self._similar1 = 24
+        self._similar2 = 23
+        self._similar3 = 24
+        self._really_similar1 = 23
+        self._really_similar2 = 42
+
+
+class Child(Parent):
+
+    def __init__(self):
+        super(Child, self).__init__()
+
+        self._similar # [no-member]
+        self._really_similar # [no-member]
+        self._paren # [no-member]
+        # Distance is too big
+        self._registryyyy # [no-member]
+        # Nothing close.
+        self._pretty_sure_this_wont_match # [no-member]
diff --git a/tests/functional/member_checks_no_hints.rc b/tests/functional/member_checks_no_hints.rc
new file mode 100644
index 000000000..780950df6
--- /dev/null
+++ b/tests/functional/member_checks_no_hints.rc
@@ -0,0 +1,2 @@
+[TYPECHECK]
+missing-member-hint=no
\ No newline at end of file
diff --git a/tests/functional/member_checks_no_hints.txt b/tests/functional/member_checks_no_hints.txt
new file mode 100644
index 000000000..eea748d29
--- /dev/null
+++ b/tests/functional/member_checks_no_hints.txt
@@ -0,0 +1,5 @@
+no-member:21:Child.__init__:Instance of 'Child' has no '_similar' member:INFERENCE
+no-member:22:Child.__init__:Instance of 'Child' has no '_really_similar' member:INFERENCE
+no-member:23:Child.__init__:Instance of 'Child' has no '_paren' member:INFERENCE
+no-member:25:Child.__init__:Instance of 'Child' has no '_registryyyy' member:INFERENCE
+no-member:27:Child.__init__:Instance of 'Child' has no '_pretty_sure_this_wont_match' member:INFERENCE
\ No newline at end of file
diff --git a/tests/functional/member_checks_opaque.py b/tests/functional/member_checks_opaque.py
new file mode 100644
index 000000000..9b592af64
--- /dev/null
+++ b/tests/functional/member_checks_opaque.py
@@ -0,0 +1,12 @@
+# pylint: disable=missing-docstring,import-error
+
+from unknown import Unknown, some_value
+
+
+def test(argument):
+    if argument:
+        return 42
+    return Unknown
+
+
+test(some_value).test() # [no-member]
diff --git a/tests/functional/member_checks_opaque.rc b/tests/functional/member_checks_opaque.rc
new file mode 100644
index 000000000..025cd2a0f
--- /dev/null
+++ b/tests/functional/member_checks_opaque.rc
@@ -0,0 +1,2 @@
+[TYPECHECK]
+ignore-on-opaque-inference=n
diff --git a/tests/functional/member_checks_opaque.txt b/tests/functional/member_checks_opaque.txt
new file mode 100644
index 000000000..dae295353
--- /dev/null
+++ b/tests/functional/member_checks_opaque.txt
@@ -0,0 +1 @@
+no-member:12::Instance of 'int' has no 'test' member:INFERENCE
diff --git a/tests/functional/member_checks_py37.py b/tests/functional/member_checks_py37.py
new file mode 100644
index 000000000..8d59b7d80
--- /dev/null
+++ b/tests/functional/member_checks_py37.py
@@ -0,0 +1,19 @@
+# pylint: disable=missing-docstring
+import collections
+import asyncio
+
+isinstance([], collections.Iterable)
+
+
+async def gen():
+    await asyncio.sleep(0.1)
+    value = yield 42
+    print(value)
+    await asyncio.sleep(0.2)
+
+
+async def test():
+    generator = gen()
+
+    await generator.asend(None)
+    await generator.send(None)  # [no-member]
diff --git a/tests/functional/member_checks_py37.rc b/tests/functional/member_checks_py37.rc
new file mode 100644
index 000000000..5d0572448
--- /dev/null
+++ b/tests/functional/member_checks_py37.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
\ No newline at end of file
diff --git a/tests/functional/member_checks_py37.txt b/tests/functional/member_checks_py37.txt
new file mode 100644
index 000000000..82a339d23
--- /dev/null
+++ b/tests/functional/member_checks_py37.txt
@@ -0,0 +1 @@
+no-member:19:test:AsyncGenerator 'async_generator' has no 'send' member; maybe 'asend'?:INFERENCE
diff --git a/tests/functional/membership_protocol.py b/tests/functional/membership_protocol.py
new file mode 100644
index 000000000..3401f4bb4
--- /dev/null
+++ b/tests/functional/membership_protocol.py
@@ -0,0 +1,123 @@
+# pylint: disable=missing-docstring,pointless-statement,expression-not-assigned,too-few-public-methods,import-error,no-init,wrong-import-position,no-else-return, comparison-with-itself, useless-object-inheritance
+
+# standard types
+1 in [1, 2, 3]
+1 in {'a': 1, 'b': 2}
+1 in {1, 2, 3}
+1 in (1, 2, 3)
+'1' in "123"
+'1' in u"123"
+'1' in bytearray(b"123")
+1 in frozenset([1, 2, 3])
+
+# comprehensions
+1 in [x ** 2 % 10 for x in range(10)]
+1 in {x ** 2 % 10 for x in range(10)}
+1 in {x: x ** 2 % 10 for x in range(10)}
+
+# iterators
+1 in iter([1, 2, 3])
+
+# generator
+def count(upto=float("inf")):
+    i = 0
+    while True:
+        if i > upto:
+            break
+        yield i
+        i += 1
+
+10 in count(upto=10)
+
+# custom instance
+class UniversalContainer(object):
+    def __contains__(self, key):
+        return True
+
+42 in UniversalContainer()
+
+# custom iterable
+class CustomIterable(object):
+    def __iter__(self):
+        return iter((1, 2, 3))
+3 in CustomIterable()
+
+# old-style iterable
+class OldStyleIterable(object):
+    def __getitem__(self, key):
+        if key < 10:
+            return 2 ** key
+        else:
+            raise IndexError("bad index")
+64 in OldStyleIterable()
+
+# do not emit warning if class has unknown bases
+from some_missing_module import ImportedClass
+
+class MaybeIterable(ImportedClass):
+    pass
+
+10 in MaybeIterable()
+
+# do not emit warning inside mixins/abstract/base classes
+class UsefulMixin(object):
+    stuff = None
+
+    def get_stuff(self):
+        return self.stuff
+
+    def act(self, thing):
+        stuff = self.get_stuff()
+        if thing in stuff:
+            pass
+
+class BaseThing(object):
+    valid_values = None
+
+    def validate(self, value):
+        if self.valid_values is None:
+            return True
+        else:
+            # error should not be emitted here
+            return value in self.valid_values
+
+class AbstractThing(object):
+    valid_values = None
+
+    def validate(self, value):
+        if self.valid_values is None:
+            return True
+        else:
+            # error should not be emitted here
+            return value in self.valid_values
+
+# class is not named as abstract
+# but still is deduceably abstract
+class Thing(object):
+    valid_values = None
+
+    def __init__(self):
+        self._init_values()
+
+    def validate(self, value):
+        if self.valid_values is None:
+            return True
+        else:
+            # error should not be emitted here
+            return value in self.valid_values
+
+    def _init_values(self):
+        raise NotImplementedError
+
+# error cases
+42 in 42  # [unsupported-membership-test]
+42 not in None  # [unsupported-membership-test]
+42 in 8.5  # [unsupported-membership-test]
+
+class EmptyClass(object):
+    pass
+
+42 not in EmptyClass()  # [unsupported-membership-test]
+42 in EmptyClass  # [unsupported-membership-test]
+42 not in count  # [unsupported-membership-test]
+42 in range  # [unsupported-membership-test]
diff --git a/tests/functional/membership_protocol.txt b/tests/functional/membership_protocol.txt
new file mode 100644
index 000000000..edb2227aa
--- /dev/null
+++ b/tests/functional/membership_protocol.txt
@@ -0,0 +1,7 @@
+unsupported-membership-test:113::Value '42' doesn't support membership test
+unsupported-membership-test:114::Value 'None' doesn't support membership test
+unsupported-membership-test:115::Value '8.5' doesn't support membership test
+unsupported-membership-test:120::Value 'EmptyClass()' doesn't support membership test
+unsupported-membership-test:121::Value 'EmptyClass' doesn't support membership test
+unsupported-membership-test:122::Value 'count' doesn't support membership test
+unsupported-membership-test:123::Value 'range' doesn't support membership test
diff --git a/tests/functional/membership_protocol_py2.py b/tests/functional/membership_protocol_py2.py
new file mode 100644
index 000000000..8a569c36b
--- /dev/null
+++ b/tests/functional/membership_protocol_py2.py
@@ -0,0 +1,36 @@
+# pylint: disable=missing-docstring,too-few-public-methods,no-init,no-self-use,unused-argument,pointless-statement,expression-not-assigned,undefined-variable, useless-object-inheritance
+
+# metaclasses that support membership test protocol
+class MetaIterable(type):
+    def __iter__(cls):
+        return iter((1, 2, 3))
+
+class MetaOldIterable(type):
+    def __getitem__(cls, key):
+        if key < 10:
+            return key ** 2
+        else:
+            raise IndexError("bad index")
+
+class MetaContainer(type):
+    def __contains__(cls, key):
+        return False
+
+
+class IterableClass(object):
+    __metaclass__ = MetaIterable
+
+class OldIterableClass(object):
+    __metaclass__ = MetaOldIterable
+
+class ContainerClass(object):
+    __metaclass__ = MetaContainer
+
+
+def test():
+    1 in IterableClass
+    1 in OldIterableClass
+    1 in ContainerClass
+    1 in IterableClass()  # [unsupported-membership-test]
+    1 in OldIterableClass()  # [unsupported-membership-test]
+    1 in ContainerClass()  # [unsupported-membership-test]
diff --git a/tests/functional/membership_protocol_py2.rc b/tests/functional/membership_protocol_py2.rc
new file mode 100644
index 000000000..c78f32fa0
--- /dev/null
+++ b/tests/functional/membership_protocol_py2.rc
@@ -0,0 +1,3 @@
+[testoptions]
+max_pyver=3.0
+
diff --git a/tests/functional/membership_protocol_py2.txt b/tests/functional/membership_protocol_py2.txt
new file mode 100644
index 000000000..4ba757550
--- /dev/null
+++ b/tests/functional/membership_protocol_py2.txt
@@ -0,0 +1,3 @@
+unsupported-membership-test:34:test:Value 'IterableClass()' doesn't support membership test
+unsupported-membership-test:35:test:Value 'OldIterableClass()' doesn't support membership test
+unsupported-membership-test:36:test:Value 'ContainerClass()' doesn't support membership test
diff --git a/tests/functional/membership_protocol_py3.py b/tests/functional/membership_protocol_py3.py
new file mode 100644
index 000000000..678072354
--- /dev/null
+++ b/tests/functional/membership_protocol_py3.py
@@ -0,0 +1,36 @@
+# pylint: disable=missing-docstring,too-few-public-methods,no-init,no-self-use,unused-argument,pointless-statement,expression-not-assigned
+
+# metaclasses that support membership test protocol
+class MetaIterable(type):
+    def __iter__(cls):
+        return iter((1, 2, 3))
+
+class MetaOldIterable(type):
+    def __getitem__(cls, key):
+        if key < 10:
+            return key ** 2
+
+        raise IndexError("bad index")
+
+class MetaContainer(type):
+    def __contains__(cls, key):
+        return False
+
+
+class IterableClass(metaclass=MetaOldIterable):
+    pass
+
+class OldIterableClass(metaclass=MetaOldIterable):
+    pass
+
+class ContainerClass(metaclass=MetaContainer):
+    pass
+
+
+def test():
+    1 in IterableClass
+    1 in OldIterableClass
+    1 in ContainerClass
+    1 in IterableClass()  # [unsupported-membership-test]
+    1 in OldIterableClass()  # [unsupported-membership-test]
+    1 in ContainerClass()  # [unsupported-membership-test]
diff --git a/tests/functional/membership_protocol_py3.rc b/tests/functional/membership_protocol_py3.rc
new file mode 100644
index 000000000..9bf6df0ed
--- /dev/null
+++ b/tests/functional/membership_protocol_py3.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.0
+
diff --git a/tests/functional/membership_protocol_py3.txt b/tests/functional/membership_protocol_py3.txt
new file mode 100644
index 000000000..4ba757550
--- /dev/null
+++ b/tests/functional/membership_protocol_py3.txt
@@ -0,0 +1,3 @@
+unsupported-membership-test:34:test:Value 'IterableClass()' doesn't support membership test
+unsupported-membership-test:35:test:Value 'OldIterableClass()' doesn't support membership test
+unsupported-membership-test:36:test:Value 'ContainerClass()' doesn't support membership test
diff --git a/tests/functional/messages_managed_by_id.py b/tests/functional/messages_managed_by_id.py
new file mode 100644
index 000000000..a96ac5cc5
--- /dev/null
+++ b/tests/functional/messages_managed_by_id.py
@@ -0,0 +1,11 @@
+# -*- encoding=utf-8 -*-
+#pylint: disable=C0111
+def foo(): #pylint: disable=C0102
+    return 1
+
+def toto(): #pylint: disable=C0102,R1711
+    return
+
+# +1: [missing-docstring]
+def test_enabled_by_id_msg(): #pylint: enable=C0111
+    pass
diff --git a/tests/functional/messages_managed_by_id.txt b/tests/functional/messages_managed_by_id.txt
new file mode 100644
index 000000000..e766ab0b3
--- /dev/null
+++ b/tests/functional/messages_managed_by_id.txt
@@ -0,0 +1,6 @@
+use-symbolic-message-instead:2::"Id 'C0111' is used to disable 'missing-docstring' message emission"
+use-symbolic-message-instead:3::"Id 'C0102' is used to disable 'blacklisted-name' message emission"
+use-symbolic-message-instead:6::"Id 'C0102' is used to disable 'blacklisted-name' message emission"
+use-symbolic-message-instead:6::"Id 'R1711' is used to disable 'useless-return' message emission"
+use-symbolic-message-instead:10::"Id 'C0111' is used to enable 'missing-docstring' message emission"
+missing-docstring:10:test_enabled_by_id_msg:"Missing function docstring"
diff --git a/tests/functional/method_hidden.py b/tests/functional/method_hidden.py
new file mode 100644
index 000000000..428869666
--- /dev/null
+++ b/tests/functional/method_hidden.py
@@ -0,0 +1,60 @@
+# pylint: disable=too-few-public-methods,print-statement, useless-object-inheritance,missing-docstring
+"""check method hidding ancestor attribute
+"""
+from __future__ import print_function
+
+class Abcd(object):
+    """dummy"""
+    def __init__(self):
+        self.abcd = 1
+
+class Cdef(Abcd):
+    """dummy"""
+    def abcd(self): # [method-hidden]
+        """test
+        """
+        print(self)
+
+class CustomProperty:
+    """dummy"""
+    def __init__(self, _):
+        pass
+
+    def __get__(self, obj, __):
+        if not obj:
+            return self
+        return 5
+
+    def __set__(self, _, __):
+        pass
+
+class Ddef:
+    """dummy"""
+    def __init__(self):
+        self.five = "five"
+
+    @CustomProperty
+    def five(self):
+        """Always 5."""
+        return self
+
+
+def my_decorator(*args, **kwargs):
+    return CustomProperty(*args, **kwargs)
+
+
+class Foo:
+    def __init__(self):
+        self._bar = 42
+        self._baz = 84
+
+    @my_decorator
+    def method(self):  # E0202
+        return self._baz
+
+    @method.setter
+    def method(self, value):
+        self._baz = value
+
+    def do_something_with_baz(self, value):
+        self.method = value
diff --git a/tests/functional/method_hidden.txt b/tests/functional/method_hidden.txt
new file mode 100644
index 000000000..7dfb8d3e0
--- /dev/null
+++ b/tests/functional/method_hidden.txt
@@ -0,0 +1 @@
+method-hidden:13:Cdef.abcd:An attribute defined in functional.method_hidden line 9 hides this method
diff --git a/tests/functional/misplaced_bare_raise.py b/tests/functional/misplaced_bare_raise.py
new file mode 100644
index 000000000..3a11aaee8
--- /dev/null
+++ b/tests/functional/misplaced_bare_raise.py
@@ -0,0 +1,85 @@
+# pylint: disable=missing-docstring, broad-except, unreachable, try-except-raise

+# pylint: disable=unused-variable, too-few-public-methods, invalid-name, useless-object-inheritance

+

+try:

+    raise # [misplaced-bare-raise]

+except Exception:

+    pass

+

+try:

+    pass

+except Exception:

+    raise

+

+# pylint: disable=misplaced-comparison-constant

+try:

+    pass

+except Exception:

+    if 1 == 2:

+        raise

+

+def test():

+    try:

+        pass

+    except Exception:

+        def chest():

+            try:

+                pass

+            except Exception:

+                raise

+        raise

+

+def test1():

+    try:

+        if 1 > 2:

+            def best():

+                raise # [misplaced-bare-raise]

+    except Exception:

+        pass

+    raise # [misplaced-bare-raise]

+raise # [misplaced-bare-raise]

+

+try:

+    pass

+finally:

+    # This might work or might not to, depending if there's

+    # an error raised inside the try block. But relying on this

+    # behaviour can be error prone, so we decided to warn

+    # against it.

+    raise # [misplaced-bare-raise]

+

+

+class A(object):

+    try:

+        pass

+    except Exception:

+        raise

+    raise # [misplaced-bare-raise]

+

+# This works in Python 2, but the intent is nevertheless

+# unclear. It will also not work on Python 3, so it's best

+# not to rely on it.

+exc = None

+try:

+    1/0

+except ZeroDivisionError as exc:

+    pass

+if exc:

+    raise # [misplaced-bare-raise]

+

+# Don't emit if we're in ``__exit__``.

+class ContextManager(object):

+    def __enter__(self):

+        return self

+    def __exit__(self, *args):

+        raise

+

+

+def test_dont_trigger_in_finally_clause_found_in_exception_handler():

+    try:

+        raise ValueError('bad value')

+    except ValueError:

+        try:

+            raise IOError('failed')

+        finally:

+            raise

diff --git a/tests/functional/misplaced_bare_raise.txt b/tests/functional/misplaced_bare_raise.txt
new file mode 100644
index 000000000..fb39640a1
--- /dev/null
+++ b/tests/functional/misplaced_bare_raise.txt
@@ -0,0 +1,7 @@
+misplaced-bare-raise:5::The raise statement is not inside an except clause

+misplaced-bare-raise:36:test1.best:The raise statement is not inside an except clause

+misplaced-bare-raise:39:test1:The raise statement is not inside an except clause

+misplaced-bare-raise:40::The raise statement is not inside an except clause

+misplaced-bare-raise:49::The raise statement is not inside an except clause

+misplaced-bare-raise:57:A:The raise statement is not inside an except clause

+misplaced-bare-raise:68::The raise statement is not inside an except clause

diff --git a/tests/functional/misplaced_comparison_constant.py b/tests/functional/misplaced_comparison_constant.py
new file mode 100644
index 000000000..29f2b1ed8
--- /dev/null
+++ b/tests/functional/misplaced_comparison_constant.py
@@ -0,0 +1,36 @@
+"""Check that the constants are on the right side of the comparisons"""
+
+# pylint: disable=singleton-comparison, missing-docstring, too-few-public-methods, useless-object-inheritance
+
+class MyClass(object):
+    def __init__(self):
+        self.attr = 1
+
+    def dummy_return(self):
+        return self.attr
+
+def dummy_return():
+    return 2
+
+def bad_comparisons():
+    """this is not ok"""
+    instance = MyClass()
+    for i in range(10):
+        if 5 <= i:  # [misplaced-comparison-constant]
+            pass
+        if 1 == i:  # [misplaced-comparison-constant]
+            pass
+        if 3 < dummy_return():  # [misplaced-comparison-constant]
+            pass
+        if 4 != instance.dummy_return():  # [misplaced-comparison-constant]
+            pass
+        if 1 == instance.attr:  # [misplaced-comparison-constant]
+            pass
+        if "aaa" == instance.attr: # [misplaced-comparison-constant]
+            pass
+
+def good_comparison():
+    """this is ok"""
+    for i in range(10):
+        if i == 5:
+            pass
diff --git a/tests/functional/misplaced_comparison_constant.txt b/tests/functional/misplaced_comparison_constant.txt
new file mode 100644
index 000000000..a7f0d956d
--- /dev/null
+++ b/tests/functional/misplaced_comparison_constant.txt
@@ -0,0 +1,6 @@
+misplaced-comparison-constant:19:bad_comparisons:Comparison should be i >= 5
+misplaced-comparison-constant:21:bad_comparisons:Comparison should be i == 1
+misplaced-comparison-constant:23:bad_comparisons:Comparison should be dummy_return() > 3
+misplaced-comparison-constant:25:bad_comparisons:Comparison should be instance.dummy_return() != 4
+misplaced-comparison-constant:27:bad_comparisons:Comparison should be instance.attr == 1
+misplaced-comparison-constant:29:bad_comparisons:Comparison should be instance.attr == 'aaa'
diff --git a/tests/functional/misplaced_format_function.py b/tests/functional/misplaced_format_function.py
new file mode 100644
index 000000000..3520dc70b
--- /dev/null
+++ b/tests/functional/misplaced_format_function.py
@@ -0,0 +1,58 @@
+"""Test that format function is used only with string."""
+
+# pylint: disable=invalid-name, pointless-string-statement, line-too-long, no-member, blacklisted-name, undefined-variable, missing-docstring, too-few-public-methods
+
+print('value: {}').format(123)  # [misplaced-format-function]
+print("value: {}").format(123)  # [misplaced-format-function]
+print('value: {}'.format(123))
+print('{} Come Forth!'.format('Lazarus'))
+print('Der Hem ist mein Licht und mein Heil, vor wem sollte ich mich furchten? => {}'.format('Psalm 27, 1'))
+print('123')
+print()
+s = 'value: {}'.format(123)
+a = 'value: {}'
+a.format(123)
+
+def foo(arg):
+    """The World is Yours"""
+    return arg.format(123)  # we don't know if arg is str or not, don't raise error.
+
+def goo(arg):
+    """The World is Yours"""
+    TextWriter.format(arg)
+
+def bar(arg, TextWriter):
+    """The World is Yours"""
+    TextWriter().format(arg)
+
+def foobar(arg, TextWriter):
+    """The World is Yours"""
+    TextWriter.format(arg)
+
+def barfoo(arg):
+    """The World is Yours"""
+    TextWriter().format(arg)
+
+def _display(self, layout):
+    """launch layouts display"""
+    print(file=self.out)
+    TextWriter().format(layout, self.out)
+
+
+class FakeClass:
+    def __init__(self, string):
+        self.string = string
+
+    def get_string(self):
+        return self.string
+
+    def format_string(self):
+        self.string.format()
+        self.get_string().format()
+        print(self.get_string()).format()  # [misplaced-format-function]
+        print(self.get_string().format())
+
+obj = FakeClass('Voila!!!')
+obj.get_string().format()
+print(obj.get_string().format())
+print(obj.get_string()).format()  # [misplaced-format-function]
diff --git a/tests/functional/misplaced_format_function.txt b/tests/functional/misplaced_format_function.txt
new file mode 100644
index 000000000..91a1874aa
--- /dev/null
+++ b/tests/functional/misplaced_format_function.txt
@@ -0,0 +1,4 @@
+misplaced-format-function:5::format function is not called on str
+misplaced-format-function:6::format function is not called on str
+misplaced-format-function:52:FakeClass.format_string:format function is not called on str
+misplaced-format-function:58::format function is not called on str
diff --git a/tests/functional/misplaced_future.py b/tests/functional/misplaced_future.py
new file mode 100644
index 000000000..b4317d96f
--- /dev/null
+++ b/tests/functional/misplaced_future.py
@@ -0,0 +1,6 @@
+"""Test that __future__ is not the first statement after the docstring."""

+import collections

+from __future__ import print_function # [misplaced-future]

+from __future__ import with_statement

+

+DATA = collections

diff --git a/tests/functional/misplaced_future.txt b/tests/functional/misplaced_future.txt
new file mode 100644
index 000000000..bc874cf15
--- /dev/null
+++ b/tests/functional/misplaced_future.txt
@@ -0,0 +1 @@
+misplaced-future:3::"__future__ import is not the first non docstring statement"
\ No newline at end of file
diff --git a/tests/functional/missing_docstring.py b/tests/functional/missing_docstring.py
new file mode 100644
index 000000000..657af5c7e
--- /dev/null
+++ b/tests/functional/missing_docstring.py
@@ -0,0 +1,54 @@
+# [missing-docstring]

+# pylint: disable=too-few-public-methods, useless-object-inheritance

+

+def public_documented():

+    """It has a docstring."""

+

+

+def _private_undocumented():

+    # Doesn't need a docstring

+    pass

+

+

+def _private_documented():

+    """It has a docstring."""

+

+

+class ClassDocumented(object):

+    """It has a docstring."""

+

+

+class ClassUndocumented(object): # [missing-docstring]

+    pass

+

+

+def public_undocumented(): # [missing-docstring]

+    pass

+

+

+def __sizeof__():

+    # Special

+    pass

+

+

+def __mangled():

+    pass

+

+

+class Property(object):

+    """Don't warn about setters and deleters."""

+

+    def __init__(self):

+        self._value = None

+

+    @property

+    def test(self):

+        """Default docstring for setters and deleters."""

+

+    @test.setter

+    def test(self, value):

+        self._value = value

+

+    @test.deleter

+    def test(self):

+        pass

diff --git a/tests/functional/missing_docstring.txt b/tests/functional/missing_docstring.txt
new file mode 100644
index 000000000..2680319b6
--- /dev/null
+++ b/tests/functional/missing_docstring.txt
@@ -0,0 +1,3 @@
+missing-docstring:1::Missing module docstring
+missing-docstring:21:ClassUndocumented:Missing class docstring
+missing-docstring:25:public_undocumented:Missing function docstring
diff --git a/tests/functional/missing_final_newline.py b/tests/functional/missing_final_newline.py
new file mode 100644
index 000000000..370f902b7
--- /dev/null
+++ b/tests/functional/missing_final_newline.py
@@ -0,0 +1,4 @@
+"""This file does not have a final newline."""
+from __future__ import print_function
+# +1:[missing-final-newline]
+print(1)
\ No newline at end of file
diff --git a/tests/functional/missing_final_newline.txt b/tests/functional/missing_final_newline.txt
new file mode 100644
index 000000000..b53c980a3
--- /dev/null
+++ b/tests/functional/missing_final_newline.txt
@@ -0,0 +1 @@
+missing-final-newline:4::Final newline missing
diff --git a/tests/functional/missing_kwoa_py3.py b/tests/functional/missing_kwoa_py3.py
new file mode 100644
index 000000000..3b6e1c0d8
--- /dev/null
+++ b/tests/functional/missing_kwoa_py3.py
@@ -0,0 +1,36 @@
+# pylint: disable=missing-docstring,unused-argument
+
+def target(pos, *, keyword):
+    return pos + keyword
+
+
+def forwarding_kwds(pos, **kwds):
+    target(pos, **kwds)
+
+
+def forwarding_args(*args, keyword):
+    target(*args, keyword=keyword)
+
+def forwarding_conversion(*args, **kwargs):
+    target(*args, **dict(kwargs))
+
+
+def not_forwarding_kwargs(*args, **kwargs):
+    target(*args) # [missing-kwoa]
+
+
+target(1, keyword=2)
+
+PARAM = 1
+target(2, PARAM) # [too-many-function-args, missing-kwoa]
+
+
+def some_function(*, param):
+    return param + 2
+
+
+def other_function(**kwargs):
+    return some_function(**kwargs)  # Does not trigger missing-kwoa
+
+
+other_function(param=2)
diff --git a/tests/functional/missing_kwoa_py3.rc b/tests/functional/missing_kwoa_py3.rc
new file mode 100644
index 000000000..a2ab06c50
--- /dev/null
+++ b/tests/functional/missing_kwoa_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/missing_kwoa_py3.txt b/tests/functional/missing_kwoa_py3.txt
new file mode 100644
index 000000000..734208ac3
--- /dev/null
+++ b/tests/functional/missing_kwoa_py3.txt
@@ -0,0 +1,3 @@
+missing-kwoa:19:not_forwarding_kwargs:Missing mandatory keyword argument 'keyword' in function call
+missing-kwoa:25::Missing mandatory keyword argument 'keyword' in function call
+too-many-function-args:25::Too many positional arguments for function call
\ No newline at end of file
diff --git a/tests/functional/missing_parentheses_for_call_in_test.py b/tests/functional/missing_parentheses_for_call_in_test.py
new file mode 100644
index 000000000..cd1d76a8d
--- /dev/null
+++ b/tests/functional/missing_parentheses_for_call_in_test.py
@@ -0,0 +1,95 @@
+"""Verify if call to function or method inside tests are missing parentheses."""
+# pylint: disable=using-constant-test, missing-docstring, useless-object-inheritance
+# pylint: disable=invalid-name, expression-not-assigned
+
+import collections
+
+
+def bool_function():
+    return True
+
+def nonbool_function():
+    return 42
+
+
+class Class(object):
+
+    @staticmethod
+    def bool_method():
+        return False
+
+    @staticmethod
+    def nonbool_method():
+        return 42
+
+
+if collections:
+    pass
+
+if bool_function: # [missing-parentheses-for-call-in-test]
+    pass
+
+if not bool_function():
+    pass
+
+if nonbool_function:  # [missing-parentheses-for-call-in-test]
+    pass
+
+if nonbool_function() != 42:
+    pass
+
+instance = Class()
+
+if instance.bool_method:  # [missing-parentheses-for-call-in-test]
+    pass
+
+if not instance.bool_method():
+    pass
+
+if not instance.nonbool_method:
+    pass
+elif instance.bool_method:  # [missing-parentheses-for-call-in-test]
+    pass
+
+bool_lambda = lambda: True
+
+if bool_lambda:  # [missing-parentheses-for-call-in-test]
+    pass
+
+if not bool_lambda():
+    pass
+
+nonbool_lambda = lambda: 42
+
+if nonbool_lambda: # [missing-parentheses-for-call-in-test]
+    pass
+
+if not nonbool_lambda():
+    pass
+
+MY_VALUE = 42 if bool_function else -1  # [missing-parentheses-for-call-in-test]
+MY_2ND_VALUE = 42 if not bool_function() else -1
+MY_THIRD_VALUE = 42 if bool_lambda else -1  # [missing-parentheses-for-call-in-test]
+MY_FOURTH_VALUE = 42 if nonbool_lambda else -1  # [missing-parentheses-for-call-in-test]
+
+[x for x in range(100) if bool_function]  # [missing-parentheses-for-call-in-test]
+[x for x in range(100) if bool_lambda]  # [missing-parentheses-for-call-in-test]
+[x for x in range(100) if not bool_function()]
+[x for x in range(100) if not bool_lambda()]
+[x for x in range(100) if nonbool_lambda]  # [missing-parentheses-for-call-in-test]
+[x for x in range(100) if nonbool_function]  # [missing-parentheses-for-call-in-test]
+
+def non_const_node_function():
+    return (1, 2, 42)
+
+if non_const_node_function:  # [missing-parentheses-for-call-in-test]
+    pass
+
+def yielding_function():
+    yield 42
+
+if yielding_function: # [missing-parentheses-for-call-in-test]
+    pass
+
+if not yielding_function():
+    pass
diff --git a/tests/functional/missing_parentheses_for_call_in_test.txt b/tests/functional/missing_parentheses_for_call_in_test.txt
new file mode 100644
index 000000000..872c7c3df
--- /dev/null
+++ b/tests/functional/missing_parentheses_for_call_in_test.txt
@@ -0,0 +1,15 @@
+missing-parentheses-for-call-in-test:29::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:35::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:43::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:51::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:56::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:64::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:70::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:72::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:73::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:75::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:76::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:79::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:80::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:85::Using a conditional statement with potentially wrong function or method call due to missing parentheses
+missing-parentheses-for-call-in-test:91::Using a conditional statement with potentially wrong function or method call due to missing parentheses
diff --git a/tests/functional/missing_self_argument.py b/tests/functional/missing_self_argument.py
new file mode 100644
index 000000000..79ae34879
--- /dev/null
+++ b/tests/functional/missing_self_argument.py
@@ -0,0 +1,21 @@
+"""Checks that missing self in method defs don't crash Pylint."""
+# pylint: disable=useless-object-inheritance
+
+
+
+class MyClass(object):
+    """A class with some methods missing self args."""
+
+    def __init__(self):
+        self.var = "var"
+
+    def method():  # [no-method-argument]
+        """A method without a self argument."""
+
+    def setup():  # [no-method-argument]
+        """A method without a self argument, but usage."""
+        self.var = 1  # [undefined-variable]
+
+    def correct(self):
+        """Correct."""
+        self.var = "correct"
diff --git a/tests/functional/missing_self_argument.txt b/tests/functional/missing_self_argument.txt
new file mode 100644
index 000000000..9a47c8914
--- /dev/null
+++ b/tests/functional/missing_self_argument.txt
@@ -0,0 +1,6 @@
+no-method-argument:12:MyClass.method:Method has no argument
+no-method-argument:14:MyClass.met:"""Method has no argument
+""
+"
+no-method-argument:15:MyClass.setup:Method has no argument
+undefined-variable:17:MyClass.setup:Undefined variable 'self'
diff --git a/tests/functional/mixed_indentation.py b/tests/functional/mixed_indentation.py
new file mode 100644
index 000000000..724ecff7a
--- /dev/null
+++ b/tests/functional/mixed_indentation.py
@@ -0,0 +1,10 @@
+"""test mixed tabs and spaces"""
+from __future__ import print_function
+
+def spaces_func():
+    """yo"""
+    print("yo")
+
+def tab_func():
+	"""yo""" # [mixed-indentation]
+	print("yo") # [mixed-indentation]
diff --git a/tests/functional/mixed_indentation.txt b/tests/functional/mixed_indentation.txt
new file mode 100644
index 000000000..d4857e666
--- /dev/null
+++ b/tests/functional/mixed_indentation.txt
@@ -0,0 +1,2 @@
+mixed-indentation:9::Found indentation with tabs instead of spaces
+mixed-indentation:10::Found indentation with tabs instead of spaces
diff --git a/tests/functional/monkeypatch_method.py b/tests/functional/monkeypatch_method.py
new file mode 100644
index 000000000..e8bd03aa7
--- /dev/null
+++ b/tests/functional/monkeypatch_method.py
@@ -0,0 +1,16 @@
+# pylint: disable=missing-docstring,too-few-public-methods, useless-object-inheritance
+'''Test that a function is considered a method when looked up through a class.'''
+
+class Clazz(object):
+    'test class'
+
+    def __init__(self, value):
+        self.value = value
+
+def func(arg1, arg2):
+    'function that will be used as a method'
+    return arg1.value + arg2
+
+Clazz.method = func
+
+VAR = Clazz(1).method(2)
diff --git a/tests/functional/monkeypatch_method.txt b/tests/functional/monkeypatch_method.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/monkeypatch_method.txt
diff --git a/tests/functional/multiple_imports.py b/tests/functional/multiple_imports.py
new file mode 100644
index 000000000..9008dcc52
--- /dev/null
+++ b/tests/functional/multiple_imports.py
@@ -0,0 +1,2 @@
+# pylint: disable=missing-docstring, unused-import
+import os, socket  # [multiple-imports]
diff --git a/tests/functional/multiple_imports.txt b/tests/functional/multiple_imports.txt
new file mode 100644
index 000000000..a5df51e60
--- /dev/null
+++ b/tests/functional/multiple_imports.txt
@@ -0,0 +1 @@
+multiple-imports:2::Multiple imports on one line (os, socket)
diff --git a/tests/functional/namePresetCamelCase.py b/tests/functional/namePresetCamelCase.py
new file mode 100644
index 000000000..e048ec4d8
--- /dev/null
+++ b/tests/functional/namePresetCamelCase.py
@@ -0,0 +1,23 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+__version__ = "1.0"
+SOME_CONSTANT = 42  # [invalid-name]
+
+
+def sayHello(someArgument):
+    return [someArgument * someValue for someValue in range(10)]
+
+
+class MyClass:  # [invalid-name]
+    def __init__(self, argX):
+        self._mySecretX = argX
+
+    @property
+    def myPublicX(self):
+        return self._mySecretX * 2
+
+    def __eq__(self, other):
+        return isinstance(other, MyClass) and self.myPublicX == other.myPublicX
+
+
+def say_hello():  # [invalid-name]
+    pass
diff --git a/tests/functional/namePresetCamelCase.rc b/tests/functional/namePresetCamelCase.rc
new file mode 100644
index 000000000..29f44504a
--- /dev/null
+++ b/tests/functional/namePresetCamelCase.rc
@@ -0,0 +1,13 @@
+[BASIC]
+function-naming-style=camelCase
+const-naming-style=camelCase
+attr-naming-style=camelCase
+argument-naming-style=camelCase
+module-naming-style=camelCase
+method-naming-style=camelCase
+variable-naming-style=camelCase
+class-attribute-naming-style=camelCase
+inlinevar-naming-style=camelCase
+class-naming-style=camelCase
+
+include-naming-hint=yes
diff --git a/tests/functional/namePresetCamelCase.txt b/tests/functional/namePresetCamelCase.txt
new file mode 100644
index 000000000..3c31bbcb0
--- /dev/null
+++ b/tests/functional/namePresetCamelCase.txt
@@ -0,0 +1,3 @@
+invalid-name:3::"Constant name ""SOME_CONSTANT"" doesn't conform to camelCase naming style ('(([a-z_][A-Za-z0-9]*)|(__.*__))$' pattern)"
+invalid-name:10:MyClass:"Class name ""MyClass"" doesn't conform to camelCase naming style ('[a-z_][a-zA-Z0-9]+$' pattern)"
+invalid-name:22:say_hello:"Function name ""say_hello"" doesn't conform to camelCase naming style ('(([a-z_][a-zA-Z0-9]{2,})|(__[a-z][a-zA-Z0-9_]+__))$' pattern)"
diff --git a/tests/functional/name_preset_snake_case.py b/tests/functional/name_preset_snake_case.py
new file mode 100644
index 000000000..549888715
--- /dev/null
+++ b/tests/functional/name_preset_snake_case.py
@@ -0,0 +1,23 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+__version__ = "1.0"
+SOME_CONSTANT = 42  # [invalid-name]
+
+
+def say_hello(some_argument):
+    return [some_argument * some_value for some_value in range(10)]
+
+
+class MyClass:  # [invalid-name]
+    def __init__(self, arg_x):
+        self._my_secret_x = arg_x
+
+    @property
+    def my_public_x(self):
+        return self._my_secret_x * 2
+
+    def __eq__(self, other):
+        return isinstance(other, MyClass) and self.my_public_x == other.my_public_x
+
+
+def sayHello():  # [invalid-name]
+    pass
diff --git a/tests/functional/name_preset_snake_case.rc b/tests/functional/name_preset_snake_case.rc
new file mode 100644
index 000000000..0424cdcfb
--- /dev/null
+++ b/tests/functional/name_preset_snake_case.rc
@@ -0,0 +1,13 @@
+[BASIC]
+function-naming-style=snake_case
+const-naming-style=snake_case
+attr-naming-style=snake_case
+argument-naming-style=snake_case
+module-naming-style=snake_case
+method-naming-style=snake_case
+variable-naming-style=snake_case
+class-attribute-naming-style=snake_case
+inlinevar-naming-style=snake_case
+class-naming-style=snake_case
+
+include-naming-hint=yes
diff --git a/tests/functional/name_preset_snake_case.txt b/tests/functional/name_preset_snake_case.txt
new file mode 100644
index 000000000..14a3d6530
--- /dev/null
+++ b/tests/functional/name_preset_snake_case.txt
@@ -0,0 +1,3 @@
+invalid-name:3::"Constant name ""SOME_CONSTANT"" doesn't conform to snake_case naming style ('(([a-z_][a-z0-9_]*)|(__.*__))$' pattern)"
+invalid-name:10:MyClass:"Class name ""MyClass"" doesn't conform to snake_case naming style ('[a-z_][a-z0-9_]+$' pattern)"
+invalid-name:22:sayHello:"Function name ""sayHello"" doesn't conform to snake_case naming style ('(([a-z_][a-z0-9_]{2,})|(_[a-z0-9_]*)|(__[a-z][a-z0-9_]+__))$' pattern)"
diff --git a/tests/functional/name_styles.py b/tests/functional/name_styles.py
new file mode 100644
index 000000000..87b87d926
--- /dev/null
+++ b/tests/functional/name_styles.py
@@ -0,0 +1,140 @@
+"""Test for the invalid-name warning."""
+# pylint: disable=no-absolute-import, useless-object-inheritance, unnecessary-pass
+from __future__ import print_function
+import abc
+import collections
+
+GOOD_CONST_NAME = ''
+bad_const_name = 0  # [invalid-name]
+
+
+def BADFUNCTION_name():  # [invalid-name]
+    """Bad function name."""
+    BAD_LOCAL_VAR = 1  # [invalid-name]
+    print(BAD_LOCAL_VAR)
+
+
+def func_bad_argname(NOT_GOOD):  # [invalid-name]
+    """Function with a badly named argument."""
+    return NOT_GOOD
+
+
+def no_nested_args(arg1, arg21, arg22):
+    """Well-formed function."""
+    print(arg1, arg21, arg22)
+
+
+class bad_class_name(object):  # [invalid-name]
+    """Class with a bad name."""
+
+
+class CorrectClassName(object):
+    """Class with a good name."""
+
+    def __init__(self):
+        self._good_private_name = 10
+        self.__good_real_private_name = 11
+        self.good_attribute_name = 12
+        self._Bad_AtTR_name = None  # [invalid-name]
+        self.Bad_PUBLIC_name = None  # [invalid-name]
+
+    zz = 'Why Was It Bad Class Attribute?'
+    GOOD_CLASS_ATTR = 'Good Class Attribute'
+
+    def BadMethodName(self):  # [invalid-name]
+        """A Method with a bad name."""
+
+    def good_method_name(self):
+        """A method with a good name."""
+
+    def __DunDER_IS_not_free_for_all__(self):  # [invalid-name]
+        """Another badly named method."""
+
+
+class DerivedFromCorrect(CorrectClassName):
+    """A derived class with an invalid inherited members.
+
+    Derived attributes and methods with invalid names do not trigger warnings.
+    """
+    zz = 'Now a good class attribute'
+
+    def __init__(self):
+        super(DerivedFromCorrect, self).__init__()
+        self._Bad_AtTR_name = None  # Ignored
+
+    def BadMethodName(self):
+        """Ignored since the method is in the interface."""
+
+
+V = [WHAT_Ever_inListComp for WHAT_Ever_inListComp in GOOD_CONST_NAME]
+
+def class_builder():
+    """Function returning a class object."""
+
+    class EmbeddedClass(object):
+        """Useless class."""
+
+    return EmbeddedClass
+
+# +1:[invalid-name]
+BAD_NAME_FOR_CLASS = collections.namedtuple('Named', ['tuple'])
+NEXT_BAD_NAME_FOR_CLASS = class_builder()  # [invalid-name]
+
+GoodName = collections.namedtuple('Named', ['tuple'])
+ToplevelClass = class_builder()
+
+# Aliases for classes have the same name constraints.
+AlsoCorrect = CorrectClassName
+NOT_CORRECT = CorrectClassName  # [invalid-name]
+
+
+def test_globals():
+    """Names in global statements are also checked."""
+    global NOT_CORRECT
+    global AlsoCorrect  # [invalid-name]
+    NOT_CORRECT = 1
+    AlsoCorrect = 2
+
+
+class FooClass(object):
+    """A test case for property names.
+
+    Since by default, the regex for attributes is the same as the one
+    for method names, we check the warning messages to contain the
+    string 'attribute'.
+    """
+    @property
+    def PROPERTY_NAME(self):  # [invalid-name]
+        """Ignored."""
+        pass
+
+    @abc.abstractproperty
+    def ABSTRACT_PROPERTY_NAME(self):  # [invalid-name]
+        """Ignored."""
+        pass
+
+    @PROPERTY_NAME.setter
+    def PROPERTY_NAME_SETTER(self):  # [invalid-name]
+        """Ignored."""
+        pass
+
+    def _nice_and_long_descriptive_private_method_name(self):
+        """private method with long name"""
+        pass
+
+
+def good_public_function_name(good_arg_name):
+    """This is a perfect public function"""
+    good_variable_name = 1
+    return good_variable_name + good_arg_name
+
+
+def _private_scope_function_with_long_descriptive_name():
+    """Private scope function are cool with long descriptive names"""
+    return 12
+
+LONG_CONSTANT_NAME_IN_PUBLIC_SCOPE_ARE_OKAY = True
+
+class _AnExceptionalExceptionThatOccursVeryVeryRarely(Exception):
+    """A very exceptional exception with a nice descriptive name"""
+    pass
diff --git a/tests/functional/name_styles.rc b/tests/functional/name_styles.rc
new file mode 100644
index 000000000..1a63e671b
--- /dev/null
+++ b/tests/functional/name_styles.rc
@@ -0,0 +1,5 @@
+[testoptions]
+min_pyver=2.6
+
+[Messages Control]
+disable=too-few-public-methods,abstract-class-not-used,global-statement
diff --git a/tests/functional/name_styles.txt b/tests/functional/name_styles.txt
new file mode 100644
index 000000000..74d4fb801
--- /dev/null
+++ b/tests/functional/name_styles.txt
@@ -0,0 +1,16 @@
+invalid-name:8::"Constant name ""bad_const_name"" doesn't conform to UPPER_CASE naming style"
+invalid-name:11:BADFUNCTION_name:"Function name ""BADFUNCTION_name"" doesn't conform to snake_case naming style"
+invalid-name:13:BADFUNCTION_name:"Variable name ""BAD_LOCAL_VAR"" doesn't conform to snake_case naming style"
+invalid-name:17:func_bad_argname:"Argument name ""NOT_GOOD"" doesn't conform to snake_case naming style"
+invalid-name:27:bad_class_name:"Class name ""bad_class_name"" doesn't conform to PascalCase naming style"
+invalid-name:38:CorrectClassName.__init__:"Attribute name ""_Bad_AtTR_name"" doesn't conform to snake_case naming style"
+invalid-name:39:CorrectClassName.__init__:"Attribute name ""Bad_PUBLIC_name"" doesn't conform to snake_case naming style"
+invalid-name:44:CorrectClassName.BadMethodName:"Method name ""BadMethodName"" doesn't conform to snake_case naming style":INFERENCE
+invalid-name:50:CorrectClassName.__DunDER_IS_not_free_for_all__:"Method name ""__DunDER_IS_not_free_for_all__"" doesn't conform to snake_case naming style":INFERENCE
+invalid-name:80::"Class name ""BAD_NAME_FOR_CLASS"" doesn't conform to PascalCase naming style"
+invalid-name:81::"Class name ""NEXT_BAD_NAME_FOR_CLASS"" doesn't conform to PascalCase naming style"
+invalid-name:88::"Class name ""NOT_CORRECT"" doesn't conform to PascalCase naming style"
+invalid-name:94:test_globals:"Constant name ""AlsoCorrect"" doesn't conform to UPPER_CASE naming style"
+invalid-name:107:FooClass.PROPERTY_NAME:"Attribute name ""PROPERTY_NAME"" doesn't conform to snake_case naming style":INFERENCE
+invalid-name:112:FooClass.ABSTRACT_PROPERTY_NAME:"Attribute name ""ABSTRACT_PROPERTY_NAME"" doesn't conform to snake_case naming style":INFERENCE
+invalid-name:117:FooClass.PROPERTY_NAME_SETTER:"Attribute name ""PROPERTY_NAME_SETTER"" doesn't conform to snake_case naming style":INFERENCE
diff --git a/tests/functional/namedtuple_member_inference.py b/tests/functional/namedtuple_member_inference.py
new file mode 100644
index 000000000..4488ceb0a
--- /dev/null
+++ b/tests/functional/namedtuple_member_inference.py
@@ -0,0 +1,22 @@
+"""Test namedtuple attributes.
+
+Regression test for:
+https://bitbucket.org/logilab/pylint/issue/93/pylint-crashes-on-namedtuple-attribute
+"""
+from __future__ import absolute_import, print_function
+from collections import namedtuple
+
+__revision__ = None
+
+Thing = namedtuple('Thing', ())
+
+Fantastic = namedtuple('Fantastic', ['foo'])
+
+def test():
+    """Test member access in named tuples."""
+    print(Thing.x)  # [no-member]
+    fan = Fantastic(1)
+    print(fan.foo)
+    # Should not raise protected-access.
+    fan2 = fan._replace(foo=2)
+    print(fan2.foo)
diff --git a/tests/functional/namedtuple_member_inference.txt b/tests/functional/namedtuple_member_inference.txt
new file mode 100644
index 000000000..1532814c5
--- /dev/null
+++ b/tests/functional/namedtuple_member_inference.txt
@@ -0,0 +1,2 @@
+no-member:17:test:Class 'Thing' has no 'x' member:INFERENCE
+no-member:23:test:Instance of 'Fantastic' has no 'foo' member:INFERENCE
diff --git a/tests/functional/names_in__all__.py b/tests/functional/names_in__all__.py
new file mode 100644
index 000000000..9b2840acc
--- /dev/null
+++ b/tests/functional/names_in__all__.py
@@ -0,0 +1,49 @@
+# pylint: disable=too-few-public-methods,no-self-use, no-absolute-import,import-error, useless-object-inheritance, unnecessary-pass
+"""Test Pylint's use of __all__.
+
+* NonExistant is not defined in this module, and it is listed in
+  __all__. An error is expected.
+
+* This module imports path and republished it in __all__. No errors
+  are expected.
+"""
+from __future__ import print_function
+from os import path
+from collections import deque
+from missing import Missing
+
+__all__ = [
+    'Dummy',
+    '', # [undefined-all-variable]
+    Missing,
+    SomeUndefined, # [undefined-variable]
+    'NonExistant',  # [undefined-all-variable]
+    'path',
+    'func',  # [undefined-all-variable]
+    'inner',  # [undefined-all-variable]
+    'InnerKlass', deque.__name__]  # [undefined-all-variable]
+
+
+class Dummy(object):
+    """A class defined in this module."""
+    pass
+
+DUMMY = Dummy()
+
+def function():
+    """Function docstring
+    """
+    pass
+
+function()
+
+class Klass(object):
+    """A klass which contains a function"""
+    def func(self):
+        """A klass method"""
+        inner = None
+        print(inner)
+
+    class InnerKlass(object):
+        """An inner klass"""
+        pass
diff --git a/tests/functional/names_in__all__.txt b/tests/functional/names_in__all__.txt
new file mode 100644
index 000000000..94873296c
--- /dev/null
+++ b/tests/functional/names_in__all__.txt
@@ -0,0 +1,6 @@
+undefined-all-variable:17::Undefined variable name '' in __all__
+undefined-variable:19::Undefined variable 'SomeUndefined'
+undefined-all-variable:20::Undefined variable name 'NonExistant' in __all__
+undefined-all-variable:22::Undefined variable name 'func' in __all__
+undefined-all-variable:23::Undefined variable name 'inner' in __all__
+undefined-all-variable:24::Undefined variable name 'InnerKlass' in __all__
diff --git a/tests/functional/nested_blocks_issue1088.py b/tests/functional/nested_blocks_issue1088.py
new file mode 100644
index 000000000..d44a9f71f
--- /dev/null
+++ b/tests/functional/nested_blocks_issue1088.py
@@ -0,0 +1,23 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+def had_bug(num):
+    if num > 1:  # [too-many-nested-blocks]
+        if num > 2:
+            if num > 3:
+                if num > 4:
+                    if num > 5:
+                        if num > 6:
+                            return True
+    return None
+
+
+def was_correct(num):
+    if num > 1:  # [too-many-nested-blocks]
+        if num > 2:
+            if num > 3:
+                if num > 4:
+                    if num > 5:
+                        if num > 6:
+                            return True
+    if num == 0:
+        return False
+    return None
diff --git a/tests/functional/nested_blocks_issue1088.txt b/tests/functional/nested_blocks_issue1088.txt
new file mode 100644
index 000000000..cf226de78
--- /dev/null
+++ b/tests/functional/nested_blocks_issue1088.txt
@@ -0,0 +1,2 @@
+too-many-nested-blocks:3:had_bug:Too many nested blocks (6/5):HIGH
+too-many-nested-blocks:14:was_correct:Too many nested blocks (6/5):HIGH
diff --git a/tests/functional/nested_func_defined_in_loop.py b/tests/functional/nested_func_defined_in_loop.py
new file mode 100644
index 000000000..af3479074
--- /dev/null
+++ b/tests/functional/nested_func_defined_in_loop.py
@@ -0,0 +1,11 @@
+# pylint: disable=W0640
+"""Check a nested function defined in a loop."""
+
+def example(args):
+    """The check"""
+    for i in args:
+        def nested():
+            print(i)
+        nested()
+    for i in args:
+        print(i)
diff --git a/tests/functional/no_classmethod_decorator.py b/tests/functional/no_classmethod_decorator.py
new file mode 100644
index 000000000..66cc0b3c0
--- /dev/null
+++ b/tests/functional/no_classmethod_decorator.py
@@ -0,0 +1,35 @@
+"""Checks class methods are declared with a decorator if within the class
+scope and if classmethod's argument is a member of the class
+"""
+
+# pylint: disable=too-few-public-methods, using-constant-test, no-self-argument, useless-object-inheritance
+
+class MyClass(object):
+    """Some class"""
+    def __init__(self):
+        pass
+
+    def cmethod(cls):
+        """class method-to-be"""
+    cmethod = classmethod(cmethod)  # [no-classmethod-decorator]
+
+    if True:
+        cmethod = classmethod(cmethod)  # [no-classmethod-decorator]
+
+    @classmethod
+    def my_second_method(cls):
+        """correct class method definition"""
+
+    def other_method(cls):
+        """some method"""
+    cmethod2 = classmethod(other_method)  # [no-classmethod-decorator]
+
+def helloworld():
+    """says hello"""
+
+
+MyClass.new_class_method = classmethod(helloworld)
+
+class MyOtherClass(object):
+    """Some other class"""
+    _make = classmethod(tuple.__new__)
diff --git a/tests/functional/no_classmethod_decorator.txt b/tests/functional/no_classmethod_decorator.txt
new file mode 100644
index 000000000..ba51f0be4
--- /dev/null
+++ b/tests/functional/no_classmethod_decorator.txt
@@ -0,0 +1,3 @@
+no-classmethod-decorator:14:MyClass:Consider using a decorator instead of calling classmethod
+no-classmethod-decorator:17:MyClass:Consider using a decorator instead of calling classmethod
+no-classmethod-decorator:25:MyClass:Consider using a decorator instead of calling classmethod
diff --git a/tests/functional/no_else_raise.py b/tests/functional/no_else_raise.py
new file mode 100644
index 000000000..b3f27a74e
--- /dev/null
+++ b/tests/functional/no_else_raise.py
@@ -0,0 +1,110 @@
+""" Test that superfluous else return are detected. """
+
+# pylint:disable=invalid-name,missing-docstring,unused-variable
+
+def foo1(x, y, z):
+    if x:  # [no-else-raise]
+        a = 1
+        raise Exception(y)
+    else:
+        b = 2
+        raise Exception(z)
+
+
+def foo2(x, y, w, z):
+    if x:  # [no-else-raise]
+        a = 1
+        raise Exception(y)
+    elif z:
+        b = 2
+        raise Exception(w)
+    else:
+        c = 3
+        raise Exception(z)
+
+
+def foo3(x, y, z):
+    if x:
+        a = 1
+        if y:  # [no-else-raise]
+            b = 2
+            raise Exception(y)
+        else:
+            c = 3
+            raise Exception(x)
+    else:
+        d = 4
+        raise Exception(z)
+
+
+def foo4(x, y):
+    if x: # [no-else-raise]
+        if y:
+            a = 4
+        else:
+            b = 2
+        raise Exception(x)
+    else:
+        c = 3
+    raise Exception(y)
+
+
+def foo5(x, y, z):
+    if x: # [no-else-raise]
+        if y:
+            a = 4
+        else:
+            b = 2
+        raise Exception(x)
+    elif z:
+        raise Exception(y)
+    else:
+        c = 3
+    raise Exception(z)
+
+
+def foo6(x, y):
+    if x:
+        if y:   # [no-else-raise]
+            a = 4
+            raise Exception(x)
+        else:
+            b = 2
+    else:
+        c = 3
+    raise Exception(y)
+
+
+def bar1(x, y, z):
+    if x:
+        raise Exception(y)
+    raise Exception(z)
+
+
+def bar2(w, x, y, z):
+    if x:
+        raise Exception(y)
+    if z:
+        a = 1
+    else:
+        raise Exception(w)
+    raise Exception(None)
+
+
+def bar3(x, y, z):
+    if x:
+        if z:
+            raise Exception(y)
+    else:
+        raise Exception(z)
+    raise Exception(None)
+
+
+def bar4(x):
+    if x:  # [no-else-raise]
+        raise Exception(True)
+    else:
+        try:
+            raise Exception(False)
+        except ValueError:
+            raise Exception(None)
diff --git a/tests/functional/no_else_raise.txt b/tests/functional/no_else_raise.txt
new file mode 100644
index 000000000..aec1877c3
--- /dev/null
+++ b/tests/functional/no_else_raise.txt
@@ -0,0 +1,7 @@
+no-else-raise:6:foo1:Unnecessary "else" after "raise"
+no-else-raise:15:foo2:Unnecessary "elif" after "raise"
+no-else-raise:29:foo3:Unnecessary "else" after "raise"
+no-else-raise:41:foo4:Unnecessary "else" after "raise"
+no-else-raise:53:foo5:Unnecessary "elif" after "raise"
+no-else-raise:68:foo6:Unnecessary "else" after "raise"
+no-else-raise:104:bar4:Unnecessary "else" after "raise"
diff --git a/tests/functional/no_else_return.py b/tests/functional/no_else_return.py
new file mode 100644
index 000000000..0f90c153a
--- /dev/null
+++ b/tests/functional/no_else_return.py
@@ -0,0 +1,110 @@
+""" Test that superfluous else return are detected. """
+
+# pylint:disable=invalid-name,missing-docstring,unused-variable
+
+def foo1(x, y, z):
+    if x:  # [no-else-return]
+        a = 1
+        return y
+    else:
+        b = 2
+        return z
+
+
+def foo2(x, y, w, z):
+    if x:  # [no-else-return]
+        a = 1
+        return y
+    elif z:
+        b = 2
+        return w
+    else:
+        c = 3
+        return z
+
+
+def foo3(x, y, z):
+    if x:
+        a = 1
+        if y:  # [no-else-return]
+            b = 2
+            return y
+        else:
+            c = 3
+            return x
+    else:
+        d = 4
+        return z
+
+
+def foo4(x, y):
+    if x:   # [no-else-return]
+        if y:
+            a = 4
+        else:
+            b = 2
+        return
+    else:
+        c = 3
+    return
+
+
+def foo5(x, y, z):
+    if x:   # [no-else-return]
+        if y:
+            a = 4
+        else:
+            b = 2
+        return
+    elif z:
+        c = 2
+    else:
+        c = 3
+    return
+
+
+def foo6(x, y):
+    if x:
+        if y:   # [no-else-return]
+            a = 4
+            return
+        else:
+            b = 2
+    else:
+        c = 3
+    return
+
+
+def bar1(x, y, z):
+    if x:
+        return y
+    return z
+
+
+def bar2(w, x, y, z):
+    if x:
+        return y
+    if z:
+        a = 1
+    else:
+        return w
+    return None
+
+
+def bar3(x, y, z):
+    if x:
+        if z:
+            return y
+    else:
+        return z
+    return None
+
+
+def bar4(x):
+    if x:  # [no-else-return]
+        return True
+    else:
+        try:
+            return False
+        except ValueError:
+            return None
diff --git a/tests/functional/no_else_return.txt b/tests/functional/no_else_return.txt
new file mode 100644
index 000000000..72147e808
--- /dev/null
+++ b/tests/functional/no_else_return.txt
@@ -0,0 +1,7 @@
+no-else-return:6:foo1:Unnecessary "else" after "return"
+no-else-return:15:foo2:Unnecessary "elif" after "return"
+no-else-return:29:foo3:Unnecessary "else" after "return"
+no-else-return:41:foo4:Unnecessary "else" after "return"
+no-else-return:53:foo5:Unnecessary "elif" after "return"
+no-else-return:68:foo6:Unnecessary "else" after "return"
+no-else-return:104:bar4:Unnecessary "else" after "return"
diff --git a/tests/functional/no_name_in_module.py b/tests/functional/no_name_in_module.py
new file mode 100644
index 000000000..8b309fd0a
--- /dev/null
+++ b/tests/functional/no_name_in_module.py
@@ -0,0 +1,66 @@
+#pylint: disable=W0401,W0611,no-absolute-import,invalid-name,import-error,bare-except,broad-except,wrong-import-order,ungrouped-imports,wrong-import-position
+"""check unexistant names imported are reported"""
+from __future__ import print_function
+
+import collections.tutu  # [no-name-in-module]
+from collections import toto  # [no-name-in-module]
+toto.yo()
+
+from xml.etree import ElementTree
+ElementTree.nonexistant_function()  # [no-member]
+ElementTree.another.nonexistant.function()  # [no-member]
+
+
+import sys
+print(sys.stdout, 'hello world')
+print(sys.stdoout, 'bye bye world')  # [no-member]
+
+
+import re
+re.finditer('*', 'yo')
+
+from rie import *
+from re import findiiter, compiile  # [no-name-in-module,no-name-in-module]
+
+import os
+'SOMEVAR' in os.environ  # [pointless-statement]
+
+try:
+    from collections import something
+except ImportError:
+    something = None
+
+try:
+    from collections import anything # [no-name-in-module]
+except ValueError:
+    anything = None
+
+try:
+    import collections.missing
+except ImportError:
+    pass
+
+try:
+    import collections.indeed_missing # [no-name-in-module]
+except ValueError:
+    pass
+
+try:
+    import collections.emit # [no-name-in-module]
+except Exception:
+    pass
+
+try:
+    import collections.emit1
+except:
+    pass
+
+try:
+    if something:
+        import collections.emit2 # [no-name-in-module]
+except Exception:
+    pass
+
+from .no_self_use import Super
+from .no_self_use import lala  # [no-name-in-module]
+from .no_self_use.bla import lala1 # [no-name-in-module]
diff --git a/tests/functional/no_name_in_module.txt b/tests/functional/no_name_in_module.txt
new file mode 100644
index 000000000..7dbc11c6c
--- /dev/null
+++ b/tests/functional/no_name_in_module.txt
@@ -0,0 +1,14 @@
+no-name-in-module:5::No name 'tutu' in module 'collections'
+no-name-in-module:6::No name 'toto' in module 'collections'
+no-member:10::Module 'xml.etree.ElementTree' has no 'nonexistant_function' member:INFERENCE
+no-member:11::Module 'xml.etree.ElementTree' has no 'another' member:INFERENCE
+no-member:16::Module 'sys' has no 'stdoout' member; maybe 'stdout'?:INFERENCE
+no-name-in-module:23::No name 'compiile' in module 're'
+no-name-in-module:23::No name 'findiiter' in module 're'
+pointless-statement:26::Statement seems to have no effect
+no-name-in-module:34::No name 'anything' in module 'collections'
+no-name-in-module:44::No name 'indeed_missing' in module 'collections'
+no-name-in-module:49::No name 'emit' in module 'collections'
+no-name-in-module:60::No name 'emit2' in module 'collections'
+no-name-in-module:65::No name 'lala' in module 'functional.no_self_use'
+no-name-in-module:66::No name 'bla' in module 'functional.no_self_use'
diff --git a/tests/functional/no_self_argument_py37.py b/tests/functional/no_self_argument_py37.py
new file mode 100644
index 000000000..8e6d6fc34
--- /dev/null
+++ b/tests/functional/no_self_argument_py37.py
@@ -0,0 +1,15 @@
+"""Test detection of self as argument of first method in Python 3.7 and above."""
+
+# pylint: disable=missing-docstring,too-few-public-methods,useless-object-inheritance
+
+
+class Toto(object):
+
+    def __class_getitem__(cls, params):
+        # This is actually a special method which is always a class method.
+        # See https://www.python.org/dev/peps/pep-0560/#class-getitem
+        pass
+
+    def __class_other__(cls, params):  # [no-self-argument]
+        # This is not a special case and as such is an instance method.
+        pass
diff --git a/tests/functional/no_self_argument_py37.rc b/tests/functional/no_self_argument_py37.rc
new file mode 100644
index 000000000..a17bb22da
--- /dev/null
+++ b/tests/functional/no_self_argument_py37.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/no_self_argument_py37.txt b/tests/functional/no_self_argument_py37.txt
new file mode 100644
index 000000000..812b8aa0c
--- /dev/null
+++ b/tests/functional/no_self_argument_py37.txt
@@ -0,0 +1 @@
+no-self-argument:13:Toto.__class_other__:Method should have "self" as first argument
diff --git a/tests/functional/no_self_use.py b/tests/functional/no_self_use.py
new file mode 100644
index 000000000..3d3cda1f2
--- /dev/null
+++ b/tests/functional/no_self_use.py
@@ -0,0 +1,78 @@
+# pylint: disable=R0903,W0232,missing-docstring, useless-object-inheritance
+"""test detection of method which could be a function"""
+
+from __future__ import print_function
+
+class Toto(object):
+    """bla bal abl"""
+
+    def __init__(self):
+        self.aaa = 2
+
+    def regular_method(self):
+        """this method is a real method since it access to self"""
+        self.function_method()
+
+    def function_method(self): # [no-self-use]
+        """this method isn' a real method since it doesn't need self"""
+        print('hello')
+
+
+class Base(object):
+    """an abstract class"""
+
+    def __init__(self):
+        self.aaa = 2
+
+    def check(self, arg):
+        """an abstract method, could not be a function"""
+        raise NotImplementedError
+
+
+class Sub(Base):
+    """a concrete class"""
+
+    def check(self, arg):
+        """a concrete method, could not be a function since it need
+        polymorphism benefits
+        """
+        return arg == 0
+
+class Super(object):
+    """same as before without abstract"""
+    attr = 1
+    def method(self):
+        """regular"""
+        print(self.attr)
+
+class Sub1(Super):
+    """override method with need for self"""
+    def method(self):
+        """no i can not be a function"""
+        print(42)
+
+    def __len__(self):
+        """no i can not be a function"""
+        print(42)
+
+    def __cmp__(self, other):
+        """no i can not be a function"""
+        print(42)
+
+    def __copy__(self):
+        return 24
+
+    def __getstate__(self):
+        return 42
+
+
+class Prop(object):
+
+    @property
+    def count(self):
+        """Don't emit no-self-use for properties.
+
+        They can't be functions and they can be part of an
+        API specification.
+        """
+        return 42
diff --git a/tests/functional/no_self_use.txt b/tests/functional/no_self_use.txt
new file mode 100644
index 000000000..e68dcff9a
--- /dev/null
+++ b/tests/functional/no_self_use.txt
@@ -0,0 +1 @@
+no-self-use:16:Toto.function_method:Method could be a function
\ No newline at end of file
diff --git a/tests/functional/no_self_use_py3.py b/tests/functional/no_self_use_py3.py
new file mode 100644
index 000000000..f40150835
--- /dev/null
+++ b/tests/functional/no_self_use_py3.py
@@ -0,0 +1,12 @@
+# pylint: disable=missing-docstring,no-init,unused-argument,invalid-name,too-few-public-methods
+
+class A:
+    def __init__(self):
+        self.store = {}
+
+    def get(self, key, default=None):
+        return self.store.get(key, default)
+
+class B(A):
+    def get_memo(self, obj):
+        return super().get(obj)
diff --git a/tests/functional/no_self_use_py3.rc b/tests/functional/no_self_use_py3.rc
new file mode 100644
index 000000000..a2ab06c50
--- /dev/null
+++ b/tests/functional/no_self_use_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/no_self_use_py3.txt b/tests/functional/no_self_use_py3.txt
new file mode 100644
index 000000000..8b1378917
--- /dev/null
+++ b/tests/functional/no_self_use_py3.txt
@@ -0,0 +1 @@
+
diff --git a/tests/functional/no_staticmethod_decorator.py b/tests/functional/no_staticmethod_decorator.py
new file mode 100644
index 000000000..d0e0effa4
--- /dev/null
+++ b/tests/functional/no_staticmethod_decorator.py
@@ -0,0 +1,35 @@
+"""Checks static methods are declared with a decorator if within the class
+scope and if static method's argument is a member of the class
+"""
+
+# pylint: disable=too-few-public-methods, using-constant-test, no-method-argument, useless-object-inheritance
+
+class MyClass(object):
+    """Some class"""
+    def __init__(self):
+        pass
+
+    def smethod():
+        """static method-to-be"""
+    smethod = staticmethod(smethod) # [no-staticmethod-decorator]
+
+    if True:
+        smethod = staticmethod(smethod)  # [no-staticmethod-decorator]
+
+    @staticmethod
+    def my_second_method():
+        """correct static method definition"""
+
+    def other_method():
+        """some method"""
+    smethod2 = staticmethod(other_method)  # [no-staticmethod-decorator]
+
+def helloworld():
+    """says hello"""
+
+
+MyClass.new_static_method = staticmethod(helloworld)
+
+class MyOtherClass(object):
+    """Some other class"""
+    _make = staticmethod(tuple.__new__)
diff --git a/tests/functional/no_staticmethod_decorator.txt b/tests/functional/no_staticmethod_decorator.txt
new file mode 100644
index 000000000..c0aea0eaa
--- /dev/null
+++ b/tests/functional/no_staticmethod_decorator.txt
@@ -0,0 +1,3 @@
+no-staticmethod-decorator:14:MyClass:Consider using a decorator instead of calling staticmethod
+no-staticmethod-decorator:17:MyClass:Consider using a decorator instead of calling staticmethod
+no-staticmethod-decorator:25:MyClass:Consider using a decorator instead of calling staticmethod
diff --git a/tests/functional/non_iterator_returned.py b/tests/functional/non_iterator_returned.py
new file mode 100644
index 000000000..32486f722
--- /dev/null
+++ b/tests/functional/non_iterator_returned.py
@@ -0,0 +1,95 @@
+"""Check non-iterators returned by __iter__ """
+
+# pylint: disable=too-few-public-methods, missing-docstring, no-self-use, useless-object-inheritance
+
+import six
+
+class FirstGoodIterator(object):
+    """ yields in iterator. """
+
+    def __iter__(self):
+        for index in range(10):
+            yield index
+
+class SecondGoodIterator(object):
+    """ __iter__ and next """
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        """ Infinite iterator, but still an iterator """
+        return 1
+
+    def next(self):
+        """Same as __next__, but for Python 2."""
+        return 1
+
+class ThirdGoodIterator(object):
+    """ Returns other iterator, not the current instance """
+
+    def __iter__(self):
+        return SecondGoodIterator()
+
+class FourthGoodIterator(object):
+    """ __iter__ returns iter(...) """
+
+    def __iter__(self):
+        return iter(range(10))
+
+
+class IteratorMetaclass(type):
+    def __next__(cls):
+        return 1
+
+    def next(cls):
+        return 2
+
+
+@six.add_metaclass(IteratorMetaclass)
+class IteratorClass(object):
+    """Iterable through the metaclass."""
+
+
+class FifthGoodIterator(object):
+    """__iter__ returns a class which uses an iterator-metaclass."""
+    def __iter__(self):
+        return IteratorClass
+
+class FileBasedIterator(object):
+    def __init__(self, path):
+        self.path = path
+        self.file = None
+
+    def __iter__(self):
+        if self.file is not None:
+            self.file.close()
+        self.file = open(self.path)
+        # self file has two infered values: None and <instance of 'file'>
+        # we don't want to emit error in this case
+        return self.file
+
+
+class FirstBadIterator(object):
+    """ __iter__ returns a list """
+
+    def __iter__(self): # [non-iterator-returned]
+        return []
+
+class SecondBadIterator(object):
+    """ __iter__ without next """
+
+    def __iter__(self): # [non-iterator-returned]
+        return self
+
+class ThirdBadIterator(object):
+    """ __iter__ returns an instance of another non-iterator """
+
+    def __iter__(self): # [non-iterator-returned]
+        return SecondBadIterator()
+
+class FourthBadIterator(object):
+    """__iter__ returns a class."""
+
+    def __iter__(self): # [non-iterator-returned]
+        return ThirdBadIterator
diff --git a/tests/functional/non_iterator_returned.txt b/tests/functional/non_iterator_returned.txt
new file mode 100644
index 000000000..fa1d5bec5
--- /dev/null
+++ b/tests/functional/non_iterator_returned.txt
@@ -0,0 +1,4 @@
+non-iterator-returned:76:FirstBadIterator.__iter__:__iter__ returns non-iterator
+non-iterator-returned:82:SecondBadIterator.__iter__:__iter__ returns non-iterator
+non-iterator-returned:88:ThirdBadIterator.__iter__:__iter__ returns non-iterator
+non-iterator-returned:94:FourthBadIterator.__iter__:__iter__ returns non-iterator
diff --git a/tests/functional/none_dunder_protocols_py36.py b/tests/functional/none_dunder_protocols_py36.py
new file mode 100644
index 000000000..5573ceeb4
--- /dev/null
+++ b/tests/functional/none_dunder_protocols_py36.py
@@ -0,0 +1,34 @@
+# pylint: disable=missing-docstring, too-few-public-methods,pointless-statement
+# pylint: disable=expression-not-assigned
+
+class MetaIterable(type):
+    __iter__ = None
+
+
+class MetaOldIterable(type):
+    __getitem__ = None
+
+
+class MetaContainer(type):
+    __contains__ = None
+
+
+class NonIterableClass(metaclass=MetaOldIterable):
+    __contains__ = None
+
+
+class OldNonIterableClass(metaclass=MetaOldIterable):
+    __contains__ = None
+
+
+class NonContainerClass(metaclass=MetaContainer):
+    __iter__ = None
+
+
+def test():
+    1 in NonIterableClass  # [unsupported-membership-test]
+    1 in OldNonIterableClass  # [unsupported-membership-test]
+    1 in NonContainerClass # [unsupported-membership-test]
+    1 in NonIterableClass()  # [unsupported-membership-test]
+    1 in OldNonIterableClass()  # [unsupported-membership-test]
+    1 in NonContainerClass()  # [unsupported-membership-test]
diff --git a/tests/functional/none_dunder_protocols_py36.rc b/tests/functional/none_dunder_protocols_py36.rc
new file mode 100644
index 000000000..a2ab06c50
--- /dev/null
+++ b/tests/functional/none_dunder_protocols_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/none_dunder_protocols_py36.txt b/tests/functional/none_dunder_protocols_py36.txt
new file mode 100644
index 000000000..0775b4ac3
--- /dev/null
+++ b/tests/functional/none_dunder_protocols_py36.txt
@@ -0,0 +1,6 @@
+unsupported-membership-test:29:test:Value 'NonIterableClass' doesn't support membership test
+unsupported-membership-test:30:test:Value 'OldNonIterableClass' doesn't support membership test
+unsupported-membership-test:31:test:Value 'NonContainerClass' doesn't support membership test
+unsupported-membership-test:32:test:Value 'NonIterableClass()' doesn't support membership test
+unsupported-membership-test:33:test:Value 'OldNonIterableClass()' doesn't support membership test
+unsupported-membership-test:34:test:Value 'NonContainerClass()' doesn't support membership test
diff --git a/tests/functional/nonexistent_operator.py b/tests/functional/nonexistent_operator.py
new file mode 100644
index 000000000..f05a64947
--- /dev/null
+++ b/tests/functional/nonexistent_operator.py
@@ -0,0 +1,15 @@
+"""check operator use"""
+# pylint: disable=invalid-name, pointless-statement
+a = 1
+a += 5
+a = +a
+b = ++a # [nonexistent-operator]
+++a # [nonexistent-operator]
+c = (++a) * b # [nonexistent-operator]
+
+a = 1
+a -= 5
+b = --a # [nonexistent-operator]
+b = a
+--a # [nonexistent-operator]
+c = (--a) * b # [nonexistent-operator]
diff --git a/tests/functional/nonexistent_operator.txt b/tests/functional/nonexistent_operator.txt
new file mode 100644
index 000000000..da59f4147
--- /dev/null
+++ b/tests/functional/nonexistent_operator.txt
@@ -0,0 +1,6 @@
+nonexistent-operator:6::"Use of the non-existent ++ operator"
+nonexistent-operator:7::"Use of the non-existent ++ operator"
+nonexistent-operator:8::"Use of the non-existent ++ operator"
+nonexistent-operator:12::"Use of the non-existent -- operator"
+nonexistent-operator:14::"Use of the non-existent -- operator"
+nonexistent-operator:15::"Use of the non-existent -- operator"
diff --git a/tests/functional/nonlocal_and_global.py b/tests/functional/nonlocal_and_global.py
new file mode 100644
index 000000000..940052436
--- /dev/null
+++ b/tests/functional/nonlocal_and_global.py
@@ -0,0 +1,12 @@
+"""Test that a name is both nonlocal and global in the same scope."""

+# pylint: disable=missing-docstring,global-variable-not-assigned,invalid-name,nonlocal-without-binding

+

+def bad(): # [nonlocal-and-global]

+    nonlocal missing

+    global missing

+

+def good():

+    nonlocal missing

+    def test():

+        global missing

+    return test

diff --git a/tests/functional/nonlocal_and_global.rc b/tests/functional/nonlocal_and_global.rc
new file mode 100644
index 000000000..c093be204
--- /dev/null
+++ b/tests/functional/nonlocal_and_global.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/nonlocal_and_global.txt b/tests/functional/nonlocal_and_global.txt
new file mode 100644
index 000000000..46f0d0feb
--- /dev/null
+++ b/tests/functional/nonlocal_and_global.txt
@@ -0,0 +1 @@
+nonlocal-and-global:4:bad:"Name 'missing' is nonlocal and global"
\ No newline at end of file
diff --git a/tests/functional/nonlocal_without_binding.py b/tests/functional/nonlocal_without_binding.py
new file mode 100644
index 000000000..be3c00371
--- /dev/null
+++ b/tests/functional/nonlocal_without_binding.py
@@ -0,0 +1,42 @@
+""" Checks that reversed() receive proper argument """
+# pylint: disable=missing-docstring,invalid-name,unused-variable, useless-object-inheritance
+# pylint: disable=too-few-public-methods,no-self-use,no-absolute-import
+
+def test():
+    def parent():
+        a = 42
+        def stuff():
+            nonlocal a
+
+    c = 24
+    def parent2():
+        a = 42
+        def stuff():
+            def other_stuff():
+                nonlocal a
+                nonlocal c
+
+b = 42
+def func():
+    def other_func():
+        nonlocal b  # [nonlocal-without-binding]
+
+class SomeClass(object):
+    nonlocal x # [nonlocal-without-binding]
+
+    def func(self):
+        nonlocal some_attr # [nonlocal-without-binding]
+
+
+def func2():
+    nonlocal_ = None
+    local = None
+
+    class Class:
+
+        nonlocal nonlocal_
+
+        nonlocal_ = 1
+        local = 1
+
+    return local + nonlocal_
diff --git a/tests/functional/nonlocal_without_binding.rc b/tests/functional/nonlocal_without_binding.rc
new file mode 100644
index 000000000..a2ab06c50
--- /dev/null
+++ b/tests/functional/nonlocal_without_binding.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/nonlocal_without_binding.txt b/tests/functional/nonlocal_without_binding.txt
new file mode 100644
index 000000000..05a1105c1
--- /dev/null
+++ b/tests/functional/nonlocal_without_binding.txt
@@ -0,0 +1,3 @@
+nonlocal-without-binding:22:func.other_func:nonlocal name b found without binding

+nonlocal-without-binding:25:SomeClass:nonlocal name x found without binding

+nonlocal-without-binding:28:SomeClass.func:nonlocal name some_attr found without binding
\ No newline at end of file
diff --git a/tests/functional/not_async_context_manager.py b/tests/functional/not_async_context_manager.py
new file mode 100644
index 000000000..138d76dfa
--- /dev/null
+++ b/tests/functional/not_async_context_manager.py
@@ -0,0 +1,71 @@
+"""Test that an async context manager receives a proper object."""

+# pylint: disable=missing-docstring, import-error, too-few-public-methods, useless-object-inheritance

+import contextlib

+

+from ala import Portocala

+

+

+@contextlib.contextmanager

+def ctx_manager():

+    yield

+

+

+class ContextManager(object):

+    def __enter__(self):

+        pass

+    def __exit__(self, *args):

+        pass

+

+class PartialAsyncContextManager(object):

+    def __aenter__(self):

+        pass

+

+class SecondPartialAsyncContextManager(object):

+    def __aexit__(self, *args):

+        pass

+

+class UnknownBases(Portocala):

+    def __aenter__(self):

+        pass

+

+

+class AsyncManagerMixin(object):

+    pass

+

+class GoodAsyncManager(object):

+    def __aenter__(self):

+        pass

+    def __aexit__(self, *args):

+        pass

+

+class InheritExit(object):

+    def __aexit__(self, *args):

+        pass

+

+class SecondGoodAsyncManager(InheritExit):

+    def __aenter__(self):

+        pass

+

+

+async def bad_coro():

+    async with 42: # [not-async-context-manager]

+        pass

+    async with ctx_manager(): # [not-async-context-manager]

+        pass

+    async with ContextManager(): # [not-async-context-manager]

+        pass

+    async with PartialAsyncContextManager(): # [not-async-context-manager]

+        pass

+    async with SecondPartialAsyncContextManager(): # [not-async-context-manager]

+        pass

+

+

+async def good_coro():

+    async with UnknownBases():

+        pass

+    async with AsyncManagerMixin():

+        pass

+    async with GoodAsyncManager():

+        pass

+    async with SecondGoodAsyncManager():

+        pass

diff --git a/tests/functional/not_async_context_manager.rc b/tests/functional/not_async_context_manager.rc
new file mode 100644
index 000000000..03004f2c2
--- /dev/null
+++ b/tests/functional/not_async_context_manager.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5
\ No newline at end of file
diff --git a/tests/functional/not_async_context_manager.txt b/tests/functional/not_async_context_manager.txt
new file mode 100644
index 000000000..ae9fad79b
--- /dev/null
+++ b/tests/functional/not_async_context_manager.txt
@@ -0,0 +1,5 @@
+not-async-context-manager:51:bad_coro:Async context manager 'int' doesn't implement __aenter__ and __aexit__.
+not-async-context-manager:53:bad_coro:Async context manager 'generator' doesn't implement __aenter__ and __aexit__.
+not-async-context-manager:55:bad_coro:Async context manager 'ContextManager' doesn't implement __aenter__ and __aexit__.
+not-async-context-manager:57:bad_coro:Async context manager 'PartialAsyncContextManager' doesn't implement __aenter__ and __aexit__.
+not-async-context-manager:59:bad_coro:Async context manager 'SecondPartialAsyncContextManager' doesn't implement __aenter__ and __aexit__.
diff --git a/tests/functional/not_async_context_manager_py37.py b/tests/functional/not_async_context_manager_py37.py
new file mode 100644
index 000000000..705e5afc9
--- /dev/null
+++ b/tests/functional/not_async_context_manager_py37.py
@@ -0,0 +1,12 @@
+# pylint: disable=missing-docstring
+
+from contextlib import asynccontextmanager
+
+
+@asynccontextmanager
+async def context_manager(value):
+    yield value
+
+
+async with context_manager(42) as ans:
+    assert ans == 42
diff --git a/tests/functional/not_async_context_manager_py37.rc b/tests/functional/not_async_context_manager_py37.rc
new file mode 100644
index 000000000..a17bb22da
--- /dev/null
+++ b/tests/functional/not_async_context_manager_py37.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/not_async_context_manager_py37.txt b/tests/functional/not_async_context_manager_py37.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/not_async_context_manager_py37.txt
diff --git a/tests/functional/not_callable.py b/tests/functional/not_callable.py
new file mode 100644
index 000000000..8d5b000c5
--- /dev/null
+++ b/tests/functional/not_callable.py
@@ -0,0 +1,125 @@
+# pylint: disable=missing-docstring,no-self-use,too-few-public-methods,wrong-import-position, useless-object-inheritance
+
+REVISION = None
+
+REVISION() # [not-callable]
+
+def correct():
+    return 1
+
+REVISION = correct()
+
+class Correct(object):
+    """callable object"""
+
+class MetaCorrect(object):
+    """callable object"""
+    def __call__(self):
+        return self
+
+INSTANCE = Correct()
+CALLABLE_INSTANCE = MetaCorrect()
+CORRECT = CALLABLE_INSTANCE()
+INCORRECT = INSTANCE() # [not-callable]
+LIST = []
+INCORRECT = LIST() # [not-callable]
+DICT = {}
+INCORRECT = DICT() # [not-callable]
+TUPLE = ()
+INCORRECT = TUPLE() # [not-callable]
+INT = 1
+INCORRECT = INT() # [not-callable]
+
+# Test calling properties. Pylint can detect when using only the
+# getter, but it doesn't infer properly when having a getter
+# and a setter.
+class MyProperty(property):
+    """ test subclasses """
+
+class PropertyTest(object):
+    """ class """
+
+    def __init__(self):
+        self.attr = 4
+
+    @property
+    def test(self):
+        """ Get the attribute """
+        return self.attr
+
+    @test.setter
+    def test(self, value):
+        """ Set the attribute """
+        self.attr = value
+
+    @MyProperty
+    def custom(self):
+        """ Get the attribute """
+        return self.attr
+
+    @custom.setter
+    def custom(self, value):
+        """ Set the attribute """
+        self.attr = value
+
+PROP = PropertyTest()
+PROP.test(40) # [not-callable]
+PROP.custom() # [not-callable]
+
+# Safe from not-callable when using properties.
+
+class SafeProperty(object):
+    @property
+    def static(self):
+        return staticmethod
+
+    @property
+    def klass(self):
+        return classmethod
+
+    @property
+    def get_lambda(self):
+        return lambda: None
+
+    @property
+    def other_function(self):
+        def function(arg):
+            return arg
+        return function
+
+    @property
+    def dict_builtin(self):
+        return dict
+
+    @property
+    def range_builtin(self):
+        return range
+
+    @property
+    def instance(self):
+        class Empty(object):
+            def __call__(self):
+                return 42
+        return Empty()
+
+    @property
+    def does_not_make_sense(self):
+        raise NotImplementedError
+
+PROP1 = SafeProperty()
+PROP1.static(2)
+PROP1.klass(2)
+PROP1.get_lambda()
+PROP1.other_function(4)
+PROP1.dict_builtin()
+PROP1.range_builtin(4)
+PROP1.instance()
+PROP1.does_not_make_sense()
+
+
+import missing # pylint: disable=import-error
+
+class UnknownBaseCallable(missing.Blah):
+    pass
+
+UnknownBaseCallable()()
diff --git a/tests/functional/not_callable.txt b/tests/functional/not_callable.txt
new file mode 100644
index 000000000..4928c8c8b
--- /dev/null
+++ b/tests/functional/not_callable.txt
@@ -0,0 +1,8 @@
+not-callable:5::REVISION is not callable
+not-callable:23::INSTANCE is not callable
+not-callable:25::LIST is not callable
+not-callable:27::DICT is not callable
+not-callable:29::TUPLE is not callable
+not-callable:31::INT is not callable
+not-callable:66::PROP.test is not callable
+not-callable:67::PROP.custom is not callable
\ No newline at end of file
diff --git a/tests/functional/not_context_manager.py b/tests/functional/not_context_manager.py
new file mode 100644
index 000000000..a59f5a200
--- /dev/null
+++ b/tests/functional/not_context_manager.py
@@ -0,0 +1,135 @@
+"""Tests that onjects used in a with statement implement context manager protocol"""
+
+# pylint: disable=too-few-public-methods, invalid-name, import-error, missing-docstring
+# pylint: disable=no-init,wrong-import-position, useless-object-inheritance
+# Tests no messages for objects that implement the protocol
+class Manager(object):
+    def __enter__(self):
+        pass
+    def __exit__(self, type_, value, traceback):
+        pass
+with Manager():
+    pass
+
+class AnotherManager(Manager):
+    pass
+with AnotherManager():
+    pass
+
+
+# Tests message for class that doesn't implement the protocol
+class NotAManager(object):
+    pass
+with NotAManager():  #[not-context-manager]
+    pass
+
+# Tests contextlib.contextmanager usage is recognized as correct.
+from contextlib import contextmanager
+@contextmanager
+def dec():
+    yield
+with dec():  # valid use
+    pass
+
+
+# Tests a message is produced when a contextlib.contextmanager
+# decorated function is used without being called.
+with dec:  # [not-context-manager]
+    pass
+
+
+# Tests no messages about context manager protocol
+# if the type can't be inferred.
+from missing import Missing
+with Missing():
+    pass
+
+# Tests context managers as names.
+
+def penelopa():
+    return 42
+
+hopa = dec()
+tropa = penelopa()
+
+with tropa: # [not-context-manager]
+    pass
+
+with hopa:
+    pass
+
+
+# Tests that no messages are emitted for function calls
+# which return managers
+
+def wrapper():
+    return dec()
+
+with wrapper():
+    pass
+
+# Tests for properties returning managers.
+
+class Property(object):
+
+    @property
+    def ctx(self):
+        return dec()
+
+    @property
+    def not_ctx(self):
+        return 42
+
+
+lala = Property()
+with lala.ctx:
+    # Don't emit when the context manager is the
+    # result of accessing a property.
+    pass
+
+with lala.not_ctx: # [not-context-manager]
+    pass
+
+
+class TestKnownBases(Missing):
+    pass
+
+with TestKnownBases():
+    pass
+
+# Ignore mixins.
+class ManagerMixin(object):
+    def test(self):
+        with self:
+            pass
+
+class FullContextManager(ManagerMixin):
+    def __enter__(self):
+        return self
+    def __exit__(self, *args):
+        pass
+
+# Test a false positive with returning a generator
+# from a context manager.
+def generator():
+    yield 42
+
+@contextmanager
+def context_manager_returning_generator():
+    return generator()
+
+with context_manager_returning_generator():
+    pass
+
+FIRST = [context_manager_returning_generator()]
+with FIRST[0]:
+    pass
+
+def other_indirect_func():
+    return generator()
+
+def not_context_manager():
+    return other_indirect_func()
+
+with not_context_manager(): # [not-context-manager]
+    pass
diff --git a/tests/functional/not_context_manager.txt b/tests/functional/not_context_manager.txt
new file mode 100644
index 000000000..7fad3af0d
--- /dev/null
+++ b/tests/functional/not_context_manager.txt
@@ -0,0 +1,5 @@
+not-context-manager:23::Context manager 'NotAManager' doesn't implement __enter__ and __exit__.
+not-context-manager:37::Context manager 'dec' doesn't implement __enter__ and __exit__.
+not-context-manager:55::Context manager 'int' doesn't implement __enter__ and __exit__.
+not-context-manager:90::Context manager 'int' doesn't implement __enter__ and __exit__.
+not-context-manager:134::Context manager 'generator' doesn't implement __enter__ and __exit__.
diff --git a/tests/functional/not_in_loop.py b/tests/functional/not_in_loop.py
new file mode 100644
index 000000000..3ea7573d2
--- /dev/null
+++ b/tests/functional/not_in_loop.py
@@ -0,0 +1,54 @@
+"""Test that not-in-loop is detected properly."""
+# pylint: disable=missing-docstring, invalid-name, too-few-public-methods
+# pylint: disable=useless-else-on-loop, using-constant-test, useless-object-inheritance
+
+while True:
+    def ala():
+        continue # [not-in-loop]
+
+while True:
+    pass
+else:
+    continue # [not-in-loop]
+
+def lala():
+    continue # [not-in-loop]
+
+while True:
+    class A(object):
+        continue # [not-in-loop]
+
+for _ in range(10):
+    pass
+else:
+    continue # [not-in-loop]
+
+for _ in range(42):
+    pass
+else:
+    break # [not-in-loop]
+
+if True:
+    continue # [not-in-loop]
+else:
+    break # [not-in-loop]
+
+for _ in range(10):
+    for _ in range(20):
+        pass
+    else:
+        continue
+
+while True:
+    while True:
+        break
+    else:
+        break
+    break
+else:
+    pass
+
+for _ in range(1):
+    continue
+for _ in range(42):
+    break
diff --git a/tests/functional/not_in_loop.txt b/tests/functional/not_in_loop.txt
new file mode 100644
index 000000000..6730bfccd
--- /dev/null
+++ b/tests/functional/not_in_loop.txt
@@ -0,0 +1,8 @@
+not-in-loop:7:ala:'continue' not properly in loop
+not-in-loop:12::'continue' not properly in loop
+not-in-loop:15:lala:'continue' not properly in loop
+not-in-loop:19:A:'continue' not properly in loop
+not-in-loop:24::'continue' not properly in loop
+not-in-loop:29::'break' not properly in loop
+not-in-loop:32::'continue' not properly in loop
+not-in-loop:34::'break' not properly in loop
\ No newline at end of file
diff --git a/tests/functional/old_division_manually.py b/tests/functional/old_division_manually.py
new file mode 100644
index 000000000..aab4bd4fe
--- /dev/null
+++ b/tests/functional/old_division_manually.py
@@ -0,0 +1,2 @@
+from __future__ import division
+print 1 / 3
\ No newline at end of file
diff --git a/tests/functional/old_division_manually.rc b/tests/functional/old_division_manually.rc
new file mode 100644
index 000000000..11dbb8d01
--- /dev/null
+++ b/tests/functional/old_division_manually.rc
@@ -0,0 +1,6 @@
+[testoptions]
+max_pyver=3.0
+
+[Messages Control]
+disable=all
+enable=old-division
\ No newline at end of file
diff --git a/tests/functional/postponed_evaluation_activated.py b/tests/functional/postponed_evaluation_activated.py
new file mode 100644
index 000000000..3cc694d47
--- /dev/null
+++ b/tests/functional/postponed_evaluation_activated.py
@@ -0,0 +1,28 @@
+# pylint: disable=missing-docstring,no-self-use,unused-argument,pointless-statement
+# pylint: disable=too-few-public-methods,no-name-in-module
+from __future__ import annotations
+
+
+class Class:
+    @classmethod
+    def from_string(cls, source) -> Class:
+        ...
+
+    def validate_b(self, obj: OtherClass) -> bool:
+        ...
+
+
+class OtherClass:
+    ...
+
+
+class Example:
+    obj: Other
+
+
+class Other:
+    ...
+
+
+class ExampleSelf:
+    next: ExampleSelf
diff --git a/tests/functional/postponed_evaluation_activated.rc b/tests/functional/postponed_evaluation_activated.rc
new file mode 100644
index 000000000..a17bb22da
--- /dev/null
+++ b/tests/functional/postponed_evaluation_activated.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/postponed_evaluation_activated.txt b/tests/functional/postponed_evaluation_activated.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/postponed_evaluation_activated.txt
diff --git a/tests/functional/postponed_evaluation_not_activated.py b/tests/functional/postponed_evaluation_not_activated.py
new file mode 100644
index 000000000..f892414f0
--- /dev/null
+++ b/tests/functional/postponed_evaluation_not_activated.py
@@ -0,0 +1,14 @@
+# pylint: disable=missing-docstring,no-self-use,unused-argument,pointless-statement
+# pylint: disable=too-few-public-methods
+
+class Class:
+    @classmethod
+    def from_string(cls, source) -> Class:  # [undefined-variable]
+        ...
+
+    def validate_b(self, obj: OtherClass) -> bool:  # [used-before-assignment]
+        ...
+
+
+class OtherClass:
+    ...
diff --git a/tests/functional/postponed_evaluation_not_activated.rc b/tests/functional/postponed_evaluation_not_activated.rc
new file mode 100644
index 000000000..a17bb22da
--- /dev/null
+++ b/tests/functional/postponed_evaluation_not_activated.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/postponed_evaluation_not_activated.txt b/tests/functional/postponed_evaluation_not_activated.txt
new file mode 100644
index 000000000..cae433c42
--- /dev/null
+++ b/tests/functional/postponed_evaluation_not_activated.txt
@@ -0,0 +1,2 @@
+undefined-variable:6:Class.from_string:Undefined variable 'Class'
+used-before-assignment:9:Class.validate_b:Using variable 'OtherClass' before assignment
diff --git a/tests/functional/pragma_after_backslash.py b/tests/functional/pragma_after_backslash.py
new file mode 100644
index 000000000..c506f6c9d
--- /dev/null
+++ b/tests/functional/pragma_after_backslash.py
@@ -0,0 +1,10 @@
+"""Test that a pragma has an effect when separated by a backslash."""
+# pylint: disable=too-few-public-methods
+
+class Foo:
+    """block-disable test"""
+
+    def meth3(self):
+        """test one line disabling"""
+        print(self.bla) \
+           # pylint: disable=E1101
diff --git a/tests/functional/preferred_module.py b/tests/functional/preferred_module.py
new file mode 100644
index 000000000..ce1f1c2c8
--- /dev/null
+++ b/tests/functional/preferred_module.py
@@ -0,0 +1,5 @@
+"""Test preferred modules."""
+# pylint: disable=unused-import
+
+import json  # [preferred-module]
+from re import search  # [preferred-module]
diff --git a/tests/functional/preferred_module.rc b/tests/functional/preferred_module.rc
new file mode 100644
index 000000000..e0982e030
--- /dev/null
+++ b/tests/functional/preferred_module.rc
@@ -0,0 +1,2 @@
+[IMPORTS]
+preferred-modules=json:ujson,re:regex
diff --git a/tests/functional/preferred_module.txt b/tests/functional/preferred_module.txt
new file mode 100644
index 000000000..7d327cac4
--- /dev/null
+++ b/tests/functional/preferred_module.txt
@@ -0,0 +1,2 @@
+preferred-module:4::Prefer importing 'ujson' instead of 'json'
+preferred-module:5::Prefer importing 'regex' instead of 're'
diff --git a/tests/functional/print_always_warns.py b/tests/functional/print_always_warns.py
new file mode 100644
index 000000000..8b7f2fc9c
--- /dev/null
+++ b/tests/functional/print_always_warns.py
@@ -0,0 +1,8 @@
+"""Check print statement always warns even if in Python 2 block """
+
+from __future__ import absolute_import
+
+import six
+
+if six.PY2:
+    print "Python 3 fails to parse print statements." # [print-statement]
diff --git a/tests/functional/print_always_warns.rc b/tests/functional/print_always_warns.rc
new file mode 100644
index 000000000..4a0e47a21
--- /dev/null
+++ b/tests/functional/print_always_warns.rc
@@ -0,0 +1,5 @@
+[testoptions]
+max_pyver=3.0
+
+[Messages Control]
+enable=python3
diff --git a/tests/functional/print_always_warns.txt b/tests/functional/print_always_warns.txt
new file mode 100644
index 000000000..c35e118d4
--- /dev/null
+++ b/tests/functional/print_always_warns.txt
@@ -0,0 +1 @@
+print-statement:8::print statement used
diff --git a/tests/functional/protected_access_access_different_scopes.py b/tests/functional/protected_access_access_different_scopes.py
new file mode 100644
index 000000000..dc09aa52b
--- /dev/null
+++ b/tests/functional/protected_access_access_different_scopes.py
@@ -0,0 +1,13 @@
+# pylint: disable=missing-docstring, too-few-public-methods
+class MyClass:
+
+    async def method(self):
+        pass
+
+
+def function():
+    assert self.attr # [undefined-variable]
+
+
+def func():
+    self.attr += 2 # [undefined-variable]
diff --git a/tests/functional/protected_access_access_different_scopes.rc b/tests/functional/protected_access_access_different_scopes.rc
new file mode 100644
index 000000000..71de8b630
--- /dev/null
+++ b/tests/functional/protected_access_access_different_scopes.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5
diff --git a/tests/functional/protected_access_access_different_scopes.txt b/tests/functional/protected_access_access_different_scopes.txt
new file mode 100644
index 000000000..ab8b5be11
--- /dev/null
+++ b/tests/functional/protected_access_access_different_scopes.txt
@@ -0,0 +1,2 @@
+undefined-variable:9:function:"Undefined variable 'self'"
+undefined-variable:13:func:"Undefined variable 'self'"
\ No newline at end of file
diff --git a/tests/functional/raising_format_tuple.py b/tests/functional/raising_format_tuple.py
new file mode 100644
index 000000000..cfdda1023
--- /dev/null
+++ b/tests/functional/raising_format_tuple.py
@@ -0,0 +1,51 @@
+'''
+Complain about multi-argument exception constructors where the first argument
+contains a percent sign, thus suggesting a % string formatting was intended
+instead.  The same holds for a string containing {...} suggesting str.format()
+was intended.
+'''
+
+def bad_percent(arg):
+    '''Raising a percent-formatted string and an argument'''
+    raise KeyError('Bad key: %r', arg)  # [raising-format-tuple]
+
+def good_percent(arg):
+    '''Instead of passing multiple arguments, format the message'''
+    raise KeyError('Bad key: %r' % arg)
+
+def bad_multiarg(name, value):
+    '''Raising a formatted string and multiple additional arguments'''
+    raise ValueError('%s measures %.2f', name, value)  # [raising-format-tuple]
+
+def good_multiarg(name, value):
+    '''The arguments have to be written as a tuple for formatting'''
+    raise ValueError('%s measures %.2f' % (name, value))
+
+def bad_braces(arg):
+    '''Curly braces as placeholders'''
+    raise KeyError('Bad key: {:r}', arg)  # [raising-format-tuple]
+
+def good_braces(arg):
+    '''Call str.format() instead'''
+    raise KeyError('Bad key: {:r}'.format(arg))
+
+def bad_multistring(arg):
+    '''Multiple adjacent string literals'''
+    raise AssertionError(  # [raising-format-tuple]
+        'Long message about %s '
+        "split over several adjacent literals", arg)
+
+def bad_triplequote(arg):
+    '''String literals with triple quotes'''
+    raise AssertionError(  # [raising-format-tuple]
+        '''Long message about %s
+        split over several adjacent literals''', arg)
+
+def bad_unicode(arg):
+    '''Unicode string literal'''
+    raise ValueError(u'Bad %s', arg)  # [raising-format-tuple]
+
+def raise_something_without_name(arg):
+    '''Regression test for nodes without .node attribute'''
+    import standard_exceptions  # pylint: disable=import-error
+    raise standard_exceptions.MyException(u'An %s', arg)  # [raising-format-tuple]
diff --git a/tests/functional/raising_format_tuple.txt b/tests/functional/raising_format_tuple.txt
new file mode 100644
index 000000000..126971551
--- /dev/null
+++ b/tests/functional/raising_format_tuple.txt
@@ -0,0 +1,7 @@
+raising-format-tuple:10:bad_percent:Exception arguments suggest string formatting might be intended
+raising-format-tuple:18:bad_multiarg:Exception arguments suggest string formatting might be intended
+raising-format-tuple:26:bad_braces:Exception arguments suggest string formatting might be intended
+raising-format-tuple:34:bad_multistring:Exception arguments suggest string formatting might be intended
+raising-format-tuple:40:bad_triplequote:Exception arguments suggest string formatting might be intended
+raising-format-tuple:46:bad_unicode:Exception arguments suggest string formatting might be intended
+raising-format-tuple:51:raise_something_without_name:Exception arguments suggest string formatting might be intended
diff --git a/tests/functional/raising_non_exception_py3.py b/tests/functional/raising_non_exception_py3.py
new file mode 100644
index 000000000..7961c5220
--- /dev/null
+++ b/tests/functional/raising_non_exception_py3.py
@@ -0,0 +1,13 @@
+"""The following code should emit a raising-non-exception.
+
+Previously, it didn't, due to a bug in the check for bad-exception-context,
+which prevented further checking on the Raise node.
+"""
+# pylint: disable=import-error, too-few-public-methods, useless-object-inheritance
+
+from missing_module import missing
+
+class Exc(object):
+    """Not an actual exception."""
+
+raise Exc from missing # [raising-non-exception]
diff --git a/tests/functional/raising_non_exception_py3.rc b/tests/functional/raising_non_exception_py3.rc
new file mode 100644
index 000000000..c093be204
--- /dev/null
+++ b/tests/functional/raising_non_exception_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/raising_non_exception_py3.txt b/tests/functional/raising_non_exception_py3.txt
new file mode 100644
index 000000000..12c886288
--- /dev/null
+++ b/tests/functional/raising_non_exception_py3.txt
@@ -0,0 +1 @@
+raising-non-exception:13::Raising a new style class which doesn't inherit from BaseException
\ No newline at end of file
diff --git a/tests/functional/raising_self.py b/tests/functional/raising_self.py
new file mode 100644
index 000000000..16f244ba5
--- /dev/null
+++ b/tests/functional/raising_self.py
@@ -0,0 +1,10 @@
+# pylint: disable=missing-docstring
+
+class MultiException(Exception):
+    def __init__(self):
+        Exception.__init__(self)
+    def return_self(self):
+        return self
+
+
+raise MultiException().return_self()
diff --git a/tests/functional/raising_self.txt b/tests/functional/raising_self.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/raising_self.txt
diff --git a/tests/functional/recursion_error_2667.py b/tests/functional/recursion_error_2667.py
new file mode 100644
index 000000000..585cf7f2f
--- /dev/null
+++ b/tests/functional/recursion_error_2667.py
@@ -0,0 +1,9 @@
+"""Add regression test for https://github.com/PyCQA/pylint/issues/2667"""
+# pylint: disable=missing-docstring, too-few-public-methods
+
+class MyClass:
+    def __init__(self):
+        self._slice = slice(0, 10)
+
+    def incr(self):
+        self._slice = slice(0, self._slice.stop + 1)
diff --git a/tests/functional/recursion_error_2667.txt b/tests/functional/recursion_error_2667.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/recursion_error_2667.txt
diff --git a/tests/functional/recursion_error_2906.py b/tests/functional/recursion_error_2906.py
new file mode 100644
index 000000000..062109672
--- /dev/null
+++ b/tests/functional/recursion_error_2906.py
@@ -0,0 +1,14 @@
+"""Recursion error for https://github.com/PyCQA/pylint/issues/2906"""
+# pylint: disable=blacklisted-name,global-statement,invalid-name,missing-docstring
+lst = []
+
+
+def foo():
+    lst.append(0)
+
+
+def bar():
+    global lst
+
+    length = len(lst)
+    lst += [length]
diff --git a/tests/functional/recursion_error_940.py b/tests/functional/recursion_error_940.py
new file mode 100644
index 000000000..4a9f346cb
--- /dev/null
+++ b/tests/functional/recursion_error_940.py
@@ -0,0 +1,13 @@
+# pylint: disable=missing-docstring, too-few-public-methods, useless-object-inheritance
+import datetime
+
+
+class NewDate(datetime.date):
+    @classmethod
+    def today(cls):
+        return cls(2010, 1, 1)
+
+
+class Next(object):
+    def __init__(self):
+        datetime.date = NewDate
diff --git a/tests/functional/recursion_error_crash.py b/tests/functional/recursion_error_crash.py
new file mode 100644
index 000000000..208bc2e7a
--- /dev/null
+++ b/tests/functional/recursion_error_crash.py
@@ -0,0 +1,9 @@
+"""Test that a recursion error does not happen
+
+https://github.com/PyCQA/pylint/issues/2463
+"""
+import os
+
+ABC = os.path.realpath('abc')
+DEF = os.path.realpath(ABC + 'def')
+GHI = os.path.join(DEF, 'ghi')
diff --git a/tests/functional/recursion_error_crash.txt b/tests/functional/recursion_error_crash.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/recursion_error_crash.txt
diff --git a/tests/functional/recursion_error_crash_2683.py b/tests/functional/recursion_error_crash_2683.py
new file mode 100644
index 000000000..05978a355
--- /dev/null
+++ b/tests/functional/recursion_error_crash_2683.py
@@ -0,0 +1,13 @@
+"""Test for https://github.com/PyCQA/pylint/issues/2683"""
+# pylint: disable=missing-docstring,too-few-public-methods
+
+class Cls:
+    def __init__(self):
+        self.count = 5
+
+    def method(self):
+        records = []
+        for _ in []:
+            records += []
+        records = records[:self.count]
+        records.sort()
diff --git a/tests/functional/recursion_error_crash_2683.txt b/tests/functional/recursion_error_crash_2683.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/recursion_error_crash_2683.txt
diff --git a/tests/functional/recursion_error_crash_astroid_623.py b/tests/functional/recursion_error_crash_astroid_623.py
new file mode 100644
index 000000000..662da6145
--- /dev/null
+++ b/tests/functional/recursion_error_crash_astroid_623.py
@@ -0,0 +1,10 @@
+"""Test that a recursion error does not happen
+
+https://github.com/PyCQA/astroid/issues/623
+"""
+from os import path
+
+FIRST = path.normpath(path.dirname(path.realpath(__file__)))
+SECOND = path.normpath(path.abspath(path.join(FIRST, "..")))
+THIRD = path.normpath(path.abspath(path.join(SECOND, "..")))
+FOURTH = path.join(THIRD)
diff --git a/tests/functional/recursion_error_crash_astroid_623.txt b/tests/functional/recursion_error_crash_astroid_623.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/recursion_error_crash_astroid_623.txt
diff --git a/tests/functional/redefine_in_handler.py b/tests/functional/redefine_in_handler.py
new file mode 100644
index 000000000..9f56cfbea
--- /dev/null
+++ b/tests/functional/redefine_in_handler.py
@@ -0,0 +1,68 @@
+"""Test for W0623, overwriting names in exception handlers."""
+# pylint: disable=broad-except,bare-except,print-statement,no-absolute-import,duplicate-except
+# pylint: disable=invalid-name, unused-variable
+import exceptions
+
+__revision__ = ''
+
+class MyError(Exception):
+    """Special exception class."""
+    pass
+
+
+def some_function():
+    """A function."""
+    exc = None
+
+    try:
+        {}["a"]
+    except KeyError, exceptions.RuntimeError: # [redefine-in-handler]
+        pass
+    except KeyError, OSError: # [redefine-in-handler]
+        pass
+    except KeyError, MyError: # [redefine-in-handler]
+        pass
+    except KeyError, exc: # this is fine
+        print exc
+    except KeyError, exc1: # this is fine
+        print exc1
+    except KeyError, FOO: # C0103
+        print FOO
+
+    try:
+        pass
+    except KeyError, exc1: # this is fine
+        print exc1
+
+class MyOtherError(Exception):
+    """Special exception class."""
+    pass
+
+
+exc3 = None
+
+try:
+    pass
+except KeyError, exceptions.RuntimeError: # [redefine-in-handler]
+    pass
+except KeyError, exceptions.RuntimeError.args: # [redefine-in-handler]
+    pass
+except KeyError, OSError: # [redefine-in-handler]
+    pass
+except KeyError, MyOtherError: # [redefine-in-handler]
+    pass
+except KeyError, exc3: # this is fine
+    print exc3
+except KeyError, exc4: # this is fine
+    print exc4
+except KeyError, OOPS: # C0103
+    print OOPS
+
+try:
+    pass
+except KeyError, exc4: # this is fine
+    print exc4
+except IOError, exc5: # this is fine
+    print exc5
+except MyOtherError, exc5: # this is fine
+    print exc5
diff --git a/tests/functional/redefine_in_handler.rc b/tests/functional/redefine_in_handler.rc
new file mode 100644
index 000000000..a65023393
--- /dev/null
+++ b/tests/functional/redefine_in_handler.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max_pyver=3.0
diff --git a/tests/functional/redefine_in_handler.txt b/tests/functional/redefine_in_handler.txt
new file mode 100644
index 000000000..48674a19b
--- /dev/null
+++ b/tests/functional/redefine_in_handler.txt
@@ -0,0 +1,7 @@
+redefine-in-handler:19:some_function:Redefining name 'RuntimeError' from object 'exceptions' in exception handler
+redefine-in-handler:21:some_function:Redefining name 'OSError' from builtins in exception handler
+redefine-in-handler:23:some_function:Redefining name 'MyError' from outer scope (line 8) in exception handler
+redefine-in-handler:46::Redefining name 'RuntimeError' from object 'exceptions' in exception handler
+redefine-in-handler:48::Redefining name 'args' from object 'exceptions.RuntimeError' in exception handler
+redefine-in-handler:50::Redefining name 'OSError' from builtins in exception handler
+redefine-in-handler:52::Redefining name 'MyOtherError' from outer scope (line 37) in exception handler
diff --git a/tests/functional/redefined_argument_from_local.py b/tests/functional/redefined_argument_from_local.py
new file mode 100644
index 000000000..b1735e9c0
--- /dev/null
+++ b/tests/functional/redefined_argument_from_local.py
@@ -0,0 +1,67 @@
+# pylint: disable=missing-docstring, unused-variable, unused-argument
+# pylint: disable=redefined-outer-name, invalid-name, redefine-in-handler
+
+def test_redefined_in_with(name):
+    with open('something') as name: # [redefined-argument-from-local]
+        pass
+    with open('something') as (second, name): # [redefined-argument-from-local]
+        pass
+    with open('something') as (second, (name, third)): # [redefined-argument-from-local]
+        pass
+    other = None
+    with open('something') as other:
+        pass
+
+
+
+def test_not_redefined_in_with(name):
+    with open('something') as test_redefined_in_with:
+        pass
+
+
+
+def test_redefined_in_for(name):
+    for name in []: # [redefined-argument-from-local]
+        pass
+    for (name, is_) in []: # [redefined-argument-from-local]
+        pass
+    for (is_, (name, _)) in []: # [redefined-argument-from-local]
+        pass
+    for _ in []:
+        pass
+
+
+def test_not_redefined_in_for(name):
+    for name_1 in []:
+        pass
+
+    # This one can be okay if you are interested in the last value
+    # of the iteration
+    other = None
+    for other in []:
+        pass
+
+
+def test_redefined_in_except_handler(name):
+    try:
+        1 / 0
+    except ZeroDivisionError as name: # [redefined-argument-from-local]
+        pass
+
+
+def test_not_redefined_in_except_handler(name):
+    try:
+        1 / 0
+    except ZeroDivisionError as test_redefined_in_except_handler:
+        pass
+
+
+def test_not_redefined(name):
+    if not name:
+        name = ''
+
+
+def apply_filter(objects, filt=lambda obj: True):
+    for obj in objects:
+        if filt(obj):
+            yield obj
diff --git a/tests/functional/redefined_argument_from_local.txt b/tests/functional/redefined_argument_from_local.txt
new file mode 100644
index 000000000..c3c026b7d
--- /dev/null
+++ b/tests/functional/redefined_argument_from_local.txt
@@ -0,0 +1,7 @@
+redefined-argument-from-local:5:test_redefined_in_with:Redefining argument with the local name 'name'
+redefined-argument-from-local:7:test_redefined_in_with:Redefining argument with the local name 'name'
+redefined-argument-from-local:9:test_redefined_in_with:Redefining argument with the local name 'name'
+redefined-argument-from-local:24:test_redefined_in_for:Redefining argument with the local name 'name'
+redefined-argument-from-local:26:test_redefined_in_for:Redefining argument with the local name 'name'
+redefined-argument-from-local:28:test_redefined_in_for:Redefining argument with the local name 'name'
+redefined-argument-from-local:48:test_redefined_in_except_handler:Redefining argument with the local name 'name'
\ No newline at end of file
diff --git a/tests/functional/redefined_builtin.py b/tests/functional/redefined_builtin.py
new file mode 100644
index 000000000..c840f8dd5
--- /dev/null
+++ b/tests/functional/redefined_builtin.py
@@ -0,0 +1,11 @@
+"""Tests for redefining builtins."""
+from __future__ import print_function
+
+def function():
+    """Redefined local."""
+    type = 1  # [redefined-builtin]
+    print(type)
+
+# pylint:disable=invalid-name
+map = {}  # [redefined-builtin]
+__doc__ = 'reset the doc'
diff --git a/tests/functional/redefined_builtin.txt b/tests/functional/redefined_builtin.txt
new file mode 100644
index 000000000..fb11cd3ab
--- /dev/null
+++ b/tests/functional/redefined_builtin.txt
@@ -0,0 +1,2 @@
+redefined-builtin:6:function:Redefining built-in 'type'
+redefined-builtin:10::Redefining built-in 'map'
diff --git a/tests/functional/redundant_unittest_assert.py b/tests/functional/redundant_unittest_assert.py
new file mode 100644
index 000000000..2eb73e3d4
--- /dev/null
+++ b/tests/functional/redundant_unittest_assert.py
@@ -0,0 +1,38 @@
+# pylint: disable=missing-docstring,too-few-public-methods
+"""
+http://www.logilab.org/ticket/355
+If you are using assertTrue or assertFalse and the first argument is a
+constant(like a string), then the assert will always be true. Therefore,
+it should emit a warning message.
+"""
+
+import unittest
+
+@unittest.skip("don't run this")
+class Tests(unittest.TestCase):
+    def test_something(self):
+        ''' Simple test '''
+        some_var = 'It should be assertEqual'
+        # +1:[redundant-unittest-assert]
+        self.assertTrue('I meant assertEqual not assertTrue', some_var)
+        # +1:[redundant-unittest-assert]
+        self.assertFalse('I meant assertEqual not assertFalse', some_var)
+        # +1:[redundant-unittest-assert]
+        self.assertTrue(True, some_var)
+        # +1:[redundant-unittest-assert]
+        self.assertFalse(False, some_var)
+        # +1:[redundant-unittest-assert]
+        self.assertFalse(None, some_var)
+        # +1:[redundant-unittest-assert]
+        self.assertTrue(0, some_var)
+
+        self.assertTrue('should be' in some_var, some_var)
+        self.assertTrue(some_var, some_var)
+
+
+@unittest.skip("don't run this")
+class RegressionWithArgs(unittest.TestCase):
+    '''Don't fail if the bound method doesn't have arguments.'''
+
+    def test(self):
+        self.run()
diff --git a/tests/functional/redundant_unittest_assert.txt b/tests/functional/redundant_unittest_assert.txt
new file mode 100644
index 000000000..889d395c0
--- /dev/null
+++ b/tests/functional/redundant_unittest_assert.txt
@@ -0,0 +1,6 @@
+redundant-unittest-assert:17:Tests.test_something:"Redundant use of assertTrue with constant value 'I meant assertEqual not assertTrue'"
+redundant-unittest-assert:19:Tests.test_something:"Redundant use of assertFalse with constant value 'I meant assertEqual not assertFalse'"
+redundant-unittest-assert:21:Tests.test_something:"Redundant use of assertTrue with constant value True"
+redundant-unittest-assert:23:Tests.test_something:"Redundant use of assertFalse with constant value False"
+redundant-unittest-assert:25:Tests.test_something:"Redundant use of assertFalse with constant value None"
+redundant-unittest-assert:27:Tests.test_something:"Redundant use of assertTrue with constant value 0"
\ No newline at end of file
diff --git a/tests/functional/regression_1326_crash_uninferable.py b/tests/functional/regression_1326_crash_uninferable.py
new file mode 100644
index 000000000..a42d44ac3
--- /dev/null
+++ b/tests/functional/regression_1326_crash_uninferable.py
@@ -0,0 +1,12 @@
+# pylint: disable=missing-docstring
+
+import socket
+
+RETRYABLE_EXCEPTIONS = (socket.error,)
+
+# pylint: disable=wrong-exception-operation
+def exception_handler():
+    try:
+        yield 1
+    except RETRYABLE_EXCEPTIONS + tuple():
+        yield 2
diff --git a/tests/functional/regression_2443_duplicate_bases.py b/tests/functional/regression_2443_duplicate_bases.py
new file mode 100644
index 000000000..f32490c44
--- /dev/null
+++ b/tests/functional/regression_2443_duplicate_bases.py
@@ -0,0 +1,28 @@
+# pylint: disable=missing-docstring, too-many-ancestors,too-few-public-methods
+from typing import Generic, TypeVar
+
+IN = TypeVar('IN', contravariant=True)
+OUT = TypeVar('OUT', covariant=True)
+
+
+class Service:
+    pass
+
+
+class ConsumingMixin(Generic[IN]):
+    pass
+
+
+class ProducingMixin(Generic[OUT]):
+    pass
+
+
+class StreamingMixin(Generic[IN, OUT], ConsumingMixin[IN], ProducingMixin[OUT]):
+    pass
+
+
+class Example(StreamingMixin[str, int], Service):
+    pass
+
+
+print(Example.__mro__)
diff --git a/tests/functional/regression_2443_duplicate_bases.rc b/tests/functional/regression_2443_duplicate_bases.rc
new file mode 100644
index 000000000..0ba2b6333
--- /dev/null
+++ b/tests/functional/regression_2443_duplicate_bases.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/regression_2937_ifexp.py b/tests/functional/regression_2937_ifexp.py
new file mode 100644
index 000000000..55b240440
--- /dev/null
+++ b/tests/functional/regression_2937_ifexp.py
@@ -0,0 +1,20 @@
+# pylint: disable=missing-docstring,no-else-return,using-constant-test
+def get_list():
+    return [1] if True else [2]
+
+
+def find_int():
+    return int(get_list()[0])
+
+
+def func():
+    if True:
+        return find_int()
+    else:
+        return find_int()
+
+
+def test():
+    resp = func()
+    assert resp / resp > 0
+    return resp
diff --git a/tests/functional/regression_no_value_for_parameter.py b/tests/functional/regression_no_value_for_parameter.py
new file mode 100644
index 000000000..30308e605
--- /dev/null
+++ b/tests/functional/regression_no_value_for_parameter.py
@@ -0,0 +1,15 @@
+# pylint: disable=missing-docstring,import-error
+from Unknown import Unknown
+
+class ConfigManager(Unknown):
+
+
+    RENAMED_SECTIONS = {
+        'permissions': 'content'
+    }
+
+    def test(self):
+        self.RENAMED_SECTIONS.items() #@
+
+    def items(self, sectname, raw=True):
+        pass
diff --git a/tests/functional/regression_no_value_for_parameter.txt b/tests/functional/regression_no_value_for_parameter.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/regression_no_value_for_parameter.txt
diff --git a/tests/functional/reimported.py b/tests/functional/reimported.py
new file mode 100644
index 000000000..b73f1ce08
--- /dev/null
+++ b/tests/functional/reimported.py
@@ -0,0 +1,16 @@
+# pylint: disable=missing-docstring,unused-import,import-error, wildcard-import,unused-wildcard-import,redefined-builtin,no-name-in-module,ungrouped-imports,wrong-import-order

+

+from time import sleep, sleep # [reimported]

+from lala import missing, missing # [reimported]

+

+import missing1

+import missing1 # [reimported]

+

+from collections import deque

+from itertools import deque # [reimported]

+

+from collections import OrderedDict

+from itertools import OrderedDict as NotOrderedDict

+

+from itertools import *

+from os import *

diff --git a/tests/functional/reimported.txt b/tests/functional/reimported.txt
new file mode 100644
index 000000000..b15625e2c
--- /dev/null
+++ b/tests/functional/reimported.txt
@@ -0,0 +1,4 @@
+reimported:3::"Reimport 'sleep' (imported line 3)"
+reimported:4::"Reimport 'missing' (imported line 4)"
+reimported:7::"Reimport 'missing1' (imported line 6)"
+reimported:10::"Reimport 'deque' (imported line 9)"
\ No newline at end of file
diff --git a/tests/functional/repeated_keyword.py b/tests/functional/repeated_keyword.py
new file mode 100644
index 000000000..786c53bab
--- /dev/null
+++ b/tests/functional/repeated_keyword.py
@@ -0,0 +1,13 @@
+"""Check that a keyword is not repeated in a function call

+

+This is somehow related to redundant-keyword, but it's not the same.

+"""

+

+# pylint: disable=missing-docstring, invalid-name

+

+def test(a, b):

+    return a, b

+

+test(1, 24)

+test(1, b=24, **{})

+test(1, b=24, **{'b': 24}) # [repeated-keyword]

diff --git a/tests/functional/repeated_keyword.txt b/tests/functional/repeated_keyword.txt
new file mode 100644
index 000000000..1344b15bc
--- /dev/null
+++ b/tests/functional/repeated_keyword.txt
@@ -0,0 +1 @@
+repeated-keyword:13::"Got multiple values for keyword argument 'b' in function call"
\ No newline at end of file
diff --git a/tests/functional/return_in_init.py b/tests/functional/return_in_init.py
new file mode 100644
index 000000000..bf0aa064f
--- /dev/null
+++ b/tests/functional/return_in_init.py
@@ -0,0 +1,25 @@
+# pylint: disable=missing-docstring,too-few-public-methods,useless-return, useless-object-inheritance
+
+class MyClass(object):
+
+    def __init__(self): # [return-in-init]
+        return 1
+
+class MyClass2(object):
+    """dummy class"""
+
+    def __init__(self):
+        return
+
+
+class MyClass3(object):
+    """dummy class"""
+
+    def __init__(self):
+        return None
+
+class MyClass5(object):
+    """dummy class"""
+
+    def __init__(self):
+        self.callable = lambda: (yield None)
diff --git a/tests/functional/return_in_init.txt b/tests/functional/return_in_init.txt
new file mode 100644
index 000000000..5e708d0d7
--- /dev/null
+++ b/tests/functional/return_in_init.txt
@@ -0,0 +1 @@
+return-in-init:5:MyClass.__init__:Explicit return in __init__
\ No newline at end of file
diff --git a/tests/functional/return_outside_function.py b/tests/functional/return_outside_function.py
new file mode 100644
index 000000000..449dafd68
--- /dev/null
+++ b/tests/functional/return_outside_function.py
@@ -0,0 +1,2 @@
+"""This is gramatically correct, but it's still a SyntaxError"""
+return # [return-outside-function]
diff --git a/tests/functional/return_outside_function.txt b/tests/functional/return_outside_function.txt
new file mode 100644
index 000000000..0c9aa5699
--- /dev/null
+++ b/tests/functional/return_outside_function.txt
@@ -0,0 +1 @@
+return-outside-function:2::Return outside function
\ No newline at end of file
diff --git a/tests/functional/reused_outer_loop_variable.py b/tests/functional/reused_outer_loop_variable.py
new file mode 100644
index 000000000..b244e99f5
--- /dev/null
+++ b/tests/functional/reused_outer_loop_variable.py
@@ -0,0 +1,37 @@
+"""Tests for redefining an outer loop variable."""
+from __future__ import print_function
+__revision__ = 0
+
+# Simple nested loop
+for i in range(10):
+    for i in range(10): #[redefined-outer-name]
+        print(i)
+
+# When outer loop unpacks a tuple
+for i, i_again in enumerate(range(10)):
+    for i in range(10): #[redefined-outer-name]
+        print(i, i_again)
+
+# When inner loop unpacks a tuple
+for i in range(10):
+    for i, i_again in range(10): #[redefined-outer-name]
+        print(i, i_again)
+
+# With nested tuple unpacks
+for (a, (b, c)) in [(1, (2, 3))]:
+    for i, a in range(10): #[redefined-outer-name]
+        print(i, a, b, c)
+
+# Ignores when in else
+for i in range(10):
+    print(i)
+    if i > 5:
+        break
+else:
+    for i in range(2):
+        print(i)
+
+# Ignores dummy variables
+for _ in range(10):
+    for _ in range(10):
+        print("Hello")
diff --git a/tests/functional/reused_outer_loop_variable.txt b/tests/functional/reused_outer_loop_variable.txt
new file mode 100644
index 000000000..1252ac9d6
--- /dev/null
+++ b/tests/functional/reused_outer_loop_variable.txt
@@ -0,0 +1,4 @@
+redefined-outer-name:7::Redefining name 'i' from outer scope (line 6)
+redefined-outer-name:12::Redefining name 'i' from outer scope (line 11)
+redefined-outer-name:17::Redefining name 'i' from outer scope (line 16)
+redefined-outer-name:22::Redefining name 'a' from outer scope (line 21)
diff --git a/tests/functional/reused_outer_loop_variable_py3.py b/tests/functional/reused_outer_loop_variable_py3.py
new file mode 100644
index 000000000..6eaa1f51c
--- /dev/null
+++ b/tests/functional/reused_outer_loop_variable_py3.py
@@ -0,0 +1,5 @@
+"""Python >= 3 tests for redefining an outer loop's variable."""
+
+for i, *j in [(1, 2, 3, 4)]:
+    for j in range(i): #[redefined-outer-name]
+        print(j)
diff --git a/tests/functional/reused_outer_loop_variable_py3.rc b/tests/functional/reused_outer_loop_variable_py3.rc
new file mode 100644
index 000000000..c093be204
--- /dev/null
+++ b/tests/functional/reused_outer_loop_variable_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/reused_outer_loop_variable_py3.txt b/tests/functional/reused_outer_loop_variable_py3.txt
new file mode 100644
index 000000000..ac3a6ead2
--- /dev/null
+++ b/tests/functional/reused_outer_loop_variable_py3.txt
@@ -0,0 +1 @@
+redefined-outer-name:4::Redefining name 'j' from outer scope (line 3)
diff --git a/tests/functional/self_cls_assignment.py b/tests/functional/self_cls_assignment.py
new file mode 100644
index 000000000..4e63bb422
--- /dev/null
+++ b/tests/functional/self_cls_assignment.py
@@ -0,0 +1,47 @@
+"""Warning about assigning self/cls variable."""
+from __future__ import print_function
+# pylint: disable=too-few-public-methods, useless-object-inheritance
+
+class Foo(object):
+    """Class with methods that check for self/cls assignment"""
+
+    # pylint: disable=no-self-argument,no-self-use
+    def self_foo(bar_):
+        """Instance method, should warn for bar"""
+        bar_ = 10  # [self-cls-assignment]
+
+    # pylint: disable=no-self-use
+    def self_foofoo(self, lala):
+        """Instance method, should warn for self"""
+        self = lala  # [self-cls-assignment]
+
+    @classmethod
+    def cls_foo(cls):
+        """Class method, should warn for cls"""
+        cls = 'tada'  # [self-cls-assignment]
+
+    # pylint: disable=unused-argument
+    @staticmethod
+    def static_foo(lala):
+        """Static method, no warnings"""
+        lala = 10
+
+
+# pylint: disable=unused-argument
+def free_foo(bar_, lala):
+    """Free function, no warnings"""
+    bar_ = lala
+
+
+class TestNonLocal:
+    """Test class for nonlocal assignment of self"""
+
+    def function(self, param):
+        """This function uses nonlocal to reassign self"""
+
+        def _set_param(param):
+            nonlocal self
+            self = param  # [self-cls-assignment]
+
+        _set_param(param)
+        return self
diff --git a/tests/functional/self_cls_assignment.txt b/tests/functional/self_cls_assignment.txt
new file mode 100644
index 000000000..42a90340c
--- /dev/null
+++ b/tests/functional/self_cls_assignment.txt
@@ -0,0 +1,4 @@
+self-cls-assignment:11:Foo.self_foo:Invalid assignment to bar_ in method
+self-cls-assignment:16:Foo.self_foofoo:Invalid assignment to self in method
+self-cls-assignment:21:Foo.cls_foo:Invalid assignment to cls in method
+self-cls-assignment:44:TestNonLocal.function._set_param:Invalid assignment to self in method
diff --git a/tests/functional/signature_differs.py b/tests/functional/signature_differs.py
new file mode 100644
index 000000000..920611fd0
--- /dev/null
+++ b/tests/functional/signature_differs.py
@@ -0,0 +1,22 @@
+# pylint: disable=too-few-public-methods, missing-docstring, no-self-use, useless-object-inheritance
+
+class Abcd(object):
+
+    def __init__(self):
+        self.aarg = False
+
+    def abcd(self, aaa=1, bbbb=None):
+        return aaa, bbbb
+
+    def args(self):
+        self.aarg = True
+
+
+class Cdef(Abcd):
+
+    def __init__(self, aaa):
+        Abcd.__init__(self)
+        self.aaa = aaa
+
+    def abcd(self, aaa, bbbb=None): # [signature-differs]
+        return aaa, bbbb
diff --git a/tests/functional/signature_differs.txt b/tests/functional/signature_differs.txt
new file mode 100644
index 000000000..a9985e5fc
--- /dev/null
+++ b/tests/functional/signature_differs.txt
@@ -0,0 +1 @@
+signature-differs:21:Cdef.abcd:Signature differs from overridden 'abcd' method
diff --git a/tests/functional/simplifiable_if_expression.py b/tests/functional/simplifiable_if_expression.py
new file mode 100644
index 000000000..bcfdf890b
--- /dev/null
+++ b/tests/functional/simplifiable_if_expression.py
@@ -0,0 +1,27 @@
+"""Test that some if expressions can be simplified."""
+
+# pylint: disable=missing-docstring, invalid-name
+
+
+def test_simplifiable_1(arg):
+    # Simple test that can be replaced by bool(arg)
+    return True if arg else False # [simplifiable-if-expression]
+
+def test_simplifiable_2(arg):
+    # Simple test that can be replaced by not arg
+    return False if arg else True # [simplifiable-if-expression]
+
+def test_simplifiable_3(arg):
+    # Simple test that can be replaced by arg == 1
+    return True if arg == 1 else False # [simplifiable-if-expression]
+
+def test_simplifiable_4(arg):
+    # Simple test that can be replaced by not (arg == 1)
+    return False if arg == 1 else True # [simplifiable-if-expression]
+
+def test_not_simplifiable(arg):
+    x = True if arg else True
+    y = 0 if arg else 1
+    t = False if arg != 1 else False
+    t2 = None if arg > 3 else False
+    return x, y, t, t2
diff --git a/tests/functional/simplifiable_if_expression.txt b/tests/functional/simplifiable_if_expression.txt
new file mode 100644
index 000000000..b35e08462
--- /dev/null
+++ b/tests/functional/simplifiable_if_expression.txt
@@ -0,0 +1,4 @@
+simplifiable-if-expression:8:test_simplifiable_1:The if expression can be replaced with 'bool(test)'
+simplifiable-if-expression:12:test_simplifiable_2:The if expression can be replaced with 'not test'
+simplifiable-if-expression:16:test_simplifiable_3:The if expression can be replaced with 'test'
+simplifiable-if-expression:20:test_simplifiable_4:The if expression can be replaced with 'not test'
\ No newline at end of file
diff --git a/tests/functional/simplifiable_if_statement.py b/tests/functional/simplifiable_if_statement.py
new file mode 100644
index 000000000..1e36e612c
--- /dev/null
+++ b/tests/functional/simplifiable_if_statement.py
@@ -0,0 +1,146 @@
+"""Test that some if statement tests can be simplified."""

+

+# pylint: disable=missing-docstring, invalid-name, no-else-return

+

+

+def test_simplifiable_1(arg):

+    # Simple test that can be replaced by bool(arg)

+    if arg: # [simplifiable-if-statement]

+        return True

+    else:

+        return False

+

+

+def test_simplifiable_2(arg, arg2):

+    # Can be reduced to bool(arg and not arg2)

+    if arg and not arg2: # [simplifiable-if-statement]

+        return True

+    else:

+        return False

+

+

+def test_simplifiable_3(arg, arg2):

+    # Can be reduced to bool(arg and not arg2)

+    if arg and not arg2: # [simplifiable-if-statement]

+        var = True

+    else:

+        var = False

+    return var

+

+

+def test_simplifiable_4(arg):

+    if arg:

+        var = True

+    else:

+        if arg == "arg1": # [simplifiable-if-statement]

+            return True

+        else:

+            return False

+    return var

+

+

+def test_not_necessarily_simplifiable_1(arg, arg2):

+    # Can be reduced to bool(not arg and not arg2) or to

+    # `not all(N)`, which is a bit harder to understand

+    # than `any(N)` when var should be False.

+    if arg or arg2:

+        var = False

+    else:

+        var = True

+    return var

+

+

+def test_not_necessarily_simplifiabile_2(arg):

+    # This could theoretically be reduced to `not arg or arg > 3`

+    # but the net result is that now the condition is harder to understand,

+    # because it requires understanding of an extra clause:

+    #   * first, there is the negation of truthness with `not arg`

+    #   * the second clause is `arg > 3`, which occurs when arg has a

+    #     a truth value, but it implies that `arg > 3` is equivalent

+    #     with `arg and arg > 3`, which means that the user must

+    #     think about this assumption when evaluating `arg > 3`.

+    #     The original form is easier to grasp.

+    if arg and arg <= 3:

+        return False

+    else:

+        return True

+

+

+def test_not_simplifiable_3(arg):

+    if arg:

+        test_not_necessarily_simplifiabile_2(arg)

+        test_not_necessarily_simplifiable_1(arg, arg)

+        return False

+    else:

+        if arg < 3:

+            test_simplifiable_3(arg, 42)

+        return True

+

+

+def test_not_simplifiable_4(arg):

+    # Not interested in multiple elifs

+    if arg == "any":

+        return True

+    elif test_not_simplifiable_3(arg) == arg:

+        return True

+    else:

+        return False

+

+

+def test_not_simplifiable_5(arg):

+    # Different actions in each branch

+    if arg == "any":

+        return True

+    else:

+        var = 42

+    return var

+

+

+def test_not_simplifiable_6(arg):

+    # Different actions in each branch

+    if arg == "any":

+        var = 42

+    else:

+        return True

+    return var

+

+def test_not_simplifiable_7(arg):

+    # Returning something different

+    if arg == "any":

+        return 4

+    else:

+        return 5

+

+

+def test_not_simplifiable_8(arg):

+    # Only one of the branch returns something boolean

+    if arg == "any":

+        return True

+    else:

+        return 0

+

+

+def test_not_simplifiable_9():

+    # Not the same targets

+    first = True

+    second = 1

+    third = [1]

+    fourth = False

+    fifth = False

+

+    if first and second in third:

+        fourth = True

+    else:

+        fifth = True

+    return fourth + fifth

+

+

+def test_not_simplifiable_10():

+    # Subscripts are not considered

+    object_type = 'read'

+    filter_kwargs = {}

+    if object_type == 'read':

+        filter_kwargs['a'] = True

+    else:

+        filter_kwargs['b'] = True

+    return filter_kwargs

diff --git a/tests/functional/simplifiable_if_statement.txt b/tests/functional/simplifiable_if_statement.txt
new file mode 100644
index 000000000..1c5110908
--- /dev/null
+++ b/tests/functional/simplifiable_if_statement.txt
@@ -0,0 +1,4 @@
+simplifiable-if-statement:8:test_simplifiable_1:The if statement can be replaced with 'return bool(test)'
+simplifiable-if-statement:16:test_simplifiable_2:The if statement can be replaced with 'return bool(test)'
+simplifiable-if-statement:24:test_simplifiable_3:The if statement can be replaced with 'var = bool(test)'
+simplifiable-if-statement:35:test_simplifiable_4:The if statement can be replaced with 'return bool(test)'
diff --git a/tests/functional/simplify_chained_comparison.py b/tests/functional/simplify_chained_comparison.py
new file mode 100644
index 000000000..4be9fbe3d
--- /dev/null
+++ b/tests/functional/simplify_chained_comparison.py
@@ -0,0 +1,89 @@
+"""Test that some boolean expression statement tests can be simplified."""
+
+# pylint: disable=missing-docstring, invalid-name, no-else-return, too-many-branches
+
+
+def test_simplify_chained_comparison_1():
+    a = 1
+    b = 2
+    c = 3
+    return a < b and b < c # [chained-comparison]
+
+
+def test_simplify_chained_comparison_2():
+    a = 1
+    return a < 10 and a > 1 # [chained-comparison]
+
+
+def test_simplify_chained_comparison_3():
+    a = 1
+    b = 2
+    c = 3
+    d = 4
+    if a < 10 and a > 1: # [chained-comparison]
+        pass
+    elif a > 1 and a < 10: # [chained-comparison]
+        pass
+    elif a > 1 and a <= 10: # [chained-comparison]
+        pass
+    elif a > 1 and a < 10 and b == 2: # [chained-comparison]
+        pass
+    elif a > 1 and c == b and a < 10: # [chained-comparison]
+        pass
+    elif a > 100 and c == b and a < 10: # [chained-comparison]
+        # In this comparison we are not checking whether left bound is actually
+        # lower than right bound or not.
+        pass
+    elif a < b and b < c: # [chained-comparison]
+        pass
+    elif a > b and b > c: # [chained-comparison]
+        pass
+    elif a < b and a == 1 and b < c: # [chained-comparison]
+        pass
+    elif a < b and b < c and c == 786: # [chained-comparison]
+        pass
+    elif a < b and b < 0 and c == 786: # [chained-comparison]
+        pass
+    elif a < b and c == 786 and b < 0: # [chained-comparison]
+        pass
+    elif c == 786 and b < 0 and a < b: # [chained-comparison]
+        pass
+    elif a < b < c and c < d: # [chained-comparison]
+        pass
+    elif b < c < d and a < b: # [chained-comparison]
+        pass
+    elif a < b < c and a < b and b < c: # [chained-comparison]
+        pass
+
+
+def test_not_simplify_chained_comparison_1():
+    a = 1
+    b = 2
+    c = 3
+    d = 4
+    if a < 10 and b > 1:
+        pass
+    elif a > 1 and b < 10:
+        pass
+    elif a > 1 and a == 10:
+        pass
+    elif a == 1 and b == 2:
+        pass
+    elif a > 1 and a > 10:
+        pass
+    elif a < 100 and a < 10:
+        pass
+    elif a < b and a < c:
+        pass
+    elif a < b and a == 1 and a < c:
+        pass
+    elif a < b and a < c and c == 786:
+        pass
+    elif a < b < c and b < d:
+        pass
+    elif a < b < c and a < d:
+        pass
+    elif b < c < d and a < c:
+        pass
+    elif b < c < d and a < d:
+        pass
diff --git a/tests/functional/simplify_chained_comparison.txt b/tests/functional/simplify_chained_comparison.txt
new file mode 100644
index 000000000..3107e60cb
--- /dev/null
+++ b/tests/functional/simplify_chained_comparison.txt
@@ -0,0 +1,18 @@
+chained-comparison:10:test_simplify_chained_comparison_1:Simplify chained comparison between the operands
+chained-comparison:15:test_simplify_chained_comparison_2:Simplify chained comparison between the operands
+chained-comparison:23:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:25:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:27:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:29:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:31:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:33:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:37:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:39:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:41:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:43:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:45:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:47:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:49:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:51:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:53:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
+chained-comparison:55:test_simplify_chained_comparison_3:Simplify chained comparison between the operands
diff --git a/tests/functional/singledispatch_functions.py b/tests/functional/singledispatch_functions.py
new file mode 100644
index 000000000..cfd4d873c
--- /dev/null
+++ b/tests/functional/singledispatch_functions.py
@@ -0,0 +1,76 @@
+# pylint: disable=missing-docstring,import-error,unused-import,assignment-from-no-return
+# pylint: disable=invalid-name, too-few-public-methods, useless-object-inheritance
+from __future__ import print_function
+from UNINFERABLE import uninferable_func
+
+try:
+    from functools import singledispatch
+except ImportError:
+    from singledispatch import singledispatch
+
+my_single_dispatch = singledispatch
+
+
+class FakeSingleDispatch(object):
+
+    @staticmethod
+    def register(function):
+        return function
+
+    def __call__(self, function):
+        return function
+
+fake_singledispatch_decorator = FakeSingleDispatch()
+
+@singledispatch
+def func(arg):
+    return arg
+
+
+@func.register(str)
+def _(arg):
+    return 42
+
+
+@func.register(float)
+@func.register(int)
+def _(arg):
+    return 42
+
+
+@my_single_dispatch
+def func2(arg):
+    return arg
+
+
+@func2.register(int)
+def _(arg):
+    return 42
+
+
+@singledispatch
+def with_extra_arg(arg, verbose=False):
+    if verbose:
+        print(arg)
+    return arg
+
+
+@with_extra_arg.register(str)
+def _(arg, verbose=False):
+    unused = 42 # [unused-variable]
+    return arg[::-1]
+
+
+@fake_singledispatch_decorator
+def not_single_dispatch(arg): # [unused-argument]
+    return 'not yet implemented'
+
+
+@fake_singledispatch_decorator.register(str)
+def bad_single_dispatch(arg): # [unused-argument]
+    return 42
+
+
+@fake_singledispatch_decorator.register(str)
+def bad_single_dispatch(arg): # [unused-argument, function-redefined]
+    return 24
diff --git a/tests/functional/singledispatch_functions.rc b/tests/functional/singledispatch_functions.rc
new file mode 100644
index 000000000..fc795dc6d
--- /dev/null
+++ b/tests/functional/singledispatch_functions.rc
@@ -0,0 +1,3 @@
+[testoptions]
+;http://bugs.python.org/issue10445
+max_pyver=3.0
diff --git a/tests/functional/singledispatch_functions.txt b/tests/functional/singledispatch_functions.txt
new file mode 100644
index 000000000..568f41b31
--- /dev/null
+++ b/tests/functional/singledispatch_functions.txt
@@ -0,0 +1,5 @@
+unused-variable:60:_:Unused variable 'unused'
+unused-argument:65:not_single_dispatch:Unused argument 'arg'
+unused-argument:70:bad_single_dispatch:Unused argument 'arg'
+function-redefined:75:bad_single_dispatch:function already defined line 70
+unused-argument:75:bad_single_dispatch:Unused argument 'arg'
\ No newline at end of file
diff --git a/tests/functional/singledispatch_functions_py3.py b/tests/functional/singledispatch_functions_py3.py
new file mode 100644
index 000000000..cfd4d873c
--- /dev/null
+++ b/tests/functional/singledispatch_functions_py3.py
@@ -0,0 +1,76 @@
+# pylint: disable=missing-docstring,import-error,unused-import,assignment-from-no-return
+# pylint: disable=invalid-name, too-few-public-methods, useless-object-inheritance
+from __future__ import print_function
+from UNINFERABLE import uninferable_func
+
+try:
+    from functools import singledispatch
+except ImportError:
+    from singledispatch import singledispatch
+
+my_single_dispatch = singledispatch
+
+
+class FakeSingleDispatch(object):
+
+    @staticmethod
+    def register(function):
+        return function
+
+    def __call__(self, function):
+        return function
+
+fake_singledispatch_decorator = FakeSingleDispatch()
+
+@singledispatch
+def func(arg):
+    return arg
+
+
+@func.register(str)
+def _(arg):
+    return 42
+
+
+@func.register(float)
+@func.register(int)
+def _(arg):
+    return 42
+
+
+@my_single_dispatch
+def func2(arg):
+    return arg
+
+
+@func2.register(int)
+def _(arg):
+    return 42
+
+
+@singledispatch
+def with_extra_arg(arg, verbose=False):
+    if verbose:
+        print(arg)
+    return arg
+
+
+@with_extra_arg.register(str)
+def _(arg, verbose=False):
+    unused = 42 # [unused-variable]
+    return arg[::-1]
+
+
+@fake_singledispatch_decorator
+def not_single_dispatch(arg): # [unused-argument]
+    return 'not yet implemented'
+
+
+@fake_singledispatch_decorator.register(str)
+def bad_single_dispatch(arg): # [unused-argument]
+    return 42
+
+
+@fake_singledispatch_decorator.register(str)
+def bad_single_dispatch(arg): # [unused-argument, function-redefined]
+    return 24
diff --git a/tests/functional/singledispatch_functions_py3.rc b/tests/functional/singledispatch_functions_py3.rc
new file mode 100644
index 000000000..d43f6c339
--- /dev/null
+++ b/tests/functional/singledispatch_functions_py3.rc
@@ -0,0 +1,3 @@
+[testoptions]
+;http://bugs.python.org/issue10445
+min_pyver=3.4
diff --git a/tests/functional/singledispatch_functions_py3.txt b/tests/functional/singledispatch_functions_py3.txt
new file mode 100644
index 000000000..568f41b31
--- /dev/null
+++ b/tests/functional/singledispatch_functions_py3.txt
@@ -0,0 +1,5 @@
+unused-variable:60:_:Unused variable 'unused'
+unused-argument:65:not_single_dispatch:Unused argument 'arg'
+unused-argument:70:bad_single_dispatch:Unused argument 'arg'
+function-redefined:75:bad_single_dispatch:function already defined line 70
+unused-argument:75:bad_single_dispatch:Unused argument 'arg'
\ No newline at end of file
diff --git a/tests/functional/singleton_comparison.py b/tests/functional/singleton_comparison.py
new file mode 100644
index 000000000..9a28c0e2e
--- /dev/null
+++ b/tests/functional/singleton_comparison.py
@@ -0,0 +1,15 @@
+# pylint: disable=missing-docstring, invalid-name, misplaced-comparison-constant,literal-comparison, comparison-with-itself
+x = 42
+a = x is None
+b = x == None  # [singleton-comparison]
+c = x == True  # [singleton-comparison]
+d = x == False  # [singleton-comparison]
+e = True == True  # [singleton-comparison]
+f = x is 1
+g = 123 is "123"
+h = None is x
+i = None == x  # [singleton-comparison]
+
+j = x != True  # [singleton-comparison]
+j1 = x != False  # [singleton-comparison]
+j2 = x != None # [singleton-comparison]
diff --git a/tests/functional/singleton_comparison.txt b/tests/functional/singleton_comparison.txt
new file mode 100644
index 000000000..533d71f63
--- /dev/null
+++ b/tests/functional/singleton_comparison.txt
@@ -0,0 +1,8 @@
+singleton-comparison:4::Comparison to None should be 'expr is None'
+singleton-comparison:5::Comparison to True should be just 'expr'
+singleton-comparison:6::Comparison to False should be 'not expr'
+singleton-comparison:7::Comparison to True should be just 'expr'
+singleton-comparison:11::Comparison to None should be 'expr is None'
+singleton-comparison:13::Comparison to True should be just 'not expr'
+singleton-comparison:14::Comparison to False should be 'expr'
+singleton-comparison:15::Comparison to None should be 'expr is not None'
diff --git a/tests/functional/slots_checks.py b/tests/functional/slots_checks.py
new file mode 100644
index 000000000..64a439f33
--- /dev/null
+++ b/tests/functional/slots_checks.py
@@ -0,0 +1,105 @@
+""" Checks that classes uses valid __slots__ """
+
+# pylint: disable=too-few-public-methods, missing-docstring, no-absolute-import, useless-object-inheritance
+# pylint: disable=using-constant-test, wrong-import-position, no-else-return, line-too-long
+from collections import deque
+
+def func():
+    if True:
+        return ("a", "b", "c")
+    else:
+        return [str(var) for var in range(3)]
+
+
+class NotIterable(object):
+    def __iter_(self):
+        """ do nothing """
+
+class Good(object):
+    __slots__ = ()
+
+class SecondGood(object):
+    __slots__ = []
+
+class ThirdGood(object):
+    __slots__ = ['a']
+
+class FourthGood(object):
+    __slots__ = ('a%s' % i for i in range(10))
+
+class FifthGood(object):
+    __slots__ = deque(["a", "b", "c"])
+
+class SixthGood(object):
+    __slots__ = {"a": "b", "c": "d"}
+
+class Bad(object): # [invalid-slots]
+    __slots__ = list
+
+class SecondBad(object):  # [invalid-slots]
+    __slots__ = 1
+
+class ThirdBad(object):
+    __slots__ = ('a', 2)  # [invalid-slots-object]
+
+class FourthBad(object):  # [invalid-slots]
+    __slots__ = NotIterable()
+
+class FifthBad(object):
+    __slots__ = ("a", "b", "")  # [invalid-slots-object]
+
+class SixthBad(object):  # [single-string-used-for-slots]
+    __slots__ = "a"
+
+class SeventhBad(object):  # [single-string-used-for-slots]
+    __slots__ = ('foo')
+
+class EighthBad(object):  # [single-string-used-for-slots]
+    __slots__ = deque.__name__
+
+class PotentiallyGood(object):
+    __slots__ = func()
+
+class PotentiallySecondGood(object):
+    __slots__ = ('a', deque.__name__)
+
+
+import six
+
+
+class Metaclass(type):
+
+    def __iter__(cls):
+        for value in range(10):
+            yield str(value)
+
+
+@six.add_metaclass(Metaclass)
+class IterableClass(object):
+    pass
+
+class PotentiallyThirdGood(object):
+    __slots__ = IterableClass
+
+class PotentiallyFourthGood(object):
+    __slots__ = Good.__slots__
+
+
+class ValueInSlotConflict(object):
+    __slots__ = ('first', 'second', 'third', 'fourth') # [class-variable-slots-conflict, class-variable-slots-conflict, class-variable-slots-conflict]
+    first = None
+
+    @property
+    def third(self):
+        return 42
+
+    def fourth(self):
+        return self.third
+
+
+class Parent(object):
+    first = 42
+
+
+class ChildNotAffectedByValueInSlot(Parent):
+    __slots__ = ('first', )
diff --git a/tests/functional/slots_checks.txt b/tests/functional/slots_checks.txt
new file mode 100644
index 000000000..b3d71afcc
--- /dev/null
+++ b/tests/functional/slots_checks.txt
@@ -0,0 +1,11 @@
+invalid-slots:36:Bad:Invalid __slots__ object
+invalid-slots:39:SecondBad:Invalid __slots__ object
+invalid-slots-object:43:ThirdBad:Invalid object '2' in __slots__, must contain only non empty strings
+invalid-slots:45:FourthBad:Invalid __slots__ object
+invalid-slots-object:49:FifthBad:"Invalid object ""''"" in __slots__, must contain only non empty strings"
+single-string-used-for-slots:51:SixthBad:Class __slots__ should be a non-string iterable
+single-string-used-for-slots:54:SeventhBad:Class __slots__ should be a non-string iterable
+single-string-used-for-slots:57:EighthBad:Class __slots__ should be a non-string iterable
+class-variable-slots-conflict:89:ValueInSlotConflict:Value 'first' in slots conflicts with class variable
+class-variable-slots-conflict:89:ValueInSlotConflict:Value 'fourth' in slots conflicts with class variable
+class-variable-slots-conflict:89:ValueInSlotConflict:Value 'third' in slots conflicts with class variable
diff --git a/tests/functional/socketerror_import.py b/tests/functional/socketerror_import.py
new file mode 100644
index 000000000..df5de2957
--- /dev/null
+++ b/tests/functional/socketerror_import.py
@@ -0,0 +1,6 @@
+"""ds"""
+from __future__ import absolute_import, print_function
+from socket import error
+__revision__ = '$Id: socketerror_import.py,v 1.2 2005-12-28 14:58:22 syt Exp $'
+
+print(error)
diff --git a/tests/functional/star_needs_assignment_target.py b/tests/functional/star_needs_assignment_target.py
new file mode 100644
index 000000000..5421c226b
--- /dev/null
+++ b/tests/functional/star_needs_assignment_target.py
@@ -0,0 +1,4 @@
+"""Test for a = *b"""

+

+FIRST = *[1, 2]  # [star-needs-assignment-target]

+*THIRD, FOURTH = [1, 2, 3,]

diff --git a/tests/functional/star_needs_assignment_target.rc b/tests/functional/star_needs_assignment_target.rc
new file mode 100644
index 000000000..c093be204
--- /dev/null
+++ b/tests/functional/star_needs_assignment_target.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/star_needs_assignment_target.txt b/tests/functional/star_needs_assignment_target.txt
new file mode 100644
index 000000000..b66975c97
--- /dev/null
+++ b/tests/functional/star_needs_assignment_target.txt
@@ -0,0 +1 @@
+star-needs-assignment-target:3::Can use starred expression only in assignment target

diff --git a/tests/functional/star_needs_assignment_target_py35.py b/tests/functional/star_needs_assignment_target_py35.py
new file mode 100644
index 000000000..58e43dbac
--- /dev/null
+++ b/tests/functional/star_needs_assignment_target_py35.py
@@ -0,0 +1,15 @@
+"""
+Test PEP 0448 -- Additional Unpacking Generalizations
+https://www.python.org/dev/peps/pep-0448/
+"""
+
+# pylint: disable=superfluous-parens
+
+UNPACK_TUPLE = (*range(4), 4)
+UNPACK_LIST = [*range(4), 4]
+UNPACK_SET = {*range(4), 4}
+UNPACK_DICT = {'a': 1, **{'b': '2'}}
+UNPACK_DICT2 = {**UNPACK_DICT, "x": 1, "y": 2}
+UNPACK_DICT3 = {**{'a': 1}, 'a': 2, **{'a': 3}}
+
+UNPACK_IN_COMP = {elem for elem in (*range(10))} # [star-needs-assignment-target]
diff --git a/tests/functional/star_needs_assignment_target_py35.rc b/tests/functional/star_needs_assignment_target_py35.rc
new file mode 100644
index 000000000..71de8b630
--- /dev/null
+++ b/tests/functional/star_needs_assignment_target_py35.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5
diff --git a/tests/functional/star_needs_assignment_target_py35.txt b/tests/functional/star_needs_assignment_target_py35.txt
new file mode 100644
index 000000000..07770523b
--- /dev/null
+++ b/tests/functional/star_needs_assignment_target_py35.txt
@@ -0,0 +1 @@
+star-needs-assignment-target:15::Can use starred expression only in assignment target
\ No newline at end of file
diff --git a/tests/functional/statement_without_effect.py b/tests/functional/statement_without_effect.py
new file mode 100644
index 000000000..c8394b45e
--- /dev/null
+++ b/tests/functional/statement_without_effect.py
@@ -0,0 +1,75 @@
+"""Test for statements without effects."""
+# pylint: disable=too-few-public-methods, useless-object-inheritance
+
+# +1:[pointless-string-statement]
+"""inline doc string should use a separated message"""
+
+__revision__ = ''
+
+__revision__  # [pointless-statement]
+
+__revision__ <= 1  # [pointless-statement]
+
+__revision__.lower()
+
+[i for i in __revision__]  # [pointless-statement]
+
+# +1:[pointless-string-statement]
+"""inline doc string should use a separated message"""
+
+
+__revision__.lower();  # [unnecessary-semicolon]
+
+list() and tuple()  # [expression-not-assigned]
+
+def to_be():
+    """return 42"""
+    return "42"
+
+ANSWER = to_be() # ok
+ANSWER == to_be()  # [expression-not-assigned]
+
+to_be() or not to_be()  # [expression-not-assigned]
+to_be().title  # [expression-not-assigned]
+
+GOOD_ATTRIBUTE_DOCSTRING = 42
+"""Module level attribute docstring is fine. """
+
+class ClassLevelAttributeTest(object):
+    """ test attribute docstrings. """
+
+    good_attribute_docstring = 24
+    """ class level attribute docstring is fine either. """
+    second_good_attribute_docstring = 42
+    # Comments are good.
+
+    # empty lines are good, too.
+    """ Still a valid class level attribute docstring. """
+
+    def __init__(self):
+        self.attr = 42
+        """ Good attribute docstring """
+        attr = 24
+        """ Still a good __init__ level attribute docstring. """
+        val = 0
+        for val in range(42):
+            val += attr
+        # +1:[pointless-string-statement]
+        """ Invalid attribute docstring """
+        self.val = val
+
+    def test(self):
+        """ invalid attribute docstrings here. """
+        self.val = 42
+        # +1:[pointless-string-statement]
+        """ this is an invalid attribute docstring. """
+
+
+def ellipsis():
+    """Test that an Ellipsis as a body does not trigger the error"""
+    ...
+
+
+class EllipsisBody:
+    """Test that an Ellipsis as a body does not trigger the error"""
+    ...
diff --git a/tests/functional/statement_without_effect.txt b/tests/functional/statement_without_effect.txt
new file mode 100644
index 000000000..bda6eaea9
--- /dev/null
+++ b/tests/functional/statement_without_effect.txt
@@ -0,0 +1,60 @@
+pointless-string-statement:5::String statement has no effect
+pointless-statement:6::"""Statement seems to have no effect
+""
+"
+pointless-statement:8::"""Statement seems to have no effect
+""
+"
+pointless-statement:9::Statement seems to have no effect
+pointless-statement:11::Statement seems to have no effect
+pointless-statement:12::"""Statement seems to have no effect
+""
+"
+pointless-statement:15::Statement seems to have no effect
+pointless-string-statement:15::"""String statement has no effect
+""
+"
+unnecessary-semicolon:17::"""Unnecessary semicolon
+""
+"
+pointless-string-statement:18::String statement has no effect
+unnecessary-semicolon:18::"""Unnecessary semicolon
+""
+"
+expression-not-assigned:19::"""Expression """"list() and tuple()"""" is assigned to nothing
+""
+"
+expression-not-assigned:20::"""Expression """"list() and tuple()"""" is assigned to nothing
+""
+"
+unnecessary-semicolon:21::Unnecessary semicolon
+expression-not-assigned:23::"Expression ""list() and tuple()"" is assigned to nothing"
+expression-not-assigned:26::"""Expression """"ANSWER == to_be()"""" is assigned to nothing
+""
+"
+expression-not-assigned:27::"""Expression """"ANSWER == to_be()"""" is assigned to nothing
+""
+"
+expression-not-assigned:28::"""Expression """"to_be() or not to_be()"""" is assigned to nothing
+""
+"
+expression-not-assigned:29::"""Expression """"to_be() or not to_be()"""" is assigned to nothing
+""
+"
+expression-not-assigned:30::"Expression ""ANSWER == to_be()"" is assigned to nothing"
+expression-not-assigned:32::"Expression ""to_be() or not to_be()"" is assigned to nothing"
+expression-not-assigned:33::"Expression ""to_be().title"" is assigned to nothing"
+pointless-string-statement:54:ClassLevelAttributeTest.__init__:"""String statement has no effect
+""
+"
+pointless-string-statement:55:ClassLevelAttributeTest.__init__:"""String statement has no effect
+""
+"
+pointless-string-statement:58:ClassLevelAttributeTest.__init__:String statement has no effect
+pointless-string-statement:61:ClassLevelAttributeTest.test:"""String statement has no effect
+""
+"
+pointless-string-statement:62:ClassLevelAttributeTest.test:"""String statement has no effect
+""
+"
+pointless-string-statement:65:ClassLevelAttributeTest.test:String statement has no effect
diff --git a/tests/functional/statement_without_effect_py36.py b/tests/functional/statement_without_effect_py36.py
new file mode 100644
index 000000000..59745ce2b
--- /dev/null
+++ b/tests/functional/statement_without_effect_py36.py
@@ -0,0 +1,18 @@
+"""Test for statements without effects."""
+# pylint: disable=too-few-public-methods, useless-object-inheritance
+
+
+class ClassLevelAttributeTest(object):
+    """ test attribute docstrings. """
+
+    some_variable: int = 42
+    """Data docstring"""
+
+    some_other_variable: int = 42
+    """Data docstring"""
+
+    def func(self):
+        """Some Empty Docstring"""
+
+    # +1: [pointless-string-statement]
+    """useless"""
diff --git a/tests/functional/statement_without_effect_py36.rc b/tests/functional/statement_without_effect_py36.rc
new file mode 100644
index 000000000..0ba2b6333
--- /dev/null
+++ b/tests/functional/statement_without_effect_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/statement_without_effect_py36.txt b/tests/functional/statement_without_effect_py36.txt
new file mode 100644
index 000000000..6b782923b
--- /dev/null
+++ b/tests/functional/statement_without_effect_py36.txt
@@ -0,0 +1 @@
+pointless-string-statement:18:ClassLevelAttributeTest:String statement has no effect
\ No newline at end of file
diff --git a/tests/functional/stop_iteration_inside_generator.py b/tests/functional/stop_iteration_inside_generator.py
new file mode 100644
index 000000000..a51f2d3e7
--- /dev/null
+++ b/tests/functional/stop_iteration_inside_generator.py
@@ -0,0 +1,129 @@
+"""
+Test that no StopIteration is raised inside a generator
+"""
+# pylint: disable=missing-docstring,invalid-name,import-error, try-except-raise, wrong-import-position
+import asyncio
+
+class RebornStopIteration(StopIteration):
+    """
+    A class inheriting from StopIteration exception
+    """
+
+# This one is ok
+def gen_ok():
+    yield 1
+    yield 2
+    yield 3
+
+# pylint should warn about this one
+# because of a direct raising of StopIteration inside generator
+def gen_stopiter():
+    yield 1
+    yield 2
+    yield 3
+    raise StopIteration  # [stop-iteration-return]
+
+# pylint should warn about this one
+# because of a direct raising of an exception inheriting from StopIteration inside generator
+def gen_stopiterchild():
+    yield 1
+    yield 2
+    yield 3
+    raise RebornStopIteration  # [stop-iteration-return]
+
+# pylint should warn here
+# because of the possibility that next raises a StopIteration exception
+def gen_next_raises_stopiter():
+    g = gen_ok()
+    while True:
+        yield next(g)  # [stop-iteration-return]
+
+# This one is the same as gen_next_raises_stopiter
+# but is ok because the next function is inside
+# a try/except block handling StopIteration
+def gen_next_inside_try_except():
+    g = gen_ok()
+    while True:
+        try:
+            yield next(g)
+        except StopIteration:
+            return
+
+# This one is the same as gen_next_inside_try_except
+# but is not ok because the next function is inside
+# a try/except block that don't handle StopIteration
+def gen_next_inside_wrong_try_except():
+    g = gen_ok()
+    while True:
+        try:
+            yield next(g)  # [stop-iteration-return]
+        except ValueError:
+            return
+
+# This one is the same as gen_next_inside_try_except
+# but is not ok because the next function is inside
+# a try/except block that handle StopIteration but reraise it
+def gen_next_inside_wrong_try_except2():
+    g = gen_ok()
+    while True:
+        try:
+            yield next(g)
+        except StopIteration:
+            raise StopIteration  # [stop-iteration-return]
+
+# Those two last are ok
+def gen_in_for():
+    for el in gen_ok():
+        yield el
+
+def gen_yield_from():
+    yield from gen_ok()
+
+
+def gen_dont_crash_on_no_exception():
+    g = gen_ok()
+    while True:
+        try:
+            yield next(g) # [stop-iteration-return]
+        except ValueError:
+            raise
+
+
+def gen_dont_crash_on_uninferable():
+    # https://github.com/PyCQA/pylint/issues/1779
+    yield from iter()
+    raise asyncio.TimeoutError()
+
+
+# https://github.com/PyCQA/pylint/issues/1830
+def gen_next_with_sentinel():
+    yield next([], 42) # No bad return
+
+
+from itertools import count
+
+# https://github.com/PyCQA/pylint/issues/2158
+def generator_using_next():
+    counter = count()
+    number = next(counter)
+    yield number * 2
+
+
+# pylint: disable=no-self-use,too-few-public-methods
+class SomeClassWithNext:
+    def next(self):
+        return iter([1, 2, 3])
+    def some_gen(self):
+        for value in self.next():
+            yield value
+
+
+SomeClassWithNext().some_gen()
+
+
+def something_invalid():
+    raise Exception('cannot iterate this')
+
+
+def invalid_object_passed_to_next():
+    yield next(something_invalid()) # [stop-iteration-return]
diff --git a/tests/functional/stop_iteration_inside_generator.rc b/tests/functional/stop_iteration_inside_generator.rc
new file mode 100644
index 000000000..c093be204
--- /dev/null
+++ b/tests/functional/stop_iteration_inside_generator.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/stop_iteration_inside_generator.txt b/tests/functional/stop_iteration_inside_generator.txt
new file mode 100644
index 000000000..107d563b6
--- /dev/null
+++ b/tests/functional/stop_iteration_inside_generator.txt
@@ -0,0 +1,7 @@
+stop-iteration-return:24:gen_stopiter:Do not raise StopIteration in generator, use return statement instead
+stop-iteration-return:32:gen_stopiterchild:Do not raise StopIteration in generator, use return statement instead
+stop-iteration-return:39:gen_next_raises_stopiter:Do not raise StopIteration in generator, use return statement instead
+stop-iteration-return:59:gen_next_inside_wrong_try_except:Do not raise StopIteration in generator, use return statement instead
+stop-iteration-return:72:gen_next_inside_wrong_try_except2:Do not raise StopIteration in generator, use return statement instead
+stop-iteration-return:87:gen_dont_crash_on_no_exception:Do not raise StopIteration in generator, use return statement instead
+stop-iteration-return:129:invalid_object_passed_to_next:Do not raise StopIteration in generator, use return statement instead
diff --git a/tests/functional/string_formatting.py b/tests/functional/string_formatting.py
new file mode 100644
index 000000000..7e60d9fd9
--- /dev/null
+++ b/tests/functional/string_formatting.py
@@ -0,0 +1,188 @@
+"""test for Python 3 string formatting error

+"""

+# pylint: disable=too-few-public-methods, import-error, unused-argument, line-too-long, no-absolute-import, useless-object-inheritance

+import os

+from missing import Missing

+

+__revision__ = 1

+

+class Custom(object):

+    """ Has a __getattr__ """

+    def __getattr__(self, _):

+        return self

+

+class Test(object):

+    """ test format attribute access """

+    custom = Custom()

+    ids = [1, 2, 3, [4, 5, 6]]

+

+class Getitem(object):

+    """ test custom getitem for lookup access """

+    def __getitem__(self, index):

+        return 42

+

+class ReturnYes(object):

+    """ can't be properly infered """

+    missing = Missing()

+

+def log(message, message_type="error"):

+    """ Test """

+    return message

+

+def print_good():

+    """ Good format strings """

+    "{0} {1}".format(1, 2)

+    "{0!r:20}".format("Hello")

+    "{!r:20}".format("Hello")

+    "{a!r:20}".format(a="Hello")

+    "{pid}".format(pid=os.getpid())

+    str("{}").format(2)

+    "{0.missing.length}".format(ReturnYes())

+    "{1.missing.length}".format(ReturnYes())

+    "{a.ids[3][1]}".format(a=Test())

+    "{a[0][0]}".format(a=[[1]])

+    "{[0][0]}".format({0: {0: 1}})

+    "{a.test}".format(a=Custom())

+    "{a.__len__}".format(a=[])

+    "{a.ids.__len__}".format(a=Test())

+    "{a[0]}".format(a=Getitem())

+    "{a[0][0]}".format(a=[Getitem()])

+    "{[0][0]}".format(["test"])

+    # these are skipped

+    "{0} {1}".format(*[1, 2])

+    "{a} {b}".format(**{'a': 1, 'b': 2})

+    "{a}".format(a=Missing())

+

+def pprint_bad():

+    """Test string format """

+    "{{}}".format(1) # [too-many-format-args]

+    "{} {".format() # [bad-format-string]

+    "{} }".format() # [bad-format-string]

+    "{0} {}".format(1, 2) # [format-combined-specification]

+    # +1: [missing-format-argument-key, unused-format-string-argument]

+    "{a} {b}".format(a=1, c=2)

+    "{} {a}".format(1, 2) # [missing-format-argument-key]

+    "{} {}".format(1) # [too-few-format-args]

+    "{} {}".format(1, 2, 3) # [too-many-format-args]

+    # +1: [missing-format-argument-key,missing-format-argument-key,missing-format-argument-key]

+    "{a} {b} {c}".format()

+    "{} {}".format(a=1, b=2) # [too-few-format-args]

+    # +1: [missing-format-argument-key, missing-format-argument-key]

+    "{a} {b}".format(1, 2)

+    "{0} {1} {a}".format(1, 2, 3) # [missing-format-argument-key]

+    # +1: [missing-format-attribute]

+    "{a.ids.__len__.length}".format(a=Test())

+    "{a.ids[3][400]}".format(a=Test()) # [invalid-format-index]

+    "{a.ids[3]['string']}".format(a=Test()) # [invalid-format-index]

+    "{[0][1]}".format(["a"]) # [invalid-format-index]

+    "{[0][0]}".format(((1, ))) # [invalid-format-index]

+    # +1: [missing-format-argument-key, unused-format-string-argument]

+    "{b[0]}".format(a=23)

+    "{a[0]}".format(a=object) # [invalid-format-index]

+    log("{}".format(2, "info")) # [too-many-format-args]

+    "{0.missing}".format(2) # [missing-format-attribute]

+    "{0} {1} {2}".format(1, 2) # [too-few-format-args]

+    "{0} {1}".format(1, 2, 3) # [too-many-format-args]

+    "{0} {a}".format(a=4) # [too-few-format-args]

+    "{[0]} {}".format([4]) # [too-few-format-args]

+    "{[0]} {}".format([4], 5, 6) # [too-many-format-args]

+

+def good_issue288(*args, **kwargs):

+    """ Test that using kwargs does not emit a false

+    positive.

+    """

+    'Hello John Doe {0[0]}'.format(args)

+    'Hello {0[name]}'.format(kwargs)

+

+def good_issue287():

+    """ Test that the string format checker skips

+    format nodes which don't have a string as a parent

+    (but a subscript, name etc).

+    """

+    name = 'qwerty'

+    ret = {'comment': ''}

+    ret['comment'] = 'MySQL grant {0} is set to be revoked'

+    ret['comment'] = ret['comment'].format(name)

+    return ret, name

+

+def nested_issue294():

+    """ Test nested format fields. """

+    '{0:>{1}}'.format(42, 24)

+    '{0:{a[1]}} {a}'.format(1, a=[1, 2])

+    '{:>{}}'.format(42, 24)

+    '{0:>{1}}'.format(42) # [too-few-format-args]

+    '{0:>{1}}'.format(42, 24, 54) # [too-many-format-args]

+    '{0:{a[1]}}'.format(1) # [missing-format-argument-key]

+    '{0:{a.x}}'.format(1, a=2) # [missing-format-attribute]

+

+def issue310():

+    """ Test a regression using duplicate manual position arguments. """

+    '{0} {1} {0}'.format(1, 2)

+    '{0} {1} {0}'.format(1) # [too-few-format-args]

+

+def issue322():

+    """ Test a regression using mixed manual position arguments

+    and attribute access arguments.

+    """

+    '{0}{1[FOO]}'.format(123, {'FOO': 456})

+    '{0}{1[FOO]}'.format(123, {'FOO': 456}, 321) # [too-many-format-args]

+    '{0}{1[FOO]}'.format(123) # [too-few-format-args]

+

+def issue338():

+    """

+    Check that using a namedtuple subclass doesn't crash when

+    trying to infer EmptyNodes (resulted after mocking the

+    members of namedtuples).

+    """

+    from collections import namedtuple

+

+    class Crash(namedtuple("C", "foo bar")):

+        """ Looking for attributes in __str__ will crash,

+        because EmptyNodes can't be infered.

+        """

+        def __str__(self):

+            return "{0.foo}: {0.bar}".format(self)

+    return Crash

+

+def issue351():

+    """

+    Check that the format method can be assigned to a variable, ie:

+    """

+    fmt = 'test {} {}'.format

+    fmt('arg1') # [too-few-format-args]

+    fmt('arg1', 'arg2')

+    fmt('arg1', 'arg2', 'arg3') # [too-many-format-args]

+

+def issue373():

+    """

+    Ignore any object coming from an argument.

+    """

+    class SomeClass(object):

+        """ empty docstring. """

+        def __init__(self, opts=None):

+            self.opts = opts

+

+        def dunc(self, arg):

+            """Don't try to analyze this."""

+            return "A{0}{1}".format(arg, self.opts)

+

+        def func(self):

+            """Don't try to analyze the following string."""

+            return 'AAA{0[iface]}BBB{0[port]}'.format(self.opts)

+

+    return SomeClass

+

+def issue_463():

+    """

+    Mix positional arguments, `{0}`, with positional

+    arguments with attribute access, `{0.__x__}`.

+    """

+    data = "{0.__class__.__name__}: {0}".format(42)

+    data2 = "{0[0]}: {0}".format([1])

+    return (data, data2)

+

+

+def avoid_empty_attribute():

+    """The following string is invalid, avoid crashing."""

+

+    return "There are {.:2f} undiscovered errors.".format(1) # [bad-format-string]

diff --git a/tests/functional/string_formatting.txt b/tests/functional/string_formatting.txt
new file mode 100644
index 000000000..9801de1a7
--- /dev/null
+++ b/tests/functional/string_formatting.txt
@@ -0,0 +1,41 @@
+too-many-format-args:58:pprint_bad:Too many arguments for format string
+bad-format-string:59:pprint_bad:Invalid format string
+bad-format-string:60:pprint_bad:Invalid format string
+format-combined-specification:61:pprint_bad:Format string contains both automatic field numbering and manual field specification
+missing-format-argument-key:63:pprint_bad:Missing keyword argument 'b' for format string
+unused-format-string-argument:63:pprint_bad:Unused format argument 'c'
+missing-format-argument-key:64:pprint_bad:Missing keyword argument 'a' for format string
+too-few-format-args:65:pprint_bad:Not enough arguments for format string
+too-many-format-args:66:pprint_bad:Too many arguments for format string
+missing-format-argument-key:68:pprint_bad:Missing keyword argument 'a' for format string
+missing-format-argument-key:68:pprint_bad:Missing keyword argument 'b' for format string
+missing-format-argument-key:68:pprint_bad:Missing keyword argument 'c' for format string
+too-few-format-args:69:pprint_bad:Not enough arguments for format string
+missing-format-argument-key:71:pprint_bad:Missing keyword argument 'a' for format string
+missing-format-argument-key:71:pprint_bad:Missing keyword argument 'b' for format string
+missing-format-argument-key:72:pprint_bad:Missing keyword argument 'a' for format string
+missing-format-attribute:74:pprint_bad:Missing format attribute 'length' in format specifier 'a.ids.__len__.length'
+invalid-format-index:75:pprint_bad:Using invalid lookup key 400 in format specifier 'a.ids[3][400]'
+invalid-format-index:76:pprint_bad:"Using invalid lookup key ""'string'"" in format specifier 'a.ids[3][""\'string\'""]'"
+invalid-format-index:77:pprint_bad:Using invalid lookup key 1 in format specifier '0[0][1]'
+invalid-format-index:78:pprint_bad:Using invalid lookup key 0 in format specifier '0[0][0]'
+missing-format-argument-key:80:pprint_bad:Missing keyword argument 'b' for format string
+unused-format-string-argument:80:pprint_bad:Unused format argument 'a'
+invalid-format-index:81:pprint_bad:Using invalid lookup key 0 in format specifier 'a[0]'
+too-many-format-args:82:pprint_bad:Too many arguments for format string
+missing-format-attribute:83:pprint_bad:Missing format attribute 'missing' in format specifier '0.missing'
+too-few-format-args:84:pprint_bad:Not enough arguments for format string
+too-many-format-args:85:pprint_bad:Too many arguments for format string
+too-few-format-args:86:pprint_bad:Not enough arguments for format string
+too-few-format-args:87:pprint_bad:Not enough arguments for format string
+too-many-format-args:88:pprint_bad:Too many arguments for format string
+too-few-format-args:113:nested_issue294:Not enough arguments for format string
+too-many-format-args:114:nested_issue294:Too many arguments for format string
+missing-format-argument-key:115:nested_issue294:Missing keyword argument 'a' for format string
+missing-format-attribute:116:nested_issue294:Missing format attribute 'x' in format specifier 'a.x'
+too-few-format-args:121:issue310:Not enough arguments for format string
+too-many-format-args:128:issue322:Too many arguments for format string
+too-few-format-args:129:issue322:Not enough arguments for format string
+too-few-format-args:152:issue351:Not enough arguments for format string
+too-many-format-args:154:issue351:Too many arguments for format string
+bad-format-string:188:avoid_empty_attribute:Invalid format string
\ No newline at end of file
diff --git a/tests/functional/string_formatting_disable.py b/tests/functional/string_formatting_disable.py
new file mode 100644
index 000000000..096c84734
--- /dev/null
+++ b/tests/functional/string_formatting_disable.py
@@ -0,0 +1 @@
+"a {} {".format(1) # [bad-format-string]
\ No newline at end of file
diff --git a/tests/functional/string_formatting_disable.rc b/tests/functional/string_formatting_disable.rc
new file mode 100644
index 000000000..0193339de
--- /dev/null
+++ b/tests/functional/string_formatting_disable.rc
@@ -0,0 +1,3 @@
+[Messages Control]
+disable=all
+enable=bad-format-string
diff --git a/tests/functional/string_formatting_disable.txt b/tests/functional/string_formatting_disable.txt
new file mode 100644
index 000000000..2c8f6db59
--- /dev/null
+++ b/tests/functional/string_formatting_disable.txt
@@ -0,0 +1 @@
+bad-format-string:1::Invalid format string
\ No newline at end of file
diff --git a/tests/functional/string_formatting_failed_inference.py b/tests/functional/string_formatting_failed_inference.py
new file mode 100644
index 000000000..c5add58c8
--- /dev/null
+++ b/tests/functional/string_formatting_failed_inference.py
@@ -0,0 +1,4 @@
+""" Testing string format with a failed inference. This should not crash. """
+# pylint: disable=using-constant-test
+import collections
+"{dict[0]}".format(dict=collections.defaultdict(int))
diff --git a/tests/functional/string_formatting_failed_inference_py35.py b/tests/functional/string_formatting_failed_inference_py35.py
new file mode 100644
index 000000000..a511ff80e
--- /dev/null
+++ b/tests/functional/string_formatting_failed_inference_py35.py
@@ -0,0 +1,6 @@
+""" Testing string format with a failed inference. This should not crash. """
+# pylint: disable=using-constant-test
+import collections
+"{dict[0]}".format(dict=collections.defaultdict(int))
+
+COMMENT = "message %s %s %s" % (0, *(1 if "cond" else 2,) * 2)
diff --git a/tests/functional/string_formatting_failed_inference_py35.rc b/tests/functional/string_formatting_failed_inference_py35.rc
new file mode 100644
index 000000000..71de8b630
--- /dev/null
+++ b/tests/functional/string_formatting_failed_inference_py35.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5
diff --git a/tests/functional/string_formatting_py27.py b/tests/functional/string_formatting_py27.py
new file mode 100644
index 000000000..eab042c07
--- /dev/null
+++ b/tests/functional/string_formatting_py27.py
@@ -0,0 +1,22 @@
+"""test for Python 2 string formatting error

+"""

+from __future__ import unicode_literals

+# pylint: disable=line-too-long

+__revision__ = 1

+

+def pprint_bad():

+    """Test string format """

+    "{{}}".format(1) # [too-many-format-args]

+    "{} {".format() # [bad-format-string]

+    "{} }".format() # [bad-format-string]

+    "{0} {}".format(1, 2) # [format-combined-specification]

+    # +1: [missing-format-argument-key, unused-format-string-argument]

+    "{a} {b}".format(a=1, c=2)

+    "{} {a}".format(1, 2) # [missing-format-argument-key]

+    "{} {}".format(1) # [too-few-format-args]

+    "{} {}".format(1, 2, 3) # [too-many-format-args]

+    # +1: [missing-format-argument-key,missing-format-argument-key,missing-format-argument-key]

+    "{a} {b} {c}".format()

+    "{} {}".format(a=1, b=2) # [too-few-format-args]

+    # +1: [missing-format-argument-key, missing-format-argument-key]

+    "{a} {b}".format(1, 2)

diff --git a/tests/functional/string_formatting_py27.rc b/tests/functional/string_formatting_py27.rc
new file mode 100644
index 000000000..80170b777
--- /dev/null
+++ b/tests/functional/string_formatting_py27.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=2.7

+max_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/string_formatting_py27.txt b/tests/functional/string_formatting_py27.txt
new file mode 100644
index 000000000..47f21ded0
--- /dev/null
+++ b/tests/functional/string_formatting_py27.txt
@@ -0,0 +1,15 @@
+too-many-format-args:9:pprint_bad:Too many arguments for format string
+bad-format-string:10:pprint_bad:Invalid format string
+bad-format-string:11:pprint_bad:Invalid format string
+format-combined-specification:12:pprint_bad:Format string contains both automatic field numbering and manual field specification
+missing-format-argument-key:14:pprint_bad:Missing keyword argument u'b' for format string
+unused-format-string-argument:14:pprint_bad:Unused format argument 'c'
+missing-format-argument-key:15:pprint_bad:Missing keyword argument u'a' for format string
+too-few-format-args:16:pprint_bad:Not enough arguments for format string
+too-many-format-args:17:pprint_bad:Too many arguments for format string
+missing-format-argument-key:19:pprint_bad:Missing keyword argument u'a' for format string
+missing-format-argument-key:19:pprint_bad:Missing keyword argument u'b' for format string
+missing-format-argument-key:19:pprint_bad:Missing keyword argument u'c' for format string
+too-few-format-args:20:pprint_bad:Not enough arguments for format string
+missing-format-argument-key:22:pprint_bad:Missing keyword argument u'a' for format string
+missing-format-argument-key:22:pprint_bad:Missing keyword argument u'b' for format string
diff --git a/tests/functional/string_formatting_py3.py b/tests/functional/string_formatting_py3.py
new file mode 100644
index 000000000..c27e9719e
--- /dev/null
+++ b/tests/functional/string_formatting_py3.py
@@ -0,0 +1,21 @@
+# pylint: disable=missing-docstring,import-error
+
+
+def issue_957_good():
+    meat = ['spam', 'ham']
+    print('%s%s%s' % ('eggs', *meat))
+
+
+def issue_957_bad1():
+    meat = ['spam', 'ham', 'monty python']
+    print('%s%s%s' % ('eggs', *meat))  # [too-many-format-args]
+
+
+def issue_957_bad2():
+    meat = ['spam']
+    print('%s%s%s' % ('eggs', *meat))  # [too-few-format-args]
+
+
+def issue_957_uninferable():
+    from butchery import meat
+    print('%s%s%s' % ('eggs', *meat))
diff --git a/tests/functional/string_formatting_py3.rc b/tests/functional/string_formatting_py3.rc
new file mode 100644
index 000000000..a2ab06c50
--- /dev/null
+++ b/tests/functional/string_formatting_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/string_formatting_py3.txt b/tests/functional/string_formatting_py3.txt
new file mode 100644
index 000000000..45975899a
--- /dev/null
+++ b/tests/functional/string_formatting_py3.txt
@@ -0,0 +1,2 @@
+too-many-format-args:11:issue_957_bad1:Too many arguments for format string
+too-few-format-args:16:issue_957_bad2:Not enough arguments for format string
diff --git a/tests/functional/subprocess_popen_preexec_fn.py b/tests/functional/subprocess_popen_preexec_fn.py
new file mode 100644
index 000000000..e785abc76
--- /dev/null
+++ b/tests/functional/subprocess_popen_preexec_fn.py
@@ -0,0 +1,11 @@
+# pylint: disable=blacklisted-name,no-value-for-parameter,missing-docstring
+
+import subprocess
+
+def foo():
+    pass
+
+
+subprocess.Popen(preexec_fn=foo) # [subprocess-popen-preexec-fn]
+
+subprocess.Popen()
diff --git a/tests/functional/subprocess_popen_preexec_fn.txt b/tests/functional/subprocess_popen_preexec_fn.txt
new file mode 100644
index 000000000..cd237a442
--- /dev/null
+++ b/tests/functional/subprocess_popen_preexec_fn.txt
@@ -0,0 +1 @@
+subprocess-popen-preexec-fn:9::Using preexec_fn keyword which may be unsafe in the presence of threads
diff --git a/tests/functional/subprocess_run_check35.py b/tests/functional/subprocess_run_check35.py
new file mode 100644
index 000000000..f123fb20d
--- /dev/null
+++ b/tests/functional/subprocess_run_check35.py
@@ -0,0 +1,6 @@
+# pylint: disable=blacklisted-name,no-value-for-parameter,missing-docstring
+
+import subprocess
+
+
+subprocess.run() # [subprocess-run-check]
diff --git a/tests/functional/subprocess_run_check35.rc b/tests/functional/subprocess_run_check35.rc
new file mode 100644
index 000000000..71de8b630
--- /dev/null
+++ b/tests/functional/subprocess_run_check35.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5
diff --git a/tests/functional/subprocess_run_check35.txt b/tests/functional/subprocess_run_check35.txt
new file mode 100644
index 000000000..31e5dbfc1
--- /dev/null
+++ b/tests/functional/subprocess_run_check35.txt
@@ -0,0 +1 @@
+subprocess-run-check:6::Using subprocess.run without explicitly set `check` is not recommended.
diff --git a/tests/functional/super_checks.py b/tests/functional/super_checks.py
new file mode 100644
index 000000000..3888488fe
--- /dev/null
+++ b/tests/functional/super_checks.py
@@ -0,0 +1,125 @@
+# pylint: disable=too-few-public-methods,import-error, no-absolute-import,missing-docstring, useless-object-inheritance
+# pylint: disable=useless-super-delegation,wrong-import-position,invalid-name, wrong-import-order
+
+from unknown import Missing
+
+class Aaaa:
+    """old style"""
+    def hop(self):
+        """hop"""
+        super(Aaaa, self).hop() # >=3.0:[no-member]
+
+    def __init__(self):
+        super(Aaaa, self).__init__()
+
+class NewAaaa(object):
+    """old style"""
+    def hop(self):
+        """hop"""
+        super(NewAaaa, self).hop() # [no-member]
+
+    def __init__(self):
+        super(Aaaa, self).__init__()  # [bad-super-call]
+
+class Py3kAaaa(NewAaaa):
+    """new style"""
+    def __init__(self):
+        super().__init__()  # <3.0:[missing-super-argument]
+
+class Py3kWrongSuper(Py3kAaaa):
+    """new style"""
+    def __init__(self):
+        super(NewAaaa, self).__init__()  # [bad-super-call]
+
+class WrongNameRegression(Py3kAaaa):
+    """ test a regression with the message """
+    def __init__(self):
+        super(Missing, self).__init__()  # [bad-super-call]
+
+class Getattr(object):
+    """ crash """
+    name = NewAaaa
+
+class CrashSuper(object):
+    """ test a crash with this checker """
+    def __init__(self):
+        super(Getattr.name, self).__init__()  # [bad-super-call]
+
+class Empty(object):
+    """Just an empty class."""
+
+class SuperDifferentScope(object):
+    """Don'emit bad-super-call when the super call is in another scope.
+    For reference, see https://bitbucket.org/logilab/pylint/issue/403.
+    """
+    @staticmethod
+    def test():
+        """Test that a bad-super-call is not emitted for this case."""
+        class FalsePositive(Empty):
+            """The following super is in another scope than `test`."""
+            def __init__(self, arg):
+                super(FalsePositive, self).__init__(arg)
+        super(object, 1).__init__() # [bad-super-call]
+
+
+class UnknownBases(Missing):
+    """Don't emit if we don't know all the bases."""
+    def __init__(self):
+        super(UnknownBases, self).__init__()
+        super(UnknownBases, self).test()
+        super(Missing, self).test() # [bad-super-call]
+
+
+# Test that we are detecting proper super errors.
+
+class BaseClass(object):
+
+    not_a_method = 42
+
+    def function(self, param):
+        return param + self.not_a_method
+
+    def __getattr__(self, attr):
+        return attr
+
+
+class InvalidSuperChecks(BaseClass):
+
+    def __init__(self):
+        super(InvalidSuperChecks, self).not_a_method() # [not-callable]
+        super(InvalidSuperChecks, self).attribute_error() # [no-member]
+        super(InvalidSuperChecks, self).function(42)
+        super(InvalidSuperChecks, self).function() # [no-value-for-parameter]
+        super(InvalidSuperChecks, self).function(42, 24, 24) # [too-many-function-args]
+        # +1: [unexpected-keyword-arg,no-value-for-parameter]
+        super(InvalidSuperChecks, self).function(lala=42)
+        # Even though BaseClass has a __getattr__, that won't
+        # be called.
+        super(InvalidSuperChecks, self).attribute_error() # [no-member]
+
+
+
+# Regression for PyCQA/pylint/issues/773
+import subprocess
+
+# The problem was related to astroid not filtering statements
+# at scope level properly, basically not doing strong updates.
+try:
+    TimeoutExpired = subprocess.TimeoutExpired
+except AttributeError:
+    class TimeoutExpired(subprocess.CalledProcessError):
+        def __init__(self):
+            returncode = -1
+            self.timeout = -1
+            super(TimeoutExpired, self).__init__(returncode)
+
+
+class SuperWithType(object):
+    """type(self) may lead to recursion loop in derived classes"""
+    def __init__(self):
+        super(type(self), self).__init__() # [bad-super-call]
+
+class SuperWithSelfClass(object):
+    """self.__class__ may lead to recursion loop in derived classes"""
+    def __init__(self):
+        super(self.__class__, self).__init__() # [bad-super-call]
diff --git a/tests/functional/super_checks.txt b/tests/functional/super_checks.txt
new file mode 100644
index 000000000..4911a6c86
--- /dev/null
+++ b/tests/functional/super_checks.txt
@@ -0,0 +1,18 @@
+no-member:10:Aaaa.hop:Super of 'Aaaa' has no 'hop' member:INFERENCE
+no-member:19:NewAaaa.hop:Super of 'NewAaaa' has no 'hop' member:INFERENCE
+bad-super-call:22:NewAaaa.__init__:Bad first argument 'Aaaa' given to super()
+missing-super-argument:27:Py3kAaaa.__init__:Missing argument to super()
+bad-super-call:32:Py3kWrongSuper.__init__:Bad first argument 'NewAaaa' given to super()
+bad-super-call:37:WrongNameRegression.__init__:Bad first argument 'Missing' given to super()
+bad-super-call:46:CrashSuper.__init__:Bad first argument 'NewAaaa' given to super()
+bad-super-call:62:SuperDifferentScope.test:Bad first argument 'object' given to super()
+bad-super-call:70:UnknownBases.__init__:Bad first argument 'Missing' given to super()
+not-callable:89:InvalidSuperChecks.__init__:super(InvalidSuperChecks, self).not_a_method is not callable
+no-member:90:InvalidSuperChecks.__init__:Super of 'InvalidSuperChecks' has no 'attribute_error' member:INFERENCE
+no-value-for-parameter:92:InvalidSuperChecks.__init__:No value for argument 'param' in method call
+too-many-function-args:93:InvalidSuperChecks.__init__:Too many positional arguments for method call
+no-value-for-parameter:95:InvalidSuperChecks.__init__:No value for argument 'param' in method call
+unexpected-keyword-arg:95:InvalidSuperChecks.__init__:Unexpected keyword argument 'lala' in method call
+no-member:98:InvalidSuperChecks.__init__:Super of 'InvalidSuperChecks' has no 'attribute_error' member:INFERENCE
+bad-super-call:120:SuperWithType.__init__:Bad first argument 'type' given to super()
+bad-super-call:125:SuperWithSelfClass.__init__:Bad first argument 'self.__class__' given to super()
diff --git a/tests/functional/superfluous_parens.py b/tests/functional/superfluous_parens.py
new file mode 100644
index 000000000..13418cd78
--- /dev/null
+++ b/tests/functional/superfluous_parens.py
@@ -0,0 +1,19 @@
+"""Test the superfluous-parens warning."""
+from __future__ import print_function
+# pylint: disable=unneeded-not
+i = 3
+if (i == 5):  # [superfluous-parens]
+    pass
+if not (i == 5):  # [superfluous-parens]
+    pass
+if not (3 or 5):
+    pass
+for (x) in (1, 2, 3):  # [superfluous-parens]
+    print(x)
+if (1) in (1, 2, 3):  # [superfluous-parens]
+    pass
+if (1, 2) in (1, 2, 3):
+    pass
+DICT = {'a': 1, 'b': 2}
+del(DICT['b'])  # [superfluous-parens]
+del DICT['a']
diff --git a/tests/functional/superfluous_parens.txt b/tests/functional/superfluous_parens.txt
new file mode 100644
index 000000000..57e1019c3
--- /dev/null
+++ b/tests/functional/superfluous_parens.txt
@@ -0,0 +1,5 @@
+superfluous-parens:5::Unnecessary parens after 'if' keyword
+superfluous-parens:7::Unnecessary parens after 'not' keyword
+superfluous-parens:11::Unnecessary parens after 'for' keyword
+superfluous-parens:13::Unnecessary parens after 'if' keyword
+superfluous-parens:18::Unnecessary parens after 'del' keyword
diff --git a/tests/functional/suspicious_str_strip_call.py b/tests/functional/suspicious_str_strip_call.py
new file mode 100644
index 000000000..bc3a27c27
--- /dev/null
+++ b/tests/functional/suspicious_str_strip_call.py
@@ -0,0 +1,10 @@
+"""Suspicious str.strip calls."""
+__revision__ = 1
+
+''.strip('yo')
+''.strip()
+
+u''.strip('http://')  # [bad-str-strip-call]
+u''.lstrip('http://')  # [bad-str-strip-call]
+b''.rstrip('http://')  # [bad-str-strip-call]
+"some_sensible_string".strip(None) # Don't crash
diff --git a/tests/functional/suspicious_str_strip_call.rc b/tests/functional/suspicious_str_strip_call.rc
new file mode 100644
index 000000000..a65023393
--- /dev/null
+++ b/tests/functional/suspicious_str_strip_call.rc
@@ -0,0 +1,2 @@
+[testoptions]
+max_pyver=3.0
diff --git a/tests/functional/suspicious_str_strip_call.txt b/tests/functional/suspicious_str_strip_call.txt
new file mode 100644
index 000000000..ad714cc6b
--- /dev/null
+++ b/tests/functional/suspicious_str_strip_call.txt
@@ -0,0 +1,3 @@
+bad-str-strip-call:7::Suspicious argument in unicode.strip call
+bad-str-strip-call:8::Suspicious argument in unicode.lstrip call
+bad-str-strip-call:9::Suspicious argument in str.rstrip call
diff --git a/tests/functional/suspicious_str_strip_call_py3.py b/tests/functional/suspicious_str_strip_call_py3.py
new file mode 100644
index 000000000..e859f25f8
--- /dev/null
+++ b/tests/functional/suspicious_str_strip_call_py3.py
@@ -0,0 +1,9 @@
+"""Suspicious str.strip calls."""
+__revision__ = 1
+
+''.strip('yo')
+''.strip()
+
+u''.strip('http://')  # [bad-str-strip-call]
+u''.lstrip('http://')  # [bad-str-strip-call]
+b''.rstrip('http://')  # [bad-str-strip-call]
diff --git a/tests/functional/suspicious_str_strip_call_py3.rc b/tests/functional/suspicious_str_strip_call_py3.rc
new file mode 100644
index 000000000..c093be204
--- /dev/null
+++ b/tests/functional/suspicious_str_strip_call_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/suspicious_str_strip_call_py3.txt b/tests/functional/suspicious_str_strip_call_py3.txt
new file mode 100644
index 000000000..81f32cf4e
--- /dev/null
+++ b/tests/functional/suspicious_str_strip_call_py3.txt
@@ -0,0 +1,3 @@
+bad-str-strip-call:7::Suspicious argument in str.strip call
+bad-str-strip-call:8::Suspicious argument in str.lstrip call
+bad-str-strip-call:9::Suspicious argument in bytes.rstrip call
diff --git a/tests/functional/syntax_error.py b/tests/functional/syntax_error.py
new file mode 100644
index 000000000..c93df6b05
--- /dev/null
+++ b/tests/functional/syntax_error.py
@@ -0,0 +1 @@
+def toto # [syntax-error]
diff --git a/tests/functional/syntax_error.rc b/tests/functional/syntax_error.rc
new file mode 100644
index 000000000..58b5a9413
--- /dev/null
+++ b/tests/functional/syntax_error.rc
@@ -0,0 +1 @@
+[testoptions]
diff --git a/tests/functional/syntax_error.txt b/tests/functional/syntax_error.txt
new file mode 100644
index 000000000..f14ae39dd
--- /dev/null
+++ b/tests/functional/syntax_error.txt
@@ -0,0 +1 @@
+syntax-error:1::invalid syntax (<unknown>, line 1)
\ No newline at end of file
diff --git a/tests/functional/syntax_error_jython.py b/tests/functional/syntax_error_jython.py
new file mode 100644
index 000000000..c93df6b05
--- /dev/null
+++ b/tests/functional/syntax_error_jython.py
@@ -0,0 +1 @@
+def toto # [syntax-error]
diff --git a/tests/functional/syntax_error_jython.rc b/tests/functional/syntax_error_jython.rc
new file mode 100644
index 000000000..29bd3facf
--- /dev/null
+++ b/tests/functional/syntax_error_jython.rc
@@ -0,0 +1,2 @@
+[testoptions]
+except_implementations=CPython, PyPy
diff --git a/tests/functional/syntax_error_jython.txt b/tests/functional/syntax_error_jython.txt
new file mode 100644
index 000000000..e532aece7
--- /dev/null
+++ b/tests/functional/syntax_error_jython.txt
@@ -0,0 +1 @@
+syntax-error:1::"mismatched input '\n\n\n\n' expecting LPAREN"
\ No newline at end of file
diff --git a/tests/functional/sys_stream_regression_1004.py b/tests/functional/sys_stream_regression_1004.py
new file mode 100644
index 000000000..c0391859d
--- /dev/null
+++ b/tests/functional/sys_stream_regression_1004.py
@@ -0,0 +1,7 @@
+'''Regression for issue https://github.com/PyCQA/pylint/issues/1004'''
+# pylint: disable=missing-docstring, pointless-statement
+
+import sys
+sys.__stdout__.buffer.write('test')
+sys.__stdout__.buff # [no-member]
+sys.__stdout__.buffer.write1 # [no-member]
diff --git a/tests/functional/sys_stream_regression_1004.rc b/tests/functional/sys_stream_regression_1004.rc
new file mode 100644
index 000000000..182fae81c
--- /dev/null
+++ b/tests/functional/sys_stream_regression_1004.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.5
+except_implementations=PyPy
\ No newline at end of file
diff --git a/tests/functional/sys_stream_regression_1004.txt b/tests/functional/sys_stream_regression_1004.txt
new file mode 100644
index 000000000..b68af46fa
--- /dev/null
+++ b/tests/functional/sys_stream_regression_1004.txt
@@ -0,0 +1,2 @@
+no-member:6::Instance of 'TextIOWrapper' has no 'buff' member:INFERENCE
+no-member:7::Instance of 'BufferedWriter' has no 'write1' member; maybe 'write'?:INFERENCE
\ No newline at end of file
diff --git a/tests/functional/ternary.py b/tests/functional/ternary.py
new file mode 100644
index 000000000..835eb73cf
--- /dev/null
+++ b/tests/functional/ternary.py
@@ -0,0 +1,33 @@
+"""Test for old tenrary constructs"""
+from UNINFERABLE import condition, true_value, false_value, some_callable  # pylint: disable=import-error
+
+SOME_VALUE1 = true_value if condition else false_value
+SOME_VALUE2 = condition and true_value or false_value  # [consider-using-ternary]
+SOME_VALUE3 = condition
+
+def func1():
+    """Ternary return value correct"""
+    return true_value if condition else false_value
+
+
+def func2():
+    """Ternary return value incorrect"""
+    return condition and true_value or false_value  # [consider-using-ternary]
+
+
+SOME_VALUE4 = some_callable(condition) and 'ERROR' or 'SUCCESS'  # [consider-using-ternary]
+SOME_VALUE5 = SOME_VALUE1 > 3 and 'greater' or 'not greater'  # [consider-using-ternary]
+SOME_VALUE6 = (SOME_VALUE2 > 4 and SOME_VALUE3) and 'both' or 'not'  # [consider-using-ternary]
+SOME_VALUE7 = 'both' if (SOME_VALUE2 > 4) and (SOME_VALUE3) else 'not'
+SOME_VALUE8 = SOME_VALUE1 and SOME_VALUE2 and SOME_VALUE3 or SOME_VALUE4
+SOME_VALUE9 = SOME_VALUE1 and False or SOME_VALUE2  # [simplify-boolean-expression]
+
+YEAR = 1992
+# Cannot be simplified with a ternary.
+IS_LEAP_YEAR = YEAR % 4 == 0 and YEAR % 100 != 0 or YEAR % 400 == 0
+
+
+def func4():
+    """"Using a Name as a condition but still emits"""
+    truth_value = 42
+    return condition and truth_value or false_value # [consider-using-ternary]
diff --git a/tests/functional/ternary.txt b/tests/functional/ternary.txt
new file mode 100644
index 000000000..0008e16b6
--- /dev/null
+++ b/tests/functional/ternary.txt
@@ -0,0 +1,7 @@
+consider-using-ternary:5::Consider using ternary (true_value if condition else false_value):HIGH
+consider-using-ternary:15:func2:Consider using ternary (true_value if condition else false_value):HIGH
+consider-using-ternary:18::Consider using ternary ('ERROR' if some_callable(condition) else 'SUCCESS'):HIGH
+consider-using-ternary:19::Consider using ternary ('greater' if SOME_VALUE1 > 3 else 'not greater'):HIGH
+consider-using-ternary:20::Consider using ternary ('both' if SOME_VALUE2 > 4 and SOME_VALUE3 else 'not'):HIGH
+simplify-boolean-expression:23::Boolean expression may be simplified to SOME_VALUE2:HIGH
+consider-using-ternary:33:func4:Consider using ternary (truth_value if condition else false_value):HIGH
diff --git a/tests/functional/test_compile.py b/tests/functional/test_compile.py
new file mode 100644
index 000000000..d4a4ac2aa
--- /dev/null
+++ b/tests/functional/test_compile.py
@@ -0,0 +1,6 @@
+# pylint: disable=missing-docstring, unused-variable, pointless-statement, too-few-public-methods, useless-object-inheritance
+
+class WrapperClass(object):
+    def method(self):
+        var = +4294967296
+        self.method.__code__.co_consts
diff --git a/tests/functional/tokenize_error.py b/tests/functional/tokenize_error.py
new file mode 100644
index 000000000..323950d91
--- /dev/null
+++ b/tests/functional/tokenize_error.py
@@ -0,0 +1,6 @@
+"""A module that is accepted by Python but rejected by tokenize.
+
+The problem is the trailing line continuation at the end of the line,
+which produces a TokenError."""
+# +2: [syntax-error]
+""\
diff --git a/tests/functional/tokenize_error.rc b/tests/functional/tokenize_error.rc
new file mode 100644
index 000000000..58b5a9413
--- /dev/null
+++ b/tests/functional/tokenize_error.rc
@@ -0,0 +1 @@
+[testoptions]
diff --git a/tests/functional/tokenize_error.txt b/tests/functional/tokenize_error.txt
new file mode 100644
index 000000000..4e65f7127
--- /dev/null
+++ b/tests/functional/tokenize_error.txt
@@ -0,0 +1 @@
+syntax-error:7::EOF in multi-line statement
diff --git a/tests/functional/tokenize_error_jython.py b/tests/functional/tokenize_error_jython.py
new file mode 100644
index 000000000..205f5fc6b
--- /dev/null
+++ b/tests/functional/tokenize_error_jython.py
@@ -0,0 +1,7 @@
+# [syntax-error]
+"""A module that is accepted by Python but rejected by tokenize.
+
+The problem is the trailing line continuation at the end of the line,
+which produces a TokenError."""
+
+""\
diff --git a/tests/functional/tokenize_error_jython.rc b/tests/functional/tokenize_error_jython.rc
new file mode 100644
index 000000000..79ffac09c
--- /dev/null
+++ b/tests/functional/tokenize_error_jython.rc
@@ -0,0 +1,2 @@
+[testoptions]
+except_implementations=CPython,PyPy,IronPython
\ No newline at end of file
diff --git a/tests/functional/tokenize_error_jython.txt b/tests/functional/tokenize_error_jython.txt
new file mode 100644
index 000000000..82e662eb8
--- /dev/null
+++ b/tests/functional/tokenize_error_jython.txt
@@ -0,0 +1 @@
+syntax-error:1::unexpected character after line continuation character
\ No newline at end of file
diff --git a/tests/functional/too_few_public_methods.py b/tests/functional/too_few_public_methods.py
new file mode 100644
index 000000000..0b300351c
--- /dev/null
+++ b/tests/functional/too_few_public_methods.py
@@ -0,0 +1,50 @@
+# pylint: disable=missing-docstring, useless-object-inheritance
+from __future__ import print_function
+
+
+from enum import Enum
+
+
+class Aaaa(object): # [too-few-public-methods]
+
+    def __init__(self):
+        pass
+
+    def meth1(self):
+        print(self)
+
+    def _dontcount(self):
+        print(self)
+
+
+# Don't emit for these cases.
+class Klass(object):
+    """docstring"""
+
+    def meth1(self):
+        """first"""
+
+    def meth2(self):
+        """second"""
+
+
+class EnoughPublicMethods(Klass):
+    """We shouldn't emit too-few-public-methods for this."""
+
+
+class BossMonster(Enum):
+    """An enum does not need methods to be useful."""
+    megashark = 1
+    octopus = 2
+
+
+class DumbList:
+    """A class can define only special methods."""
+    def __init__(self, iterable):
+        self._list = list(iterable)
+
+    def __len__(self):
+        return len(self._list)
+
+    def __getitem__(self, index):
+        return self._list[index]
diff --git a/tests/functional/too_few_public_methods.txt b/tests/functional/too_few_public_methods.txt
new file mode 100644
index 000000000..79362d110
--- /dev/null
+++ b/tests/functional/too_few_public_methods.txt
@@ -0,0 +1 @@
+too-few-public-methods:8:Aaaa:Too few public methods (1/2)
diff --git a/tests/functional/too_few_public_methods_37.py b/tests/functional/too_few_public_methods_37.py
new file mode 100644
index 000000000..0bb3a3c16
--- /dev/null
+++ b/tests/functional/too_few_public_methods_37.py
@@ -0,0 +1,24 @@
+# pylint: disable=missing-docstring
+import typing
+import dataclasses
+from dataclasses import dataclass
+
+
+@dataclasses.dataclass
+class ScheduledTxSearchModel:
+    date_from = None
+    date_to = None
+
+
+@dataclass
+class ScheduledTxSearchModelOne:
+    date = None
+
+
+@dataclass(frozen=True)
+class Test:
+    some_integer: int
+
+
+class Example(typing.NamedTuple):
+    some_int: int
diff --git a/tests/functional/too_few_public_methods_37.rc b/tests/functional/too_few_public_methods_37.rc
new file mode 100644
index 000000000..5d0572448
--- /dev/null
+++ b/tests/functional/too_few_public_methods_37.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
\ No newline at end of file
diff --git a/tests/functional/too_few_public_methods_37.txt b/tests/functional/too_few_public_methods_37.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/too_few_public_methods_37.txt
diff --git a/tests/functional/too_many_ancestors.py b/tests/functional/too_many_ancestors.py
new file mode 100644
index 000000000..a0ae18a02
--- /dev/null
+++ b/tests/functional/too_many_ancestors.py
@@ -0,0 +1,24 @@
+# pylint: disable=missing-docstring, too-few-public-methods, useless-object-inheritance
+
+class Aaaa(object):
+    pass
+class Bbbb(object):
+    pass
+class Cccc(object):
+    pass
+class Dddd(object):
+    pass
+class Eeee(object):
+    pass
+class Ffff(object):
+    pass
+class Gggg(object):
+    pass
+class Hhhh(object):
+    pass
+
+class Iiii(Aaaa, Bbbb, Cccc, Dddd, Eeee, Ffff, Gggg, Hhhh): # [too-many-ancestors]
+    pass
+
+class Jjjj(Iiii): # [too-many-ancestors]
+    pass
diff --git a/tests/functional/too_many_ancestors.txt b/tests/functional/too_many_ancestors.txt
new file mode 100644
index 000000000..e9f0841ca
--- /dev/null
+++ b/tests/functional/too_many_ancestors.txt
@@ -0,0 +1,2 @@
+too-many-ancestors:20:Iiii:Too many ancestors (9/7)
+too-many-ancestors:23:Jjjj:Too many ancestors (10/7)
\ No newline at end of file
diff --git a/tests/functional/too_many_arguments.py b/tests/functional/too_many_arguments.py
new file mode 100644
index 000000000..689745e27
--- /dev/null
+++ b/tests/functional/too_many_arguments.py
@@ -0,0 +1,32 @@
+# pylint: disable=missing-docstring,wrong-import-position
+
+def stupid_function(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9): # [too-many-arguments]
+    return arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9
+
+
+class MyClass:
+    text = "MyText"
+
+    def mymethod1(self):
+        return self.text
+
+    def mymethod2(self):
+        return self.mymethod1.__get__(self, MyClass)
+
+
+MyClass().mymethod2()()
+
+
+# Check a false positive does not occur
+from functools import partial
+
+
+def root_function(first, second, third):
+    return first + second + third
+
+
+def func_call():
+    """Test we don't emit a FP for https://github.com/PyCQA/pylint/issues/2588"""
+    partial_func = partial(root_function, 1, 2, 3)
+    partial_func()
+    return root_function(1, 2, 3)
diff --git a/tests/functional/too_many_arguments.txt b/tests/functional/too_many_arguments.txt
new file mode 100644
index 000000000..8f99a462e
--- /dev/null
+++ b/tests/functional/too_many_arguments.txt
@@ -0,0 +1 @@
+too-many-arguments:3:stupid_function:Too many arguments (9/5)
diff --git a/tests/functional/too_many_arguments_issue_1045.py b/tests/functional/too_many_arguments_issue_1045.py
new file mode 100644
index 000000000..e5aa76d75
--- /dev/null
+++ b/tests/functional/too_many_arguments_issue_1045.py
@@ -0,0 +1,13 @@
+# pylint: disable=missing-docstring
+
+# pylint: disable=unused-import, undefined-variable; false positives :-(
+
+import functools
+
+
+@functools.lru_cache()
+def func():
+    pass
+
+
+func.cache_clear()
diff --git a/tests/functional/too_many_arguments_issue_1045.rc b/tests/functional/too_many_arguments_issue_1045.rc
new file mode 100644
index 000000000..46032f660
--- /dev/null
+++ b/tests/functional/too_many_arguments_issue_1045.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.2
\ No newline at end of file
diff --git a/tests/functional/too_many_arguments_issue_1045.txt b/tests/functional/too_many_arguments_issue_1045.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/too_many_arguments_issue_1045.txt
diff --git a/tests/functional/too_many_boolean_expressions.py b/tests/functional/too_many_boolean_expressions.py
new file mode 100644
index 000000000..68214ab8e
--- /dev/null
+++ b/tests/functional/too_many_boolean_expressions.py
@@ -0,0 +1,20 @@
+"""Checks for if statements containing too many boolean expressions"""
+
+# pylint: disable=invalid-name, comparison-with-itself, chained-comparison
+
+x = y = z = 5
+if x > -5 and x < 5 and y > -5 and y < 5 and z > -5 and z < 5:  # [too-many-boolean-expressions]
+    pass
+elif True and False and 1 and 2 and 3:
+    pass
+elif True and False and 1 and 2 and 3 and 4 and 5: # [too-many-boolean-expressions]
+    pass
+elif True and (True and True) and (x == 5 or True or True): # [too-many-boolean-expressions]
+    pass
+elif True and (True or (x > -5 and x < 5 and (z > -5 or z < 5))): # [too-many-boolean-expressions]
+    pass
+elif True == True == True == True == True == True:
+    pass
+
+if True and False and 1 and 2 and 3:
+    pass
diff --git a/tests/functional/too_many_boolean_expressions.txt b/tests/functional/too_many_boolean_expressions.txt
new file mode 100644
index 000000000..0bb0086c1
--- /dev/null
+++ b/tests/functional/too_many_boolean_expressions.txt
@@ -0,0 +1,4 @@
+too-many-boolean-expressions:6::Too many boolean expressions in if statement (6/5)
+too-many-boolean-expressions:10::Too many boolean expressions in if statement (7/5)
+too-many-boolean-expressions:12::Too many boolean expressions in if statement (6/5)
+too-many-boolean-expressions:14::Too many boolean expressions in if statement (6/5)
diff --git a/tests/functional/too_many_branches.py b/tests/functional/too_many_branches.py
new file mode 100644
index 000000000..7b0b068ad
--- /dev/null
+++ b/tests/functional/too_many_branches.py
@@ -0,0 +1,69 @@
+""" Test for too many branches. """

+# pylint: disable=using-constant-test

+def wrong(): # [too-many-branches]

+    """ Has too many branches. """

+    if 1:

+        pass

+    elif 1:

+        pass

+    elif 1:

+        pass

+    elif 1:

+        pass

+    elif 1:

+        pass

+    elif 1:

+        pass

+    try:

+        pass

+    finally:

+        pass

+    if 2:

+        pass

+    while True:

+        pass

+    if 1:

+        pass

+    elif 2:

+        pass

+    elif 3:

+        pass

+

+def good():

+    """ Too many branches only if we take

+    into consideration the nested functions.

+    """

+    def nested_1():

+        """ empty """

+        if 1:

+            pass

+        elif 2:

+            pass

+        elif 3:

+            pass

+        elif 4:

+            pass

+

+    nested_1()

+    try:

+        pass

+    finally:

+        pass

+    try:

+        pass

+    finally:

+        pass

+    if 1:

+        pass

+    elif 2:

+        pass

+    elif 3:

+        pass

+    elif 4:

+        pass

+    elif 5:

+        pass

+    elif 6:

+        pass

+    elif 7:

+        pass

diff --git a/tests/functional/too_many_branches.txt b/tests/functional/too_many_branches.txt
new file mode 100644
index 000000000..fbc82ccca
--- /dev/null
+++ b/tests/functional/too_many_branches.txt
@@ -0,0 +1 @@
+too-many-branches:3:wrong:Too many branches (13/12)
diff --git a/tests/functional/too_many_instance_attributes.py b/tests/functional/too_many_instance_attributes.py
new file mode 100644
index 000000000..f6703e0b7
--- /dev/null
+++ b/tests/functional/too_many_instance_attributes.py
@@ -0,0 +1,26 @@
+# pylint: disable=missing-docstring, too-few-public-methods, useless-object-inheritance
+
+class Aaaa(object): # [too-many-instance-attributes]
+
+    def __init__(self):
+        self.aaaa = 1
+        self.bbbb = 2
+        self.cccc = 3
+        self.dddd = 4
+        self.eeee = 5
+        self.ffff = 6
+        self.gggg = 7
+        self.hhhh = 8
+        self.iiii = 9
+        self.jjjj = 10
+        self._aaaa = 1
+        self._bbbb = 2
+        self._cccc = 3
+        self._dddd = 4
+        self._eeee = 5
+        self._ffff = 6
+        self._gggg = 7
+        self._hhhh = 8
+        self._iiii = 9
+        self._jjjj = 10
+        self.tomuch = None
diff --git a/tests/functional/too_many_instance_attributes.txt b/tests/functional/too_many_instance_attributes.txt
new file mode 100644
index 000000000..652ccea31
--- /dev/null
+++ b/tests/functional/too_many_instance_attributes.txt
@@ -0,0 +1 @@
+too-many-instance-attributes:3:Aaaa:Too many instance attributes (21/7)
diff --git a/tests/functional/too_many_lines.py b/tests/functional/too_many_lines.py
new file mode 100644
index 000000000..78e568c23
--- /dev/null
+++ b/tests/functional/too_many_lines.py
@@ -0,0 +1,1015 @@
+# pylint: disable=missing-docstring
+# -1: [too-many-lines]
+__revision__ = 0
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ZERFZAER = 3
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HEHEHE = 2
diff --git a/tests/functional/too_many_lines.txt b/tests/functional/too_many_lines.txt
new file mode 100644
index 000000000..0374f0c0c
--- /dev/null
+++ b/tests/functional/too_many_lines.txt
@@ -0,0 +1 @@
+too-many-lines:1::Too many lines in module (1015/1000)
\ No newline at end of file
diff --git a/tests/functional/too_many_lines_disabled.py b/tests/functional/too_many_lines_disabled.py
new file mode 100644
index 000000000..1b0866db2
--- /dev/null
+++ b/tests/functional/too_many_lines_disabled.py
@@ -0,0 +1,1018 @@
+"""Test that disabling too-many-lines on any line works."""
+
+
+
+# pylint: disable=too-many-lines
+__revision__ = 0
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ZERFZAER = 3
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HEHEHE = 2
diff --git a/tests/functional/too_many_locals.py b/tests/functional/too_many_locals.py
new file mode 100644
index 000000000..ac38a9e01
--- /dev/null
+++ b/tests/functional/too_many_locals.py
@@ -0,0 +1,60 @@
+# pylint: disable=missing-docstring
+from __future__ import print_function
+
+def function(arg1, arg2, arg3, arg4, arg5): # [too-many-locals]
+    arg6, arg7, arg8, arg9 = arg1, arg2, arg3, arg4
+    print(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
+    loc1, loc2, loc3, loc4, loc5, loc6, loc7 = arg1, arg2, arg3, arg4, arg5, \
+ arg6, arg7
+    print(loc1, loc2, loc3, loc4, loc5, loc6, loc7)
+
+
+def too_many_locals_function(): # [too-many-locals]
+    """pylint will complains about too many local variables"""
+    args0 = 0
+    args1 = args0 * 1
+    args2 = args1 * 2
+    args3 = args2 * 3
+    args4 = args3 * 4
+    args5 = args4 * 5
+    args6 = args5 * 6
+    args7 = args6 * 7
+    args8 = args7 * 8
+    args9 = args8 * 9
+    args10 = args9 * 10
+    args11 = args10 * 11
+    args12 = args11 * 12
+    args13 = args12 * 13
+    args14 = args13 * 14
+    args15 = args14 * 15
+    return args15
+
+def too_many_arguments_function(arga, argu, argi, arge, argt, args): # [too-many-arguments]
+    """pylint will complains about too many arguments."""
+    arga = argu
+    arga += argi
+    arga += arge
+    arga += argt
+    arga += args
+    return arga
+
+def ignored_arguments_function(arga, argu, argi,
+                               _arge=0, _argt=1, _args=None):
+    """pylint will ignore _arge, _argt, _args.
+
+    Consequently pylint will only coun 13 arguments.
+    """
+    arg0 = 0
+    arg1 = arg0 * 1 + arga
+    arg2 = arg1 * 2 + argu
+    arg3 = arg2 * 3 + argi
+    arg4 = arg3 * 4 + _arge
+    arg5 = arg4 * 5 + _argt
+    arg6 = arg5 * 6
+    arg7 = arg6 * 7
+    arg8 = arg7 * 8
+    arg9 = arg8 * 9
+    arg9 += arg0
+    if _args:
+        arg9 += sum(_args)
+    return arg9
diff --git a/tests/functional/too_many_locals.txt b/tests/functional/too_many_locals.txt
new file mode 100644
index 000000000..4a7d19d4f
--- /dev/null
+++ b/tests/functional/too_many_locals.txt
@@ -0,0 +1,3 @@
+too-many-locals:4:function:Too many local variables (16/15)

+too-many-locals:12:too_many_locals_function:Too many local variables (16/15)

+too-many-arguments:32:too_many_arguments_function:Too many arguments (6/5)
\ No newline at end of file
diff --git a/tests/functional/too_many_nested_blocks.py b/tests/functional/too_many_nested_blocks.py
new file mode 100644
index 000000000..e7c007957
--- /dev/null
+++ b/tests/functional/too_many_nested_blocks.py
@@ -0,0 +1,97 @@
+"""Checks the maximum block level is smaller than 6 in function definitions"""
+
+#pylint: disable=using-constant-test, missing-docstring, too-many-return-statements,no-else-return
+
+def my_function():
+    if 1:  # [too-many-nested-blocks]
+        for i in range(10):
+            if i == 2:
+                while True:
+                    try:
+                        if True:
+                            i += 1
+                    except IOError:
+                        pass
+
+    if 1:
+        for i in range(10):
+            if i == 2:
+                while True:
+                    try:
+                        i += 1
+                    except IOError:
+                        pass
+
+    def nested_func():
+        if True:
+            for i in range(10):
+                while True:
+                    if True:
+                        if True:
+                            yield i
+
+    nested_func()
+
+def more_complex_function():
+    attr1 = attr2 = attr3 = [1, 2, 3]
+    if attr1:
+        for i in attr1:
+            if attr2:
+                return i
+            else:
+                return 'duh'
+    elif attr2:
+        for i in attr2:
+            if attr2:
+                return i
+            else:
+                return 'duh'
+    else:
+        for i in range(15):
+            if attr3:
+                return i
+            else:
+                return 'doh'
+            return None
+
+def elif_function():
+    arg = None
+    if arg == 1:
+        return 1
+    elif arg == 2:
+        return 2
+    elif arg == 3:
+        return 3
+    elif arg == 4:
+        return 4
+    elif arg == 5:
+        return 5
+    elif arg == 6:
+        return 6
+    elif arg == 7:
+        return 7
+    return None
+
+def else_if_function():
+    arg = None
+    if arg == 1:  # [too-many-nested-blocks]
+        return 1
+    else:
+        if arg == 2:
+            return 2
+        else:
+            if arg == 3:
+                return 3
+            else:
+                if arg == 4:
+                    return 4
+                else:
+                    if arg == 5:
+                        return 5
+                    else:
+                        if arg == 6:
+                            return 6
+                        else:
+                            if arg == 7:
+                                return 7
+        return None
diff --git a/tests/functional/too_many_nested_blocks.txt b/tests/functional/too_many_nested_blocks.txt
new file mode 100644
index 000000000..b2a30fd25
--- /dev/null
+++ b/tests/functional/too_many_nested_blocks.txt
@@ -0,0 +1,2 @@
+too-many-nested-blocks:6:my_function:Too many nested blocks (6/5)
+too-many-nested-blocks:77:else_if_function:Too many nested blocks (7/5)
diff --git a/tests/functional/too_many_public_methods.py b/tests/functional/too_many_public_methods.py
new file mode 100644
index 000000000..11b4b367d
--- /dev/null
+++ b/tests/functional/too_many_public_methods.py
@@ -0,0 +1,79 @@
+# pylint: disable=missing-docstring, useless-object-inheritance
+
+class Aaaa(object): # [too-many-public-methods]
+
+    def __init__(self):
+        pass
+
+    def meth1(self):
+        """hehehe"""
+
+    def meth2(self):
+        """hehehe"""
+
+    def meth3(self):
+        """hehehe"""
+
+    def meth4(self):
+        """hehehe"""
+
+    def meth5(self):
+        """hehehe"""
+
+    def meth6(self):
+        """hehehe"""
+
+    def meth7(self):
+        """hehehe"""
+
+    def meth8(self):
+        """hehehe"""
+
+    def meth9(self):
+        """hehehe"""
+
+    def meth10(self):
+        """hehehe"""
+
+    def meth11(self):
+        """hehehe"""
+
+    def meth12(self):
+        """hehehe"""
+
+    def meth13(self):
+        """hehehe"""
+
+    def meth14(self):
+        """hehehe"""
+
+    def meth15(self):
+        """hehehe"""
+
+    def meth16(self):
+        """hehehe"""
+
+    def meth17(self):
+        """hehehe"""
+
+    def meth18(self):
+        """hehehe"""
+
+    def meth19(self):
+        """hehehe"""
+
+    def meth20(self):
+        """hehehe"""
+
+    def meth21(self):
+        """hehehe"""
+
+    def _dontcount(self):
+        """not public"""
+
+class BBB(Aaaa):
+    """Don't emit for methods defined in the parent."""
+    def meth1(self):
+        """trop"""
+    def meth2(self):
+        """tzop"""
diff --git a/tests/functional/too_many_public_methods.txt b/tests/functional/too_many_public_methods.txt
new file mode 100644
index 000000000..1b5a25016
--- /dev/null
+++ b/tests/functional/too_many_public_methods.txt
@@ -0,0 +1 @@
+too-many-public-methods:3:Aaaa:Too many public methods (21/20)
diff --git a/tests/functional/too_many_return_statements.py b/tests/functional/too_many_return_statements.py
new file mode 100644
index 000000000..66a85da40
--- /dev/null
+++ b/tests/functional/too_many_return_statements.py
@@ -0,0 +1,40 @@
+# pylint: disable=missing-docstring
+
+def stupid_function(arg): # [too-many-return-statements]
+    if arg == 1:
+        return 1
+    if arg == 2:
+        return 2
+    if arg == 3:
+        return 3
+    if arg == 4:
+        return 4
+    if arg == 5:
+        return 5
+    if arg == 6:
+        return 6
+    if arg == 7:
+        return 7
+    if arg == 8:
+        return 8
+    if arg == 9:
+        return 9
+    if arg == 10:
+        return 10
+    return None
+
+
+def many_yield(text):
+    """Not a problem"""
+    if text:
+        yield "    line 1: %s\n" % text
+        yield "    line 2\n"
+        yield "    line 3\n"
+        yield "    line 4\n"
+        yield "    line 5\n"
+    else:
+        yield "    line 6\n"
+        yield "    line 7\n"
+        yield "    line 8\n"
+        yield "    line 9\n"
+        yield "    line 10\n"
diff --git a/tests/functional/too_many_return_statements.txt b/tests/functional/too_many_return_statements.txt
new file mode 100644
index 000000000..4f65db229
--- /dev/null
+++ b/tests/functional/too_many_return_statements.txt
@@ -0,0 +1 @@
+too-many-return-statements:3:stupid_function:Too many return statements (11/6)
\ No newline at end of file
diff --git a/tests/functional/too_many_star_expressions.py b/tests/functional/too_many_star_expressions.py
new file mode 100644
index 000000000..c1bbfb9d3
--- /dev/null
+++ b/tests/functional/too_many_star_expressions.py
@@ -0,0 +1,7 @@
+"""Test for too-many-star-expressions."""

+# pylint: disable=unbalanced-tuple-unpacking

+*FIRST, *SECOND = [1, 2, 3] # [too-many-star-expressions]

+(FIRST, *SECOND), *THIRD = ((1, 2, 3), 4, 5)

+*FIRST_1, SECOND = (1, 2, 3)

+(*FIRST, *SECOND), THIRD = [...]  # [too-many-star-expressions]

+((*FIRST, SECOND), *THIRD), *FOURTH = [...]

diff --git a/tests/functional/too_many_star_expressions.rc b/tests/functional/too_many_star_expressions.rc
new file mode 100644
index 000000000..c093be204
--- /dev/null
+++ b/tests/functional/too_many_star_expressions.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/too_many_star_expressions.txt b/tests/functional/too_many_star_expressions.txt
new file mode 100644
index 000000000..97af35293
--- /dev/null
+++ b/tests/functional/too_many_star_expressions.txt
@@ -0,0 +1,2 @@
+too-many-star-expressions:3::More than one starred expression in assignment
+too-many-star-expressions:6::More than one starred expression in assignment
diff --git a/tests/functional/too_many_statements.py b/tests/functional/too_many_statements.py
new file mode 100644
index 000000000..b3e2fd796
--- /dev/null
+++ b/tests/functional/too_many_statements.py
@@ -0,0 +1,125 @@
+# pylint: disable=missing-docstring
+
+from __future__ import print_function
+
+def stupid_function(arg): # [too-many-statements]
+    if arg == 1:
+        print(1)
+    elif arg == 2:
+        print(1)
+    elif arg == 3:
+        print(1)
+    elif arg == 4:
+        print(1)
+    elif arg == 5:
+        print(1)
+    elif arg == 6:
+        print(1)
+    elif arg == 7:
+        print(1)
+    elif arg == 8:
+        print(1)
+    elif arg == 9:
+        print(1)
+    elif arg == 10:
+        print(1)
+    elif arg < 1:
+        print(1)
+        print(1)
+        arg = 0
+    for _ in range(arg):
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+        print(1)
+
+def long_function_with_inline_def(fake): # [too-many-statements]
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    def an_inline_function(var):
+        return var + var
+    fake = an_inline_function(fake)
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
+    fake += 1
diff --git a/tests/functional/too_many_statements.txt b/tests/functional/too_many_statements.txt
new file mode 100644
index 000000000..9a8abfc36
--- /dev/null
+++ b/tests/functional/too_many_statements.txt
@@ -0,0 +1,2 @@
+too-many-statements:5:stupid_function:Too many statements (55/50)
+too-many-statements:62:long_function_with_inline_def:Too many statements (62/50)
diff --git a/tests/functional/trailing_comma_tuple.py b/tests/functional/trailing_comma_tuple.py
new file mode 100644
index 000000000..a832ccc28
--- /dev/null
+++ b/tests/functional/trailing_comma_tuple.py
@@ -0,0 +1,38 @@
+"""Check trailing comma one element tuples."""
+# pylint: disable=bad-whitespace, missing-docstring
+AAA = 1, # [trailing-comma-tuple]
+BBB = "aaaa", # [trailing-comma-tuple]
+CCC="aaa", # [trailing-comma-tuple]
+FFF=['f'], # [trailing-comma-tuple]
+
+BBB = 1, 2
+CCC = (1, 2, 3)
+DDD = (
+    1, 2, 3,
+)
+EEE = (
+    "aaa",
+)
+
+
+def test(*args, **kwargs):
+    return args, kwargs
+
+
+test(widget=1, label='test')
+test(widget=1,
+     label='test')
+test(widget=1, \
+     label='test')
+
+
+def some_func(first, second):
+    if first:
+        return first, # [trailing-comma-tuple]
+    if second:
+        return (first, second,)
+    return first, second,  # [trailing-comma-tuple]
+
+
+def some_other_func():
+    yield 'hello',  # [trailing-comma-tuple]
diff --git a/tests/functional/trailing_comma_tuple.rc b/tests/functional/trailing_comma_tuple.rc
new file mode 100644
index 000000000..a2ab06c50
--- /dev/null
+++ b/tests/functional/trailing_comma_tuple.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/trailing_comma_tuple.txt b/tests/functional/trailing_comma_tuple.txt
new file mode 100644
index 000000000..bdf53a255
--- /dev/null
+++ b/tests/functional/trailing_comma_tuple.txt
@@ -0,0 +1,7 @@
+trailing-comma-tuple:3::Disallow trailing comma tuple
+trailing-comma-tuple:4::Disallow trailing comma tuple
+trailing-comma-tuple:5::Disallow trailing comma tuple
+trailing-comma-tuple:6::Disallow trailing comma tuple
+trailing-comma-tuple:31::Disallow trailing comma tuple
+trailing-comma-tuple:34::Disallow trailing comma tuple
+trailing-comma-tuple:38::Disallow trailing comma tuple
diff --git a/tests/functional/trailing_newlines.py b/tests/functional/trailing_newlines.py
new file mode 100644
index 000000000..8fbadbb3e
--- /dev/null
+++ b/tests/functional/trailing_newlines.py
@@ -0,0 +1,3 @@
+"""Regression test for trailing-newlines (C0304)."""
+# +1: [trailing-newlines]
+
diff --git a/tests/functional/trailing_newlines.txt b/tests/functional/trailing_newlines.txt
new file mode 100644
index 000000000..254f49d9d
--- /dev/null
+++ b/tests/functional/trailing_newlines.txt
@@ -0,0 +1 @@
+trailing-newlines:3::Trailing newlines
diff --git a/tests/functional/trailing_whitespaces.py b/tests/functional/trailing_whitespaces.py
new file mode 100644
index 000000000..48de809c6
--- /dev/null
+++ b/tests/functional/trailing_whitespaces.py
@@ -0,0 +1,11 @@
+"""Regression test for trailing-whitespace (C0303)."""
+# pylint: disable=mixed-line-endings
+from __future__ import print_function
+
+# +1: [trailing-whitespace]
+print('some trailing whitespace')   
+# +1: [trailing-whitespace]
+print('trailing whitespace does not count towards the line length limit')                   
+print('windows line ends are ok')

+# +1: [trailing-whitespace]

+print('but trailing whitespace on win is not')   

diff --git a/tests/functional/trailing_whitespaces.txt b/tests/functional/trailing_whitespaces.txt
new file mode 100644
index 000000000..38fc2c322
--- /dev/null
+++ b/tests/functional/trailing_whitespaces.txt
@@ -0,0 +1,3 @@
+trailing-whitespace:6::Trailing whitespace
+trailing-whitespace:8::Trailing whitespace
+trailing-whitespace:11::Trailing whitespace
diff --git a/tests/functional/try_except_raise.py b/tests/functional/try_except_raise.py
new file mode 100644
index 000000000..c78852b81
--- /dev/null
+++ b/tests/functional/try_except_raise.py
@@ -0,0 +1,111 @@
+# pylint:disable=missing-docstring, unreachable, bad-except-order, bare-except, unnecessary-pass
+# pylint: disable=undefined-variable, broad-except
+try:
+    int("9a")
+except:  # [try-except-raise]
+    raise
+
+try:
+    int("9a")
+except:
+    raise ValueError('Invalid integer')
+
+
+try:
+    int("9a")
+except:  # [try-except-raise]
+    raise
+    print('caught exception')
+
+try:
+    int("9a")
+except:
+    print('caught exception')
+    raise
+
+
+class AAAException(Exception):
+    """AAAException"""
+    pass
+
+class BBBException(AAAException):
+    """BBBException"""
+    pass
+
+def ccc():
+    """try-except-raise test function"""
+
+    try:
+        raise BBBException("asdf")
+    except BBBException:
+        raise
+    except AAAException:
+        raise BBBException("raised from AAAException")
+
+
+def ddd():
+    """try-except-raise test function"""
+
+    try:
+        raise BBBException("asdf")
+    except AAAException:
+        raise BBBException("raised from AAAException")
+    except:  # [try-except-raise]
+        raise
+
+try:
+    pass
+except RuntimeError:
+    raise
+except:
+    print("a failure")
+
+try:
+    pass
+except:
+    print("a failure")
+except RuntimeError:  # [try-except-raise]
+    raise
+
+try:
+    pass
+except:  # [try-except-raise]
+    raise
+except RuntimeError:
+    print("a failure")
+
+try:
+    pass
+except (FileNotFoundError, PermissionError):
+    raise
+except OSError:
+    print("a failure")
+
+# also consider tuples for subsequent exception handler instead of just bare except handler
+try:
+    pass
+except (FileNotFoundError, PermissionError):
+    raise
+except (OverflowError, OSError):
+    print("a failure")
+
+try:
+    pass
+except (FileNotFoundError, PermissionError):  # [try-except-raise]
+    raise
+except (OverflowError, ZeroDivisionError):
+    print("a failure")
+
+try:
+    pass
+except (FileNotFoundError, PermissionError):
+    raise
+except Exception:
+    print("a failure")
+
+try:
+    pass
+except (FileNotFoundError, PermissionError):
+    raise
+except (Exception,):
+    print("a failure")
diff --git a/tests/functional/try_except_raise.txt b/tests/functional/try_except_raise.txt
new file mode 100644
index 000000000..882fd4007
--- /dev/null
+++ b/tests/functional/try_except_raise.txt
@@ -0,0 +1,6 @@
+try-except-raise:5::The except handler raises immediately
+try-except-raise:16::The except handler raises immediately
+try-except-raise:53:ddd:The except handler raises immediately
+try-except-raise:67::The except handler raises immediately
+try-except-raise:72::The except handler raises immediately
+try-except-raise:94::The except handler raises immediately
diff --git a/tests/functional/try_except_raise_crash.py b/tests/functional/try_except_raise_crash.py
new file mode 100644
index 000000000..7a1f8d972
--- /dev/null
+++ b/tests/functional/try_except_raise_crash.py
@@ -0,0 +1,25 @@
+# pylint: disable=missing-docstring,too-many-ancestors, broad-except
+import collections.abc
+from typing import TYPE_CHECKING, Any, MutableMapping
+
+if TYPE_CHECKING:
+    BaseClass = MutableMapping[str, Any]
+else:
+    BaseClass = collections.abc.MutableMapping
+
+
+class TestBaseException(BaseClass):
+    pass
+
+
+class TestException(TestBaseException):
+    pass
+
+
+def test():
+    try:
+        1 / 0
+    except TestException:  # [try-except-raise]
+        raise
+    except Exception:
+        pass
diff --git a/tests/functional/try_except_raise_crash.txt b/tests/functional/try_except_raise_crash.txt
new file mode 100644
index 000000000..a99476ab9
--- /dev/null
+++ b/tests/functional/try_except_raise_crash.txt
@@ -0,0 +1 @@
+try-except-raise:22:test:The except handler raises immediately
diff --git a/tests/functional/typing_use.py b/tests/functional/typing_use.py
new file mode 100644
index 000000000..3e2c48ba0
--- /dev/null
+++ b/tests/functional/typing_use.py
@@ -0,0 +1,51 @@
+# pylint: disable=missing-docstring
+
+import typing
+
+
+@typing.overload
+def double_with_docstring(arg: str) -> str:
+    """Return arg, concatenated with itself."""
+
+
+@typing.overload
+def double_with_docstring(arg: int) -> int:
+    """Return twice arg."""
+
+
+def double_with_docstring(arg):
+    """Return 2 * arg."""
+    return 2 * arg
+
+
+def double_with_docstring(arg):  # [function-redefined]
+    """Redefined function implementation"""
+    return 2 * arg
+
+
+@typing.overload
+def double_with_ellipsis(arg: str) -> str:
+    ...
+
+
+@typing.overload
+def double_with_ellipsis(arg: int) -> int:
+    ...
+
+
+def double_with_ellipsis(arg):
+    return 2 * arg
+
+
+@typing.overload
+def double_with_pass(arg: str) -> str:
+    pass
+
+
+@typing.overload
+def double_with_pass(arg: int) -> int:
+    pass
+
+
+def double_with_pass(arg):
+    return 2 * arg
diff --git a/tests/functional/typing_use.rc b/tests/functional/typing_use.rc
new file mode 100644
index 000000000..0ba2b6333
--- /dev/null
+++ b/tests/functional/typing_use.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/typing_use.txt b/tests/functional/typing_use.txt
new file mode 100644
index 000000000..1d0233c98
--- /dev/null
+++ b/tests/functional/typing_use.txt
@@ -0,0 +1 @@
+function-redefined:21:double_with_docstring:"function already defined line 16"
diff --git a/tests/functional/unbalanced_tuple_unpacking.py b/tests/functional/unbalanced_tuple_unpacking.py
new file mode 100644
index 000000000..afa217f40
--- /dev/null
+++ b/tests/functional/unbalanced_tuple_unpacking.py
@@ -0,0 +1,108 @@
+"""Check possible unbalanced tuple unpacking """
+from __future__ import absolute_import
+from functional.unpacking import unpack
+
+# pylint: disable=using-constant-test, useless-object-inheritance
+
+def do_stuff():
+    """This is not right."""
+    first, second = 1, 2, 3 # [unbalanced-tuple-unpacking]
+    return first + second
+
+def do_stuff1():
+    """This is not right."""
+    first, second = [1, 2, 3] # [unbalanced-tuple-unpacking]
+    return first + second
+
+def do_stuff2():
+    """This is not right."""
+    (first, second) = 1, 2, 3 # [unbalanced-tuple-unpacking]
+    return first + second
+
+def do_stuff3():
+    """This is not right."""
+    first, second = range(100)
+    return first + second
+
+def do_stuff4():
+    """ This is right """
+    first, second = 1, 2
+    return first + second
+
+def do_stuff5():
+    """ This is also right """
+    first, second = (1, 2)
+    return first + second
+
+def do_stuff6():
+    """ This is right """
+    (first, second) = (1, 2)
+    return first + second
+
+def temp():
+    """ This is not weird """
+    if True:
+        return [1, 2]
+    return [2, 3, 4]
+
+def do_stuff7():
+    """ This is not right, but we're not sure """
+    first, second = temp()
+    return first + second
+
+def temp2():
+    """ This is weird, but correct """
+    if True:
+        return (1, 2)
+
+    if True:
+        return (2, 3)
+    return (4, 5)
+
+def do_stuff8():
+    """ This is correct """
+    first, second = temp2()
+    return first + second
+
+def do_stuff9():
+    """ This is not correct """
+    first, second = unpack() # [unbalanced-tuple-unpacking]
+    return first + second
+
+class UnbalancedUnpacking(object):
+    """ Test unbalanced tuple unpacking in instance attributes. """
+    # pylint: disable=attribute-defined-outside-init, invalid-name, too-few-public-methods
+    def test(self):
+        """ unpacking in instance attributes """
+        # we're not sure if temp() returns two or three values
+        # so we shouldn't emit an error
+        self.a, self.b = temp()
+        self.a, self.b = temp2()
+        self.a, self.b = unpack() # [unbalanced-tuple-unpacking]
+
+
+def issue329(*args):
+    """ Don't emit unbalanced tuple unpacking if the
+    rhs of the assignment is a variable-length argument,
+    because we don't know the actual length of the tuple.
+    """
+    first, second, third = args
+    return first, second, third
+
+
+def test_decimal():
+    """Test a false positive with decimal.Decimal.as_tuple
+
+    See astroid https://bitbucket.org/logilab/astroid/issues/92/
+    """
+    from decimal import Decimal
+    dec = Decimal(2)
+    first, second, third = dec.as_tuple()
+    return first, second, third
+
+
+def test_issue_559():
+    """Test that we don't have a false positive wrt to issue #559."""
+    from ctypes import c_int
+    root_x, root_y, win_x, win_y = [c_int()] * 4
+    return root_x, root_y, win_x, win_y
diff --git a/tests/functional/unbalanced_tuple_unpacking.txt b/tests/functional/unbalanced_tuple_unpacking.txt
new file mode 100644
index 000000000..e904209e5
--- /dev/null
+++ b/tests/functional/unbalanced_tuple_unpacking.txt
@@ -0,0 +1,6 @@
+unbalanced-tuple-unpacking:9:do_stuff:"Possible unbalanced tuple unpacking with sequence (1, 2, 3): left side has 2 label(s), right side has 3 value(s)"
+unbalanced-tuple-unpacking:14:do_stuff1:"Possible unbalanced tuple unpacking with sequence [1, 2, 3]: left side has 2 label(s), right side has 3 value(s)"
+unbalanced-tuple-unpacking:19:do_stuff2:"Possible unbalanced tuple unpacking with sequence (1, 2, 3): left side has 2 label(s), right side has 3 value(s)"
+unbalanced-tuple-unpacking:24:do_stuff3:"Possible unbalanced tuple unpacking with sequence (1, 2, 3): left side has 2 label(s), right side has 3 value(s)"
+unbalanced-tuple-unpacking:69:do_stuff9:"Possible unbalanced tuple unpacking with sequence defined at line 7 of functional.unpacking: left side has 2 label(s), right side has 3 value(s)"
+unbalanced-tuple-unpacking:81:UnbalancedUnpacking.test:"Possible unbalanced tuple unpacking with sequence defined at line 7 of functional.unpacking: left side has 2 label(s), right side has 3 value(s)"
diff --git a/tests/functional/unbalanced_tuple_unpacking_py30.py b/tests/functional/unbalanced_tuple_unpacking_py30.py
new file mode 100644
index 000000000..68f5fb79a
--- /dev/null
+++ b/tests/functional/unbalanced_tuple_unpacking_py30.py
@@ -0,0 +1,11 @@
+""" Test that using starred nodes in unpacking
+does not trigger a false positive on Python 3.
+"""
+
+__revision__ = 1
+
+def test():
+    """ Test that starred expressions don't give false positives. """
+    first, second, *last = (1, 2, 3, 4)
+    *last, = (1, 2)
+    return (first, second, last)
diff --git a/tests/functional/unbalanced_tuple_unpacking_py30.rc b/tests/functional/unbalanced_tuple_unpacking_py30.rc
new file mode 100644
index 000000000..8c6eb56c4
--- /dev/null
+++ b/tests/functional/unbalanced_tuple_unpacking_py30.rc
@@ -0,0 +1,2 @@
+[testoptions]

+min_pyver=3.0
\ No newline at end of file
diff --git a/tests/functional/undefined_loop_variable.py b/tests/functional/undefined_loop_variable.py
new file mode 100644
index 000000000..a984898f8
--- /dev/null
+++ b/tests/functional/undefined_loop_variable.py
@@ -0,0 +1,75 @@
+# pylint: disable=missing-docstring,redefined-builtin
+
+def do_stuff(some_random_list):
+    for var in some_random_list:
+        pass
+    return var # [undefined-loop-variable]
+
+
+def do_else(some_random_list):
+    for var in some_random_list:
+        if var == 42:
+            break
+    else:
+        var = 84
+    return var
+
+__revision__ = 'yo'
+
+TEST_LC = [C for C in __revision__ if C.isalpha()]
+B = [B for B in  __revision__ if B.isalpha()]
+VAR2 = B # nor this one
+
+for var1, var2 in TEST_LC:
+    var1 = var2 + 4
+VAR3 = var1 # [undefined-loop-variable]
+
+for note in __revision__:
+    note.something()
+for line in __revision__:
+    for note in line:
+        A = note.anotherthing()
+
+
+for x in []:
+    pass
+for x in range(3):
+    VAR5 = (lambda: x)()
+
+
+def do_stuff_with_a_list():
+    for var in [1, 2, 3]:
+        pass
+    return var
+
+
+def do_stuff_with_a_set():
+    for var in {1, 2, 3}:
+        pass
+    return var
+
+
+def do_stuff_with_a_dict():
+    for var in {1: 2, 3: 4}:
+        pass
+    return var
+
+
+def do_stuff_with_a_tuple():
+    for var in (1, 2, 3):
+        pass
+    return var
+
+
+def do_stuff_with_a_range():
+    for var in range(1, 2):
+        pass
+    return var
+
+
+def do_stuff_with_redefined_range():
+    def range(key):
+        yield from [1, key]
+    for var in range(3):
+        pass
+    return var # [undefined-loop-variable]
diff --git a/tests/functional/undefined_loop_variable.txt b/tests/functional/undefined_loop_variable.txt
new file mode 100644
index 000000000..64cf6388b
--- /dev/null
+++ b/tests/functional/undefined_loop_variable.txt
@@ -0,0 +1,3 @@
+undefined-loop-variable:6:do_stuff:Using possibly undefined loop variable 'var'
+undefined-loop-variable:25::Using possibly undefined loop variable 'var1'
+undefined-loop-variable:75:do_stuff_with_redefined_range:Using possibly undefined loop variable 'var'
diff --git a/tests/functional/undefined_variable.py b/tests/functional/undefined_variable.py
new file mode 100644
index 000000000..59af47e19
--- /dev/null
+++ b/tests/functional/undefined_variable.py
@@ -0,0 +1,247 @@
+# pylint: disable=missing-docstring, multiple-statements, useless-object-inheritance
+# pylint: disable=too-few-public-methods, no-init, no-self-use,bare-except,broad-except, import-error
+from __future__ import print_function
+DEFINED = 1
+
+if DEFINED != 1:
+    if DEFINED in (unknown, DEFINED):  # [undefined-variable]
+        DEFINED += 1
+
+
+def in_method(var):
+    """method doc"""
+    var = nomoreknown  # [undefined-variable]
+    assert var
+
+DEFINED = {DEFINED:__revision__}  # [undefined-variable]
+# +1:[undefined-variable]
+DEFINED[__revision__] = OTHER = 'move this is astroid test'
+
+OTHER += '$'
+
+def bad_default(var, default=unknown2):  # [undefined-variable]
+    """function with defaut arg's value set to an unexistant name"""
+    print(var, default)
+    print(xxxx)  # [undefined-variable]
+    augvar += 1  # [undefined-variable]
+    del vardel  # [undefined-variable]
+
+LMBD = lambda x, y=doesnotexist: x+y  # [undefined-variable]
+LMBD2 = lambda x, y: x+z  # [undefined-variable]
+
+try:
+    POUET # don't catch me
+except NameError:
+    POUET = 'something'
+
+try:
+    POUETT # [used-before-assignment]
+except Exception: # pylint:disable = broad-except
+    POUETT = 'something'
+
+try:
+    POUETTT # don't catch me
+except: # pylint:disable = bare-except
+    POUETTT = 'something'
+
+print(POUET, POUETT, POUETTT)
+
+
+try:
+    PLOUF  # [used-before-assignment]
+except ValueError:
+    PLOUF = 'something'
+
+print(PLOUF)
+
+def if_branch_test(something):
+    """hop"""
+    if something == 0:
+        if xxx == 1:  # [used-before-assignment]
+            pass
+    else:
+        print(xxx)
+        xxx = 3
+
+
+def decorator(arg):
+    """Decorator with one argument."""
+    return lambda: list(arg)
+
+
+@decorator(arg=[i * 2 for i in range(15)])
+def func1():
+    """A function with a decorator that contains a listcomp."""
+
+@decorator(arg=(i * 2 for i in range(15)))
+def func2():
+    """A function with a decorator that contains a genexpr."""
+
+@decorator(lambda x: x > 0)
+def main():
+    """A function with a decorator that contains a lambda."""
+
+# Test shared scope.
+
+def test_arguments(arg=TestClass):  # [used-before-assignment]
+    """ TestClass isn't defined yet. """
+    return arg
+
+class TestClass(Ancestor):  # [used-before-assignment]
+    """ contains another class, which uses an undefined ancestor. """
+
+    class MissingAncestor(Ancestor1):  # [used-before-assignment]
+        """ no op """
+
+    def test1(self):
+        """ It should trigger here, because the two classes
+        have the same scope.
+        """
+        class UsingBeforeDefinition(Empty):  # [used-before-assignment]
+            """ uses Empty before definition """
+        class Empty(object):
+            """ no op """
+        return UsingBeforeDefinition
+
+    def test(self):
+        """ Ancestor isn't defined yet, but we don't care. """
+        class MissingAncestor1(Ancestor):
+            """ no op """
+        return MissingAncestor1
+
+class Self(object):
+    """ Detect when using the same name inside the class scope. """
+    obj = Self # [undefined-variable]
+
+class Self1(object):
+    """ No error should be raised here. """
+
+    def test(self):
+        """ empty """
+        return Self1
+
+
+class Ancestor(object):
+    """ No op """
+
+class Ancestor1(object):
+    """ No op """
+
+NANA = BAT # [undefined-variable]
+del BAT
+
+
+class KeywordArgument(object):
+    """Test keyword arguments."""
+
+    enable = True
+    def test(self, is_enabled=enable):
+        """do nothing."""
+
+    def test1(self, is_enabled=enabled): # [used-before-assignment]
+        """enabled is undefined at this point, but it is used before assignment."""
+
+    def test2(self, is_disabled=disabled): # [undefined-variable]
+        """disabled is undefined"""
+
+    enabled = True
+
+    func = lambda arg=arg: arg * arg # [undefined-variable]
+
+    arg2 = 0
+    func2 = lambda arg2=arg2: arg2 * arg2
+
+# Don't emit if the code is protected by NameError
+try:
+    unicode_1
+except NameError:
+    pass
+
+try:
+    unicode_2 # [undefined-variable]
+except Exception:
+    pass
+
+try:
+    unicode_3
+except:
+    pass
+
+try:
+    unicode_4 # [undefined-variable]
+except ValueError:
+    pass
+
+# See https://bitbucket.org/logilab/pylint/issue/111/
+try: raise IOError(1, "a")
+except IOError as err: print(err)
+
+
+def test_conditional_comprehension():
+    methods = ['a', 'b', '_c', '_d']
+    my_methods = sum(1 for method in methods
+                     if not method.startswith('_'))
+    return my_methods
+
+
+class MyError(object):
+    pass
+
+
+class MyClass(object):
+    class MyError(MyError):
+        pass
+
+
+def dec(inp):
+    def inner(func):
+        print(inp)
+        return func
+    return inner
+
+# Make sure lambdas with expressions
+# referencing parent class do not raise undefined variable
+# because at the time of their calling, the class name will
+# be populated
+# See https://github.com/PyCQA/pylint/issues/704
+class LambdaClass:
+    myattr = 1
+    mylambda = lambda: LambdaClass.myattr
+
+# Need different classes to make sure
+# consumed variables don't get in the way
+class LambdaClass2:
+    myattr = 1
+    # Different base_scope scope but still applies
+    mylambda2 = lambda: [LambdaClass2.myattr for _ in [1, 2]]
+
+class LambdaClass3:
+    myattr = 1
+    # Nested default argument in lambda
+    # Should not raise error
+    mylambda3 = lambda: lambda a=LambdaClass3: a
+
+class LambdaClass4:
+    myattr = 1
+    mylambda4 = lambda a=LambdaClass4: lambda: a # [undefined-variable]
+
+# Make sure the first lambda does not consume the LambdaClass5 class
+# name although the expression is is valid
+# Consuming the class would cause the subsequent undefined-variable to be masked
+class LambdaClass5:
+    myattr = 1
+    mylambda = lambda: LambdaClass5.myattr
+    mylambda4 = lambda a=LambdaClass5: lambda: a # [undefined-variable]
+
+
+def nonlocal_in_ifexp():
+    import matplotlib.pyplot as plt
+    def onclick(event):
+        if event:
+            nonlocal i
+            i += 1
+            print(i)
+    i = 0
+    fig = plt.figure()
+    fig.canvas.mpl_connect('button_press_event', onclick)
+    plt.show(block=True)
diff --git a/tests/functional/undefined_variable.txt b/tests/functional/undefined_variable.txt
new file mode 100644
index 000000000..bc935c12d
--- /dev/null
+++ b/tests/functional/undefined_variable.txt
@@ -0,0 +1,26 @@
+undefined-variable:7::Undefined variable 'unknown'
+undefined-variable:13:in_method:Undefined variable 'nomoreknown'
+undefined-variable:16::Undefined variable '__revision__'
+undefined-variable:18::Undefined variable '__revision__'
+undefined-variable:22:bad_default:Undefined variable 'unknown2'
+undefined-variable:25:bad_default:Undefined variable 'xxxx'
+undefined-variable:26:bad_default:Undefined variable 'augvar'
+undefined-variable:27:bad_default:Undefined variable 'vardel'
+undefined-variable:29:<lambda>:Undefined variable 'doesnotexist'
+undefined-variable:30:<lambda>:Undefined variable 'z'
+used-before-assignment:38::Using variable 'POUETT' before assignment
+used-before-assignment:51::Using variable 'PLOUF' before assignment
+used-before-assignment:60:if_branch_test:Using variable 'xxx' before assignment
+used-before-assignment:86:test_arguments:Using variable 'TestClass' before assignment
+used-before-assignment:90:TestClass:Using variable 'Ancestor' before assignment
+used-before-assignment:93:TestClass.MissingAncestor:Using variable 'Ancestor1' before assignment
+used-before-assignment:100:TestClass.test1.UsingBeforeDefinition:Using variable 'Empty' before assignment
+undefined-variable:114:Self:Undefined variable 'Self'
+undefined-variable:130::Undefined variable 'BAT'
+used-before-assignment:141:KeywordArgument.test1:Using variable 'enabled' before assignment
+undefined-variable:144:KeywordArgument.test2:Undefined variable 'disabled'
+undefined-variable:149:KeywordArgument.<lambda>:Undefined variable 'arg'
+undefined-variable:161::Undefined variable 'unicode_2'
+undefined-variable:171::Undefined variable 'unicode_4'
+undefined-variable:226:LambdaClass4.<lambda>:Undefined variable 'LambdaClass4'
+undefined-variable:234:LambdaClass5.<lambda>:Undefined variable 'LambdaClass5'
diff --git a/tests/functional/undefined_variable_py30.py b/tests/functional/undefined_variable_py30.py
new file mode 100644
index 000000000..3ccdfa635
--- /dev/null
+++ b/tests/functional/undefined_variable_py30.py
@@ -0,0 +1,82 @@
+"""Test warnings about access to undefined variables
+for various Python 3 constructs. """
+# pylint: disable=too-few-public-methods, no-init, no-self-use
+# pylint: disable=wrong-import-position, invalid-metaclass, useless-object-inheritance
+class Undefined:
+    """ test various annotation problems. """
+
+    def test(self)->Undefined: # [undefined-variable]
+        """ used Undefined, which is Undefined in this scope. """
+
+    Undefined = True
+
+    def test1(self)->Undefined:
+        """ This Undefined exists at local scope. """
+
+    def test2(self):
+        """ This should not emit. """
+        def func()->Undefined:
+            """ empty """
+            return 2
+        return func
+
+
+class Undefined1:
+    """ Other annotation problems. """
+
+    Undef = 42
+    ABC = 42
+
+    class InnerScope:
+        """ Test inner scope definition. """
+
+        def test_undefined(self)->Undef: # [undefined-variable]
+            """ Looking at a higher scope is impossible. """
+
+        def test1(self)->ABC: # [undefined-variable]
+            """ Triggers undefined-variable. """
+
+
+class FalsePositive342(object):
+    # pylint: disable=line-too-long
+    """ Fix some false positives found in
+    https://bitbucket.org/logilab/pylint/issue/342/spurious-undefined-variable-for-class
+    """
+
+    top = 42
+
+    def test_good(self, bac: top):
+        """ top is defined at this moment. """
+
+    def test_bad(self, bac: trop): # [undefined-variable]
+        """ trop is undefined at this moment. """
+
+    def test_bad1(self, *args: trop1): # [undefined-variable]
+        """ trop1 is undefined at this moment. """
+
+    def test_bad2(self, **bac: trop2): # [undefined-variable]
+        """ trop2 is undefined at this moment. """
+
+from abc import ABCMeta
+
+class Bad(metaclass=ABCMet): # [undefined-variable]
+    """ Notice the typo """
+
+class SecondBad(metaclass=ab.ABCMeta): # [undefined-variable]
+    """ Notice the `ab` module. """
+
+class Good(metaclass=int):
+    """ int is not a proper metaclass, but it is defined. """
+
+class SecondGood(metaclass=Good):
+    """ empty """
+
+class ThirdGood(metaclass=ABCMeta):
+    """ empty """
+
+class FourthGood(ThirdGood):
+    """ This should not trigger anything. """
+
+# The following used to raise used-before-assignment
+# pylint: disable=missing-docstring, multiple-statements
+def used_before_assignment(*, arg): return arg + 1
diff --git a/tests/functional/undefined_variable_py30.rc b/tests/functional/undefined_variable_py30.rc
new file mode 100644
index 000000000..c093be204
--- /dev/null
+++ b/tests/functional/undefined_variable_py30.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/undefined_variable_py30.txt b/tests/functional/undefined_variable_py30.txt
new file mode 100644
index 000000000..28f67d354
--- /dev/null
+++ b/tests/functional/undefined_variable_py30.txt
@@ -0,0 +1,8 @@
+undefined-variable:8:Undefined.test:Undefined variable 'Undefined'

+undefined-variable:33:Undefined1.InnerScope.test_undefined:Undefined variable 'Undef'

+undefined-variable:36:Undefined1.InnerScope.test1:Undefined variable 'ABC'

+undefined-variable:51:FalsePositive342.test_bad:Undefined variable 'trop'

+undefined-variable:54:FalsePositive342.test_bad1:Undefined variable 'trop1'

+undefined-variable:57:FalsePositive342.test_bad2:Undefined variable 'trop2'

+undefined-variable:62:Bad:Undefined variable 'ABCMet'

+undefined-variable:65:SecondBad:Undefined variable 'ab.ABCMeta'
\ No newline at end of file
diff --git a/tests/functional/unexpected_special_method_signature.py b/tests/functional/unexpected_special_method_signature.py
new file mode 100644
index 000000000..aba6811b9
--- /dev/null
+++ b/tests/functional/unexpected_special_method_signature.py
@@ -0,0 +1,120 @@
+"""Test for special methods implemented incorrectly."""

+

+# pylint: disable=missing-docstring, unused-argument, too-few-public-methods

+# pylint: disable=invalid-name,too-many-arguments,bad-staticmethod-argument, useless-object-inheritance

+

+class Invalid(object):

+

+    def __enter__(self, other): # [unexpected-special-method-signature]

+        pass

+

+    def __del__(self, other): # [unexpected-special-method-signature]

+        pass

+

+    def __format__(self, other, other2): # [unexpected-special-method-signature]

+        pass

+

+    def __setattr__(self): # [unexpected-special-method-signature]

+        pass

+

+    def __round__(self, invalid, args): # [unexpected-special-method-signature]

+        pass

+

+    def __deepcopy__(self, memo, other): # [unexpected-special-method-signature]

+        pass

+

+    def __iter__(): # [no-method-argument]

+        pass

+

+    @staticmethod

+    def __getattr__(self, nanana): # [unexpected-special-method-signature]

+        pass

+

+

+class FirstBadContextManager(object):

+    def __enter__(self):

+        return self

+    def __exit__(self, exc_type): # [unexpected-special-method-signature]

+        pass

+

+class SecondBadContextManager(object):

+    def __enter__(self):

+        return self

+    def __exit__(self, exc_type, value, tb, stack): # [unexpected-special-method-signature]

+        pass

+

+class ThirdBadContextManager(object):

+    def __enter__(self):

+        return self

+

+    # +1: [unexpected-special-method-signature]

+    def __exit__(self, exc_type, value, tb, stack, *args):

+        pass

+

+

+class Async(object):

+

+    def __aiter__(self, extra): # [unexpected-special-method-signature]

+        pass

+    def __anext__(self, extra, argument): # [unexpected-special-method-signature]

+        pass

+    def __await__(self, param): # [unexpected-special-method-signature]

+        pass

+    def __aenter__(self, first): # [unexpected-special-method-signature]

+        pass

+    def __aexit__(self): # [unexpected-special-method-signature]

+        pass

+

+

+class Valid(object):

+

+    def __new__(cls, test, multiple, args):

+        pass

+

+    def __init__(self, this, can, have, multiple, args, as_well):

+        pass

+

+    def __call__(self, also, trv, for_this):

+        pass

+

+    def __round__(self, n):

+        pass

+

+    def __index__(self, n=42):

+        """Expects 0 args, but we are taking in account arguments with defaults."""

+

+    def __deepcopy__(self, memo):

+        pass

+

+    def __format__(self, format_specification=''):

+        pass

+

+    def __copy__(self, this=None, is_not=None, necessary=None):

+        pass

+

+    @staticmethod

+    def __enter__():

+        pass

+

+    @staticmethod

+    def __getitem__(index):

+        pass

+

+

+class FirstGoodContextManager(object):

+    def __enter__(self):

+        return self

+    def __exit__(self, exc_type, value, tb):

+        pass

+

+class SecondGoodContextManager(object):

+    def __enter__(self):

+        return self

+    def __exit__(self, exc_type=None, value=None, tb=None):

+        pass

+

+class ThirdGoodContextManager(object):

+    def __enter__(self):

+        return self

+    def __exit__(self, exc_type, *args):

+        pass

diff --git a/tests/functional/unexpected_special_method_signature.txt b/tests/functional/unexpected_special_method_signature.txt
new file mode 100644
index 000000000..4fb52df64
--- /dev/null
+++ b/tests/functional/unexpected_special_method_signature.txt
@@ -0,0 +1,16 @@
+unexpected-special-method-signature:8:Invalid.__enter__:The special method '__enter__' expects 0 param(s), 1 was given
+unexpected-special-method-signature:11:Invalid.__del__:The special method '__del__' expects 0 param(s), 1 was given
+unexpected-special-method-signature:14:Invalid.__format__:The special method '__format__' expects 1 param(s), 2 were given
+unexpected-special-method-signature:17:Invalid.__setattr__:The special method '__setattr__' expects 2 param(s), 0 was given
+unexpected-special-method-signature:20:Invalid.__round__:The special method '__round__' expects between 0 or 1 param(s), 2 were given
+unexpected-special-method-signature:23:Invalid.__deepcopy__:The special method '__deepcopy__' expects 1 param(s), 2 were given
+no-method-argument:26:Invalid.__iter__:Method has no argument
+unexpected-special-method-signature:30:Invalid.__getattr__:The special method '__getattr__' expects 1 param(s), 2 were given
+unexpected-special-method-signature:37:FirstBadContextManager.__exit__:The special method '__exit__' expects 3 param(s), 1 was given
+unexpected-special-method-signature:43:SecondBadContextManager.__exit__:The special method '__exit__' expects 3 param(s), 4 were given
+unexpected-special-method-signature:51:ThirdBadContextManager.__exit__:The special method '__exit__' expects 3 param(s), 4 were given
+unexpected-special-method-signature:57:Async.__aiter__:The special method '__aiter__' expects 0 param(s), 1 was given
+unexpected-special-method-signature:59:Async.__anext__:The special method '__anext__' expects 0 param(s), 2 were given
+unexpected-special-method-signature:61:Async.__await__:The special method '__await__' expects 0 param(s), 1 was given
+unexpected-special-method-signature:63:Async.__aenter__:The special method '__aenter__' expects 0 param(s), 1 was given
+unexpected-special-method-signature:65:Async.__aexit__:The special method '__aexit__' expects 3 param(s), 0 was given
\ No newline at end of file
diff --git a/tests/functional/ungrouped_imports.py b/tests/functional/ungrouped_imports.py
new file mode 100644
index 000000000..2fcf18afc
--- /dev/null
+++ b/tests/functional/ungrouped_imports.py
@@ -0,0 +1,26 @@
+"""Checks import order rule"""
+# pylint: disable=unused-import,relative-import,wrong-import-position,wrong-import-order,using-constant-test
+# pylint: disable=import-error
+import six
+import logging.config
+import os.path
+from astroid import are_exclusive
+import logging  # [ungrouped-imports]
+import unused_import
+try:
+    import os  # [ungrouped-imports]
+except ImportError:
+    pass
+from os import pardir
+import scipy
+from os import sep
+from astroid import exceptions # [ungrouped-imports]
+if True:
+    import logging.handlers  # [ungrouped-imports]
+from os.path import join  # [ungrouped-imports]
+# Test related to compatibility with isort:
+# We check that we do not create error with the old way pylint was handling it
+import subprocess
+import unittest
+from unittest import TestCase
+from unittest.mock import MagicMock
diff --git a/tests/functional/ungrouped_imports.txt b/tests/functional/ungrouped_imports.txt
new file mode 100644
index 000000000..c29bb1811
--- /dev/null
+++ b/tests/functional/ungrouped_imports.txt
@@ -0,0 +1,5 @@
+ungrouped-imports:8::Imports from package logging are not grouped
+ungrouped-imports:11::Imports from package os are not grouped
+ungrouped-imports:17::Imports from package astroid are not grouped
+ungrouped-imports:19::Imports from package logging are not grouped
+ungrouped-imports:20::Imports from package os are not grouped
diff --git a/tests/functional/ungrouped_imports_isort_compatible.py b/tests/functional/ungrouped_imports_isort_compatible.py
new file mode 100644
index 000000000..2e64ed402
--- /dev/null
+++ b/tests/functional/ungrouped_imports_isort_compatible.py
@@ -0,0 +1,6 @@
+"""Checks import order rule with imports that isort could generate"""
+# pylint: disable=unused-import
+import astroid
+import isort
+from astroid import are_exclusive, decorators
+from astroid.modutils import get_module_part, is_standard_module
diff --git a/tests/functional/ungrouped_imports_isort_compatible.txt b/tests/functional/ungrouped_imports_isort_compatible.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/ungrouped_imports_isort_compatible.txt
diff --git a/tests/functional/unhashable_dict_key.py b/tests/functional/unhashable_dict_key.py
new file mode 100644
index 000000000..1b469f3dd
--- /dev/null
+++ b/tests/functional/unhashable_dict_key.py
@@ -0,0 +1,11 @@
+# pylint: disable=missing-docstring,expression-not-assigned,too-few-public-methods,pointless-statement, useless-object-inheritance
+
+
+class Unhashable(object):
+    __hash__ = list.__hash__
+
+{}[[1, 2, 3]] # [unhashable-dict-key]
+{}[{}] # [unhashable-dict-key]
+{}[Unhashable()] # [unhashable-dict-key]
+{'foo': 'bar'}['foo']
+{'foo': 'bar'}[42]
diff --git a/tests/functional/unhashable_dict_key.txt b/tests/functional/unhashable_dict_key.txt
new file mode 100644
index 000000000..77c3b9287
--- /dev/null
+++ b/tests/functional/unhashable_dict_key.txt
@@ -0,0 +1,3 @@
+unhashable-dict-key:7::Dict key is unhashable
+unhashable-dict-key:8::Dict key is unhashable
+unhashable-dict-key:9::Dict key is unhashable
diff --git a/tests/functional/unidiomatic_typecheck.py b/tests/functional/unidiomatic_typecheck.py
new file mode 100644
index 000000000..008456b1e
--- /dev/null
+++ b/tests/functional/unidiomatic_typecheck.py
@@ -0,0 +1,76 @@
+"""Warnings for using type(x) == Y or type(x) is Y instead of isinstance(x, Y)."""
+# pylint: disable=missing-docstring,expression-not-assigned,redefined-builtin,invalid-name
+
+def simple_positives():
+    type(42) is int # [unidiomatic-typecheck]
+    type(42) is not int # [unidiomatic-typecheck]
+    type(42) == int # [unidiomatic-typecheck]
+    type(42) != int # [unidiomatic-typecheck]
+    type(42) in [int] # [unidiomatic-typecheck]
+    type(42) not in [int] # [unidiomatic-typecheck]
+
+def simple_inference_positives():
+    alias = type
+    alias(42) is int # [unidiomatic-typecheck]
+    alias(42) is not int # [unidiomatic-typecheck]
+    alias(42) == int # [unidiomatic-typecheck]
+    alias(42) != int # [unidiomatic-typecheck]
+    alias(42) in [int] # [unidiomatic-typecheck]
+    alias(42) not in [int] # [unidiomatic-typecheck]
+
+def type_creation_negatives():
+    type('Q', (object,), dict(a=1)) is int
+    type('Q', (object,), dict(a=1)) is not int
+    type('Q', (object,), dict(a=1)) == int
+    type('Q', (object,), dict(a=1)) != int
+    type('Q', (object,), dict(a=1)) in [int]
+    type('Q', (object,), dict(a=1)) not in [int]
+
+def invalid_type_call_negatives(**kwargs):
+    type(bad=7) is int
+    type(bad=7) is not int
+    type(bad=7) == int
+    type(bad=7) != int
+    type(bad=7) in [int]
+    type(bad=7) not in [int]
+    type('bad', 7) is int
+    type('bad', 7) is not int
+    type('bad', 7) == int
+    type('bad', 7) != int
+    type('bad', 7) in [int]
+    type('bad', 7) not in [int]
+    type(**kwargs) is int
+    type(**kwargs) is not int
+    type(**kwargs) == int
+    type(**kwargs) != int
+    type(**kwargs) in [int]
+    type(**kwargs) not in [int]
+
+def local_var_shadowing_inference_negatives():
+    type = lambda dummy: 7
+    type(42) is int
+    type(42) is not int
+    type(42) == int
+    type(42) != int
+    type(42) in [int]
+    type(42) not in [int]
+
+def parameter_shadowing_inference_negatives(type):
+    type(42) is int
+    type(42) is not int
+    type(42) == int
+    type(42) != int
+    type(42) in [int]
+    type(42) not in [int]
+
+def deliberate_subclass_check_negatives(b):
+    type(42) is type(b)
+    type(42) is not type(b)
+
+def type_of_literals_positives(a):
+    type(a) is type([]) # [unidiomatic-typecheck]
+    type(a) is not type([]) # [unidiomatic-typecheck]
+    type(a) is type({}) # [unidiomatic-typecheck]
+    type(a) is not type({}) # [unidiomatic-typecheck]
+    type(a) is type("") # [unidiomatic-typecheck]
+    type(a) is not type("") # [unidiomatic-typecheck]
diff --git a/tests/functional/unidiomatic_typecheck.txt b/tests/functional/unidiomatic_typecheck.txt
new file mode 100644
index 000000000..23c0f6f28
--- /dev/null
+++ b/tests/functional/unidiomatic_typecheck.txt
@@ -0,0 +1,18 @@
+unidiomatic-typecheck:5:simple_positives:Using type() instead of isinstance() for a typecheck.
+unidiomatic-typecheck:6:simple_positives:Using type() instead of isinstance() for a typecheck.
+unidiomatic-typecheck:7:simple_positives:Using type() instead of isinstance() for a typecheck.
+unidiomatic-typecheck:8:simple_positives:Using type() instead of isinstance() for a typecheck.
+unidiomatic-typecheck:9:simple_positives:Using type() instead of isinstance() for a typecheck.
+unidiomatic-typecheck:10:simple_positives:Using type() instead of isinstance() for a typecheck.
+unidiomatic-typecheck:14:simple_inference_positives:Using type() instead of isinstance() for a typecheck.
+unidiomatic-typecheck:15:simple_inference_positives:Using type() instead of isinstance() for a typecheck.
+unidiomatic-typecheck:16:simple_inference_positives:Using type() instead of isinstance() for a typecheck.
+unidiomatic-typecheck:17:simple_inference_positives:Using type() instead of isinstance() for a typecheck.
+unidiomatic-typecheck:18:simple_inference_positives:Using type() instead of isinstance() for a typecheck.
+unidiomatic-typecheck:19:simple_inference_positives:Using type() instead of isinstance() for a typecheck.
+unidiomatic-typecheck:71:type_of_literals_positives:Using type() instead of isinstance() for a typecheck.
+unidiomatic-typecheck:72:type_of_literals_positives:Using type() instead of isinstance() for a typecheck.
+unidiomatic-typecheck:73:type_of_literals_positives:Using type() instead of isinstance() for a typecheck.
+unidiomatic-typecheck:74:type_of_literals_positives:Using type() instead of isinstance() for a typecheck.
+unidiomatic-typecheck:75:type_of_literals_positives:Using type() instead of isinstance() for a typecheck.
+unidiomatic-typecheck:76:type_of_literals_positives:Using type() instead of isinstance() for a typecheck.
\ No newline at end of file
diff --git a/tests/functional/uninferable_all_object.py b/tests/functional/uninferable_all_object.py
new file mode 100644
index 000000000..3e565f9eb
--- /dev/null
+++ b/tests/functional/uninferable_all_object.py
@@ -0,0 +1,9 @@
+"""Test that non-inferable __all__ variables do not make Pylint crash."""
+
+__all__ = sorted([
+    'Dummy',
+    'NonExistant',
+    'path',
+    'func',
+    'inner',
+    'InnerKlass'])
diff --git a/tests/functional/unknown_encoding_jython.py b/tests/functional/unknown_encoding_jython.py
new file mode 100644
index 000000000..a28cfed06
--- /dev/null
+++ b/tests/functional/unknown_encoding_jython.py
@@ -0,0 +1,7 @@
+# [syntax-error]

+# -*- coding: IBO-8859-1 -*-

+""" check correct unknown encoding declaration

+"""

+

+__revision__ = 'יייי'

+

diff --git a/tests/functional/unknown_encoding_jython.rc b/tests/functional/unknown_encoding_jython.rc
new file mode 100644
index 000000000..788d377ba
--- /dev/null
+++ b/tests/functional/unknown_encoding_jython.rc
@@ -0,0 +1,2 @@
+[testoptions]
+except_implementations=PyPy,CPython,IronPython
\ No newline at end of file
diff --git a/tests/functional/unknown_encoding_jython.txt b/tests/functional/unknown_encoding_jython.txt
new file mode 100644
index 000000000..b7ff720d3
--- /dev/null
+++ b/tests/functional/unknown_encoding_jython.txt
@@ -0,0 +1 @@
+syntax-error:1::"Unknown encoding: IBO-8859-1"

diff --git a/tests/functional/unknown_encoding_py29.py b/tests/functional/unknown_encoding_py29.py
new file mode 100644
index 000000000..aeb2be607
--- /dev/null
+++ b/tests/functional/unknown_encoding_py29.py
@@ -0,0 +1,7 @@
+# [syntax-error]

+# -*- coding: IBO-8859-1 -*-

+""" check correct unknown encoding declaration

+"""

+

+__revision__ = 'יייי'

+

diff --git a/tests/functional/unknown_encoding_py29.rc b/tests/functional/unknown_encoding_py29.rc
new file mode 100644
index 000000000..1c066fbc5
--- /dev/null
+++ b/tests/functional/unknown_encoding_py29.rc
@@ -0,0 +1,3 @@
+[testoptions]
+max_pyver=3.0
+except_implementations=PyPy
\ No newline at end of file
diff --git a/tests/functional/unknown_encoding_py29.txt b/tests/functional/unknown_encoding_py29.txt
new file mode 100644
index 000000000..20e775752
--- /dev/null
+++ b/tests/functional/unknown_encoding_py29.txt
@@ -0,0 +1 @@
+syntax-error:1::"unknown encoding: IBO-8859-1 (<string>, line 0)"

diff --git a/tests/functional/unknown_encoding_pypy.py b/tests/functional/unknown_encoding_pypy.py
new file mode 100644
index 000000000..2ee5f694c
--- /dev/null
+++ b/tests/functional/unknown_encoding_pypy.py
@@ -0,0 +1,7 @@
+# +1: [syntax-error]

+# -*- coding: IBO-8859-1 -*-

+""" check correct unknown encoding declaration

+"""

+

+__revision__ = 'יייי'

+

diff --git a/tests/functional/unknown_encoding_pypy.rc b/tests/functional/unknown_encoding_pypy.rc
new file mode 100644
index 000000000..8c4cfd095
--- /dev/null
+++ b/tests/functional/unknown_encoding_pypy.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.0
+except_implementations=CPython, IronPython
\ No newline at end of file
diff --git a/tests/functional/unknown_encoding_pypy.txt b/tests/functional/unknown_encoding_pypy.txt
new file mode 100644
index 000000000..e4c18053c
--- /dev/null
+++ b/tests/functional/unknown_encoding_pypy.txt
@@ -0,0 +1 @@
+syntax-error:1::"Unknown encoding: ibo-8859-1"
\ No newline at end of file
diff --git a/tests/functional/unnecessary_lambda.py b/tests/functional/unnecessary_lambda.py
new file mode 100644
index 000000000..f0bd775f3
--- /dev/null
+++ b/tests/functional/unnecessary_lambda.py
@@ -0,0 +1,53 @@
+# pylint: disable=undefined-variable

+"""test suspicious lambda expressions

+"""

+

+__revision__ = ''

+

+# Some simple examples of the most commonly encountered forms.

+# +1: [unnecessary-lambda]

+_ = lambda: list()  # replaceable with "list"

+# +1: [unnecessary-lambda]

+_ = lambda x: hash(x)  # replaceable with "hash"

+# +1: [unnecessary-lambda]

+_ = lambda x, y: min(x, y)  # replaceable with "min"

+

+# A function that can take any arguments given to it.

+_ANYARGS = lambda *args, **kwargs: 'completely arbitrary return value'

+

+# Some more complex forms of unnecessary lambda expressions.

+# +1: [unnecessary-lambda]

+_ = lambda *args: _ANYARGS(*args)

+# +1: [unnecessary-lambda]

+_ = lambda **kwargs: _ANYARGS(**kwargs)

+# +1: [unnecessary-lambda]

+_ = lambda *args, **kwargs: _ANYARGS(*args, **kwargs)

+# +1: [unnecessary-lambda]

+_ = lambda x, y, z, *args, **kwargs: _ANYARGS(x, y, z, *args, **kwargs)

+

+# Lambdas that are *not* unnecessary and should *not* trigger warnings.

+_ = lambda x: x

+_ = lambda x: x()

+_ = lambda x=4: hash(x)

+_ = lambda x, y: list(range(y, x))

+_ = lambda x: list(range(5, x))

+_ = lambda x, y: list(range(x, 5))

+_ = lambda x, y, z: x.y(z)

+_ = lambda: 5

+_ = lambda **kwargs: _ANYARGS()

+_ = lambda **kwargs: _ANYARGS(**dict([('three', 3)]))

+_ = lambda **kwargs: _ANYARGS(**{'three': 3})

+_ = lambda dict_arg, **kwargs: _ANYARGS(kwargs, **dict_arg)

+_ = lambda *args: _ANYARGS()

+_ = lambda *args: _ANYARGS(*list([3, 4]))

+_ = lambda *args: _ANYARGS(*[3, 4])

+_ = lambda list_arg, *args: _ANYARGS(args, *list_arg)

+_ = lambda: _ANYARGS(*[3])

+_ = lambda: _ANYARGS(**{'three': 3})

+_ = lambda: _ANYARGS(*[3], **{'three': 3})

+_ = lambda: _ANYARGS(func=42)

+

+# Don't warn about this.

+_ = lambda: code().analysis()

+

+_ = lambda **kwargs: dict(bar=42, **kwargs)

diff --git a/tests/functional/unnecessary_lambda.txt b/tests/functional/unnecessary_lambda.txt
new file mode 100644
index 000000000..de13882ab
--- /dev/null
+++ b/tests/functional/unnecessary_lambda.txt
@@ -0,0 +1,7 @@
+unnecessary-lambda:9:<lambda>:Lambda may not be necessary
+unnecessary-lambda:11:<lambda>:Lambda may not be necessary
+unnecessary-lambda:13:<lambda>:Lambda may not be necessary
+unnecessary-lambda:20:<lambda>:Lambda may not be necessary
+unnecessary-lambda:22:<lambda>:Lambda may not be necessary
+unnecessary-lambda:24:<lambda>:Lambda may not be necessary
+unnecessary-lambda:26:<lambda>:Lambda may not be necessary
diff --git a/tests/functional/unnecessary_pass.py b/tests/functional/unnecessary_pass.py
new file mode 100644
index 000000000..c2733096a
--- /dev/null
+++ b/tests/functional/unnecessary_pass.py
@@ -0,0 +1,49 @@
+# pylint: disable=missing-docstring, too-few-public-methods
+
+try:
+    A = 2
+except ValueError:
+    A = 24
+    pass # [unnecessary-pass]
+
+def docstring_only():
+    '''In Python, stubbed functions often have a body that contains just a
+    single `pass` statement, indicating that the function doesn't do
+    anything. However, a stubbed function can also have just a
+    docstring, and function with a docstring and no body also does
+    nothing.
+    '''
+
+
+# This function has no docstring, so it needs a `pass` statement.
+def pass_only():
+    pass
+
+
+def docstring_and_pass():
+    '''This function doesn't do anything, but it has a docstring, so its
+    `pass` statement is useless clutter.
+
+    NEW CHECK: useless-pass
+
+    This would check for stubs with both docstrings and `pass`
+    statements, suggesting the removal of the useless `pass`
+    statements
+    '''
+    pass # [unnecessary-pass]
+
+
+class DocstringOnly:
+    '''The same goes for class stubs: docstring, or `pass`, but not both.
+    '''
+
+
+# No problem
+class PassOnly:
+    pass
+
+
+class DocstringAndPass:
+    '''Whoops! Mark this one as bad too.
+    '''
+    pass # [unnecessary-pass]
diff --git a/tests/functional/unnecessary_pass.txt b/tests/functional/unnecessary_pass.txt
new file mode 100644
index 000000000..dbbc094d6
--- /dev/null
+++ b/tests/functional/unnecessary_pass.txt
@@ -0,0 +1,3 @@
+unnecessary-pass:7::Unnecessary pass statement
+unnecessary-pass:33:docstring_and_pass:Unnecessary pass statement
+unnecessary-pass:49:DocstringAndPass:Unnecessary pass statement
diff --git a/tests/functional/unneeded_not.py b/tests/functional/unneeded_not.py
new file mode 100644
index 000000000..97acecd73
--- /dev/null
+++ b/tests/functional/unneeded_not.py
@@ -0,0 +1,63 @@
+"""Check exceeding negations in boolean expressions trigger warnings"""
+
+# pylint: disable=singleton-comparison,too-many-branches,too-few-public-methods,undefined-variable
+# pylint: disable=literal-comparison, comparison-with-itself, useless-object-inheritance
+def unneeded_not():
+    """This is not ok
+    """
+    bool_var = True
+    someint = 2
+    if not not bool_var:  # [unneeded-not]
+        pass
+    if not someint == 1:  # [unneeded-not]
+        pass
+    if not someint != 1:  # [unneeded-not]
+        pass
+    if not someint < 1:  # [unneeded-not]
+        pass
+    if not someint > 1:  # [unneeded-not]
+        pass
+    if not someint <= 1:  # [unneeded-not]
+        pass
+    if not someint >= 1:  # [unneeded-not]
+        pass
+    if not not someint:  # [unneeded-not]
+        pass
+    if not bool_var == True:  # [unneeded-not]
+        pass
+    if not bool_var == False:  # [unneeded-not]
+        pass
+    if not bool_var != True:  # [unneeded-not]
+        pass
+    if not True == True:  # [unneeded-not]
+        pass
+    if not 2 in [3, 4]:  # [unneeded-not]
+        pass
+    if not someint is 'test':  # [unneeded-not]
+        pass
+
+
+def tolerated_statements():
+    """This is ok"""
+    bool_var = True
+    someint = 2
+    if not(bool_var == False and someint == 1):
+        pass
+    if 2 not in [3, 4]:
+        pass
+    if not someint == bool_var == 2:
+        pass
+    if not 2 <= someint < 3 < 4:
+        pass
+    if not set('bar') <= set('foobaz'):
+        pass
+    if not set(something) <= 3:
+        pass
+    if not frozenset(something) <= 3:
+        pass
+
+
+class Klass(object):
+    """This is also ok"""
+    def __ne__(self, other):
+        return not self == other
diff --git a/tests/functional/unneeded_not.txt b/tests/functional/unneeded_not.txt
new file mode 100644
index 000000000..13b35129e
--- /dev/null
+++ b/tests/functional/unneeded_not.txt
@@ -0,0 +1,14 @@
+unneeded-not:10:unneeded_not:Consider changing "not not bool_var" to "bool_var"
+unneeded-not:12:unneeded_not:Consider changing "not someint == 1" to "someint != 1"
+unneeded-not:14:unneeded_not:Consider changing "not someint != 1" to "someint == 1"
+unneeded-not:16:unneeded_not:Consider changing "not someint < 1" to "someint >= 1"
+unneeded-not:18:unneeded_not:Consider changing "not someint > 1" to "someint <= 1"
+unneeded-not:20:unneeded_not:Consider changing "not someint <= 1" to "someint > 1"
+unneeded-not:22:unneeded_not:Consider changing "not someint >= 1" to "someint < 1"
+unneeded-not:24:unneeded_not:Consider changing "not not someint" to "someint"
+unneeded-not:26:unneeded_not:Consider changing "not bool_var == True" to "bool_var != True"
+unneeded-not:28:unneeded_not:Consider changing "not bool_var == False" to "bool_var != False"
+unneeded-not:30:unneeded_not:Consider changing "not bool_var != True" to "bool_var == True"
+unneeded-not:32:unneeded_not:Consider changing "not True == True" to "True != True"
+unneeded-not:34:unneeded_not:Consider changing "not 2 in [3, 4]" to "2 not in [3, 4]"
+unneeded-not:36:unneeded_not:Consider changing "not someint is 'test'" to "someint is not 'test'"
diff --git a/tests/functional/unpacked_exceptions.py b/tests/functional/unpacked_exceptions.py
new file mode 100644
index 000000000..ec3599c3c
--- /dev/null
+++ b/tests/functional/unpacked_exceptions.py
@@ -0,0 +1,11 @@
+"""Test for redefine-in-handler, overwriting names in exception handlers."""
+
+def new_style():
+    """Some exceptions can be unpacked."""
+    try:
+        pass
+    except IOError, (errno, message):  # [unpacking-in-except]
+        print errno, message  # pylint: disable=print-statement
+    # +1: [redefine-in-handler,redefine-in-handler,unpacking-in-except]
+    except IOError, (new_style, tuple):  # pylint: disable=duplicate-except
+        print new_style, tuple  # pylint: disable=print-statement
diff --git a/tests/functional/unpacked_exceptions.rc b/tests/functional/unpacked_exceptions.rc
new file mode 100644
index 000000000..9540bc95e
--- /dev/null
+++ b/tests/functional/unpacked_exceptions.rc
@@ -0,0 +1,5 @@
+[testoptions]
+max_pyver=3.0
+
+[Messages Control]
+enable=python3
\ No newline at end of file
diff --git a/tests/functional/unpacked_exceptions.txt b/tests/functional/unpacked_exceptions.txt
new file mode 100644
index 000000000..1a1b03423
--- /dev/null
+++ b/tests/functional/unpacked_exceptions.txt
@@ -0,0 +1,4 @@
+unpacking-in-except:7:new_style:Implicit unpacking of exceptions is not supported in Python 3
+redefine-in-handler:10:new_style:Redefining name 'new_style' from outer scope (line 3) in exception handler
+redefine-in-handler:10:new_style:Redefining name 'tuple' from builtins in exception handler
+unpacking-in-except:10:new_style:Implicit unpacking of exceptions is not supported in Python 3
diff --git a/tests/functional/unpacking.py b/tests/functional/unpacking.py
new file mode 100644
index 000000000..59d9abbe4
--- /dev/null
+++ b/tests/functional/unpacking.py
@@ -0,0 +1,11 @@
+""" Code for checking the display of the module

+for unbalanced-tuple-unpacking and unpacking-non-sequence

+"""

+

+def unpack():

+    """ Return something"""

+    return (1, 2, 3)

+

+def nonseq():

+    """ Return non sequence """

+    return 1

diff --git a/tests/functional/unpacking_generalizations.py b/tests/functional/unpacking_generalizations.py
new file mode 100644
index 000000000..1c5fb16b8
--- /dev/null
+++ b/tests/functional/unpacking_generalizations.py
@@ -0,0 +1,29 @@
+"""Various tests for unpacking generalizations added in Python 3.5"""

+

+# pylint: disable=missing-docstring, invalid-name

+

+def func_variadic_args(*args):

+    return args

+

+

+def func_variadic_positional_args(a, b, *args):

+    return a, b, args

+

+def func_positional_args(a, b, c, d):

+    return a, b, c, d

+

+

+func_variadic_args(*(2, 3), *(3, 4), *(4, 5))

+func_variadic_args(1, 2, *(2, 3), 2, 3, *(4, 5))

+func_variadic_positional_args(1, 2, *(4, 5), *(5, 6))

+func_variadic_positional_args(*(2, 3), *(4, 5), *(5, 6))

+func_variadic_positional_args(*(2, 3))

+func_variadic_positional_args(*(2, 3, 4))

+func_variadic_positional_args(1, 2, 3, *(3, 4))

+

+func_positional_args(*(2, 3, 4), *(2, 3)) # [too-many-function-args]

+func_positional_args(*(1, 2), 3) # [no-value-for-parameter]

+func_positional_args(1, *(2, ), 3, *(4, 5)) # [too-many-function-args]

+func_positional_args(1, 2, c=24, d=32, **{'d': 32}) # [repeated-keyword]

+# +1: [repeated-keyword,repeated-keyword]

+func_positional_args(1, 2, c=24, **{'c': 34, 'd': 33}, **{'d': 24})

diff --git a/tests/functional/unpacking_generalizations.rc b/tests/functional/unpacking_generalizations.rc
new file mode 100644
index 000000000..03004f2c2
--- /dev/null
+++ b/tests/functional/unpacking_generalizations.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5
\ No newline at end of file
diff --git a/tests/functional/unpacking_generalizations.txt b/tests/functional/unpacking_generalizations.txt
new file mode 100644
index 000000000..d92fcc91e
--- /dev/null
+++ b/tests/functional/unpacking_generalizations.txt
@@ -0,0 +1,6 @@
+too-many-function-args:24::Too many positional arguments for function call
+no-value-for-parameter:25::"No value for argument 'd' in function call"
+too-many-function-args:26::Too many positional arguments for function call
+repeated-keyword:27::Got multiple values for keyword argument 'd' in function call
+repeated-keyword:29::Got multiple values for keyword argument 'c' in function call
+repeated-keyword:29::Got multiple values for keyword argument 'd' in function call
\ No newline at end of file
diff --git a/tests/functional/unpacking_non_sequence.py b/tests/functional/unpacking_non_sequence.py
new file mode 100644
index 000000000..06a840b58
--- /dev/null
+++ b/tests/functional/unpacking_non_sequence.py
@@ -0,0 +1,140 @@
+"""Check unpacking non-sequences in assignments. """
+
+# pylint: disable=too-few-public-methods, invalid-name, attribute-defined-outside-init, unused-variable, no-absolute-import
+# pylint: disable=using-constant-test, no-init, missing-docstring, wrong-import-order,wrong-import-position,no-else-return, useless-object-inheritance
+from os import rename as nonseq_func
+from six import with_metaclass
+from functional.unpacking import nonseq
+
+__revision__ = 0
+
+# Working
+
+class Seq(object):
+    """ sequence """
+    def __init__(self):
+        self.items = range(2)
+
+    def __getitem__(self, item):
+        return self.items[item]
+
+    def __len__(self):
+        return len(self.items)
+
+class Iter(object):
+    """ Iterator """
+    def __iter__(self):
+        for number in range(2):
+            yield number
+
+def good_unpacking():
+    """ returns should be unpackable """
+    if True:
+        return [1, 2]
+    else:
+        return (3, 4)
+
+def good_unpacking2():
+    """ returns should be unpackable """
+    return good_unpacking()
+
+class MetaIter(type):
+    "metaclass that makes classes that use it iterables"
+    def __iter__(cls):
+        return iter((1, 2))
+
+class IterClass(with_metaclass(MetaIter)):
+    "class that is iterable (and unpackable)"
+
+class AbstrClass(object):
+    "abstract class"
+    pair = None
+
+    def setup_pair(self):
+        "abstract method"
+        raise NotImplementedError
+
+    def __init__(self):
+        "error should not be emitted because setup_pair is abstract"
+        self.setup_pair()
+        x, y = self.pair
+
+a, b = [1, 2]
+a, b = (1, 2)
+a, b = set([1, 2])
+a, b = {1: 2, 2: 3}
+a, b = "xy"
+a, b = Seq()
+a, b = Iter()
+a, b = (number for number in range(2))
+a, b = good_unpacking()
+a, b = good_unpacking2()
+a, b = IterClass
+
+# Not working
+class NonSeq(object):
+    """ does nothing """
+
+a, b = NonSeq() # [unpacking-non-sequence]
+a, b = ValueError # [unpacking-non-sequence]
+a, b = None # [unpacking-non-sequence]
+a, b = 1 # [unpacking-non-sequence]
+a, b = nonseq # [unpacking-non-sequence]
+a, b = nonseq() # [unpacking-non-sequence]
+a, b = nonseq_func # [unpacking-non-sequence]
+
+class ClassUnpacking(object):
+    """ Check unpacking as instance attributes. """
+
+    def test(self):
+        """ test unpacking in instance attributes. """
+
+        self.a, self.b = 1, 2
+        self.a, self.b = {1: 2, 2: 3}
+        self.a, self.b = "xy"
+        self.a, c = "xy"
+        c, self.a = good_unpacking()
+        self.a, self.b = Iter()
+
+        self.a, self.b = NonSeq() # [unpacking-non-sequence]
+        self.a, self.b = ValueError # [unpacking-non-sequence]
+        self.a, c = nonseq_func # [unpacking-non-sequence]
+
+class TestBase(object):
+    'base class with `test` method implementation'
+    @staticmethod
+    def test(data):
+        'default implementation'
+        return data
+
+class Test(TestBase):
+    'child class that overrides `test` method'
+    def __init__(self):
+        # no error should be emitted here as `test` is overridden in this class
+        (self.aaa, self.bbb, self.ccc) = self.test(None)
+
+    @staticmethod
+    def test(data):
+        'overridden implementation'
+        return (1, 2, 3)
+
+
+import platform
+
+
+def flow_control_false_positive():
+    # This used to trigger an unpacking-non-sequence error. The problem was
+    # partially related to the fact that pylint does not understand flow control,
+    # but now it does not emit anymore, for this example, due to skipping it when
+    # determining an inference of multiple potential values.
+    # In any case, it is good having this repro as a test.
+    system, node, release, version, machine, processor = platform.uname()
+    # The previous line raises W0633
+    return system, node, release, version, machine, processor
+
+
+def flow_control_unpacking(var=None):
+    if var is not None:
+        var0, var1 = var
+        return var0, var1
+    return None
diff --git a/tests/functional/unpacking_non_sequence.txt b/tests/functional/unpacking_non_sequence.txt
new file mode 100644
index 000000000..0a21fab42
--- /dev/null
+++ b/tests/functional/unpacking_non_sequence.txt
@@ -0,0 +1,10 @@
+unpacking-non-sequence:78::Attempting to unpack a non-sequence defined at line 75
+unpacking-non-sequence:79::Attempting to unpack a non-sequence
+unpacking-non-sequence:80::Attempting to unpack a non-sequence None
+unpacking-non-sequence:81::Attempting to unpack a non-sequence 1
+unpacking-non-sequence:82::Attempting to unpack a non-sequence defined at line 9 of functional.unpacking
+unpacking-non-sequence:83::Attempting to unpack a non-sequence defined at line 11 of functional.unpacking
+unpacking-non-sequence:84::Attempting to unpack a non-sequence
+unpacking-non-sequence:99:ClassUnpacking.test:Attempting to unpack a non-sequence defined at line 75
+unpacking-non-sequence:100:ClassUnpacking.test:Attempting to unpack a non-sequence
+unpacking-non-sequence:101:ClassUnpacking.test:Attempting to unpack a non-sequence
diff --git a/tests/functional/unreachable.py b/tests/functional/unreachable.py
new file mode 100644
index 000000000..b03dec88f
--- /dev/null
+++ b/tests/functional/unreachable.py
@@ -0,0 +1,22 @@
+# pylint: disable=missing-docstring
+
+from __future__ import print_function
+
+def func1():
+    return 1
+    print('unreachable') # [unreachable]
+
+def func2():
+    while 1:
+        break
+        print('unreachable') # [unreachable]
+
+def func3():
+    for i in (1, 2, 3):
+        print(i)
+        continue
+        print('unreachable') # [unreachable]
+
+def func4():
+    raise Exception
+    return 1 / 0 # [unreachable]
diff --git a/tests/functional/unreachable.txt b/tests/functional/unreachable.txt
new file mode 100644
index 000000000..adf05264f
--- /dev/null
+++ b/tests/functional/unreachable.txt
@@ -0,0 +1,4 @@
+unreachable:7:func1:Unreachable code

+unreachable:12:func2:Unreachable code

+unreachable:18:func3:Unreachable code

+unreachable:22:func4:Unreachable code
\ No newline at end of file
diff --git a/tests/functional/unrecognized_inline_option.py b/tests/functional/unrecognized_inline_option.py
new file mode 100644
index 000000000..3163b1ea6
--- /dev/null
+++ b/tests/functional/unrecognized_inline_option.py
@@ -0,0 +1,3 @@
+# +1: [unrecognized-inline-option]
+# pylint:bouboule=1
+"""Check unknown option"""

diff --git a/tests/functional/unrecognized_inline_option.txt b/tests/functional/unrecognized_inline_option.txt
new file mode 100644
index 000000000..922cc9273
--- /dev/null
+++ b/tests/functional/unrecognized_inline_option.txt
@@ -0,0 +1 @@
+unrecognized-inline-option:2::"Unrecognized file option 'bouboule'"
diff --git a/tests/functional/unsubscriptable_value.py b/tests/functional/unsubscriptable_value.py
new file mode 100644
index 000000000..eddb6211d
--- /dev/null
+++ b/tests/functional/unsubscriptable_value.py
@@ -0,0 +1,114 @@
+"""
+Checks that value used in a subscript supports subscription
+(i.e. defines __getitem__ method).
+"""
+# pylint: disable=missing-docstring,pointless-statement,expression-not-assigned,wrong-import-position
+# pylint: disable=too-few-public-methods,import-error,invalid-name,wrong-import-order, useless-object-inheritance
+import six
+
+# primitives
+numbers = [1, 2, 3]
+numbers[0]
+"123"[0]
+u"123"[0]
+b"123"[0]
+bytearray(b"123")[0]
+dict(a=1, b=2)['a']
+(1, 2, 3)[0]
+
+# list/dict comprehensions are fine
+[x for x in range(10)][0]
+{x: 10 - x for x in range(10)}[0]
+
+
+# instances
+class NonSubscriptable(object):
+    pass
+
+class Subscriptable(object):
+    def __getitem__(self, key):
+        return key + key
+
+NonSubscriptable()[0]  # [unsubscriptable-object]
+NonSubscriptable[0]  # [unsubscriptable-object]
+Subscriptable()[0]
+Subscriptable[0]  # [unsubscriptable-object]
+
+# generators are not subscriptable
+def powers_of_two():
+    k = 0
+    while k < 10:
+        yield 2 ** k
+        k += 1
+
+powers_of_two()[0]  # [unsubscriptable-object]
+powers_of_two[0]  # [unsubscriptable-object]
+
+
+# check that primitive non subscriptable types are caught
+True[0]  # [unsubscriptable-object]
+None[0]  # [unsubscriptable-object]
+8.5[0]  # [unsubscriptable-object]
+10[0]  # [unsubscriptable-object]
+
+# sets are not subscriptable
+{x ** 2 for x in range(10)}[0]  # [unsubscriptable-object]
+set(numbers)[0]  # [unsubscriptable-object]
+frozenset(numbers)[0]  # [unsubscriptable-object]
+
+# skip instances with unknown base classes
+from some_missing_module import LibSubscriptable
+
+class MaybeSubscriptable(LibSubscriptable):
+    pass
+
+MaybeSubscriptable()[0]
+
+# subscriptable classes (through metaclasses)
+
+class MetaSubscriptable(type):
+    def __getitem__(cls, key):
+        return key + key
+
+class SubscriptableClass(six.with_metaclass(MetaSubscriptable, object)):
+    pass
+
+SubscriptableClass[0]
+SubscriptableClass()[0]  # [unsubscriptable-object]
+
+# functions are not subscriptable
+def test(*args, **kwargs):
+    return args, kwargs
+
+test()[0]
+test[0]  # [unsubscriptable-object]
+
+# deque
+from collections import deque
+deq = deque(maxlen=10)
+deq.append(42)
+deq[0]
+
+
+class AbstractClass(object):
+
+    def __init__(self):
+        self.ala = {i for i in range(10)}
+        self.bala = [i for i in range(10)]
+        self.portocala = None
+
+    def test_unsubscriptable(self):
+        self.bala[0]
+        self.portocala[0]
+
+
+class ClassMixin(object):
+
+    def __init__(self):
+        self.ala = {i for i in range(10)}
+        self.bala = [i for i in range(10)]
+        self.portocala = None
+
+    def test_unsubscriptable(self):
+        self.bala[0]
+        self.portocala[0]
diff --git a/tests/functional/unsubscriptable_value.txt b/tests/functional/unsubscriptable_value.txt
new file mode 100644
index 000000000..d3243946d
--- /dev/null
+++ b/tests/functional/unsubscriptable_value.txt
@@ -0,0 +1,14 @@
+unsubscriptable-object:32::Value 'NonSubscriptable()' is unsubscriptable
+unsubscriptable-object:33::Value 'NonSubscriptable' is unsubscriptable
+unsubscriptable-object:35::Value 'Subscriptable' is unsubscriptable
+unsubscriptable-object:44::Value 'powers_of_two()' is unsubscriptable
+unsubscriptable-object:45::Value 'powers_of_two' is unsubscriptable
+unsubscriptable-object:49::Value 'True' is unsubscriptable
+unsubscriptable-object:50::Value 'None' is unsubscriptable
+unsubscriptable-object:51::Value '8.5' is unsubscriptable
+unsubscriptable-object:52::Value '10' is unsubscriptable
+unsubscriptable-object:55::Value '{x**2 for x in range(10)}' is unsubscriptable
+unsubscriptable-object:56::Value 'set(numbers)' is unsubscriptable
+unsubscriptable-object:57::Value 'frozenset(numbers)' is unsubscriptable
+unsubscriptable-object:77::Value 'SubscriptableClass()' is unsubscriptable
+unsubscriptable-object:84::Value 'test' is unsubscriptable
diff --git a/tests/functional/unsubscriptable_value_py37.py b/tests/functional/unsubscriptable_value_py37.py
new file mode 100644
index 000000000..c7b06cfb2
--- /dev/null
+++ b/tests/functional/unsubscriptable_value_py37.py
@@ -0,0 +1,19 @@
+"""
+Checks that class used in a subscript supports subscription
+(i.e. defines __class_getitem__ method).
+"""
+# pylint: disable=missing-docstring,pointless-statement,expression-not-assigned,wrong-import-position
+# pylint: disable=too-few-public-methods,import-error,invalid-name,wrong-import-order, useless-object-inheritance
+
+import typing
+
+class Subscriptable(object):
+
+    def __class_getitem__(cls, params):
+        pass
+
+
+Subscriptable[0]
+Subscriptable()[0]  # [unsubscriptable-object]
+
+a: typing.List[int]
diff --git a/tests/functional/unsubscriptable_value_py37.rc b/tests/functional/unsubscriptable_value_py37.rc
new file mode 100644
index 000000000..a17bb22da
--- /dev/null
+++ b/tests/functional/unsubscriptable_value_py37.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.7
diff --git a/tests/functional/unsubscriptable_value_py37.txt b/tests/functional/unsubscriptable_value_py37.txt
new file mode 100644
index 000000000..b2ff0fff5
--- /dev/null
+++ b/tests/functional/unsubscriptable_value_py37.txt
@@ -0,0 +1 @@
+unsubscriptable-object:17::Value 'Subscriptable()' is unsubscriptable
diff --git a/tests/functional/unsupported_assignment_operation.py b/tests/functional/unsupported_assignment_operation.py
new file mode 100644
index 000000000..ad2deabef
--- /dev/null
+++ b/tests/functional/unsupported_assignment_operation.py
@@ -0,0 +1,94 @@
+"""
+Checks that value used in a subscript support assignments
+(i.e. defines __setitem__ method).
+"""
+# pylint: disable=missing-docstring,pointless-statement,expression-not-assigned,wrong-import-position
+# pylint: disable=too-few-public-methods,import-error,invalid-name,wrong-import-order, useless-object-inheritance
+import six
+
+# primitives
+numbers = [1, 2, 3]
+numbers[0] = 42
+
+
+bytearray(b"123")[0] = 42
+dict(a=1, b=2)['a'] = 42
+(1, 2, 3)[0] = 42 # [unsupported-assignment-operation]
+
+# list/dict comprehensions are fine
+[x for x in range(10)][0] = 42
+{x: 10 - x for x in range(10)}[0] = 42
+
+
+# instances
+class NonSubscriptable(object):
+    pass
+
+class Subscriptable(object):
+    def __setitem__(self, key, value):
+        return key + value
+
+NonSubscriptable()[0] = 24  # [unsupported-assignment-operation]
+NonSubscriptable[0] = 24 # [unsupported-assignment-operation]
+Subscriptable()[0] = 24
+Subscriptable[0] = 24 # [unsupported-assignment-operation]
+
+# generators are not subscriptable
+def powers_of_two():
+    k = 0
+    while k < 10:
+        yield 2 ** k
+        k += 1
+
+powers_of_two()[0] = 42 # [unsupported-assignment-operation]
+powers_of_two[0] = 42  # [unsupported-assignment-operation]
+
+
+# check that primitive non subscriptable types are caught
+True[0] = 24  # [unsupported-assignment-operation]
+None[0] = 42 # [unsupported-assignment-operation]
+8.5[0] = 24 # [unsupported-assignment-operation]
+10[0] = 24 # [unsupported-assignment-operation]
+
+# sets are not subscriptable
+{x ** 2 for x in range(10)}[0] = 24 # [unsupported-assignment-operation]
+set(numbers)[0] = 24 # [unsupported-assignment-operation]
+frozenset(numbers)[0] = 42 # [unsupported-assignment-operation]
+
+# skip instances with unknown base classes
+from some_missing_module import LibSubscriptable
+
+class MaybeSubscriptable(LibSubscriptable):
+    pass
+
+MaybeSubscriptable()[0] = 42
+
+# subscriptable classes (through metaclasses)
+
+class MetaSubscriptable(type):
+    def __setitem__(cls, key, value):
+        return key + value
+
+class SubscriptableClass(six.with_metaclass(MetaSubscriptable, object)):
+    pass
+
+SubscriptableClass[0] = 24
+SubscriptableClass()[0] = 24 # [unsupported-assignment-operation]
+
+# functions are not subscriptable
+def test(*args, **kwargs):
+    return args, kwargs
+
+test()[0] = 24 # [unsupported-assignment-operation]
+test[0] = 24 # [unsupported-assignment-operation]
+
+# deque
+from collections import deque
+deq = deque(maxlen=10)
+deq.append(42)
+deq[0] = 42
+
+# tuples assignment
+values = [1, 2, 3, 4]
+(values[0], values[1]) = 3, 4
+(values[0], SubscriptableClass()[0]) = 42, 42 # [unsupported-assignment-operation]
diff --git a/tests/functional/unsupported_assignment_operation.txt b/tests/functional/unsupported_assignment_operation.txt
new file mode 100644
index 000000000..27a11e49d
--- /dev/null
+++ b/tests/functional/unsupported_assignment_operation.txt
@@ -0,0 +1,17 @@
+unsupported-assignment-operation:16::'(1, 2, 3)' does not support item assignment
+unsupported-assignment-operation:31::'NonSubscriptable()' does not support item assignment
+unsupported-assignment-operation:32::'NonSubscriptable' does not support item assignment
+unsupported-assignment-operation:34::'Subscriptable' does not support item assignment
+unsupported-assignment-operation:43::'powers_of_two()' does not support item assignment
+unsupported-assignment-operation:44::'powers_of_two' does not support item assignment
+unsupported-assignment-operation:48::'True' does not support item assignment
+unsupported-assignment-operation:49::'None' does not support item assignment
+unsupported-assignment-operation:50::'8.5' does not support item assignment
+unsupported-assignment-operation:51::'10' does not support item assignment
+unsupported-assignment-operation:54::'{x**2 for x in range(10)}' does not support item assignment
+unsupported-assignment-operation:55::'set(numbers)' does not support item assignment
+unsupported-assignment-operation:56::'frozenset(numbers)' does not support item assignment
+unsupported-assignment-operation:76::'SubscriptableClass()' does not support item assignment
+unsupported-assignment-operation:82::'test()' does not support item assignment
+unsupported-assignment-operation:83::'test' does not support item assignment
+unsupported-assignment-operation:94::'SubscriptableClass()' does not support item assignment
diff --git a/tests/functional/unsupported_binary_operation.py b/tests/functional/unsupported_binary_operation.py
new file mode 100644
index 000000000..0bfe1d16a
--- /dev/null
+++ b/tests/functional/unsupported_binary_operation.py
@@ -0,0 +1,66 @@
+"""Test for unsupported-binary-operation."""

+# pylint: disable=missing-docstring,too-few-public-methods,pointless-statement

+# pylint: disable=expression-not-assigned, invalid-name, useless-object-inheritance

+

+

+import collections

+

+

+1 + "a" # [unsupported-binary-operation]

+1 - [] # [unsupported-binary-operation]

+1 * {} # [unsupported-binary-operation]

+1 / collections # [unsupported-binary-operation]

+1 ** (lambda x: x) # [unsupported-binary-operation]

+{} * {} # [unsupported-binary-operation]

+{} - {} # [unsupported-binary-operation]

+{} | {} # [unsupported-binary-operation]

+{} >> {} # [unsupported-binary-operation]

+[] + () # [unsupported-binary-operation]

+() + [] # [unsupported-binary-operation]

+[] * 2.0 # [unsupported-binary-operation]

+() * 2.0 # [unsupported-binary-operation]

+2.0 >> 2.0 # [unsupported-binary-operation]

+class A(object):

+    pass

+class B(object):

+    pass

+A() + B() # [unsupported-binary-operation]

+class A1(object):

+    def __add__(self, other):

+        return NotImplemented

+

+A1() + A1() # [unsupported-binary-operation]

+

+class A2(object):

+    def __add__(self, other):

+        return NotImplemented

+class B2(object):

+    def __radd__(self, other):

+        return NotImplemented

+A2() + B2() # [unsupported-binary-operation]

+

+class Parent(object):

+    pass

+class Child(Parent):

+    def __add__(self, other):

+        return NotImplemented

+Child() + Parent() # [unsupported-binary-operation]

+class A3(object):

+    def __add__(self, other):

+        return NotImplemented

+class B3(A3):

+    def __radd__(self, other):

+        return NotImplemented

+A3() + B3() # [unsupported-binary-operation]

+# Augmented

+FFF = 1

+FFF += A() # [unsupported-binary-operation]

+TTT = 1

+TTT += [] # [unsupported-binary-operation]

+

+

+# Don't emit for this case since we don't know what unknown is.

+from unknown import Unknown

+class Base(Unknown):

+    pass

+Base() * 23

diff --git a/tests/functional/unsupported_binary_operation.rc b/tests/functional/unsupported_binary_operation.rc
new file mode 100644
index 000000000..401ccfe27
--- /dev/null
+++ b/tests/functional/unsupported_binary_operation.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=4.0
diff --git a/tests/functional/unsupported_binary_operation.txt b/tests/functional/unsupported_binary_operation.txt
new file mode 100644
index 000000000..d94365d0a
--- /dev/null
+++ b/tests/functional/unsupported_binary_operation.txt
@@ -0,0 +1,21 @@
+unsupported-binary-operation:9::"unsupported operand type(s) for +: 'int' and 'str'"

+unsupported-binary-operation:10::"unsupported operand type(s) for -: 'int' and 'list'"

+unsupported-binary-operation:11::"unsupported operand type(s) for *: 'int' and 'dict'"

+unsupported-binary-operation:12::"unsupported operand type(s) for /: 'int' and 'module'"

+unsupported-binary-operation:13::"unsupported operand type(s) for **: 'int' and 'function'"

+unsupported-binary-operation:14::"unsupported operand type(s) for *: 'dict' and 'dict'"

+unsupported-binary-operation:15::"unsupported operand type(s) for -: 'dict' and 'dict'"

+unsupported-binary-operation:16::"unsupported operand type(s) for |: 'dict' and 'dict'"

+unsupported-binary-operation:17::"unsupported operand type(s) for >>: 'dict' and 'dict'"

+unsupported-binary-operation:18::"unsupported operand type(s) for +: 'list' and 'tuple'"

+unsupported-binary-operation:19::"unsupported operand type(s) for +: 'tuple' and 'list'"

+unsupported-binary-operation:20::"unsupported operand type(s) for *: 'list' and 'float'"

+unsupported-binary-operation:21::"unsupported operand type(s) for *: 'tuple' and 'float'"

+unsupported-binary-operation:22::"unsupported operand type(s) for >>: 'float' and 'float'"

+unsupported-binary-operation:27::"unsupported operand type(s) for +: 'A' and 'B'"

+unsupported-binary-operation:32::"unsupported operand type(s) for +: 'A1' and 'A1'"

+unsupported-binary-operation:40::"unsupported operand type(s) for +: 'A2' and 'B2'"

+unsupported-binary-operation:47::"unsupported operand type(s) for +: 'Child' and 'Parent'"

+unsupported-binary-operation:54::"unsupported operand type(s) for +: 'A3' and 'B3'"

+unsupported-binary-operation:57::"unsupported operand type(s) for +=: 'int' and 'A'"

+unsupported-binary-operation:59::"unsupported operand type(s) for +=: 'int' and 'list'"
\ No newline at end of file
diff --git a/tests/functional/unsupported_delete_operation.py b/tests/functional/unsupported_delete_operation.py
new file mode 100644
index 000000000..c9bab62ea
--- /dev/null
+++ b/tests/functional/unsupported_delete_operation.py
@@ -0,0 +1,94 @@
+"""
+Checks that value used in a subscript support deletion
+(i.e. defines __delitem__ method).
+"""
+# pylint: disable=missing-docstring,pointless-statement,expression-not-assigned,wrong-import-position
+# pylint: disable=too-few-public-methods,import-error,invalid-name,wrong-import-order, useless-object-inheritance
+import six
+
+# primitives
+numbers = [1, 2, 3]
+del numbers[0]
+
+
+del bytearray(b"123")[0]
+del dict(a=1, b=2)['a']
+del (1, 2, 3)[0] # [unsupported-delete-operation]
+
+# list/dict comprehensions are fine
+del [x for x in range(10)][0]
+del {x: 10 - x for x in range(10)}[0]
+
+
+# instances
+class NonSubscriptable(object):
+    pass
+
+class Subscriptable(object):
+    def __delitem__(self, key):
+        pass
+
+del NonSubscriptable()[0]  # [unsupported-delete-operation]
+del NonSubscriptable[0] # [unsupported-delete-operation]
+del Subscriptable()[0]
+del Subscriptable[0] # [unsupported-delete-operation]
+
+# generators are not subscriptable
+def powers_of_two():
+    k = 0
+    while k < 10:
+        yield 2 ** k
+        k += 1
+
+del powers_of_two()[0] # [unsupported-delete-operation]
+del powers_of_two[0]  # [unsupported-delete-operation]
+
+
+# check that primitive non subscriptable types are caught
+del True[0]  # [unsupported-delete-operation]
+del None[0] # [unsupported-delete-operation]
+del 8.5[0] # [unsupported-delete-operation]
+del 10[0] # [unsupported-delete-operation]
+
+# sets are not subscriptable
+del {x ** 2 for x in range(10)}[0] # [unsupported-delete-operation]
+del set(numbers)[0] # [unsupported-delete-operation]
+del frozenset(numbers)[0] # [unsupported-delete-operation]
+
+# skip instances with unknown base classes
+from some_missing_module import LibSubscriptable
+
+class MaybeSubscriptable(LibSubscriptable):
+    pass
+
+del MaybeSubscriptable()[0]
+
+# subscriptable classes (through metaclasses)
+
+class MetaSubscriptable(type):
+    def __delitem__(cls, key):
+        pass
+
+class SubscriptableClass(six.with_metaclass(MetaSubscriptable, object)):
+    pass
+
+del SubscriptableClass[0]
+del SubscriptableClass()[0] # [unsupported-delete-operation]
+
+# functions are not subscriptable
+def test(*args, **kwargs):
+    return args, kwargs
+
+del test()[0] # [unsupported-delete-operation]
+del test[0] # [unsupported-delete-operation]
+
+# deque
+from collections import deque
+deq = deque(maxlen=10)
+deq.append(42)
+del deq[0]
+
+# tuples assignment
+values = [1, 2, 3, 4]
+del (values[0], values[1])
+del (values[0], SubscriptableClass()[0]) # [unsupported-delete-operation]
diff --git a/tests/functional/unsupported_delete_operation.txt b/tests/functional/unsupported_delete_operation.txt
new file mode 100644
index 000000000..6c3078ec8
--- /dev/null
+++ b/tests/functional/unsupported_delete_operation.txt
@@ -0,0 +1,17 @@
+unsupported-delete-operation:16::'(1, 2, 3)' does not support item deletion
+unsupported-delete-operation:31::'NonSubscriptable()' does not support item deletion
+unsupported-delete-operation:32::'NonSubscriptable' does not support item deletion
+unsupported-delete-operation:34::'Subscriptable' does not support item deletion
+unsupported-delete-operation:43::'powers_of_two()' does not support item deletion
+unsupported-delete-operation:44::'powers_of_two' does not support item deletion
+unsupported-delete-operation:48::'True' does not support item deletion
+unsupported-delete-operation:49::'None' does not support item deletion
+unsupported-delete-operation:50::'8.5' does not support item deletion
+unsupported-delete-operation:51::'10' does not support item deletion
+unsupported-delete-operation:54::'{x**2 for x in range(10)}' does not support item deletion
+unsupported-delete-operation:55::'set(numbers)' does not support item deletion
+unsupported-delete-operation:56::'frozenset(numbers)' does not support item deletion
+unsupported-delete-operation:76::'SubscriptableClass()' does not support item deletion
+unsupported-delete-operation:82::'test()' does not support item deletion
+unsupported-delete-operation:83::'test' does not support item deletion
+unsupported-delete-operation:94::'SubscriptableClass()' does not support item deletion
diff --git a/tests/functional/unused_argument.py b/tests/functional/unused_argument.py
new file mode 100644
index 000000000..013d4b3e5
--- /dev/null
+++ b/tests/functional/unused_argument.py
@@ -0,0 +1,48 @@
+# pylint: disable=missing-docstring,too-few-public-methods, useless-object-inheritance
+
+def test_unused(first, second, _not_used): # [unused-argument, unused-argument]
+    pass
+
+
+def test_prefixed_with_ignored(first, ignored_second):
+    first()
+
+
+def test_prefixed_with_unused(first, unused_second):
+    first()
+
+# for Sub.inherited, only the warning for "aay" is desired.
+# The warnings for "aab" and "aac"  are most likely false positives though,
+# because there could be another subclass that overrides the same method and does
+# use the arguments (eg Sub2)
+
+
+class Base(object):
+    "parent"
+    def inherited(self, aaa, aab, aac):
+        "abstract method"
+        raise NotImplementedError
+
+class Sub(Base):
+    "child 1"
+    def inherited(self, aaa, aab, aac):
+        "overridden method, though don't use every argument"
+        return aaa
+
+    def newmethod(self, aax, aay): # [unused-argument]
+        "another method, warning for aay desired"
+        return self, aax
+
+class Sub2(Base):
+    "child 1"
+
+    def inherited(self, aaa, aab, aac):
+        "overridden method, use every argument"
+        return aaa + aab + aac
+
+def metadata_from_dict(key):
+    """
+    Should not raise unused-argument message because key is
+    used inside comprehension dict
+    """
+    return {key: str(value) for key, value in key.items()}
diff --git a/tests/functional/unused_argument.txt b/tests/functional/unused_argument.txt
new file mode 100644
index 000000000..d5834389f
--- /dev/null
+++ b/tests/functional/unused_argument.txt
@@ -0,0 +1,3 @@
+unused-argument:3:test_unused:Unused argument 'first'
+unused-argument:3:test_unused:Unused argument 'second'
+unused-argument:32:Sub.newmethod:Unused argument 'aay':INFERENCE
diff --git a/tests/functional/unused_argument_py3.py b/tests/functional/unused_argument_py3.py
new file mode 100644
index 000000000..65af3e729
--- /dev/null
+++ b/tests/functional/unused_argument_py3.py
@@ -0,0 +1,4 @@
+# pylint: disable=missing-docstring
+
+def func(first, *, second): # [unused-argument, unused-argument]
+    pass
diff --git a/tests/functional/unused_argument_py3.rc b/tests/functional/unused_argument_py3.rc
new file mode 100644
index 000000000..c093be204
--- /dev/null
+++ b/tests/functional/unused_argument_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/unused_argument_py3.txt b/tests/functional/unused_argument_py3.txt
new file mode 100644
index 000000000..f575e43f3
--- /dev/null
+++ b/tests/functional/unused_argument_py3.txt
@@ -0,0 +1,2 @@
+unused-argument:3:func:Unused argument 'first'
+unused-argument:3:func:Unused argument 'second'
\ No newline at end of file
diff --git a/tests/functional/unused_global_variable1.py b/tests/functional/unused_global_variable1.py
new file mode 100644
index 000000000..e630c3337
--- /dev/null
+++ b/tests/functional/unused_global_variable1.py
@@ -0,0 +1,2 @@
+# pylint: disable=missing-docstring
+VAR = 'pylint'
diff --git a/tests/functional/unused_global_variable2.py b/tests/functional/unused_global_variable2.py
new file mode 100644
index 000000000..62224096e
--- /dev/null
+++ b/tests/functional/unused_global_variable2.py
@@ -0,0 +1,2 @@
+# pylint: disable=missing-docstring
+VAR = 'pylint'  # [unused-variable]
diff --git a/tests/functional/unused_global_variable2.rc b/tests/functional/unused_global_variable2.rc
new file mode 100644
index 000000000..5dcd4a84c
--- /dev/null
+++ b/tests/functional/unused_global_variable2.rc
@@ -0,0 +1,2 @@
+[variables]
+allow-global-unused-variables=no
diff --git a/tests/functional/unused_global_variable2.txt b/tests/functional/unused_global_variable2.txt
new file mode 100644
index 000000000..27019cbd7
--- /dev/null
+++ b/tests/functional/unused_global_variable2.txt
@@ -0,0 +1 @@
+unused-variable:2::Unused variable 'VAR':HIGH
diff --git a/tests/functional/unused_global_variable3.py b/tests/functional/unused_global_variable3.py
new file mode 100644
index 000000000..896789eda
--- /dev/null
+++ b/tests/functional/unused_global_variable3.py
@@ -0,0 +1,6 @@
+# pylint: disable=missing-docstring
+VAR = 'pylint'
+
+
+def func(argument):
+    return VAR + argument
diff --git a/tests/functional/unused_global_variable4.py b/tests/functional/unused_global_variable4.py
new file mode 100644
index 000000000..aef49d68c
--- /dev/null
+++ b/tests/functional/unused_global_variable4.py
@@ -0,0 +1,3 @@
+# pylint: disable=missing-docstring
+VAR = 'pylint'  # [unused-variable]
+VAR = 'pylint2'  # [unused-variable]
diff --git a/tests/functional/unused_global_variable4.rc b/tests/functional/unused_global_variable4.rc
new file mode 100644
index 000000000..5dcd4a84c
--- /dev/null
+++ b/tests/functional/unused_global_variable4.rc
@@ -0,0 +1,2 @@
+[variables]
+allow-global-unused-variables=no
diff --git a/tests/functional/unused_global_variable4.txt b/tests/functional/unused_global_variable4.txt
new file mode 100644
index 000000000..61e3b286c
--- /dev/null
+++ b/tests/functional/unused_global_variable4.txt
@@ -0,0 +1,2 @@
+unused-variable:2::Unused variable 'VAR':HIGH
+unused-variable:3::Unused variable 'VAR':HIGH
diff --git a/tests/functional/unused_import.py b/tests/functional/unused_import.py
new file mode 100644
index 000000000..4f265277a
--- /dev/null
+++ b/tests/functional/unused_import.py
@@ -0,0 +1,39 @@
+"""unused import"""
+# pylint: disable=undefined-all-variable, import-error, no-absolute-import, too-few-public-methods, missing-docstring,wrong-import-position, useless-object-inheritance, multiple-imports
+import xml.etree  # [unused-import]
+import xml.sax  # [unused-import]
+import os.path as test  # [unused-import]
+from sys import argv as test2  # [unused-import]
+from sys import flags  # [unused-import]
+# +1:[unused-import,unused-import]
+from collections import deque, OrderedDict, Counter
+import re, html.parser  # [unused-import]
+DATA = Counter()
+
+from fake import SomeName, SomeOtherName  # [unused-import]
+class SomeClass(object):
+    SomeName = SomeName # https://bitbucket.org/logilab/pylint/issue/475
+    SomeOtherName = 1
+    SomeOtherName = SomeOtherName
+
+from never import __all__
+# pylint: disable=wrong-import-order,ungrouped-imports
+import typing
+from typing import TYPE_CHECKING
+
+
+if typing.TYPE_CHECKING:
+    import collections
+if TYPE_CHECKING:
+    import itertools
+
+
+def get_ordered_dict() -> 'collections.OrderedDict':
+    return []
+
+
+def get_itertools_obj() -> 'itertools.count':
+    return []
+
+def use_html_parser() -> 'html.parser.HTMLParser':
+    return html.parser.HTMLParser
diff --git a/tests/functional/unused_import.txt b/tests/functional/unused_import.txt
new file mode 100644
index 000000000..aa3c07726
--- /dev/null
+++ b/tests/functional/unused_import.txt
@@ -0,0 +1,9 @@
+unused-import:3::Unused import xml.etree
+unused-import:4::Unused import xml.sax
+unused-import:5::Unused os.path imported as test
+unused-import:6::Unused argv imported from sys as test2
+unused-import:7::Unused flags imported from sys
+unused-import:9::Unused OrderedDict imported from collections
+unused-import:9::Unused deque imported from collections
+unused-import:10::Unused import re
+unused-import:13::Unused SomeOtherName imported from fake
diff --git a/tests/functional/unused_import_assigned_to.py b/tests/functional/unused_import_assigned_to.py
new file mode 100644
index 000000000..81d3e2ce0
--- /dev/null
+++ b/tests/functional/unused_import_assigned_to.py
@@ -0,0 +1,25 @@
+# pylint: disable=missing-docstring, import-error, invalid-name
+# pylint: disable=too-few-public-methods, blacklisted-name, no-member, useless-object-inheritance
+
+import uuid
+
+# Note this import doesn't actually exist
+import foo
+
+from .a import x
+
+
+class Y(object):
+    x = x[0]
+
+
+def test(default=None):
+    return default
+
+
+class BaseModel(object):
+    uuid = test(default=uuid.uuid4)
+
+
+class bar(object):
+    foo = foo.baz
diff --git a/tests/functional/unused_typing_imports.py b/tests/functional/unused_typing_imports.py
new file mode 100644
index 000000000..6edca7153
--- /dev/null
+++ b/tests/functional/unused_typing_imports.py
@@ -0,0 +1,56 @@
+# pylint: disable=missing-docstring, bad-whitespace
+"""Regression test for https://github.com/PyCQA/pylint/issues/1168
+
+The problem was that we weren't handling keyword-only arguments annotations,
+which means we were never processing them.
+"""
+
+import re
+import typing
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+    List,
+    NamedTuple,
+    Optional,
+    Pattern,
+    Set,
+    Tuple,
+)
+
+
+def func1(arg: Optional[Callable]=None):
+    return arg
+
+
+def func2(*, arg: Optional[Iterable]=None):
+    return arg
+
+
+SOME_VALUE = [1] # type: List[Any]
+for VALUE in [[1], [2], [3]]:  # type: Tuple[Any]
+    print(VALUE)
+
+
+class ContextManager:
+    def __enter__(self):
+        return {1}
+
+    def __exit__(self, *_args):
+        pass
+
+
+with ContextManager() as SOME_DICT: # type: Set[int]
+    print(SOME_DICT)
+
+
+def func_test_type_comment(param):
+    # type: (NamedTuple) -> Tuple[NamedTuple, Pattern]
+    return param, re.compile('good')
+
+
+def typing_fully_qualified():
+    variable = None  # type: typing.Optional[str]
+    other_variable: 'typing.Optional[str]' = None
+    return variable, other_variable
diff --git a/tests/functional/unused_typing_imports.rc b/tests/functional/unused_typing_imports.rc
new file mode 100644
index 000000000..0ba2b6333
--- /dev/null
+++ b/tests/functional/unused_typing_imports.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/unused_variable.py b/tests/functional/unused_variable.py
new file mode 100644
index 000000000..e475a9038
--- /dev/null
+++ b/tests/functional/unused_variable.py
@@ -0,0 +1,60 @@
+# pylint: disable=missing-docstring, invalid-name, too-few-public-methods, no-self-use, useless-object-inheritance
+
+def test_regression_737():
+    import xml # [unused-import]
+
+def test_regression_923():
+    import unittest.case  # [unused-import]
+    import xml as sql # [unused-import]
+
+def test_unused_with_prepended_underscore():
+    _foo = 42
+    _ = 24
+    __a = 24
+    dummy = 24
+    _a_ = 42 # [unused-variable]
+    __a__ = 24 # [unused-variable]
+    __never_used = 42
+
+def test_local_field_prefixed_with_unused_or_ignored():
+    flagged_local_field = 42 # [unused-variable]
+    unused_local_field = 42
+    ignored_local_field = 42
+
+
+class HasUnusedDunderClass(object):
+
+    def test(self):
+        __class__ = 42  # [unused-variable]
+
+    def best(self):
+        self.test()
+
+
+def locals_example_defined_before():
+    value = 42  # [possibly-unused-variable]
+    return locals()
+
+
+def locals_example_defined_after():
+    local_variables = locals()
+    value = 42  # [unused-variable]
+    return local_variables
+
+
+def locals_does_not_account_for_subscopes():
+    value = 42  # [unused-variable]
+
+    def some_other_scope():
+        return locals()
+    return some_other_scope
+
+
+def unused_import_from():
+    from functools import wraps as abc # [unused-import]
+    from collections import namedtuple # [unused-import]
+
+
+def unused_import_in_function(value):
+    from six import PY2, text_type # [unused-import]
+    return value.encode("utf-8") if PY2 else value
diff --git a/tests/functional/unused_variable.txt b/tests/functional/unused_variable.txt
new file mode 100644
index 000000000..e9f7ef022
--- /dev/null
+++ b/tests/functional/unused_variable.txt
@@ -0,0 +1,13 @@
+unused-import:4:test_regression_737:Unused import xml
+unused-import:7:test_regression_923:Unused import unittest.case
+unused-import:8:test_regression_923:Unused xml imported as sql
+unused-variable:15:test_unused_with_prepended_underscore:Unused variable '_a_'
+unused-variable:16:test_unused_with_prepended_underscore:Unused variable '__a__'
+unused-variable:20:test_local_field_prefixed_with_unused_or_ignored:Unused variable 'flagged_local_field'
+unused-variable:28:HasUnusedDunderClass.test:Unused variable '__class__'
+possibly-unused-variable:35:locals_example_defined_before:Possibly unused variable 'value'
+unused-variable:41:locals_example_defined_after:Unused variable 'value'
+unused-variable:46:locals_does_not_account_for_subscopes:Unused variable 'value'
+unused-import:54:unused_import_from:Unused wraps imported from functools as abc
+unused-import:55:unused_import_from:Unused namedtuple imported from collections
+unused-import:59:unused_import_in_function:Unused text_type imported from six
diff --git a/tests/functional/unused_variable_py36.py b/tests/functional/unused_variable_py36.py
new file mode 100644
index 000000000..396d02805
--- /dev/null
+++ b/tests/functional/unused_variable_py36.py
@@ -0,0 +1,13 @@
+# pylint: disable=missing-docstring
+
+def function():
+    ann: int = 0
+    assign = 0
+
+    def inner():
+        nonlocal ann, assign
+        ann += 1
+        assign += 1
+        return ann + assign
+
+    return inner()
diff --git a/tests/functional/unused_variable_py36.rc b/tests/functional/unused_variable_py36.rc
new file mode 100644
index 000000000..0ba2b6333
--- /dev/null
+++ b/tests/functional/unused_variable_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/unused_variable_py36.txt b/tests/functional/unused_variable_py36.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/unused_variable_py36.txt
diff --git a/tests/functional/used_before_assignment_488.py b/tests/functional/used_before_assignment_488.py
new file mode 100644
index 000000000..efc133c2b
--- /dev/null
+++ b/tests/functional/used_before_assignment_488.py
@@ -0,0 +1,9 @@
+# pylint: disable=missing-docstring
+def func():
+    """Test that a variable defined in a finally clause does not trigger a false positive"""
+    try:
+        variable = 1
+        yield variable
+    finally:
+        variable = 2
+        yield variable
diff --git a/tests/functional/used_before_assignment_issue1081.py b/tests/functional/used_before_assignment_issue1081.py
new file mode 100644
index 000000000..0c59ccebe
--- /dev/null
+++ b/tests/functional/used_before_assignment_issue1081.py
@@ -0,0 +1,40 @@
+# pylint: disable=missing-docstring,invalid-name,too-few-public-methods, useless-object-inheritance
+
+x = 24
+
+
+def used_before_assignment_1(a):
+    if x == a:  # [used-before-assignment]
+        for x in [1, 2]:  # [redefined-outer-name]
+            pass
+
+
+def used_before_assignment_2(a):
+    if x == a:  # [used-before-assignment]
+        pass
+    x = 2  # [redefined-outer-name]
+
+
+def used_before_assignment_3(a):
+    if x == a:  # [used-before-assignment]
+        if x > 3:
+            x = 2  # [redefined-outer-name]
+
+
+def not_used_before_assignment(a):
+    if x == a:
+        pass
+
+
+def not_used_before_assignment_2(a):
+    x = 3  # [redefined-outer-name]
+    if x == a:
+        pass
+
+
+def func(something):
+    return something ** 3
+
+
+class FalsePositive(object):
+    x = func(x)
diff --git a/tests/functional/used_before_assignment_issue1081.txt b/tests/functional/used_before_assignment_issue1081.txt
new file mode 100644
index 000000000..9b05aac30
--- /dev/null
+++ b/tests/functional/used_before_assignment_issue1081.txt
@@ -0,0 +1,7 @@
+used-before-assignment:7:used_before_assignment_1:Using variable 'x' before assignment
+redefined-outer-name:8:used_before_assignment_1:Redefining name 'x' from outer scope (line 3)
+used-before-assignment:13:used_before_assignment_2:Using variable 'x' before assignment
+redefined-outer-name:15:used_before_assignment_2:Redefining name 'x' from outer scope (line 3)
+used-before-assignment:19:used_before_assignment_3:Using variable 'x' before assignment
+redefined-outer-name:21:used_before_assignment_3:Redefining name 'x' from outer scope (line 3)
+redefined-outer-name:30:not_used_before_assignment_2:Redefining name 'x' from outer scope (line 3)
diff --git a/tests/functional/used_before_assignment_issue853.py b/tests/functional/used_before_assignment_issue853.py
new file mode 100644
index 000000000..f8b412252
--- /dev/null
+++ b/tests/functional/used_before_assignment_issue853.py
@@ -0,0 +1,23 @@
+# pylint: disable=missing-docstring,bare-except,pointless-statement,superfluous-parens
+def strangeproblem():
+    try:
+        for _ in range(0, 4):
+            message = object()
+            print(type(message))
+    finally:
+        message = object()
+
+
+try:
+    MY_INT = 1
+    print("MY_INT = %d" % MY_INT)
+finally:
+    MY_INT = 2
+
+try:
+    pass
+except:
+    FALSE_POSITIVE = 1
+    FALSE_POSITIVE  # here pylint claims used-before-assignment
+finally:
+    FALSE_POSITIVE = 2  # this line is needed to reproduce the issue
diff --git a/tests/functional/used_before_assignment_nonlocal.py b/tests/functional/used_before_assignment_nonlocal.py
new file mode 100644
index 000000000..5cbdd510c
--- /dev/null
+++ b/tests/functional/used_before_assignment_nonlocal.py
@@ -0,0 +1,60 @@
+"""Check for nonlocal and used-before-assignment"""

+# pylint: disable=missing-docstring, unused-variable, no-init, too-few-public-methods

+

+__revision__ = 0

+

+def test_ok():

+    """ uses nonlocal """

+    cnt = 1

+    def wrap():

+        nonlocal cnt

+        cnt = cnt + 1

+    wrap()

+

+def test_fail():

+    """ doesn't use nonlocal """

+    cnt = 1

+    def wrap():

+        cnt = cnt + 1 # [used-before-assignment]

+    wrap()

+

+def test_fail2():

+    """ use nonlocal, but for other variable """

+    cnt = 1

+    count = 1

+    def wrap():

+        nonlocal count

+        cnt = cnt + 1 # [used-before-assignment]

+    wrap()

+

+def test_fail3(arg: test_fail4): # [used-before-assignment]

+    """ Depends on `test_fail4`, in argument annotation. """

+    return arg

+# +1: [used-before-assignment, used-before-assignment]

+def test_fail4(*args: test_fail5, **kwargs: undefined):

+    """ Depends on `test_fail5` and `undefined` in

+    variable and named arguments annotations.

+    """

+    return args, kwargs

+

+def test_fail5()->undefined1: # [used-before-assignment]

+    """ Depends on `undefined1` in function return annotation. """

+

+def undefined():

+    """ no op """

+

+def undefined1():

+    """ no op """

+

+

+def nonlocal_in_ifexp():

+    """bar"""

+    bug2 = True

+    def on_click(event):

+        """on_click"""

+        if event:

+            nonlocal bug2

+            bug2 = not bug2

+    on_click(True)

+

+nonlocal_in_ifexp()

diff --git a/tests/functional/used_before_assignment_nonlocal.rc b/tests/functional/used_before_assignment_nonlocal.rc
new file mode 100644
index 000000000..c093be204
--- /dev/null
+++ b/tests/functional/used_before_assignment_nonlocal.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/used_before_assignment_nonlocal.txt b/tests/functional/used_before_assignment_nonlocal.txt
new file mode 100644
index 000000000..36e635e0b
--- /dev/null
+++ b/tests/functional/used_before_assignment_nonlocal.txt
@@ -0,0 +1,6 @@
+used-before-assignment:18:test_fail.wrap:Using variable 'cnt' before assignment

+used-before-assignment:27:test_fail2.wrap:Using variable 'cnt' before assignment

+used-before-assignment:30:test_fail3:Using variable 'test_fail4' before assignment

+used-before-assignment:34:test_fail4:Using variable 'test_fail5' before assignment

+used-before-assignment:34:test_fail4:Using variable 'undefined' before assignment

+used-before-assignment:40:test_fail5:Using variable 'undefined1' before assignment
\ No newline at end of file
diff --git a/tests/functional/used_prior_global_declaration.py b/tests/functional/used_prior_global_declaration.py
new file mode 100644
index 000000000..079501022
--- /dev/null
+++ b/tests/functional/used_prior_global_declaration.py
@@ -0,0 +1,39 @@
+# pylint: disable=missing-docstring, pointless-statement, global-variable-not-assigned, global-statement
+
+
+CONST = 1
+
+
+def test():
+    CONST  # [used-prior-global-declaration]
+
+    global CONST
+
+
+def other_test():
+    CONST
+
+    global SOMETHING
+
+
+def other_test_1():
+    global SOMETHING
+
+    CONST
+
+
+def other_test_2():
+    CONST
+
+    def inner():
+        global CONST
+
+    return inner
+
+
+def other_test_3():
+    def inner():
+        return CONST
+
+    global CONST
+    return inner
diff --git a/tests/functional/used_prior_global_declaration.rc b/tests/functional/used_prior_global_declaration.rc
new file mode 100644
index 000000000..0ba2b6333
--- /dev/null
+++ b/tests/functional/used_prior_global_declaration.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/used_prior_global_declaration.txt b/tests/functional/used_prior_global_declaration.txt
new file mode 100644
index 000000000..861ba17c1
--- /dev/null
+++ b/tests/functional/used_prior_global_declaration.txt
@@ -0,0 +1 @@
+used-prior-global-declaration:8:test:Name 'CONST' is used prior to global declaration
\ No newline at end of file
diff --git a/tests/functional/useless-import-alias.py b/tests/functional/useless-import-alias.py
new file mode 100644
index 000000000..c8ef8374d
--- /dev/null
+++ b/tests/functional/useless-import-alias.py
@@ -0,0 +1,21 @@
+# pylint: disable=unused-import, missing-docstring, invalid-name, reimported, import-error, wrong-import-order, no-name-in-module, relative-beyond-top-level
+from collections import OrderedDict as OrderedDict # [useless-import-alias]
+from collections import OrderedDict as o_dict
+import os.path as path
+import os.path as p
+import foo.bar.foobar as foobar
+import os
+import os as OS
+from sys import version
+from . import bar as bar # [useless-import-alias]
+from . import bar as Bar
+from . import bar
+from ..foo import bar as bar # [useless-import-alias]
+from ..foo.bar import foobar as foobar # [useless-import-alias]
+from ..foo.bar import foobar as anotherfoobar
+from . import foo as foo, foo2 as bar2  # [useless-import-alias]
+from . import foo as bar, foo2 as foo2  # [useless-import-alias]
+from . import foo as bar, foo2 as bar2
+from foo.bar import foobar as foobar  # [useless-import-alias]
+from foo.bar import foobar as foo
+from .foo.bar import f as foobar
diff --git a/tests/functional/useless-import-alias.txt b/tests/functional/useless-import-alias.txt
new file mode 100644
index 000000000..6f90b1c95
--- /dev/null
+++ b/tests/functional/useless-import-alias.txt
@@ -0,0 +1,9 @@
+useless-import-alias:2::Import alias does not rename original package
+useless-import-alias:4::Import alias does not rename original package
+useless-import-alias:6::Import alias does not rename original package
+useless-import-alias:10::Import alias does not rename original package
+useless-import-alias:13::Import alias does not rename original package
+useless-import-alias:14::Import alias does not rename original package
+useless-import-alias:16::Import alias does not rename original package
+useless-import-alias:17::Import alias does not rename original package
+useless-import-alias:19::Import alias does not rename original package
diff --git a/tests/functional/useless_else_on_loop.py b/tests/functional/useless_else_on_loop.py
new file mode 100644
index 000000000..d686f4658
--- /dev/null
+++ b/tests/functional/useless_else_on_loop.py
@@ -0,0 +1,103 @@
+"""Check for else branches on loops with break and return only."""
+from __future__ import print_function
+__revision__ = 0
+
+def test_return_for():
+    """else + return is not accetable."""
+    for i in range(10):
+        if i % 2:
+            return i
+    else:  # [useless-else-on-loop]
+        print('math is broken')
+    return None
+
+def test_return_while():
+    """else + return is not accetable."""
+    while True:
+        return 1
+    else:  # [useless-else-on-loop]
+        print('math is broken')
+    return None
+
+
+while True:
+    def short_fun():
+        """A function with a loop."""
+        for _ in range(10):
+            break
+else:  # [useless-else-on-loop]
+    print('or else!')
+
+
+while True:
+    while False:
+        break
+else:  # [useless-else-on-loop]
+    print('or else!')
+
+for j in range(10):
+    pass
+else:  # [useless-else-on-loop]
+    print('fat chance')
+    for j in range(10):
+        break
+
+
+def test_return_for2():
+    """no false positive for break in else
+
+    https://bitbucket.org/logilab/pylint/issue/117/useless-else-on-loop-false-positives
+    """
+    for i in range(10):
+        for _ in range(i):
+            if i % 2:
+                break
+        else:
+            break
+    else:
+        print('great math')
+
+
+def test_break_in_orelse_deep():
+    """no false positive for break in else deeply nested
+    """
+    for _ in range(10):
+        if 1 < 2:
+            for _ in range(3):
+                if 3 < 2:
+                    break
+            else:
+                break
+    else:
+        return True
+    return False
+
+
+def test_break_in_orelse_deep2():
+    """should rise a useless-else-on-loop message, as the break statement is only
+    for the inner for loop
+    """
+    for _ in range(10):
+        if 1 < 2:
+            for _ in range(3):
+                if 3 < 2:
+                    break
+            else:
+                print("all right")
+    else:  # [useless-else-on-loop]
+        return True
+    return False
+
+
+def test_break_in_orelse_deep3():
+    """no false positive for break deeply nested in else
+    """
+    for _ in range(10):
+        for _ in range(3):
+            pass
+        else:
+            if 1 < 2:
+                break
+    else:
+        return True
+    return False
diff --git a/tests/functional/useless_else_on_loop.txt b/tests/functional/useless_else_on_loop.txt
new file mode 100644
index 000000000..efa1161ab
--- /dev/null
+++ b/tests/functional/useless_else_on_loop.txt
@@ -0,0 +1,6 @@
+useless-else-on-loop:10:test_return_for:Else clause on loop without a break statement
+useless-else-on-loop:18:test_return_while:Else clause on loop without a break statement
+useless-else-on-loop:28::Else clause on loop without a break statement
+useless-else-on-loop:35::Else clause on loop without a break statement
+useless-else-on-loop:40::Else clause on loop without a break statement
+useless-else-on-loop:87:test_break_in_orelse_deep2:Else clause on loop without a break statement
diff --git a/tests/functional/useless_object_inheritance.py b/tests/functional/useless_object_inheritance.py
new file mode 100644
index 000000000..562c81f6a
--- /dev/null
+++ b/tests/functional/useless_object_inheritance.py
@@ -0,0 +1,27 @@
+"""Check if a class inherits from object.
+In python3 every class implicitly inherits from object, therefore give refactoring message to
+ remove object from bases"""
+# pylint: disable=no-init, invalid-name, missing-docstring, too-few-public-methods
+# pylint: disable=inconsistent-mro
+import abc
+
+class A(object):    # [useless-object-inheritance]
+    pass
+
+class B:
+    pass
+
+class C(B, object): # [useless-object-inheritance]
+    pass
+
+class D(object, C, metaclass=abc.ABCMeta):   # [useless-object-inheritance]
+    pass
+
+class E(D, C, object, metaclass=abc.ABCMeta):   # [useless-object-inheritance]
+    pass
+
+class F(A): # positive test case
+    pass
+
+class G(B): # positive test case
+    pass
diff --git a/tests/functional/useless_object_inheritance.txt b/tests/functional/useless_object_inheritance.txt
new file mode 100644
index 000000000..2e0067367
--- /dev/null
+++ b/tests/functional/useless_object_inheritance.txt
@@ -0,0 +1,4 @@
+useless-object-inheritance:8:A:Class 'A' inherits from object, can be safely removed from bases in python3
+useless-object-inheritance:14:C:Class 'C' inherits from object, can be safely removed from bases in python3
+useless-object-inheritance:17:D:Class 'D' inherits from object, can be safely removed from bases in python3
+useless-object-inheritance:20:E:Class 'E' inherits from object, can be safely removed from bases in python3
diff --git a/tests/functional/useless_return.py b/tests/functional/useless_return.py
new file mode 100644
index 000000000..61aaebe7a
--- /dev/null
+++ b/tests/functional/useless_return.py
@@ -0,0 +1,15 @@
+# pylint: disable=missing-docstring,too-few-public-methods,no-self-use,bad-option-value, useless-object-inheritance
+from __future__ import print_function
+
+def myfunc(): # [useless-return]
+    print('---- testing ---')
+    return
+
+class SomeClass(object):
+    def mymethod(self): # [useless-return]
+        print('---- testing ---')
+        return None
+
+    # These are not emitted
+    def item_at(self):
+        return None
diff --git a/tests/functional/useless_return.txt b/tests/functional/useless_return.txt
new file mode 100644
index 000000000..c28c6d494
--- /dev/null
+++ b/tests/functional/useless_return.txt
@@ -0,0 +1,2 @@
+useless-return:4:myfunc:Useless return at end of function or method
+useless-return:9:SomeClass.mymethod:Useless return at end of function or method
diff --git a/tests/functional/useless_super_delegation.py b/tests/functional/useless_super_delegation.py
new file mode 100644
index 000000000..421f667e3
--- /dev/null
+++ b/tests/functional/useless_super_delegation.py
@@ -0,0 +1,252 @@
+# pylint: disable=missing-docstring, no-member, no-self-use, bad-super-call
+# pylint: disable=too-few-public-methods, unused-argument, invalid-name, too-many-public-methods
+# pylint: disable=line-too-long, useless-object-inheritance
+
+
+def not_a_method(param, param2):
+    return super(None, None).not_a_method(param, param2)
+
+
+class SuperBase(object):
+    def with_default_arg(self, first, default_arg="only_in_super_base"):
+        pass
+
+    def with_default_arg_bis(self, first, default_arg="only_in_super_base"):
+        pass
+
+    def with_default_arg_ter(self, first, default_arg="will_be_changed"):
+        pass
+
+    def with_default_arg_quad(self, first, default_arg="will_be_changed"):
+        pass
+
+
+class Base(SuperBase):
+
+    fake_method = not_a_method
+
+    def something(self):
+        pass
+
+    def with_default_argument(self, first, default_arg="default"):
+        pass
+
+    def with_default_argument_bis(self, first, default_arg="default"):
+        pass
+
+    def without_default_argument(self, first, second):
+        pass
+
+    def with_default_argument_none(self, first, default_arg=None):
+        pass
+
+    def without_default_argument2(self, first, second):
+        pass
+
+    def with_default_argument_int(self, first, default_arg=42):
+        pass
+
+    def with_default_argument_tuple(self, first, default_arg=()):
+        pass
+
+    def with_default_arg_ter(self, first, default_arg="has_been_changed"):
+        super(Base, self).with_default_arg_ter(first, default_arg)
+
+    def with_default_arg_quad(self, first, default_arg="has_been_changed"):
+        super(Base, self).with_default_arg_quad(first, default_arg)
+
+class NotUselessSuper(Base):
+
+    def multiple_statements(self):
+        first = 42 * 24
+        return super(NotUselessSuper, self).multiple_statements() + first
+
+    def not_a_call(self):
+        return 1 + 2
+
+    def not_super_call(self):
+        return type(self).__class__
+
+    def not_super_attribute_access(self):
+        return super(NotUselessSuper, self)
+
+    def invalid_super_call(self):
+        return super(NotUselessSuper, 1).invalid_super_call()
+
+    def other_invalid_super_call(self):
+        return super(2, 3, 4, 5).other_invalid_super_call()
+
+    def different_name(self):
+        return super(NotUselessSuper, self).something()
+
+    def different_super_mro_pointer(self):
+        return super(Base, self).different_super_mro_pointer()
+
+    def different_super_type(self):
+        return super(NotUselessSuper, NotUselessSuper).different_super_type()
+
+    def other_different_super_type(self):
+        return super(NotUselessSuper, 1).other_different_super_type()
+
+    def not_passing_param(self, first):
+        return super(NotUselessSuper, self).not_passing_param()
+
+    def modifying_param(self, first):
+        return super(NotUselessSuper, self).modifying_param(first + 1)
+
+    def transforming_param(self, first):
+        return super(NotUselessSuper, self).transforming_param(type(first))
+
+    def modifying_variadic(self, *args):
+        return super(NotUselessSuper, self).modifying_variadic(tuple(args))
+
+    def not_passing_keyword_variadics(self, *args, **kwargs):
+        return super(NotUselessSuper, self).not_passing_keyword_variadics(*args)
+
+    def not_passing_default(self, first, second=None):
+        return super(NotUselessSuper, self).not_passing_default(first)
+
+    def passing_only_a_handful(self, first, second, third, fourth):
+        return super(NotUselessSuper, self).passing_only_a_handful(
+            first, second)
+
+    def not_the_same_order(self, first, second, third):
+        return super(NotUselessSuper, self).not_the_same_order(third, first, second)
+
+    def no_kwargs_in_signature(self, key=None):
+        values = {'key': 'something'}
+        return super(NotUselessSuper, self).no_kwargs_in_signature(**values)
+
+    def no_args_in_signature(self, first, second):
+        values = (first + 1, second + 2)
+        return super(NotUselessSuper, self).no_args_in_signature(*values)
+
+    def variadics_with_multiple_keyword_arguments(self, **kwargs):
+        return super(NotUselessSuper, self).variadics_with_multiple_keyword_arguments(
+            first=None,
+            second=None,
+            **kwargs)
+
+    def extraneous_keyword_params(self, none_ok=False):
+        super(NotUselessSuper, self).extraneous_keyword_params(
+            none_ok,
+            valid_values=[23, 42])
+
+    def extraneous_positional_args(self, **args):
+        super(NotUselessSuper, self).extraneous_positional_args(
+            1, 2, **args)
+
+    def with_default_argument(self, first, default_arg="other"):
+        # Not useless because the default_arg is different from the one in the base class
+        super(NotUselessSuper, self).with_default_argument(first, default_arg)
+
+    def without_default_argument(self, first, second=True):
+        # Not useless because in the base class there is not default value for second argument
+        super(NotUselessSuper, self).without_default_argument(first, second)
+
+    def with_default_argument_none(self, first, default_arg='NotNone'):
+        # Not useless because the default_arg is different from the one in the base class
+        super(NotUselessSuper, self).with_default_argument_none(first, default_arg)
+
+    def without_default_argument2(self, first, second=None):
+        # Not useless because in the base class there is not default value for second argument
+        super(NotUselessSuper, self).without_default_argument2(first, second)
+
+    def with_default_argument_int(self, first, default_arg="42"):
+        # Not useless because the default_arg is a string whereas in the base class it's an int
+        super(NotUselessSuper, self).with_default_argument_int(first, default_arg)
+
+    def with_default_argument_tuple(self, first, default_arg=("42", "a")):
+        # Not useless because the default_arg is different from the one in the base class
+        super(NotUselessSuper, self).with_default_argument_tuple(first, default_arg)
+
+    def with_default_argument_bis(self, first, default_arg="default"):
+        # Although the default_arg is the same as in the base class, the call signature
+        # differs. Thus it is not useless.
+        super(NotUselessSuper, self).with_default_argument_bis(default_arg + "_argument")
+
+    def fake_method(self, param2="other"):
+        super(NotUselessSuper, self).fake_method(param2)
+
+    def with_default_arg(self, first, default_arg="only_in_super_base"):
+        # Not useless because the call of this method is different from the function signature
+        super(NotUselessSuper, self).with_default_arg(first, default_arg + "_and_here")
+
+    def with_default_arg_bis(self, first, default_arg="default_changed"):
+        # Not useless because the default value is different from the SuperBase one
+        super(NotUselessSuper, self).with_default_arg_bis(first, default_arg)
+
+    def with_default_arg_ter(self, first, default_arg="has_been_changed_again"):
+        # Not useless because the default value is different from the Base one
+        super(NotUselessSuper, self).with_default_arg_ter(first, default_arg)
+
+    def with_default_arg_quad(self, first, default_arg="has_been_changed"):
+        # Not useless because the default value is the same as in the base but the
+        # call is different from the signature
+        super(NotUselessSuper, self).with_default_arg_quad(first, default_arg + "_and_modified")
+
+
+class UselessSuper(Base):
+
+    def equivalent_params(self): # [useless-super-delegation]
+        return super(UselessSuper, self).equivalent_params()
+
+    def equivalent_params_1(self, first): # [useless-super-delegation]
+        return super(UselessSuper, self).equivalent_params_1(first)
+
+    def equivalent_params_2(self, *args): # [useless-super-delegation]
+        return super(UselessSuper, self).equivalent_params_2(*args)
+
+    def equivalent_params_3(self, *args, **kwargs): # [useless-super-delegation]
+        return super(UselessSuper, self).equivalent_params_3(*args, **kwargs)
+
+    def equivalent_params_4(self, first): # [useless-super-delegation]
+        super(UselessSuper, self).equivalent_params_4(first)
+
+    def equivalent_params_5(self, first, *args): # [useless-super-delegation]
+        super(UselessSuper, self).equivalent_params_5(first, *args)
+
+    def equivalent_params_6(self, first, *args, **kwargs): # [useless-super-delegation]
+        return super(UselessSuper, self).equivalent_params_6(first, *args, **kwargs)
+
+    def with_default_argument(self, first, default_arg="default"): # [useless-super-delegation]
+        # useless because the default value here is the same as in the base class
+        return super(UselessSuper, self).with_default_argument(first, default_arg)
+
+    def without_default_argument(self, first, second): # [useless-super-delegation]
+        return super(UselessSuper, self).without_default_argument(first, second)
+
+    def with_default_argument_none(self, first, default_arg=None): # [useless-super-delegation]
+        # useless because the default value here is the same as in the base class
+        super(UselessSuper, self).with_default_argument_none(first, default_arg)
+
+    def with_default_argument_int(self, first, default_arg=42): # [useless-super-delegation]
+        super(UselessSuper, self).with_default_argument_int(first, default_arg)
+
+    def with_default_argument_tuple(self, first, default_arg=()): # [useless-super-delegation]
+        super(UselessSuper, self).with_default_argument_tuple(first, default_arg)
+
+    def __init__(self): # [useless-super-delegation]
+        super(UselessSuper, self).__init__()
+
+    def with_default_arg(self, first, default_arg="only_in_super_base"): # [useless-super-delegation]
+        super(UselessSuper, self).with_default_arg(first, default_arg)
+
+    def with_default_arg_bis(self, first, default_arg="only_in_super_base"): # [useless-super-delegation]
+        super(UselessSuper, self).with_default_arg_bis(first, default_arg)
+
+    def with_default_arg_ter(self, first, default_arg="has_been_changed"): # [useless-super-delegation]
+        super(UselessSuper, self).with_default_arg_ter(first, default_arg)
+
+    def with_default_arg_quad(self, first, default_arg="has_been_changed"): # [useless-super-delegation]
+        super(UselessSuper, self).with_default_arg_quad(first, default_arg)
+
+
+def trigger_something(value_to_trigger):
+    pass
+
+
+class NotUselessSuperDecorators(Base):
+    @trigger_something('value1')
+    def method_decorated(self):
+        super(NotUselessSuperDecorators, self).method_decorated()
diff --git a/tests/functional/useless_super_delegation.txt b/tests/functional/useless_super_delegation.txt
new file mode 100644
index 000000000..4426fd125
--- /dev/null
+++ b/tests/functional/useless_super_delegation.txt
@@ -0,0 +1,17 @@
+useless-super-delegation:191:UselessSuper.equivalent_params:Useless super delegation in method 'equivalent_params'
+useless-super-delegation:194:UselessSuper.equivalent_params_1:Useless super delegation in method 'equivalent_params_1'
+useless-super-delegation:197:UselessSuper.equivalent_params_2:Useless super delegation in method 'equivalent_params_2'
+useless-super-delegation:200:UselessSuper.equivalent_params_3:Useless super delegation in method 'equivalent_params_3'
+useless-super-delegation:203:UselessSuper.equivalent_params_4:Useless super delegation in method 'equivalent_params_4'
+useless-super-delegation:206:UselessSuper.equivalent_params_5:Useless super delegation in method 'equivalent_params_5'
+useless-super-delegation:209:UselessSuper.equivalent_params_6:Useless super delegation in method 'equivalent_params_6'
+useless-super-delegation:212:UselessSuper.with_default_argument:Useless super delegation in method 'with_default_argument'
+useless-super-delegation:216:UselessSuper.without_default_argument:Useless super delegation in method 'without_default_argument'
+useless-super-delegation:219:UselessSuper.with_default_argument_none:Useless super delegation in method 'with_default_argument_none'
+useless-super-delegation:223:UselessSuper.with_default_argument_int:Useless super delegation in method 'with_default_argument_int'
+useless-super-delegation:226:UselessSuper.with_default_argument_tuple:Useless super delegation in method 'with_default_argument_tuple'
+useless-super-delegation:229:UselessSuper.__init__:Useless super delegation in method '__init__'
+useless-super-delegation:232:UselessSuper.with_default_arg:Useless super delegation in method 'with_default_arg'
+useless-super-delegation:235:UselessSuper.with_default_arg_bis:Useless super delegation in method 'with_default_arg_bis'
+useless-super-delegation:238:UselessSuper.with_default_arg_ter:Useless super delegation in method 'with_default_arg_ter'
+useless-super-delegation:241:UselessSuper.with_default_arg_quad:Useless super delegation in method 'with_default_arg_quad'
diff --git a/tests/functional/useless_super_delegation_py3.py b/tests/functional/useless_super_delegation_py3.py
new file mode 100644
index 000000000..09bc25b4c
--- /dev/null
+++ b/tests/functional/useless_super_delegation_py3.py
@@ -0,0 +1,43 @@
+# pylint: disable=missing-docstring, no-member, unused-argument, invalid-name,unused-variable
+# pylint: disable=too-few-public-methods,wrong-import-position, useless-object-inheritance
+
+class NotUselessSuper(object):
+
+    def not_passing_keyword_only(self, first, *, second):
+        return super(NotUselessSuper, self).not_passing_keyword_only(first)
+
+    def passing_keyword_only_with_modifications(self, first, *, second):
+        return super(NotUselessSuper, self).passing_keyword_only_with_modifications(
+            first, second + 1)
+
+
+class AlsoNotUselessSuper(NotUselessSuper):
+    def not_passing_keyword_only(self, first, *, second="second"):
+        return super().not_passing_keyword_only(first, second=second)
+
+
+class UselessSuper(object):
+
+    def useless(self, *, first): # [useless-super-delegation]
+        super(UselessSuper, self).useless(first=first)
+
+
+class Egg():
+    def __init__(self, thing: object) -> None:
+        pass
+
+class Spam(Egg):
+    def __init__(self, thing: int) -> None:
+        super().__init__(thing)
+
+class Ham(Egg):
+    def __init__(self, thing: object) -> None: # [useless-super-delegation]
+        super().__init__(thing)
+
+
+from typing import List
+
+
+class Test:
+    def __init__(self, _arg: List[int]) -> None:
+        super().__init__()
diff --git a/tests/functional/useless_super_delegation_py3.rc b/tests/functional/useless_super_delegation_py3.rc
new file mode 100644
index 000000000..c093be204
--- /dev/null
+++ b/tests/functional/useless_super_delegation_py3.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.0
diff --git a/tests/functional/useless_super_delegation_py3.txt b/tests/functional/useless_super_delegation_py3.txt
new file mode 100644
index 000000000..433c7a9bc
--- /dev/null
+++ b/tests/functional/useless_super_delegation_py3.txt
@@ -0,0 +1,2 @@
+useless-super-delegation:21:UselessSuper.useless:Useless super delegation in method 'useless'
+useless-super-delegation:34:Ham.__init__:Useless super delegation in method '__init__'
diff --git a/tests/functional/useless_super_delegation_py35.py b/tests/functional/useless_super_delegation_py35.py
new file mode 100644
index 000000000..ffc3c6c74
--- /dev/null
+++ b/tests/functional/useless_super_delegation_py35.py
@@ -0,0 +1,12 @@
+# pylint: disable=missing-docstring,too-few-public-methods,no-member,unused-argument, useless-object-inheritance
+
+class NotUselessSuper(object):
+
+    def not_passing_all_params(self, first, *args, second=None, **kwargs):
+        return super(NotUselessSuper, self).not_passing_all_params(*args, second, **kwargs)
+
+
+class UselessSuper(object):
+
+    def useless(self, first, *, second=None, **kwargs): # [useless-super-delegation]
+        return super(UselessSuper, self).useless(first, second=second, **kwargs)
diff --git a/tests/functional/useless_super_delegation_py35.rc b/tests/functional/useless_super_delegation_py35.rc
new file mode 100644
index 000000000..71de8b630
--- /dev/null
+++ b/tests/functional/useless_super_delegation_py35.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5
diff --git a/tests/functional/useless_super_delegation_py35.txt b/tests/functional/useless_super_delegation_py35.txt
new file mode 100644
index 000000000..8d9cdaa77
--- /dev/null
+++ b/tests/functional/useless_super_delegation_py35.txt
@@ -0,0 +1 @@
+useless-super-delegation:11:UselessSuper.useless:Useless super delegation in method 'useless'
\ No newline at end of file
diff --git a/tests/functional/using_constant_test.py b/tests/functional/using_constant_test.py
new file mode 100644
index 000000000..732164ecd
--- /dev/null
+++ b/tests/functional/using_constant_test.py
@@ -0,0 +1,142 @@
+"""Verify if constant tests are used inside if statements."""
+# pylint: disable=invalid-name, missing-docstring,too-few-public-methods
+# pylint: disable=no-init,expression-not-assigned, useless-object-inheritance
+# pylint: disable=missing-parentheses-for-call-in-test
+
+
+import collections
+
+
+def function():
+    yield
+
+
+class Class(object):
+
+    def method(self):
+        pass
+
+
+instance = Class()
+
+if collections: # [using-constant-test]
+    pass
+
+# GenExpr
+if (node for node in range(10)): # [using-constant-test]
+    pass
+
+if lambda: None: # [using-constant-test]
+    pass
+
+if function: # [using-constant-test]
+    pass
+
+if Class: # [using-constant-test]
+    pass
+
+if 2: # [using-constant-test]
+    pass
+
+if True: # [using-constant-test]
+    pass
+
+if '': # [using-constant-test]
+    pass
+
+if b'': # [using-constant-test]
+    pass
+
+if 2.0: # [using-constant-test]
+    pass
+
+if {}: # [using-constant-test]
+    pass
+
+if {1, 2, 3}: # [using-constant-test]
+    pass
+
+if (1, 2, 3): # [using-constant-test]
+    pass
+
+if (): # [using-constant-test]
+    pass
+
+# Generator
+generator = function()
+if generator: # [using-constant-test]
+    pass
+
+if 1 if 2 else 3: # [using-constant-test]
+    pass
+
+def test_comprehensions():
+    [data for data in range(100) if abs] # [using-constant-test]
+    [data for data in range(100) if 1] # [using-constant-test]
+    (data for data in range(100) if abs) # [using-constant-test]
+    (data for data in range(100) if 1) # [using-constant-test]
+    {data for data in range(100) if abs} # [using-constant-test]
+    {data: 1 for data in range(100) if abs} # [using-constant-test]
+
+
+# UnboundMethod / Function
+if Class.method:  # [using-constant-test]
+    pass
+
+# BoundMethod
+if instance.method:  # [using-constant-test]
+    pass
+
+
+# For these, we require to do inference, even though the result can be a
+# constant value. For some of them, we could determine that the test
+# is constant, such as 2 + 3, but the components of the BinOp
+# can be anything else (2 + somefunccall).
+
+name = 42
+if name:
+    pass
+
+if 3 + 4:
+    pass
+
+if 3 and 4:
+    pass
+
+if not 3:
+    pass
+
+if instance.method():
+    pass
+
+# pylint: disable=misplaced-comparison-constant
+if 2 < 3:
+    pass
+
+if tuple((1, 2, 3)):
+    pass
+
+if dict():
+    pass
+
+if tuple():
+    pass
+
+if [1, 2, 3][:1]:
+    pass
+
+def test(*args):
+    if args:
+        return 42
+    return None
+
+def test_good_comprehension_checks():
+    [data for data in range(100)]
+    [data for data in range(100) if data]
+    [data for data in range(100) if abs(data)]
+    (data for data in range(100) if data)
+    (data for data in range(100) if abs(data))
+    {data for data in range(100) if data}
+    {data for data in range(100) if abs(data)}
+    {data: 1 for data in range(100) if data}
+    {data: 1 for data in range(100)}
diff --git a/tests/functional/using_constant_test.txt b/tests/functional/using_constant_test.txt
new file mode 100644
index 000000000..e10b10cca
--- /dev/null
+++ b/tests/functional/using_constant_test.txt
@@ -0,0 +1,24 @@
+using-constant-test:22::Using a conditional statement with a constant value
+using-constant-test:26::Using a conditional statement with a constant value
+using-constant-test:29::Using a conditional statement with a constant value
+using-constant-test:32::Using a conditional statement with a constant value
+using-constant-test:35::Using a conditional statement with a constant value
+using-constant-test:38::Using a conditional statement with a constant value
+using-constant-test:41::Using a conditional statement with a constant value
+using-constant-test:44::Using a conditional statement with a constant value
+using-constant-test:47::Using a conditional statement with a constant value
+using-constant-test:50::Using a conditional statement with a constant value
+using-constant-test:53::Using a conditional statement with a constant value
+using-constant-test:56::Using a conditional statement with a constant value
+using-constant-test:59::Using a conditional statement with a constant value
+using-constant-test:62::Using a conditional statement with a constant value
+using-constant-test:67::Using a conditional statement with a constant value
+using-constant-test:70::Using a conditional statement with a constant value
+using-constant-test:74:test_comprehensions:Using a conditional statement with a constant value
+using-constant-test:75:test_comprehensions:Using a conditional statement with a constant value
+using-constant-test:76:test_comprehensions:Using a conditional statement with a constant value
+using-constant-test:77:test_comprehensions:Using a conditional statement with a constant value
+using-constant-test:78:test_comprehensions:Using a conditional statement with a constant value
+using-constant-test:79:test_comprehensions:Using a conditional statement with a constant value
+using-constant-test:83::Using a conditional statement with a constant value
+using-constant-test:87::Using a conditional statement with a constant value
diff --git a/tests/functional/wildcard_import.py b/tests/functional/wildcard_import.py
new file mode 100644
index 000000000..66ae63d9e
--- /dev/null
+++ b/tests/functional/wildcard_import.py
@@ -0,0 +1,5 @@
+# pylint: disable=no-absolute-import,missing-docstring,import-error,unused-wildcard-import
+from indirect1 import * # [wildcard-import]
+# This is an unresolved import which still generates the wildcard-import
+# warning.
+from unknown.package import * # [wildcard-import]
diff --git a/tests/functional/wildcard_import.txt b/tests/functional/wildcard_import.txt
new file mode 100644
index 000000000..643d818b2
--- /dev/null
+++ b/tests/functional/wildcard_import.txt
@@ -0,0 +1,2 @@
+wildcard-import:2::Wildcard import indirect1
+wildcard-import:5::Wildcard import unknown.package
diff --git a/tests/functional/wildcard_import_allowed.py b/tests/functional/wildcard_import_allowed.py
new file mode 100644
index 000000000..21fea4738
--- /dev/null
+++ b/tests/functional/wildcard_import_allowed.py
@@ -0,0 +1,4 @@
+# pylint: disable=missing-docstring,unused-wildcard-import,redefined-builtin,import-error
+from csv import *
+from abc import *  # [wildcard-import]
+from UNINFERABLE import *  # [wildcard-import]
diff --git a/tests/functional/wildcard_import_allowed.rc b/tests/functional/wildcard_import_allowed.rc
new file mode 100644
index 000000000..c46d828f6
--- /dev/null
+++ b/tests/functional/wildcard_import_allowed.rc
@@ -0,0 +1,2 @@
+[IMPORTS]
+allow-wildcard-with-all=yes
diff --git a/tests/functional/wildcard_import_allowed.txt b/tests/functional/wildcard_import_allowed.txt
new file mode 100644
index 000000000..ef223fa82
--- /dev/null
+++ b/tests/functional/wildcard_import_allowed.txt
@@ -0,0 +1,2 @@
+wildcard-import:3::Wildcard import abc:HIGH
+wildcard-import:4::Wildcard import UNINFERABLE:HIGH
diff --git a/tests/functional/with_used_before_assign.py b/tests/functional/with_used_before_assign.py
new file mode 100644
index 000000000..64a475af1
--- /dev/null
+++ b/tests/functional/with_used_before_assign.py
@@ -0,0 +1,11 @@
+'''
+Regression test for
+https://bitbucket.org/logilab/pylint/issue/128/attributeerror-when-parsing
+'''
+from __future__ import with_statement
+
+def do_nothing():
+    """ empty """
+    with open("") as ctx.obj:  # [undefined-variable]
+        context.do()  # [used-before-assignment]
+        context = None
diff --git a/tests/functional/with_used_before_assign.txt b/tests/functional/with_used_before_assign.txt
new file mode 100644
index 000000000..783ae732d
--- /dev/null
+++ b/tests/functional/with_used_before_assign.txt
@@ -0,0 +1,2 @@
+undefined-variable:9:do_nothing:Undefined variable 'ctx'
+used-before-assignment:10:do_nothing:Using variable 'context' before assignment
diff --git a/tests/functional/with_using_generator.py b/tests/functional/with_using_generator.py
new file mode 100644
index 000000000..187bdcfea
--- /dev/null
+++ b/tests/functional/with_using_generator.py
@@ -0,0 +1,15 @@
+""" Testing with statements that use generators. This should not crash. """
+# pylint: disable=useless-object-inheritance
+
+class Base(object):
+    """ Base class. """
+    val = 0
+
+    def gen(self):
+        """ A generator. """
+        yield self.val
+
+    def fun(self):
+        """ With statement using a generator. """
+        with self.gen():  # [not-context-manager]
+            pass
diff --git a/tests/functional/with_using_generator.txt b/tests/functional/with_using_generator.txt
new file mode 100644
index 000000000..2b8103483
--- /dev/null
+++ b/tests/functional/with_using_generator.txt
@@ -0,0 +1 @@
+not-context-manager:14:Base.fun:Context manager 'generator' doesn't implement __enter__ and __exit__.
diff --git a/tests/functional/wrong_exception_operation.py b/tests/functional/wrong_exception_operation.py
new file mode 100644
index 000000000..1c3c4e380
--- /dev/null
+++ b/tests/functional/wrong_exception_operation.py
@@ -0,0 +1,18 @@
+# pylint: disable=missing-docstring, superfluous-parens
+
+
+try:
+    1/0
+except (ValueError | TypeError): # [wrong-exception-operation]
+    pass
+
+try:
+    1/0
+except (ValueError + TypeError): # [wrong-exception-operation]
+    pass
+
+
+try:
+    1/0
+except (ValueError < TypeError): # [wrong-exception-operation]
+    pass
diff --git a/tests/functional/wrong_exception_operation.txt b/tests/functional/wrong_exception_operation.txt
new file mode 100644
index 000000000..61a2e179f
--- /dev/null
+++ b/tests/functional/wrong_exception_operation.txt
@@ -0,0 +1,3 @@
+wrong-exception-operation:6::Invalid exception operation. Did you mean '(ValueError, TypeError)' instead?
+wrong-exception-operation:11::Invalid exception operation. Did you mean '(ValueError, TypeError)' instead?
+wrong-exception-operation:17::Invalid exception operation. Did you mean '(ValueError, TypeError)' instead?
diff --git a/tests/functional/wrong_import_order.py b/tests/functional/wrong_import_order.py
new file mode 100644
index 000000000..c2791d14a
--- /dev/null
+++ b/tests/functional/wrong_import_order.py
@@ -0,0 +1,43 @@
+"""Checks import order rule"""
+# pylint: disable=unused-import,relative-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level
+from __future__ import absolute_import
+try:
+    from six.moves import configparser
+except ImportError:
+    import configparser
+
+import logging
+
+import six
+import os.path  # [wrong-import-order]
+from astroid import are_exclusive
+import sys  # [wrong-import-order]
+import datetime  # [wrong-import-order]
+import unused_import
+from .package import Class
+import totally_missing  # [wrong-import-order]
+from . import package
+import astroid  # [wrong-import-order]
+from . import package2
+from .package2 import Class2
+from ..package3 import Class3
+from six.moves.urllib.parse import quote # [wrong-import-order]
+
+
+LOGGER = logging.getLogger(__name__)
+
+
+if LOGGER:
+    # imports nested skipped
+    from . import package4
+    import pprint
+    from pprint import PrettyPrinter
+
+
+try:
+    # imports nested skipped
+    from . import package4
+    import random
+    from random import division
+except ImportError:
+    LOGGER.info('A useful message here')
diff --git a/tests/functional/wrong_import_order.txt b/tests/functional/wrong_import_order.txt
new file mode 100644
index 000000000..13b601eb5
--- /dev/null
+++ b/tests/functional/wrong_import_order.txt
@@ -0,0 +1,6 @@
+wrong-import-order:12::standard import "import os.path" should be placed before "import six"
+wrong-import-order:14::standard import "import sys" should be placed before "import six"
+wrong-import-order:15::standard import "import datetime" should be placed before "import six"
+wrong-import-order:18::first party import "import totally_missing" should be placed before "from .package import Class"
+wrong-import-order:20::third party import "import astroid" should be placed before "import unused_import"
+wrong-import-order:24::third party import "from six.moves.urllib.parse import quote" should be placed before "import unused_import"
diff --git a/tests/functional/wrong_import_order2.py b/tests/functional/wrong_import_order2.py
new file mode 100644
index 000000000..4f9a100b8
--- /dev/null
+++ b/tests/functional/wrong_import_order2.py
@@ -0,0 +1,16 @@
+"""Checks import order rule in a right case"""
+# pylint: disable=unused-import,relative-import,ungrouped-imports,import-error,no-name-in-module
+
+
+# Standard imports
+import os
+from sys import argv
+
+# external imports
+import isort
+
+from six import moves
+
+# local_imports
+from . import my_package
+from .my_package import myClass
diff --git a/tests/functional/wrong_import_position.py b/tests/functional/wrong_import_position.py
new file mode 100644
index 000000000..88db33be1
--- /dev/null
+++ b/tests/functional/wrong_import_position.py
@@ -0,0 +1,33 @@
+"""Checks import order rule"""
+# pylint: disable=unused-import,relative-import,ungrouped-imports,wrong-import-order
+# pylint: disable=import-error, too-few-public-methods, missing-docstring,using-constant-test, useless-object-inheritance
+import os.path
+
+if True:
+    from astroid import are_exclusive
+try:
+    import sys
+except ImportError:
+    class Myclass(object):
+        """docstring"""
+
+if sys.version_info[0] == 3:
+    from collections import OrderedDict
+else:
+    class OrderedDict(object):
+        """Nothing to see here."""
+        def some_func(self):
+            pass
+
+import six  # [wrong-import-position]
+
+CONSTANT = True
+
+import datetime  # [wrong-import-position]
+
+VAR = 0
+for i in range(10):
+    VAR += i
+
+import scipy  # [wrong-import-position]
+import astroid  # [wrong-import-position]
diff --git a/tests/functional/wrong_import_position.txt b/tests/functional/wrong_import_position.txt
new file mode 100644
index 000000000..e734ac5e5
--- /dev/null
+++ b/tests/functional/wrong_import_position.txt
@@ -0,0 +1,4 @@
+wrong-import-position:22::Import "import six" should be placed at the top of the module
+wrong-import-position:26::Import "import datetime" should be placed at the top of the module
+wrong-import-position:32::Import "import scipy" should be placed at the top of the module
+wrong-import-position:33::Import "import astroid" should be placed at the top of the module
diff --git a/tests/functional/wrong_import_position10.py b/tests/functional/wrong_import_position10.py
new file mode 100644
index 000000000..f4a868039
--- /dev/null
+++ b/tests/functional/wrong_import_position10.py
@@ -0,0 +1,15 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import
+import os
+
+try:
+    import ast
+except ImportError:
+    def method(items):
+        """docstring"""
+        value = 0
+        for item in items:
+            value += item
+        return value
+
+import sys
diff --git a/tests/functional/wrong_import_position11.py b/tests/functional/wrong_import_position11.py
new file mode 100644
index 000000000..9af72c0e5
--- /dev/null
+++ b/tests/functional/wrong_import_position11.py
@@ -0,0 +1,4 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,pointless-string-statement
+A = 1
+import os  # [wrong-import-position]
diff --git a/tests/functional/wrong_import_position11.txt b/tests/functional/wrong_import_position11.txt
new file mode 100644
index 000000000..01bb58421
--- /dev/null
+++ b/tests/functional/wrong_import_position11.txt
@@ -0,0 +1 @@
+wrong-import-position:4::Import "import os" should be placed at the top of the module
diff --git a/tests/functional/wrong_import_position12.py b/tests/functional/wrong_import_position12.py
new file mode 100644
index 000000000..300968c40
--- /dev/null
+++ b/tests/functional/wrong_import_position12.py
@@ -0,0 +1,5 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,pointless-string-statement
+"Two string"
+
+import os  # [wrong-import-position]
diff --git a/tests/functional/wrong_import_position12.txt b/tests/functional/wrong_import_position12.txt
new file mode 100644
index 000000000..6d560822b
--- /dev/null
+++ b/tests/functional/wrong_import_position12.txt
@@ -0,0 +1 @@
+wrong-import-position:5::Import "import os" should be placed at the top of the module
diff --git a/tests/functional/wrong_import_position13.py b/tests/functional/wrong_import_position13.py
new file mode 100644
index 000000000..6b3d03463
--- /dev/null
+++ b/tests/functional/wrong_import_position13.py
@@ -0,0 +1,4 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,no-name-in-module
+A = 1
+from sys import x  # [wrong-import-position]
diff --git a/tests/functional/wrong_import_position13.txt b/tests/functional/wrong_import_position13.txt
new file mode 100644
index 000000000..f3def1900
--- /dev/null
+++ b/tests/functional/wrong_import_position13.txt
@@ -0,0 +1 @@
+wrong-import-position:4::Import "from sys import x" should be placed at the top of the module
diff --git a/tests/functional/wrong_import_position14.py b/tests/functional/wrong_import_position14.py
new file mode 100644
index 000000000..f5c9a03e5
--- /dev/null
+++ b/tests/functional/wrong_import_position14.py
@@ -0,0 +1,5 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,undefined-variable,import-error
+if x:
+    import os
+import y  # [wrong-import-position]
diff --git a/tests/functional/wrong_import_position14.txt b/tests/functional/wrong_import_position14.txt
new file mode 100644
index 000000000..9fcdac503
--- /dev/null
+++ b/tests/functional/wrong_import_position14.txt
@@ -0,0 +1 @@
+wrong-import-position:5::Import "import y" should be placed at the top of the module
diff --git a/tests/functional/wrong_import_position15.py b/tests/functional/wrong_import_position15.py
new file mode 100644
index 000000000..58a19b66c
--- /dev/null
+++ b/tests/functional/wrong_import_position15.py
@@ -0,0 +1,9 @@
+"""Checks import position rule with pep-0008"""
+# pylint: disable=unused-import
+
+__author__ = 'some author'
+__email__ = 'some.author@some_email'
+__copyright__ = 'Some copyright'
+
+
+import sys
diff --git a/tests/functional/wrong_import_position2.py b/tests/functional/wrong_import_position2.py
new file mode 100644
index 000000000..65ad9e656
--- /dev/null
+++ b/tests/functional/wrong_import_position2.py
@@ -0,0 +1,10 @@
+"""Checks import order rule with nested non_import sentence"""
+# pylint: disable=unused-import,relative-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level
+try:
+    from sys import argv
+except ImportError:
+    pass
+else:
+    pass
+
+import os
diff --git a/tests/functional/wrong_import_position3.py b/tests/functional/wrong_import_position3.py
new file mode 100644
index 000000000..d2cf68529
--- /dev/null
+++ b/tests/functional/wrong_import_position3.py
@@ -0,0 +1,3 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,relative-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level
+import os
diff --git a/tests/functional/wrong_import_position4.py b/tests/functional/wrong_import_position4.py
new file mode 100644
index 000000000..3f1174f9d
--- /dev/null
+++ b/tests/functional/wrong_import_position4.py
@@ -0,0 +1,5 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,relative-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level,unused-variable
+def method1():
+    """Method 1"""
+    import x
diff --git a/tests/functional/wrong_import_position5.py b/tests/functional/wrong_import_position5.py
new file mode 100644
index 000000000..b96a8a0e4
--- /dev/null
+++ b/tests/functional/wrong_import_position5.py
@@ -0,0 +1,4 @@
+r"""Checks import position rule"""
+# pylint: disable=unused-import,relative-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level
+
+import os
diff --git a/tests/functional/wrong_import_position6.py b/tests/functional/wrong_import_position6.py
new file mode 100644
index 000000000..694c109d1
--- /dev/null
+++ b/tests/functional/wrong_import_position6.py
@@ -0,0 +1,7 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,relative-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level,undefined-variable
+
+import y
+
+if x:
+    import os
diff --git a/tests/functional/wrong_import_position7.py b/tests/functional/wrong_import_position7.py
new file mode 100644
index 000000000..bb5095603
--- /dev/null
+++ b/tests/functional/wrong_import_position7.py
@@ -0,0 +1,9 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,relative-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level
+try:
+    import x
+except ImportError:
+    pass
+finally:
+    pass
+import y
diff --git a/tests/functional/wrong_import_position8.py b/tests/functional/wrong_import_position8.py
new file mode 100644
index 000000000..cd1028a1b
--- /dev/null
+++ b/tests/functional/wrong_import_position8.py
@@ -0,0 +1,4 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,relative-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level,undefined-variable
+if x:
+    import os
diff --git a/tests/functional/wrong_import_position9.py b/tests/functional/wrong_import_position9.py
new file mode 100644
index 000000000..a08880b8a
--- /dev/null
+++ b/tests/functional/wrong_import_position9.py
@@ -0,0 +1,9 @@
+"""Checks import position rule"""
+# pylint: disable=unused-import,relative-import,ungrouped-imports,import-error,no-name-in-module,relative-beyond-top-level
+import y
+try:
+    import x
+except ImportError:
+    pass
+else:
+    pass
diff --git a/tests/functional/wrong_import_position_exclude_dunder_main.py b/tests/functional/wrong_import_position_exclude_dunder_main.py
new file mode 100644
index 000000000..05f680377
--- /dev/null
+++ b/tests/functional/wrong_import_position_exclude_dunder_main.py
@@ -0,0 +1,12 @@
+# pylint: disable=import-error, unused-import, missing-docstring
+CONS = 42
+
+if __name__ == '__main__':
+    CONSTANT = True
+    VAR = 0
+    for i in range(10):
+        VAR += i
+
+    import six
+    import datetime
+    import astroid
diff --git a/tests/functional/wrong_import_position_exclude_dunder_main.txt b/tests/functional/wrong_import_position_exclude_dunder_main.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/functional/wrong_import_position_exclude_dunder_main.txt
diff --git a/tests/functional/yield_from_iterable_py33.py b/tests/functional/yield_from_iterable_py33.py
new file mode 100644
index 000000000..7803936d5
--- /dev/null
+++ b/tests/functional/yield_from_iterable_py33.py
@@ -0,0 +1,7 @@
+"""
+Check that `yield from`-statement takes an iterable.
+"""
+# pylint: disable=missing-docstring
+
+def to_ten():
+    yield from 10  # [not-an-iterable]
diff --git a/tests/functional/yield_from_iterable_py33.rc b/tests/functional/yield_from_iterable_py33.rc
new file mode 100644
index 000000000..3330edda5
--- /dev/null
+++ b/tests/functional/yield_from_iterable_py33.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.3
\ No newline at end of file
diff --git a/tests/functional/yield_from_iterable_py33.txt b/tests/functional/yield_from_iterable_py33.txt
new file mode 100644
index 000000000..906ee93ae
--- /dev/null
+++ b/tests/functional/yield_from_iterable_py33.txt
@@ -0,0 +1 @@
+not-an-iterable:7:to_ten:Non-iterable value 10 is used in an iterating context

diff --git a/tests/functional/yield_from_outside_func.py b/tests/functional/yield_from_outside_func.py
new file mode 100644
index 000000000..e2db90c94
--- /dev/null
+++ b/tests/functional/yield_from_outside_func.py
@@ -0,0 +1,4 @@
+"""This is gramatically correct, but it's still a SyntaxError"""
+yield from [1, 2]  # [yield-outside-function]
+
+LAMBDA_WITH_YIELD = lambda: (yield from [1, 2])
diff --git a/tests/functional/yield_from_outside_func.rc b/tests/functional/yield_from_outside_func.rc
new file mode 100644
index 000000000..28c99bc28
--- /dev/null
+++ b/tests/functional/yield_from_outside_func.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.3
diff --git a/tests/functional/yield_from_outside_func.txt b/tests/functional/yield_from_outside_func.txt
new file mode 100644
index 000000000..fa3a7fc49
--- /dev/null
+++ b/tests/functional/yield_from_outside_func.txt
@@ -0,0 +1 @@
+yield-outside-function:2::Yield outside function
diff --git a/tests/functional/yield_inside_async_function.py b/tests/functional/yield_inside_async_function.py
new file mode 100644
index 000000000..33585bf77
--- /dev/null
+++ b/tests/functional/yield_inside_async_function.py
@@ -0,0 +1,12 @@
+"""Test that `yield` or `yield from` can't be used inside an async function."""

+# pylint: disable=missing-docstring, unused-variable

+

+async def good_coro():

+    def _inner():

+        yield 42

+        yield from [1, 2, 3]

+

+

+async def bad_coro():

+    yield 42 # [yield-inside-async-function]

+    yield from [1, 2, 3] # [yield-inside-async-function]

diff --git a/tests/functional/yield_inside_async_function.rc b/tests/functional/yield_inside_async_function.rc
new file mode 100644
index 000000000..0a040cbcf
--- /dev/null
+++ b/tests/functional/yield_inside_async_function.rc
@@ -0,0 +1,3 @@
+[testoptions]
+min_pyver=3.5
+max_pyver=3.6
diff --git a/tests/functional/yield_inside_async_function.txt b/tests/functional/yield_inside_async_function.txt
new file mode 100644
index 000000000..ae97cae4b
--- /dev/null
+++ b/tests/functional/yield_inside_async_function.txt
@@ -0,0 +1,2 @@
+yield-inside-async-function:11:bad_coro:Yield inside async function
+yield-inside-async-function:12:bad_coro:Yield inside async function
\ No newline at end of file
diff --git a/tests/functional/yield_inside_async_function_py36.py b/tests/functional/yield_inside_async_function_py36.py
new file mode 100644
index 000000000..a0f52e61f
--- /dev/null
+++ b/tests/functional/yield_inside_async_function_py36.py
@@ -0,0 +1,12 @@
+"""Test that `yield` or `yield from` can't be used inside an async function."""

+# pylint: disable=missing-docstring, unused-variable

+

+async def good_coro():

+    def _inner():

+        yield 42

+        yield from [1, 2, 3]

+

+

+async def bad_coro():

+    yield 42

+    yield from [1, 2, 3] # [yield-inside-async-function]

diff --git a/tests/functional/yield_inside_async_function_py36.rc b/tests/functional/yield_inside_async_function_py36.rc
new file mode 100644
index 000000000..0ba2b6333
--- /dev/null
+++ b/tests/functional/yield_inside_async_function_py36.rc
@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.6
diff --git a/tests/functional/yield_inside_async_function_py36.txt b/tests/functional/yield_inside_async_function_py36.txt
new file mode 100644
index 000000000..d6e68d0b5
--- /dev/null
+++ b/tests/functional/yield_inside_async_function_py36.txt
@@ -0,0 +1 @@
+yield-inside-async-function:12:bad_coro:Yield inside async function
diff --git a/tests/functional/yield_outside_func.py b/tests/functional/yield_outside_func.py
new file mode 100644
index 000000000..5824bc0c7
--- /dev/null
+++ b/tests/functional/yield_outside_func.py
@@ -0,0 +1,4 @@
+"""This is gramatically correct, but it's still a SyntaxError"""
+yield 1  # [yield-outside-function]
+
+LAMBDA_WITH_YIELD = lambda: (yield)
diff --git a/tests/functional/yield_outside_func.txt b/tests/functional/yield_outside_func.txt
new file mode 100644
index 000000000..fa3a7fc49
--- /dev/null
+++ b/tests/functional/yield_outside_func.txt
@@ -0,0 +1 @@
+yield-outside-function:2::Yield outside function
diff --git a/tests/input/__init__.py b/tests/input/__init__.py
new file mode 100644
index 000000000..60e92b76c
--- /dev/null
+++ b/tests/input/__init__.py
@@ -0,0 +1 @@
+"""test"""
diff --git a/tests/input/func_3k_removed_stuff_py_30.py b/tests/input/func_3k_removed_stuff_py_30.py
new file mode 100644
index 000000000..54ad935bc
--- /dev/null
+++ b/tests/input/func_3k_removed_stuff_py_30.py
@@ -0,0 +1,13 @@
+"""test relative import"""
+# pylint: disable=no-absolute-import
+from __future__ import print_function
+import func_w0401
+__revision__ = filter(None, map(str, (1, 2, 3)))
+
+
+def function():
+    """something"""
+    print(func_w0401)
+    unic = u"unicode"
+    low = unic.looower
+    return low
diff --git a/tests/input/func_bad_cont_dictcomp_py27.py b/tests/input/func_bad_cont_dictcomp_py27.py
new file mode 100644
index 000000000..a55271079
--- /dev/null
+++ b/tests/input/func_bad_cont_dictcomp_py27.py
@@ -0,0 +1,38 @@
+"""Bad continuations in dictionary comprehensions."""
+
+__revision__ = 0
+
+# Dictionary comprehensions should not require extra indentation when breaking
+# before the 'for', which is not part of the value
+C1 = {'key{}'.format(x): 'value{}'.format(x)
+      for x in range(3)}
+
+C2 = {'key{}'.format(x): 'value{}'.format(x) for x in
+      range(3)}
+
+# Dictionary comprehensions with multiple loops broken in different places
+C3 = {x*y: (x, y) for x in range(3) for y in range(3)}
+
+C4 = {x*y: (x, y)
+      for x in range(3) for y in range(3)}
+
+C5 = {x*y: (x, y) for x
+      in range(3) for y in range(3)}
+
+C6 = {x*y: (x, y) for x in range(3)
+      for y in range(3)}
+
+C7 = {key:
+          key ** 2
+      for key in range(10)}
+
+C8 = {
+    key: key ** 2
+    for key in range(10)}
+
+# Misaligned cases for dict comprehensions
+C9 = {'key{}'.format(x): 'value{}'.format(x)
+    for x in range(3)}  # [bad-continuation]
+
+C9 = {'key{}'.format(x): 'value{}'.format(x)
+          for x in range(3)}  # [bad-continuation]
diff --git a/tests/input/func_bug113231.py b/tests/input/func_bug113231.py
new file mode 100644
index 000000000..6334ff9c8
--- /dev/null
+++ b/tests/input/func_bug113231.py
@@ -0,0 +1,24 @@
+# pylint: disable=E1101
+# pylint: disable=C0103
+# pylint: disable=R0903, useless-object-inheritance, unnecessary-pass
+"""test bugfix for #113231 in logging checker
+"""
+from __future__ import absolute_import
+# Muck up the names in an effort to confuse...
+import logging as renamed_logging
+
+__revision__ = ''
+
+class Logger(object):
+    """Fake logger"""
+    pass
+
+logger = renamed_logging.getLogger(__name__)
+fake_logger = Logger()
+
+# Statements that should be flagged:
+renamed_logging.warning('%s, %s' % (4, 5))
+logger.warning('%s' % 5)
+
+# Statements that should not be flagged:
+fake_logger.warn('%s' % 5)
diff --git a/tests/input/func_disable_linebased.py b/tests/input/func_disable_linebased.py
new file mode 100644
index 000000000..b94c2e315
--- /dev/null
+++ b/tests/input/func_disable_linebased.py
@@ -0,0 +1,14 @@
+# This is a very very very very very very very very very very very very very very very very very very very very very long line.
+# pylint: disable=line-too-long
+"""Make sure enable/disable pragmas work for messages that are applied to lines and not syntax nodes.
+
+A disable pragma for a message that applies to nodes is applied to the whole
+block if it comes before the first statement (excluding the docstring). For
+line-based messages, this behavior needs to be altered to really only apply to
+the enclosed lines.
+"""
+# pylint: enable=line-too-long
+
+from __future__ import print_function
+
+print('This is a very long line which the linter will warn about, now that line-too-long has been enabled again.')
diff --git a/tests/input/func_dotted_ancestor.py b/tests/input/func_dotted_ancestor.py
new file mode 100644
index 000000000..ff3285803
--- /dev/null
+++ b/tests/input/func_dotted_ancestor.py
@@ -0,0 +1,11 @@
+"""bla"""
+# pylint: disable=no-absolute-import
+
+from input import func_w0233
+
+__revision__ = 'yo'
+
+class Aaaa(func_w0233.AAAA):
+    """test dotted name in ancestors"""
+    def __init__(self):
+        func_w0233.AAAA.__init__(self)
diff --git a/tests/input/func_e0012.py b/tests/input/func_e0012.py
new file mode 100644
index 000000000..f4810ee7a
--- /dev/null
+++ b/tests/input/func_e0012.py
@@ -0,0 +1,4 @@
+# pylint:enable=W04044
+"""check unknown option
+"""
+__revision__ = 1
diff --git a/tests/input/func_e0204.py b/tests/input/func_e0204.py
new file mode 100644
index 000000000..9a0f708f0
--- /dev/null
+++ b/tests/input/func_e0204.py
@@ -0,0 +1,20 @@
+"""check for method without self as first argument
+"""
+# pylint: disable=useless-object-inheritance
+from __future__ import print_function
+__revision__ = 0
+
+
+class Abcd(object):
+    """dummy class"""
+
+    def __init__(truc):
+        """method without self"""
+        print(1)
+
+    def abdc(yoo):
+        """another test"""
+        print(yoo)
+    def edf(self):
+        """just another method"""
+        print('yapudju in', self)
diff --git a/tests/input/func_e12xx.py b/tests/input/func_e12xx.py
new file mode 100644
index 000000000..74984d998
--- /dev/null
+++ b/tests/input/func_e12xx.py
@@ -0,0 +1,28 @@
+# pylint: disable=E1101, no-absolute-import
+"""Test checking of log format strings
+"""
+
+import logging
+
+__revision__ = ''
+
+
+def pprint():
+    """Test string format in logging statements.
+    """
+    # These should all emit lint errors:
+    logging.info(0, '') # 1205
+    logging.info('', '') # 1205
+    logging.info('%s%', '') # 1201
+    logging.info('%s%s', '') # 1206
+    logging.info('%s%y', '', '') # 1200
+    logging.info('%s%s', '', '', '') # 1205
+
+    # These should be okay:
+    logging.info(1)
+    logging.info(True)
+    logging.info('')
+    logging.info('%s%')
+    logging.info('%s', '')
+    logging.info('%s%%', '')
+    logging.info('%s%s', '', '')
diff --git a/tests/input/func_e13xx.py b/tests/input/func_e13xx.py
new file mode 100644
index 000000000..227311cb6
--- /dev/null
+++ b/tests/input/func_e13xx.py
@@ -0,0 +1,21 @@
+"""test string format error
+"""
+# pylint: disable=print-statement,unsupported-binary-operation
+from __future__ import print_function
+
+PARG_1 = PARG_2 = PARG_3 = 1
+
+def pprint():
+    """Test string format
+    """
+    print("%s %s" % {'PARG_1': 1, 'PARG_2': 2}) # E1306
+    print("%s" % (PARG_1, PARG_2)) # E1305
+    print("%(PARG_1)d %d" % {'PARG_1': 1, 'PARG_2': 2}) # E1302
+    print("%(PARG_1)d %(PARG_2)d" % {'PARG_1': 1}) # E1304
+    print("%(PARG_1)d %(PARG_2)d" % {'PARG_1': 1, 'PARG_2':2, 'PARG_3':3}) #W1301
+    print("%(PARG_1)d %(PARG_2)d" % {'PARG_1': 1, 2:3}) # W1300 E1304
+    print("%(PARG_1)d %(PARG_2)d" % (2, 3)) # 1303
+    print("%(PARG_1)d %(PARG_2)d" % [2, 3]) # 1303
+    print("%2z" % PARG_1)
+    print("strange format %2" % PARG_2)
+    print("works in 3 %a" % 1)
diff --git a/tests/input/func_excess_escapes.py b/tests/input/func_excess_escapes.py
new file mode 100644
index 000000000..954202195
--- /dev/null
+++ b/tests/input/func_excess_escapes.py
@@ -0,0 +1,30 @@
+# pylint:disable=W0105, W0511, misplaced-comparison-constant, comparison-with-itself
+"""Stray backslash escapes may be missing a raw-string prefix."""
+
+__revision__ = '$Id$'
+
+# Bad escape sequences, which probably don't do what you expect.
+A = "\[\]\\"
+assert '\/' == '\\/'
+ESCAPE_BACKSLASH = '\`'
+
+# Valid escape sequences.
+NEWLINE = "\n"
+OLD_ESCAPES = '\a\b\f\n\t\r\v'
+HEX = '\xad\x0a\x0d'
+FALSE_OCTAL = '\o123\o000'  # Not octal in Python
+OCTAL = '\123\000'
+NOT_OCTAL = '\888\999'
+NUL = '\0'
+UNICODE = u'\u1234'
+HIGH_UNICODE = u'\U0000abcd'
+QUOTES = '\'\"'
+LITERAL_NEWLINE = '\
+'
+ESCAPE_UNICODE = "\\\\n"
+
+# Bad docstring
+"""Even in a docstring
+
+You shouldn't have ambiguous text like: C:\Program Files\alpha
+"""
diff --git a/tests/input/func_first_arg.py b/tests/input/func_first_arg.py
new file mode 100644
index 000000000..7df2fd20c
--- /dev/null
+++ b/tests/input/func_first_arg.py
@@ -0,0 +1,42 @@
+# pylint: disable=C0111, W0232, useless-object-inheritance
+"""check for methods first arguments
+"""
+
+__revision__ = 0
+
+
+class Obj(object):
+    # C0202, classmethod
+    def __new__(something):
+        pass
+
+    # C0202, classmethod
+    def class1(cls):
+        pass
+    class1 = classmethod(class1)
+
+    def class2(other):
+        pass
+    class2 = classmethod(class2)
+
+
+class Meta(type):
+    # C0204, metaclass __new__
+    def __new__(other, name, bases, dct):
+        pass
+
+    # C0203, metaclass method
+    def method1(cls):
+        pass
+
+    def method2(other):
+        pass
+
+    # C0205, metaclass classmethod
+    def class1(cls):
+        pass
+    class1 = classmethod(class1)
+
+    def class2(other):
+        pass
+    class2 = classmethod(class2)
diff --git a/tests/input/func_i0011.py b/tests/input/func_i0011.py
new file mode 100644
index 000000000..a4ef215bc
--- /dev/null
+++ b/tests/input/func_i0011.py
@@ -0,0 +1,4 @@
+# pylint:disable=W0404
+"""check warning on local disabling
+"""
+__revision__ = 1
diff --git a/tests/input/func_i0012.py b/tests/input/func_i0012.py
new file mode 100644
index 000000000..9b6fbe79f
--- /dev/null
+++ b/tests/input/func_i0012.py
@@ -0,0 +1,4 @@
+# pylint:enable=W0404
+"""check warning on local enabling
+"""
+__revision__ = 1
diff --git a/tests/input/func_i0013.py b/tests/input/func_i0013.py
new file mode 100644
index 000000000..0a3f83367
--- /dev/null
+++ b/tests/input/func_i0013.py
@@ -0,0 +1,8 @@
+# pylint: skip-file
+"""disable-all is usable as an inline option"""
+
+# no warning should be issued
+try:
+    import this
+except:
+    pass
diff --git a/tests/input/func_i0014.py b/tests/input/func_i0014.py
new file mode 100644
index 000000000..63ff37c9f
--- /dev/null
+++ b/tests/input/func_i0014.py
@@ -0,0 +1,8 @@
+# pylint: disable-all
+"""disable-all is usable as an inline option"""
+
+# no warning should be issued
+try:
+    import this
+except:
+    pass
diff --git a/tests/input/func_i0020.py b/tests/input/func_i0020.py
new file mode 100644
index 000000000..8c0fe9f5c
--- /dev/null
+++ b/tests/input/func_i0020.py
@@ -0,0 +1,8 @@
+"""Test for reporting of suppressed messages."""
+
+__revision__ = 0
+
+def suppressed():
+    """A function with an unused variable."""
+    # pylint: disable=W0612
+    var = 0
diff --git a/tests/input/func_i0022.py b/tests/input/func_i0022.py
new file mode 100644
index 000000000..f5b308f70
--- /dev/null
+++ b/tests/input/func_i0022.py
@@ -0,0 +1,22 @@
+"""Deprecated suppression style."""
+
+__revision__ = None
+
+a = 1  # pylint: disable=invalid-name
+b = 1  # pylint: disable-msg=invalid-name
+
+# pylint: disable=invalid-name
+c = 1
+# pylint: enable=invalid-name
+
+# pylint: disable-msg=invalid-name
+d = 1
+# pylint: enable-msg=invalid-name
+
+# pylint: disable-msg=C0103
+e = 1
+# pylint: enable-msg=C0103
+
+# pylint: disable=C0103
+f = 1
+# pylint: enable=C0103
diff --git a/tests/input/func_logging_not_lazy_with_logger.py b/tests/input/func_logging_not_lazy_with_logger.py
new file mode 100644
index 000000000..973a5c795
--- /dev/null
+++ b/tests/input/func_logging_not_lazy_with_logger.py
@@ -0,0 +1,13 @@
+"""Logging warnings using a logger class."""
+from __future__ import absolute_import
+import logging
+
+__revision__ = ''
+
+LOG = logging.getLogger("domain")
+LOG.debug("%s" % "junk")
+LOG.log(logging.DEBUG, "%s" % "junk")
+LOG2 = LOG.debug
+LOG2("%s" % "junk")
+
+logging.getLogger("domain").debug("%s" % "junk")
diff --git a/tests/input/func_loopvar_in_dict_comp_py27.py b/tests/input/func_loopvar_in_dict_comp_py27.py
new file mode 100644
index 000000000..312eee727
--- /dev/null
+++ b/tests/input/func_loopvar_in_dict_comp_py27.py
@@ -0,0 +1,8 @@
+"""Tests for loopvar-in-closure."""
+
+__revision__ = 0
+
+
+def bad_case():
+    """Loop variable from dict comprehension."""
+    return {x: lambda: x for x in range(10)}
diff --git a/tests/input/func_module___dict__.py b/tests/input/func_module___dict__.py
new file mode 100644
index 000000000..54514224a
--- /dev/null
+++ b/tests/input/func_module___dict__.py
@@ -0,0 +1,9 @@
+"""http://www.logilab.org/ticket/6949."""
+from __future__ import print_function
+__revision__ = None
+
+print(__dict__ is not None)
+
+__dict__ = {}
+
+print(__dict__ is not None)
diff --git a/tests/input/func_nameerror_on_string_substitution.py b/tests/input/func_nameerror_on_string_substitution.py
new file mode 100644
index 000000000..be7b5c82a
--- /dev/null
+++ b/tests/input/func_nameerror_on_string_substitution.py
@@ -0,0 +1,8 @@
+"""pylint doesn't see the NameError in this module"""
+
+__revision__ = None
+
+MSG = "hello %s" % MSG
+
+MSG2 = ("hello %s" %
+        MSG2)
diff --git a/tests/input/func_no_dummy_redefined.py b/tests/input/func_no_dummy_redefined.py
new file mode 100644
index 000000000..a5c0aea4a
--- /dev/null
+++ b/tests/input/func_no_dummy_redefined.py
@@ -0,0 +1,14 @@
+"""Make sure warnings about redefinitions do not trigger for dummy variables."""
+from __future__ import print_function
+
+
+_, INTERESTING = 'a=b'.split('=')
+
+value = 10
+
+
+def clobbering():
+    """Clobbers a dummy name from the outer scope."""
+    value = 9
+    for _ in range(7):
+        print(value)
diff --git a/tests/input/func_noerror___init___return_from_inner_function.py b/tests/input/func_noerror___init___return_from_inner_function.py
new file mode 100644
index 000000000..769d5ac96
--- /dev/null
+++ b/tests/input/func_noerror___init___return_from_inner_function.py
@@ -0,0 +1,12 @@
+# pylint: disable=R0903, useless-object-inheritance
+"""#10075"""
+
+__revision__ = 1
+
+class Aaa(object):
+    """docstring"""
+    def __init__(self):
+        def inner_function(arg):
+            """inner docstring"""
+            return arg + 4
+        self.func = inner_function
diff --git a/tests/input/func_noerror_access_attr_before_def_false_positive.py b/tests/input/func_noerror_access_attr_before_def_false_positive.py
new file mode 100644
index 000000000..3884c9980
--- /dev/null
+++ b/tests/input/func_noerror_access_attr_before_def_false_positive.py
@@ -0,0 +1,98 @@
+#pylint: disable=C0103,R0904,R0903,W0201,no-absolute-import, useless-object-inheritance
+"""
+This module demonstrates a possible problem of pyLint with calling __init__ s
+from inherited classes.
+Initializations done there are not considered, which results in Error E0203 for
+self.cookedq.
+"""
+
+from __future__ import print_function
+
+import telnetlib
+
+class SeeTelnet(telnetlib.Telnet):
+    """
+    Extension of telnetlib.
+    """
+
+    def __init__(self, host=None, port=0):
+        """
+        Constructor.
+        When called without arguments, create an unconnected instance.
+        With a hostname argument, it connects the instance; a port
+        number is optional.
+        Parameter:
+        - host: IP address of the host
+        - port: Port number
+        """
+        telnetlib.Telnet.__init__(self, host, port)
+
+    def readUntilArray(self, matches, _=None):
+        """
+        Read until a given string is encountered or until timeout.
+        ...
+        """
+        self.process_rawq()
+        maxLength = 0
+        for match in matches:
+            if len(match) > maxLength:
+                maxLength = len(match)
+
+class Base(object):
+    """bla bla"""
+    dougloup_papa = None
+
+    def __init__(self):
+        self._var = False
+
+class Derived(Base):
+    """derived blabla"""
+    dougloup_moi = None
+    def Work(self):
+        """do something"""
+        # E0203 - Access to member '_var' before its definition
+        if self._var:
+            print("True")
+        else:
+            print("False")
+        self._var = True
+
+        # E0203 - Access to member 'dougloup_papa' before its definition
+        if self.dougloup_papa:
+            print('dougloup !')
+        self.dougloup_papa = True
+        # E0203 - Access to member 'dougloup_moi' before its definition
+        if self.dougloup_moi:
+            print('dougloup !')
+        self.dougloup_moi = True
+
+
+class QoSALConnection(object):
+    """blabla"""
+
+    _the_instance = None
+
+    def __new__(cls):
+        if cls._the_instance is None:
+            cls._the_instance = object.__new__(cls)
+        return cls._the_instance
+
+    def __init__(self):
+        pass
+
+class DefinedOutsideInit(object):
+    """use_attr is seen as the method defining attr because its in
+    first position
+    """
+    def __init__(self):
+        self.reset()
+
+    def use_attr(self):
+        """use and set members"""
+        if self.attr:
+            print('hop')
+        self.attr = 10
+
+    def reset(self):
+        """reset members"""
+        self.attr = 4
diff --git a/tests/input/func_noerror_base_init_vars.py b/tests/input/func_noerror_base_init_vars.py
new file mode 100644
index 000000000..152cbfd47
--- /dev/null
+++ b/tests/input/func_noerror_base_init_vars.py
@@ -0,0 +1,35 @@
+# pylint:disable=R0201, print-statement, too-few-public-methods, useless-object-inheritance
+"""Checks that class variables are seen as inherited !
+"""
+__revision__ = ''
+
+class BaseClass(object):
+    """A simple base class
+    """
+
+    def __init__(self):
+        self.base_var = {}
+
+    def met(self):
+        """yo"""
+    def meeting(self, with_):
+        """ye"""
+        return with_
+class MyClass(BaseClass):
+    """Inherits from BaseClass
+    """
+
+    def __init__(self):
+        BaseClass.__init__(self)
+        self.var = {}
+
+    def met(self):
+        """Checks that base_var is not seen as defined outsite '__init__'
+        """
+        self.var[1] = 'one'
+        self.base_var[1] = 'one'
+        return self.base_var, self.var
+
+if __name__ == '__main__':
+    OBJ = MyClass()
+    OBJ.met()
diff --git a/tests/input/func_noerror_builtin_module_test.py b/tests/input/func_noerror_builtin_module_test.py
new file mode 100644
index 000000000..9b1e7ce8e
--- /dev/null
+++ b/tests/input/func_noerror_builtin_module_test.py
@@ -0,0 +1,11 @@
+"""test import from a builtin module"""
+
+from __future__ import absolute_import
+from math import log10
+
+__revision__ = None
+
+
+def log10_2():
+    """bla bla bla"""
+    return log10(2)
diff --git a/tests/input/func_noerror_class_attributes.py b/tests/input/func_noerror_class_attributes.py
new file mode 100644
index 000000000..b6fd4601e
--- /dev/null
+++ b/tests/input/func_noerror_class_attributes.py
@@ -0,0 +1,18 @@
+"""Test that valid class attribute doesn't trigger errors"""
+__revision__ = 'sponge bob'
+# pylint: disable=useless-object-inheritance
+
+class Clazz(object):
+    "dummy class"
+
+    def __init__(self):
+        self.topic = 5
+        self._data = 45
+
+    def change_type(self, new_class):
+        """Change type"""
+        self.__class__ = new_class
+
+    def do_nothing(self):
+        "I do nothing useful"
+        return self.topic + 56
diff --git a/tests/input/func_noerror_classes_meth_could_be_a_function.py b/tests/input/func_noerror_classes_meth_could_be_a_function.py
new file mode 100644
index 000000000..05a6c40d7
--- /dev/null
+++ b/tests/input/func_noerror_classes_meth_could_be_a_function.py
@@ -0,0 +1,33 @@
+# pylint: disable=C0111,R0903,W0232, useless-object-inheritance
+"""
+#2479
+
+R0201 (formely W0212), Method could be a function shouldn't be emitted in case
+like factory method pattern
+"""
+__revision__ = 1
+
+class XAsub(object):
+    pass
+class XBsub(XAsub):
+    pass
+class XCsub(XAsub):
+    pass
+
+class Aimpl(object):
+    # disable "method could be a function" on classes which are not overriding
+    # the factory method because in that case the usage of polymorphism is not
+    # detected
+    # pylint: disable=R0201
+    def makex(self):
+        return XAsub()
+
+class Bimpl(Aimpl):
+
+    def makex(self):
+        return XBsub()
+
+class Cimpl(Aimpl):
+
+    def makex(self):
+        return XCsub()
diff --git a/tests/input/func_noerror_classes_protected_member_access.py b/tests/input/func_noerror_classes_protected_member_access.py
new file mode 100644
index 000000000..516efd7d4
--- /dev/null
+++ b/tests/input/func_noerror_classes_protected_member_access.py
@@ -0,0 +1,26 @@
+"""
+#3123: W0212 false positive on static method
+"""
+__revision__ = 1
+
+# pylint: disable=no-classmethod-decorator, no-staticmethod-decorator, useless-object-inheritance
+class A3123(object):
+    """oypuee"""
+    _protected = 1
+    def __init__(self):
+        pass
+
+
+    def cmeth(cls, val):
+        """set protected member"""
+        cls._protected = +val
+
+    cmeth = classmethod(cmeth)
+
+    def smeth(val):
+        """set protected member"""
+        A3123._protected += val
+
+    smeth = staticmethod(smeth)
+
+    prop = property(lambda self: self._protected)
diff --git a/tests/input/func_noerror_decorator_scope.py b/tests/input/func_noerror_decorator_scope.py
new file mode 100644
index 000000000..8d35159e9
--- /dev/null
+++ b/tests/input/func_noerror_decorator_scope.py
@@ -0,0 +1,19 @@
+# -*- pylint: disable=W0232,R0903, useless-object-inheritance
+"""Test that decorators sees the class namespace - just like
+function default values does but function body doesn't.
+
+https://www.logilab.net/elo/ticket/3711 - bug finding decorator arguments
+https://www.logilab.net/elo/ticket/5626 - name resolution bug inside classes
+"""
+
+from __future__ import print_function
+
+class Test(object):
+    """test class"""
+    ident = lambda x: x
+
+    @ident(ident)
+    def method(self, val=ident(7), func=ident):
+        """hop"""
+        print(self)
+        return func(val)
diff --git a/tests/input/func_noerror_e1101_9588_base_attr_aug_assign.py b/tests/input/func_noerror_e1101_9588_base_attr_aug_assign.py
new file mode 100644
index 000000000..14be39853
--- /dev/null
+++ b/tests/input/func_noerror_e1101_9588_base_attr_aug_assign.py
@@ -0,0 +1,38 @@
+# pylint: disable=R0903, useless-object-inheritance
+"""
+False positive case of E1101:
+
+The error is triggered when the attribute set in the base class is
+modified with augmented assignment in a derived class.
+
+http://www.logilab.org/ticket/9588
+"""
+__revision__ = 0
+
+class BaseClass(object):
+    "The base class"
+    def __init__(self):
+        "Set an attribute."
+        self.e1101 = 1
+
+class FalsePositiveClass(BaseClass):
+    "The first derived class which triggers the false positive"
+    def __init__(self):
+        "Augmented assignment triggers E1101."
+        BaseClass.__init__(self)
+        self.e1101 += 1
+
+    def countup(self):
+        "Consequently this also triggers E1101."
+        self.e1101 += 1
+
+class NegativeClass(BaseClass):
+    "The second derived class, which does not trigger the error E1101"
+    def __init__(self):
+        "Ordinary assignment is OK."
+        BaseClass.__init__(self)
+        self.e1101 = self.e1101 + 1
+
+    def countup(self):
+        "No problem."
+        self.e1101 += 1
diff --git a/tests/input/func_noerror_external_classmethod_crash.py b/tests/input/func_noerror_external_classmethod_crash.py
new file mode 100644
index 000000000..e9842a5e5
--- /dev/null
+++ b/tests/input/func_noerror_external_classmethod_crash.py
@@ -0,0 +1,21 @@
+# pylint: disable=W0232,R0903,W0613, useless-object-inheritance
+"""tagging a function as a class method cause a crash when checking for
+signature overriding
+"""
+
+def fetch_config(mainattr=None):
+    """return a class method"""
+
+    def fetch_order(cls, attr, var):
+        """a class method"""
+        if attr == mainattr:
+            return var
+        return None
+    fetch_order = classmethod(fetch_order)
+    return fetch_order
+
+class Aaa(object):
+    """hop"""
+    fetch_order = fetch_config('A')
+
+__revision__ = None
diff --git a/tests/input/func_noerror_inner_classes.py b/tests/input/func_noerror_inner_classes.py
new file mode 100644
index 000000000..24a2edb80
--- /dev/null
+++ b/tests/input/func_noerror_inner_classes.py
@@ -0,0 +1,33 @@
+# pylint: disable=R0903, useless-object-inheritance, unnecessary-pass
+"""Backend Base Classes for the schwelm user DB"""
+
+__revision__ = "alpha"
+
+class Aaa(object):
+    """docstring"""
+    def __init__(self):
+        self.__setattr__('a', 'b')
+
+
+    def one_public(self):
+        """docstring"""
+        pass
+
+    def another_public(self):
+        """docstring"""
+        pass
+
+class Bbb(Aaa):
+    """docstring"""
+    pass
+
+class Ccc(Aaa):
+    """docstring"""
+
+    class Ddd(Aaa):
+        """docstring"""
+        pass
+
+    class Eee(Ddd):
+        """docstring"""
+        pass
diff --git a/tests/input/func_noerror_lambda_use_before_assign.py b/tests/input/func_noerror_lambda_use_before_assign.py
new file mode 100644
index 000000000..af2775cae
--- /dev/null
+++ b/tests/input/func_noerror_lambda_use_before_assign.py
@@ -0,0 +1,8 @@
+"""https://www.logilab.net/elo/ticket/18862"""
+from __future__ import print_function
+__revision__ = 1
+def function():
+    """hop"""
+    ggg = lambda: xxx
+    xxx = 1
+    print(ggg())
diff --git a/tests/input/func_noerror_mcs_attr_access.py b/tests/input/func_noerror_mcs_attr_access.py
new file mode 100644
index 000000000..149e07812
--- /dev/null
+++ b/tests/input/func_noerror_mcs_attr_access.py
@@ -0,0 +1,20 @@
+# pylint: disable=R0903, metaclass-assignment, useless-object-inheritance
+"""test attribute access on metaclass"""
+
+
+from __future__ import print_function
+
+class Meta(type):
+    """the meta class"""
+    def __init__(cls, name, bases, dictionary):
+        super(Meta, cls).__init__(name, bases, dictionary)
+        print(cls, cls._meta_args)
+        delattr(cls, '_meta_args')
+
+class Test(object):
+    """metaclassed class"""
+    __metaclass__ = Meta
+    _meta_args = ('foo', 'bar')
+
+    def __init__(self):
+        print('__init__', self)
diff --git a/tests/input/func_noerror_new_style_class_py_30.py b/tests/input/func_noerror_new_style_class_py_30.py
new file mode 100644
index 000000000..a33ae19f4
--- /dev/null
+++ b/tests/input/func_noerror_new_style_class_py_30.py
@@ -0,0 +1,45 @@
+"""check builtin data descriptors such as mode and name attributes
+on a file are correctly handled
+
+bug notified by Pierre Rouleau on 2005-04-24
+"""
+from __future__ import print_function
+__revision__ = None
+
+class File(file):  # pylint: disable=file-builtin
+    """ Testing new-style class inheritance from file"""
+
+    #
+    def __init__(self, name, mode="r", buffering=-1, verbose=False):
+        """Constructor"""
+
+        self.was_modified = False
+        self.verbose = verbose
+        super(File, self).__init__(name, mode, buffering)
+        if self.verbose:
+            print("File %s is opened.  The mode is: %s" % (self.name,
+                                                           self.mode))
+
+    #
+    def write(self, a_string):
+        """ Write a string to the file."""
+
+        super(File, self).write(a_string)
+        self.was_modified = True
+
+    #
+    def writelines(self, sequence):
+        """ Write a sequence of strings to the file. """
+
+        super(File, self).writelines(sequence)
+        self.was_modified = True
+
+    #
+    def close(self):
+        """Close the file."""
+
+        if self.verbose:
+            print("Closing file %s" % self.name)
+
+        super(File, self).close()
+        self.was_modified = False
diff --git a/tests/input/func_noerror_no_warning_docstring.py b/tests/input/func_noerror_no_warning_docstring.py
new file mode 100644
index 000000000..315eeeaab
--- /dev/null
+++ b/tests/input/func_noerror_no_warning_docstring.py
@@ -0,0 +1,42 @@
+''' Test for inheritance '''
+from __future__ import print_function
+__revision__ = 1
+# pylint: disable=too-few-public-methods, using-constant-test, useless-object-inheritance
+class AAAA(object):
+    ''' class AAAA '''
+
+    def __init__(self):
+        pass
+
+    def method1(self):
+        ''' method 1 '''
+        print(self)
+
+    def method2(self):
+        ''' method 2 '''
+        print(self)
+
+class BBBB(AAAA):
+    ''' class BBBB '''
+
+    def __init__(self):
+        AAAA.__init__(self)
+
+    # should ignore docstring calling from class AAAA
+    def method1(self):
+        AAAA.method1(self)
+
+class CCCC(BBBB):
+    ''' class CCCC '''
+
+    def __init__(self):
+        BBBB.__init__(self)
+
+    # should ignore docstring since CCCC is inherited from BBBB which is
+    # inherited from AAAA containing method2
+    if __revision__:
+        def method2(self):
+            AAAA.method2(self)
+    else:
+        def method2(self):
+            AAAA.method1(self)
diff --git a/tests/input/func_noerror_object_as_class_attribute.py b/tests/input/func_noerror_object_as_class_attribute.py
new file mode 100644
index 000000000..71cd027b7
--- /dev/null
+++ b/tests/input/func_noerror_object_as_class_attribute.py
@@ -0,0 +1,18 @@
+# pylint: disable=R0903, useless-object-inheritance
+"""Test case for the problem described below :
+ - A class extends 'object'
+ - This class defines its own __init__()
+   * pylint will therefore check that baseclasses' init()
+     are called
+ - If this class defines an 'object' attribute, then pylint
+   will use this new definition when trying to retrieve
+   object.__init__()
+"""
+
+__revision__ = None
+
+class Statement(object):
+    """ ... """
+    def __init__(self):
+        pass
+    object = None
diff --git a/tests/input/func_noerror_overloaded_operator.py b/tests/input/func_noerror_overloaded_operator.py
new file mode 100644
index 000000000..3a158b00b
--- /dev/null
+++ b/tests/input/func_noerror_overloaded_operator.py
@@ -0,0 +1,21 @@
+# pylint: disable=C0111,R0903, useless-object-inheritance
+"""#3291"""
+from __future__ import print_function
+
+class Myarray(object):
+    def __init__(self, array):
+        self.array = array
+
+    def __mul__(self, val):
+        return Myarray(val)
+
+    def astype(self):
+        return "ASTYPE", self
+
+def randint(maximum):
+    if maximum is not None:
+        return Myarray([1, 2, 3]) * 2
+
+    return int(5)
+
+print(randint(1).astype()) # we don't wan't an error for astype access
diff --git a/tests/input/func_noerror_property_affectation_py26.py b/tests/input/func_noerror_property_affectation_py26.py
new file mode 100644
index 000000000..60118bbf6
--- /dev/null
+++ b/tests/input/func_noerror_property_affectation_py26.py
@@ -0,0 +1,24 @@
+# pylint: disable=R0903, useless-object-inheritance
+"""
+Simple test case for an annoying behavior in pylint.
+"""
+
+__revision__ = 'pouet'
+
+class Test(object):
+    """Smallest test case for reported issue."""
+
+    def __init__(self):
+        self._thing = None
+
+    @property
+    def myattr(self):
+        """Getter for myattr"""
+        return self._thing
+
+    @myattr.setter
+    def myattr(self, value):
+        """Setter for myattr."""
+        self._thing = value
+
+Test().myattr = 'grou'
diff --git a/tests/input/func_noerror_yield_assign_py25.py b/tests/input/func_noerror_yield_assign_py25.py
new file mode 100644
index 000000000..f40d8d96e
--- /dev/null
+++ b/tests/input/func_noerror_yield_assign_py25.py
@@ -0,0 +1,21 @@
+"""http://www.logilab.org/ticket/8771"""
+
+from __future__ import print_function
+
+def generator():
+    """yield as assignment"""
+    yield 45
+    xxxx = yield 123
+    print(xxxx)
+
+def generator_fp1(seq):
+    """W0631 false positive"""
+    for val in seq:
+        pass
+    for val in seq:
+        yield val
+
+def generator_fp2():
+    """E0601 false positive"""
+    xxxx = 12
+    yield xxxx
diff --git a/tests/input/func_noerror_yield_return_mix.py b/tests/input/func_noerror_yield_return_mix.py
new file mode 100644
index 000000000..8e050f0f0
--- /dev/null
+++ b/tests/input/func_noerror_yield_return_mix.py
@@ -0,0 +1,8 @@
+""" module doc """
+# pylint: disable=useless-return
+__revision__ = None
+
+def somegen():
+    """this kind of mix is OK"""
+    yield 1
+    return
diff --git a/tests/input/func_nonregr___file___global.py b/tests/input/func_nonregr___file___global.py
new file mode 100644
index 000000000..910033c4a
--- /dev/null
+++ b/tests/input/func_nonregr___file___global.py
@@ -0,0 +1,8 @@
+"""test no crash on __file__ global"""
+
+def func():
+    """override __file__"""
+    global __file__
+    __file__ = 'hop'
+
+__revision__ = 'pouet'
diff --git a/tests/input/func_return_yield_mix_py_33.py b/tests/input/func_return_yield_mix_py_33.py
new file mode 100644
index 000000000..b120b80ac
--- /dev/null
+++ b/tests/input/func_return_yield_mix_py_33.py
@@ -0,0 +1,15 @@
+"""pylint should detect yield and return mix inside generators"""
+# pylint: disable=using-constant-test, inconsistent-return-statements
+def somegen():
+    """this is a bad generator"""
+    if True:
+        return 1
+    else:
+        yield 2
+
+def moregen():
+    """this is another bad generator"""
+    if True:
+        yield 1
+    else:
+        return 2
diff --git a/tests/input/func_typecheck_callfunc_assigment.py b/tests/input/func_typecheck_callfunc_assigment.py
new file mode 100644
index 000000000..36d476e89
--- /dev/null
+++ b/tests/input/func_typecheck_callfunc_assigment.py
@@ -0,0 +1,61 @@
+# pylint: disable=useless-return, useless-object-inheritance
+"""check assignment to function call where the function doesn't return
+
+    'E1111': ('Assigning to function call which doesn\'t return',
+              'Used when an assignment is done on a function call but the \
+              infered function doesn\'t return anything.'),
+    'W1111': ('Assigning to function call which only returns None',
+              'Used when an assignment is done on a function call but the \
+              infered function returns nothing but None.'),
+
+"""
+from __future__ import generators, print_function
+
+def func_no_return():
+    """function without return"""
+    print('dougloup')
+
+A = func_no_return()
+
+
+def func_return_none():
+    """function returning none"""
+    print('dougloup')
+    return None
+
+A = func_return_none()
+
+
+def func_implicit_return_none():
+    """Function returning None from bare return statement."""
+    return
+
+A = func_implicit_return_none()
+
+
+def func_return_none_and_smth():
+    """function returning none and something else"""
+    print('dougloup')
+    if 2 or 3:
+        return None
+    return 3
+
+A = func_return_none_and_smth()
+
+def generator():
+    """no problemo"""
+    yield 2
+
+A = generator()
+
+class Abstract(object):
+    """bla bla"""
+
+    def abstract_method(self):
+        """use to return something in concrete implementation"""
+        raise NotImplementedError
+
+    def use_abstract(self):
+        """should not issue E1111"""
+        var = self.abstract_method()
+        print(var)
diff --git a/tests/input/func_unused_import_py30.py b/tests/input/func_unused_import_py30.py
new file mode 100644
index 000000000..91a9e9ac9
--- /dev/null
+++ b/tests/input/func_unused_import_py30.py
@@ -0,0 +1,20 @@
+"""check unused import for metaclasses
+"""
+# pylint: disable=too-few-public-methods,wrong-import-position,ungrouped-imports
+__revision__ = 1
+import abc
+import sys
+from abc import ABCMeta
+from abc import ABCMeta as SomethingElse
+
+class Meta(metaclass=abc.ABCMeta):
+    """ Test """
+    def __init__(self):
+        self.data = sys.executable
+        self.test = abc
+
+class Meta2(metaclass=ABCMeta):
+    """ Test """
+
+class Meta3(metaclass=SomethingElse):
+    """ test """
diff --git a/tests/input/func_variables_unused_name_from_wilcard_import.py b/tests/input/func_variables_unused_name_from_wilcard_import.py
new file mode 100644
index 000000000..bb92155c6
--- /dev/null
+++ b/tests/input/func_variables_unused_name_from_wilcard_import.py
@@ -0,0 +1,3 @@
+"""check unused import from a wildcard import"""
+# pylint: disable=no-absolute-import
+from input.func_w0611 import *
diff --git a/tests/input/func_w0122_py_30.py b/tests/input/func_w0122_py_30.py
new file mode 100644
index 000000000..6b8669130
--- /dev/null
+++ b/tests/input/func_w0122_py_30.py
@@ -0,0 +1,12 @@
+"""test global statement"""
+
+__revision__ = 0
+
+exec 'a = __revision__'
+exec 'a = 1' in {}
+
+exec 'a = 1' in globals()
+
+def func():
+    """exec in local scope"""
+    exec 'b = 1'
diff --git a/tests/input/func_w0233.py b/tests/input/func_w0233.py
new file mode 100644
index 000000000..eb5d97226
--- /dev/null
+++ b/tests/input/func_w0233.py
@@ -0,0 +1,51 @@
+# pylint: disable=R0903,W0212,W0403,W0406,no-absolute-import,wrong-import-order, useless-object-inheritance
+
+"""test for call to __init__ from a non ancestor class
+"""
+from __future__ import print_function
+from . import func_w0233
+import nonexistant
+__revision__ = '$Id: func_w0233.py,v 1.2 2004-09-29 08:35:13 syt Exp $'
+
+class AAAA(object):
+    """ancestor 1"""
+
+    def __init__(self):
+        print('init', self)
+        BBBBMixin.__init__(self)
+
+class BBBBMixin(object):
+    """ancestor 2"""
+
+    def __init__(self):
+        print('init', self)
+
+class CCC(BBBBMixin, func_w0233.AAAA, func_w0233.BBBB, nonexistant.AClass):
+    """mix different things, some inferable some not"""
+    def __init__(self):
+        BBBBMixin.__init__(self)
+        func_w0233.AAAA.__init__(self)
+        func_w0233.BBBB.__init__(self)
+        nonexistant.AClass.__init__(self)
+
+class DDDD(AAAA):
+    """call superclass constructor in disjunct branches"""
+    def __init__(self, value):
+        if value:
+            AAAA.__init__(self)
+        else:
+            AAAA.__init__(self)
+
+class Super(dict):
+    """ test late binding super() call """
+    def __init__(self):
+        base = super()
+        base.__init__()
+
+class Super2(dict):
+    """ Using the same idiom as Super, but without calling
+    the __init__ method.
+    """
+    def __init__(self):
+        base = super()
+        base.__woohoo__()
diff --git a/tests/input/func_w0332_py_30.py b/tests/input/func_w0332_py_30.py
new file mode 100644
index 000000000..6a38e8c0d
--- /dev/null
+++ b/tests/input/func_w0332_py_30.py
@@ -0,0 +1,4 @@
+"""check use of l as long int marker
+"""
+# pylint: disable=long-suffix
+__revision__ = 1l
diff --git a/tests/input/func_w0401.py b/tests/input/func_w0401.py
new file mode 100644
index 000000000..12227bc9a
--- /dev/null
+++ b/tests/input/func_w0401.py
@@ -0,0 +1,9 @@
+"""test cyclic import
+"""
+# pylint: disable=no-absolute-import
+from __future__ import print_function
+
+from . import w0401_cycle
+
+if w0401_cycle:
+    print(w0401_cycle)
diff --git a/tests/input/func_w0401_disabled.py b/tests/input/func_w0401_disabled.py
new file mode 100644
index 000000000..966706caf
--- /dev/null
+++ b/tests/input/func_w0401_disabled.py
@@ -0,0 +1,9 @@
+"""test cyclic import
+"""
+# pylint: disable=no-absolute-import
+from __future__ import print_function
+
+from . import w0401_cycle  # pylint: disable=cyclic-import
+
+if w0401_cycle:
+    print(w0401_cycle)
diff --git a/tests/input/func_w0401_disabled_in_func.py b/tests/input/func_w0401_disabled_in_func.py
new file mode 100644
index 000000000..b9b0ced8d
--- /dev/null
+++ b/tests/input/func_w0401_disabled_in_func.py
@@ -0,0 +1,11 @@
+"""Test disabling of cyclic import check inside a function
+"""
+# pylint: disable=no-absolute-import
+from __future__ import print_function
+
+
+def func():
+    """Test disabling of cyclic import check inside a function"""
+    from . import w0401_cycle  # pylint: disable=cyclic-import
+    if w0401_cycle:
+        print(w0401_cycle)
diff --git a/tests/input/func_w0401_package/__init__.py b/tests/input/func_w0401_package/__init__.py
new file mode 100644
index 000000000..dedef6608
--- /dev/null
+++ b/tests/input/func_w0401_package/__init__.py
@@ -0,0 +1,2 @@
+"""Our big package."""
+__revision__ = None
diff --git a/tests/input/func_w0401_package/all_the_things.py b/tests/input/func_w0401_package/all_the_things.py
new file mode 100644
index 000000000..b8bd47b9e
--- /dev/null
+++ b/tests/input/func_w0401_package/all_the_things.py
@@ -0,0 +1,9 @@
+"""All the things!"""
+# pylint: disable=no-absolute-import
+from .thing1 import THING1
+from .thing2 import THING2
+from .thing2 import THING1_PLUS_THING2
+__revision__ = None
+
+_ = (THING1, THING2, THING1_PLUS_THING2)
+del _
diff --git a/tests/input/func_w0401_package/thing1.py b/tests/input/func_w0401_package/thing1.py
new file mode 100644
index 000000000..34972a7d2
--- /dev/null
+++ b/tests/input/func_w0401_package/thing1.py
@@ -0,0 +1,3 @@
+"""The first thing."""
+__revision__ = None
+THING1 = "I am thing1"
diff --git a/tests/input/func_w0401_package/thing2.py b/tests/input/func_w0401_package/thing2.py
new file mode 100644
index 000000000..66d331677
--- /dev/null
+++ b/tests/input/func_w0401_package/thing2.py
@@ -0,0 +1,7 @@
+"""The second thing."""
+# pylint: disable=no-absolute-import
+from .all_the_things import THING1
+__revision__ = None
+
+THING2 = "I am thing2"
+THING1_PLUS_THING2 = "%s, plus %s" % (THING1, THING2)
diff --git a/tests/input/func_w0404.py b/tests/input/func_w0404.py
new file mode 100644
index 000000000..2ce7d651c
--- /dev/null
+++ b/tests/input/func_w0404.py
@@ -0,0 +1,27 @@
+"""Unittests for W0404 (reimport)"""
+from __future__ import absolute_import, print_function
+
+import sys
+
+import xml.etree.ElementTree
+from xml.etree import ElementTree
+
+from email import encoders
+import email.encoders
+
+import sys  #pylint: disable=ungrouped-imports,wrong-import-order
+__revision__ = 0
+
+def no_reimport():
+    """docstring"""
+    import os
+    print(os)
+
+
+def reimport():
+    """This function contains a reimport."""
+    import sys
+    del sys
+
+
+del sys, ElementTree, xml.etree.ElementTree, encoders, email.encoders
diff --git a/tests/input/func_w0405.py b/tests/input/func_w0405.py
new file mode 100644
index 000000000..50a069d7a
--- /dev/null
+++ b/tests/input/func_w0405.py
@@ -0,0 +1,31 @@
+"""check reimport
+"""
+from __future__ import absolute_import, print_function
+
+# pylint: disable=using-constant-test,ungrouped-imports,wrong-import-position
+import os
+from os.path import join, exists
+import os
+import re as _re
+
+__revision__ = 0
+_re.match('yo', '.*')
+
+if __revision__:
+    print(os)
+    from os.path import exists
+    print(join, exists)
+
+def func(yooo):
+    """reimport in different scope"""
+    import os as ass
+    ass.remove(yooo)
+    import re
+    re.compile('.*')
+
+if 1: # pylint: disable=using-constant-test
+    import sys
+    print(sys.modules)
+else:
+    print('bla')
+    import sys
diff --git a/tests/input/func_w0406.py b/tests/input/func_w0406.py
new file mode 100644
index 000000000..ceb12b5ff
--- /dev/null
+++ b/tests/input/func_w0406.py
@@ -0,0 +1,10 @@
+"""test module importing itself"""
+# pylint: disable=no-absolute-import,using-constant-test
+from __future__ import print_function
+from . import func_w0406
+
+__revision__ = 0
+
+
+if __revision__:
+    print(func_w0406)
diff --git a/tests/input/func_w0611.py b/tests/input/func_w0611.py
new file mode 100644
index 000000000..887787242
--- /dev/null
+++ b/tests/input/func_w0611.py
@@ -0,0 +1,25 @@
+"""check unused import
+"""
+# pylint: disable=no-absolute-import, useless-object-inheritance
+
+from __future__ import print_function
+
+import os
+import sys
+
+class NonRegr(object):
+    """???"""
+    def __init__(self):
+        print('initialized')
+
+    def sys(self):
+        """should not get sys from there..."""
+        print(self, sys)
+
+    def dummy(self, truc):
+        """yo"""
+        return self, truc
+
+    def blop(self):
+        """yo"""
+        print(self, 'blip')
diff --git a/tests/input/func_w0612.py b/tests/input/func_w0612.py
new file mode 100644
index 000000000..3d873bbeb
--- /dev/null
+++ b/tests/input/func_w0612.py
@@ -0,0 +1,37 @@
+"""test unused variable
+"""
+# pylint: disable=invalid-name, redefined-outer-name, no-absolute-import
+from __future__ import print_function
+PATH = OS = collections = deque = None
+
+def function(matches):
+    """"yo"""
+    aaaa = 1
+    index = -1
+    for match in matches:
+        index += 1
+        print(match)
+
+def visit_if(self, node):
+    """increments the branches counter"""
+    branches = 1
+    # don't double count If nodes coming from some 'elif'
+    if node.orelse and len(node.orelse) > 1:
+        branches += 1
+    self.inc_branch(branches)
+    self.stmts += branches
+
+def test_global():
+    """ Test various assignments of global
+    variables through imports.
+    """
+    global PATH, OS, collections, deque
+    from os import path as PATH
+    import os as OS
+    import collections
+    from collections import deque
+    # make sure that these triggers unused-variable
+    from sys import platform
+    from sys import version as VERSION
+    import this
+    import re as RE
diff --git a/tests/input/func_w0613.py b/tests/input/func_w0613.py
new file mode 100644
index 000000000..02213c83b
--- /dev/null
+++ b/tests/input/func_w0613.py
@@ -0,0 +1,42 @@
+# pylint: disable=R0903, print-statement, useless-object-inheritance
+"""test unused argument
+"""
+from __future__ import print_function
+
+
+def function(arg=1):
+    """ignore arg"""
+
+
+class AAAA(object):
+    """dummy class"""
+
+    def method(self, arg):
+        """dummy method"""
+        print(self)
+    def __init__(self, *unused_args, **unused_kwargs):
+        pass
+
+    @classmethod
+    def selected(cls, *args, **kwargs):
+        """called by the registry when the vobject has been selected.
+        """
+        return cls
+
+    def using_inner_function(self, etype, size=1):
+        """return a fake result set for a particular entity type"""
+        rset = AAAA([('A',)]*size, '%s X' % etype,
+                    description=[(etype,)]*size)
+        def inner(row, col=0, etype=etype, req=self, rset=rset):
+            """inner using all its argument"""
+            # pylint: disable = E1103
+            return req.vreg.etype_class(etype)(req, rset, row, col)
+        # pylint: disable = W0201
+        rset.get_entity = inner
+
+class BBBB(object):
+    """dummy class"""
+
+    def __init__(self, arg):
+        """Constructor with an extra parameter. Should raise a warning"""
+        self.spam = 1
diff --git a/tests/input/func_w0623_py30.py b/tests/input/func_w0623_py30.py
new file mode 100644
index 000000000..7eb27a923
--- /dev/null
+++ b/tests/input/func_w0623_py30.py
@@ -0,0 +1,17 @@
+"""Test for W0623, overwriting names in exception handlers."""
+# pylint: disable=unnecessary-pass
+
+__revision__ = ''
+
+class MyError(Exception):
+    """Special exception class."""
+    pass
+
+
+def some_function():
+    """A function."""
+
+    try:
+        {}["a"]
+    except KeyError as some_function: # W0623
+        pass
diff --git a/tests/input/func_w0801.py b/tests/input/func_w0801.py
new file mode 100644
index 000000000..cd386ff55
--- /dev/null
+++ b/tests/input/func_w0801.py
@@ -0,0 +1,11 @@
+"""test code similarities
+by defaut docstring are not considered
+"""
+__revision__ = 'id'
+A = 2
+B = 3
+C = A + B
+# need more than X lines to trigger the message
+C *= 2
+A -= B
+# all this should be detected
diff --git a/tests/input/hide_code_with_imports.py b/tests/input/hide_code_with_imports.py
new file mode 100644
index 000000000..a8449c9b9
--- /dev/null
+++ b/tests/input/hide_code_with_imports.py
@@ -0,0 +1,16 @@
+quicksort = lambda a: qs1(a,0,len(a)-1)                               ; import a
+qs1 = lambda a,lo,hi: qs2(a,lo,hi) if lo<hi else a                    ; import b
+qs2 = lambda a,lo,hi: qs3(lo,hi,*qsp(a,lo,hi))                        ; import c
+qs3 = lambda lo,hi,a,p: qs1(qs1(a,p+1,hi),lo,p-1)                     ; import d
+qsp = lambda a,lo,hi: qsp1(a,lo,hi,a[hi],lo,lo)                       ; import e
+qsp1 = lambda a,lo,hi,p,i,j: qsp2(a,lo,hi,p,i,j,j<hi)                 ; import f
+qsp2 = lambda a,lo,hi,p,i,j,c: qspt(a,lo,hi,p,i,j,qsp3 if c else qsp7); import g
+qspt = lambda a,lo,hi,p,i,j,n: n(a,lo,hi,p,i,j)                       ; import h
+qsp3 = lambda a,lo,hi,p,i,j: qsp4(a,lo,hi,p,i,j,a[j]<p)               ; import i
+qsp4 = lambda a,lo,hi,p,i,j,c: qspt(a,lo,hi,p,i,j,qsp5 if c else qsp6); import j
+qsp5 = lambda a,lo,hi,p,i,j: qsp1(sw(a,i,j),lo,hi,p,i+1,j+1)          ; import k
+qsp6 = lambda a,lo,hi,p,i,j: qsp1(a,lo,hi,p,i,j+1)                    ; import l
+qsp7 = lambda a,lo,hi,p,i,j: (sw(a,i,hi), i)                          ; import m
+sw = lambda a,i,j: sw1(enumerate(a),i,j,a[i],(-1,a[j]))               ; import n
+sw1 = lambda a,i,j,ai,aj: sw2([aj if x[0]==i else x for x in a],j,ai) ; import o
+sw2 = lambda a,j,ai: [ai if x[0]==j else x[1] for x in a]             ; import p
diff --git a/tests/input/ignore_except_pass_by_default.py b/tests/input/ignore_except_pass_by_default.py
new file mode 100644
index 000000000..444e540d2
--- /dev/null
+++ b/tests/input/ignore_except_pass_by_default.py
@@ -0,0 +1,6 @@
+"""#5575: by default no W0704 warning on bare pass in except"""
+
+try:
+    __exception__ = 0
+except ValueError:
+    pass
diff --git a/tests/input/multiline-import b/tests/input/multiline-import
new file mode 100644
index 000000000..b9507ef8a
--- /dev/null
+++ b/tests/input/multiline-import
@@ -0,0 +1,8 @@
+from foo import (
+  bar,
+  baz,
+  quux,
+  quuux,
+  quuuux,
+  quuuuux,
+)
diff --git a/tests/input/noext b/tests/input/noext
new file mode 100644
index 000000000..8aeda06d3
--- /dev/null
+++ b/tests/input/noext
@@ -0,0 +1,4 @@
+#!/usr/bin/env python
+"""a python file without .py extension"""
+
+__revision__ = None
diff --git a/tests/input/not__init__.py b/tests/input/not__init__.py
new file mode 100644
index 000000000..60e92b76c
--- /dev/null
+++ b/tests/input/not__init__.py
@@ -0,0 +1 @@
+"""test"""
diff --git a/tests/input/similar1 b/tests/input/similar1
new file mode 100644
index 000000000..a533e2f6f
--- /dev/null
+++ b/tests/input/similar1
@@ -0,0 +1,30 @@
+import one
+from two import two
+three
+four
+five
+six # comments optionally ignored
+seven
+eight
+nine
+''' ten
+eleven
+twelve '''
+thirteen
+fourteen
+fifteen
+
+
+
+
+sixteen
+seventeen
+eighteen
+
+
+
+
+nineteen
+r"""
+twenty
+"""
diff --git a/tests/input/similar2 b/tests/input/similar2
new file mode 100644
index 000000000..79bcab2fd
--- /dev/null
+++ b/tests/input/similar2
@@ -0,0 +1,30 @@
+import one
+from two import two
+three
+four
+five
+six
+seven
+eight
+nine
+''' ten
+ELEVEN
+twelve '''
+thirteen
+fourteen
+FIFTEEN
+
+
+
+
+sixteen
+seventeen
+eighteen
+
+
+
+
+NINETEEN
+r"""
+twenty
+"""
diff --git a/tests/input/w0401_cycle.py b/tests/input/w0401_cycle.py
new file mode 100644
index 000000000..ddb42557e
--- /dev/null
+++ b/tests/input/w0401_cycle.py
@@ -0,0 +1,9 @@
+"""w0401 dependency
+"""
+# pylint: disable=print-statement, no-absolute-import
+from __future__ import print_function
+
+from . import func_w0401
+
+if func_w0401:
+    print(input)
diff --git a/tests/input/w0801_same.py b/tests/input/w0801_same.py
new file mode 100644
index 000000000..cd386ff55
--- /dev/null
+++ b/tests/input/w0801_same.py
@@ -0,0 +1,11 @@
+"""test code similarities
+by defaut docstring are not considered
+"""
+__revision__ = 'id'
+A = 2
+B = 3
+C = A + B
+# need more than X lines to trigger the message
+C *= 2
+A -= B
+# all this should be detected
diff --git a/tests/message/unittest_message.py b/tests/message/unittest_message.py
new file mode 100644
index 000000000..7420ca273
--- /dev/null
+++ b/tests/message/unittest_message.py
@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+import pytest
+
+from pylint.checkers import BaseChecker
+from pylint.exceptions import InvalidMessageError
+from pylint.message import MessageDefinition, MessagesStore
+
+
+@pytest.fixture
+def store():
+    return MessagesStore()
+
+
+@pytest.mark.parametrize(
+    "messages,expected",
+    [
+        (
+            {
+                "W1234": ("message one", "msg-symbol-one", "msg description"),
+                "W4321": ("message two", "msg-symbol-two", "msg description"),
+            },
+            r"Inconsistent checker part in message id 'W4321' (expected 'x12xx' because we already had ['W1234']).",
+        ),
+        (
+            {
+                "W1233": (
+                    "message two",
+                    "msg-symbol-two",
+                    "msg description",
+                    {"old_names": [("W1234", "old-symbol")]},
+                ),
+                "W1234": ("message one", "msg-symbol-one", "msg description"),
+            },
+            "Message id 'W1234' cannot have both 'msg-symbol-one' and 'old-symbol' as symbolic name.",
+        ),
+        (
+            {
+                "W1234": ("message one", "msg-symbol-one", "msg description"),
+                "W1235": (
+                    "message two",
+                    "msg-symbol-two",
+                    "msg description",
+                    {"old_names": [("W1234", "old-symbol")]},
+                ),
+            },
+            "Message id 'W1234' cannot have both 'msg-symbol-one' and 'old-symbol' as symbolic name.",
+        ),
+        (
+            {
+                "W1234": (
+                    "message one",
+                    "msg-symbol-one",
+                    "msg description",
+                    {"old_names": [("W1201", "old-symbol-one")]},
+                ),
+                "W1235": (
+                    "message two",
+                    "msg-symbol-two",
+                    "msg description",
+                    {"old_names": [("W1201", "old-symbol-two")]},
+                ),
+            },
+            "Message id 'W1201' cannot have both 'old-symbol-one' and 'old-symbol-two' as symbolic name.",
+        ),
+        (
+            {
+                "W1234": ("message one", "msg-symbol", "msg description"),
+                "W1235": ("message two", "msg-symbol", "msg description"),
+            },
+            "Message symbol 'msg-symbol' cannot be used for 'W1234' and 'W1235' at the same time.",
+        ),
+        (
+            {
+                "W1233": (
+                    "message two",
+                    "msg-symbol-two",
+                    "msg description",
+                    {"old_names": [("W1230", "msg-symbol-one")]},
+                ),
+                "W1234": ("message one", "msg-symbol-one", "msg description"),
+            },
+            "Message symbol 'msg-symbol-one' cannot be used for 'W1230' and 'W1234' at the same time.",
+        ),
+        (
+            {
+                "W1234": ("message one", "msg-symbol-one", "msg description"),
+                "W1235": (
+                    "message two",
+                    "msg-symbol-two",
+                    "msg description",
+                    {"old_names": [("W1230", "msg-symbol-one")]},
+                ),
+            },
+            "Message symbol 'msg-symbol-one' cannot be used for 'W1234' and 'W1235' at the same time.",
+        ),
+        (
+            {
+                "W1234": (
+                    "message one",
+                    "msg-symbol-one",
+                    "msg description",
+                    {"old_names": [("W1230", "old-symbol-one")]},
+                ),
+                "W1235": (
+                    "message two",
+                    "msg-symbol-two",
+                    "msg description",
+                    {"old_names": [("W1231", "old-symbol-one")]},
+                ),
+            },
+            "Message symbol 'old-symbol-one' cannot be used for 'W1230' and 'W1235' at the same time.",
+        ),
+    ],
+)
+def test_register_error(store, messages, expected):
+    class Checker(BaseChecker):
+        name = "checker"
+        msgs = messages
+
+    with pytest.raises(InvalidMessageError) as cm:
+        store.register_messages_from_checker(Checker())
+    assert str(cm.value) == expected
+
+
+def test_register_error_new_id_duplicate_of_new(store):
+    class CheckerOne(BaseChecker):
+        name = "checker_one"
+        msgs = {"W1234": ("message one", "msg-symbol-one", "msg description.")}
+
+    class CheckerTwo(BaseChecker):
+        name = "checker_two"
+        msgs = {"W1234": ("message two", "msg-symbol-two", "another msg description.")}
+
+    store.register_messages_from_checker(CheckerOne())
+    test_register_error(
+        store,
+        {"W1234": ("message two", "msg-symbol-two", "another msg description.")},
+        "Message id 'W1234' cannot have both 'msg-symbol-one' and 'msg-symbol-two' as symbolic name.",
+    )
+
+
+@pytest.mark.parametrize(
+    "msgid,expected",
+    [
+        ("Q1234", "Bad message type Q in 'Q1234'"),
+        ("W12345", "Invalid message id 'W12345'"),
+    ],
+)
+def test_create_invalid_message_type(msgid, expected):
+    with pytest.raises(InvalidMessageError) as cm:
+        MessageDefinition("checker", msgid, "msg", "descr", "symbol", "scope")
+    assert str(cm.value) == expected
diff --git a/tests/message/unittest_message_store.py b/tests/message/unittest_message_store.py
new file mode 100644
index 000000000..053bfca50
--- /dev/null
+++ b/tests/message/unittest_message_store.py
@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+from contextlib import redirect_stdout
+from io import StringIO
+
+import pytest
+
+from pylint.checkers import BaseChecker
+from pylint.exceptions import InvalidMessageError, UnknownMessageError
+from pylint.message import MessageDefinition, MessagesStore
+
+
+@pytest.fixture
+def store():
+    store = MessagesStore()
+
+    class Checker(BaseChecker):
+        name = "achecker"
+        msgs = {
+            "W1234": (
+                "message",
+                "msg-symbol",
+                "msg description.",
+                {"old_names": [("W0001", "old-symbol")]},
+            ),
+            "E1234": (
+                "Duplicate keyword argument %r in %s call",
+                "duplicate-keyword-arg",
+                "Used when a function call passes the same keyword argument multiple times.",
+                {"maxversion": (2, 6)},
+            ),
+        }
+
+    store.register_messages_from_checker(Checker())
+    return store
+
+
+class TestMessagesStore(object):
+    def _compare_messages(self, desc, msg, checkerref=False):
+        assert desc == msg.format_help(checkerref=checkerref)
+
+    def test_check_message_id(self, store):
+        assert isinstance(store.get_message_definitions("W1234")[0], MessageDefinition)
+        with pytest.raises(UnknownMessageError):
+            store.get_message_definitions("YB12")
+
+    def test_message_help(self, store):
+        message_definition = store.get_message_definitions("W1234")[0]
+        self._compare_messages(
+            """:msg-symbol (W1234): *message*
+  msg description. This message belongs to the achecker checker.""",
+            message_definition,
+            checkerref=True,
+        )
+        self._compare_messages(
+            """:msg-symbol (W1234): *message*
+  msg description.""",
+            message_definition,
+            checkerref=False,
+        )
+
+    def test_message_help_minmax(self, store):
+        # build the message manually to be python version independent
+        message_definition = store.get_message_definitions("E1234")[0]
+        self._compare_messages(
+            """:duplicate-keyword-arg (E1234): *Duplicate keyword argument %r in %s call*
+  Used when a function call passes the same keyword argument multiple times.
+  This message belongs to the achecker checker. It can't be emitted when using
+  Python >= 2.6.""",
+            message_definition,
+            checkerref=True,
+        )
+        self._compare_messages(
+            """:duplicate-keyword-arg (E1234): *Duplicate keyword argument %r in %s call*
+  Used when a function call passes the same keyword argument multiple times.
+  This message can't be emitted when using Python >= 2.6.""",
+            message_definition,
+            checkerref=False,
+        )
+
+    def test_list_messages(self, store):
+        output = StringIO()
+        with redirect_stdout(output):
+            store.list_messages()
+        # cursory examination of the output: we're mostly testing it completes
+        assert ":msg-symbol (W1234): *message*" in output.getvalue()
+
+    def test_add_renamed_message(self, store):
+        store.add_renamed_message("W1234", "old-bad-name", "msg-symbol")
+        assert "msg-symbol" == store.get_message_definitions("W1234")[0].symbol
+        assert "msg-symbol" == store.get_message_definitions("old-bad-name")[0].symbol
+
+    def test_add_renamed_message_invalid(self, store):
+        # conflicting message ID
+        with pytest.raises(InvalidMessageError) as cm:
+            store.add_renamed_message(
+                "W1234", "old-msg-symbol", "duplicate-keyword-arg"
+            )
+        expected = (
+            "Message id 'W1234' cannot have both 'msg-symbol' and 'old-msg-symbol' "
+            "as symbolic name."
+        )
+        assert str(cm.value) == expected
+
+    def test_renamed_message_register(self, store):
+        assert "msg-symbol" == store.get_message_definitions("W0001")[0].symbol
+        assert "msg-symbol" == store.get_message_definitions("old-symbol")[0].symbol
diff --git a/tests/messages/builtin_module.txt b/tests/messages/builtin_module.txt
new file mode 100644
index 000000000..2616c0e20
--- /dev/null
+++ b/tests/messages/builtin_module.txt
@@ -0,0 +1 @@
+F:  1: ignored builtin module sys
diff --git a/tests/messages/func_3k_removed_stuff_py_30.txt b/tests/messages/func_3k_removed_stuff_py_30.txt
new file mode 100644
index 000000000..9920f1b64
--- /dev/null
+++ b/tests/messages/func_3k_removed_stuff_py_30.txt
@@ -0,0 +1,2 @@
+E: 12:function: Instance of 'unicode' has no 'looower' member
+W:  4: Relative import 'func_w0401', should be 'input.func_w0401'
diff --git a/tests/messages/func_bad_cont_dictcomp_py27.txt b/tests/messages/func_bad_cont_dictcomp_py27.txt
new file mode 100644
index 000000000..51bde771e
--- /dev/null
+++ b/tests/messages/func_bad_cont_dictcomp_py27.txt
@@ -0,0 +1,6 @@
+C: 35: Wrong continued indentation (add 2 spaces).
+    for x in range(3)}  # [bad-continuation]
+    ^ |
+C: 38: Wrong continued indentation (remove 4 spaces).
+          for x in range(3)}  # [bad-continuation]
+      |   ^
diff --git a/tests/messages/func_bug113231.txt b/tests/messages/func_bug113231.txt
new file mode 100644
index 000000000..a9d3f7ef3
--- /dev/null
+++ b/tests/messages/func_bug113231.txt
@@ -0,0 +1,2 @@
+W: 20: Specify string format arguments as logging function parameters
+W: 21: Specify string format arguments as logging function parameters
diff --git a/tests/messages/func_disable_linebased.txt b/tests/messages/func_disable_linebased.txt
new file mode 100644
index 000000000..06e391d4f
--- /dev/null
+++ b/tests/messages/func_disable_linebased.txt
@@ -0,0 +1,2 @@
+C:  1: Line too long (127/100)
+C: 14: Line too long (114/100)
diff --git a/tests/messages/func_disable_linebased_py30.txt b/tests/messages/func_disable_linebased_py30.txt
new file mode 100644
index 000000000..06e391d4f
--- /dev/null
+++ b/tests/messages/func_disable_linebased_py30.txt
@@ -0,0 +1,2 @@
+C:  1: Line too long (127/100)
+C: 14: Line too long (114/100)
diff --git a/tests/messages/func_dotted_ancestor.txt b/tests/messages/func_dotted_ancestor.txt
new file mode 100644
index 000000000..6e2c6fa5e
--- /dev/null
+++ b/tests/messages/func_dotted_ancestor.txt
@@ -0,0 +1 @@
+R:  8:Aaaa: Too few public methods (0/2)
diff --git a/tests/messages/func_e0012.txt b/tests/messages/func_e0012.txt
new file mode 100644
index 000000000..a6d1b698c
--- /dev/null
+++ b/tests/messages/func_e0012.txt
@@ -0,0 +1 @@
+E:  1: Bad option value 'W04044'
diff --git a/tests/messages/func_e0204.txt b/tests/messages/func_e0204.txt
new file mode 100644
index 000000000..40a5928b5
--- /dev/null
+++ b/tests/messages/func_e0204.txt
@@ -0,0 +1,3 @@
+E: 11:Abcd.__init__: Method should have "self" as first argument
+E: 15:Abcd.abdc: Method should have "self" as first argument
+
diff --git a/tests/messages/func_e12xx.txt b/tests/messages/func_e12xx.txt
new file mode 100644
index 000000000..92640d256
--- /dev/null
+++ b/tests/messages/func_e12xx.txt
@@ -0,0 +1,6 @@
+E: 14:pprint: Too many arguments for logging format string
+E: 15:pprint: Too many arguments for logging format string
+E: 16:pprint: Logging format string ends in middle of conversion specifier
+E: 17:pprint: Not enough arguments for logging format string
+E: 18:pprint: Unsupported logging format character 'y' (0x79) at index 3
+E: 19:pprint: Too many arguments for logging format string
diff --git a/tests/messages/func_e13xx.txt b/tests/messages/func_e13xx.txt
new file mode 100644
index 000000000..f2d0d364e
--- /dev/null
+++ b/tests/messages/func_e13xx.txt
@@ -0,0 +1,13 @@
+E: 11:pprint: Not enough arguments for format string
+E: 12:pprint: Too many arguments for format string
+E: 13:pprint: Mixing named and unnamed conversion specifiers in format string
+E: 14:pprint: Missing key 'PARG_2' in format string dictionary
+E: 16:pprint: Missing key 'PARG_2' in format string dictionary
+E: 17:pprint: Expected mapping for format string, not Tuple
+E: 18:pprint: Expected mapping for format string, not List
+E: 19:pprint: Unsupported format character 'z' (0x7a) at index 2
+E: 20:pprint: Format string ends in middle of conversion specifier
+E: 21:pprint: Unsupported format character 'a' (0x61) at index 12
+W: 15:pprint: Unused key 'PARG_3' in format string dictionary
+W: 16:pprint: Format string dictionary key should be a string, not 2
+
diff --git a/tests/messages/func_e13xx_py30.txt b/tests/messages/func_e13xx_py30.txt
new file mode 100644
index 000000000..7ac9fb180
--- /dev/null
+++ b/tests/messages/func_e13xx_py30.txt
@@ -0,0 +1,11 @@
+E: 11:pprint: Not enough arguments for format string
+E: 12:pprint: Too many arguments for format string
+E: 13:pprint: Mixing named and unnamed conversion specifiers in format string
+E: 14:pprint: Missing key 'PARG_2' in format string dictionary
+E: 16:pprint: Missing key 'PARG_2' in format string dictionary
+E: 17:pprint: Expected mapping for format string, not Tuple
+E: 18:pprint: Expected mapping for format string, not List
+E: 19:pprint: Unsupported format character 'z' (0x7a) at index 2
+E: 20:pprint: Format string ends in middle of conversion specifier
+W: 15:pprint: Unused key 'PARG_3' in format string dictionary
+W: 16:pprint: Format string dictionary key should be a string, not 2
\ No newline at end of file
diff --git a/tests/messages/func_excess_escapes.txt b/tests/messages/func_excess_escapes.txt
new file mode 100644
index 000000000..2f07722cf
--- /dev/null
+++ b/tests/messages/func_excess_escapes.txt
@@ -0,0 +1,9 @@
+W:  7: Anomalous backslash in string: '\['. String constant might be missing an r prefix.
+W:  7: Anomalous backslash in string: '\]'. String constant might be missing an r prefix.
+W:  8: Anomalous backslash in string: '\/'. String constant might be missing an r prefix.
+W:  9: Anomalous backslash in string: '\`'. String constant might be missing an r prefix.
+W: 15: Anomalous backslash in string: '\o'. String constant might be missing an r prefix.
+W: 15: Anomalous backslash in string: '\o'. String constant might be missing an r prefix.
+W: 17: Anomalous backslash in string: '\8'. String constant might be missing an r prefix.
+W: 17: Anomalous backslash in string: '\9'. String constant might be missing an r prefix.
+W: 27: Anomalous backslash in string: '\P'. String constant might be missing an r prefix.
diff --git a/tests/messages/func_first_arg.txt b/tests/messages/func_first_arg.txt
new file mode 100644
index 000000000..8d932048a
--- /dev/null
+++ b/tests/messages/func_first_arg.txt
@@ -0,0 +1,9 @@
+C: 10:Obj.__new__: Class method __new__ should have 'cls' as first argument
+C: 18:Obj.class2: Class method class2 should have 'cls' as first argument
+C: 25:Meta.__new__: Metaclass class method __new__ should have 'cls' as first argument
+C: 32:Meta.method2: Metaclass method method2 should have 'cls' as first argument
+C: 40:Meta.class2: Metaclass class method class2 should have 'cls' as first argument
+R: 16:Obj: Consider using a decorator instead of calling classmethod
+R: 20:Obj: Consider using a decorator instead of calling classmethod
+R: 38:Meta: Consider using a decorator instead of calling classmethod
+R: 42:Meta: Consider using a decorator instead of calling classmethod
diff --git a/tests/messages/func_i0011.txt b/tests/messages/func_i0011.txt
new file mode 100644
index 000000000..66d4bfc68
--- /dev/null
+++ b/tests/messages/func_i0011.txt
@@ -0,0 +1,3 @@
+I:  1: Id 'W0404' is used to disable 'reimported' message emission
+I:  1: Locally disabling reimported (W0404)
+I:  1: Useless suppression of 'reimported'
diff --git a/tests/messages/func_i0012.txt b/tests/messages/func_i0012.txt
new file mode 100644
index 000000000..5ad4cd6c6
--- /dev/null
+++ b/tests/messages/func_i0012.txt
@@ -0,0 +1 @@
+I:  1: Id 'W0404' is used to enable 'reimported' message emission
diff --git a/tests/messages/func_i0013.txt b/tests/messages/func_i0013.txt
new file mode 100644
index 000000000..75d7afd60
--- /dev/null
+++ b/tests/messages/func_i0013.txt
@@ -0,0 +1 @@
+I:  1: Ignoring entire file
diff --git a/tests/messages/func_i0014.txt b/tests/messages/func_i0014.txt
new file mode 100644
index 000000000..c3b521d5a
--- /dev/null
+++ b/tests/messages/func_i0014.txt
@@ -0,0 +1,2 @@
+I:  1: Ignoring entire file
+I:  1: Pragma "disable-all" is deprecated, use "skip-file" instead
diff --git a/tests/messages/func_i0020.txt b/tests/messages/func_i0020.txt
new file mode 100644
index 000000000..ddd1cb4a6
--- /dev/null
+++ b/tests/messages/func_i0020.txt
@@ -0,0 +1,3 @@
+I:  7: Id 'W0612' is used to disable 'unused-variable' message emission
+I:  7: Locally disabling unused-variable (W0612)
+I:  8: Suppressed 'unused-variable' (from line 7)
diff --git a/tests/messages/func_i0022.txt b/tests/messages/func_i0022.txt
new file mode 100644
index 000000000..28b7d71c1
--- /dev/null
+++ b/tests/messages/func_i0022.txt
@@ -0,0 +1,21 @@
+I:  5: Locally disabling invalid-name (C0103)
+I:  5: Suppressed 'invalid-name' (from line 5)
+I:  6: Locally disabling invalid-name (C0103)
+I:  6: Pragma "disable-msg" is deprecated, use "disable" instead
+I:  6: Suppressed 'invalid-name' (from line 6)
+I:  8: Locally disabling invalid-name (C0103)
+I:  9: Suppressed 'invalid-name' (from line 8)
+I: 12: Locally disabling invalid-name (C0103)
+I: 12: Pragma "disable-msg" is deprecated, use "disable" instead
+I: 13: Suppressed 'invalid-name' (from line 12)
+I: 14: Pragma "enable-msg" is deprecated, use "enable" instead
+I: 16: Id 'C0103' is used to disable 'invalid-name' message emission
+I: 16: Locally disabling invalid-name (C0103)
+I: 16: Pragma "disable-msg" is deprecated, use "disable" instead
+I: 17: Suppressed 'invalid-name' (from line 16)
+I: 18: Id 'C0103' is used to enable 'invalid-name' message emission
+I: 18: Pragma "enable-msg" is deprecated, use "enable" instead
+I: 20: Id 'C0103' is used to disable 'invalid-name' message emission
+I: 20: Locally disabling invalid-name (C0103)
+I: 21: Suppressed 'invalid-name' (from line 20)
+I: 22: Id 'C0103' is used to enable 'invalid-name' message emission
diff --git a/tests/messages/func_logging_not_lazy_with_logger.txt b/tests/messages/func_logging_not_lazy_with_logger.txt
new file mode 100644
index 000000000..04823cf33
--- /dev/null
+++ b/tests/messages/func_logging_not_lazy_with_logger.txt
@@ -0,0 +1,4 @@
+W:  8: Specify string format arguments as logging function parameters
+W:  9: Specify string format arguments as logging function parameters
+W: 11: Specify string format arguments as logging function parameters
+W: 13: Specify string format arguments as logging function parameters
diff --git a/tests/messages/func_loopvar_in_dict_comp_py27.txt b/tests/messages/func_loopvar_in_dict_comp_py27.txt
new file mode 100644
index 000000000..bc11121c4
--- /dev/null
+++ b/tests/messages/func_loopvar_in_dict_comp_py27.txt
@@ -0,0 +1 @@
+W:  8:bad_case.<lambda>: Cell variable x defined in loop
diff --git a/tests/messages/func_module___dict__.txt b/tests/messages/func_module___dict__.txt
new file mode 100644
index 000000000..416982434
--- /dev/null
+++ b/tests/messages/func_module___dict__.txt
@@ -0,0 +1 @@
+E:  5: Using variable '__dict__' before assignment
diff --git a/tests/messages/func_nameerror_on_string_substitution.txt b/tests/messages/func_nameerror_on_string_substitution.txt
new file mode 100644
index 000000000..aab21024b
--- /dev/null
+++ b/tests/messages/func_nameerror_on_string_substitution.txt
@@ -0,0 +1,2 @@
+E:  5: Using variable 'MSG' before assignment
+E:  8: Using variable 'MSG2' before assignment
diff --git a/tests/messages/func_no_dummy_redefined.txt b/tests/messages/func_no_dummy_redefined.txt
new file mode 100644
index 000000000..a7db92f55
--- /dev/null
+++ b/tests/messages/func_no_dummy_redefined.txt
@@ -0,0 +1,2 @@
+C:  7: Constant name "value" doesn't conform to UPPER_CASE naming style
+W: 12:clobbering: Redefining name 'value' from outer scope (line 7)
diff --git a/tests/messages/func_nonregr___file___global.txt b/tests/messages/func_nonregr___file___global.txt
new file mode 100644
index 000000000..c0d7340f9
--- /dev/null
+++ b/tests/messages/func_nonregr___file___global.txt
@@ -0,0 +1,2 @@
+W:  5:func: Redefining built-in '__file__'
+W:  5:func: Using the global statement
diff --git a/tests/messages/func_raw_escapes.txt b/tests/messages/func_raw_escapes.txt
new file mode 100644
index 000000000..991fba7dd
--- /dev/null
+++ b/tests/messages/func_raw_escapes.txt
@@ -0,0 +1,3 @@
+W:  5: Anomalous Unicode escape in byte string: '\u'. String constant might be missing an r or u prefix.
+W:  6: Anomalous Unicode escape in byte string: '\U'. String constant might be missing an r or u prefix.
+W:  7: Anomalous Unicode escape in byte string: '\N'. String constant might be missing an r or u prefix.
diff --git a/tests/messages/func_return_yield_mix_py_33.txt b/tests/messages/func_return_yield_mix_py_33.txt
new file mode 100644
index 000000000..d81ce5cf4
--- /dev/null
+++ b/tests/messages/func_return_yield_mix_py_33.txt
@@ -0,0 +1,2 @@
+E:  6:somegen: Return with argument inside generator
+E: 15:moregen: Return with argument inside generator
diff --git a/tests/messages/func_toolonglines_py30.txt b/tests/messages/func_toolonglines_py30.txt
new file mode 100644
index 000000000..cd594f5fa
--- /dev/null
+++ b/tests/messages/func_toolonglines_py30.txt
@@ -0,0 +1,4 @@
+C:  1: Line too long (101/100)
+C:  2: Line too long (104/100)
+C: 17: Line too long (102/100)
+C: 25: Line too long (105/100)
diff --git a/tests/messages/func_typecheck_callfunc_assigment.txt b/tests/messages/func_typecheck_callfunc_assigment.txt
new file mode 100644
index 000000000..d1257ca17
--- /dev/null
+++ b/tests/messages/func_typecheck_callfunc_assigment.txt
@@ -0,0 +1,3 @@
+E: 18: Assigning result of a function call, where the function has no return
+E: 26: Assigning result of a function call, where the function returns None
+E: 33: Assigning result of a function call, where the function returns None
diff --git a/tests/messages/func_typecheck_getattr_py30.txt b/tests/messages/func_typecheck_getattr_py30.txt
new file mode 100644
index 000000000..b6bf150f6
--- /dev/null
+++ b/tests/messages/func_typecheck_getattr_py30.txt
@@ -0,0 +1,9 @@
+E: 25:Client.__init__: Class 'Provider' has no 'cattribute' member
+E: 35:Client.use_method: Instance of 'Provider' has no 'hophophop' member
+E: 40:Client.use_attr: Instance of 'Provider' has no 'attribute' member
+E: 52:Client.test_bt_types: Instance of 'list' has no 'apppend' member
+E: 54:Client.test_bt_types: Instance of 'dict' has no 'set' member
+E: 56:Client.test_bt_types: Instance of 'tuple' has no 'append' member
+E: 58:Client.test_bt_types: Instance of 'str' has no 'loower' member
+E: 62:Client.test_bt_types: Instance of 'int' has no 'whatever' member
+E: 66: Instance of 'int' has no 'lower' member (but some types could not be inferred)
diff --git a/tests/messages/func_typecheck_non_callable_call.txt b/tests/messages/func_typecheck_non_callable_call.txt
new file mode 100644
index 000000000..8baa237a3
--- /dev/null
+++ b/tests/messages/func_typecheck_non_callable_call.txt
@@ -0,0 +1,8 @@
+E: 10: __revision__ is not callable
+E: 29: INSTANCE is not callable
+E: 31: LIST is not callable
+E: 33: DICT is not callable
+E: 35: TUPLE is not callable
+E: 37: INT is not callable
+E: 72: PROP.test is not callable
+E: 73: PROP.custom is not callable
\ No newline at end of file
diff --git a/tests/messages/func_unicode_literal_py26.txt b/tests/messages/func_unicode_literal_py26.txt
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/messages/func_unicode_literal_py26.txt
diff --git a/tests/messages/func_unicode_literal_py274.txt b/tests/messages/func_unicode_literal_py274.txt
new file mode 100644
index 000000000..25efa9998
--- /dev/null
+++ b/tests/messages/func_unicode_literal_py274.txt
@@ -0,0 +1 @@
+W:  6: Anomalous Unicode escape in byte string: '\u'. String constant might be missing an r or u prefix.
diff --git a/tests/messages/func_unused_import_py30.txt b/tests/messages/func_unused_import_py30.txt
new file mode 100644
index 000000000..1868abc2d
--- /dev/null
+++ b/tests/messages/func_unused_import_py30.txt
@@ -0,0 +1 @@
+W:  8: Reimport 'ABCMeta' (imported line 7)

diff --git a/tests/messages/func_use_for_or_listcomp_var_py29.txt b/tests/messages/func_use_for_or_listcomp_var_py29.txt
new file mode 100644
index 000000000..14d61ad65
--- /dev/null
+++ b/tests/messages/func_use_for_or_listcomp_var_py29.txt
@@ -0,0 +1,3 @@
+W:  6: Using possibly undefined loop variable 'C'
+W: 15: Using possibly undefined loop variable 'var1'
+
diff --git a/tests/messages/func_use_for_or_listcomp_var_py30.txt b/tests/messages/func_use_for_or_listcomp_var_py30.txt
new file mode 100644
index 000000000..46d3430af
--- /dev/null
+++ b/tests/messages/func_use_for_or_listcomp_var_py30.txt
@@ -0,0 +1,3 @@
+E:  6: Using variable 'C' before assignment
+W: 15: Using possibly undefined loop variable 'var1'
+
diff --git a/tests/messages/func_variables_unused_name_from_wilcard_import.txt b/tests/messages/func_variables_unused_name_from_wilcard_import.txt
new file mode 100644
index 000000000..01c57af07
--- /dev/null
+++ b/tests/messages/func_variables_unused_name_from_wilcard_import.txt
@@ -0,0 +1,4 @@
+W:  3: Unused import NonRegr from wildcard import
+W:  3: Unused import os from wildcard import
+W:  3: Unused import sys from wildcard import
+W:  3: Wildcard import input.func_w0611
diff --git a/tests/messages/func_w0122_py_30.txt b/tests/messages/func_w0122_py_30.txt
new file mode 100644
index 000000000..d833076d5
--- /dev/null
+++ b/tests/messages/func_w0122_py_30.txt
@@ -0,0 +1,5 @@
+W:  5: Use of exec
+W:  6: Use of exec
+W:  8: Use of exec
+W: 12:func: Use of exec
+
diff --git a/tests/messages/func_w0233.txt b/tests/messages/func_w0233.txt
new file mode 100644
index 000000000..de4f0fba9
--- /dev/null
+++ b/tests/messages/func_w0233.txt
@@ -0,0 +1,6 @@
+E:  7: Unable to import 'nonexistant'
+E: 23:CCC: Module 'input.func_w0233' has no 'BBBB' member
+E: 28:CCC.__init__: Module 'input.func_w0233' has no 'BBBB' member
+E: 51:Super2.__init__: Super of 'Super2' has no '__woohoo__' member
+W: 15:AAAA.__init__: __init__ method from a non direct base class 'BBBBMixin' is called
+W: 49:Super2.__init__: __init__ method from base class 'dict' is not called
diff --git a/tests/messages/func_w0312.txt b/tests/messages/func_w0312.txt
new file mode 100644
index 000000000..917e8d0e2
--- /dev/null
+++ b/tests/messages/func_w0312.txt
@@ -0,0 +1,2 @@
+W: 10: Found indentation with tabs instead of spaces
+W: 11: Found indentation with tabs instead of spaces
diff --git a/tests/messages/func_w0332_py_30.txt b/tests/messages/func_w0332_py_30.txt
new file mode 100644
index 000000000..16f1d8024
--- /dev/null
+++ b/tests/messages/func_w0332_py_30.txt
@@ -0,0 +1 @@
+W:  4: Use of "l" as long integer identifier
diff --git a/tests/messages/func_w0401.txt b/tests/messages/func_w0401.txt
new file mode 100644
index 000000000..f6648f477
--- /dev/null
+++ b/tests/messages/func_w0401.txt
@@ -0,0 +1,3 @@
+R:  1: Cyclic import (input.func_w0401 -> input.w0401_cycle)
+W:  8: Using a conditional statement with a constant value
+W:  8: Using a conditional statement with a constant value
diff --git a/tests/messages/func_w0401_disabled.txt b/tests/messages/func_w0401_disabled.txt
new file mode 100644
index 000000000..b5a8db3d2
--- /dev/null
+++ b/tests/messages/func_w0401_disabled.txt
@@ -0,0 +1,2 @@
+W:  8: Using a conditional statement with a constant value
+W:  8: Using a conditional statement with a constant value
diff --git a/tests/messages/func_w0401_disabled_in_func.txt b/tests/messages/func_w0401_disabled_in_func.txt
new file mode 100644
index 000000000..b5ce4524d
--- /dev/null
+++ b/tests/messages/func_w0401_disabled_in_func.txt
@@ -0,0 +1,2 @@
+W:  8: Using a conditional statement with a constant value
+W: 10:func: Using a conditional statement with a constant value
diff --git a/tests/messages/func_w0401_package.txt b/tests/messages/func_w0401_package.txt
new file mode 100644
index 000000000..ca0512448
--- /dev/null
+++ b/tests/messages/func_w0401_package.txt
@@ -0,0 +1,2 @@
+R:  1: Cyclic import (input.func_w0401_package.all_the_things -> input.func_w0401_package.thing2)
+W:  8: Using a conditional statement with a constant value
diff --git a/tests/messages/func_w0404.txt b/tests/messages/func_w0404.txt
new file mode 100644
index 000000000..2cfc13736
--- /dev/null
+++ b/tests/messages/func_w0404.txt
@@ -0,0 +1,5 @@
+W:  7: Reimport 'ElementTree' (imported line 6)
+W: 10: Reimport 'email.encoders' (imported line 9)
+W: 12: Reimport 'sys' (imported line 4)
+W: 23:reimport: Redefining name 'sys' from outer scope (line 4)
+W: 23:reimport: Reimport 'sys' (imported line 4)
diff --git a/tests/messages/func_w0405.txt b/tests/messages/func_w0405.txt
new file mode 100644
index 000000000..072b15547
--- /dev/null
+++ b/tests/messages/func_w0405.txt
@@ -0,0 +1,4 @@
+W:  8: Reimport 'os' (imported line 6)
+W: 16: Reimport 'exists' (imported line 7)
+W: 21:func: Reimport 'os' (imported line 6)
+W: 23:func: Reimport 're' (imported line 9)
diff --git a/tests/messages/func_w0406.txt b/tests/messages/func_w0406.txt
new file mode 100644
index 000000000..f6bc14db2
--- /dev/null
+++ b/tests/messages/func_w0406.txt
@@ -0,0 +1 @@
+W:  4: Module import itself
diff --git a/tests/messages/func_w0611.txt b/tests/messages/func_w0611.txt
new file mode 100644
index 000000000..2be0d0a8d
--- /dev/null
+++ b/tests/messages/func_w0611.txt
@@ -0,0 +1 @@
+W:  7: Unused import os
diff --git a/tests/messages/func_w0612.txt b/tests/messages/func_w0612.txt
new file mode 100644
index 000000000..a6d8bdc29
--- /dev/null
+++ b/tests/messages/func_w0612.txt
@@ -0,0 +1,6 @@
+W:  9:function: Unused variable 'aaaa'
+W: 28:test_global: Using the global statement
+W: 34:test_global: Unused platform imported from sys
+W: 35:test_global: Unused version imported from sys as VERSION
+W: 36:test_global: Unused import this
+W: 37:test_global: Unused re imported as RE
diff --git a/tests/messages/func_w0613.txt b/tests/messages/func_w0613.txt
new file mode 100644
index 000000000..36cb38014
--- /dev/null
+++ b/tests/messages/func_w0613.txt
@@ -0,0 +1,5 @@
+W:  7:function: Unused argument 'arg'
+W: 14:AAAA.method: Unused argument 'arg'
+W: 21:AAAA.selected: Unused argument 'args'
+W: 21:AAAA.selected: Unused argument 'kwargs'
+W: 40:BBBB.__init__: Unused argument 'arg'
diff --git a/tests/messages/func_w0622.txt b/tests/messages/func_w0622.txt
new file mode 100644
index 000000000..719134726
--- /dev/null
+++ b/tests/messages/func_w0622.txt
@@ -0,0 +1,2 @@
+W:  8:function: Redefining built-in 'type'
+W: 11: Redefining built-in 'map'
diff --git a/tests/messages/func_w0623.txt b/tests/messages/func_w0623.txt
new file mode 100644
index 000000000..08fe8b571
--- /dev/null
+++ b/tests/messages/func_w0623.txt
@@ -0,0 +1,11 @@
+C: 28:some_function: Variable name "FOO" doesn't conform to 'variable-name-hint' template
+C: 41: Constant name "exc3" doesn't conform to 'constant-name-hint' template
+C: 55: Variable name "OOPS" doesn't conform to 'variable-name-hint' template
+W: 18:some_function: Redefining name 'RuntimeError' from object 'exceptions' in exception handler
+W: 20:some_function: Redefining name 'OSError' from builtins in exception handler
+W: 20:some_function: Unused variable 'OSError'
+W: 22:some_function: Redefining name 'MyError' from outer scope (line 7) in exception handler
+W: 22:some_function: Unused variable 'MyError'
+W: 45: Redefining name 'RuntimeError' from object 'exceptions' in exception handler
+W: 47: Redefining name 'OSError' from builtins in exception handler
+W: 49: Redefining name 'MyOtherError' from outer scope (line 36) in exception handler
diff --git a/tests/messages/func_w0623_py30.txt b/tests/messages/func_w0623_py30.txt
new file mode 100644
index 000000000..e5cc0f57e
--- /dev/null
+++ b/tests/messages/func_w0623_py30.txt
@@ -0,0 +1,2 @@
+W: 16:some_function: Redefining name 'some_function' from outer scope (line 11) in exception handler
+W: 16:some_function: Unused variable 'some_function'
diff --git a/tests/messages/func_w0623_py_30.txt b/tests/messages/func_w0623_py_30.txt
new file mode 100644
index 000000000..77329bb0f
--- /dev/null
+++ b/tests/messages/func_w0623_py_30.txt
@@ -0,0 +1,12 @@
+C: 28:some_function: Variable name "FOO" doesn't conform to 'variable-name-hint' template
+C: 41: Constant name "exc3" doesn't conform to 'constant-name-hint' template
+C: 57: Variable name "OOPS" doesn't conform to 'variable-name-hint' template
+W: 18:some_function: Redefining name 'RuntimeError' from object 'exceptions' in exception handler
+W: 20:some_function: Redefining name 'OSError' from builtins in exception handler
+W: 20:some_function: Unused variable 'OSError'
+W: 22:some_function: Redefining name 'MyError' from outer scope (line 7) in exception handler
+W: 22:some_function: Unused variable 'MyError'
+W: 45: Redefining name 'RuntimeError' from object 'exceptions' in exception handler
+W: 47: Redefining name 'args' from object 'exceptions.RuntimeError' in exception handler
+W: 49: Redefining name 'OSError' from builtins in exception handler
+W: 51: Redefining name 'MyOtherError' from outer scope (line 36) in exception handler
diff --git a/tests/messages/func_w0801.txt b/tests/messages/func_w0801.txt
new file mode 100644
index 000000000..203ce9294
--- /dev/null
+++ b/tests/messages/func_w0801.txt
@@ -0,0 +1,11 @@
+R:  1: Similar lines in 2 files
+==input.func_w0801:3
+==input.w0801_same:3
+__revision__ = 'id'
+A = 2
+B = 3
+C = A + B
+# need more than X lines to trigger the message
+C *= 2
+A -= B
+# all this should be detected
diff --git a/tests/messages/func_with_without_as_py25.txt b/tests/messages/func_with_without_as_py25.txt
new file mode 100644
index 000000000..18ca3711c
--- /dev/null
+++ b/tests/messages/func_with_without_as_py25.txt
@@ -0,0 +1,3 @@
+E: 11:do_nothing: Using variable 'base' before assignment
+W: 11:do_nothing: Statement seems to have no effect
+
diff --git a/tests/regrtest_data/.pylintrc b/tests/regrtest_data/.pylintrc
new file mode 100644
index 000000000..9a5bb5a44
--- /dev/null
+++ b/tests/regrtest_data/.pylintrc
@@ -0,0 +1,4 @@
+[MASTER]
+
+optimize-ast=no
+
diff --git a/tests/regrtest_data/absimp/__init__.py b/tests/regrtest_data/absimp/__init__.py
new file mode 100644
index 000000000..fdabe9f78
--- /dev/null
+++ b/tests/regrtest_data/absimp/__init__.py
@@ -0,0 +1,4 @@
+"""a package with absolute import activated
+"""
+
+from __future__ import absolute_import
diff --git a/tests/regrtest_data/absimp/string.py b/tests/regrtest_data/absimp/string.py
new file mode 100644
index 000000000..f47e9a5e9
--- /dev/null
+++ b/tests/regrtest_data/absimp/string.py
@@ -0,0 +1,7 @@
+"""
+http://www.logilab.org/ticket/70495
+http://www.logilab.org/ticket/70565
+"""
+from __future__ import absolute_import, print_function
+import string
+print(string)
diff --git a/tests/regrtest_data/application_crash.py b/tests/regrtest_data/application_crash.py
new file mode 100644
index 000000000..8d3eb170b
--- /dev/null
+++ b/tests/regrtest_data/application_crash.py
@@ -0,0 +1 @@
+ABC = something_undefined
diff --git a/tests/regrtest_data/bad_package/__init__.py b/tests/regrtest_data/bad_package/__init__.py
new file mode 100644
index 000000000..60585fdbe
--- /dev/null
+++ b/tests/regrtest_data/bad_package/__init__.py
@@ -0,0 +1,2 @@
+import missing

+raise missing.Missing..
\ No newline at end of file
diff --git a/tests/regrtest_data/bad_package/wrong.py b/tests/regrtest_data/bad_package/wrong.py
new file mode 100644
index 000000000..2d2d78f98
--- /dev/null
+++ b/tests/regrtest_data/bad_package/wrong.py
@@ -0,0 +1,5 @@
+"""

+Test that pylint doesn't crash when a relative import

+depends on the local __init__, which contains an expected syntax error.

+"""

+from . import missing

diff --git a/tests/regrtest_data/beyond_top/__init__.py b/tests/regrtest_data/beyond_top/__init__.py
new file mode 100644
index 000000000..401fe0674
--- /dev/null
+++ b/tests/regrtest_data/beyond_top/__init__.py
@@ -0,0 +1,6 @@
+from ... import Something

+from . import data

+try:

+    from ... import Lala

+except ImportError:

+    pass
\ No newline at end of file
diff --git a/tests/regrtest_data/beyond_top/data.py b/tests/regrtest_data/beyond_top/data.py
new file mode 100644
index 000000000..9ec64d267
--- /dev/null
+++ b/tests/regrtest_data/beyond_top/data.py
@@ -0,0 +1 @@
+Anything = 42
\ No newline at end of file
diff --git a/tests/regrtest_data/classdoc_usage.py b/tests/regrtest_data/classdoc_usage.py
new file mode 100644
index 000000000..2d9df51cd
--- /dev/null
+++ b/tests/regrtest_data/classdoc_usage.py
@@ -0,0 +1,17 @@
+"""ds"""
+
+__revision__ = None
+# pylint: disable=useless-object-inheritance
+
+class SomeClass(object):
+    """cds"""
+    doc = __doc__
+
+    def __init__(self):
+        """only to make pylint happier"""
+
+    def please(self):
+        """public method 1/2"""
+
+    def besilent(self):
+        """public method 2/2"""
diff --git a/tests/regrtest_data/comments_pylintrc b/tests/regrtest_data/comments_pylintrc
new file mode 100644
index 000000000..93a33101f
--- /dev/null
+++ b/tests/regrtest_data/comments_pylintrc
@@ -0,0 +1,7 @@
+[MESSAGES CONTROL]
+disable=all
+enable=
+  trailing-whitespace, # Caring about it
+  bad-indentation, # And about this
+  # And about this
+  missing-docstring
\ No newline at end of file
diff --git a/tests/regrtest_data/decimal_inference.py b/tests/regrtest_data/decimal_inference.py
new file mode 100644
index 000000000..00c913040
--- /dev/null
+++ b/tests/regrtest_data/decimal_inference.py
@@ -0,0 +1,10 @@
+"""hum E1011 on .prec member is justifiable since Context instance are built
+using setattr/locals :(
+
+2007/02/17 update: .prec attribute is now detected by astroid :o)
+"""
+from __future__ import print_function
+import decimal
+
+decimal.getcontext().prec = 200
+print(decimal.getcontext().prec)
diff --git a/tests/regrtest_data/descriptor_crash.py b/tests/regrtest_data/descriptor_crash.py
new file mode 100644
index 000000000..4b3adccde
--- /dev/null
+++ b/tests/regrtest_data/descriptor_crash.py
@@ -0,0 +1,20 @@
+# -*- coding: iso-8859-1 -*-
+
+import urllib
+
+class Page(object):
+    _urlOpen = staticmethod(urllib.urlopen)
+
+    def getPage(self, url):
+        handle = self._urlOpen(url)
+        data = handle.read()
+        handle.close()
+        return data
+    #_getPage
+
+#Page
+
+if __name__ == "__main__":
+    import sys
+    p = Page()
+    print p.getPage(sys.argv[1])
diff --git a/tests/regrtest_data/dummy/__init__.py b/tests/regrtest_data/dummy/__init__.py
new file mode 100644
index 000000000..0b43a7096
--- /dev/null
+++ b/tests/regrtest_data/dummy/__init__.py
@@ -0,0 +1,3 @@
+# pylint: disable=missing-docstring
+from .dummy import DUMMY
+from .another import ANOTHER
diff --git a/tests/regrtest_data/dummy/another.py b/tests/regrtest_data/dummy/another.py
new file mode 100644
index 000000000..56a871238
--- /dev/null
+++ b/tests/regrtest_data/dummy/another.py
@@ -0,0 +1,3 @@
+# pylint: disable=missing-docstring
+
+ANOTHER = 42
diff --git a/tests/regrtest_data/dummy/dummy.py b/tests/regrtest_data/dummy/dummy.py
new file mode 100644
index 000000000..60345dc13
--- /dev/null
+++ b/tests/regrtest_data/dummy/dummy.py
@@ -0,0 +1,2 @@
+# pylint: disable=missing-docstring
+DUMMY = 42
diff --git a/tests/regrtest_data/dummy_plugin.rc b/tests/regrtest_data/dummy_plugin.rc
new file mode 100644
index 000000000..162dedc89
--- /dev/null
+++ b/tests/regrtest_data/dummy_plugin.rc
@@ -0,0 +1,6 @@
+[MASTER]
+load-plugins=dummy_plugin
+
+[DUMMY_PLUGIN]
+dummy_option_1="dummy value 1"
+dummy_option_2="dummy value 2"
diff --git a/tests/regrtest_data/dummy_plugin/dummy_conf_plugin.py b/tests/regrtest_data/dummy_plugin/dummy_conf_plugin.py
new file mode 100644
index 000000000..f58387f83
--- /dev/null
+++ b/tests/regrtest_data/dummy_plugin/dummy_conf_plugin.py
@@ -0,0 +1,6 @@
+def register(linter):
+    pass
+
+
+def load_configuration(linter):
+    linter.config.black_list += ('bin',)
diff --git a/tests/regrtest_data/dummy_plugin/dummy_plugin.py b/tests/regrtest_data/dummy_plugin/dummy_plugin.py
new file mode 100644
index 000000000..95b0b9305
--- /dev/null
+++ b/tests/regrtest_data/dummy_plugin/dummy_plugin.py
@@ -0,0 +1,30 @@
+from pylint.checkers import BaseChecker
+
+
+class DummyPlugin1(BaseChecker):
+    name = 'dummy_plugin'
+    msgs = {'I9061': ('Dummy short desc 01', 'dummy-message-01', 'Dummy long desc')}
+    options = (
+        ('dummy_option_1', {
+            'type': 'string',
+            'metavar': '<string>',
+            'help': 'Dummy option 1',
+        }),
+    )
+
+
+class DummyPlugin2(BaseChecker):
+    name = 'dummy_plugin'
+    msgs = {'I9060': ('Dummy short desc 02', 'dummy-message-02', 'Dummy long desc')}
+    options = (
+        ('dummy_option_2', {
+            'type': 'string',
+            'metavar': '<string>',
+            'help': 'Dummy option 2',
+        }),
+    )
+
+
+def register(linter):
+    linter.register_checker(DummyPlugin1(linter))
+    linter.register_checker(DummyPlugin2(linter))
diff --git a/tests/regrtest_data/empty.py b/tests/regrtest_data/empty.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/regrtest_data/empty.py
diff --git a/tests/regrtest_data/func_block_disable_msg.py b/tests/regrtest_data/func_block_disable_msg.py
new file mode 100644
index 000000000..36198db2b
--- /dev/null
+++ b/tests/regrtest_data/func_block_disable_msg.py
@@ -0,0 +1,1026 @@
+# pylint: disable=C0302,bare-except,print-statement, useless-object-inheritance
+"""pylint option block-disable"""
+from __future__ import print_function
+
+class Foo(object):
+    """block-disable test"""
+
+    def __init__(self):
+        self._test = "42"
+
+    def meth1(self, arg):
+        """this issues a message"""
+        print(self)
+
+    def meth2(self, arg):
+        """and this one not"""
+        # pylint: disable=W0613
+        print(self._test\
+              + "foo")
+
+    def meth3(self):
+        """test one line disabling"""
+        # no error
+        print(self.bla) # pylint: disable=E1101
+        # error
+        print(self.blop)
+
+    def meth4(self):
+        """test re-enabling"""
+        # pylint: disable=E1101
+        # no error
+        print(self.bla)
+        print(self.blop)
+        # pylint: enable=E1101
+        # error
+        print(self.blip)
+
+    def meth5(self):
+        """test IF sub-block re-enabling"""
+        # pylint: disable=E1101
+        # no error
+        print(self.bla)
+        if self.blop:
+            # pylint: enable=E1101
+            # error
+            print(self.blip)
+        else:
+            # no error
+            print(self.blip)
+        # no error
+        print(self.blip)
+
+    def meth6(self):
+        """test TRY/EXCEPT sub-block re-enabling"""
+        # pylint: disable=E1101
+        # no error
+        print(self.bla)
+        try:
+            # pylint: enable=E1101
+            # error
+            print(self.blip)
+        except UndefinedName: # pylint: disable=E0602
+            # no error
+            print(self.blip)
+        # no error
+        print(self.blip)
+
+    def meth7(self):
+        """test one line block opening disabling"""
+        if self.blop: # pylint: disable=E1101
+            # error
+            print(self.blip)
+        else:
+            # error
+            print(self.blip)
+        # error
+        print(self.blip)
+
+
+    def meth8(self):
+        """test late disabling"""
+        # error
+        print(self.blip)
+        # pylint: disable=E1101
+        # no error
+        print(self.bla)
+        print(self.blop)
+
+    def meth9(self):
+        """test re-enabling right after a block with whitespace"""
+        eris = 5
+
+        if eris: # pylint: disable=using-constant-test
+            print("In block")
+
+        # pylint: disable=E1101
+        # no error
+        print(self.bla)
+        print(self.blu)
+        # pylint: enable=E1101
+        # error
+        print(self.blip)
+
+    def meth10(self):
+        """Test double disable"""
+        # pylint: disable=E1101
+        # no error
+        print(self.bla)
+        # pylint: disable=E1101
+        print(self.blu)
+
+
+class ClassLevelMessage(object):
+    """shouldn't display to much attributes/not enough methods messages
+    """
+    # pylint: disable=R0902,R0903
+
+    def __init__(self):
+        self.attr1 = 1
+        self.attr2 = 1
+        self.attr3 = 1
+        self.attr4 = 1
+        self.attr5 = 1
+        self.attr6 = 1
+        self.attr7 = 1
+        self.attr8 = 1
+        self.attr9 = 1
+        self.attr0 = 1
+
+    def too_complex_but_thats_ok(self, attr1, attr2):
+        """THIS Method has too much branches and returns but i don't care
+        """
+        # pylint: disable=R0912,R0911
+        try:
+            attr3 = attr1+attr2
+        except ValueError:
+            attr3 = None
+        except:
+            return 'duh', self
+        if attr1:
+            for i in attr1:
+                if attr2:
+                    return i
+            else:
+                return 'duh'
+        elif attr2:
+            for i in attr2:
+                if attr2:
+                    return i
+            else:
+                return 'duh'
+        else:
+            for i in range(15):
+                if attr3:
+                    return i
+            else:
+                return 'doh'
+        return None
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+print('hop, too many lines but i don\'t care')
diff --git a/tests/regrtest_data/import_assign.py b/tests/regrtest_data/import_assign.py
new file mode 100644
index 000000000..c01cd52f7
--- /dev/null
+++ b/tests/regrtest_data/import_assign.py
@@ -0,0 +1,5 @@
+import shmixml.dom.minidom
+import xml.dom.minidom
+
+if 'dom' not in xml.__dict__:
+  xml.dom = shmixml.dom
diff --git a/tests/regrtest_data/import_package_subpackage_module.py b/tests/regrtest_data/import_package_subpackage_module.py
new file mode 100644
index 000000000..2864e3c9e
--- /dev/null
+++ b/tests/regrtest_data/import_package_subpackage_module.py
@@ -0,0 +1,49 @@
+# pylint: disable=I0011,C0301,W0611
+"""I found some of my scripts trigger off an AttributeError in pylint
+0.8.1 (with common 0.12.0 and astroid 0.13.1).
+
+Traceback (most recent call last):
+  File "/usr/bin/pylint", line 4, in ?
+    lint.Run(sys.argv[1:])
+  File "/usr/lib/python2.4/site-packages/pylint/lint.py", line 729, in __init__
+    linter.check(args)
+  File "/usr/lib/python2.4/site-packages/pylint/lint.py", line 412, in check
+    self.check_file(filepath, modname, checkers)
+  File "/usr/lib/python2.4/site-packages/pylint/lint.py", line 426, in check_file
+    astroid = self._check_file(filepath, modname, checkers)
+  File "/usr/lib/python2.4/site-packages/pylint/lint.py", line 450, in _check_file
+    self.check_astroid_module(astroid, checkers)
+  File "/usr/lib/python2.4/site-packages/pylint/lint.py", line 494, in check_astroid_module
+    self.astroid_events(astroid, [checker for checker in checkers
+  File "/usr/lib/python2.4/site-packages/pylint/lint.py", line 511, in astroid_events
+    self.astroid_events(child, checkers, _reversed_checkers)
+  File "/usr/lib/python2.4/site-packages/pylint/lint.py", line 511, in astroid_events
+    self.astroid_events(child, checkers, _reversed_checkers)
+  File "/usr/lib/python2.4/site-packages/pylint/lint.py", line 508, in astroid_events
+    checker.visit(astroid)
+  File "/usr/lib/python2.4/site-packages/logilab/astroid/utils.py", line 84, in visit
+    method(node)
+  File "/usr/lib/python2.4/site-packages/pylint/checkers/variables.py", line 295, in visit_import
+    self._check_module_attrs(node, module, name_parts[1:])
+  File "/usr/lib/python2.4/site-packages/pylint/checkers/variables.py", line 357, in _check_module_attrs
+    self.add_message('E0611', args=(name, module.name),
+AttributeError: Import instance has no attribute 'name'
+
+
+You can reproduce it by:
+(1) create package structure like the following:
+
+package/
+        __init__.py
+        subpackage/
+                   __init__.py
+                   module.py
+
+(2) in package/__init__.py write:
+
+import subpackage
+
+(3) run pylint with a script importing package.subpackage.module.
+"""
+import package.subpackage.module
+__revision__ = '$Id: import_package_subpackage_module.py,v 1.1 2005-11-10 16:08:54 syt Exp $'
diff --git a/tests/regrtest_data/import_something.py b/tests/regrtest_data/import_something.py
new file mode 100644
index 000000000..3a74a717f
--- /dev/null
+++ b/tests/regrtest_data/import_something.py
@@ -0,0 +1,4 @@
+# pylint: disable=missing-docstring,unused-import

+

+import os

+import sys

diff --git a/tests/regrtest_data/init_wildcard/__init__.py b/tests/regrtest_data/init_wildcard/__init__.py
new file mode 100644
index 000000000..8a4b31cea
--- /dev/null
+++ b/tests/regrtest_data/init_wildcard/__init__.py
@@ -0,0 +1 @@
+from empty import *
diff --git a/tests/regrtest_data/meta.py b/tests/regrtest_data/meta.py
new file mode 100644
index 000000000..700120727
--- /dev/null
+++ b/tests/regrtest_data/meta.py
@@ -0,0 +1,3 @@
+# pylint: disable=invalid-name, missing-docstring
+# pylint: disable=unbalanced-tuple-unpacking
+n = 42
diff --git a/tests/regrtest_data/module_global.py b/tests/regrtest_data/module_global.py
new file mode 100644
index 000000000..107d65289
--- /dev/null
+++ b/tests/regrtest_data/module_global.py
@@ -0,0 +1,7 @@
+# pylint: disable=W0603,W0601,W0604,E0602,W0104
+"""was causing infinite recursion
+"""
+__revision__ = 1
+
+global GLOBAL_VAR
+GLOBAL_VAR.foo
diff --git a/tests/regrtest_data/no_stdout_encoding.py b/tests/regrtest_data/no_stdout_encoding.py
new file mode 100644
index 000000000..d72aa65bb
--- /dev/null
+++ b/tests/regrtest_data/no_stdout_encoding.py
@@ -0,0 +1,4 @@
+#-*- coding:iso-8859-1 -*-
+class test:
+    def __init__(self, dir):
+        testString = u"répertoire :\n%s !"%dir
diff --git a/tests/regrtest_data/numarray_import.py b/tests/regrtest_data/numarray_import.py
new file mode 100644
index 000000000..e89757f19
--- /dev/null
+++ b/tests/regrtest_data/numarray_import.py
@@ -0,0 +1,7 @@
+"""#10077"""
+
+__revision__ = 1
+
+from numarray import zeros
+
+zeros(shape=(4, 5))
diff --git a/tests/regrtest_data/numarray_inf.py b/tests/regrtest_data/numarray_inf.py
new file mode 100644
index 000000000..4ea22a9c6
--- /dev/null
+++ b/tests/regrtest_data/numarray_inf.py
@@ -0,0 +1,5 @@
+"""#3216"""
+
+import numarray as na
+import numarray.random_array as nar
+IM16 = nar.randint(0, 256, 300).astype(na.UInt8)
diff --git a/tests/regrtest_data/package/AudioTime.py b/tests/regrtest_data/package/AudioTime.py
new file mode 100644
index 000000000..ef65143c1
--- /dev/null
+++ b/tests/regrtest_data/package/AudioTime.py
@@ -0,0 +1,3 @@
+"""test preceded by the AudioTime class in __init__.py"""
+
+__revision__ = 0
diff --git a/tests/regrtest_data/package/__init__.py b/tests/regrtest_data/package/__init__.py
new file mode 100644
index 000000000..bf6b73cda
--- /dev/null
+++ b/tests/regrtest_data/package/__init__.py
@@ -0,0 +1,15 @@
+# pylint: disable=R0903,W0403
+
+"""package's __init__ file"""
+
+from . import subpackage
+
+__revision__ = 0
+
+# E0602 - Undefined variable '__path__'
+__path__ += "folder"
+
+class AudioTime:
+    """test precedence over the AudioTime submodule"""
+
+    DECIMAL = 3
diff --git a/tests/regrtest_data/package/subpackage/__init__.py b/tests/regrtest_data/package/subpackage/__init__.py
new file mode 100644
index 000000000..dc4782e6c
--- /dev/null
+++ b/tests/regrtest_data/package/subpackage/__init__.py
@@ -0,0 +1 @@
+"""package.subpackage"""
diff --git a/tests/regrtest_data/package/subpackage/module.py b/tests/regrtest_data/package/subpackage/module.py
new file mode 100644
index 000000000..4b7244ba0
--- /dev/null
+++ b/tests/regrtest_data/package/subpackage/module.py
@@ -0,0 +1 @@
+"""package.subpackage.module"""
diff --git a/tests/regrtest_data/package_all/__init__.py b/tests/regrtest_data/package_all/__init__.py
new file mode 100644
index 000000000..4e3696bec
--- /dev/null
+++ b/tests/regrtest_data/package_all/__init__.py
@@ -0,0 +1,3 @@
+""" Check for E0603 for missing submodule found in __all__ """

+__revision__ = 1

+__all__ = ['notmissing', 'missing']

diff --git a/tests/regrtest_data/package_all/notmissing.py b/tests/regrtest_data/package_all/notmissing.py
new file mode 100644
index 000000000..7cf85430a
--- /dev/null
+++ b/tests/regrtest_data/package_all/notmissing.py
@@ -0,0 +1,2 @@
+""" empty """

+__revision__ = 1

diff --git a/tests/regrtest_data/precedence_test.py b/tests/regrtest_data/precedence_test.py
new file mode 100644
index 000000000..ff5871d46
--- /dev/null
+++ b/tests/regrtest_data/precedence_test.py
@@ -0,0 +1,21 @@
+"""
+  # package/__init__.py
+  class AudioTime(object):
+    DECIMAL = 3
+
+  # package/AudioTime.py
+  class AudioTime(object):
+    pass
+
+  # test.py
+  from package import AudioTime
+  # E0611 - No name 'DECIMAL' in module 'AudioTime.AudioTime'
+  print AudioTime.DECIMAL
+
+"""
+from __future__ import print_function
+from package import AudioTime
+__revision__ = 0
+
+
+print(AudioTime.DECIMAL)
diff --git a/tests/regrtest_data/py3k-disabled.rc b/tests/regrtest_data/py3k-disabled.rc
new file mode 100644
index 000000000..41d775778
--- /dev/null
+++ b/tests/regrtest_data/py3k-disabled.rc
@@ -0,0 +1,2 @@
+[MESSAGES CONTROL]
+disable=no-absolute-import
diff --git a/tests/regrtest_data/py3k_error_flag.py b/tests/regrtest_data/py3k_error_flag.py
new file mode 100644
index 000000000..6bead4102
--- /dev/null
+++ b/tests/regrtest_data/py3k_error_flag.py
@@ -0,0 +1,11 @@
+"""Contains both normal error messages and Python3 porting error messages."""

+# pylint: disable=too-few-public-methods

+

+raise Exception, 1  # Error emitted here with the Python 3 checker.

+

+

+class Test(object):

+    """dummy"""

+

+    def __init__(self):

+        return 42

diff --git a/tests/regrtest_data/py3k_errors_and_warnings.py b/tests/regrtest_data/py3k_errors_and_warnings.py
new file mode 100644
index 000000000..3d033e86c
--- /dev/null
+++ b/tests/regrtest_data/py3k_errors_and_warnings.py
@@ -0,0 +1,19 @@
+"""Contains both normal error messages and Python3 porting error messages."""
+# pylint: disable=too-few-public-methods
+
+# error: import missing `from __future__ import absolute_import`
+import sys
+
+# error: Use raise ErrorClass(args) instead of raise ErrorClass, args.
+raise Exception, 1
+
+class Test(object):
+    """dummy"""
+
+    def __init__(self):
+        # warning: Calling a dict.iter*() method
+        {1: 2}.iteritems()
+        return 42
+
+# error: print statement used
+print 'not in python3'
diff --git a/tests/regrtest_data/special_attr_scope_lookup_crash.py b/tests/regrtest_data/special_attr_scope_lookup_crash.py
new file mode 100644
index 000000000..b693a9fcc
--- /dev/null
+++ b/tests/regrtest_data/special_attr_scope_lookup_crash.py
@@ -0,0 +1,3 @@
+class Klass(object):
+    """A"""
+    __doc__ += "B"
diff --git a/tests/regrtest_data/syntax_error.py b/tests/regrtest_data/syntax_error.py
new file mode 100644
index 000000000..bf86aff05
--- /dev/null
+++ b/tests/regrtest_data/syntax_error.py
@@ -0,0 +1 @@
+class A extends B {}
\ No newline at end of file
diff --git a/tests/regrtest_data/test_pylintrc_comments.py b/tests/regrtest_data/test_pylintrc_comments.py
new file mode 100644
index 000000000..6bcff58d2
--- /dev/null
+++ b/tests/regrtest_data/test_pylintrc_comments.py
@@ -0,0 +1,2 @@
+def f(x):
+ return x # 1 space
\ No newline at end of file
diff --git a/tests/regrtest_data/try_finally_disable_msg_crash.py b/tests/regrtest_data/try_finally_disable_msg_crash.py
new file mode 100644
index 000000000..1719308fd
--- /dev/null
+++ b/tests/regrtest_data/try_finally_disable_msg_crash.py
@@ -0,0 +1,5 @@
+try:
+    pass
+finally:
+    # pylint: disable=W0201
+    pass
diff --git a/tests/regrtest_data/unused_variable.py b/tests/regrtest_data/unused_variable.py
new file mode 100644
index 000000000..eee909d53
--- /dev/null
+++ b/tests/regrtest_data/unused_variable.py
@@ -0,0 +1,6 @@
+# pylint: disable=missing-docstring
+
+def test():
+    variable = ''
+    variable2 = None
+    return variable2
diff --git a/tests/regrtest_data/wildcard.py b/tests/regrtest_data/wildcard.py
new file mode 100644
index 000000000..8a4b31cea
--- /dev/null
+++ b/tests/regrtest_data/wildcard.py
@@ -0,0 +1 @@
+from empty import *
diff --git a/tests/regrtest_data/wrong_import_position.py b/tests/regrtest_data/wrong_import_position.py
new file mode 100644
index 000000000..9e2d099e0
--- /dev/null
+++ b/tests/regrtest_data/wrong_import_position.py
@@ -0,0 +1,11 @@
+"""Test that wrong-import-position is properly reset when

+other errors are disabled.

+"""

+# pylint: disable=unused-import, too-few-public-methods

+

+

+class Something(object):

+    """A class before an import."""

+

+

+import os

diff --git a/tests/test_func.py b/tests/test_func.py
new file mode 100644
index 000000000..1566df992
--- /dev/null
+++ b/tests/test_func.py
@@ -0,0 +1,158 @@
+# Copyright (c) 2006-2010, 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
+# Copyright (c) 2013-2014 Google, Inc.
+# Copyright (c) 2014-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Michal Nowikowski <godfryd@gmail.com>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2017 Michka Popoff <michkapopoff@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""functional/non regression tests for pylint"""
+
+import re
+import sys
+from os.path import abspath, dirname, join
+
+import pytest
+
+from pylint.testutils import _get_tests_info, linter
+
+PY3K = sys.version_info >= (3, 0)
+SYS_VERS_STR = "%d%d%d" % sys.version_info[:3]
+
+# Configure paths
+INPUT_DIR = join(dirname(abspath(__file__)), "input")
+MSG_DIR = join(dirname(abspath(__file__)), "messages")
+
+FILTER_RGX = None
+UPDATE = False
+INFO_TEST_RGX = re.compile(r"^func_i\d\d\d\d$")
+
+# Classes
+
+quote = "'" if sys.version_info >= (3, 3) else ""
+
+
+def exception_str(self, ex):  # pylint: disable=unused-argument
+    """function used to replace default __str__ method of exception instances"""
+    return "in %s\n:: %s" % (ex.file, ", ".join(ex.args))
+
+
+class LintTestUsingModule(object):
+    INPUT_DIR = None
+    DEFAULT_PACKAGE = "input"
+    package = DEFAULT_PACKAGE
+    linter = linter
+    module = None
+    depends = None
+    output = None
+    _TEST_TYPE = "module"
+
+    # def runTest(self):
+    #     # This is a hack to make ./test/test_func.py work under pytest.
+    #     pass
+
+    def _test_functionality(self):
+        tocheck = [self.package + "." + self.module]
+        # pylint: disable=not-an-iterable; can't handle boolean checks for now
+        if self.depends:
+            tocheck += [
+                self.package + ".%s" % name.replace(".py", "")
+                for name, _ in self.depends
+            ]
+        self._test(tocheck)
+
+    def _check_result(self, got):
+        assert self._get_expected().strip() + "\n" == got.strip() + "\n"
+
+    def _test(self, tocheck):
+        if INFO_TEST_RGX.match(self.module):
+            self.linter.enable("I")
+        else:
+            self.linter.disable("I")
+        try:
+            self.linter.check(tocheck)
+        except Exception as ex:
+            # need finalization to restore a correct state
+            self.linter.reporter.finalize()
+            ex.file = tocheck
+            print(ex)
+            ex.__str__ = exception_str
+            raise
+        self._check_result(self.linter.reporter.finalize())
+
+    def _has_output(self):
+        return not self.module.startswith("func_noerror_")
+
+    def _get_expected(self):
+        if self._has_output() and self.output:
+            with open(self.output, "r") as fobj:
+                return fobj.read().strip() + "\n"
+        else:
+            return ""
+
+
+class LintTestUpdate(LintTestUsingModule):
+
+    _TEST_TYPE = "update"
+
+    def _check_result(self, got):
+        if self._has_output():
+            try:
+                expected = self._get_expected()
+            except IOError:
+                expected = ""
+            if got != expected:
+                with open(self.output, "w") as fobj:
+                    fobj.write(got)
+
+
+def gen_tests(filter_rgx):
+    if filter_rgx:
+        is_to_run = re.compile(filter_rgx).search
+    else:
+        is_to_run = lambda x: 1
+    tests = []
+    for module_file, messages_file in _get_tests_info(INPUT_DIR, MSG_DIR, "func_", ""):
+        if not is_to_run(module_file) or module_file.endswith((".pyc", "$py.class")):
+            continue
+        base = module_file.replace(".py", "").split("_")[1]
+        dependencies = _get_tests_info(INPUT_DIR, MSG_DIR, base, ".py")
+        tests.append((module_file, messages_file, dependencies))
+
+    if UPDATE:
+        return tests
+
+    assert len(tests) < 196, "Please do not add new test cases here."
+    return tests
+
+
+@pytest.mark.parametrize(
+    "module_file,messages_file,dependencies",
+    gen_tests(FILTER_RGX),
+    ids=[o[0] for o in gen_tests(FILTER_RGX)],
+)
+def test_functionality(module_file, messages_file, dependencies):
+
+    LT = LintTestUpdate() if UPDATE else LintTestUsingModule()
+
+    LT.module = module_file.replace(".py", "")
+    LT.output = messages_file
+    LT.depends = dependencies or None
+    LT.INPUT_DIR = INPUT_DIR
+    LT._test_functionality()
+
+
+if __name__ == "__main__":
+    if "-u" in sys.argv:
+        UPDATE = True
+        sys.argv.remove("-u")
+
+    if len(sys.argv) > 1:
+        FILTER_RGX = sys.argv[1]
+        del sys.argv[1]
+    pytest.main(sys.argv)
diff --git a/tests/test_functional.py b/tests/test_functional.py
new file mode 100644
index 000000000..bb4145c4d
--- /dev/null
+++ b/tests/test_functional.py
@@ -0,0 +1,384 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 Michal Nowikowski <godfryd@gmail.com>
+# Copyright (c) 2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@upcloud.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Functional full-module tests for PyLint."""
+
+import collections
+import csv
+import io
+import operator
+import os
+import platform
+import re
+import sys
+
+import pytest
+import six
+from six.moves import configparser
+
+from pylint import checkers, interfaces, lint, reporters
+
+
+class test_dialect(csv.excel):
+    if sys.version_info[0] < 3:
+        delimiter = b':'
+        lineterminator = b'\n'
+    else:
+        delimiter = ':'
+        lineterminator = '\n'
+
+
+csv.register_dialect('test', test_dialect)
+
+
+class NoFileError(Exception):
+    pass
+
+# Notes:
+# - for the purpose of this test, the confidence levels HIGH and UNDEFINED
+#   are treated as the same.
+
+# TODOs
+#  - implement exhaustivity tests
+
+# If message files should be updated instead of checked.
+UPDATE = False
+
+class OutputLine(collections.namedtuple('OutputLine',
+                ['symbol', 'lineno', 'object', 'msg', 'confidence'])):
+    @classmethod
+    def from_msg(cls, msg):
+        return cls(
+            msg.symbol, msg.line, msg.obj or '', msg.msg.replace("\r\n", "\n"),
+            msg.confidence.name
+            if msg.confidence != interfaces.UNDEFINED else interfaces.HIGH.name)
+
+    @classmethod
+    def from_csv(cls, row):
+        confidence = row[4] if len(row) == 5 else interfaces.HIGH.name
+        return cls(row[0], int(row[1]), row[2], row[3], confidence)
+
+    def to_csv(self):
+        if self.confidence == interfaces.HIGH.name:
+            return self[:-1]
+        else:
+            return self
+
+
+# Common sub-expressions.
+_MESSAGE = {'msg': r'[a-z][a-z\-]+'}
+# Matches a #,
+#  - followed by a comparison operator and a Python version (optional),
+#  - followed by a line number with a +/- (optional),
+#  - followed by a list of bracketed message symbols.
+# Used to extract expected messages from testdata files.
+_EXPECTED_RE = re.compile(
+    r'\s*#\s*(?:(?P<line>[+-]?[0-9]+):)?'
+    r'(?:(?P<op>[><=]+) *(?P<version>[0-9.]+):)?'
+    r'\s*\[(?P<msgs>%(msg)s(?:,\s*%(msg)s)*)\]' % _MESSAGE)
+
+
+def parse_python_version(str):
+    return tuple(int(digit) for digit in str.split('.'))
+
+
+class FunctionalTestReporter(reporters.BaseReporter):
+    def handle_message(self, msg):
+        self.messages.append(msg)
+
+    def on_set_current_module(self, module, filepath):
+        self.messages = []
+
+    def display_reports(self, layout):
+        """Ignore layouts."""
+
+
+class FunctionalTestFile(object):
+    """A single functional test case file with options."""
+
+    _CONVERTERS = {
+        'min_pyver': parse_python_version,
+        'max_pyver': parse_python_version,
+        'requires': lambda s: s.split(',')
+    }
+
+
+    def __init__(self, directory, filename):
+        self._directory = directory
+        self.base = filename.replace('.py', '')
+        self.options = {
+            'min_pyver': (2, 5),
+            'max_pyver': (4, 0),
+            'requires': [],
+            'except_implementations': [],
+            }
+        self._parse_options()
+
+    def _parse_options(self):
+        cp = configparser.ConfigParser()
+        cp.add_section('testoptions')
+        try:
+            cp.read(self.option_file)
+        except NoFileError:
+            pass
+
+        for name, value in cp.items('testoptions'):
+            conv = self._CONVERTERS.get(name, lambda v: v)
+            self.options[name] = conv(value)
+
+    @property
+    def option_file(self):
+        return self._file_type('.rc')
+
+    @property
+    def module(self):
+        package = os.path.basename(self._directory)
+        return '.'.join([package, self.base])
+
+    @property
+    def expected_output(self):
+        return self._file_type('.txt', check_exists=False)
+
+    @property
+    def source(self):
+        return self._file_type('.py')
+
+    def _file_type(self, ext, check_exists=True):
+        name = os.path.join(self._directory, self.base + ext)
+        if not check_exists or os.path.exists(name):
+            return name
+        else:
+            raise NoFileError
+
+
+_OPERATORS = {
+    '>': operator.gt,
+    '<': operator.lt,
+    '>=': operator.ge,
+    '<=': operator.le,
+}
+
+def parse_expected_output(stream):
+    return [OutputLine.from_csv(row) for row in csv.reader(stream, 'test')]
+
+
+def get_expected_messages(stream):
+    """Parses a file and get expected messages.
+
+    :param stream: File-like input stream.
+    :returns: A dict mapping line,msg-symbol tuples to the count on this line.
+    """
+    messages = collections.Counter()
+    for i, line in enumerate(stream):
+        match = _EXPECTED_RE.search(line)
+        if match is None:
+            continue
+        line = match.group('line')
+        if line is None:
+            line = i + 1
+        elif line.startswith('+') or line.startswith('-'):
+            line = i + 1 + int(line)
+        else:
+            line = int(line)
+
+        version = match.group('version')
+        op = match.group('op')
+        if version:
+            required = parse_python_version(version)
+            if not _OPERATORS[op](sys.version_info, required):
+                continue
+
+        for msg_id in match.group('msgs').split(','):
+            messages[line, msg_id.strip()] += 1
+    return messages
+
+
+def multiset_difference(left_op, right_op):
+    """Takes two multisets and compares them.
+
+    A multiset is a dict with the cardinality of the key as the value.
+
+    :param left_op: The expected entries.
+    :param right_op: Actual entries.
+
+    :returns: The two multisets of missing and unexpected messages.
+    """
+    missing = left_op.copy()
+    missing.subtract(right_op)
+    unexpected = {}
+    for key, value in list(six.iteritems(missing)):
+        if value <= 0:
+            missing.pop(key)
+            if value < 0:
+                unexpected[key] = -value
+    return missing, unexpected
+
+
+class LintModuleTest(object):
+    maxDiff = None
+
+    def __init__(self, test_file):
+        test_reporter = FunctionalTestReporter()
+        self._linter = lint.PyLinter()
+        self._linter.set_reporter(test_reporter)
+        self._linter.config.persistent = 0
+        checkers.initialize(self._linter)
+        self._linter.disable('I')
+        try:
+            self._linter.read_config_file(test_file.option_file)
+            self._linter.load_config_file()
+        except NoFileError:
+            pass
+        self._test_file = test_file
+
+    def setUp(self):
+        if self._should_be_skipped_due_to_version():
+            pytest.skip( 'Test cannot run with Python %s.' % (sys.version.split(' ')[0],))
+        missing = []
+        for req in self._test_file.options['requires']:
+            try:
+                __import__(req)
+            except ImportError:
+                missing.append(req)
+        if missing:
+            pytest.skip('Requires %s to be present.' % (','.join(missing),))
+        if self._test_file.options['except_implementations']:
+            implementations = [
+                item.strip() for item in
+                self._test_file.options['except_implementations'].split(",")
+            ]
+            implementation = platform.python_implementation()
+            if implementation in implementations:
+                pytest.skip(
+                    'Test cannot run with Python implementation %r'
+                    % (implementation, ))
+
+    def _should_be_skipped_due_to_version(self):
+        return (sys.version_info < self._test_file.options['min_pyver'] or
+                sys.version_info > self._test_file.options['max_pyver'])
+
+    def __str__(self):
+        return "%s (%s.%s)" % (self._test_file.base, self.__class__.__module__,
+                               self.__class__.__name__)
+
+    def _open_expected_file(self):
+        return open(self._test_file.expected_output)
+
+    def _open_source_file(self):
+        if self._test_file.base == "invalid_encoded_data":
+            return open(self._test_file.source)
+        if "latin1" in self._test_file.base:
+            return io.open(self._test_file.source, encoding="latin1")
+        return io.open(self._test_file.source, encoding="utf8")
+
+    def _get_expected(self):
+        with self._open_source_file() as fobj:
+            expected_msgs = get_expected_messages(fobj)
+
+        if expected_msgs:
+            with self._open_expected_file() as fobj:
+                expected_output_lines = parse_expected_output(fobj)
+        else:
+            expected_output_lines = []
+        return expected_msgs, expected_output_lines
+
+    def _get_received(self):
+        messages = self._linter.reporter.messages
+        messages.sort(key=lambda m: (m.line, m.symbol, m.msg))
+        received_msgs = collections.Counter()
+        received_output_lines = []
+        for msg in messages:
+            received_msgs[msg.line, msg.symbol] += 1
+            received_output_lines.append(OutputLine.from_msg(msg))
+        return received_msgs, received_output_lines
+
+    def _runTest(self):
+        self._linter.check([self._test_file.module])
+
+        expected_messages, expected_text = self._get_expected()
+        received_messages, received_text = self._get_received()
+
+        if expected_messages != received_messages:
+            msg = ['Wrong results for file "%s":' % (self._test_file.base)]
+            missing, unexpected = multiset_difference(expected_messages,
+                                                      received_messages)
+            if missing:
+                msg.append('\nExpected in testdata:')
+                msg.extend(' %3d: %s' % msg for msg in sorted(missing))
+            if unexpected:
+                msg.append('\nUnexpected in testdata:')
+                msg.extend(' %3d: %s' % msg for msg in sorted(unexpected))
+            pytest.fail('\n'.join(msg))
+        self._check_output_text(expected_messages, expected_text, received_text)
+
+    def _split_lines(self, expected_messages, lines):
+        emitted, omitted = [], []
+        for msg in lines:
+            if (msg[1], msg[0]) in expected_messages:
+                emitted.append(msg)
+            else:
+                omitted.append(msg)
+        return emitted, omitted
+
+    def _check_output_text(self, expected_messages, expected_lines,
+                           received_lines):
+        assert self._split_lines(expected_messages, expected_lines)[0] == \
+            received_lines, self._test_file.base
+
+
+class LintModuleOutputUpdate(LintModuleTest):
+    def _open_expected_file(self):
+        try:
+            return super(LintModuleOutputUpdate, self)._open_expected_file()
+        except IOError:
+            return io.StringIO()
+
+    def _check_output_text(self, expected_messages, expected_lines,
+                           received_lines):
+        if not expected_messages:
+            return
+        emitted, remaining = self._split_lines(expected_messages, expected_lines)
+        if emitted != received_lines:
+            remaining.extend(received_lines)
+            remaining.sort(key=lambda m: (m[1], m[0], m[3]))
+            with open(self._test_file.expected_output, 'w') as fobj:
+                writer = csv.writer(fobj, dialect='test')
+                for line in remaining:
+                    writer.writerow(line.to_csv())
+
+def get_tests():
+    input_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                             'functional')
+    suite = []
+    for fname in os.listdir(input_dir):
+        if fname != '__init__.py' and fname.endswith('.py'):
+            suite.append(FunctionalTestFile(input_dir, fname))
+    return suite
+
+
+TESTS = get_tests()
+TESTS_NAMES = [t.base for t in TESTS]
+
+
+@pytest.mark.parametrize("test_file", TESTS, ids=TESTS_NAMES)
+def test_functional(test_file):
+    LintTest = LintModuleOutputUpdate(test_file) if UPDATE else LintModuleTest(test_file)
+    LintTest.setUp()
+    LintTest._runTest()
+
+
+if __name__ == '__main__':
+    if '-u' in sys.argv:
+        UPDATE = True
+        sys.argv.remove('-u')
+    pytest.main(sys.argv)
diff --git a/tests/test_import_graph.py b/tests/test_import_graph.py
new file mode 100644
index 000000000..d7b009693
--- /dev/null
+++ b/tests/test_import_graph.py
@@ -0,0 +1,83 @@
+# Copyright (c) 2006-2008, 2010, 2013 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
+# Copyright (c) 2014-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Reverb C <reverbc@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+import os
+from os.path import exists
+
+import pytest
+
+import pylint.testutils as testutils
+from pylint.checkers import imports, initialize
+from pylint.lint import PyLinter
+
+
+@pytest.fixture
+def dest():
+    dest = "dependencies_graph.dot"
+    yield dest
+    os.remove(dest)
+
+
+def test_dependencies_graph(dest):
+    imports._dependencies_graph(dest, {"labas": ["hoho", "yep"], "hoho": ["yep"]})
+    with open(dest) as stream:
+        assert (
+            stream.read().strip()
+            == """
+digraph "dependencies_graph" {
+rankdir=LR
+charset="utf-8"
+URL="." node[shape="box"]
+"hoho" [];
+"yep" [];
+"labas" [];
+"yep" -> "hoho" [];
+"hoho" -> "labas" [];
+"yep" -> "labas" [];
+}
+""".strip()
+        )
+
+
+@pytest.fixture
+def linter():
+    l = PyLinter(reporter=testutils.TestReporter())
+    initialize(l)
+    return l
+
+
+@pytest.fixture
+def remove_files():
+    yield
+    for fname in ("import.dot", "ext_import.dot", "int_import.dot"):
+        try:
+            os.remove(fname)
+        except:
+            pass
+
+
+@pytest.mark.usefixtures("remove_files")
+def test_checker_dep_graphs(linter):
+    l = linter
+    l.global_set_option("persistent", False)
+    l.global_set_option("reports", True)
+    l.global_set_option("enable", "imports")
+    l.global_set_option("import-graph", "import.dot")
+    l.global_set_option("ext-import-graph", "ext_import.dot")
+    l.global_set_option("int-import-graph", "int_import.dot")
+    l.global_set_option("int-import-graph", "int_import.dot")
+    # ignore this file causing spurious MemoryError w/ some python version (>=2.3?)
+    l.global_set_option("ignore", ("func_unknown_encoding.py",))
+    l.check("input")
+    l.generate_reports()
+    assert exists("import.dot")
+    assert exists("ext_import.dot")
+    assert exists("int_import.dot")
diff --git a/tests/test_regr.py b/tests/test_regr.py
new file mode 100644
index 000000000..e91d4464b
--- /dev/null
+++ b/tests/test_regr.py
@@ -0,0 +1,137 @@
+# Copyright (c) 2006-2011, 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015-2018 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016-2017 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Reverb C <reverbc@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""non regression tests for pylint, which requires a too specific configuration
+to be incorporated in the automatic functional test framework
+"""
+
+import os
+import sys
+from os.path import abspath, dirname, join
+
+import astroid
+import pytest
+
+import pylint.testutils as testutils
+
+REGR_DATA = join(dirname(abspath(__file__)), "regrtest_data")
+sys.path.insert(1, REGR_DATA)
+
+try:
+    PYPY_VERSION_INFO = sys.pypy_version_info
+except AttributeError:
+    PYPY_VERSION_INFO = None
+
+
+@pytest.fixture(scope="module")
+def reporter(reporter):
+    return testutils.TestReporter
+
+
+@pytest.fixture(scope="module")
+def disable(disable):
+    return ["I"]
+
+
+@pytest.fixture
+def finalize_linter(linter):
+    """call reporter.finalize() to cleanup
+    pending messages if a test finished badly
+    """
+    yield linter
+    linter.reporter.finalize()
+
+
+def Equals(expected):
+    return lambda got: got == expected
+
+
+@pytest.mark.parametrize(
+    "file_name, check",
+    [
+        ("package.__init__", Equals("")),
+        ("precedence_test", Equals("")),
+        ("import_package_subpackage_module", Equals("")),
+        ("pylint.checkers.__init__", lambda x: "__path__" not in x),
+        (join(REGR_DATA, "classdoc_usage.py"), Equals("")),
+        (join(REGR_DATA, "module_global.py"), Equals("")),
+        (join(REGR_DATA, "decimal_inference.py"), Equals("")),
+        (join(REGR_DATA, "absimp", "string.py"), Equals("")),
+        (join(REGR_DATA, "bad_package"), lambda x: "Unused import missing" in x),
+    ],
+)
+def test_package(finalize_linter, file_name, check):
+    finalize_linter.check(file_name)
+    got = finalize_linter.reporter.finalize().strip()
+    assert check(got)
+
+
+@pytest.mark.parametrize(
+    "file_name",
+    [
+        join(REGR_DATA, "import_assign.py"),
+        join(REGR_DATA, "special_attr_scope_lookup_crash.py"),
+        join(REGR_DATA, "try_finally_disable_msg_crash"),
+    ],
+)
+def test_crash(finalize_linter, file_name):
+    finalize_linter.check(file_name)
+
+
+@pytest.mark.parametrize(
+    "fname", [x for x in os.listdir(REGR_DATA) if x.endswith("_crash.py")]
+)
+def test_descriptor_crash(fname, finalize_linter):
+    finalize_linter.check(join(REGR_DATA, fname))
+    finalize_linter.reporter.finalize().strip()
+
+
+@pytest.fixture
+def modify_path():
+    cwd = os.getcwd()
+    sys.path.insert(0, "")
+    yield
+    sys.path.pop(0)
+    os.chdir(cwd)
+
+
+@pytest.mark.usefixtures("modify_path")
+def test_check_package___init__(finalize_linter):
+    filename = "package.__init__"
+    finalize_linter.check(filename)
+    checked = list(finalize_linter.stats["by_module"].keys())
+    assert checked == [filename]
+
+    os.chdir(join(REGR_DATA, "package"))
+    finalize_linter.check("__init__")
+    checked = list(finalize_linter.stats["by_module"].keys())
+    assert checked == ["__init__"]
+
+
+def test_pylint_config_attr():
+    mod = astroid.MANAGER.ast_from_module_name("pylint.lint")
+    pylinter = mod["PyLinter"]
+    expect = [
+        "OptionsManagerMixIn",
+        "object",
+        "MessagesHandlerMixIn",
+        "ReportsHandlerMixIn",
+        "BaseTokenChecker",
+        "BaseChecker",
+        "OptionsProviderMixIn",
+    ]
+    assert [c.name for c in pylinter.ancestors()] == expect
+    assert list(astroid.Instance(pylinter).getattr("config"))
+    inferred = list(astroid.Instance(pylinter).igetattr("config"))
+    assert len(inferred) == 1
+    assert inferred[0].root().name == "optparse"
+    assert inferred[0].name == "Values"
diff --git a/tests/test_self.py b/tests/test_self.py
new file mode 100644
index 000000000..051eea87d
--- /dev/null
+++ b/tests/test_self.py
@@ -0,0 +1,669 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2006-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014-2018 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Vlad Temian <vladtemian@gmail.com>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
+# Copyright (c) 2017 hippo91 <guillaume.peillex@gmail.com>
+# Copyright (c) 2017 Daniel Miller <millerdev@gmail.com>
+# Copyright (c) 2017 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2017 Thomas Hisch <t.hisch@gmail.com>
+# Copyright (c) 2017 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Jason Owen <jason.a.owen@gmail.com>
+# Copyright (c) 2018 Jace Browning <jacebrowning@gmail.com>
+# Copyright (c) 2018 Reverb C <reverbc@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+import configparser
+import contextlib
+import json
+import platform
+import re
+import subprocess
+import tempfile
+import textwrap
+from io import StringIO
+from os.path import abspath, dirname, join
+from unittest import mock
+
+import pytest
+
+from pylint import utils
+from pylint.lint import Run
+from pylint.reporters import BaseReporter, JSONReporter
+from pylint.reporters.text import *
+
+HERE = abspath(dirname(__file__))
+
+
+@contextlib.contextmanager
+def _patch_streams(out):
+    sys.stderr = sys.stdout = out
+    try:
+        yield
+    finally:
+        sys.stderr = sys.__stderr__
+        sys.stdout = sys.__stdout__
+
+
+@contextlib.contextmanager
+def _configure_lc_ctype(lc_ctype):
+    lc_ctype_env = "LC_CTYPE"
+    original_lctype = os.environ.get(lc_ctype_env)
+    os.environ[lc_ctype_env] = lc_ctype
+    try:
+        yield
+    finally:
+        os.environ.pop(lc_ctype_env)
+        if original_lctype:
+            os.environ[lc_ctype_env] = original_lctype
+
+
+class MultiReporter(BaseReporter):
+    def __init__(self, reporters):
+        self._reporters = reporters
+        self.path_strip_prefix = os.getcwd() + os.sep
+
+    def on_set_current_module(self, *args, **kwargs):
+        for rep in self._reporters:
+            rep.on_set_current_module(*args, **kwargs)
+
+    def handle_message(self, msg):
+        for rep in self._reporters:
+            rep.handle_message(msg)
+
+    def display_reports(self, layout):
+        pass
+
+    @property
+    def out(self):
+        return self._reporters[0].out
+
+    @property
+    def linter(self):
+        return self._linter
+
+    @linter.setter
+    def linter(self, value):
+        self._linter = value
+        for rep in self._reporters:
+            rep.linter = value
+
+
+class TestRunTC(object):
+    def _runtest(self, args, reporter=None, out=None, code=None):
+        if out is None:
+            out = StringIO()
+        pylint_code = self._run_pylint(args, reporter=reporter, out=out)
+        if reporter:
+            output = reporter.out.getvalue()
+        elif hasattr(out, "getvalue"):
+            output = out.getvalue()
+        else:
+            output = None
+        msg = "expected output status %s, got %s" % (code, pylint_code)
+        if output is not None:
+            msg = "%s. Below pylint output: \n%s" % (msg, output)
+        assert pylint_code == code, msg
+
+    def _run_pylint(self, args, out, reporter=None):
+        args = args + ["--persistent=no"]
+        with _patch_streams(out):
+            with pytest.raises(SystemExit) as cm:
+                with warnings.catch_warnings():
+                    warnings.simplefilter("ignore")
+                    Run(args, reporter=reporter)
+            return cm.value.code
+
+    def _clean_paths(self, output):
+        """Remove version-specific tox parent directories from paths."""
+        return re.sub(
+            "^py.+/site-packages/", "", output.replace("\\", "/"), flags=re.MULTILINE
+        )
+
+    def _test_output(self, args, expected_output):
+        out = StringIO()
+        self._run_pylint(args, out=out)
+        actual_output = self._clean_paths(out.getvalue())
+        assert expected_output.strip() in actual_output.strip()
+
+    def test_pkginfo(self):
+        """Make pylint check itself."""
+        self._runtest(["pylint.__pkginfo__"], reporter=TextReporter(StringIO()), code=0)
+
+    def test_all(self):
+        """Make pylint check itself."""
+        reporters = [
+            TextReporter(StringIO()),
+            ColorizedTextReporter(StringIO()),
+            JSONReporter(StringIO()),
+        ]
+        self._runtest(
+            [join(HERE, "functional/arguments.py")],
+            reporter=MultiReporter(reporters),
+            code=2,
+        )
+
+    def test_no_ext_file(self):
+        self._runtest([join(HERE, "input", "noext")], code=0)
+
+    def test_w0704_ignored(self):
+        self._runtest([join(HERE, "input", "ignore_except_pass_by_default.py")], code=0)
+
+    def test_exit_zero(self):
+        self._runtest(
+            ["--exit-zero", join(HERE, "regrtest_data", "syntax_error.py")], code=0
+        )
+
+    def test_generate_config_option(self):
+        self._runtest(["--generate-rcfile"], code=0)
+
+    def test_generate_config_option_order(self):
+        out1 = StringIO()
+        out2 = StringIO()
+        self._runtest(["--generate-rcfile"], code=0, out=out1)
+        self._runtest(["--generate-rcfile"], code=0, out=out2)
+        output1 = out1.getvalue()
+        output2 = out2.getvalue()
+        assert output1 == output2
+
+    def test_generate_config_disable_symbolic_names(self):
+        # Test that --generate-rcfile puts symbolic names in the --disable
+        # option.
+
+        out = StringIO()
+        self._run_pylint(["--generate-rcfile", "--rcfile="], out=out)
+
+        output = out.getvalue()
+        # Get rid of the pesky messages that pylint emits if the
+        # configuration file is not found.
+        master = re.search(r"\[MASTER", output)
+        out = StringIO(output[master.start() :])
+        parser = configparser.RawConfigParser()
+        parser.read_file(out)
+        messages = utils._splitstrip(parser.get("MESSAGES CONTROL", "disable"))
+        assert "suppressed-message" in messages
+
+    def test_generate_rcfile_no_obsolete_methods(self):
+        out = StringIO()
+        self._run_pylint(["--generate-rcfile"], out=out)
+        output = out.getvalue()
+        assert "profile" not in output
+
+    def test_inexisting_rcfile(self):
+        out = StringIO()
+        with pytest.raises(IOError) as excinfo:
+            self._run_pylint(["--rcfile=/tmp/norcfile.txt"], out=out)
+        assert "The config file /tmp/norcfile.txt doesn't exist!" == str(excinfo.value)
+
+    def test_help_message_option(self):
+        self._runtest(["--help-msg", "W0101"], code=0)
+
+    def test_error_help_message_option(self):
+        self._runtest(["--help-msg", "WX101"], code=0)
+
+    def test_error_missing_arguments(self):
+        self._runtest([], code=32)
+
+    def test_no_out_encoding(self):
+        """test redirection of stdout with non ascii caracters
+        """
+        # This test reproduces bug #48066 ; it happens when stdout is redirected
+        # through '>' : the sys.stdout.encoding becomes then None, and if the
+        # output contains non ascii, pylint will crash
+        if sys.version_info < (3, 0):
+            strio = tempfile.TemporaryFile()
+        else:
+            strio = StringIO()
+        assert strio.encoding is None
+        self._runtest(
+            [join(HERE, "regrtest_data/no_stdout_encoding.py"), "--enable=all"],
+            out=strio,
+            code=28,
+        )
+
+    def test_parallel_execution(self):
+        self._runtest(
+            [
+                "-j 2",
+                join(HERE, "functional/arguments.py"),
+                join(HERE, "functional/arguments.py"),
+            ],
+            code=2,
+        )
+
+    def test_parallel_execution_missing_arguments(self):
+        self._runtest(["-j 2", "not_here", "not_here_too"], code=1)
+
+    def test_py3k_option(self):
+        # Test that --py3k flag works.
+        rc_code = 0
+        self._runtest(
+            [join(HERE, "functional", "unpacked_exceptions.py"), "--py3k"], code=rc_code
+        )
+
+    def test_py3k_jobs_option(self):
+        rc_code = 0
+        self._runtest(
+            [join(HERE, "functional", "unpacked_exceptions.py"), "--py3k", "-j 2"],
+            code=rc_code,
+        )
+
+    @pytest.mark.skipif(sys.version_info[0] > 2, reason="Requires the --py3k flag.")
+    def test_py3k_commutative_with_errors_only(self):
+
+        # Test what gets emitted with -E only
+        module = join(HERE, "regrtest_data", "py3k_error_flag.py")
+        expected = textwrap.dedent(
+            """
+        ************* Module py3k_error_flag
+        Explicit return in __init__
+        """
+        )
+        self._test_output(
+            [module, "-E", "--msg-template='{msg}'"], expected_output=expected
+        )
+
+        # Test what gets emitted with -E --py3k
+        expected = textwrap.dedent(
+            """
+        ************* Module py3k_error_flag
+        Use raise ErrorClass(args) instead of raise ErrorClass, args.
+        """
+        )
+        self._test_output(
+            [module, "-E", "--py3k", "--msg-template='{msg}'"], expected_output=expected
+        )
+
+        # Test what gets emitted with --py3k -E
+        self._test_output(
+            [module, "--py3k", "-E", "--msg-template='{msg}'"], expected_output=expected
+        )
+
+    @pytest.mark.skipif(sys.version_info[0] > 2, reason="Requires the --py3k flag.")
+    def test_py3k_commutative_with_config_disable(self):
+        module = join(HERE, "regrtest_data", "py3k_errors_and_warnings.py")
+        rcfile = join(HERE, "regrtest_data", "py3k-disabled.rc")
+        cmd = [module, "--msg-template='{msg}'", "--reports=n"]
+
+        expected = textwrap.dedent(
+            """
+        ************* Module py3k_errors_and_warnings
+        import missing `from __future__ import absolute_import`
+        Use raise ErrorClass(args) instead of raise ErrorClass, args.
+        Calling a dict.iter*() method
+        print statement used
+        """
+        )
+        self._test_output(cmd + ["--py3k"], expected_output=expected)
+
+        expected = textwrap.dedent(
+            """
+        ************* Module py3k_errors_and_warnings
+        Use raise ErrorClass(args) instead of raise ErrorClass, args.
+        Calling a dict.iter*() method
+        print statement used
+        """
+        )
+        self._test_output(
+            cmd + ["--py3k", "--rcfile", rcfile], expected_output=expected
+        )
+
+        expected = textwrap.dedent(
+            """
+        ************* Module py3k_errors_and_warnings
+        Use raise ErrorClass(args) instead of raise ErrorClass, args.
+        print statement used
+        """
+        )
+        self._test_output(
+            cmd + ["--py3k", "-E", "--rcfile", rcfile], expected_output=expected
+        )
+
+        self._test_output(
+            cmd + ["-E", "--py3k", "--rcfile", rcfile], expected_output=expected
+        )
+
+    def test_abbreviations_are_not_supported(self):
+        expected = "no such option: --load-plugin"
+        self._test_output([".", "--load-plugin"], expected_output=expected)
+
+    def test_enable_all_works(self):
+        module = join(HERE, "data", "clientmodule_test.py")
+        expected = textwrap.dedent(
+            """
+        ************* Module data.clientmodule_test
+        {0}:10:8: W0612: Unused variable 'local_variable' (unused-variable)
+        {0}:18:4: C0111: Missing method docstring (missing-docstring)
+        {0}:22:0: C0111: Missing class docstring (missing-docstring)
+        """.format(module)
+        )
+        self._test_output(
+            [module, "--disable=all", "--enable=all", "-rn"], expected_output=expected
+        )
+
+    def test_wrong_import_position_when_others_disabled(self):
+        module1 = join(HERE, "regrtest_data", "import_something.py")
+        module2 = join(HERE, "regrtest_data", "wrong_import_position.py")
+        expected_output = textwrap.dedent(
+            """
+        ************* Module wrong_import_position
+        {}:11:0: C0413: Import "import os" should be placed at the top of the module (wrong-import-position)
+        """.format(module2)
+        )
+        args = [
+            module2,
+            module1,
+            "--disable=all",
+            "--enable=wrong-import-position",
+            "-rn",
+            "-sn",
+        ]
+        out = StringIO()
+        self._run_pylint(args, out=out)
+        actual_output = self._clean_paths(out.getvalue().strip())
+
+        to_remove = "No config file found, using default configuration"
+        if to_remove in actual_output:
+            actual_output = actual_output[len(to_remove) :]
+        if actual_output.startswith("Using config file "):
+            # If ~/.pylintrc is present remove the
+            # Using config file...  line
+            actual_output = actual_output[actual_output.find("\n") :]
+        assert expected_output.strip() == actual_output.strip()
+
+    def test_import_itself_not_accounted_for_relative_imports(self):
+        expected = "Your code has been rated at 10.00/10"
+        package = join(HERE, "regrtest_data", "dummy")
+        self._test_output(
+            [package, "--disable=locally-disabled", "-rn"], expected_output=expected
+        )
+
+    def test_reject_empty_indent_strings(self):
+        expected = "indent string can't be empty"
+        module = join(HERE, "data", "clientmodule_test.py")
+        self._test_output([module, "--indent-string="], expected_output=expected)
+
+    def test_json_report_when_file_has_syntax_error(self):
+        out = StringIO()
+        module = join(HERE, "regrtest_data", "syntax_error.py")
+        self._runtest([module], code=2, reporter=JSONReporter(out))
+        output = json.loads(out.getvalue())
+        assert isinstance(output, list)
+        assert len(output) == 1
+        assert isinstance(output[0], dict)
+        expected = {
+            "obj": "",
+            "column": 8 if platform.python_implementation() == "PyPy" else 15,
+            "line": 1,
+            "type": "error",
+            "symbol": "syntax-error",
+            "module": "syntax_error",
+        }
+        message = output[0]
+        for key, value in expected.items():
+            assert key in message
+            assert message[key] == value
+        assert "invalid syntax" in message["message"].lower()
+
+    def test_json_report_when_file_is_missing(self):
+        out = StringIO()
+        module = join(HERE, "regrtest_data", "totally_missing.py")
+        self._runtest([module], code=1, reporter=JSONReporter(out))
+        output = json.loads(out.getvalue())
+        assert isinstance(output, list)
+        assert len(output) == 1
+        assert isinstance(output[0], dict)
+        expected = {
+            "obj": "",
+            "column": 0,
+            "line": 1,
+            "type": "fatal",
+            "symbol": "fatal",
+            "module": module,
+        }
+        message = output[0]
+        for key, value in expected.items():
+            assert key in message
+            assert message[key] == value
+        assert message["message"].startswith("No module named")
+
+    def test_json_report_does_not_escape_quotes(self):
+        out = StringIO()
+        module = join(HERE, "regrtest_data", "unused_variable.py")
+        self._runtest([module], code=4, reporter=JSONReporter(out))
+        output = json.loads(out.getvalue())
+        assert isinstance(output, list)
+        assert len(output) == 1
+        assert isinstance(output[0], dict)
+        expected = {
+            "symbol": "unused-variable",
+            "module": "unused_variable",
+            "column": 4,
+            "message": "Unused variable 'variable'",
+            "message-id": "W0612",
+            "line": 4,
+            "type": "warning",
+        }
+        message = output[0]
+        for key, value in expected.items():
+            assert key in message
+            assert message[key] == value
+
+    def test_information_category_disabled_by_default(self):
+        expected = "Your code has been rated at 10.00/10"
+        path = join(HERE, "regrtest_data", "meta.py")
+        self._test_output([path], expected_output=expected)
+
+    def test_error_mode_shows_no_score(self):
+        module = join(HERE, "regrtest_data", "application_crash.py")
+        expected_output = textwrap.dedent(
+            """
+        ************* Module application_crash
+        {}:1:6: E0602: Undefined variable 'something_undefined' (undefined-variable)
+        """.format(module)
+        )
+        self._test_output([module, "-E"], expected_output=expected_output)
+
+    def test_evaluation_score_shown_by_default(self):
+        expected_output = "Your code has been rated at "
+        module = join(HERE, "regrtest_data", "application_crash.py")
+        self._test_output([module], expected_output=expected_output)
+
+    def test_confidence_levels(self):
+        expected = "Your code has been rated at"
+        path = join(HERE, "regrtest_data", "meta.py")
+        self._test_output(
+            [path, "--confidence=HIGH,INFERENCE"], expected_output=expected
+        )
+
+    def test_bom_marker(self):
+        path = join(HERE, "regrtest_data", "meta.py")
+        config_path = join(HERE, "regrtest_data", ".pylintrc")
+        expected = "Your code has been rated at 10.00/10"
+        self._test_output(
+            [path, "--rcfile=%s" % config_path, "-rn"], expected_output=expected
+        )
+
+    def test_pylintrc_plugin_duplicate_options(self):
+        dummy_plugin_path = join(HERE, "regrtest_data", "dummy_plugin")
+        # Enable --load-plugins=dummy_plugin
+        sys.path.append(dummy_plugin_path)
+        config_path = join(HERE, "regrtest_data", "dummy_plugin.rc")
+        expected = (
+            ":dummy-message-01 (I9061): *Dummy short desc 01*\n"
+            "  Dummy long desc This message belongs to the dummy_plugin checker.\n\n"
+            ":dummy-message-02 (I9060): *Dummy short desc 02*\n"
+            "  Dummy long desc This message belongs to the dummy_plugin checker."
+        )
+        self._test_output(
+            [
+                "--rcfile=%s" % config_path,
+                "--help-msg=dummy-message-01,dummy-message-02",
+            ],
+            expected_output=expected,
+        )
+        expected = (
+            "[DUMMY_PLUGIN]\n\n# Dummy option 1\ndummy_option_1=dummy value 1\n\n"
+            "# Dummy option 2\ndummy_option_2=dummy value 2"
+        )
+        self._test_output(
+            ["--rcfile=%s" % config_path, "--generate-rcfile"], expected_output=expected
+        )
+        sys.path.remove(dummy_plugin_path)
+
+    def test_pylintrc_comments_in_values(self):
+        path = join(HERE, "regrtest_data", "test_pylintrc_comments.py")
+        config_path = join(HERE, "regrtest_data", "comments_pylintrc")
+        expected = textwrap.dedent(
+            """
+        ************* Module test_pylintrc_comments
+        {0}:2:0: W0311: Bad indentation. Found 1 spaces, expected 4 (bad-indentation)
+        {0}:1:0: C0111: Missing module docstring (missing-docstring)
+        {0}:1:0: C0111: Missing function docstring (missing-docstring)
+        """.format(path)
+        )
+        self._test_output(
+            [path, "--rcfile=%s" % config_path, "-rn"], expected_output=expected
+        )
+
+    def test_no_crash_with_formatting_regex_defaults(self):
+        self._runtest(
+            ["--ignore-patterns=a"], reporter=TextReporter(StringIO()), code=32
+        )
+
+    def test_getdefaultencoding_crashes_with_lc_ctype_utf8(self):
+        module = join(HERE, "regrtest_data", "application_crash.py")
+        expected_output = textwrap.dedent(
+            """
+        ************* Module application_crash
+        {}:1:6: E0602: Undefined variable 'something_undefined' (undefined-variable)
+        """.format(module)
+        )
+        with _configure_lc_ctype("UTF-8"):
+            self._test_output([module, "-E"], expected_output=expected_output)
+
+    @pytest.mark.skipif(sys.platform == "win32", reason="only occurs on *nix")
+    def test_parseable_file_path(self):
+        file_name = "test_target.py"
+        fake_path = HERE + os.getcwd()
+        module = join(fake_path, file_name)
+
+        try:
+            # create module under directories which have the same name as reporter.path_strip_prefix
+            # e.g. /src/some/path/src/test_target.py when reporter.path_strip_prefix = /src/
+            os.makedirs(fake_path)
+            with open(module, "w") as test_target:
+                test_target.write("a,b = object()")
+
+            self._test_output(
+                [module, "--output-format=parseable"],
+                expected_output=file_name,
+            )
+        finally:
+            os.remove(module)
+            os.removedirs(fake_path)
+
+    @pytest.mark.parametrize(
+        "input_path,module,expected_path",
+        [
+            (join(HERE, "mymodule.py"), "mymodule", join(HERE, "mymodule.py")),
+            ("mymodule.py", "mymodule", "mymodule.py"),
+        ],
+    )
+    def test_stdin(self, input_path, module, expected_path):
+        expected_output = (
+            "************* Module {module}\n"
+            "{path}:1:0: W0611: Unused import os (unused-import)\n\n"
+        ).format(path=expected_path, module=module)
+
+        with mock.patch(
+            "pylint.lint._read_stdin", return_value="import os\n"
+        ) as mock_stdin:
+            self._test_output(
+                ["--from-stdin", input_path, "--disable=all", "--enable=unused-import"],
+                expected_output=expected_output,
+            )
+            assert mock_stdin.call_count == 1
+
+    def test_stdin_missing_modulename(self):
+        self._runtest(["--from-stdin"], code=32)
+
+    @pytest.mark.parametrize("write_bpy_to_disk", [False, True])
+    def test_relative_imports(self, write_bpy_to_disk, tmpdir):
+        a = tmpdir.join("a")
+
+        b_code = textwrap.dedent(
+            """
+            from .c import foobar
+            from .d import bla  # module does not exist
+
+            foobar('hello')
+            bla()
+            """
+        )
+
+        c_code = textwrap.dedent(
+            """
+            def foobar(arg):
+                pass
+            """
+        )
+
+        a.mkdir()
+        a.join("__init__.py").write("")
+        if write_bpy_to_disk:
+            a.join("b.py").write(b_code)
+        a.join("c.py").write(c_code)
+
+        curdir = os.getcwd()
+        try:
+            # why don't we start pylint in a subprocess?
+            os.chdir(str(tmpdir))
+            expected = (
+                "************* Module a.b\n"
+                "a/b.py:3:0: E0401: Unable to import 'a.d' (import-error)\n\n"
+            )
+
+            if write_bpy_to_disk:
+                # --from-stdin is not used here
+                self._test_output(
+                    ["a/b.py", "--disable=all", "--enable=import-error"],
+                    expected_output=expected,
+                )
+
+            # this code needs to work w/ and w/o a file named a/b.py on the
+            # harddisk.
+            with mock.patch("pylint.lint._read_stdin", return_value=b_code):
+                self._test_output(
+                    [
+                        "--from-stdin",
+                        join("a", "b.py"),
+                        "--disable=all",
+                        "--enable=import-error",
+                    ],
+                    expected_output=expected,
+                )
+
+        finally:
+            os.chdir(curdir)
+
+    def test_version(self):
+        def check(lines):
+            assert lines[0].startswith("pylint ")
+            assert lines[1].startswith("astroid ")
+            assert lines[2].startswith("Python ")
+
+        out = StringIO()
+        self._run_pylint(["--version"], out=out)
+        check(out.getvalue().splitlines())
+
+        result = subprocess.check_output([sys.executable, "-m", "pylint", "--version"])
+        result = result.decode("utf-8")
+        check(result.splitlines())
diff --git a/tests/unittest_checker_base.py b/tests/unittest_checker_base.py
new file mode 100644
index 000000000..1feae5b7a
--- /dev/null
+++ b/tests/unittest_checker_base.py
@@ -0,0 +1,528 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2013-2015 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2013-2014 Google, Inc.
+# Copyright (c) 2015-2018 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Dmitry Pribysh <dmand@yandex.ru>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Yannack <yannack@users.noreply.github.com>
+# Copyright (c) 2017 ttenhoeve-aa <ttenhoeve@appannie.com>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2017 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2018 Fureigh <fureigh@users.noreply.github.com>
+# Copyright (c) 2018 glmdgrielson <32415403+glmdgrielson@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Unittest for the base checker."""
+
+import re
+import sys
+import unittest
+
+import astroid
+
+from pylint.checkers import base
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+
+class TestDocstring(CheckerTestCase):
+    CHECKER_CLASS = base.DocStringChecker
+
+    def test_missing_docstring_module(self):
+        module = astroid.parse("something")
+        message = Message("missing-docstring", node=module, args=("module",))
+        with self.assertAddsMessages(message):
+            self.checker.visit_module(module)
+
+    def test_missing_docstring_empty_module(self):
+        module = astroid.parse("")
+        with self.assertNoMessages():
+            self.checker.visit_module(module)
+
+    def test_empty_docstring_module(self):
+        module = astroid.parse("''''''")
+        message = Message("empty-docstring", node=module, args=("module",))
+        with self.assertAddsMessages(message):
+            self.checker.visit_module(module)
+
+    def test_empty_docstring_function(self):
+        func = astroid.extract_node(
+            """
+        def func(tion):
+           pass"""
+        )
+        message = Message("missing-docstring", node=func, args=("function",))
+        with self.assertAddsMessages(message):
+            self.checker.visit_functiondef(func)
+
+    @set_config(docstring_min_length=2)
+    def test_short_function_no_docstring(self):
+        func = astroid.extract_node(
+            """
+        def func(tion):
+           pass"""
+        )
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(func)
+
+    @set_config(docstring_min_length=2)
+    def test_long_function_no_docstring(self):
+        func = astroid.extract_node(
+            """
+        def func(tion):
+            pass
+            pass
+           """
+        )
+        message = Message("missing-docstring", node=func, args=("function",))
+        with self.assertAddsMessages(message):
+            self.checker.visit_functiondef(func)
+
+    @set_config(docstring_min_length=2)
+    def test_long_function_nested_statements_no_docstring(self):
+        func = astroid.extract_node(
+            """
+        def func(tion):
+            try:
+                pass
+            except:
+                pass
+           """
+        )
+        message = Message("missing-docstring", node=func, args=("function",))
+        with self.assertAddsMessages(message):
+            self.checker.visit_functiondef(func)
+
+    @set_config(docstring_min_length=2)
+    def test_function_no_docstring_by_name(self):
+        func = astroid.extract_node(
+            """
+        def __fun__(tion):
+           pass"""
+        )
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(func)
+
+    def test_class_no_docstring(self):
+        klass = astroid.extract_node(
+            """
+        class Klass(object):
+           pass"""
+        )
+        message = Message("missing-docstring", node=klass, args=("class",))
+        with self.assertAddsMessages(message):
+            self.checker.visit_classdef(klass)
+
+    def test_inner_function_no_docstring(self):
+        func = astroid.extract_node(
+            """
+        def func(tion):
+            \"""Documented\"""
+            def inner(fun):
+                # Not documented
+                pass
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(func)
+
+
+class TestNameChecker(CheckerTestCase):
+    CHECKER_CLASS = base.NameChecker
+    CONFIG = {"bad_names": set()}
+
+    @set_config(
+        attr_rgx=re.compile("[A-Z]+"),
+        property_classes=("abc.abstractproperty", ".custom_prop"),
+    )
+    def test_property_names(self):
+        # If a method is annotated with @property, its name should
+        # match the attr regex. Since by default the attribute regex is the same
+        # as the method regex, we override it here.
+        methods = astroid.extract_node(
+            """
+        import abc
+
+        def custom_prop(f):
+          return property(f)
+
+        class FooClass(object):
+          @property
+          def FOO(self): #@
+            pass
+
+          @property
+          def bar(self): #@
+            pass
+
+          @abc.abstractproperty
+          def BAZ(self): #@
+            pass
+
+          @custom_prop
+          def QUX(self): #@
+            pass
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(methods[0])
+            self.checker.visit_functiondef(methods[2])
+            self.checker.visit_functiondef(methods[3])
+        with self.assertAddsMessages(
+            Message(
+                "invalid-name",
+                node=methods[1],
+                args=("Attribute", "bar", "'[A-Z]+' pattern"),
+            )
+        ):
+            self.checker.visit_functiondef(methods[1])
+
+    @set_config(attr_rgx=re.compile("[A-Z]+"))
+    def test_property_setters(self):
+        method = astroid.extract_node(
+            """
+        class FooClass(object):
+          @property
+          def foo(self): pass
+
+          @foo.setter
+          def FOOSETTER(self): #@
+             pass
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(method)
+
+    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])
+
+    @unittest.skipIf(sys.version_info >= (3, 7), reason="Needs Python 3.6 or earlier")
+    @set_config(const_rgx=re.compile(".+"))
+    @set_config(function_rgx=re.compile(".+"))
+    @set_config(class_rgx=re.compile(".+"))
+    def test_assign_to_new_keyword_py3(self):
+        ast = astroid.extract_node(
+            """
+        async = "foo"  #@
+        await = "bar"  #@
+        def async():   #@
+            pass
+        class async:   #@
+            pass
+        """
+        )
+        with self.assertAddsMessages(
+            Message(
+                msg_id="assign-to-new-keyword",
+                node=ast[0].targets[0],
+                args=("async", "3.7"),
+            )
+        ):
+            self.checker.visit_assignname(ast[0].targets[0])
+        with self.assertAddsMessages(
+            Message(
+                msg_id="assign-to-new-keyword",
+                node=ast[1].targets[0],
+                args=("await", "3.7"),
+            )
+        ):
+            self.checker.visit_assignname(ast[1].targets[0])
+        with self.assertAddsMessages(
+            Message(msg_id="assign-to-new-keyword", node=ast[2], args=("async", "3.7"))
+        ):
+            self.checker.visit_functiondef(ast[2])
+        with self.assertAddsMessages(
+            Message(msg_id="assign-to-new-keyword", node=ast[3], args=("async", "3.7"))
+        ):
+            self.checker.visit_classdef(ast[3])
+
+
+class TestMultiNamingStyle(CheckerTestCase):
+    CHECKER_CLASS = base.NameChecker
+
+    MULTI_STYLE_RE = re.compile("(?:(?P<UP>[A-Z]+)|(?P<down>[a-z]+))$")
+
+    @set_config(class_rgx=MULTI_STYLE_RE)
+    def test_multi_name_detection_majority(self):
+        classes = astroid.extract_node(
+            """
+        class classb(object): #@
+            pass
+        class CLASSA(object): #@
+            pass
+        class CLASSC(object): #@
+            pass
+        """
+        )
+        message = Message(
+            "invalid-name",
+            node=classes[0],
+            args=("Class", "classb", "'(?:(?P<UP>[A-Z]+)|(?P<down>[a-z]+))$' pattern"),
+        )
+        with self.assertAddsMessages(message):
+            for cls in classes:
+                self.checker.visit_classdef(cls)
+            self.checker.leave_module(cls.root)
+
+    @set_config(class_rgx=MULTI_STYLE_RE)
+    def test_multi_name_detection_first_invalid(self):
+        classes = astroid.extract_node(
+            """
+        class class_a(object): #@
+            pass
+        class classb(object): #@
+            pass
+        class CLASSC(object): #@
+            pass
+        """
+        )
+        messages = [
+            Message(
+                "invalid-name",
+                node=classes[0],
+                args=(
+                    "Class",
+                    "class_a",
+                    "'(?:(?P<UP>[A-Z]+)|(?P<down>[a-z]+))$' pattern",
+                ),
+            ),
+            Message(
+                "invalid-name",
+                node=classes[2],
+                args=(
+                    "Class",
+                    "CLASSC",
+                    "'(?:(?P<UP>[A-Z]+)|(?P<down>[a-z]+))$' pattern",
+                ),
+            ),
+        ]
+        with self.assertAddsMessages(*messages):
+            for cls in classes:
+                self.checker.visit_classdef(cls)
+            self.checker.leave_module(cls.root)
+
+    @set_config(
+        method_rgx=MULTI_STYLE_RE,
+        function_rgx=MULTI_STYLE_RE,
+        name_group=("function:method",),
+    )
+    def test_multi_name_detection_group(self):
+        function_defs = astroid.extract_node(
+            """
+        class First(object):
+            def func(self): #@
+                pass
+
+        def FUNC(): #@
+            pass
+        """,
+            module_name="test",
+        )
+        message = Message(
+            "invalid-name",
+            node=function_defs[1],
+            args=("Function", "FUNC", "'(?:(?P<UP>[A-Z]+)|(?P<down>[a-z]+))$' pattern"),
+        )
+        with self.assertAddsMessages(message):
+            for func in function_defs:
+                self.checker.visit_functiondef(func)
+            self.checker.leave_module(func.root)
+
+    @set_config(
+        function_rgx=re.compile("(?:(?P<ignore>FOO)|(?P<UP>[A-Z]+)|(?P<down>[a-z]+))$")
+    )
+    def test_multi_name_detection_exempt(self):
+        function_defs = astroid.extract_node(
+            """
+        def FOO(): #@
+            pass
+        def lower(): #@
+            pass
+        def FOO(): #@
+            pass
+        def UPPER(): #@
+            pass
+        """
+        )
+        message = Message(
+            "invalid-name",
+            node=function_defs[3],
+            args=(
+                "Function",
+                "UPPER",
+                "'(?:(?P<ignore>FOO)|(?P<UP>[A-Z]+)|(?P<down>[a-z]+))$' pattern",
+            ),
+        )
+        with self.assertAddsMessages(message):
+            for func in function_defs:
+                self.checker.visit_functiondef(func)
+            self.checker.leave_module(func.root)
+
+
+class TestComparison(CheckerTestCase):
+    CHECKER_CLASS = base.ComparisonChecker
+
+    def test_comparison(self):
+        node = astroid.extract_node("foo == True")
+        message = Message("singleton-comparison", node=node, args=(True, "just 'expr'"))
+        with self.assertAddsMessages(message):
+            self.checker.visit_compare(node)
+
+        node = astroid.extract_node("foo == False")
+        message = Message("singleton-comparison", node=node, args=(False, "'not expr'"))
+        with self.assertAddsMessages(message):
+            self.checker.visit_compare(node)
+
+        node = astroid.extract_node("foo == None")
+        message = Message(
+            "singleton-comparison", node=node, args=(None, "'expr is None'")
+        )
+        with self.assertAddsMessages(message):
+            self.checker.visit_compare(node)
+
+        node = astroid.extract_node("True == foo")
+        messages = (
+            Message("misplaced-comparison-constant", node=node, args=("foo == True",)),
+            Message("singleton-comparison", node=node, args=(True, "just 'expr'")),
+        )
+        with self.assertAddsMessages(*messages):
+            self.checker.visit_compare(node)
+
+        node = astroid.extract_node("False == foo")
+        messages = (
+            Message("misplaced-comparison-constant", node=node, args=("foo == False",)),
+            Message("singleton-comparison", node=node, args=(False, "'not expr'")),
+        )
+        with self.assertAddsMessages(*messages):
+            self.checker.visit_compare(node)
+
+        node = astroid.extract_node("None == foo")
+        messages = (
+            Message("misplaced-comparison-constant", node=node, args=("foo == None",)),
+            Message("singleton-comparison", node=node, args=(None, "'expr is None'")),
+        )
+        with self.assertAddsMessages(*messages):
+            self.checker.visit_compare(node)
+
+
+class TestNamePresets(unittest.TestCase):
+    SNAKE_CASE_NAMES = {"test_snake_case", "test_snake_case11", "test_https_200"}
+    CAMEL_CASE_NAMES = {"testCamelCase", "testCamelCase11", "testHTTP200"}
+    UPPER_CASE_NAMES = {"TEST_UPPER_CASE", "TEST_UPPER_CASE11", "TEST_HTTP_200"}
+    PASCAL_CASE_NAMES = {"TestPascalCase", "TestPascalCase11", "TestHTTP200"}
+    ALL_NAMES = (
+        SNAKE_CASE_NAMES | CAMEL_CASE_NAMES | UPPER_CASE_NAMES | PASCAL_CASE_NAMES
+    )
+
+    def _test_name_is_correct_for_all_name_types(self, naming_style, name):
+        for name_type in base.KNOWN_NAME_TYPES:
+            self._test_is_correct(naming_style, name, name_type)
+
+    def _test_name_is_incorrect_for_all_name_types(self, naming_style, name):
+        for name_type in base.KNOWN_NAME_TYPES:
+            self._test_is_incorrect(naming_style, name, name_type)
+
+    def _test_should_always_pass(self, naming_style):
+        always_pass_data = [
+            ("__add__", "method"),
+            ("__set_name__", "method"),
+            ("__version__", "const"),
+            ("__author__", "const"),
+        ]
+        for name, name_type in always_pass_data:
+            self._test_is_correct(naming_style, name, name_type)
+
+    def _test_is_correct(self, naming_style, name, name_type):
+        rgx = naming_style.get_regex(name_type)
+        self.assertTrue(
+            rgx.match(name),
+            "{!r} does not match pattern {!r} (style: {}, type: {})".format(
+                name, rgx, naming_style, name_type
+            ),
+        )
+
+    def _test_is_incorrect(self, naming_style, name, name_type):
+        rgx = naming_style.get_regex(name_type)
+        self.assertFalse(
+            rgx.match(name),
+            "{!r} match pattern {!r} but shouldn't (style: {}, type: {})".format(
+                name, rgx, naming_style, name_type
+            ),
+        )
+
+    def test_snake_case(self):
+        naming_style = base.SnakeCaseStyle
+
+        for name in self.SNAKE_CASE_NAMES:
+            self._test_name_is_correct_for_all_name_types(naming_style, name)
+        for name in self.ALL_NAMES - self.SNAKE_CASE_NAMES:
+            self._test_name_is_incorrect_for_all_name_types(naming_style, name)
+
+        self._test_should_always_pass(naming_style)
+
+    def test_camel_case(self):
+        naming_style = base.CamelCaseStyle
+
+        for name in self.CAMEL_CASE_NAMES:
+            self._test_name_is_correct_for_all_name_types(naming_style, name)
+        for name in self.ALL_NAMES - self.CAMEL_CASE_NAMES:
+            self._test_name_is_incorrect_for_all_name_types(naming_style, name)
+
+        self._test_should_always_pass(naming_style)
+
+    def test_upper_case(self):
+        naming_style = base.UpperCaseStyle
+
+        for name in self.UPPER_CASE_NAMES:
+            self._test_name_is_correct_for_all_name_types(naming_style, name)
+        for name in self.ALL_NAMES - self.UPPER_CASE_NAMES:
+            self._test_name_is_incorrect_for_all_name_types(naming_style, name)
+
+        self._test_should_always_pass(naming_style)
+
+    def test_pascal_case(self):
+        naming_style = base.PascalCaseStyle
+
+        for name in self.PASCAL_CASE_NAMES:
+            self._test_name_is_correct_for_all_name_types(naming_style, name)
+        for name in self.ALL_NAMES - self.PASCAL_CASE_NAMES:
+            self._test_name_is_incorrect_for_all_name_types(naming_style, name)
+
+        self._test_should_always_pass(naming_style)
diff --git a/tests/unittest_checker_classes.py b/tests/unittest_checker_classes.py
new file mode 100644
index 000000000..3925cc36d
--- /dev/null
+++ b/tests/unittest_checker_classes.py
@@ -0,0 +1,115 @@
+# Copyright (c) 2014-2018 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Unit tests for the variables checker."""
+import astroid
+
+from pylint.checkers import classes
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+
+class TestVariablesChecker(CheckerTestCase):
+
+    CHECKER_CLASS = classes.ClassChecker
+
+    def test_bitbucket_issue_164(self):
+        """Issue 164 report a false negative for access-member-before-definition"""
+        n1, n2 = astroid.extract_node(
+            """
+        class MyClass1:
+          def __init__(self):
+            self.first += 5 #@
+            self.first = 0  #@
+        """
+        )
+        message = Message(
+            "access-member-before-definition", node=n1.target, args=("first", n2.lineno)
+        )
+        with self.assertAddsMessages(message):
+            self.walk(n1.root())
+
+    @set_config(exclude_protected=("_meta", "_manager"))
+    def test_exclude_protected(self):
+        """Test that exclude-protected can be used to
+        exclude names from protected-access warning.
+        """
+
+        node = astroid.parse(
+            """
+        class Protected:
+            '''empty'''
+            def __init__(self):
+                self._meta = 42
+                self._manager = 24
+                self._teta = 29
+        OBJ = Protected()
+        OBJ._meta
+        OBJ._manager
+        OBJ._teta
+        """
+        )
+        with self.assertAddsMessages(
+            Message("protected-access", node=node.body[-1].value, args="_teta")
+        ):
+            self.walk(node.root())
+
+    def test_regression_non_parent_init_called_tracemalloc(self):
+        # This used to raise a non-parent-init-called on Pylint 1.3
+        # See issue https://bitbucket.org/logilab/pylint/issue/308/
+        # for reference.
+        node = astroid.extract_node(
+            """
+        from tracemalloc import Sequence
+        class _Traces(Sequence):
+            def __init__(self, traces): #@
+                Sequence.__init__(self)
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_super_init_not_called_regression(self):
+        # This should not emit a super-init-not-called
+        # warning. It previously did this, because
+        # ``next(node.infer())`` was used in that checker's
+        # logic and the first inferred node was an Uninferable object,
+        # leading to this false positive.
+        node = astroid.extract_node(
+            """
+        import ctypes
+
+        class Foo(ctypes.BigEndianStructure):
+            def __init__(self): #@
+                ctypes.BigEndianStructure.__init__(self)
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_uninferable_attribute(self):
+        """Make sure protect-access doesn't raise
+        an exception Uninferable attributes"""
+
+        node = astroid.extract_node(
+            """
+        class MC():
+            @property
+            def nargs(self):
+                return 1 if self._nargs else 2
+
+        class Application(metaclass=MC):
+            def __new__(cls):
+                nargs = obj._nargs #@
+        """
+        )
+        with self.assertAddsMessages(
+            Message("protected-access", node=node.value, args="_nargs")
+        ):
+            self.checker.visit_attribute(node.value)
diff --git a/tests/unittest_checker_exceptions.py b/tests/unittest_checker_exceptions.py
new file mode 100644
index 000000000..e1596afa2
--- /dev/null
+++ b/tests/unittest_checker_exceptions.py
@@ -0,0 +1,49 @@
+# Copyright (c) 2015-2018 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Rene Zhang <rz99@cornell.edu>
+# Copyright (c) 2015 Steven Myint <hg@stevenmyint.com>
+# Copyright (c) 2015 Pavel Roskin <proski@gnu.org>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Brian Shaginaw <brian.shaginaw@warbyparker.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Tests for pylint.checkers.exceptions."""
+import astroid
+
+from pylint.checkers import exceptions
+from pylint.testutils import CheckerTestCase, Message
+
+
+class TestExceptionsChecker(CheckerTestCase):
+    """Tests for pylint.checkers.exceptions."""
+
+    CHECKER_CLASS = exceptions.ExceptionsChecker
+
+    # These tests aren't in the functional test suite,
+    # since they will be converted with 2to3 for Python 3
+    # and `raise (Error, ...)` will be converted to
+    # `raise Error(...)`, so it beats the purpose of the test.
+
+    def test_raising_bad_type_python3(self):
+        node = astroid.extract_node("raise (ZeroDivisionError, None)  #@")
+        message = Message("raising-bad-type", node=node, args="tuple")
+        with self.assertAddsMessages(message):
+            self.checker.visit_raise(node)
+
+    def test_bad_exception_context_function(self):
+        node = astroid.extract_node(
+            """
+        def function():
+            pass
+
+        try:
+            pass
+        except function as exc:
+            raise Exception from exc  #@
+        """
+        )
+        message = Message("bad-exception-context", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_raise(node)
diff --git a/tests/unittest_checker_format.py b/tests/unittest_checker_format.py
new file mode 100644
index 000000000..c47b4e54b
--- /dev/null
+++ b/tests/unittest_checker_format.py
@@ -0,0 +1,522 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2009-2011, 2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
+# Copyright (c) 2013-2014 Google, Inc.
+# Copyright (c) 2014-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 buck <buck.2019@gmail.com>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Harut <yes@harutune.name>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Petr Pulc <petrpulc@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2017 Krzysztof Czapla <k.czapla68@gmail.com>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2017 James M. Allen <james.m.allen@gmail.com>
+# Copyright (c) 2017 vinnyrose <vinnyrose@users.noreply.github.com>
+# Copyright (c) 2018 Bryce Guinta <bryce.guinta@protonmail.com>
+# Copyright (c) 2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2018 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Check format checker helper functions"""
+
+from __future__ import unicode_literals
+
+import os
+import tempfile
+import tokenize
+
+import astroid
+
+from pylint import lint, reporters
+from pylint.checkers.format import *
+from pylint.testutils import CheckerTestCase, Message, _tokenize_str, set_config
+
+
+class TestMultiStatementLine(CheckerTestCase):
+    CHECKER_CLASS = FormatChecker
+
+    def testSingleLineIfStmts(self):
+        stmt = astroid.extract_node(
+            """
+        if True: pass  #@
+        """
+        )
+        self.checker.config.single_line_if_stmt = False
+        with self.assertAddsMessages(Message("multiple-statements", node=stmt.body[0])):
+            self.visitFirst(stmt)
+        self.checker.config.single_line_if_stmt = True
+        with self.assertNoMessages():
+            self.visitFirst(stmt)
+        stmt = astroid.extract_node(
+            """
+        if True: pass  #@
+        else:
+            pass
+        """
+        )
+        with self.assertAddsMessages(Message("multiple-statements", node=stmt.body[0])):
+            self.visitFirst(stmt)
+
+    def testSingleLineClassStmts(self):
+        stmt = astroid.extract_node(
+            """
+        class MyError(Exception): pass  #@
+        """
+        )
+        self.checker.config.single_line_class_stmt = False
+        with self.assertAddsMessages(Message("multiple-statements", node=stmt.body[0])):
+            self.visitFirst(stmt)
+        self.checker.config.single_line_class_stmt = True
+        with self.assertNoMessages():
+            self.visitFirst(stmt)
+
+        stmt = astroid.extract_node(
+            """
+        class MyError(Exception): a='a'  #@
+        """
+        )
+        self.checker.config.single_line_class_stmt = False
+        with self.assertAddsMessages(Message("multiple-statements", node=stmt.body[0])):
+            self.visitFirst(stmt)
+        self.checker.config.single_line_class_stmt = True
+        with self.assertNoMessages():
+            self.visitFirst(stmt)
+
+        stmt = astroid.extract_node(
+            """
+        class MyError(Exception): a='a'; b='b'  #@
+        """
+        )
+        self.checker.config.single_line_class_stmt = False
+        with self.assertAddsMessages(Message("multiple-statements", node=stmt.body[0])):
+            self.visitFirst(stmt)
+        self.checker.config.single_line_class_stmt = True
+        with self.assertAddsMessages(Message("multiple-statements", node=stmt.body[0])):
+            self.visitFirst(stmt)
+
+    def testTryExceptFinallyNoMultipleStatement(self):
+        tree = astroid.extract_node(
+            """
+        try:  #@
+            pass
+        except:
+            pass
+        finally:
+            pass"""
+        )
+        with self.assertNoMessages():
+            self.visitFirst(tree)
+
+    def visitFirst(self, tree):
+        self.checker.process_tokens([])
+        self.checker.visit_default(tree.body[0])
+
+
+class TestSuperfluousParentheses(CheckerTestCase):
+    CHECKER_CLASS = FormatChecker
+
+    def testCheckKeywordParensHandlesValidCases(self):
+        self.checker._keywords_with_parens = set()
+        cases = [
+            "if foo:",
+            "if foo():",
+            "if (x and y) or z:",
+            "assert foo()",
+            "assert ()",
+            "if (1, 2) in (3, 4):",
+            "if (a or b) in c:",
+            "return (x for x in x)",
+            "if (x for x in x):",
+            "for x in (x for x in x):",
+            "not (foo or bar)",
+            "not (foo or bar) and baz",
+        ]
+        with self.assertNoMessages():
+            for code in cases:
+                self.checker._check_keyword_parentheses(_tokenize_str(code), 0)
+
+    def testCheckKeywordParensHandlesUnnecessaryParens(self):
+        self.checker._keywords_with_parens = set()
+        cases = [
+            (Message("superfluous-parens", line=1, args="if"), "if (foo):", 0),
+            (Message("superfluous-parens", line=1, args="if"), "if ((foo, bar)):", 0),
+            (Message("superfluous-parens", line=1, args="if"), "if (foo(bar)):", 0),
+            (
+                Message("superfluous-parens", line=1, args="return"),
+                "return ((x for x in x))",
+                0,
+            ),
+            (Message("superfluous-parens", line=1, args="not"), "not (foo)", 0),
+            (Message("superfluous-parens", line=1, args="not"), "if not (foo):", 1),
+            (Message("superfluous-parens", line=1, args="if"), "if (not (foo)):", 0),
+            (Message("superfluous-parens", line=1, args="not"), "if (not (foo)):", 2),
+            (
+                Message("superfluous-parens", line=1, args="for"),
+                "for (x) in (1, 2, 3):",
+                0,
+            ),
+            (
+                Message("superfluous-parens", line=1, args="if"),
+                "if (1) in (1, 2, 3):",
+                0,
+            ),
+        ]
+        for msg, code, offset in cases:
+            with self.assertAddsMessages(msg):
+                self.checker._check_keyword_parentheses(_tokenize_str(code), offset)
+
+    def testCheckIfArgsAreNotUnicode(self):
+        self.checker._keywords_with_parens = set()
+        cases = [("if (foo):", 0), ("assert (1 == 1)", 0)]
+
+        for code, offset in cases:
+            self.checker._check_keyword_parentheses(_tokenize_str(code), offset)
+            got = self.linter.release_messages()
+            assert isinstance(got[-1].args, str)
+
+    def testFuturePrintStatementWithoutParensWarning(self):
+        code = """from __future__ import print_function
+print('Hello world!')
+"""
+        tree = astroid.parse(code)
+        with self.assertNoMessages():
+            self.checker.process_module(tree)
+            self.checker.process_tokens(_tokenize_str(code))
+
+    def testKeywordParensFalsePositive(self):
+        self.checker._keywords_with_parens = set()
+        code = "if 'bar' in (DICT or {}):"
+        with self.assertNoMessages():
+            self.checker._check_keyword_parentheses(_tokenize_str(code), start=2)
+
+
+class TestCheckSpace(CheckerTestCase):
+    CHECKER_CLASS = FormatChecker
+
+    def testParenthesesGood(self):
+        good_cases = ["(a)\n", "(a * (b + c))\n", "(#\n    a)\n"]
+        with self.assertNoMessages():
+            for code in good_cases:
+                self.checker.process_tokens(_tokenize_str(code))
+
+    def testParenthesesBad(self):
+        with self.assertAddsMessages(
+            Message(
+                "bad-whitespace",
+                line=1,
+                args=("No", "allowed", "after", "bracket", "( a)\n^"),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("( a)\n"))
+
+        with self.assertAddsMessages(
+            Message(
+                "bad-whitespace",
+                line=1,
+                args=("No", "allowed", "before", "bracket", "(a )\n   ^"),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("(a )\n"))
+
+        with self.assertAddsMessages(
+            Message(
+                "bad-whitespace",
+                line=1,
+                args=("No", "allowed", "before", "bracket", "foo (a)\n    ^"),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("foo (a)\n"))
+
+        with self.assertAddsMessages(
+            Message(
+                "bad-whitespace",
+                line=1,
+                args=("No", "allowed", "before", "bracket", "{1: 2} [1]\n       ^"),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("{1: 2} [1]\n"))
+
+    def testTrailingCommaGood(self):
+        with self.assertNoMessages():
+            self.checker.process_tokens(_tokenize_str("(a, )\n"))
+            self.checker.process_tokens(_tokenize_str("(a,)\n"))
+
+        self.checker.config.no_space_check = []
+        with self.assertNoMessages():
+            self.checker.process_tokens(_tokenize_str("(a,)\n"))
+
+    @set_config(no_space_check=[])
+    def testTrailingCommaBad(self):
+        with self.assertAddsMessages(
+            Message(
+                "bad-whitespace",
+                line=1,
+                args=("No", "allowed", "before", "bracket", "(a, )\n    ^"),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("(a, )\n"))
+
+    def testComma(self):
+        with self.assertAddsMessages(
+            Message(
+                "bad-whitespace",
+                line=1,
+                args=("No", "allowed", "before", "comma", "(a , b)\n   ^"),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("(a , b)\n"))
+
+    def testSpacesAllowedInsideSlices(self):
+        good_cases = ["[a:b]\n", "[a : b]\n", "[a : ]\n", "[:a]\n", "[:]\n", "[::]\n"]
+        with self.assertNoMessages():
+            for code in good_cases:
+                self.checker.process_tokens(_tokenize_str(code))
+
+    def testKeywordSpacingGood(self):
+        with self.assertNoMessages():
+            self.checker.process_tokens(_tokenize_str("foo(foo=bar)\n"))
+            self.checker.process_tokens(_tokenize_str("foo(foo: int = bar)\n"))
+            self.checker.process_tokens(
+                _tokenize_str("foo(foo: module.classname = bar)\n")
+            )
+            self.checker.process_tokens(
+                _tokenize_str("foo(foo: Dict[int, str] = bar)\n")
+            )
+            self.checker.process_tokens(_tokenize_str("foo(foo: 'int' = bar)\n"))
+            self.checker.process_tokens(
+                _tokenize_str("foo(foo: Dict[int, 'str'] = bar)\n")
+            )
+            self.checker.process_tokens(_tokenize_str("lambda x=1: x\n"))
+
+    def testKeywordSpacingBad(self):
+        with self.assertAddsMessages(
+            Message(
+                "bad-whitespace",
+                line=1,
+                args=(
+                    "No",
+                    "allowed",
+                    "before",
+                    "keyword argument assignment",
+                    "(foo =bar)\n     ^",
+                ),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("(foo =bar)\n"))
+
+        with self.assertAddsMessages(
+            Message(
+                "bad-whitespace",
+                line=1,
+                args=(
+                    "No",
+                    "allowed",
+                    "after",
+                    "keyword argument assignment",
+                    "(foo= bar)\n    ^",
+                ),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("(foo= bar)\n"))
+
+        with self.assertAddsMessages(
+            Message(
+                "bad-whitespace",
+                line=1,
+                args=(
+                    "No",
+                    "allowed",
+                    "around",
+                    "keyword argument assignment",
+                    "(foo = bar)\n     ^",
+                ),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("(foo = bar)\n"))
+
+        with self.assertAddsMessages(
+            Message(
+                "bad-whitespace",
+                line=1,
+                args=(
+                    "Exactly one",
+                    "required",
+                    "before",
+                    "keyword argument assignment",
+                    "(foo: int= bar)\n         ^",
+                ),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("(foo: int= bar)\n"))
+
+        with self.assertAddsMessages(
+            Message(
+                "bad-whitespace",
+                line=1,
+                args=(
+                    "Exactly one",
+                    "required",
+                    "after",
+                    "keyword argument assignment",
+                    "(foo: int =bar)\n          ^",
+                ),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("(foo: int =bar)\n"))
+
+        with self.assertAddsMessages(
+            Message(
+                "bad-whitespace",
+                line=1,
+                args=(
+                    "Exactly one",
+                    "required",
+                    "around",
+                    "keyword argument assignment",
+                    "(foo: int=bar)\n         ^",
+                ),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("(foo: int=bar)\n"))
+
+        with self.assertAddsMessages(
+            Message(
+                "bad-whitespace",
+                line=1,
+                args=(
+                    "Exactly one",
+                    "required",
+                    "around",
+                    "keyword argument assignment",
+                    "(foo: List[int]=bar)\n               ^",
+                ),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("(foo: List[int]=bar)\n"))
+        # Regression test for #1831
+        with self.assertNoMessages():
+            self.checker.process_tokens(
+                _tokenize_str("(arg: Tuple[\n    int, str] = None):\n")
+            )
+
+    def testOperatorSpacingGood(self):
+        good_cases = ["a = b\n" "a < b\n" "a\n< b\n"]
+        with self.assertNoMessages():
+            for code in good_cases:
+                self.checker.process_tokens(_tokenize_str(code))
+
+    def testOperatorSpacingBad(self):
+        with self.assertAddsMessages(
+            Message(
+                "bad-whitespace",
+                line=1,
+                args=("Exactly one", "required", "before", "comparison", "a< b\n ^"),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("a< b\n"))
+
+        with self.assertAddsMessages(
+            Message(
+                "bad-whitespace",
+                line=1,
+                args=("Exactly one", "required", "after", "comparison", "a <b\n  ^"),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("a <b\n"))
+
+        with self.assertAddsMessages(
+            Message(
+                "bad-whitespace",
+                line=1,
+                args=("Exactly one", "required", "around", "comparison", "a<b\n ^"),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("a<b\n"))
+
+        with self.assertAddsMessages(
+            Message(
+                "bad-whitespace",
+                line=1,
+                args=("Exactly one", "required", "around", "comparison", "a<  b\n ^"),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("a<  b\n"))
+
+    def testValidTypingAnnotationEllipses(self):
+        """Make sure ellipses in function typing annotation
+        doesn't cause a false positive bad-whitespace message"""
+        with self.assertNoMessages():
+            self.checker.process_tokens(
+                _tokenize_str("def foo(t: Tuple[str, ...] = None):\n")
+            )
+
+    def testEmptyLines(self):
+        self.checker.config.no_space_check = []
+        with self.assertAddsMessages(Message("trailing-whitespace", line=2)):
+            self.checker.process_tokens(_tokenize_str("a = 1\n \nb = 2\n"))
+
+        with self.assertAddsMessages(Message("trailing-whitespace", line=2)):
+            self.checker.process_tokens(_tokenize_str("a = 1\n\t\nb = 2\n"))
+
+        with self.assertAddsMessages(Message("trailing-whitespace", line=2)):
+            self.checker.process_tokens(_tokenize_str("a = 1\n\v\nb = 2\n"))
+
+        with self.assertNoMessages():
+            self.checker.process_tokens(_tokenize_str("a = 1\n\f\nb = 2\n"))
+
+        self.checker.config.no_space_check = ["empty-line"]
+        with self.assertNoMessages():
+            self.checker.process_tokens(_tokenize_str("a = 1\n \nb = 2\n"))
+
+        with self.assertNoMessages():
+            self.checker.process_tokens(_tokenize_str("a = 1\n\t\nb = 2\n"))
+
+        with self.assertNoMessages():
+            self.checker.process_tokens(_tokenize_str("a = 1\n\v\nb = 2\n"))
+
+    def test_encoding_token(self):
+        """Make sure the encoding token doesn't change the checker's behavior
+
+        _tokenize_str doesn't produce an encoding token, but
+        reading a file does
+        """
+        with self.assertNoMessages():
+            encoding_token = tokenize.TokenInfo(
+                tokenize.ENCODING, "utf-8", (0, 0), (0, 0), ""
+            )
+            tokens = [encoding_token] + _tokenize_str(
+                "if (\n        None):\n    pass\n"
+            )
+            self.checker.process_tokens(tokens)
+
+
+def test_disable_global_option_end_of_line():
+    """
+    Test for issue with disabling tokenizer messages
+    that extend beyond the scope of the ast tokens
+    """
+    file_ = tempfile.NamedTemporaryFile("w", delete=False)
+    with file_:
+        file_.write(
+            """
+mylist = [
+    None
+        ]
+    """
+        )
+    try:
+        linter = lint.PyLinter()
+        checker = FormatChecker(linter)
+        linter.register_checker(checker)
+        args = linter.load_command_line_configuration(
+            [file_.name, "-d", "bad-continuation"]
+        )
+        myreporter = reporters.CollectingReporter()
+        linter.set_reporter(myreporter)
+        linter.check(args)
+        assert not myreporter.messages
+    finally:
+        os.remove(file_.name)
diff --git a/tests/unittest_checker_imports.py b/tests/unittest_checker_imports.py
new file mode 100644
index 000000000..898be4ef5
--- /dev/null
+++ b/tests/unittest_checker_imports.py
@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2015-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Dmitry Pribysh <dmand@yandex.ru>
+# Copyright (c) 2015 Cezar <celnazli@bitdefender.com>
+# Copyright (c) 2015 James Morgensen <james.morgensen@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Marianna Polatoglou <mpolatoglou@bloomberg.net>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@upcloud.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Unit tests for the imports checker."""
+import os
+
+import astroid
+
+from pylint.checkers import imports
+from pylint.interfaces import UNDEFINED
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+REGR_DATA = os.path.join(os.path.dirname(__file__), "regrtest_data", "")
+
+
+class TestImportsChecker(CheckerTestCase):
+
+    CHECKER_CLASS = imports.ImportsChecker
+
+    @set_config(
+        ignored_modules=("external_module", "fake_module.submodule", "foo", "bar")
+    )
+    def test_import_error_skipped(self):
+        """Make sure that imports do not emit an 'import-error' when the
+        module is configured to be ignored."""
+
+        node = astroid.extract_node(
+            """
+        from external_module import anything
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_importfrom(node)
+
+        node = astroid.extract_node(
+            """
+        from external_module.another_module import anything
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_importfrom(node)
+
+        node = astroid.extract_node(
+            """
+        import external_module
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_import(node)
+
+        node = astroid.extract_node(
+            """
+        from fake_module.submodule import anything
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_importfrom(node)
+
+        node = astroid.extract_node(
+            """
+        from fake_module.submodule.deeper import anything
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_importfrom(node)
+
+        node = astroid.extract_node(
+            """
+        import foo, bar
+        """
+        )
+        msg = Message("multiple-imports", node=node, args="foo, bar")
+        with self.assertAddsMessages(msg):
+            self.checker.visit_import(node)
+
+        node = astroid.extract_node(
+            """
+        import foo
+        import bar
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_import(node)
+
+    def test_reimported_same_line(self):
+        """
+        Test that duplicate imports on single line raise 'reimported'.
+        """
+        node = astroid.extract_node("from time import sleep, sleep, time")
+        msg = Message(msg_id="reimported", node=node, args=("sleep", 1))
+        with self.assertAddsMessages(msg):
+            self.checker.visit_importfrom(node)
+
+    def test_relative_beyond_top_level(self):
+        module = astroid.MANAGER.ast_from_module_name("beyond_top", REGR_DATA)
+        import_from = module.body[0]
+
+        msg = Message(msg_id="relative-beyond-top-level", node=import_from)
+        with self.assertAddsMessages(msg):
+            self.checker.visit_importfrom(import_from)
+        with self.assertNoMessages():
+            self.checker.visit_importfrom(module.body[1])
+        with self.assertNoMessages():
+            self.checker.visit_importfrom(module.body[2].body[0])
+
+    def test_wildcard_import_init(self):
+        module = astroid.MANAGER.ast_from_module_name("init_wildcard", REGR_DATA)
+        import_from = module.body[0]
+
+        with self.assertNoMessages():
+            self.checker.visit_importfrom(import_from)
+
+    def test_wildcard_import_non_init(self):
+        module = astroid.MANAGER.ast_from_module_name("wildcard", REGR_DATA)
+        import_from = module.body[0]
+
+        msg = Message(
+            msg_id="wildcard-import",
+            node=import_from,
+            args="empty",
+            confidence=UNDEFINED,
+        )
+        with self.assertAddsMessages(msg):
+            self.checker.visit_importfrom(import_from)
diff --git a/tests/unittest_checker_logging.py b/tests/unittest_checker_logging.py
new file mode 100644
index 000000000..8fb4cae93
--- /dev/null
+++ b/tests/unittest_checker_logging.py
@@ -0,0 +1,125 @@
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2015-2018 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Unittest for the logging checker."""
+import astroid
+
+from pylint.checkers import logging
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+
+class TestLoggingModuleDetection(CheckerTestCase):
+    CHECKER_CLASS = logging.LoggingChecker
+
+    def test_detects_standard_logging_module(self):
+        stmts = astroid.extract_node(
+            """
+        import logging #@
+        logging.warn('%s' % '%s')  #@
+        """
+        )
+        self.checker.visit_module(None)
+        self.checker.visit_import(stmts[0])
+        with self.assertAddsMessages(Message("logging-not-lazy", node=stmts[1])):
+            self.checker.visit_call(stmts[1])
+
+    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 test_detects_renamed_standard_logging_module(self):
+        stmts = astroid.extract_node(
+            """
+        import logging as blogging #@
+        blogging.warn('%s' % '%s')  #@
+        """
+        )
+        self.checker.visit_module(None)
+        self.checker.visit_import(stmts[0])
+        with self.assertAddsMessages(Message("logging-not-lazy", node=stmts[1])):
+            self.checker.visit_call(stmts[1])
+
+    @set_config(logging_modules=["logging", "my.logging"])
+    def test_nonstandard_logging_module(self):
+        stmts = astroid.extract_node(
+            """
+        from my import logging as blogging #@
+        blogging.warn('%s' % '%s')  #@
+        """
+        )
+        self.checker.visit_module(None)
+        self.checker.visit_import(stmts[0])
+        with self.assertAddsMessages(Message("logging-not-lazy", node=stmts[1])):
+            self.checker.visit_call(stmts[1])
+
+    def _assert_brace_format_no_messages(self, stmt):
+        stmts = astroid.extract_node(
+            """
+        import logging #@
+        logging.error<placeholder> #@
+        """.replace(
+                "<placeholder>", stmt
+            )
+        )
+        self.checker.visit_module(None)
+        self.checker.visit_import(stmts[0])
+        with self.assertNoMessages():
+            self.checker.visit_call(stmts[1])
+
+    def _assert_brace_format_message(self, msg, stmt):
+        stmts = astroid.extract_node(
+            """
+        import logging #@
+        logging.error<placeholder> #@
+        """.replace(
+                "<placeholder>", stmt
+            )
+        )
+        self.checker.visit_module(None)
+        self.checker.visit_import(stmts[0])
+        with self.assertAddsMessages(Message(msg, node=stmts[1])):
+            self.checker.visit_call(stmts[1])
+
+    def _assert_brace_format_too_few_args(self, stmt):
+        self._assert_brace_format_message("logging-too-few-args", stmt)
+
+    def _assert_brace_format_too_many_args(self, stmt):
+        self._assert_brace_format_message("logging-too-many-args", stmt)
+
+    @set_config(logging_format_style="new")
+    def test_brace_format_style_matching_arguments(self):
+        self._assert_brace_format_no_messages("('constant string')")
+        self._assert_brace_format_no_messages("('{}')")
+        self._assert_brace_format_no_messages("('{}', 1)")
+        self._assert_brace_format_no_messages("('{0}', 1)")
+        self._assert_brace_format_no_messages("('{named}', {'named': 1})")
+        self._assert_brace_format_no_messages("('{} {named}', 1, {'named': 1})")
+        self._assert_brace_format_no_messages("('{0} {named}', 1, {'named': 1})")
+
+    @set_config(logging_format_style="new")
+    def test_brace_format_style_too_few_args(self):
+        self._assert_brace_format_too_few_args("('{}, {}', 1)")
+        self._assert_brace_format_too_few_args("('{0}, {1}', 1)")
+        self._assert_brace_format_too_few_args("('{named1}, {named2}', {'named1': 1})")
+        self._assert_brace_format_too_few_args("('{0}, {named}', 1)")
+        self._assert_brace_format_too_few_args("('{}, {named}', {'named': 1})")
+        self._assert_brace_format_too_few_args("('{0}, {named}', {'named': 1})")
+
+    @set_config(logging_format_style="new")
+    def test_brace_format_style_not_enough_arguments(self):
+        self._assert_brace_format_too_many_args("('constant string', 1, 2)")
+        self._assert_brace_format_too_many_args("('{}', 1, 2)")
+        self._assert_brace_format_too_many_args("('{0}', 1, 2)")
+        self._assert_brace_format_too_many_args("('{}, {named}', 1, 2, {'named': 1})")
+        self._assert_brace_format_too_many_args("('{0}, {named}', 1, 2, {'named': 1})")
diff --git a/tests/unittest_checker_misc.py b/tests/unittest_checker_misc.py
new file mode 100644
index 000000000..b72b7acaa
--- /dev/null
+++ b/tests/unittest_checker_misc.py
@@ -0,0 +1,103 @@
+# Copyright (c) 2013-2014, 2016-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2013-2014 Google, Inc.
+# Copyright (c) 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 glegoux <gilles.legoux@gmail.com>
+# Copyright (c) 2018 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Tests for the misc checker."""
+
+from pylint.checkers import misc
+from pylint.testutils import CheckerTestCase, Message, _tokenize_str, set_config
+
+
+class TestFixme(CheckerTestCase):
+    CHECKER_CLASS = misc.EncodingChecker
+
+    def test_fixme_with_message(self):
+        code = """a = 1
+                # FIXME message
+                """
+        with self.assertAddsMessages(
+            Message(msg_id="fixme", line=2, args="FIXME message")
+        ):
+            self.checker.process_tokens(_tokenize_str(code))
+
+    def test_todo_without_message(self):
+        code = """a = 1
+                # TODO
+                """
+        with self.assertAddsMessages(Message(msg_id="fixme", line=2, args="TODO")):
+            self.checker.process_tokens(_tokenize_str(code))
+
+    def test_xxx_without_space(self):
+        code = """a = 1
+                #XXX
+                """
+        with self.assertAddsMessages(Message(msg_id="fixme", line=2, args="XXX")):
+            self.checker.process_tokens(_tokenize_str(code))
+
+    def test_xxx_middle(self):
+        code = """a = 1
+                # midle XXX
+                """
+        with self.assertNoMessages():
+            self.checker.process_tokens(_tokenize_str(code))
+
+    def test_without_space_fixme(self):
+        code = """a = 1
+                #FIXME
+                """
+        with self.assertAddsMessages(Message(msg_id="fixme", line=2, args="FIXME")):
+            self.checker.process_tokens(_tokenize_str(code))
+
+    @set_config(notes=[])
+    def test_absent_codetag(self):
+        code = """a = 1
+                # FIXME	                # FIXME
+                # TODO	                # TODO
+                # XXX	                # XXX
+                """
+        with self.assertNoMessages():
+            self.checker.process_tokens(_tokenize_str(code))
+
+    @set_config(notes=["CODETAG"])
+    def test_other_present_codetag(self):
+        code = """a = 1
+                # CODETAG
+                # FIXME
+                """
+        with self.assertAddsMessages(Message(msg_id="fixme", line=2, args="CODETAG")):
+            self.checker.process_tokens(_tokenize_str(code))
+
+    def test_issue_2321_should_not_trigger(self):
+        code = 'print("# TODO this should not trigger a fixme")'
+        with self.assertNoMessages():
+            self.checker.process_tokens(_tokenize_str(code))
+
+    def test_issue_2321_should_trigger(self):
+        code = "# TODO this should not trigger a fixme"
+        with self.assertAddsMessages(
+            Message(msg_id="fixme", line=1, args="TODO this should not trigger a fixme")
+        ):
+            self.checker.process_tokens(_tokenize_str(code))
+
+    def test_dont_trigger_on_todoist(self):
+        code = """
+        # Todoist API: What is this task about?
+        # Todoist API: Look up a task's due date
+        # Todoist API: Look up a Project/Label/Task ID
+        # Todoist API: Fetch all labels
+        # Todoist API: "Name" value
+        # Todoist API: Get a task's priority
+        # Todoist API: Look up the Project ID a Task belongs to
+        # Todoist API: Fetch all Projects
+        # Todoist API: Fetch all Tasks
+        """
+        with self.assertNoMessages():
+            self.checker.process_tokens(_tokenize_str(code))
diff --git a/tests/unittest_checker_python3.py b/tests/unittest_checker_python3.py
new file mode 100644
index 000000000..2fa8fca29
--- /dev/null
+++ b/tests/unittest_checker_python3.py
@@ -0,0 +1,1270 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014-2018 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014-2015 Brett Cannon <brett@python.org>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2015 Cosmin Poieana <cmin@ropython.org>
+# Copyright (c) 2015 Viorel Stirbu <viorels@gmail.com>
+# Copyright (c) 2016-2017 Roy Williams <roy.williams.iii@gmail.com>
+# Copyright (c) 2016 Roy Williams <rwilliams@lyft.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2017 Daniel Miller <millerdev@gmail.com>
+# Copyright (c) 2018 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@upcloud.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Tests for the python3 checkers."""
+from __future__ import absolute_import
+
+import sys
+import textwrap
+
+import astroid
+import pytest
+
+from pylint import testutils
+from pylint.checkers import python3 as checker
+from pylint.interfaces import INFERENCE, INFERENCE_FAILURE
+
+# Decorator for any tests that will fail under Python 3
+python2_only = pytest.mark.skipif(sys.version_info[0] > 2, reason="Python 2 only")
+
+# TODO(cpopa): Port these to the functional test framework instead.
+
+
+class TestPython3Checker(testutils.CheckerTestCase):
+
+    CHECKER_CLASS = checker.Python3Checker
+
+    def check_bad_builtin(self, builtin_name):
+        node = astroid.extract_node(builtin_name + "  #@")
+        message = builtin_name.lower() + "-builtin"
+        with self.assertAddsMessages(testutils.Message(message, node=node)):
+            self.checker.visit_name(node)
+
+    @python2_only
+    def test_bad_builtins(self):
+        builtins = [
+            "apply",
+            "buffer",
+            "cmp",
+            "coerce",
+            "execfile",
+            "file",
+            "input",
+            "intern",
+            "long",
+            "raw_input",
+            "round",
+            "reduce",
+            "StandardError",
+            "unichr",
+            "unicode",
+            "xrange",
+            "reload",
+        ]
+        for builtin in builtins:
+            self.check_bad_builtin(builtin)
+
+    def as_iterable_in_for_loop_test(self, fxn):
+        code = "for x in {}(): pass".format(fxn)
+        module = astroid.parse(code)
+        with self.assertNoMessages():
+            self.walk(module)
+
+    def as_used_by_iterable_in_for_loop_test(self, fxn):
+        checker = "{}-builtin-not-iterating".format(fxn)
+        node = astroid.extract_node(
+            """
+        for x in (whatever(
+            {}() #@
+        )):
+            pass
+        """.format(
+                fxn
+            )
+        )
+        message = testutils.Message(checker, node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_call(node)
+
+    def as_iterable_in_genexp_test(self, fxn):
+        code = "x = (x for x in {}())".format(fxn)
+        module = astroid.parse(code)
+        with self.assertNoMessages():
+            self.walk(module)
+
+    def as_iterable_in_starred_context(self, fxn):
+        code = "x = test(*{}())".format(fxn)
+        module = astroid.parse(code)
+        with self.assertNoMessages():
+            self.walk(module)
+
+    def as_iterable_in_listcomp_test(self, fxn):
+        code = "x = [x for x in {}(None, [1])]".format(fxn)
+        module = astroid.parse(code)
+        with self.assertNoMessages():
+            self.walk(module)
+
+    def as_iterable_in_yield_from(self, fxn):
+        code = "yield from {}()".format(fxn)
+        module = astroid.parse(code)
+        with self.assertNoMessages():
+            self.walk(module)
+
+    def as_used_in_variant_in_genexp_test(self, fxn):
+        checker = "{}-builtin-not-iterating".format(fxn)
+        node = astroid.extract_node(
+            """
+        list(
+            __({}(x))
+            for x in [1]
+        )
+        """.format(
+                fxn
+            )
+        )
+        message = testutils.Message(checker, node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_call(node)
+
+    def as_used_in_variant_in_listcomp_test(self, fxn):
+        checker = "{}-builtin-not-iterating".format(fxn)
+        node = astroid.extract_node(
+            """
+        [
+            __({}(None, x))
+        for x in [[1]]]
+        """.format(
+                fxn
+            )
+        )
+        message = testutils.Message(checker, node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_call(node)
+
+    def as_argument_to_callable_constructor_test(self, fxn, callable_fn):
+        module = astroid.parse("x = {}({}())".format(callable_fn, fxn))
+        with self.assertNoMessages():
+            self.walk(module)
+
+    def as_argument_to_materialized_filter(self, callable_fn):
+        module = astroid.parse("list(filter(None, {}()))".format(callable_fn))
+        with self.assertNoMessages():
+            self.walk(module)
+
+    def as_argument_to_random_fxn_test(self, fxn):
+        checker = "{}-builtin-not-iterating".format(fxn)
+        node = astroid.extract_node(
+            """
+        y(
+            {}() #@
+        )
+        """.format(
+                fxn
+            )
+        )
+        message = testutils.Message(checker, node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_call(node)
+
+    def as_argument_to_str_join_test(self, fxn):
+        code = "x = ''.join({}())".format(fxn)
+        module = astroid.parse(code)
+        with self.assertNoMessages():
+            self.walk(module)
+
+    def as_argument_to_itertools_functions(self, fxn):
+        code = """
+        from __future__ import absolute_import
+        import itertools
+        from itertools import product
+        for i,j in product({fxn}(), repeat=2):
+            pass
+        for i,j in itertools.product({fxn}(), repeat=2):
+            pass
+        """.format(
+            fxn=fxn
+        )
+        module = astroid.parse(code)
+        with self.assertNoMessages():
+            self.walk(module)
+
+    def as_iterable_in_unpacking(self, fxn):
+        node = astroid.extract_node(
+            """
+        a, b = __({}())
+        """.format(
+                fxn
+            )
+        )
+        with self.assertNoMessages():
+            self.checker.visit_call(node)
+
+    def as_assignment(self, fxn):
+        checker = "{}-builtin-not-iterating".format(fxn)
+        node = astroid.extract_node(
+            """
+        a = __({}())
+        """.format(
+                fxn
+            )
+        )
+        message = testutils.Message(checker, node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_call(node)
+
+    def iterating_context_tests(self, fxn):
+        """Helper for verifying a function isn't used as an iterator."""
+        self.as_iterable_in_for_loop_test(fxn)
+        self.as_used_by_iterable_in_for_loop_test(fxn)
+        self.as_iterable_in_genexp_test(fxn)
+        self.as_iterable_in_listcomp_test(fxn)
+        self.as_used_in_variant_in_genexp_test(fxn)
+        self.as_used_in_variant_in_listcomp_test(fxn)
+        self.as_argument_to_random_fxn_test(fxn)
+        self.as_argument_to_str_join_test(fxn)
+        self.as_iterable_in_unpacking(fxn)
+        self.as_assignment(fxn)
+        self.as_argument_to_materialized_filter(fxn)
+        self.as_iterable_in_yield_from(fxn)
+        self.as_iterable_in_starred_context(fxn)
+        self.as_argument_to_itertools_functions(fxn)
+
+        for func in (
+            "iter",
+            "list",
+            "tuple",
+            "sorted",
+            "set",
+            "sum",
+            "any",
+            "all",
+            "enumerate",
+            "dict",
+            "OrderedDict",
+        ):
+            self.as_argument_to_callable_constructor_test(fxn, func)
+
+    def test_dict_subclasses_methods_in_iterating_context(self):
+        iterating, not_iterating = astroid.extract_node(
+            """
+        from __future__ import absolute_import
+        from collections import defaultdict
+        d = defaultdict(list)
+        a, b = d.keys() #@
+        x = d.keys() #@
+        """
+        )
+
+        with self.assertNoMessages():
+            self.checker.visit_call(iterating.value)
+
+        message = testutils.Message("dict-keys-not-iterating", node=not_iterating.value)
+        with self.assertAddsMessages(message):
+            self.checker.visit_call(not_iterating.value)
+
+    def test_dict_methods_in_iterating_context(self):
+        iterating_code = [
+            "for x in {}(): pass",
+            "(x for x in {}())",
+            "[x for x in {}()]",
+            "iter({}())",
+            "a, b = {}()",
+            "max({}())",
+            "min({}())",
+            "3 in {}()",
+            "set().update({}())",
+            "[].extend({}())",
+            "{{}}.update({}())",
+            """
+            from __future__ import absolute_import
+            from itertools import chain
+            chain.from_iterable({}())
+            """,
+        ]
+        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_map_in_iterating_context(self):
+        self.iterating_context_tests("map")
+
+    def test_zip_in_iterating_context(self):
+        self.iterating_context_tests("zip")
+
+    def test_range_in_iterating_context(self):
+        self.iterating_context_tests("range")
+
+    def test_filter_in_iterating_context(self):
+        self.iterating_context_tests("filter")
+
+    def defined_method_test(self, method, warning):
+        """Helper for verifying that a certain method is not defined."""
+        node = astroid.extract_node(
+            """
+            class Foo(object):
+                def __{}__(self, other):  #@
+                    pass""".format(
+                method
+            )
+        )
+        message = testutils.Message(warning, node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_functiondef(node)
+
+    def test_delslice_method(self):
+        self.defined_method_test("delslice", "delslice-method")
+
+    def test_getslice_method(self):
+        self.defined_method_test("getslice", "getslice-method")
+
+    def test_setslice_method(self):
+        self.defined_method_test("setslice", "setslice-method")
+
+    def test_coerce_method(self):
+        self.defined_method_test("coerce", "coerce-method")
+
+    def test_oct_method(self):
+        self.defined_method_test("oct", "oct-method")
+
+    def test_hex_method(self):
+        self.defined_method_test("hex", "hex-method")
+
+    def test_nonzero_method(self):
+        self.defined_method_test("nonzero", "nonzero-method")
+
+    def test_cmp_method(self):
+        self.defined_method_test("cmp", "cmp-method")
+
+    def test_div_method(self):
+        self.defined_method_test("div", "div-method")
+
+    def test_idiv_method(self):
+        self.defined_method_test("idiv", "idiv-method")
+
+    def test_rdiv_method(self):
+        self.defined_method_test("rdiv", "rdiv-method")
+
+    def test_eq_and_hash_method(self):
+        """Helper for verifying that a certain method is not defined."""
+        node = astroid.extract_node(
+            """
+            class Foo(object):  #@
+                def __eq__(self, other):
+                    pass
+                def __hash__(self):
+                    pass"""
+        )
+        with self.assertNoMessages():
+            self.checker.visit_classdef(node)
+
+    def test_eq_and_hash_is_none(self):
+        """Helper for verifying that a certain method is not defined."""
+        node = astroid.extract_node(
+            """
+            class Foo(object):  #@
+                def __eq__(self, other):
+                    pass
+                __hash__ = None"""
+        )
+        with self.assertNoMessages():
+            self.checker.visit_classdef(node)
+
+    def test_eq_without_hash_method(self):
+        """Helper for verifying that a certain method is not defined."""
+        node = astroid.extract_node(
+            """
+            class Foo(object):  #@
+                def __eq__(self, other):
+                    pass"""
+        )
+        message = testutils.Message("eq-without-hash", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_classdef(node)
+
+    @python2_only
+    def test_print_statement(self):
+        node = astroid.extract_node('print "Hello, World!" #@')
+        message = testutils.Message("print-statement", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_print(node)
+
+    @python2_only
+    def test_backtick(self):
+        node = astroid.extract_node("`test`")
+        message = testutils.Message("backtick", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_repr(node)
+
+    def test_relative_import(self):
+        node = astroid.extract_node("import string  #@")
+        message = testutils.Message("no-absolute-import", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_import(node)
+        with self.assertNoMessages():
+            # message should only be added once
+            self.checker.visit_import(node)
+
+    def test_relative_from_import(self):
+        node = astroid.extract_node("from os import path  #@")
+        message = testutils.Message("no-absolute-import", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_importfrom(node)
+        with self.assertNoMessages():
+            # message should only be added once
+            self.checker.visit_importfrom(node)
+
+    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_import_star_module_level(self):
+        node = astroid.extract_node(
+            """
+        def test():
+            from lala import * #@
+        """
+        )
+        absolute = testutils.Message("no-absolute-import", node=node)
+        star = testutils.Message("import-star-module-level", node=node)
+        with self.assertAddsMessages(absolute, star):
+            self.checker.visit_importfrom(node)
+
+    def test_division(self):
+        nodes = astroid.extract_node(
+            """\
+            from _unknown import a, b
+            3 / 2  #@
+            3 / int(a) #@
+            int(a) / 3 #@
+            a / b #@
+            """
+        )
+        for node in nodes:
+            message = testutils.Message("old-division", node=node)
+            with self.assertAddsMessages(message):
+                self.checker.visit_binop(node)
+
+    def test_division_with_future_statement(self):
+        module = astroid.parse("from __future__ import division; 3 / 2")
+        with self.assertNoMessages():
+            self.walk(module)
+
+    def test_floor_division(self):
+        node = astroid.extract_node(" 3 // 2  #@")
+        with self.assertNoMessages():
+            self.checker.visit_binop(node)
+
+    def test_division_by_float(self):
+        nodes = astroid.extract_node(
+            """\
+            3.0 / 2  #@
+            3 / 2.0  #@
+            3 / float(a)  #@
+            float(a) / 3  #@
+            """
+        )
+        with self.assertNoMessages():
+            for node in nodes:
+                self.checker.visit_binop(node)
+
+    def test_division_different_types(self):
+        nodes = astroid.extract_node(
+            """
+        class A:
+            pass
+        A / 2 #@
+        A() / 2 #@
+        "a" / "a" #@
+        class Path:
+            def __div__(self, other):
+                return 42
+        Path() / 24 #@
+        """
+        )
+        for node in nodes:
+            with self.assertNoMessages():
+                self.checker.visit_binop(node)
+
+    def test_dict_iter_method(self):
+        for meth in ("keys", "values", "items"):
+            node = astroid.extract_node("x.iter%s()  #@" % meth)
+            message = testutils.Message("dict-iter-method", node=node)
+            with self.assertAddsMessages(message):
+                self.checker.visit_call(node)
+
+    def test_dict_iter_method_on_dict(self):
+        nodes = astroid.extract_node(
+            """
+        from collections import defaultdict
+        {}.iterkeys() #@
+        defaultdict(list).iterkeys() #@
+        class Someclass(dict):
+            pass
+        Someclass().iterkeys() #@
+
+        # Emits even though we are not sure they are dicts
+        x.iterkeys() #@
+
+        def func(x):
+            x.iterkeys() #@
+        """
+        )
+        for node in nodes:
+            message = testutils.Message("dict-iter-method", node=node)
+            with self.assertAddsMessages(message):
+                self.checker.visit_call(node)
+
+    def test_dict_not_iter_method(self):
+        arg_node = astroid.extract_node("x.iterkeys(x)  #@")
+        stararg_node = astroid.extract_node("x.iterkeys(*x)  #@")
+        kwarg_node = astroid.extract_node("x.iterkeys(y=x)  #@")
+        with self.assertNoMessages():
+            for node in (arg_node, stararg_node, kwarg_node):
+                self.checker.visit_call(node)
+
+    def test_dict_view_method(self):
+        for meth in ("keys", "values", "items"):
+            node = astroid.extract_node("x.view%s()  #@" % meth)
+            message = testutils.Message("dict-view-method", node=node)
+            with self.assertAddsMessages(message):
+                self.checker.visit_call(node)
+
+    def test_dict_viewkeys(self):
+        nodes = astroid.extract_node(
+            """
+        from collections import defaultdict
+        {}.viewkeys() #@
+        defaultdict(list).viewkeys() #@
+        class Someclass(dict):
+            pass
+        Someclass().viewkeys() #@
+
+        # Emits even though they might not be dicts
+        x.viewkeys() #@
+
+        def func(x):
+            x.viewkeys() #@
+        """
+        )
+        for node in nodes:
+            message = testutils.Message("dict-view-method", node=node)
+            with self.assertAddsMessages(message):
+                self.checker.visit_call(node)
+
+    def test_next_method(self):
+        node = astroid.extract_node("x.next()  #@")
+        message = testutils.Message("next-method-called", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_call(node)
+
+    def test_not_next_method(self):
+        arg_node = astroid.extract_node("x.next(x)  #@")
+        stararg_node = astroid.extract_node("x.next(*x)  #@")
+        kwarg_node = astroid.extract_node("x.next(y=x)  #@")
+        with self.assertNoMessages():
+            for node in (arg_node, stararg_node, kwarg_node):
+                self.checker.visit_call(node)
+
+    def test_metaclass_assignment(self):
+        node = astroid.extract_node(
+            """
+            class Foo(object):  #@
+                __metaclass__ = type"""
+        )
+        message = testutils.Message("metaclass-assignment", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_classdef(node)
+
+    def test_metaclass_global_assignment(self):
+        module = astroid.parse("__metaclass__ = type")
+        with self.assertNoMessages():
+            self.walk(module)
+
+    @python2_only
+    def test_parameter_unpacking(self):
+        node = astroid.extract_node("def func((a, b)):#@\n pass")
+        arg = node.args.args[0]
+        with self.assertAddsMessages(
+            testutils.Message("parameter-unpacking", node=arg)
+        ):
+            self.checker.visit_arguments(node.args)
+
+    @python2_only
+    def test_old_raise_syntax(self):
+        node = astroid.extract_node('raise Exception, "test"')
+        message = testutils.Message("old-raise-syntax", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_raise(node)
+
+    def test_xreadlines_attribute(self):
+        node = astroid.extract_node(
+            """
+        f.xreadlines #@
+        """
+        )
+        message = testutils.Message("xreadlines-attribute", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_attribute(node)
+
+    def test_exception_message_attribute(self):
+        node = astroid.extract_node(
+            """
+        try:
+            raise Exception("test")
+        except Exception as e:
+            e.message #@
+        """
+        )
+        message = testutils.Message("exception-message-attribute", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_attribute(node)
+
+    def test_normal_message_attribute(self):
+        node = astroid.extract_node(
+            """
+        e.message #@
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_attribute(node)
+
+    def test_invalid_codec(self):
+        node = astroid.extract_node('foobar.encode("hex") #@')
+        message = testutils.Message("invalid-str-codec", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_call(node)
+
+    def test_valid_codec(self):
+        node = astroid.extract_node('foobar.encode("ascii", "ignore")  #@')
+        with self.assertNoMessages():
+            self.checker.visit_call(node)
+
+    def test_visit_call_with_kwarg(self):
+        node = astroid.extract_node('foobar.raz(encoding="hex")  #@')
+        with self.assertNoMessages():
+            self.checker.visit_call(node)
+
+    def test_invalid_open_codec(self):
+        node = astroid.extract_node('open(foobar, encoding="hex") #@')
+        message = testutils.Message("invalid-str-codec", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_call(node)
+
+    def test_valid_open_codec(self):
+        node = astroid.extract_node('open(foobar, encoding="palmos") #@')
+        with self.assertNoMessages():
+            self.checker.visit_call(node)
+
+    @python2_only
+    def test_raising_string(self):
+        node = astroid.extract_node('raise "Test"')
+        message = testutils.Message("raising-string", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_raise(node)
+
+    @python2_only
+    def test_checker_disabled_by_default(self):
+        node = astroid.parse(
+            textwrap.dedent(
+                """
+        abc = 1l
+        raise Exception, "test"
+        raise "test"
+        `abc`
+        """
+            )
+        )
+        with self.assertNoMessages():
+            self.walk(node)
+
+    def test_using_cmp_argument(self):
+        nodes = astroid.extract_node(
+            """
+        [].sort(cmp=lambda x: x) #@
+        a = list(range(x))
+        a.sort(cmp=lambda x: x) #@
+
+        sorted([], cmp=lambda x: x) #@
+        """
+        )
+        for node in nodes:
+            message = testutils.Message("using-cmp-argument", node=node)
+            with self.assertAddsMessages(message):
+                self.checker.visit_call(node)
+
+    def test_sys_maxint(self):
+        node = astroid.extract_node(
+            """
+        import sys
+        sys.maxint #@
+        """
+        )
+        message = testutils.Message("sys-max-int", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_attribute(node)
+
+    def test_itertools_izip(self):
+        node = astroid.extract_node(
+            """
+        from itertools import izip #@
+        """
+        )
+        absolute_import_message = testutils.Message("no-absolute-import", node=node)
+        message = testutils.Message("deprecated-itertools-function", node=node)
+        with self.assertAddsMessages(absolute_import_message, message):
+            self.checker.visit_importfrom(node)
+
+    def test_deprecated_types_fields(self):
+        node = astroid.extract_node(
+            """
+        from types import StringType #@
+        """
+        )
+        absolute_import_message = testutils.Message("no-absolute-import", node=node)
+        message = testutils.Message("deprecated-types-field", node=node)
+        with self.assertAddsMessages(absolute_import_message, message):
+            self.checker.visit_importfrom(node)
+
+    def test_sys_maxint_imort_from(self):
+        node = astroid.extract_node(
+            """
+        from sys import maxint #@
+        """
+        )
+        absolute_import_message = testutils.Message("no-absolute-import", node=node)
+        message = testutils.Message("sys-max-int", node=node)
+        with self.assertAddsMessages(absolute_import_message, message):
+            self.checker.visit_importfrom(node)
+
+    def test_object_maxint(self):
+        node = astroid.extract_node(
+            """
+        sys = object()
+        sys.maxint #@
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_attribute(node)
+
+    def test_bad_import(self):
+        node = astroid.extract_node(
+            """
+        import urllib2, sys #@
+        """
+        )
+        absolute_import_message = testutils.Message("no-absolute-import", node=node)
+        message = testutils.Message("bad-python3-import", node=node)
+        with self.assertAddsMessages(absolute_import_message, message):
+            self.checker.visit_import(node)
+
+    def test_bad_import_turtle(self):
+        node = astroid.extract_node(
+            """
+        import turtle #@
+        turtle.Turtle()
+        """
+        )
+        absolute_import_message = testutils.Message("no-absolute-import", node=node)
+        with self.assertAddsMessages(absolute_import_message):
+            self.checker.visit_import(node)
+
+    def test_bad_import_dbm(self):
+        node = astroid.extract_node(
+            """
+        from dbm import open as open_ #@
+        open_("dummy.db")
+        """
+        )
+        absolute_import_message = testutils.Message("no-absolute-import", node=node)
+        with self.assertAddsMessages(absolute_import_message):
+            self.checker.visit_importfrom(node)
+
+    @python2_only
+    def test_bad_import_not_on_relative(self):
+        samples = ["from .commands import titi", "from . import commands"]
+        for code in samples:
+            node = astroid.extract_node(code)
+            absolute_import_message = testutils.Message("no-absolute-import", node=node)
+            with self.assertAddsMessages(absolute_import_message):
+                self.checker.visit_importfrom(node)
+            self.checker._future_absolute_import = False
+
+    def test_bad_import_conditional(self):
+        node = astroid.extract_node(
+            """
+        import six
+        if six.PY2:
+            import urllib2 #@
+        """
+        )
+        absolute_import_message = testutils.Message("no-absolute-import", node=node)
+        with self.assertAddsMessages(absolute_import_message):
+            self.checker.visit_import(node)
+
+    def test_bad_import_try_except_handler(self):
+        node = astroid.extract_node(
+            """
+        try:
+            from hashlib import sha
+        except:
+            import sha #@
+        """
+        )
+        absolute_import_message = testutils.Message("no-absolute-import", node=node)
+        with self.assertAddsMessages(absolute_import_message):
+            self.checker.visit_import(node)
+
+    def test_bad_import_try(self):
+        node = astroid.extract_node(
+            """
+        try:
+            import md5  #@
+        except:
+            from hashlib import md5
+        finally:
+            pass
+        """
+        )
+        absolute_import_message = testutils.Message("no-absolute-import", node=node)
+        with self.assertAddsMessages(absolute_import_message):
+            self.checker.visit_import(node)
+
+    def test_bad_import_try_finally(self):
+        node = astroid.extract_node(
+            """
+        try:
+            import Queue  #@
+        finally:
+            import queue
+        """
+        )
+        absolute_import_message = testutils.Message("no-absolute-import", node=node)
+        message = testutils.Message("bad-python3-import", node=node)
+        with self.assertAddsMessages(absolute_import_message, message):
+            self.checker.visit_import(node)
+
+    def test_bad_import_from(self):
+        node = astroid.extract_node(
+            """
+        from cStringIO import StringIO #@
+        """
+        )
+        absolute_import_message = testutils.Message("no-absolute-import", node=node)
+        message = testutils.Message("bad-python3-import", node=node)
+        with self.assertAddsMessages(absolute_import_message, message):
+            self.checker.visit_importfrom(node)
+
+    def test_bad_string_attribute(self):
+        node = astroid.extract_node(
+            """
+        import string
+        string.maketrans #@
+        """
+        )
+        message = testutils.Message("deprecated-string-function", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_attribute(node)
+
+    def test_bad_operator_attribute(self):
+        node = astroid.extract_node(
+            """
+        import operator
+        operator.div #@
+        """
+        )
+        message = testutils.Message("deprecated-operator-function", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_attribute(node)
+
+    def test_comprehension_escape(self):
+        assign, escaped_node = astroid.extract_node(
+            """
+        a = [i for i in range(10)] #@
+        i #@
+        """
+        )
+        good_module = astroid.parse(
+            """
+        {c for c in range(10)} #@
+        {j:j for j in range(10)} #@
+        [image_child] = [x for x in range(10)]
+        thumbnail = func(__(image_child))
+        """
+        )
+        message = testutils.Message("comprehension-escape", node=escaped_node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_listcomp(assign.value)
+
+        with self.assertNoMessages():
+            self.walk(good_module)
+
+    def test_comprehension_escape_newly_introduced(self):
+        node = astroid.extract_node(
+            """
+        [i for i in range(3)]
+        for i in range(3):
+            i
+        """
+        )
+        with self.assertNoMessages():
+            self.walk(node)
+
+    def test_exception_escape(self):
+        module = astroid.parse(
+            """
+        try: 1/0
+        except ValueError as exc:
+            pass
+        exc #@
+        try:
+           2/0
+        except (ValueError, TypeError) as exc:
+           exc = 2
+        exc #@
+        try:
+           2/0
+        except (ValueError, TypeError): #@
+           exc = 2
+        """
+        )
+        message = testutils.Message("exception-escape", node=module.body[1].value)
+        with self.assertAddsMessages(message):
+            self.checker.visit_excepthandler(module.body[0].handlers[0])
+        with self.assertNoMessages():
+            self.checker.visit_excepthandler(module.body[2].handlers[0])
+            self.checker.visit_excepthandler(module.body[4].handlers[0])
+
+    def test_bad_sys_attribute(self):
+        node = astroid.extract_node(
+            """
+        import sys
+        sys.exc_clear #@
+        """
+        )
+        message = testutils.Message("deprecated-sys-function", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_attribute(node)
+
+    def test_bad_urllib_attribute(self):
+        nodes = astroid.extract_node(
+            """
+        import urllib
+        urllib.addbase #@
+        urllib.splithost #@
+        urllib.urlretrieve #@
+        urllib.urlopen #@
+        urllib.urlencode #@
+        """
+        )
+        for node in nodes:
+            message = testutils.Message("deprecated-urllib-function", node=node)
+            with self.assertAddsMessages(message):
+                self.checker.visit_attribute(node)
+
+    def test_ok_string_attribute(self):
+        node = astroid.extract_node(
+            """
+        import string
+        string.ascii_letters #@
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_attribute(node)
+
+    def test_bad_string_call(self):
+        node = astroid.extract_node(
+            """
+        import string
+        string.upper("hello world") #@
+        """
+        )
+        message = testutils.Message("deprecated-string-function", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_call(node)
+
+    def test_ok_shadowed_call(self):
+        node = astroid.extract_node(
+            """
+        import six.moves.configparser
+        six.moves.configparser.ConfigParser() #@
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_call(node)
+
+    def test_ok_string_call(self):
+        node = astroid.extract_node(
+            """
+        import string
+        string.Foramtter() #@
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_call(node)
+
+    def test_bad_string_import_from(self):
+        node = astroid.extract_node(
+            """
+         from string import atoi #@
+         """
+        )
+        absolute_import_message = testutils.Message("no-absolute-import", node=node)
+        message = testutils.Message("deprecated-string-function", node=node)
+        with self.assertAddsMessages(absolute_import_message, message):
+            self.checker.visit_importfrom(node)
+
+    def test_ok_string_import_from(self):
+        node = astroid.extract_node(
+            """
+         from string import digits #@
+         """
+        )
+        absolute_import_message = testutils.Message("no-absolute-import", node=node)
+        with self.assertAddsMessages(absolute_import_message):
+            self.checker.visit_importfrom(node)
+
+    def test_bad_str_translate_call_string_literal(self):
+        node = astroid.extract_node(
+            """
+         foobar.translate(None, 'abc123') #@
+         """
+        )
+        message = testutils.Message(
+            "deprecated-str-translate-call", node=node, confidence=INFERENCE_FAILURE
+        )
+        with self.assertAddsMessages(message):
+            self.checker.visit_call(node)
+
+    def test_bad_str_translate_call_variable(self):
+        node = astroid.extract_node(
+            """
+         def raz(foobar):
+           foobar.translate(None, 'hello') #@
+         """
+        )
+        message = testutils.Message(
+            "deprecated-str-translate-call", node=node, confidence=INFERENCE_FAILURE
+        )
+        with self.assertAddsMessages(message):
+            self.checker.visit_call(node)
+
+    def test_bad_str_translate_call_infer_str(self):
+        node = astroid.extract_node(
+            """
+         foobar = "hello world"
+         foobar.translate(None, foobar) #@
+         """
+        )
+        message = testutils.Message(
+            "deprecated-str-translate-call", node=node, confidence=INFERENCE
+        )
+        with self.assertAddsMessages(message):
+            self.checker.visit_call(node)
+
+    def test_ok_str_translate_call_integer(self):
+        node = astroid.extract_node(
+            """
+         foobar.translate(None, 33) #@
+         """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_call(node)
+
+    def test_ok_str_translate_call_keyword(self):
+        node = astroid.extract_node(
+            """
+         foobar.translate(None, 'foobar', raz=33) #@
+         """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_call(node)
+
+    def test_ok_str_translate_call_not_str(self):
+        node = astroid.extract_node(
+            """
+         foobar = {}
+         foobar.translate(None, 'foobar') #@
+         """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_call(node)
+
+    def test_non_py2_conditional(self):
+        code = """
+        from __future__ import absolute_import
+        import sys
+        x = {}
+        if sys.maxsize:
+            x.iterkeys()  #@
+        """
+        node = astroid.extract_node(code)
+        module = node.parent.parent
+        message = testutils.Message("dict-iter-method", node=node)
+        with self.assertAddsMessages(message):
+            self.walk(module)
+
+    def test_six_conditional(self):
+        code = """
+        from __future__ import absolute_import
+        import six
+        x = {}
+        if six.PY2:
+            x.iterkeys()
+        """
+        module = astroid.parse(code)
+        with self.assertNoMessages():
+            self.walk(module)
+
+    def test_versioninfo_conditional(self):
+        code = """
+        from __future__ import absolute_import
+        import sys
+        x = {}
+        if sys.version_info[0] == 2:
+            x.iterkeys()
+        """
+        module = astroid.parse(code)
+        with self.assertNoMessages():
+            self.walk(module)
+
+    def test_versioninfo_tuple_conditional(self):
+        code = """
+        from __future__ import absolute_import
+        import sys
+        x = {}
+        if sys.version_info == (2, 7):
+            x.iterkeys()
+        """
+        module = astroid.parse(code)
+        with self.assertNoMessages():
+            self.walk(module)
+
+    def test_six_ifexp_conditional(self):
+        code = """
+        from __future__ import absolute_import
+        import six
+        import string
+        string.translate if six.PY2 else None
+        """
+        module = astroid.parse(code)
+        with self.assertNoMessages():
+            self.walk(module)
+
+    def test_next_defined(self):
+        node = astroid.extract_node(
+            """
+            class Foo(object):
+                def next(self):  #@
+                    pass"""
+        )
+        message = testutils.Message("next-method-defined", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_functiondef(node)
+
+    def test_next_defined_too_many_args(self):
+        node = astroid.extract_node(
+            """
+            class Foo(object):
+                def next(self, foo=None):  #@
+                    pass"""
+        )
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_next_defined_static_method_too_many_args(self):
+        node = astroid.extract_node(
+            """
+            class Foo(object):
+                @staticmethod
+                def next(self):  #@
+                    pass"""
+        )
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+
+    def test_next_defined_static_method(self):
+        node = astroid.extract_node(
+            """
+            class Foo(object):
+                @staticmethod
+                def next():  #@
+                    pass"""
+        )
+        message = testutils.Message("next-method-defined", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_functiondef(node)
+
+    def test_next_defined_class_method(self):
+        node = astroid.extract_node(
+            """
+            class Foo(object):
+                @classmethod
+                def next(cls):  #@
+                    pass"""
+        )
+        message = testutils.Message("next-method-defined", node=node)
+        with self.assertAddsMessages(message):
+            self.checker.visit_functiondef(node)
+
+
+@python2_only
+class TestPython3TokenChecker(testutils.CheckerTestCase):
+
+    CHECKER_CLASS = checker.Python3TokenChecker
+
+    def _test_token_message(self, code, symbolic_message):
+        tokens = testutils._tokenize_str(code)
+        message = testutils.Message(symbolic_message, line=1)
+        with self.assertAddsMessages(message):
+            self.checker.process_tokens(tokens)
+
+    def test_long_suffix(self):
+        for code in ("1l", "1L"):
+            self._test_token_message(code, "long-suffix")
+
+    def test_old_ne_operator(self):
+        self._test_token_message("1 <> 2", "old-ne-operator")
+
+    def test_old_octal_literal(self):
+        for octal in ("045", "055", "075", "077", "076543"):
+            self._test_token_message(octal, "old-octal-literal")
+
+        # Make sure we are catching only octals.
+        for non_octal in ("45", "00", "085", "08", "1"):
+            tokens = testutils._tokenize_str(non_octal)
+            with self.assertNoMessages():
+                self.checker.process_tokens(tokens)
+
+    def test_non_ascii_bytes_literal(self):
+        code = 'b"测试"'
+        self._test_token_message(code, "non-ascii-bytes-literal")
+        for code in ("测试", "测试", "abcdef", b"\x80"):
+            tokens = testutils._tokenize_str(code)
+            with self.assertNoMessages():
+                self.checker.process_tokens(tokens)
diff --git a/tests/unittest_checker_similar.py b/tests/unittest_checker_similar.py
new file mode 100644
index 000000000..7470e06c9
--- /dev/null
+++ b/tests/unittest_checker_similar.py
@@ -0,0 +1,198 @@
+# Copyright (c) 2010, 2012, 2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2012 Ry4an Brase <ry4an-hg@ry4an.org>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+import sys
+from contextlib import redirect_stdout
+from io import StringIO
+from os.path import abspath, dirname, join
+
+import pytest
+
+from pylint.checkers import similar
+
+SIMILAR1 = join(dirname(abspath(__file__)), "input", "similar1")
+SIMILAR2 = join(dirname(abspath(__file__)), "input", "similar2")
+MULTILINE = join(dirname(abspath(__file__)), "input", "multiline-import")
+HIDE_CODE_WITH_IMPORTS = join(
+    dirname(abspath(__file__)), "input", "hide_code_with_imports.py"
+)
+
+
+def test_ignore_comments():
+    output = StringIO()
+    with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+        similar.Run(["--ignore-comments", SIMILAR1, SIMILAR2])
+    assert ex.value.code == 0
+    assert (
+        output.getvalue().strip()
+        == (
+            """
+10 similar lines in 2 files
+==%s:0
+==%s:0
+   import one
+   from two import two
+   three
+   four
+   five
+   six
+   seven
+   eight
+   nine
+   ''' ten
+TOTAL lines=60 duplicates=10 percent=16.67
+"""
+            % (SIMILAR1, SIMILAR2)
+        ).strip()
+    )
+
+
+def test_ignore_docsrings():
+    output = StringIO()
+    with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+        similar.Run(["--ignore-docstrings", SIMILAR1, SIMILAR2])
+    assert ex.value.code == 0
+    assert (
+        output.getvalue().strip()
+        == (
+            """
+8 similar lines in 2 files
+==%s:6
+==%s:6
+   seven
+   eight
+   nine
+   ''' ten
+   ELEVEN
+   twelve '''
+   thirteen
+   fourteen
+
+5 similar lines in 2 files
+==%s:0
+==%s:0
+   import one
+   from two import two
+   three
+   four
+   five
+TOTAL lines=60 duplicates=13 percent=21.67
+"""
+            % ((SIMILAR1, SIMILAR2) * 2)
+        ).strip()
+    )
+
+
+def test_ignore_imports():
+    output = StringIO()
+    with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+        similar.Run(["--ignore-imports", SIMILAR1, SIMILAR2])
+    assert ex.value.code == 0
+    assert (
+        output.getvalue().strip()
+        == """
+TOTAL lines=60 duplicates=0 percent=0.00
+""".strip()
+    )
+
+
+def test_multiline_imports():
+    output = StringIO()
+    with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+        similar.Run([MULTILINE, MULTILINE])
+    assert ex.value.code == 0
+    assert (
+        output.getvalue().strip()
+        == (
+            """
+8 similar lines in 2 files
+==%s:0
+==%s:0
+   from foo import (
+     bar,
+     baz,
+     quux,
+     quuux,
+     quuuux,
+     quuuuux,
+   )
+TOTAL lines=16 duplicates=8 percent=50.00
+"""
+            % (MULTILINE, MULTILINE)
+        ).strip()
+    )
+
+
+def test_ignore_multiline_imports():
+    output = StringIO()
+    with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+        similar.Run(["--ignore-imports", MULTILINE, MULTILINE])
+    assert ex.value.code == 0
+    assert (
+        output.getvalue().strip()
+        == """
+TOTAL lines=16 duplicates=0 percent=0.00
+""".strip()
+    )
+
+
+def test_no_hide_code_with_imports():
+    output = StringIO()
+    with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+        similar.Run(["--ignore-imports"] + 2 * [HIDE_CODE_WITH_IMPORTS])
+    assert ex.value.code == 0
+    assert "TOTAL lines=32 duplicates=16 percent=50.00" in output.getvalue()
+
+
+def test_ignore_nothing():
+    output = StringIO()
+    with redirect_stdout(output), pytest.raises(SystemExit) as ex:
+        similar.Run([SIMILAR1, SIMILAR2])
+    assert ex.value.code == 0
+    assert (
+        output.getvalue().strip()
+        == (
+            """
+5 similar lines in 2 files
+==%s:0
+==%s:0
+   import one
+   from two import two
+   three
+   four
+   five
+TOTAL lines=60 duplicates=5 percent=8.33
+"""
+            % (SIMILAR1, SIMILAR2)
+        ).strip()
+    )
+
+
+def test_help():
+    output = StringIO()
+    with redirect_stdout(output):
+        try:
+            similar.Run(["--help"])
+        except SystemExit as ex:
+            assert ex.code == 0
+        else:
+            pytest.fail("not system exit")
+
+
+def test_no_args():
+    output = StringIO()
+    with redirect_stdout(output):
+        try:
+            similar.Run([])
+        except SystemExit as ex:
+            assert ex.code == 1
+        else:
+            pytest.fail("not system exit")
diff --git a/tests/unittest_checker_spelling.py b/tests/unittest_checker_spelling.py
new file mode 100644
index 000000000..c1777f74f
--- /dev/null
+++ b/tests/unittest_checker_spelling.py
@@ -0,0 +1,362 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Michal Nowikowski <godfryd@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2017 Pedro Algarvio <pedro@algarvio.me>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2018 Anthony Sottile <asottile@umich.edu>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Unittest for the spelling checker."""
+
+import astroid
+import pytest
+
+from pylint.checkers import spelling
+from pylint.testutils import CheckerTestCase, Message, _tokenize_str, set_config
+
+# try to create enchant dictionary
+try:
+    import enchant
+except ImportError:
+    enchant = None
+
+spell_dict = None
+if enchant is not None:
+    try:
+        enchant.Dict("en_US")
+        spell_dict = "en_US"
+    except enchant.DictNotFoundError:
+        pass
+
+
+class TestSpellingChecker(CheckerTestCase):
+    CHECKER_CLASS = spelling.SpellingChecker
+
+    skip_on_missing_package_or_dict = pytest.mark.skipif(
+        spell_dict is None,
+        reason="missing python-enchant package or missing spelling dictionaries",
+    )
+
+    def _get_msg_suggestions(self, word, count=4):
+        return "'{}'".format(
+            "' or '".join(self.checker.spelling_dict.suggest(word)[:count])
+        )
+
+    @skip_on_missing_package_or_dict
+    @set_config(spelling_dict=spell_dict)
+    def test_check_bad_coment(self):
+        with self.assertAddsMessages(
+            Message(
+                "wrong-spelling-in-comment",
+                line=1,
+                args=(
+                    "coment",
+                    "# bad coment",
+                    "      ^^^^^^",
+                    self._get_msg_suggestions("coment"),
+                ),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("# bad coment"))
+
+    @skip_on_missing_package_or_dict
+    @set_config(spelling_dict=spell_dict)
+    @set_config(max_spelling_suggestions=2)
+    def test_check_bad_coment_custom_suggestion_count(self):
+        with self.assertAddsMessages(
+            Message(
+                "wrong-spelling-in-comment",
+                line=1,
+                args=(
+                    "coment",
+                    "# bad coment",
+                    "      ^^^^^^",
+                    self._get_msg_suggestions("coment", count=2),
+                ),
+            )
+        ):
+            self.checker.process_tokens(_tokenize_str("# bad coment"))
+
+    @skip_on_missing_package_or_dict
+    @set_config(spelling_dict=spell_dict)
+    def test_check_bad_docstring(self):
+        stmt = astroid.extract_node('def fff():\n   """bad coment"""\n   pass')
+        with self.assertAddsMessages(
+            Message(
+                "wrong-spelling-in-docstring",
+                line=2,
+                args=(
+                    "coment",
+                    "bad coment",
+                    "    ^^^^^^",
+                    self._get_msg_suggestions("coment"),
+                ),
+            )
+        ):
+            self.checker.visit_functiondef(stmt)
+
+        stmt = astroid.extract_node('class Abc(object):\n   """bad coment"""\n   pass')
+        with self.assertAddsMessages(
+            Message(
+                "wrong-spelling-in-docstring",
+                line=2,
+                args=(
+                    "coment",
+                    "bad coment",
+                    "    ^^^^^^",
+                    self._get_msg_suggestions("coment"),
+                ),
+            )
+        ):
+            self.checker.visit_classdef(stmt)
+
+    @pytest.mark.skipif(True, reason="pyenchant's tokenizer strips these")
+    @skip_on_missing_package_or_dict
+    @set_config(spelling_dict=spell_dict)
+    def test_invalid_docstring_characters(self):
+        stmt = astroid.extract_node('def fff():\n   """test\\x00"""\n   pass')
+        with self.assertAddsMessages(
+            Message("invalid-characters-in-docstring", line=2, args=("test\x00",))
+        ):
+            self.checker.visit_functiondef(stmt)
+
+    @skip_on_missing_package_or_dict
+    @set_config(spelling_dict=spell_dict)
+    def test_skip_shebangs(self):
+        self.checker.process_tokens(_tokenize_str("#!/usr/bin/env python"))
+        assert self.linter.release_messages() == []
+
+    @skip_on_missing_package_or_dict
+    @set_config(spelling_dict=spell_dict)
+    def test_skip_python_coding_comments(self):
+        self.checker.process_tokens(_tokenize_str("# -*- coding: utf-8 -*-"))
+        assert self.linter.release_messages() == []
+        self.checker.process_tokens(_tokenize_str("# coding=utf-8"))
+        assert self.linter.release_messages() == []
+        self.checker.process_tokens(_tokenize_str("# vim: set fileencoding=utf-8 :"))
+        assert self.linter.release_messages() == []
+        # Now with a shebang first
+        self.checker.process_tokens(
+            _tokenize_str("#!/usr/bin/env python\n# -*- coding: utf-8 -*-")
+        )
+        assert self.linter.release_messages() == []
+        self.checker.process_tokens(
+            _tokenize_str("#!/usr/bin/env python\n# coding=utf-8")
+        )
+        assert self.linter.release_messages() == []
+        self.checker.process_tokens(
+            _tokenize_str("#!/usr/bin/env python\n# vim: set fileencoding=utf-8 :")
+        )
+        assert self.linter.release_messages() == []
+
+    @skip_on_missing_package_or_dict
+    @set_config(spelling_dict=spell_dict)
+    def test_skip_top_level_pylint_enable_disable_comments(self):
+        self.checker.process_tokens(
+            _tokenize_str("# Line 1\n Line 2\n# pylint: disable=ungrouped-imports")
+        )
+        assert self.linter.release_messages() == []
+
+    @skip_on_missing_package_or_dict
+    @set_config(spelling_dict=spell_dict)
+    def test_skip_words_with_numbers(self):
+        self.checker.process_tokens(_tokenize_str("\n# 0ne\n# Thr33\n# Sh3ll"))
+        assert self.linter.release_messages() == []
+
+    @skip_on_missing_package_or_dict
+    @set_config(spelling_dict=spell_dict)
+    def test_skip_wiki_words(self):
+        stmt = astroid.extract_node(
+            'class ComentAbc(object):\n   """ComentAbc with a bad coment"""\n   pass'
+        )
+        with self.assertAddsMessages(
+            Message(
+                "wrong-spelling-in-docstring",
+                line=2,
+                args=(
+                    "coment",
+                    "ComentAbc with a bad coment",
+                    "                     ^^^^^^",
+                    self._get_msg_suggestions("coment"),
+                ),
+            )
+        ):
+            self.checker.visit_classdef(stmt)
+
+    @skip_on_missing_package_or_dict
+    @set_config(spelling_dict=spell_dict)
+    def test_skip_camel_cased_words(self):
+        stmt = astroid.extract_node(
+            'class ComentAbc(object):\n   """comentAbc with a bad coment"""\n   pass'
+        )
+        with self.assertAddsMessages(
+            Message(
+                "wrong-spelling-in-docstring",
+                line=2,
+                args=(
+                    "coment",
+                    "comentAbc with a bad coment",
+                    "                     ^^^^^^",
+                    self._get_msg_suggestions("coment"),
+                ),
+            )
+        ):
+            self.checker.visit_classdef(stmt)
+
+        # With just a single upper case letter in the end
+        stmt = astroid.extract_node(
+            'class ComentAbc(object):\n   """argumentN with a bad coment"""\n   pass'
+        )
+        with self.assertAddsMessages(
+            Message(
+                "wrong-spelling-in-docstring",
+                line=2,
+                args=(
+                    "coment",
+                    "argumentN with a bad coment",
+                    "                     ^^^^^^",
+                    self._get_msg_suggestions("coment"),
+                ),
+            )
+        ):
+            self.checker.visit_classdef(stmt)
+
+        for ccn in (
+            "xmlHttpRequest",
+            "newCustomer",
+            "newCustomerId",
+            "innerStopwatch",
+            "supportsIpv6OnIos",
+            "affine3D",
+        ):
+            stmt = astroid.extract_node(
+                'class TestClass(object):\n   """{} comment"""\n   pass'.format(ccn)
+            )
+            self.checker.visit_classdef(stmt)
+            assert self.linter.release_messages() == []
+
+    @skip_on_missing_package_or_dict
+    @set_config(spelling_dict=spell_dict)
+    def test_skip_words_with_underscores(self):
+        stmt = astroid.extract_node(
+            'def fff(param_name):\n   """test param_name"""\n   pass'
+        )
+        self.checker.visit_functiondef(stmt)
+        assert self.linter.release_messages() == []
+
+    @skip_on_missing_package_or_dict
+    @set_config(spelling_dict=spell_dict)
+    def test_skip_email_address(self):
+        self.checker.process_tokens(_tokenize_str("# uname@domain.tld"))
+        assert self.linter.release_messages() == []
+
+    @skip_on_missing_package_or_dict
+    @set_config(spelling_dict=spell_dict)
+    def test_skip_urls(self):
+        self.checker.process_tokens(_tokenize_str("# https://github.com/rfk/pyenchant"))
+        assert self.linter.release_messages() == []
+
+    @skip_on_missing_package_or_dict
+    @set_config(spelling_dict=spell_dict)
+    def test_skip_sphinx_directives(self):
+        stmt = astroid.extract_node(
+            'class ComentAbc(object):\n   """This is :class:`ComentAbc` with a bad coment"""\n   pass'
+        )
+        with self.assertAddsMessages(
+            Message(
+                "wrong-spelling-in-docstring",
+                line=2,
+                args=(
+                    "coment",
+                    "This is :class:`ComentAbc` with a bad coment",
+                    "                                      ^^^^^^",
+                    self._get_msg_suggestions("coment"),
+                ),
+            )
+        ):
+            self.checker.visit_classdef(stmt)
+
+    @skip_on_missing_package_or_dict
+    @set_config(spelling_dict=spell_dict)
+    def test_handle_words_joined_by_forward_slash(self):
+        stmt = astroid.extract_node(
+            '''
+        class ComentAbc(object):
+            """This is Comment/Abcz with a bad comment"""
+            pass
+        '''
+        )
+        with self.assertAddsMessages(
+            Message(
+                "wrong-spelling-in-docstring",
+                line=3,
+                args=(
+                    "Abcz",
+                    "This is Comment/Abcz with a bad comment",
+                    "                ^^^^",
+                    self._get_msg_suggestions("Abcz"),
+                ),
+            )
+        ):
+            self.checker.visit_classdef(stmt)
+
+    @skip_on_missing_package_or_dict
+    @set_config(spelling_dict=spell_dict)
+    def test_more_than_one_error_in_same_line_for_same_word_on_docstring(self):
+        stmt = astroid.extract_node(
+            'class ComentAbc(object):\n   """Check teh dummy comment teh"""\n   pass'
+        )
+        with self.assertAddsMessages(
+            Message(
+                "wrong-spelling-in-docstring",
+                line=2,
+                args=(
+                    "teh",
+                    "Check teh dummy comment teh",
+                    "      ^^^",
+                    self._get_msg_suggestions("teh"),
+                ),
+            ),
+            Message(
+                "wrong-spelling-in-docstring",
+                line=2,
+                args=(
+                    "teh",
+                    "Check teh dummy comment teh",
+                    "                        ^^^",
+                    self._get_msg_suggestions("teh"),
+                ),
+            ),
+        ):
+            self.checker.visit_classdef(stmt)
+
+    @skip_on_missing_package_or_dict
+    @set_config(spelling_dict=spell_dict)
+    def test_more_than_one_error_in_same_line_for_same_word_on_comment(self):
+        with self.assertAddsMessages(
+            Message(
+                "wrong-spelling-in-comment",
+                line=1,
+                args=(
+                    "coment",
+                    "# bad coment coment",
+                    "      ^^^^^^",
+                    self._get_msg_suggestions("coment"),
+                ),
+            ),
+            Message(
+                "wrong-spelling-in-comment",
+                line=1,
+                args=(
+                    "coment",
+                    "# bad coment coment",
+                    "             ^^^^^^",
+                    self._get_msg_suggestions("coment"),
+                ),
+            ),
+        ):
+            self.checker.process_tokens(_tokenize_str("# bad coment coment"))
diff --git a/tests/unittest_checker_stdlib.py b/tests/unittest_checker_stdlib.py
new file mode 100644
index 000000000..55c3dc8dc
--- /dev/null
+++ b/tests/unittest_checker_stdlib.py
@@ -0,0 +1,117 @@
+# Copyright (c) 2015-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Cezar <celnazli@bitdefender.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2017 Martin <MartinBasti@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+import contextlib
+
+import astroid
+
+from pylint.checkers import stdlib
+from pylint.interfaces import UNDEFINED
+from pylint.testutils import CheckerTestCase, Message
+
+
+@contextlib.contextmanager
+def _add_transform(manager, node, transform, predicate=None):
+    manager.register_transform(node, transform, predicate)
+    try:
+        yield
+    finally:
+        manager.unregister_transform(node, transform, predicate)
+
+
+class TestStdlibChecker(CheckerTestCase):
+    CHECKER_CLASS = stdlib.StdlibChecker
+
+    def test_deprecated_no_qname_on_unexpected_nodes(self):
+        # Test that we don't crash on nodes which don't have
+        # a qname method. While this test might seem weird since
+        # it uses a transform, it's actually testing a crash that
+        # happened in production, but there was no way to retrieve
+        # the code for which this occurred (how an AssignAttr
+        # got to be the result of a function inference
+        # beats me..)
+
+        def infer_func(node, context=None):
+            new_node = astroid.AssignAttr()
+            new_node.parent = node
+            yield new_node
+
+        manager = astroid.MANAGER
+        transform = astroid.inference_tip(infer_func)
+        with _add_transform(manager, astroid.Name, transform):
+            node = astroid.extract_node(
+                """
+            call_something()
+            """
+            )
+            with self.assertNoMessages():
+                self.checker.visit_call(node)
+
+    def test_copy_environ(self):
+        # shallow copy of os.environ should be reported
+        node = astroid.extract_node(
+            """
+        import copy, os
+        copy.copy(os.environ)
+        """
+        )
+        with self.assertAddsMessages(
+            Message(msg_id="shallow-copy-environ", node=node, confidence=UNDEFINED)
+        ):
+            self.checker.visit_call(node)
+
+    def test_copy_environ_hidden(self):
+        # shallow copy of os.environ should be reported
+        # hide function names to be sure that checker is not just matching text
+        node = astroid.extract_node(
+            """
+        from copy import copy as test_cp
+        import os as o
+        test_cp(o.environ)
+        """
+        )
+        with self.assertAddsMessages(
+            Message(msg_id="shallow-copy-environ", node=node, confidence=UNDEFINED)
+        ):
+            self.checker.visit_call(node)
+
+    def test_copy_dict(self):
+        # copy of dict is OK
+        node = astroid.extract_node(
+            """
+        import copy
+        test_dict = {}
+        copy.copy(test_dict)
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_call(node)
+
+    def test_copy_uninferable(self):
+        # copy of uninferable object should not raise exception, nor make
+        # the checker crash
+        node = astroid.extract_node(
+            """
+        import copy
+        from missing_library import MissingObject
+        copy.copy(MissingObject)
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_call(node)
+
+    def test_deepcopy_environ(self):
+        # deepcopy of os.environ is OK
+        node = astroid.extract_node(
+            """
+        import copy, os
+        copy.deepcopy(os.environ)
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_call(node)
diff --git a/tests/unittest_checker_strings.py b/tests/unittest_checker_strings.py
new file mode 100644
index 000000000..bc4fce6f9
--- /dev/null
+++ b/tests/unittest_checker_strings.py
@@ -0,0 +1,85 @@
+# Copyright (c) 2015-2018 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+import astroid
+
+from pylint.checkers import strings
+from pylint.testutils import CheckerTestCase, Message
+
+TEST_TOKENS = (
+    '"X"',
+    "'X'",
+    "'''X'''",
+    '"""X"""',
+    'r"X"',
+    "R'X'",
+    'u"X"',
+    "F'X'",
+    'f"X"',
+    "F'X'",
+    'fr"X"',
+    'Fr"X"',
+    'fR"X"',
+    'FR"X"',
+    'rf"X"',
+    'rF"X"',
+    'Rf"X"',
+    'RF"X"',
+)
+
+
+class TestStringChecker(CheckerTestCase):
+    CHECKER_CLASS = strings.StringFormatChecker
+
+    def test_format_bytes(self):
+        code = "b'test'.format(1, 2)"
+        node = astroid.extract_node(code)
+        with self.assertNoMessages():
+            self.checker.visit_call(node)
+
+    def test_format_types(self):
+        for code in ("'%s' % 1", "'%d' % 1", "'%f' % 1"):
+            with self.assertNoMessages():
+                node = astroid.extract_node(code)
+            self.checker.visit_binop(node)
+
+        for code in (
+            "'%s' % 1",
+            "'%(key)s' % {'key' : 1}",
+            "'%d' % 1",
+            "'%(key)d' % {'key' : 1}",
+            "'%f' % 1",
+            "'%(key)f' % {'key' : 1}",
+            "'%d' % 1.1",
+            "'%(key)d' % {'key' : 1.1}",
+            "'%s' % []",
+            "'%(key)s' % {'key' : []}",
+            "'%s' % None",
+            "'%(key)s' % {'key' : None}",
+        ):
+            with self.assertNoMessages():
+                node = astroid.extract_node(code)
+                self.checker.visit_binop(node)
+
+        for code, arg_type, format_type in [
+            ("'%d' % '1'", "builtins.str", "d"),
+            ("'%(key)d' % {'key' : '1'}", "builtins.str", "d"),
+            ("'%x' % 1.1", "builtins.float", "x"),
+            ("'%(key)x' % {'key' : 1.1}", "builtins.float", "x"),
+            ("'%d' % []", "builtins.list", "d"),
+            ("'%(key)d' % {'key' : []}", "builtins.list", "d"),
+        ]:
+            node = astroid.extract_node(code)
+            with self.assertAddsMessages(
+                Message(
+                    "bad-string-format-type", node=node, args=(arg_type, format_type)
+                )
+            ):
+                self.checker.visit_binop(node)
+
+    def test_str_eval(self):
+        for token in TEST_TOKENS:
+            assert strings.str_eval(token) == "X"
diff --git a/tests/unittest_checker_typecheck.py b/tests/unittest_checker_typecheck.py
new file mode 100644
index 000000000..ba61a7d13
--- /dev/null
+++ b/tests/unittest_checker_typecheck.py
@@ -0,0 +1,350 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014 Holger Peters <email@holger-peters.de>
+# Copyright (c) 2015-2018 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Dmitry Pribysh <dmand@yandex.ru>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Filipe Brandenburger <filbranden@google.com>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Unittest for the type checker."""
+import sys
+
+import astroid
+import pytest
+
+from pylint.checkers import typecheck
+from pylint.testutils import CheckerTestCase, Message, set_config
+
+
+def c_extension_missing():
+    """Coverage module has C-extension, which we can reuse for test"""
+    try:
+        import coverage.tracer as _
+
+        return False
+    except ImportError:
+        _ = None
+        return True
+
+
+needs_c_extension = pytest.mark.skipif(
+    c_extension_missing(), reason="Requires coverage (source of C-extension)"
+)
+
+
+class TestTypeChecker(CheckerTestCase):
+    "Tests for pylint.checkers.typecheck"
+    CHECKER_CLASS = typecheck.TypeChecker
+
+    def test_no_member_in_getattr(self):
+        """Make sure that a module attribute access is checked by pylint.
+        """
+
+        node = astroid.extract_node(
+            """
+        import optparse
+        optparse.THIS_does_not_EXIST
+        """
+        )
+        with self.assertAddsMessages(
+            Message(
+                "no-member",
+                node=node,
+                args=("Module", "optparse", "THIS_does_not_EXIST", ""),
+            )
+        ):
+            self.checker.visit_attribute(node)
+
+    @set_config(ignored_modules=("argparse",))
+    def test_no_member_in_getattr_ignored(self):
+        """Make sure that a module attribute access check is omitted with a
+        module that is configured to be ignored.
+        """
+
+        node = astroid.extract_node(
+            """
+        import argparse
+        argparse.THIS_does_not_EXIST
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_attribute(node)
+
+    @set_config(ignored_classes=("xml.etree.",))
+    def test_ignored_modules_invalid_pattern(self):
+        node = astroid.extract_node(
+            """
+        import xml
+        xml.etree.Lala
+        """
+        )
+        message = Message(
+            "no-member", node=node, args=("Module", "xml.etree", "Lala", "")
+        )
+        with self.assertAddsMessages(message):
+            self.checker.visit_attribute(node)
+
+    @set_config(ignored_modules=("xml.etree*",))
+    def test_ignored_modules_patterns(self):
+        node = astroid.extract_node(
+            """
+        import xml
+        xml.etree.portocola #@
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_attribute(node)
+
+    @set_config(ignored_classes=("xml.*",))
+    def test_ignored_classes_no_recursive_pattern(self):
+        node = astroid.extract_node(
+            """
+        import xml
+        xml.etree.ElementTree.Test
+        """
+        )
+        message = Message(
+            "no-member", node=node, args=("Module", "xml.etree.ElementTree", "Test", "")
+        )
+        with self.assertAddsMessages(message):
+            self.checker.visit_attribute(node)
+
+    @set_config(ignored_classes=("optparse.Values",))
+    def test_ignored_classes_qualified_name(self):
+        """Test that ignored-classes supports qualified name for ignoring."""
+        node = astroid.extract_node(
+            """
+        import optparse
+        optparse.Values.lala
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_attribute(node)
+
+    @set_config(ignored_classes=("Values",))
+    def test_ignored_classes_only_name(self):
+        """Test that ignored_classes works with the name only."""
+        node = astroid.extract_node(
+            """
+        import optparse
+        optparse.Values.lala
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_attribute(node)
+
+    @set_config(suggestion_mode=False)
+    @needs_c_extension
+    def test_nomember_on_c_extension_error_msg(self):
+        node = astroid.extract_node(
+            """
+        from coverage import tracer
+        tracer.CTracer  #@
+        """
+        )
+        message = Message(
+            "no-member", node=node, args=("Module", "coverage.tracer", "CTracer", "")
+        )
+        with self.assertAddsMessages(message):
+            self.checker.visit_attribute(node)
+
+    @set_config(suggestion_mode=True)
+    @needs_c_extension
+    def test_nomember_on_c_extension_info_msg(self):
+        node = astroid.extract_node(
+            """
+        from coverage import tracer
+        tracer.CTracer  #@
+        """
+        )
+        message = Message(
+            "c-extension-no-member",
+            node=node,
+            args=("Module", "coverage.tracer", "CTracer", ""),
+        )
+        with self.assertAddsMessages(message):
+            self.checker.visit_attribute(node)
+
+    @set_config(
+        contextmanager_decorators=(
+            "contextlib.contextmanager",
+            ".custom_contextmanager",
+        )
+    )
+    def test_custom_context_manager(self):
+        """Test that @custom_contextmanager is recognized as configured."""
+        node = astroid.extract_node(
+            """
+        from contextlib import contextmanager
+        def custom_contextmanager(f):
+            return contextmanager(f)
+        @custom_contextmanager
+        def dec():
+            yield
+        with dec():
+            pass
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_with(node)
+
+    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)
+
+    @pytest.mark.skipif(sys.version_info[0] < 3, reason="Needs Python 3.")
+    def test_invalid_metaclass_function_metaclasses(self):
+        module = astroid.parse(
+            """
+        def invalid_metaclass_1(name, bases, attrs):
+            return int
+        def invalid_metaclass_2(name, bases, attrs):
+            return 1
+        class Invalid(metaclass=invalid_metaclass_1):
+            pass
+        class InvalidSecond(metaclass=invalid_metaclass_2):
+            pass
+        """
+        )
+        for class_obj, metaclass_name in (("Invalid", "int"), ("InvalidSecond", "1")):
+            classdef = module[class_obj]
+            message = Message(
+                "invalid-metaclass", node=classdef, args=(metaclass_name,)
+            )
+            with self.assertAddsMessages(message):
+                self.checker.visit_classdef(classdef)
+
+    @pytest.mark.skipif(sys.version_info < (3, 5), reason="Needs Python 3.5.")
+    def test_typing_namedtuple_not_callable_issue1295(self):
+        module = astroid.parse(
+            """
+        import typing
+        Named = typing.NamedTuple('Named', [('foo', int), ('bar', int)])
+        named = Named(1, 2)
+        """
+        )
+        call = module.body[-1].value
+        callables = call.func.inferred()
+        assert len(callables) == 1
+        assert callables[0].callable()
+        with self.assertNoMessages():
+            self.checker.visit_call(call)
+
+    @pytest.mark.skipif(sys.version_info < (3, 5), reason="Needs Python 3.5.")
+    def test_typing_namedtuple_unsubscriptable_object_issue1295(self):
+        module = astroid.parse(
+            """
+        import typing
+        MyType = typing.Tuple[str, str]
+        """
+        )
+        subscript = module.body[-1].value
+        with self.assertNoMessages():
+            self.checker.visit_subscript(subscript)
+
+    def test_staticmethod_multiprocessing_call(self):
+        """Make sure not-callable isn't raised for descriptors
+
+        astroid can't process descriptors correctly so
+        pylint needs to ignore not-callable for them
+        right now
+
+        Test for https://github.com/PyCQA/pylint/issues/1699
+        """
+        call = astroid.extract_node(
+            """
+        import multiprocessing
+        multiprocessing.current_process() #@
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_call(call)
+
+    def test_not_callable_uninferable_property(self):
+        """Make sure not-callable isn't raised for uninferable
+        properties
+        """
+        call = astroid.extract_node(
+            """
+        class A:
+            @property
+            def call(self):
+                return undefined
+
+        a = A()
+        a.call() #@
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_call(call)
+
+    def test_descriptor_call(self):
+        call = astroid.extract_node(
+            """
+        def func():
+            pass
+
+        class ADescriptor:
+            def __get__(self, instance, owner):
+                return func
+
+        class AggregateCls:
+            a = ADescriptor()
+
+        AggregateCls().a() #@
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_call(call)
+
+    def test_unknown_parent(self):
+        """Make sure the callable check does not crash when a node's parent
+        cannot be determined.
+        """
+        call = astroid.extract_node(
+            """
+        def get_num(n):
+            return 2 * n
+        get_num(10)()
+        """
+        )
+        with self.assertAddsMessages(
+            Message("not-callable", node=call, args="get_num(10)")
+        ):
+            self.checker.visit_call(call)
diff --git a/tests/unittest_checker_variables.py b/tests/unittest_checker_variables.py
new file mode 100644
index 000000000..299a550d2
--- /dev/null
+++ b/tests/unittest_checker_variables.py
@@ -0,0 +1,284 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2017 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2018 Bryce Guinta <bryce.guinta@protonmail.com>
+# Copyright (c) 2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
+# Copyright (c) 2018 mar-chi-pan <mar.polatoglou@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Unit tests for the variables checker."""
+import os
+import re
+import sys
+
+import astroid
+
+from pylint.checkers import variables
+from pylint.interfaces import UNDEFINED
+from pylint.testutils import CheckerTestCase, Message, linter, set_config
+
+
+class TestVariablesChecker(CheckerTestCase):
+
+    CHECKER_CLASS = variables.VariablesChecker
+
+    def test_bitbucket_issue_78(self):
+        """ Issue 78 report a false positive for unused-module """
+        module = astroid.parse(
+            """
+        from sys import path
+        path += ['stuff']
+        def func():
+            other = 1
+            return len(other)
+        """
+        )
+        with self.assertNoMessages():
+            self.walk(module)
+
+    @set_config(ignored_modules=("argparse",))
+    def test_no_name_in_module_skipped(self):
+        """Make sure that 'from ... import ...' does not emit a
+        'no-name-in-module' with a module that is configured
+        to be ignored.
+        """
+
+        node = astroid.extract_node(
+            """
+        from argparse import THIS_does_not_EXIST
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_importfrom(node)
+
+    def test_all_elements_without_parent(self):
+        node = astroid.extract_node("__all__ = []")
+        node.value.elts.append(astroid.Const("test"))
+        root = node.root()
+        with self.assertNoMessages():
+            self.checker.visit_module(root)
+            self.checker.leave_module(root)
+
+    def test_redefined_builtin_ignored(self):
+        node = astroid.parse(
+            """
+        from future.builtins import open
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_module(node)
+
+    @set_config(redefining_builtins_modules=("os",))
+    def test_redefined_builtin_custom_modules(self):
+        node = astroid.parse(
+            """
+        from os import open
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_module(node)
+
+    @set_config(redefining_builtins_modules=("os",))
+    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)
+
+    @set_config(redefining_builtins_modules=("os",))
+    def test_redefined_builtin_in_function(self):
+        node = astroid.extract_node(
+            """
+        def test():
+            from os import open
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_module(node.root())
+            self.checker.visit_functiondef(node)
+
+    def test_unassigned_global(self):
+        node = astroid.extract_node(
+            """
+            def func():
+                global sys  #@
+                import sys, lala
+        """
+        )
+        msg = Message("global-statement", node=node, confidence=UNDEFINED)
+        with self.assertAddsMessages(msg):
+            self.checker.visit_global(node)
+
+
+class TestVariablesCheckerWithTearDown(CheckerTestCase):
+
+    CHECKER_CLASS = variables.VariablesChecker
+
+    def setup_method(self):
+        super(TestVariablesCheckerWithTearDown, self).setup_method()
+        self._to_consume_backup = self.checker._to_consume
+        self.checker._to_consume = []
+
+    def teardown_method(self, method):
+        self.checker._to_consume = self._to_consume_backup
+
+    @set_config(callbacks=("callback_", "_callback"))
+    def test_custom_callback_string(self):
+        """ Test the --calbacks option works. """
+        node = astroid.extract_node(
+            """
+        def callback_one(abc):
+             ''' should not emit unused-argument. '''
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+            self.checker.leave_functiondef(node)
+
+        node = astroid.extract_node(
+            """
+        def two_callback(abc, defg):
+             ''' should not emit unused-argument. '''
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_functiondef(node)
+            self.checker.leave_functiondef(node)
+
+        node = astroid.extract_node(
+            """
+        def normal_func(abc):
+             ''' should emit unused-argument. '''
+        """
+        )
+        with self.assertAddsMessages(
+            Message("unused-argument", node=node["abc"], args="abc")
+        ):
+            self.checker.visit_functiondef(node)
+            self.checker.leave_functiondef(node)
+
+        node = astroid.extract_node(
+            """
+        def cb_func(abc):
+             ''' Previous callbacks are overridden. '''
+        """
+        )
+        with self.assertAddsMessages(
+            Message("unused-argument", node=node["abc"], args="abc")
+        ):
+            self.checker.visit_functiondef(node)
+            self.checker.leave_functiondef(node)
+
+    @set_config(redefining_builtins_modules=("os",))
+    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)
+
+    @set_config(redefining_builtins_modules=("os",))
+    def test_redefined_builtin_in_function(self):
+        node = astroid.extract_node(
+            """
+        def test():
+            from os import open
+        """
+        )
+        with self.assertNoMessages():
+            self.checker.visit_module(node.root())
+            self.checker.visit_functiondef(node)
+
+    def test_import_as_underscore(self):
+        node = astroid.parse(
+            """
+        import math as _
+        """
+        )
+        with self.assertNoMessages():
+            self.walk(node)
+
+    def test_lambda_in_classdef(self):
+        # Make sure lambda doesn't raises
+        # Undefined-method in class def
+
+        # Issue 1824
+        # https://github.com/PyCQA/pylint/issues/1824
+        node = astroid.parse(
+            """
+        class MyObject(object):
+            method1 = lambda func: func()
+            method2 = lambda function: function()
+        """
+        )
+        with self.assertNoMessages():
+            self.walk(node)
+
+    def test_nested_lambda(self):
+        """Make sure variables from parent lambdas
+        aren't noted as undefined
+
+        https://github.com/PyCQA/pylint/issues/760
+        """
+        node = astroid.parse(
+            """
+        lambda x: lambda: x + 1
+        """
+        )
+        with self.assertNoMessages():
+            self.walk(node)
+
+    @set_config(ignored_argument_names=re.compile("arg"))
+    def test_ignored_argument_names_no_message(self):
+        """Make sure is_ignored_argument_names properly ignores
+        function arguments"""
+        node = astroid.parse(
+            """
+        def fooby(arg):
+            pass
+        """
+        )
+        with self.assertNoMessages():
+            self.walk(node)
+
+    @set_config(ignored_argument_names=re.compile("args|kwargs"))
+    def test_ignored_argument_names_starred_args(self):
+        node = astroid.parse(
+            """
+        def fooby(*args, **kwargs):
+            pass
+        """
+        )
+        with self.assertNoMessages():
+            self.walk(node)
+
+
+class TestMissingSubmodule(CheckerTestCase):
+    CHECKER_CLASS = variables.VariablesChecker
+
+    def test_package_all(self):
+        regr_data = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), "regrtest_data"
+        )
+        sys.path.insert(0, regr_data)
+        try:
+            linter.check(os.path.join(regr_data, "package_all"))
+            got = linter.reporter.finalize().strip()
+            assert got == "E:  3: Undefined variable name 'missing' in __all__"
+        finally:
+            sys.path.pop(0)
diff --git a/tests/unittest_checkers_utils.py b/tests/unittest_checkers_utils.py
new file mode 100644
index 000000000..74a3b6259
--- /dev/null
+++ b/tests/unittest_checkers_utils.py
@@ -0,0 +1,379 @@
+# Copyright (c) 2010 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2013-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2013-2014 Google, Inc.
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Caio Carrara <ccarrara@redhat.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Tests for the pylint.checkers.utils module."""
+
+import astroid
+import pytest
+
+from pylint.checkers import utils
+
+
+@pytest.mark.parametrize(
+    "name,expected",
+    [
+        ("min", True),
+        ("__builtins__", True),
+        ("__path__", False),
+        ("__file__", False),
+        ("whatever", False),
+        ("mybuiltin", False),
+    ],
+)
+def testIsBuiltin(name, expected):
+    assert utils.is_builtin(name) == expected
+
+
+@pytest.mark.parametrize(
+    "fn,kw",
+    [("foo(3)", {"keyword": "bar"}), ("foo(one=a, two=b, three=c)", {"position": 1})],
+)
+def testGetArgumentFromCallError(fn, kw):
+    with pytest.raises(utils.NoSuchArgumentError):
+        node = astroid.extract_node(fn)
+        utils.get_argument_from_call(node, **kw)
+
+
+@pytest.mark.parametrize(
+    "fn,kw", [("foo(bar=3)", {"keyword": "bar"}), ("foo(a, b, c)", {"position": 1})]
+)
+def testGetArgumentFromCallExists(fn, kw):
+    node = astroid.extract_node(fn)
+    assert utils.get_argument_from_call(node, **kw) is not None
+
+
+def testGetArgumentFromCall():
+    node = astroid.extract_node("foo(a, not_this_one=1, this_one=2)")
+    arg = utils.get_argument_from_call(node, position=2, keyword="this_one")
+    assert 2 == arg.value
+
+    node = astroid.extract_node("foo(a)")
+    with pytest.raises(utils.NoSuchArgumentError):
+        utils.get_argument_from_call(node, position=1)
+    with pytest.raises(ValueError):
+        utils.get_argument_from_call(node, None, None)
+    name = utils.get_argument_from_call(node, position=0)
+    assert name.name == "a"
+
+
+def test_error_of_type():
+    nodes = astroid.extract_node(
+        """
+    try: pass
+    except AttributeError: #@
+         pass
+    try: pass
+    except Exception: #@
+         pass
+    except: #@
+         pass
+    """
+    )
+    assert utils.error_of_type(nodes[0], AttributeError)
+    assert utils.error_of_type(nodes[0], (AttributeError,))
+    assert not utils.error_of_type(nodes[0], Exception)
+    assert utils.error_of_type(nodes[1], Exception)
+    assert utils.error_of_type(nodes[2], ImportError)
+
+
+def test_node_ignores_exception():
+    nodes = astroid.extract_node(
+        """
+    try:
+        1/0 #@
+    except ZeroDivisionError:
+        pass
+    try:
+        1/0 #@
+    except Exception:
+        pass
+    try:
+        2/0 #@
+    except:
+        pass
+    try:
+        1/0 #@
+    except ValueError:
+        pass
+    """
+    )
+    assert utils.node_ignores_exception(nodes[0], ZeroDivisionError)
+    assert not utils.node_ignores_exception(nodes[1], ZeroDivisionError)
+    assert utils.node_ignores_exception(nodes[2], ZeroDivisionError)
+    assert not utils.node_ignores_exception(nodes[3], ZeroDivisionError)
+
+
+def test_is_subclass_of_node_b_derived_from_node_a():
+    nodes = astroid.extract_node(
+        """
+    class Superclass: #@
+        pass
+
+    class Subclass(Superclass): #@
+        pass
+    """
+    )
+    assert utils.is_subclass_of(nodes[1], nodes[0])
+
+
+def test_is_subclass_of_node_b_not_derived_from_node_a():
+    nodes = astroid.extract_node(
+        """
+    class OneClass: #@
+        pass
+
+    class AnotherClass: #@
+        pass
+    """
+    )
+    assert not utils.is_subclass_of(nodes[1], nodes[0])
+
+
+def test_is_subclass_of_not_classdefs():
+    node = astroid.extract_node(
+        """
+    class OneClass: #@
+        pass
+    """
+    )
+    assert not utils.is_subclass_of(None, node)
+    assert not utils.is_subclass_of(node, None)
+    assert not utils.is_subclass_of(None, None)
+
+
+def test_parse_format_method_string():
+    samples = [
+        ("{}", 1),
+        ("{}:{}", 2),
+        ("{field}", 1),
+        ("{:5}", 1),
+        ("{:10}", 1),
+        ("{field:10}", 1),
+        ("{field:10}{{}}", 1),
+        ("{:5}{!r:10}", 2),
+        ("{:5}{}{{}}{}", 3),
+        ("{0}{1}{0}", 2),
+        ("Coordinates: {latitude}, {longitude}", 2),
+        ("X: {0[0]};  Y: {0[1]}", 1),
+        ("{:*^30}", 1),
+        ("{!r:}", 1),
+    ]
+    for fmt, count in samples:
+        keys, num_args, pos_args = utils.parse_format_method_string(fmt)
+        keyword_args = len(set(k for k, l in keys if not isinstance(k, int)))
+        assert keyword_args + num_args + pos_args == count
+
+
+def test_inherit_from_std_ex_recursive_definition():
+    node = astroid.extract_node(
+        """
+      import datetime
+      class First(datetime.datetime):
+        pass
+      class Second(datetime.datetime): #@
+        pass
+      datetime.datetime = First
+      datetime.datetime = Second
+      """
+    )
+    assert not utils.inherit_from_std_ex(node)
+
+
+class TestGetNodeLastLineno:
+    def test_get_node_last_lineno_simple(self):
+        node = astroid.extract_node(
+            """
+            pass
+        """
+        )
+        assert utils.get_node_last_lineno(node) == 2
+
+    def test_get_node_last_lineno_if_simple(self):
+        node = astroid.extract_node(
+            """
+            if True:
+                print(1)
+                pass
+            """
+        )
+        assert utils.get_node_last_lineno(node) == 4
+
+    def test_get_node_last_lineno_if_elseif_else(self):
+        node = astroid.extract_node(
+            """
+            if True:
+                print(1)
+            elif False:
+                print(2)
+            else:
+                print(3)
+            """
+        )
+        assert utils.get_node_last_lineno(node) == 7
+
+    def test_get_node_last_lineno_while(self):
+        node = astroid.extract_node(
+            """
+            while True:
+                print(1)
+            """
+        )
+        assert utils.get_node_last_lineno(node) == 3
+
+    def test_get_node_last_lineno_while_else(self):
+        node = astroid.extract_node(
+            """
+            while True:
+                print(1)
+            else:
+                print(2)
+            """
+        )
+        assert utils.get_node_last_lineno(node) == 5
+
+    def test_get_node_last_lineno_for(self):
+        node = astroid.extract_node(
+            """
+            for x in range(0, 5):
+                print(1)
+            """
+        )
+        assert utils.get_node_last_lineno(node) == 3
+
+    def test_get_node_last_lineno_for_else(self):
+        node = astroid.extract_node(
+            """
+            for x in range(0, 5):
+                print(1)
+            else:
+                print(2)
+            """
+        )
+        assert utils.get_node_last_lineno(node) == 5
+
+    def test_get_node_last_lineno_try(self):
+        node = astroid.extract_node(
+            """
+            try:
+                print(1)
+            except ValueError:
+                print(2)
+            except Exception:
+                print(3)
+            """
+        )
+        assert utils.get_node_last_lineno(node) == 7
+
+    def test_get_node_last_lineno_try_except_else(self):
+        node = astroid.extract_node(
+            """
+            try:
+                print(1)
+            except Exception:
+                print(2)
+                print(3)
+            else:
+                print(4)
+            """
+        )
+        assert utils.get_node_last_lineno(node) == 8
+
+    def test_get_node_last_lineno_try_except_finally(self):
+        node = astroid.extract_node(
+            """
+            try:
+                print(1)
+            except Exception:
+                print(2)
+            finally:
+                print(4)
+            """
+        )
+        assert utils.get_node_last_lineno(node) == 7
+
+    def test_get_node_last_lineno_try_except_else_finally(self):
+        node = astroid.extract_node(
+            """
+            try:
+                print(1)
+            except Exception:
+                print(2)
+            else:
+                print(3)
+            finally:
+                print(4)
+            """
+        )
+        assert utils.get_node_last_lineno(node) == 9
+
+    def test_get_node_last_lineno_with(self):
+        node = astroid.extract_node(
+            """
+            with x as y:
+                print(1)
+                pass
+            """
+        )
+        assert utils.get_node_last_lineno(node) == 4
+
+    def test_get_node_last_lineno_method(self):
+        node = astroid.extract_node(
+            """
+            def x(a, b):
+                print(a, b)
+                pass
+            """
+        )
+        assert utils.get_node_last_lineno(node) == 4
+
+    def test_get_node_last_lineno_decorator(self):
+        node = astroid.extract_node(
+            """
+            @decor()
+            def x(a, b):
+                print(a, b)
+                pass
+            """
+        )
+        assert utils.get_node_last_lineno(node) == 5
+
+    def test_get_node_last_lineno_class(self):
+        node = astroid.extract_node(
+            """
+            class C(object):
+                CONST = True
+
+                def x(self, b):
+                    print(b)
+
+                def y(self):
+                    pass
+                    pass
+            """
+        )
+        assert utils.get_node_last_lineno(node) == 10
+
+    def test_get_node_last_lineno_combined(self):
+        node = astroid.extract_node(
+            """
+            class C(object):
+                CONST = True
+
+                def y(self):
+                    try:
+                        pass
+                    except:
+                        pass
+                    finally:
+                        pass
+            """
+        )
+        assert utils.get_node_last_lineno(node) == 11
diff --git a/tests/unittest_config.py b/tests/unittest_config.py
new file mode 100644
index 000000000..ca36c00eb
--- /dev/null
+++ b/tests/unittest_config.py
@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2015 Aru Sahni <arusahni@gmail.com>
+# Copyright (c) 2016-2018 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2017 Ville Skyttä <ville.skytta@iki.fi>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Unit tests for the config module."""
+
+import re
+import sre_constants
+
+import pytest
+
+from pylint import config
+
+RE_PATTERN_TYPE = getattr(re, "Pattern", getattr(re, "_pattern_type", None))
+
+
+def test__regexp_validator_valid():
+    result = config._regexp_validator(None, None, "test_.*")
+    assert isinstance(result, RE_PATTERN_TYPE)
+    assert result.pattern == "test_.*"
+
+
+def test__regexp_validator_invalid():
+    with pytest.raises(sre_constants.error):
+        config._regexp_validator(None, None, "test_)")
+
+
+def test__csv_validator_no_spaces():
+    values = ["One", "Two", "Three"]
+    result = config._csv_validator(None, None, ",".join(values))
+    assert isinstance(result, list)
+    assert len(result) == 3
+    for i, value in enumerate(values):
+        assert result[i] == value
+
+
+def test__csv_validator_spaces():
+    values = ["One", "Two", "Three"]
+    result = config._csv_validator(None, None, ", ".join(values))
+    assert isinstance(result, list)
+    assert len(result) == 3
+    for i, value in enumerate(values):
+        assert result[i] == value
+
+
+def test__regexp_csv_validator_valid():
+    pattern_strings = ["test_.*", "foo\\.bar", "^baz$"]
+    result = config._regexp_csv_validator(None, None, ",".join(pattern_strings))
+    for i, regex in enumerate(result):
+        assert isinstance(regex, RE_PATTERN_TYPE)
+        assert regex.pattern == pattern_strings[i]
+
+
+def test__regexp_csv_validator_invalid():
+    pattern_strings = ["test_.*", "foo\\.bar", "^baz)$"]
+    with pytest.raises(sre_constants.error):
+        config._regexp_csv_validator(None, None, ",".join(pattern_strings))
diff --git a/tests/unittest_lint.py b/tests/unittest_lint.py
new file mode 100644
index 000000000..8d871bfaf
--- /dev/null
+++ b/tests/unittest_lint.py
@@ -0,0 +1,771 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2006-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2009 Charles Hebert <charles.hebert@logilab.fr>
+# Copyright (c) 2011-2014 Google, Inc.
+# Copyright (c) 2012 Kevin Jing Qiu <kevin.jing.qiu@gmail.com>
+# Copyright (c) 2012 Anthony VEREZ <anthony.verez.external@cassidian.com>
+# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
+# Copyright (c) 2013-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Florian Bruhin <me@the-compiler.org>
+# Copyright (c) 2015 Noam Yorav-Raphael <noamraph@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016-2017 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2016 Glenn Matthews <glmatthe@cisco.com>
+# Copyright (c) 2017 Pierre Sassoulas <pierre.sassoulas@cea.fr>
+# Copyright (c) 2017 Craig Citro <craigcitro@gmail.com>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2017 Ville Skyttä <ville.skytta@iki.fi>
+# Copyright (c) 2018 Randall Leeds <randall@bleeds.info>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+# Copyright (c) 2018 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2018 Pierre Sassoulas <pierre.sassoulas@wisebim.fr>
+# Copyright (c) 2018 Reverb C <reverbc@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+import os
+import re
+import sys
+import tempfile
+from contextlib import contextmanager
+from importlib import reload
+from io import StringIO
+from os import chdir, getcwd
+from os.path import abspath, basename, dirname, isdir, join, sep
+from shutil import rmtree
+
+import pytest
+
+import pylint.testutils as testutils
+from pylint import checkers, config, exceptions, interfaces, lint
+from pylint.checkers.utils import check_messages
+from pylint.constants import (
+    MSG_STATE_CONFIDENCE,
+    MSG_STATE_SCOPE_CONFIG,
+    MSG_STATE_SCOPE_MODULE,
+)
+from pylint.exceptions import InvalidMessageError
+from pylint.lint import ArgumentPreprocessingError, PyLinter, Run, preprocess_options
+from pylint.reporters import text
+from pylint.utils import FileState, tokenize_module
+
+if os.name == "java":
+    if os._name == "nt":
+        HOME = "USERPROFILE"
+    else:
+        HOME = "HOME"
+else:
+    if sys.platform == "win32":
+        HOME = "USERPROFILE"
+    else:
+        HOME = "HOME"
+
+try:
+    PYPY_VERSION_INFO = sys.pypy_version_info
+except AttributeError:
+    PYPY_VERSION_INFO = None
+
+
+@contextmanager
+def fake_home():
+    folder = tempfile.mkdtemp("fake-home")
+    old_home = os.environ.get(HOME)
+    try:
+        os.environ[HOME] = folder
+        yield
+    finally:
+        os.environ.pop("PYLINTRC", "")
+        if old_home is None:
+            del os.environ[HOME]
+        else:
+            os.environ[HOME] = old_home
+        rmtree(folder, ignore_errors=True)
+
+
+def remove(file):
+    try:
+        os.remove(file)
+    except OSError:
+        pass
+
+
+HERE = abspath(dirname(__file__))
+INPUTDIR = join(HERE, "input")
+REGRTEST_DATA = join(HERE, "regrtest_data")
+
+
+@contextmanager
+def tempdir():
+    """Create a temp directory and change the current location to it.
+
+    This is supposed to be used with a *with* statement.
+    """
+    tmp = tempfile.mkdtemp()
+
+    # Get real path of tempfile, otherwise test fail on mac os x
+    current_dir = getcwd()
+    chdir(tmp)
+    abs_tmp = abspath(".")
+
+    try:
+        yield abs_tmp
+    finally:
+        chdir(current_dir)
+        rmtree(abs_tmp)
+
+
+def create_files(paths, chroot="."):
+    """Creates directories and files found in <path>.
+
+    :param paths: list of relative paths to files or directories
+    :param chroot: the root directory in which paths will be created
+
+    >>> from os.path import isdir, isfile
+    >>> isdir('/tmp/a')
+    False
+    >>> create_files(['a/b/foo.py', 'a/b/c/', 'a/b/c/d/e.py'], '/tmp')
+    >>> isdir('/tmp/a')
+    True
+    >>> isdir('/tmp/a/b/c')
+    True
+    >>> isfile('/tmp/a/b/c/d/e.py')
+    True
+    >>> isfile('/tmp/a/b/foo.py')
+    True
+    """
+    dirs, files = set(), set()
+    for path in paths:
+        path = join(chroot, path)
+        filename = basename(path)
+        # path is a directory path
+        if filename == "":
+            dirs.add(path)
+        # path is a filename path
+        else:
+            dirs.add(dirname(path))
+            files.add(path)
+    for dirpath in dirs:
+        if not isdir(dirpath):
+            os.makedirs(dirpath)
+    for filepath in files:
+        open(filepath, "w").close()
+
+
+@pytest.fixture
+def fake_path():
+    orig = list(sys.path)
+    fake = [1, 2, 3]
+    sys.path[:] = fake
+    yield fake
+    sys.path[:] = orig
+
+
+def test_no_args(fake_path):
+    with lint.fix_import_path([]):
+        assert sys.path == ["."] + fake_path
+    assert sys.path == fake_path
+
+
+@pytest.mark.parametrize(
+    "case", [["a/b/"], ["a/b"], ["a/b/__init__.py"], ["a/"], ["a"]]
+)
+def test_one_arg(fake_path, case):
+    with tempdir() as chroot:
+        create_files(["a/b/__init__.py"])
+        expected = [join(chroot, "a")] + ["."] + fake_path
+
+        assert sys.path == fake_path
+        with lint.fix_import_path(case):
+            assert sys.path == expected
+        assert sys.path == fake_path
+
+
+@pytest.mark.parametrize(
+    "case",
+    [
+        ["a/b", "a/c"],
+        ["a/c/", "a/b/"],
+        ["a/b/__init__.py", "a/c/__init__.py"],
+        ["a", "a/c/__init__.py"],
+    ],
+)
+def test_two_similar_args(fake_path, case):
+    with tempdir() as chroot:
+        create_files(["a/b/__init__.py", "a/c/__init__.py"])
+        expected = [join(chroot, "a")] + ["."] + fake_path
+
+        assert sys.path == fake_path
+        with lint.fix_import_path(case):
+            assert sys.path == expected
+        assert sys.path == fake_path
+
+
+@pytest.mark.parametrize(
+    "case",
+    [
+        ["a/b/c/__init__.py", "a/d/__init__.py", "a/e/f.py"],
+        ["a/b/c", "a", "a/e"],
+        ["a/b/c", "a", "a/b/c", "a/e", "a"],
+    ],
+)
+def test_more_args(fake_path, case):
+    with tempdir() as chroot:
+        create_files(["a/b/c/__init__.py", "a/d/__init__.py", "a/e/f.py"])
+        expected = (
+            [
+                join(chroot, suffix)
+                for suffix in [sep.join(("a", "b")), "a", sep.join(("a", "e"))]
+            ]
+            + ["."]
+            + fake_path
+        )
+
+        assert sys.path == fake_path
+        with lint.fix_import_path(case):
+            assert sys.path == expected
+        assert sys.path == fake_path
+
+
+@pytest.fixture(scope="module")
+def disable(disable):
+    return ["I"]
+
+
+@pytest.fixture(scope="module")
+def reporter(reporter):
+    return testutils.TestReporter
+
+
+@pytest.fixture
+def init_linter(linter):
+    linter.open()
+    linter.set_current_module("toto")
+    linter.file_state = FileState("toto")
+    return linter
+
+
+def test_pylint_visit_method_taken_in_account(linter):
+    class CustomChecker(checkers.BaseChecker):
+        __implements__ = interfaces.IAstroidChecker
+        name = "custom"
+        msgs = {"W9999": ("", "custom", "")}
+
+        @check_messages("custom")
+        def visit_class(self, _):
+            pass
+
+    linter.register_checker(CustomChecker(linter))
+    linter.open()
+    out = StringIO()
+    linter.set_reporter(text.TextReporter(out))
+    linter.check("abc")
+
+
+def test_enable_message(init_linter):
+    linter = init_linter
+    assert linter.is_message_enabled("W0101")
+    assert linter.is_message_enabled("W0102")
+    linter.disable("W0101", scope="package")
+    linter.disable("W0102", scope="module", line=1)
+    assert not linter.is_message_enabled("W0101")
+    assert not linter.is_message_enabled("W0102", 1)
+    linter.set_current_module("tutu")
+    assert not linter.is_message_enabled("W0101")
+    assert linter.is_message_enabled("W0102")
+    linter.enable("W0101", scope="package")
+    linter.enable("W0102", scope="module", line=1)
+    assert linter.is_message_enabled("W0101")
+    assert linter.is_message_enabled("W0102", 1)
+
+
+def test_enable_message_category(init_linter):
+    linter = init_linter
+    assert linter.is_message_enabled("W0101")
+    assert linter.is_message_enabled("C0202")
+    linter.disable("W", scope="package")
+    linter.disable("C", scope="module", line=1)
+    assert not linter.is_message_enabled("W0101")
+    assert linter.is_message_enabled("C0202")
+    assert not linter.is_message_enabled("C0202", line=1)
+    linter.set_current_module("tutu")
+    assert not linter.is_message_enabled("W0101")
+    assert linter.is_message_enabled("C0202")
+    linter.enable("W", scope="package")
+    linter.enable("C", scope="module", line=1)
+    assert linter.is_message_enabled("W0101")
+    assert linter.is_message_enabled("C0202")
+    assert linter.is_message_enabled("C0202", line=1)
+
+
+def test_message_state_scope(init_linter):
+    class FakeConfig(object):
+        confidence = ["HIGH"]
+
+    linter = init_linter
+    linter.disable("C0202")
+    assert MSG_STATE_SCOPE_CONFIG == linter.get_message_state_scope("C0202")
+    linter.disable("W0101", scope="module", line=3)
+    assert MSG_STATE_SCOPE_CONFIG == linter.get_message_state_scope("C0202")
+    assert MSG_STATE_SCOPE_MODULE == linter.get_message_state_scope("W0101", 3)
+    linter.enable("W0102", scope="module", line=3)
+    assert MSG_STATE_SCOPE_MODULE == linter.get_message_state_scope("W0102", 3)
+    linter.config = FakeConfig()
+    assert MSG_STATE_CONFIDENCE == linter.get_message_state_scope(
+        "this-is-bad", confidence=interfaces.INFERENCE
+    )
+
+
+def test_enable_message_block(init_linter):
+    linter = init_linter
+    linter.open()
+    filepath = join(REGRTEST_DATA, "func_block_disable_msg.py")
+    linter.set_current_module("func_block_disable_msg")
+    astroid = linter.get_ast(filepath, "func_block_disable_msg")
+    linter.process_tokens(tokenize_module(astroid))
+    fs = linter.file_state
+    fs.collect_block_lines(linter.msgs_store, astroid)
+    # global (module level)
+    assert linter.is_message_enabled("W0613")
+    assert linter.is_message_enabled("E1101")
+    # meth1
+    assert linter.is_message_enabled("W0613", 13)
+    # meth2
+    assert not linter.is_message_enabled("W0613", 18)
+    # meth3
+    assert not linter.is_message_enabled("E1101", 24)
+    assert linter.is_message_enabled("E1101", 26)
+    # meth4
+    assert not linter.is_message_enabled("E1101", 32)
+    assert linter.is_message_enabled("E1101", 36)
+    # meth5
+    assert not linter.is_message_enabled("E1101", 42)
+    assert not linter.is_message_enabled("E1101", 43)
+    assert linter.is_message_enabled("E1101", 46)
+    assert not linter.is_message_enabled("E1101", 49)
+    assert not linter.is_message_enabled("E1101", 51)
+    # meth6
+    assert not linter.is_message_enabled("E1101", 57)
+    assert linter.is_message_enabled("E1101", 61)
+    assert not linter.is_message_enabled("E1101", 64)
+    assert not linter.is_message_enabled("E1101", 66)
+
+    assert linter.is_message_enabled("E0602", 57)
+    assert linter.is_message_enabled("E0602", 61)
+    assert not linter.is_message_enabled("E0602", 62)
+    assert linter.is_message_enabled("E0602", 64)
+    assert linter.is_message_enabled("E0602", 66)
+    # meth7
+    assert not linter.is_message_enabled("E1101", 70)
+    assert linter.is_message_enabled("E1101", 72)
+    assert linter.is_message_enabled("E1101", 75)
+    assert linter.is_message_enabled("E1101", 77)
+
+    fs = linter.file_state
+    assert 17 == fs._suppression_mapping["W0613", 18]
+    assert 30 == fs._suppression_mapping["E1101", 33]
+    assert ("E1101", 46) not in fs._suppression_mapping
+    assert 1 == fs._suppression_mapping["C0302", 18]
+    assert 1 == fs._suppression_mapping["C0302", 50]
+    # This is tricky. While the disable in line 106 is disabling
+    # both 108 and 110, this is usually not what the user wanted.
+    # Therefore, we report the closest previous disable comment.
+    assert 106 == fs._suppression_mapping["E1101", 108]
+    assert 109 == fs._suppression_mapping["E1101", 110]
+
+
+def test_enable_by_symbol(init_linter):
+    """messages can be controlled by symbolic names.
+
+    The state is consistent across symbols and numbers.
+    """
+    linter = init_linter
+    assert linter.is_message_enabled("W0101")
+    assert linter.is_message_enabled("unreachable")
+    assert linter.is_message_enabled("W0102")
+    assert linter.is_message_enabled("dangerous-default-value")
+    linter.disable("unreachable", scope="package")
+    linter.disable("dangerous-default-value", scope="module", line=1)
+    assert not linter.is_message_enabled("W0101")
+    assert not linter.is_message_enabled("unreachable")
+    assert not linter.is_message_enabled("W0102", 1)
+    assert not linter.is_message_enabled("dangerous-default-value", 1)
+    linter.set_current_module("tutu")
+    assert not linter.is_message_enabled("W0101")
+    assert not linter.is_message_enabled("unreachable")
+    assert linter.is_message_enabled("W0102")
+    assert linter.is_message_enabled("dangerous-default-value")
+    linter.enable("unreachable", scope="package")
+    linter.enable("dangerous-default-value", scope="module", line=1)
+    assert linter.is_message_enabled("W0101")
+    assert linter.is_message_enabled("unreachable")
+    assert linter.is_message_enabled("W0102", 1)
+    assert linter.is_message_enabled("dangerous-default-value", 1)
+
+
+def test_enable_report(linter):
+    assert linter.report_is_enabled("RP0001")
+    linter.disable("RP0001")
+    assert not linter.report_is_enabled("RP0001")
+    linter.enable("RP0001")
+    assert linter.report_is_enabled("RP0001")
+
+
+def test_report_output_format_aliased(linter):
+    text.register(linter)
+    linter.set_option("output-format", "text")
+    assert linter.reporter.__class__.__name__ == "TextReporter"
+
+
+def test_set_unsupported_reporter(linter):
+    text.register(linter)
+    with pytest.raises(exceptions.InvalidReporterError):
+        linter.set_option("output-format", "missing.module.Class")
+
+
+def test_set_option_1(linter):
+    linter.set_option("disable", "C0111,W0234")
+    assert not linter.is_message_enabled("C0111")
+    assert not linter.is_message_enabled("W0234")
+    assert linter.is_message_enabled("W0113")
+    assert not linter.is_message_enabled("missing-docstring")
+    assert not linter.is_message_enabled("non-iterator-returned")
+
+
+def test_set_option_2(linter):
+    linter.set_option("disable", ("C0111", "W0234"))
+    assert not linter.is_message_enabled("C0111")
+    assert not linter.is_message_enabled("W0234")
+    assert linter.is_message_enabled("W0113")
+    assert not linter.is_message_enabled("missing-docstring")
+    assert not linter.is_message_enabled("non-iterator-returned")
+
+
+def test_enable_checkers(linter):
+    linter.disable("design")
+    assert not ("design" in [c.name for c in linter.prepare_checkers()])
+    linter.enable("design")
+    assert "design" in [c.name for c in linter.prepare_checkers()]
+
+
+def test_errors_only(linter):
+    linter.error_mode()
+    checkers = linter.prepare_checkers()
+    checker_names = {c.name for c in checkers}
+    should_not = {"design", "format", "metrics", "miscellaneous", "similarities"}
+    assert set() == should_not & checker_names
+
+
+def test_disable_similar(linter):
+    linter.set_option("disable", "RP0801")
+    linter.set_option("disable", "R0801")
+    assert not ("similarities" in [c.name for c in linter.prepare_checkers()])
+
+
+def test_disable_alot(linter):
+    """check that we disabled a lot of checkers"""
+    linter.set_option("reports", False)
+    linter.set_option("disable", "R,C,W")
+    checker_names = [c.name for c in linter.prepare_checkers()]
+    for cname in ("design", "metrics", "similarities"):
+        assert not (cname in checker_names), cname
+
+
+def test_addmessage(linter):
+    linter.set_reporter(testutils.TestReporter())
+    linter.open()
+    linter.set_current_module("0123")
+    linter.add_message("C0301", line=1, args=(1, 2))
+    linter.add_message("line-too-long", line=2, args=(3, 4))
+    assert [
+        "C:  1: Line too long (1/2)",
+        "C:  2: Line too long (3/4)",
+    ] == linter.reporter.messages
+
+
+def test_addmessage_invalid(linter):
+    linter.set_reporter(testutils.TestReporter())
+    linter.open()
+    linter.set_current_module("0123")
+
+    with pytest.raises(InvalidMessageError) as cm:
+        linter.add_message("line-too-long", args=(1, 2))
+    assert str(cm.value) == "Message C0301 must provide line, got None"
+
+    with pytest.raises(InvalidMessageError) as cm:
+        linter.add_message("line-too-long", line=2, node="fake_node", args=(1, 2))
+    assert (
+        str(cm.value)
+        == "Message C0301 must only provide line, got line=2, node=fake_node"
+    )
+
+    with pytest.raises(InvalidMessageError) as cm:
+        linter.add_message("C0321")
+    assert str(cm.value) == "Message C0321 must provide Node, got None"
+
+
+def test_load_plugin_command_line():
+    dummy_plugin_path = join(HERE, "regrtest_data", "dummy_plugin")
+    sys.path.append(dummy_plugin_path)
+
+    run = Run(
+        ["--load-plugins", "dummy_plugin", join(HERE, "regrtest_data", "empty.py")],
+        do_exit=False,
+    )
+    assert (
+        len([ch.name for ch in run.linter.get_checkers() if ch.name == "dummy_plugin"])
+        == 2
+    )
+
+    sys.path.remove(dummy_plugin_path)
+
+
+def test_load_plugin_config_file():
+    dummy_plugin_path = join(HERE, "regrtest_data", "dummy_plugin")
+    sys.path.append(dummy_plugin_path)
+    config_path = join(HERE, "regrtest_data", "dummy_plugin.rc")
+
+    run = Run(
+        ["--rcfile", config_path, join(HERE, "regrtest_data", "empty.py")],
+        do_exit=False,
+    )
+    assert (
+        len([ch.name for ch in run.linter.get_checkers() if ch.name == "dummy_plugin"])
+        == 2
+    )
+
+    sys.path.remove(dummy_plugin_path)
+
+
+def test_load_plugin_configuration():
+    dummy_plugin_path = join(HERE, "regrtest_data", "dummy_plugin")
+    sys.path.append(dummy_plugin_path)
+
+    run = Run(
+        [
+            "--load-plugins",
+            "dummy_conf_plugin",
+            "--ignore",
+            "foo,bar",
+            join(HERE, "regrtest_data", "empty.py"),
+        ],
+        do_exit=False,
+    )
+    assert run.linter.config.black_list == ["foo", "bar", "bin"]
+
+
+def test_init_hooks_called_before_load_plugins():
+    with pytest.raises(RuntimeError):
+        Run(["--load-plugins", "unexistant", "--init-hook", "raise RuntimeError"])
+    with pytest.raises(RuntimeError):
+        Run(["--init-hook", "raise RuntimeError", "--load-plugins", "unexistant"])
+
+
+def test_analyze_explicit_script(linter):
+    linter.set_reporter(testutils.TestReporter())
+    linter.check(os.path.join(os.path.dirname(__file__), "data", "ascript"))
+    assert ["C:  2: Line too long (175/100)"] == linter.reporter.messages
+
+
+def test_python3_checker_disabled(linter):
+    checker_names = [c.name for c in linter.prepare_checkers()]
+    assert "python3" not in checker_names
+
+    linter.set_option("enable", "python3")
+    checker_names = [c.name for c in linter.prepare_checkers()]
+    assert "python3" in checker_names
+
+
+def test_full_documentation(linter):
+    out = StringIO()
+    linter.print_full_documentation(out)
+    output = out.getvalue()
+    # A few spot checks only
+    for re_str in [
+        # autogenerated text
+        "^Pylint global options and switches$",
+        "Verbatim name of the checker is ``python3``",
+        # messages
+        "^:old-octal-literal \\(E1608\\):",
+        # options
+        "^:dummy-variables-rgx:",
+    ]:
+        regexp = re.compile(re_str, re.MULTILINE)
+        assert re.search(regexp, output)
+
+
+@pytest.fixture
+def pop_pylintrc():
+    os.environ.pop("PYLINTRC", None)
+
+
+@pytest.mark.usefixtures("pop_pylintrc")
+def test_pylint_home():
+    uhome = os.path.expanduser("~")
+    if uhome == "~":
+        expected = ".pylint.d"
+    else:
+        expected = os.path.join(uhome, ".pylint.d")
+    assert config.PYLINT_HOME == expected
+
+    try:
+        pylintd = join(tempfile.gettempdir(), ".pylint.d")
+        os.environ["PYLINTHOME"] = pylintd
+        try:
+            reload(config)
+            assert config.PYLINT_HOME == pylintd
+        finally:
+            try:
+                os.remove(pylintd)
+            except:
+                pass
+    finally:
+        del os.environ["PYLINTHOME"]
+
+
+@pytest.mark.skipif(
+    PYPY_VERSION_INFO,
+    reason="TOX runs this test from within the repo and finds "
+    "the project's pylintrc.",
+)
+@pytest.mark.usefixtures("pop_pylintrc")
+def test_pylintrc():
+    with fake_home():
+        current_dir = getcwd()
+        chdir(os.path.dirname(os.path.abspath(sys.executable)))
+        try:
+            assert config.find_pylintrc() is None
+            os.environ["PYLINTRC"] = join(tempfile.gettempdir(), ".pylintrc")
+            assert config.find_pylintrc() is None
+            os.environ["PYLINTRC"] = "."
+            assert config.find_pylintrc() is None
+        finally:
+            chdir(current_dir)
+            reload(config)
+
+
+@pytest.mark.usefixtures("pop_pylintrc")
+def test_pylintrc_parentdir():
+    with tempdir() as chroot:
+
+        create_files(
+            [
+                "a/pylintrc",
+                "a/b/__init__.py",
+                "a/b/pylintrc",
+                "a/b/c/__init__.py",
+                "a/b/c/d/__init__.py",
+                "a/b/c/d/e/.pylintrc",
+            ]
+        )
+        with fake_home():
+            assert config.find_pylintrc() is None
+        results = {
+            "a": join(chroot, "a", "pylintrc"),
+            "a/b": join(chroot, "a", "b", "pylintrc"),
+            "a/b/c": join(chroot, "a", "b", "pylintrc"),
+            "a/b/c/d": join(chroot, "a", "b", "pylintrc"),
+            "a/b/c/d/e": join(chroot, "a", "b", "c", "d", "e", ".pylintrc"),
+        }
+        for basedir, expected in results.items():
+            os.chdir(join(chroot, basedir))
+            assert config.find_pylintrc() == expected
+
+
+@pytest.mark.usefixtures("pop_pylintrc")
+def test_pylintrc_parentdir_no_package():
+    with tempdir() as chroot:
+        with fake_home():
+            create_files(["a/pylintrc", "a/b/pylintrc", "a/b/c/d/__init__.py"])
+            assert config.find_pylintrc() is None
+            results = {
+                "a": join(chroot, "a", "pylintrc"),
+                "a/b": join(chroot, "a", "b", "pylintrc"),
+                "a/b/c": None,
+                "a/b/c/d": None,
+            }
+            for basedir, expected in results.items():
+                os.chdir(join(chroot, basedir))
+                assert config.find_pylintrc() == expected
+
+
+class TestPreprocessOptions(object):
+    def _callback(self, name, value):
+        self.args.append((name, value))
+
+    def test_value_equal(self):
+        self.args = []
+        preprocess_options(
+            ["--foo", "--bar=baz", "--qu=ux"],
+            {"foo": (self._callback, False), "qu": (self._callback, True)},
+        )
+        assert [("foo", None), ("qu", "ux")] == self.args
+
+    def test_value_space(self):
+        self.args = []
+        preprocess_options(["--qu", "ux"], {"qu": (self._callback, True)})
+        assert [("qu", "ux")] == self.args
+
+    def test_error_missing_expected_value(self):
+        with pytest.raises(ArgumentPreprocessingError):
+            preprocess_options(["--foo", "--bar", "--qu=ux"], {"bar": (None, True)})
+        with pytest.raises(ArgumentPreprocessingError):
+            preprocess_options(["--foo", "--bar"], {"bar": (None, True)})
+
+    def test_error_unexpected_value(self):
+        with pytest.raises(ArgumentPreprocessingError):
+            preprocess_options(
+                ["--foo", "--bar=spam", "--qu=ux"], {"bar": (None, False)}
+            )
+
+
+def test_custom_should_analyze_file():
+    """Check that we can write custom should_analyze_file that work
+    even for arguments.
+    """
+
+    class CustomPyLinter(PyLinter):
+        def should_analyze_file(self, modname, path, is_argument=False):
+            if os.path.basename(path) == "wrong.py":
+                return False
+
+            return super(CustomPyLinter, self).should_analyze_file(
+                modname, path, is_argument=is_argument
+            )
+
+    package_dir = os.path.join(HERE, "regrtest_data", "bad_package")
+    wrong_file = os.path.join(package_dir, "wrong.py")
+
+    for jobs in [1, 2]:
+        reporter = testutils.TestReporter()
+        linter = CustomPyLinter()
+        linter.config.jobs = jobs
+        linter.config.persistent = 0
+        linter.open()
+        linter.set_reporter(reporter)
+
+        try:
+            sys.path.append(os.path.dirname(package_dir))
+            linter.check([package_dir, wrong_file])
+        finally:
+            sys.path.pop()
+
+        messages = reporter.messages
+        assert len(messages) == 1
+        assert "invalid syntax" in messages[0]
+
+
+def test_filename_with__init__(init_linter):
+    # This tracks a regression where a file whose name ends in __init__.py,
+    # such as flycheck__init__.py, would accidentally lead to linting the
+    # entire containing directory.
+    reporter = testutils.TestReporter()
+    linter = init_linter
+    linter.open()
+    linter.set_reporter(reporter)
+    filepath = join(INPUTDIR, "not__init__.py")
+    linter.check([filepath])
+    messages = reporter.messages
+    assert len(messages) == 0
diff --git a/tests/unittest_pyreverse_diadefs.py b/tests/unittest_pyreverse_diadefs.py
new file mode 100644
index 000000000..0659a5b11
--- /dev/null
+++ b/tests/unittest_pyreverse_diadefs.py
@@ -0,0 +1,175 @@
+# Copyright (c) 2008-2010, 2013 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""
+unit test for the extensions.diadefslib modules
+"""
+
+import astroid
+import pytest
+
+from pylint.pyreverse.diadefslib import *
+from pylint.pyreverse.inspector import Linker
+from unittest_pyreverse_writer import Config, get_project
+
+
+def _process_classes(classes):
+    """extract class names of a list"""
+    return sorted([(isinstance(c.node, astroid.ClassDef), c.title) for c in classes])
+
+
+def _process_relations(relations):
+    """extract relation indices from a relation list"""
+    result = []
+    for rel_type, rels in relations.items():
+        for rel in rels:
+            result.append((rel_type, rel.from_object.title, rel.to_object.title))
+    result.sort()
+    return result
+
+
+@pytest.fixture
+def HANDLER():
+    return DiadefsHandler(Config())
+
+
+@pytest.fixture(scope="module")
+def PROJECT():
+    return get_project("data")
+
+
+def test_option_values(HANDLER, PROJECT):
+    """test for ancestor, associated and module options"""
+    df_h = DiaDefGenerator(Linker(PROJECT), HANDLER)
+    cl_config = Config()
+    cl_config.classes = ["Specialization"]
+    cl_h = DiaDefGenerator(Linker(PROJECT), DiadefsHandler(cl_config))
+    assert (0, 0) == df_h._get_levels()
+    assert False == df_h.module_names
+    assert (-1, -1) == cl_h._get_levels()
+    assert True == cl_h.module_names
+    for hndl in [df_h, cl_h]:
+        hndl.config.all_ancestors = True
+        hndl.config.all_associated = True
+        hndl.config.module_names = True
+        hndl._set_default_options()
+        assert (-1, -1) == hndl._get_levels()
+        assert True == hndl.module_names
+    handler = DiadefsHandler(Config())
+    df_h = DiaDefGenerator(Linker(PROJECT), handler)
+    cl_config = Config()
+    cl_config.classes = ["Specialization"]
+    cl_h = DiaDefGenerator(Linker(PROJECT), DiadefsHandler(cl_config))
+    for hndl in [df_h, cl_h]:
+        hndl.config.show_ancestors = 2
+        hndl.config.show_associated = 1
+        hndl.config.module_names = False
+        hndl._set_default_options()
+        assert (2, 1) == hndl._get_levels()
+        assert False == hndl.module_names
+
+    # def test_default_values():
+    """test efault values for package or class diagrams"""
+    # TODO : should test difference between default values for package
+    # or class diagrams
+
+
+class TestDefaultDiadefGenerator(object):
+    def test_known_values1(self, HANDLER, PROJECT):
+        dd = DefaultDiadefGenerator(Linker(PROJECT), HANDLER).visit(PROJECT)
+        assert len(dd) == 2
+        keys = [d.TYPE for d in dd]
+        assert keys == ["package", "class"]
+        pd = dd[0]
+        assert pd.title == "packages No Name"
+        modules = sorted(
+            [(isinstance(m.node, astroid.Module), m.title) for m in pd.objects]
+        )
+        assert modules == [
+            (True, "data"),
+            (True, "data.clientmodule_test"),
+            (True, "data.suppliermodule_test"),
+        ]
+        cd = dd[1]
+        assert cd.title == "classes No Name"
+        classes = _process_classes(cd.objects)
+        assert classes == [
+            (True, "Ancestor"),
+            (True, "DoNothing"),
+            (True, "Interface"),
+            (True, "Specialization"),
+        ]
+
+    _should_rels = [
+        ("association", "DoNothing", "Ancestor"),
+        ("association", "DoNothing", "Specialization"),
+        ("implements", "Ancestor", "Interface"),
+        ("specialization", "Specialization", "Ancestor"),
+    ]
+
+    def test_exctract_relations(self, HANDLER, PROJECT):
+        """test extract_relations between classes"""
+        cd = DefaultDiadefGenerator(Linker(PROJECT), HANDLER).visit(PROJECT)[1]
+        cd.extract_relationships()
+        relations = _process_relations(cd.relationships)
+        assert relations == self._should_rels
+
+    def test_functional_relation_extraction(self):
+        """functional test of relations extraction;
+        different classes possibly in different modules"""
+        # XXX should be catching pyreverse environnement problem but doesn't
+        # pyreverse doesn't extracts the relations but this test ok
+        project = get_project("data")
+        handler = DiadefsHandler(Config())
+        diadefs = handler.get_diadefs(project, Linker(project, tag=True))
+        cd = diadefs[1]
+        relations = _process_relations(cd.relationships)
+        assert relations == self._should_rels
+
+    def test_known_values2(self, HANDLER):
+        project = get_project("data.clientmodule_test")
+        dd = DefaultDiadefGenerator(Linker(project), HANDLER).visit(project)
+        assert len(dd) == 1
+        keys = [d.TYPE for d in dd]
+        assert keys == ["class"]
+        cd = dd[0]
+        assert cd.title == "classes No Name"
+        classes = _process_classes(cd.objects)
+        assert classes == [(True, "Ancestor"), (True, "Specialization")]
+
+
+def test_known_values1(HANDLER, PROJECT):
+    HANDLER.config.classes = ["Specialization"]
+    cdg = ClassDiadefGenerator(Linker(PROJECT), HANDLER)
+    special = "data.clientmodule_test.Specialization"
+    cd = cdg.class_diagram(PROJECT, special)
+    assert cd.title == special
+    classes = _process_classes(cd.objects)
+    assert classes == [
+        (True, "data.clientmodule_test.Ancestor"),
+        (True, special),
+        (True, "data.suppliermodule_test.DoNothing"),
+    ]
+
+
+def test_known_values2(HANDLER, PROJECT):
+    HANDLER.config.classes = ["Specialization"]
+    HANDLER.config.module_names = False
+    cd = ClassDiadefGenerator(Linker(PROJECT), HANDLER).class_diagram(
+        PROJECT, "data.clientmodule_test.Specialization"
+    )
+    assert cd.title == "data.clientmodule_test.Specialization"
+    classes = _process_classes(cd.objects)
+    assert classes == [
+        (True, "Ancestor"),
+        (True, "DoNothing"),
+        (True, "Specialization"),
+    ]
diff --git a/tests/unittest_pyreverse_inspector.py b/tests/unittest_pyreverse_inspector.py
new file mode 100644
index 000000000..d94638c3c
--- /dev/null
+++ b/tests/unittest_pyreverse_inspector.py
@@ -0,0 +1,123 @@
+# Copyright (c) 2015-2018 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""
+ for the visitors.diadefs module
+"""
+import os
+
+import astroid
+import pytest
+from astroid import bases, nodes
+
+from pylint.pyreverse import inspector
+from unittest_pyreverse_writer import get_project
+
+
+@pytest.fixture
+def project():
+    project = get_project("data", "data")
+    linker = inspector.Linker(project)
+    linker.visit(project)
+    return project
+
+
+def test_class_implements(project):
+    klass = project.get_module("data.clientmodule_test")["Ancestor"]
+    assert hasattr(klass, "implements")
+    assert len(klass.implements) == 1
+    assert isinstance(klass.implements[0], nodes.ClassDef)
+    assert klass.implements[0].name == "Interface"
+
+
+def test_class_implements_specialization(project):
+    klass = project.get_module("data.clientmodule_test")["Specialization"]
+    assert hasattr(klass, "implements")
+    assert len(klass.implements) == 0
+
+
+def test_locals_assignment_resolution(project):
+    klass = project.get_module("data.clientmodule_test")["Specialization"]
+    assert hasattr(klass, "locals_type")
+    type_dict = klass.locals_type
+    assert len(type_dict) == 2
+    keys = sorted(type_dict.keys())
+    assert keys == ["TYPE", "top"]
+    assert len(type_dict["TYPE"]) == 1
+    assert type_dict["TYPE"][0].value == "final class"
+    assert len(type_dict["top"]) == 1
+    assert type_dict["top"][0].value == "class"
+
+
+def test_instance_attrs_resolution(project):
+    klass = project.get_module("data.clientmodule_test")["Specialization"]
+    assert hasattr(klass, "instance_attrs_type")
+    type_dict = klass.instance_attrs_type
+    assert len(type_dict) == 2
+    keys = sorted(type_dict.keys())
+    assert keys == ["_id", "relation"]
+    assert isinstance(type_dict["relation"][0], bases.Instance), type_dict["relation"]
+    assert type_dict["relation"][0].name == "DoNothing"
+    assert type_dict["_id"][0] is astroid.Uninferable
+
+
+def test_concat_interfaces():
+    cls = astroid.extract_node(
+        '''
+        class IMachin: pass
+
+        class Correct2:
+            """docstring"""
+            __implements__ = (IMachin,)
+
+        class BadArgument:
+            """docstring"""
+            __implements__ = (IMachin,)
+
+        class InterfaceCanNowBeFound: #@
+            """docstring"""
+            __implements__ = BadArgument.__implements__ + Correct2.__implements__
+    '''
+    )
+    interfaces = inspector.interfaces(cls)
+    assert [i.name for i in interfaces] == ["IMachin"]
+
+
+def test_interfaces():
+    module = astroid.parse(
+        """
+    class Interface(object): pass
+    class MyIFace(Interface): pass
+    class AnotherIFace(Interface): pass
+    class Concrete0(object):
+        __implements__ = MyIFace
+    class Concrete1:
+        __implements__ = (MyIFace, AnotherIFace)
+    class Concrete2:
+        __implements__ = (MyIFace, AnotherIFace)
+    class Concrete23(Concrete1): pass
+    """
+    )
+
+    for klass, interfaces in (
+        ("Concrete0", ["MyIFace"]),
+        ("Concrete1", ["MyIFace", "AnotherIFace"]),
+        ("Concrete2", ["MyIFace", "AnotherIFace"]),
+        ("Concrete23", ["MyIFace", "AnotherIFace"]),
+    ):
+        klass = module[klass]
+        assert [i.name for i in inspector.interfaces(klass)] == interfaces
+
+
+def test_from_directory(project):
+    expected = os.path.join("tests", "data", "__init__.py")
+    assert project.name == "data"
+    assert project.path.endswith(expected)
+
+
+def test_project_node(project):
+    expected = ["data", "data.clientmodule_test", "data.suppliermodule_test"]
+    assert sorted(project.keys()) == expected
diff --git a/tests/unittest_pyreverse_writer.py b/tests/unittest_pyreverse_writer.py
new file mode 100644
index 000000000..01654024a
--- /dev/null
+++ b/tests/unittest_pyreverse_writer.py
@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2008, 2010, 2013 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Ville Skyttä <ville.skytta@upcloud.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""
+unit test for visitors.diadefs and extensions.diadefslib modules
+"""
+
+
+import codecs
+import os
+from difflib import unified_diff
+
+import pytest
+
+from pylint.pyreverse.diadefslib import DefaultDiadefGenerator, DiadefsHandler
+from pylint.pyreverse.inspector import Linker, project_from_files
+from pylint.pyreverse.utils import get_visibility
+from pylint.pyreverse.writer import DotWriter
+
+_DEFAULTS = {
+    "all_ancestors": None,
+    "show_associated": None,
+    "module_names": None,
+    "output_format": "dot",
+    "diadefs_file": None,
+    "quiet": 0,
+    "show_ancestors": None,
+    "classes": (),
+    "all_associated": None,
+    "mode": "PUB_ONLY",
+    "show_builtin": False,
+    "only_classnames": False,
+}
+
+
+class Config(object):
+    """config object for tests"""
+
+    def __init__(self):
+        for attr, value in _DEFAULTS.items():
+            setattr(self, attr, value)
+
+
+def _file_lines(path):
+    # we don't care about the actual encoding, but python3 forces us to pick one
+    with codecs.open(path, encoding="latin1") as stream:
+        lines = [
+            line.strip()
+            for line in stream.readlines()
+            if (
+                line.find("squeleton generated by ") == -1
+                and not line.startswith('__revision__ = "$Id:')
+            )
+        ]
+    return [line for line in lines if line]
+
+
+def get_project(module, name="No Name"):
+    """return an astroid project representation"""
+
+    def _astroid_wrapper(func, modname):
+        return func(modname)
+
+    return project_from_files([module], _astroid_wrapper, project_name=name)
+
+
+DOT_FILES = ["packages_No_Name.dot", "classes_No_Name.dot"]
+
+
+@pytest.fixture(scope="module")
+def setup():
+    project = get_project(os.path.join(os.path.dirname(__file__), "data"))
+    linker = Linker(project)
+    CONFIG = Config()
+    handler = DiadefsHandler(CONFIG)
+    dd = DefaultDiadefGenerator(linker, handler).visit(project)
+    for diagram in dd:
+        diagram.extract_relationships()
+    writer = DotWriter(CONFIG)
+    writer.write(dd)
+    yield
+    for fname in DOT_FILES:
+        try:
+            os.remove(fname)
+        except:
+            continue
+
+
+@pytest.mark.usefixtures("setup")
+@pytest.mark.parametrize("generated_file", DOT_FILES)
+def test_dot_files(generated_file):
+    expected_file = os.path.join(os.path.dirname(__file__), "data", generated_file)
+    generated = _file_lines(generated_file)
+    expected = _file_lines(expected_file)
+    generated = "\n".join(generated)
+    expected = "\n".join(expected)
+    files = "\n *** expected : %s, generated : %s \n" % (expected_file, generated_file)
+    assert expected == generated, "%s%s" % (
+        files,
+        "\n".join(
+            line for line in unified_diff(expected.splitlines(), generated.splitlines())
+        ),
+    )
+    os.remove(generated_file)
+
+
+@pytest.mark.parametrize(
+    "names, expected",
+    [
+        (["__reduce_ex__", "__setattr__"], "special"),
+        (["__g_", "____dsf", "__23_9"], "private"),
+        (["simple"], "public"),
+        (
+            ["_", "__", "___", "____", "_____", "___e__", "_nextsimple", "_filter_it_"],
+            "protected",
+        ),
+    ],
+)
+def test_get_visibility(names, expected):
+    for name in names:
+        got = get_visibility(name)
+        assert got == expected, "got %s instead of %s for value %s" % (
+            got,
+            expected,
+            name,
+        )
diff --git a/tests/unittest_reporters_json.py b/tests/unittest_reporters_json.py
new file mode 100644
index 000000000..19a215acf
--- /dev/null
+++ b/tests/unittest_reporters_json.py
@@ -0,0 +1,52 @@
+# Copyright (c) 2014 Vlad Temian <vladtemian@gmail.com>
+# Copyright (c) 2015-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2017 guillaume2 <guillaume.peillex@gmail.col>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+"""Test for the JSON reporter."""
+
+import json
+from io import StringIO
+
+from pylint import checkers
+from pylint.lint import PyLinter
+from pylint.reporters import JSONReporter
+
+
+def test_simple_json_output():
+    output = StringIO()
+
+    reporter = JSONReporter()
+    linter = PyLinter(reporter=reporter)
+    checkers.initialize(linter)
+
+    linter.config.persistent = 0
+    linter.reporter.set_output(output)
+    linter.open()
+    linter.set_current_module("0123")
+    linter.add_message("line-too-long", line=1, args=(1, 2))
+
+    # we call this method because we didn't actually run the checkers
+    reporter.display_messages(None)
+
+    expected_result = [
+        [
+            ("column", 0),
+            ("line", 1),
+            ("message", "Line too long (1/2)"),
+            ("message-id", "C0301"),
+            ("module", "0123"),
+            ("obj", ""),
+            ("path", "0123"),
+            ("symbol", "line-too-long"),
+            ("type", "convention"),
+        ]
+    ]
+    report_result = json.loads(output.getvalue())
+    report_result = [sorted(report_result[0].items(), key=lambda item: item[0])]
+    assert report_result == expected_result
diff --git a/tests/unittest_reporting.py b/tests/unittest_reporting.py
new file mode 100644
index 000000000..a374e1e3e
--- /dev/null
+++ b/tests/unittest_reporting.py
@@ -0,0 +1,81 @@
+# Copyright (c) 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014-2017 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2014 Calin Don <calin.don@gmail.com>
+# Copyright (c) 2014 Google, Inc.
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016-2017 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+import warnings
+from io import StringIO
+
+import pytest
+
+from pylint import checkers
+from pylint.lint import PyLinter
+from pylint.reporters.text import ParseableTextReporter, TextReporter
+
+
+@pytest.fixture(scope="module")
+def reporter(reporter):
+    return TextReporter
+
+
+@pytest.fixture(scope="module")
+def disable(disable):
+    return ["I"]
+
+
+def test_template_option(linter):
+    output = StringIO()
+    linter.reporter.set_output(output)
+    linter.set_option("msg-template", "{msg_id}:{line:03d}")
+    linter.open()
+    linter.set_current_module("0123")
+    linter.add_message("C0301", line=1, args=(1, 2))
+    linter.add_message("line-too-long", line=2, args=(3, 4))
+    assert (
+        output.getvalue() == "************* Module 0123\n" "C0301:001\n" "C0301:002\n"
+    )
+
+
+def test_parseable_output_deprecated():
+    with warnings.catch_warnings(record=True) as cm:
+        warnings.simplefilter("always")
+        ParseableTextReporter()
+
+    assert len(cm) == 1
+    assert isinstance(cm[0].message, DeprecationWarning)
+
+
+def test_parseable_output_regression():
+    output = StringIO()
+    with warnings.catch_warnings(record=True):
+        linter = PyLinter(reporter=ParseableTextReporter())
+
+    checkers.initialize(linter)
+    linter.config.persistent = 0
+    linter.reporter.set_output(output)
+    linter.set_option("output-format", "parseable")
+    linter.open()
+    linter.set_current_module("0123")
+    linter.add_message("line-too-long", line=1, args=(1, 2))
+    assert (
+        output.getvalue() == "************* Module 0123\n"
+        "0123:1: [C0301(line-too-long), ] "
+        "Line too long (1/2)\n"
+    )
+
+
+def test_display_results_is_renamed():
+    class CustomReporter(TextReporter):
+        def _display(self, layout):
+            return None
+
+    reporter = CustomReporter()
+    with pytest.raises(AttributeError):
+        reporter.display_results
diff --git a/tests/utils/unittest_ast_walker.py b/tests/utils/unittest_ast_walker.py
new file mode 100644
index 000000000..b8fb78eac
--- /dev/null
+++ b/tests/utils/unittest_ast_walker.py
@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+import warnings
+
+import astroid
+
+from pylint.checkers.utils import check_messages
+from pylint.utils import ASTWalker
+
+
+class TestASTWalker(object):
+    class MockLinter(object):
+        def __init__(self, msgs):
+            self._msgs = msgs
+
+        def is_message_enabled(self, msgid):
+            return self._msgs.get(msgid, True)
+
+    class Checker(object):
+        def __init__(self):
+            self.called = set()
+
+        @check_messages("first-message")
+        def visit_module(self, module):
+            self.called.add("module")
+
+        @check_messages("second-message")
+        def visit_call(self, module):
+            raise NotImplementedError
+
+        @check_messages("second-message", "third-message")
+        def visit_assignname(self, module):
+            self.called.add("assignname")
+
+        @check_messages("second-message")
+        def leave_assignname(self, module):
+            raise NotImplementedError
+
+    def test_check_messages(self):
+        linter = self.MockLinter(
+            {"first-message": True, "second-message": False, "third-message": True}
+        )
+        walker = ASTWalker(linter)
+        checker = self.Checker()
+        walker.add_checker(checker)
+        walker.walk(astroid.parse("x = func()"))
+        assert {"module", "assignname"} == checker.called
+
+    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 = ASTWalker(linter)
+        checker = Checker()
+        walker.add_checker(checker)
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter("always")
+            walker.walk(astroid.parse("x = 1"))
+
+            assert not checker.called
diff --git a/tests/utils/unittest_utils.py b/tests/utils/unittest_utils.py
new file mode 100644
index 000000000..a009391de
--- /dev/null
+++ b/tests/utils/unittest_utils.py
@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2013-2014 Google, Inc.
+# Copyright (c) 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
+# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
+# Copyright (c) 2015-2018 Claudiu Popa <pcmanticore@gmail.com>
+# Copyright (c) 2015 Aru Sahni <arusahni@gmail.com>
+# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
+# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
+# Copyright (c) 2016 Glenn Matthews <glenn@e-dad.net>
+# Copyright (c) 2017-2018 Anthony Sottile <asottile@umich.edu>
+# Copyright (c) 2017 Pierre Sassoulas <pierre.sassoulas@cea.fr>
+# Copyright (c) 2017 ttenhoeve-aa <ttenhoeve@appannie.com>
+# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
+# Copyright (c) 2018 Pierre Sassoulas <pierre.sassoulas@wisebim.fr>
+
+# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
+
+import io
+import re
+
+from pylint.utils import utils
+
+
+def test__basename_in_blacklist_re_match():
+    patterns = [re.compile(".*enchilada.*"), re.compile("unittest_.*")]
+    assert utils._basename_in_blacklist_re("unittest_utils.py", patterns)
+    assert utils._basename_in_blacklist_re("cheese_enchiladas.xml", patterns)
+
+
+def test__basename_in_blacklist_re_nomatch():
+    patterns = [re.compile(".*enchilada.*"), re.compile("unittest_.*")]
+    assert not utils._basename_in_blacklist_re("test_utils.py", patterns)
+    assert not utils._basename_in_blacklist_re("enchilad.py", patterns)
+
+
+def test_decoding_stream_unknown_encoding():
+    """decoding_stream should fall back to *some* decoding when given an
+    unknown encoding.
+    """
+    binary_io = io.BytesIO(b"foo\nbar")
+    stream = utils.decoding_stream(binary_io, "garbage-encoding")
+    # should still act like a StreamReader
+    ret = stream.readlines()
+    assert ret == ["foo\n", "bar"]
+
+
+def test_decoding_stream_known_encoding():
+    binary_io = io.BytesIO("€".encode("cp1252"))
+    stream = utils.decoding_stream(binary_io, "cp1252")
+    assert stream.read() == "€"