def _test(self, exp_sig, exp_src, outer, inner,
                    num_args=0, named_args=(),
                    hide_args=False, hide_kwargs=False,
                    use_varargs=True, use_varkwargs=True,
                    partial=False):
        outer_sig = s(outer, name='o')
        inner_sig = s(inner, name='i')

        sig = forwards(
                    outer_sig, inner_sig,
                    num_args, *named_args,
                    hide_args=hide_args, hide_kwargs=hide_kwargs,
                    use_varargs=use_varargs, use_varkwargs=use_varkwargs,
                    partial=partial)
        self.assertSigsEqual(sig, s(exp_sig))
        self.assertSourcesEqual(sig.sources, {
                'o': exp_src[0], 'i': exp_src[1],
                '+depths': ['o', 'i']})

        outer_sig = self.downgrade_sig(outer_sig)
        inner_sig = self.downgrade_sig(inner_sig)
        sig = forwards(
            outer_sig, inner_sig,
            num_args, *named_args,
            hide_args=hide_args, hide_kwargs=hide_kwargs,
            use_varargs=use_varargs, use_varkwargs=use_varkwargs,
            partial=partial)
        self.assertSigsEqual(sig, s(exp_sig))

 def test_use_twice(self):
     annotator = modifiers.annotate(a=1)
     self.assertSigsEqual(
         s('a:1, b'),
         signature(annotator(f('a, b')))
         )
     self.assertSigsEqual(
         s('a:1'),
         signature(annotator(f('a')))
         )

 def test_pok_interact(self):
     pok = f('self, a, *, b')
     annotated = modifiers.annotate(a=1, b=2)(pok)
     self.assertSigsEqual(
         s('self, a:1, *, b:2'),
         signature(annotated)
         )
     self.assertSigsEqual(
         s('a:1, *, b:2'),
         signature(safe_get(annotated, object(), object))
         )

def poktranslator_test(self, expected_sig_str, orig_sig_str,
                        posoargs, kwoargs):
    expected_sig = s(expected_sig_str)
    orig_sig = s(orig_sig_str)
    for exp, orig in defaults_variations(expected_sig, orig_sig):
        for exp, orig in stars_variations(exp, orig):
            func = modifiers._PokTranslator(
                func_from_sig(orig), posoargs, kwoargs)
            self.assertSigsEqual(exp, signature(func))
            test_func_sig_coherent(func)
            repr(func) # must not cause an error

    def test_preserve_annotations(self):
        func = f('self, a:2, b, c:3', 4)

        tr = modifiers._PokTranslator(func, kwoargs=('a', 'b'))
        self.assertSigsEqual(
            s('self, c:3, *, a:2, b', 4),
            signature(tr)
            )
        self.assertSigsEqual(
            s('c:3, *, a:2, b', 4),
            signature(safe_get(tr, object(), object))
            )

 def test_success(self):
     self.assertSigsEqual(
         s('a, b:1'),
         signature(modifiers.annotate(b=1)(f('a, b')))
         )
     self.assertSigsEqual(
         s('a:1, b:2'),
         signature(modifiers.annotate(a=1, b=2)(f('a, b')))
         )
     self.assertSigsEqual(
         s('a:1, b', 2),
         signature(modifiers.annotate(2, a=1)(f('a, b')))
         )

    def test_sigs_equal(self):
        self.assertSigsEqual(s('one'), s('one'))
        self.assertSigsEqual(s('*, one'), s('*, one'))

        with self.assertRaises(AssertionError):
            self.assertSigsEqual(s('one'), s('two'))
        with self.assertRaises(AssertionError):
            self.assertSigsEqual(s('one'), s('*, one'))

 def test_converter_ignore(self):
     @parser.parameter_converter
     def conv(param, annotations):
         return parser.Parameter.IGNORE
     sig = support.s('one:conv', locals={'conv': conv})
     csig = parser.CliSignature.from_signature(sig)
     self.assertEqual(str(csig), '')

 def _test(self, func, expected, expected_src):
     sig = specifiers.signature(func)
     self.assertSigsEqual(sig, support.s(expected))
     self.assertSourcesEqual(sig.sources, expected_src, func)
     with self.assertRaises(AssertionError):
         support.test_func_sig_coherent(
             func, check_return=False, check_invalid=False)

    def test_pconverter(self):
        class CustExc(Exception):
            pass

        @parser.parameter_converter
        def converter(param, annotations):
            raise CustExc

        @parser.parameter_converter
        def noop_converter(param, annotations):
            raise NotImplementedError

        sigs = [support.s("o: c", locals={"c": converter}), support.s("*, o: a", locals={"a": ("abc", converter)})]
        for sig in sigs:
            sparam = list(sig.parameters.values())[0]
            self.assertRaises(CustExc, parser.CliSignature.convert_parameter, sparam)

    def test_bad_default_good_conv(self):
        class UnknownDefault(object):
            pass

        deft = UnknownDefault()
        sig = support.s("*, par:str=default", locals={"default": deft})
        self._do_test(sig, parser.OptionParameter, "[--par=STR]", {"conv": parser.identity, "default": deft})

    def test_vconverter(self):
        @parser.value_converter
        def converter(value):
            raise NotImplementedError

        sig = support.s("*, par: conv", locals={"conv": converter})
        self._do_test(sig, parser.OptionParameter, "--par=CONVERTER", {"conv": converter})

 def test_directly_applied(self):
     def forger(obj):
         return support.s('abc')
     def forged():
         raise NotImplementedError
     specifiers.set_signature_forger(forged, forger)
     self.assertSigsEqual(support.s('abc'), specifiers.signature(forged))

 def test_forger_sig(self):
     @specifiers.forger_function
     def forger(p1, p2, p3, obj):
         raise NotImplementedError
     self.assertSigsEqual(
         support.s('p1, p2, p3, *, emulate=None'),
         specifiers.signature(forger))

def badparam(self, sig_str, locals=None):
    if locals is None:
        locals = {}
    sig = support.s(sig_str, pre='from clize import Parameter', locals=locals)
    params = list(sig.parameters.values())
    self.assertRaises(
        ValueError, parser.CliSignature.convert_parameter, params[0])

 def _test(self, sig_str, num_args, named_args=(),
           hide_varargs=False, hide_varkwargs=False):
     sig = support.s(sig_str)
     self.assertRaises(
         ValueError, signatures.mask,
         sig, num_args, *named_args,
         hide_varargs=hide_varargs, hide_varkwargs=hide_varkwargs)

 def _test(self, func, expected, sources, incoherent=False):
     sig = specifiers.signature(func)
     self.assertSigsEqual(sig, support.s(expected))
     self.assertSourcesEqual(sig.sources, sources, func)
     if not incoherent:
         support.test_func_sig_coherent(
             func, check_return=False, check_invalid=False)

def annotated_sigtests(self, sig_info, in_args, args, kwargs):
    sig_str, annotation, str_rep = sig_info
    sig = support.s(sig_str, locals={'a': annotation})
    csig = parser.CliSignature.from_signature(sig)
    ba = util.read_arguments(csig, in_args)
    self.assertEqual(ba.args, args)
    self.assertEqual(ba.kwargs, kwargs)

def extraparamstests(self, sig_str, extra, args, posargs, kwargs, func):
    sig = support.s(sig_str)
    csig = parser.CliSignature.from_signature(sig, extra=extra)
    ba = csig.read_arguments(args)
    self.assertEqual(ba.args, posargs)
    self.assertEqual(ba.kwargs, kwargs)
    self.assertEqual(ba.func, func)

def signaturetests(self, sig_str, str_rep, args, posargs, kwargs):
    sig = support.s(sig_str, locals={'P': parser.Parameter})
    csig = parser.CliSignature.from_signature(sig)
    ba = csig.read_arguments(args)
    self.assertEqual(str(csig), str_rep)
    self.assertEqual(ba.args, posargs)
    self.assertEqual(ba.kwargs, kwargs)