def test_staticmethod(self): class Foo(object): @staticmethod def foo(): pass self.assertFalse(__unit__.is_method(Foo.foo))
def test_classmethod__of_instance(self): class Foo(object): @classmethod def foo(cls): pass self.assertTrue(__unit__.is_method(Foo().foo))
def test_regular_method_attached_to_class__of_instance(self): class Foo(object): pass def foo(self): pass Foo.foo = foo self.assertTrue(__unit__.is_method(Foo().foo))
def test_function_attached_to_object(self): class Foo(object): pass def foo(self): pass obj = Foo() obj.foo = foo self.assertTrue(__unit__.is_method(obj.foo))
def test_classmethod_attached_to_class(self): class Foo(object): pass @classmethod def foo(cls): pass Foo.foo = foo self.assertTrue(__unit__.is_method(Foo.foo))
def test_regular_method_attached_to_class__of_instance(self): class Foo(object): pass def foo(self): pass Foo.foo = foo self.assertTrue(__unit__.is_method(Foo().foo))
def test_function_attached_to_object(self): class Foo(object): pass def foo(self): pass obj = Foo() obj.foo = foo self.assertTrue(__unit__.is_method(obj.foo))
def _validate_method_decoration(meta, class_): """Validate the usage of ``@override`` and ``@final`` modifiers on methods of the given ``class_``. """ # TODO(xion): employ some code inspection tricks to serve ClassErrors # as if they were thrown at the offending class's/method's definition super_mro = class_.__mro__[1:] own_methods = ((name, member) for name, member in class_.__dict__.items() if is_method(member)) # check that ``@override`` modifier is present where it should be # and absent where it shouldn't (e.g. ``@final`` methods) for name, method in own_methods: shadowed_method, base_class = next( ((getattr(base, name), base) for base in super_mro if hasattr(base, name)), (None, None)) if meta._is_override(method): # ``@override`` is legal only when the method actually shadows # a method from a superclass, and that metod is not ``@final`` if not shadowed_method: raise ClassError("unnecessary @override on %s.%s" % (class_.__name__, name), class_=class_) if meta._is_final(shadowed_method): raise ClassError( "illegal @override on a @final method %s.%s" % (base_class.__name__, name), class_=class_) # if @override had parameter supplied, verify if it was # the same class as the base of shadowed method override_base = meta._get_override_base(method) if override_base and base_class is not override_base: if is_class(override_base): raise ClassError( "incorrect override base: expected %s, got %s" % (base_class.__name__, override_base.__name__)) else: raise ClassError( "invalid override base specified: %s" % (override_base, )) setattr(class_, name, method.method) else: if shadowed_method and name not in meta.OVERRIDE_EXEMPTIONS: if meta._is_final(shadowed_method): msg = "%s.%s is hiding a @final method %s.%s" % ( class_.__name__, name, base_class.__name__, name) else: msg = ("overridden method %s.%s " "must be marked with @override" % (class_.__name__, name)) raise ClassError(msg, class_=class_)
def test_classmethod_attached_to_class(self): class Foo(object): pass @classmethod def foo(cls): pass Foo.foo = foo self.assertTrue(__unit__.is_method(Foo.foo))
def final(arg): """Mark a class or method as _final_. Final classes are those that end the inheritance chain, i.e. forbid further subclassing. A final class can thus be only instantiated, not inherited from. Similarly, methods marked as final in a superclass cannot be overridden in any of the subclasses. .. note:: Final method itself can also be (in fact, it usually is) an overridden method from a superclass. In those cases, it's recommended to place @\ :func:`final` modifier before @\ :func:`override` for clarity:: class Foo(Base): @final @override def florb(self): super(Foo, self).florb() # ... .. versionadded:: 0.0.3 Now applicable to methods in addition to classes """ if inspect.isclass(arg): if not isinstance(arg, ObjectMetaclass): raise ValueError("@final can only be applied to a class " "that is a subclass of Object") elif not is_method(arg): raise TypeError("@final can only be applied to classes or methods") method = arg.method if isinstance(arg, _WrappedMethod) else arg method.__final__ = True return arg
def test_some_object(self): self.assertFalse(__unit__.is_method(object()))
def test_lambda(self): foo = lambda: None self.assertFalse(__unit__.is_method(foo))
def test_regular_method__of_instance(self): class Foo(object): def foo(self): pass self.assertTrue(__unit__.is_method(Foo().foo))
def test_regular_function(self): def foo(): pass self.assertFalse(__unit__.is_method(foo))
def test_regular_function(self): def foo(): pass self.assertFalse(__unit__.is_method(foo))
def test_some_object(self): self.assertFalse(__unit__.is_method(object()))
def test_lambda(self): foo = lambda: None self.assertFalse(__unit__.is_method(foo))
def test_none(self): self.assertFalse(__unit__.is_method(None))
def test_none(self): self.assertFalse(__unit__.is_method(None))
def test_staticmethod(self): class Foo(object): @staticmethod def foo(): pass self.assertFalse(__unit__.is_method(Foo.foo))
def test_classmethod__of_instance(self): class Foo(object): @classmethod def foo(cls): pass self.assertTrue(__unit__.is_method(Foo().foo))
def test_regular_method__of_instance(self): class Foo(object): def foo(self): pass self.assertTrue(__unit__.is_method(Foo().foo))