tptimer/env/lib/python2.7/site-packages/pylint/test/functional/arguments_differ.py

211 lines
3.7 KiB
Python

"""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
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