def verify(*vargs, **vkwargs):
    """
    Return the decorator which verifies the *args and **kwargs

    @param a_caller: the entity which acquire the verification.
    @type a_caller: any which have __name__ attribute.

    @rtype: decorator
    """
    for var in vargs:
        if not isinstance(var, Var):
            raise TypeError("verify: expected Var or subclass of Var, "
                            "but received '%s' with type %s." %
                            (var, type(var).__name__))
    for (key, var) in vkwargs.iteritems():
        if not isinstance(var, Var):
            raise TypeError("verify: expected Var %s or subclass of Var, "
                            "but received '%s' with type %s." %
                            (key, var, type(var).__name__))
    if ENABLED:
        def decorator(f):
            """
            Decorator which verify the count and types of received arguments.
            """
            @functools.wraps(f)
            def wrapper(*args, **kwargs):
                if len(args) != len(vargs):
                    raise TypeError("%s: count of expected arguments (%s) and "
                                    "count of received arguments (%s) is different"
                                    % (f.__name__, len(vargs), len(args)))
                for (expected, received) in zip(vargs, args):
                    expected.verify(f, received)
                kw_expected= set(vkwargs.iterkeys())
                kw_received= set(kwargs.iterkeys())
                kw_verify=   kw_expected.intersection(kw_received)
                for name in kw_verify:
                    vkwargs[name].verify(f, kwargs[name])
                print "args=" + str(args)
                print "kwargs=" + str(kwargs)
                return f(*args, **kwargs)
            return wrapper
    else:
        def decorator(f):
            return f
    return decorator

def verify_method(*vargs, **vkwargs):
    vargs= tuple([Proxy()] + list(vargs))
    return verify(*vargs, **vkwargs)