def _verify_special_methods(self, someobj):
        someobj_special_methods = self._fetch_special_methods(someobj)
        our_special_methods = self._fetch_special_methods(self.reference_obj)

        missing = set(our_special_methods).difference(set(someobj_special_methods))
        if missing:
            # someobj is lacking some method we need
            raise SignatureVerificationError, "%s lacks methods: %s" % (someobj, missing)

        for name, method in our_special_methods.items():
            if not is_signature_compatible(method, someobj_special_methods[name]):
                raise SignatureVerificationError, "%s signature for %s is incompatible" % (someobj, method)

 def test_two_fixed_args_incompatible_three_args_varargs(self):
     self.assertEquals(False, is_signature_compatible(two_arg_callable1, three_args_varargs_callable))

 def test_kwargs_compatible_with_optarg_kwargs(self):
     self.assertEquals(True, is_signature_compatible(all_kwargs_callable, optarg_kwargs_callable))

 def test_arg_optarg_kwargs_callable_compatible_with_mixed_everything_callable(self):
     self.assertEquals(True, is_signature_compatible(arg_optarg_kwargs_callable, mixed_everything_callable))

 def test_vararg_kwargs_incompatible_with_everything_but_itself(self):
     everything_but_varargs_kwargs_callable = filter(lambda x: x.func_name != "varargs_kwargs_callable", everything)
     for func in everything_but_varargs_kwargs_callable:
         self.assertEquals(False, is_signature_compatible(varargs_kwargs_callable, func), "%s is compatible!" % func.func_name)

 def test_unboundmethod_signature_is_not_compatible_with_instancemeth(self):
     self.assertFalse(is_signature_compatible(DifferentMethods.instancemeth, self.obj.instancemeth))

 def test_attrfunc_signature_is_compatible_with_instancemeth(self):
     self.assertTrue(is_signature_compatible(self.obj.attrfunc, self.obj.instancemeth))

 def test_attrfunc_signature_is_not_compatible_with_class_unbound_method(self):
     self.assertFalse(is_signature_compatible(self.obj.attrfunc, DifferentMethods.instancemeth))

 def test_static_signature_is_compatible_with_attrfunc(self):
     self.assertTrue(is_signature_compatible(self.obj.staticmeth, self.obj.attrfunc))

 def test_static_signature_is_compatible_with_obj_instance_method(self):
     self.assertTrue(is_signature_compatible(self.obj.staticmeth, self.obj.instancemeth))

 def test_static_signature_is_compatible_with_obj_class_sig(self):
     self.assertTrue(is_signature_compatible(self.obj.staticmeth, self.obj.classmeth))

 def test_all_varargs_is_not_compatibile_with_three_args_varargs(self):
     self.assertEquals(False, is_signature_compatible(all_varargs_callable, three_args_varargs_callable))

 def test_three_args_varargs_is_compatible_with_three_args_varargs(self):
     self.assertEquals(True, is_signature_compatible(three_args_varargs_callable, three_args_varargs_callable))

 def test_all_varargs_is_compatibile_with_all_varargs(self):
     self.assertEquals(True, is_signature_compatible(all_varargs_callable, all_varargs_callable))

 def test_all_varargs_is_not_compatibile_with_empty(self):
     self.assertEquals(False, is_signature_compatible(all_varargs_callable, empty_callable))

 def test_attrfunc_signature_is_compatible_with_obj_class_sig(self):
     self.assertTrue(is_signature_compatible(self.obj.attrfunc, self.obj.classmeth))

 def test_attrfunc_signature_is_compatible_with_obj_instance_method(self):
     self.assertTrue(is_signature_compatible(self.obj.attrfunc, DifferentMethods.classmeth))

 def test_classmethod_signature_is_compatible_with_obj_instance_method(self):
     self.assertTrue(is_signature_compatible(DifferentMethods.classmeth, self.obj.instancemeth))

 def test_attrfunc_signature_is_compatible_with_attrfunc_signature(self):
     self.assertTrue(is_signature_compatible(self.obj.attrfunc, DifferentMethods.staticmeth))

 def test_bound_method_without_self_is_compatible_with_unbound(self):
     self.assertTrue(is_signature_compatible(self.obj.instancemeth, BoundWithoutSelf.staticmeth))