Lines Matching refs:self
29 def __init__(self, argument
33 self.error_message = error_message
34 self.exit_status = exit_status
35 self.exit_message = exit_message
37 def __str__(self): argument
38 return self.error_message or self.exit_message or "intercepted error"
41 def exit(self, status=0, msg=None): argument
44 def error(self, msg): argument
49 def assertParseOK(self, args, expected_opts, expected_positional_args): argument
62 (options, positional_args) = self.parser.parse_args(args)
65 self.assertEqual(optdict, expected_opts,
71 self.assertEqual(positional_args, expected_positional_args,
79 def assertRaises(self, argument
110 self.assertTrue(expected_message.search(actual_message),
118 self.assertEqual(actual_message,
129 self.fail("""expected exception %(expected_exception)s not raised
138 def assertParseFail(self, cmdline_args, expected_output): argument
144 self.parser.parse_args(cmdline_args)
146 self.assertEqual(err.error_message, expected_output)
148 self.assertFalse("expected parse failure")
150 def assertOutput(self, argument
160 self.parser.parse_args(cmdline_args)
166 self.assertTrue(
172 self.fail("expected: \n'''\n" + expected_output +
174 self.assertEqual(err.exit_status, expected_status)
175 self.assertEqual(err.exit_message, expected_error)
177 self.assertFalse("expected parser.exit()")
179 def assertTypeError(self, func, expected_message, *args): argument
181 self.assertRaises(func, args, None, TypeError, expected_message)
183 def assertHelp(self, parser, expected_help): argument
186 raise self.failureException(
198 def setUp(self): argument
199 self.parser = OptionParser(usage=SUPPRESS_USAGE)
201 def assertOptionError(self, expected_message, args=[], kwargs={}): argument
202 self.assertRaises(make_option, args, kwargs,
205 def test_opt_string_empty(self): argument
206 self.assertTypeError(make_option,
209 def test_opt_string_too_short(self): argument
210 self.assertOptionError(
214 def test_opt_string_short_invalid(self): argument
215 self.assertOptionError(
220 def test_opt_string_long_invalid(self): argument
221 self.assertOptionError(
226 def test_attr_invalid(self): argument
227 self.assertOptionError(
231 def test_action_invalid(self): argument
232 self.assertOptionError(
236 def test_type_invalid(self): argument
237 self.assertOptionError(
240 self.assertOptionError(
244 def test_no_type_for_action(self): argument
245 self.assertOptionError(
249 def test_no_choices_list(self): argument
250 self.assertOptionError(
255 def test_bad_choices_list(self): argument
257 self.assertOptionError(
263 def test_no_choices_for_type(self): argument
264 self.assertOptionError(
268 def test_no_const_for_action(self): argument
269 self.assertOptionError(
273 def test_no_nargs_for_action(self): argument
274 self.assertOptionError(
278 def test_callback_not_callable(self): argument
279 self.assertOptionError(
284 def dummy(self): argument
287 def test_callback_args_no_tuple(self): argument
288 self.assertOptionError(
292 'callback': self.dummy,
295 def test_callback_kwargs_no_dict(self): argument
296 self.assertOptionError(
300 'callback': self.dummy,
303 def test_no_callback_for_action(self): argument
304 self.assertOptionError(
309 def test_no_callback_args_for_action(self): argument
310 self.assertOptionError(
315 def test_no_callback_kwargs_for_action(self): argument
316 self.assertOptionError(
321 def test_no_single_dash(self): argument
322 self.assertOptionError(
327 self.assertOptionError(
332 self.assertOptionError(
338 def setUp(self): argument
339 self.parser = OptionParser()
340 self.parser.add_option("-v", "--verbose", "-n", "--noisy",
342 self.parser.add_option("-q", "--quiet", "--silent",
345 def test_add_option_no_Option(self): argument
346 self.assertTypeError(self.parser.add_option,
349 def test_add_option_invalid_arguments(self): argument
350 self.assertTypeError(self.parser.add_option,
353 def test_get_option(self): argument
354 opt1 = self.parser.get_option("-v")
355 self.assertIsInstance(opt1, Option)
356 self.assertEqual(opt1._short_opts, ["-v", "-n"])
357 self.assertEqual(opt1._long_opts, ["--verbose", "--noisy"])
358 self.assertEqual(opt1.action, "store_true")
359 self.assertEqual(opt1.dest, "verbose")
361 def test_get_option_equals(self): argument
362 opt1 = self.parser.get_option("-v")
363 opt2 = self.parser.get_option("--verbose")
364 opt3 = self.parser.get_option("-n")
365 opt4 = self.parser.get_option("--noisy")
366 self.assertTrue(opt1 is opt2 is opt3 is opt4)
368 def test_has_option(self): argument
369 self.assertTrue(self.parser.has_option("-v"))
370 self.assertTrue(self.parser.has_option("--verbose"))
372 def assertTrueremoved(self): argument
373 self.assertTrue(self.parser.get_option("-v") is None)
374 self.assertTrue(self.parser.get_option("--verbose") is None)
375 self.assertTrue(self.parser.get_option("-n") is None)
376 self.assertTrue(self.parser.get_option("--noisy") is None)
378 self.assertFalse(self.parser.has_option("-v"))
379 self.assertFalse(self.parser.has_option("--verbose"))
380 self.assertFalse(self.parser.has_option("-n"))
381 self.assertFalse(self.parser.has_option("--noisy"))
383 self.assertTrue(self.parser.has_option("-q"))
384 self.assertTrue(self.parser.has_option("--silent"))
386 def test_remove_short_opt(self): argument
387 self.parser.remove_option("-n")
388 self.assertTrueremoved()
390 def test_remove_long_opt(self): argument
391 self.parser.remove_option("--verbose")
392 self.assertTrueremoved()
394 def test_remove_nonexistent(self): argument
395 self.assertRaises(self.parser.remove_option, ('foo',), None,
399 def test_refleak(self): argument
413 self.assertEqual(refcount, sys.getrefcount(big_thing))
417 def setUp(self): argument
420 def test_basics(self): argument
422 self.assertEqual(vars(values), {})
423 self.assertEqual(values, {})
424 self.assertNotEqual(values, {"foo": "bar"})
425 self.assertNotEqual(values, "")
429 self.assertEqual(vars(values), dict)
430 self.assertEqual(values, dict)
431 self.assertNotEqual(values, {"foo": "bar"})
432 self.assertNotEqual(values, {})
433 self.assertNotEqual(values, "")
434 self.assertNotEqual(values, [])
438 def setUp(self): argument
439 self.parser = OptionParser()
441 def test_str_aliases_string(self): argument
442 self.parser.add_option("-s", type="str")
443 self.assertEqual(self.parser.get_option("-s").type, "string")
445 def test_type_object(self): argument
446 self.parser.add_option("-s", type=str)
447 self.assertEqual(self.parser.get_option("-s").type, "string")
448 self.parser.add_option("-x", type=int)
449 self.assertEqual(self.parser.get_option("-x").type, "int")
471 def setUp(self): argument
472 self.parser = OptionParser()
473 self.parser.add_option("-v", "--verbose", default=True)
474 self.parser.add_option("-q", "--quiet", dest='verbose')
475 self.parser.add_option("-n", type="int", default=37)
476 self.parser.add_option("-m", type="int")
477 self.parser.add_option("-s", default="foo")
478 self.parser.add_option("-t")
479 self.parser.add_option("-u", default=None)
480 self.expected = { 'verbose': True,
487 def test_basic_defaults(self): argument
488 self.assertEqual(self.parser.get_default_values(), self.expected)
490 def test_mixed_defaults_post(self): argument
491 self.parser.set_defaults(n=42, m=-100)
492 self.expected.update({'n': 42, 'm': -100})
493 self.assertEqual(self.parser.get_default_values(), self.expected)
495 def test_mixed_defaults_pre(self): argument
496 self.parser.set_defaults(x="barf", y="blah")
497 self.parser.add_option("-x", default="frob")
498 self.parser.add_option("-y")
500 self.expected.update({'x': "frob", 'y': "blah"})
501 self.assertEqual(self.parser.get_default_values(), self.expected)
503 self.parser.remove_option("-y")
504 self.parser.add_option("-y", default=None)
505 self.expected.update({'y': None})
506 self.assertEqual(self.parser.get_default_values(), self.expected)
508 def test_process_default(self): argument
509 self.parser.option_class = DurationOption
510 self.parser.add_option("-d", type="duration", default=300)
511 self.parser.add_option("-e", type="duration", default="6m")
512 self.parser.set_defaults(n="42")
513 self.expected.update({'d': 300, 'e': 360, 'n': 42})
514 self.assertEqual(self.parser.get_default_values(), self.expected)
516 self.parser.set_process_default_values(False)
517 self.expected.update({'d': 300, 'e': "6m", 'n': "42"})
518 self.assertEqual(self.parser.get_default_values(), self.expected)
527 def assertUsage(self, parser, expected_usage): argument
528 self.assertEqual(parser.get_usage(), expected_usage)
530 def assertVersion(self, parser, expected_version): argument
531 self.assertEqual(parser.get_version(), expected_version)
534 def test_default_progname(self): argument
541 self.assertUsage(parser, expected_usage)
542 self.assertVersion(parser, "baz.py 1.2")
543 self.assertHelp(parser,
551 def test_custom_progname(self): argument
558 self.assertUsage(parser, expected_usage)
559 self.assertVersion(parser, "thingy 0.1")
560 self.assertHelp(parser, expected_usage + "\n")
564 def setUp(self): argument
565 self.parser = OptionParser(prog="test")
566 self.help_prefix = """\
572 self.file_help = "read from FILE [default: %default]"
573 self.expected_help_file = self.help_prefix + \
575 self.expected_help_none = self.help_prefix + \
578 def test_option_default(self): argument
579 self.parser.add_option("-f", "--file",
581 help=self.file_help)
582 self.assertHelp(self.parser, self.expected_help_file)
584 def test_parser_default_1(self): argument
585 self.parser.add_option("-f", "--file",
586 help=self.file_help)
587 self.parser.set_default('file', "foo.txt")
588 self.assertHelp(self.parser, self.expected_help_file)
590 def test_parser_default_2(self): argument
591 self.parser.add_option("-f", "--file",
592 help=self.file_help)
593 self.parser.set_defaults(file="foo.txt")
594 self.assertHelp(self.parser, self.expected_help_file)
596 def test_no_default(self): argument
597 self.parser.add_option("-f", "--file",
598 help=self.file_help)
599 self.assertHelp(self.parser, self.expected_help_none)
601 def test_default_none_1(self): argument
602 self.parser.add_option("-f", "--file",
604 help=self.file_help)
605 self.assertHelp(self.parser, self.expected_help_none)
607 def test_default_none_2(self): argument
608 self.parser.add_option("-f", "--file",
609 help=self.file_help)
610 self.parser.set_defaults(file=None)
611 self.assertHelp(self.parser, self.expected_help_none)
613 def test_float_default(self): argument
614 self.parser.add_option(
617 self.parser.set_defaults(prob=0.43)
618 expected_help = self.help_prefix + \
620 self.assertHelp(self.parser, expected_help)
622 def test_alt_expand(self): argument
623 self.parser.add_option("-f", "--file",
626 self.parser.formatter.default_tag = "*DEFAULT*"
627 self.assertHelp(self.parser, self.expected_help_file)
629 def test_no_expand(self): argument
630 self.parser.add_option("-f", "--file",
633 self.parser.formatter.default_tag = None
634 expected_help = self.help_prefix + \
636 self.assertHelp(self.parser, expected_help)
642 def setUp(self): argument
647 self.parser = InterceptingOptionParser(usage=SUPPRESS_USAGE,
650 def test_required_value(self): argument
651 self.assertParseFail(["-a"], "-a option requires 1 argument")
653 def test_invalid_integer(self): argument
654 self.assertParseFail(["-b", "5x"],
657 def test_no_such_option(self): argument
658 self.assertParseFail(["--boo13"], "no such option: --boo13")
660 def test_long_invalid_integer(self): argument
661 self.assertParseFail(["--boo=x5"],
664 def test_empty(self): argument
665 self.assertParseOK([], {'a': None, 'boo': None, 'foo': None}, [])
667 def test_shortopt_empty_longopt_append(self): argument
668 self.assertParseOK(["-a", "", "--foo=blah", "--foo="],
672 def test_long_option_append(self): argument
673 self.assertParseOK(["--foo", "bar", "--foo", "", "--foo=x"],
679 def test_option_argument_joined(self): argument
680 self.assertParseOK(["-abc"],
684 def test_option_argument_split(self): argument
685 self.assertParseOK(["-a", "34"],
689 def test_option_argument_joined_integer(self): argument
690 self.assertParseOK(["-b34"],
694 def test_option_argument_split_negative_integer(self): argument
695 self.assertParseOK(["-b", "-5"],
699 def test_long_option_argument_joined(self): argument
700 self.assertParseOK(["--boo=13"],
704 def test_long_option_argument_split(self): argument
705 self.assertParseOK(["--boo", "111"],
709 def test_long_option_short_option(self): argument
710 self.assertParseOK(["--foo=bar", "-axyz"],
714 def test_abbrev_long_option(self): argument
715 self.assertParseOK(["--f=bar", "-axyz"],
719 def test_defaults(self): argument
720 (options, args) = self.parser.parse_args([])
721 defaults = self.parser.get_default_values()
722 self.assertEqual(vars(defaults), vars(options))
724 def test_ambiguous_option(self): argument
725 self.parser.add_option("--foz", action="store",
727 self.assertParseFail(["--f=bar"],
731 def test_short_and_long_option_split(self): argument
732 self.assertParseOK(["-a", "xyz", "--foo", "bar"],
736 def test_short_option_split_long_option_append(self): argument
737 self.assertParseOK(["--foo=bar", "-b", "123", "--foo", "baz"],
741 def test_short_option_split_one_positional_arg(self): argument
742 self.assertParseOK(["-a", "foo", "bar"],
746 def test_short_option_consumes_separator(self): argument
747 self.assertParseOK(["-a", "--", "foo", "bar"],
750 self.assertParseOK(["-a", "--", "--foo", "bar"],
754 def test_short_option_joined_and_separator(self): argument
755 self.assertParseOK(["-ab", "--", "--foo", "bar"],
759 def test_hyphen_becomes_positional_arg(self): argument
760 self.assertParseOK(["-ab", "-", "--foo", "bar"],
764 def test_no_append_versus_append(self): argument
765 self.assertParseOK(["-b3", "-b", "5", "--foo=bar", "--foo", "baz"],
769 def test_option_consumes_optionlike_string(self): argument
770 self.assertParseOK(["-a", "-b3"],
774 def test_combined_single_invalid_option(self): argument
775 self.parser.add_option("-t", action="store_true")
776 self.assertParseFail(["-test"],
780 def setUp(self): argument
790 self.parser = OptionParser(option_list = options)
792 def test_bool_default(self): argument
793 self.assertParseOK([],
797 def test_bool_false(self): argument
798 (options, args) = self.assertParseOK(["-q"],
801 self.assertTrue(options.verbose is False)
803 def test_bool_true(self): argument
804 (options, args) = self.assertParseOK(["-v"],
807 self.assertTrue(options.verbose is True)
809 def test_bool_flicker_on_and_off(self): argument
810 self.assertParseOK(["-qvq", "-q", "-v"],
815 def setUp(self): argument
816 self.parser = InterceptingOptionParser(usage=SUPPRESS_USAGE)
817 self.parser.add_option("-c", action="store", type="choice",
820 def test_valid_choice(self): argument
821 self.assertParseOK(["-c", "one", "xyz"],
825 def test_invalid_choice(self): argument
826 self.assertParseFail(["-c", "four", "abc"],
830 def test_add_choice_option(self): argument
831 self.parser.add_option("-d", "--default",
833 opt = self.parser.get_option("-d")
834 self.assertEqual(opt.type, "choice")
835 self.assertEqual(opt.action, "store")
838 def setUp(self): argument
839 self.parser = InterceptingOptionParser(usage=SUPPRESS_USAGE)
840 self.v_opt = make_option("-v", action="count", dest="verbose")
841 self.parser.add_option(self.v_opt)
842 self.parser.add_option("--verbose", type="int", dest="verbose")
843 self.parser.add_option("-q", "--quiet",
846 def test_empty(self): argument
847 self.assertParseOK([], {'verbose': None}, [])
849 def test_count_one(self): argument
850 self.assertParseOK(["-v"], {'verbose': 1}, [])
852 def test_count_three(self): argument
853 self.assertParseOK(["-vvv"], {'verbose': 3}, [])
855 def test_count_three_apart(self): argument
856 self.assertParseOK(["-v", "-v", "-v"], {'verbose': 3}, [])
858 def test_count_override_amount(self): argument
859 self.assertParseOK(["-vvv", "--verbose=2"], {'verbose': 2}, [])
861 def test_count_override_quiet(self): argument
862 self.assertParseOK(["-vvv", "--verbose=2", "-q"], {'verbose': 0}, [])
864 def test_count_overriding(self): argument
865 self.assertParseOK(["-vvv", "--verbose=2", "-q", "-v"],
868 def test_count_interspersed_args(self): argument
869 self.assertParseOK(["--quiet", "3", "-v"],
873 def test_count_no_interspersed_args(self): argument
874 self.parser.disable_interspersed_args()
875 self.assertParseOK(["--quiet", "3", "-v"],
879 def test_count_no_such_option(self): argument
880 self.assertParseFail(["-q3", "-v"], "no such option: -3")
882 def test_count_option_no_value(self): argument
883 self.assertParseFail(["--quiet=3", "-v"],
886 def test_count_with_default(self): argument
887 self.parser.set_default('verbose', 0)
888 self.assertParseOK([], {'verbose':0}, [])
890 def test_count_overriding_default(self): argument
891 self.parser.set_default('verbose', 0)
892 self.assertParseOK(["-vvv", "--verbose=2", "-q", "-v"],
896 def setUp(self): argument
897 self.parser = InterceptingOptionParser(usage=SUPPRESS_USAGE)
898 self.parser.add_option("-p", "--point",
901 def test_nargs_with_positional_args(self): argument
902 self.assertParseOK(["foo", "-p", "1", "2.5", "-4.3", "xyz"],
906 def test_nargs_long_opt(self): argument
907 self.assertParseOK(["--point", "-1", "2.5", "-0", "xyz"],
911 def test_nargs_invalid_float_value(self): argument
912 self.assertParseFail(["-p", "1.0", "2x", "3.5"],
916 def test_nargs_required_values(self): argument
917 self.assertParseFail(["--point", "1.0", "3.5"],
921 def setUp(self): argument
922 self.parser = InterceptingOptionParser(usage=SUPPRESS_USAGE)
923 self.parser.add_option("-p", "--point", action="store", nargs=3,
925 self.parser.add_option("-f", "--foo", action="append", nargs=2,
927 self.parser.add_option("-z", "--zero", action="append_const",
930 def test_nargs_append(self): argument
931 self.assertParseOK(["-f", "4", "-3", "blah", "--foo", "1", "666"],
935 def test_nargs_append_required_values(self): argument
936 self.assertParseFail(["-f4,3"],
939 def test_nargs_append_simple(self): argument
940 self.assertParseOK(["--foo=3", "4"],
944 def test_nargs_append_const(self): argument
945 self.assertParseOK(["--zero", "--foo", "3", "4", "-z"],
950 def test_version(self): argument
951 self.parser = InterceptingOptionParser(usage=SUPPRESS_USAGE,
956 self.assertOutput(["--version"], "bar 0.1\n")
960 def test_no_version(self): argument
961 self.parser = InterceptingOptionParser(usage=SUPPRESS_USAGE)
962 self.assertParseFail(["--version"],
969 def setUp(self): argument
970 self.parser = OptionParser(option_list=[
973 def test_conflict_default(self): argument
974 self.parser.add_option("-q", action="store_false", dest="verbose",
976 self.assertParseOK([], {'verbose': 0}, [])
978 def test_conflict_default_none(self): argument
979 self.parser.add_option("-q", action="store_false", dest="verbose",
981 self.assertParseOK([], {'verbose': None}, [])
984 def setUp(self): argument
985 self.parser = OptionParser(usage=SUPPRESS_USAGE)
987 def test_option_group_create_instance(self): argument
988 group = OptionGroup(self.parser, "Spam")
989 self.parser.add_option_group(group)
992 self.assertParseOK(["--spam"], {'spam': 1}, [])
994 def test_add_group_no_group(self): argument
995 self.assertTypeError(self.parser.add_option_group,
998 def test_add_group_invalid_arguments(self): argument
999 self.assertTypeError(self.parser.add_option_group,
1002 def test_add_group_wrong_parser(self): argument
1003 group = OptionGroup(self.parser, "Spam")
1005 self.assertRaises(self.parser.add_option_group, (group,), None,
1008 def test_group_manipulate(self): argument
1009 group = self.parser.add_option_group("Group 2",
1013 self.assertTrue(self.parser.get_option_group("--bacon"), group)
1018 def setUp(self): argument
1019 self.parser = InterceptingOptionParser(usage=SUPPRESS_USAGE,
1020 option_class=self.MyOption)
1021 self.parser.add_option("-a", None, type="string", dest="a")
1022 self.parser.add_option("-f", "--file", type="file", dest="file")
1024 def tearDown(self): argument
1042 def test_filetype_ok(self): argument
1044 self.assertParseOK(["--file", os_helper.TESTFN, "-afoo"],
1048 def test_filetype_noexist(self): argument
1049 self.assertParseFail(["--file", os_helper.TESTFN, "-afoo"],
1053 def test_filetype_notfile(self): argument
1055 self.assertParseFail(["--file", os_helper.TESTFN, "-afoo"],
1061 def setUp(self): argument
1062 options = [self.MyOption("-a", "--apple", action="extend",
1064 self.parser = OptionParser(option_list=options)
1071 def take_action(self, action, dest, opt, value, values, parser): argument
1076 Option.take_action(self, action, dest, opt, parser, value,
1079 def test_extend_add_action(self): argument
1080 self.assertParseOK(["-afoo,bar", "--apple=blah"],
1084 def test_extend_add_action_normal(self): argument
1085 self.assertParseOK(["-a", "foo", "-abar", "--apple=x,y"],
1092 def setUp(self): argument
1096 callback=self.process_opt),
1100 callback=self.process_opt,
1103 self.parser = OptionParser(option_list=options)
1105 def process_opt(self, option, opt, value, parser_): argument
1107 self.assertEqual(option._short_opts, ["-x"])
1108 self.assertEqual(option._long_opts, [])
1109 self.assertTrue(parser_ is self.parser)
1110 self.assertTrue(value is None)
1111 self.assertEqual(vars(parser_.values), {'filename': None})
1115 self.assertEqual(option._short_opts, ["-f"])
1116 self.assertEqual(option._long_opts, ["--file"])
1117 self.assertTrue(parser_ is self.parser)
1118 self.assertEqual(value, "foo")
1119 self.assertEqual(vars(parser_.values), {'filename': None, 'x': 42})
1123 self.fail("Unknown option %r in process_opt." % opt)
1125 def test_callback(self): argument
1126 self.assertParseOK(["-x", "--file=foo"],
1130 def test_callback_help(self): argument
1142 self.assertHelp(parser, expected_help)
1146 def setUp(self): argument
1148 callback=self.process_tuple,
1151 self.parser = OptionParser(option_list=options)
1153 def process_tuple(self, option, opt, value, parser_, len, type): argument
1154 self.assertEqual(len, 3)
1155 self.assertTrue(type is int)
1158 self.assertEqual(value, "1,2,3")
1160 self.assertEqual(value, "4,5,6")
1165 def test_callback_extra_args(self): argument
1166 self.assertParseOK(["-p1,2,3", "--point", "4,5,6"],
1171 def setUp(self): argument
1173 callback=self.process_n, dest='things')
1175 self.parser = OptionParser(option_list=options)
1178 def process_n(self, option, opt, value, parser_): argument
1183 self.fail("Expected %d arguments for %s option." % (nargs, opt))
1189 def test_callback_meddle_args(self): argument
1190 self.assertParseOK(["-1", "foo", "-3", "bar", "baz", "qux"],
1194 def test_callback_meddle_args_separator(self): argument
1195 self.assertParseOK(["-2", "foo", "--"],
1200 def setUp(self): argument
1202 callback=self.process_many, type="string"),
1204 callback=self.process_many, type="int")]
1205 self.parser = OptionParser(option_list=options)
1207 def process_many(self, option, opt, value, parser_): argument
1209 self.assertEqual(value, ("foo", "bar"))
1211 self.assertEqual(value, ("ding", "dong"))
1213 self.assertEqual(value, (1, 2, 3))
1215 self.assertEqual(value, (-666, 42, 0))
1217 def test_many_args(self): argument
1218 self.assertParseOK(["-a", "foo", "bar", "--apple", "ding", "dong",
1225 def setUp(self): argument
1226 self.parser = OptionParser()
1227 self.parser.add_option("--foo-bar", action="callback",
1228 callback=self.check_abbrev)
1230 def check_abbrev(self, option, opt, value, parser): argument
1231 self.assertEqual(opt, "--foo-bar")
1233 def test_abbrev_callback_expansion(self): argument
1234 self.assertParseOK(["--foo"], {}, [])
1237 def setUp(self): argument
1241 callback=self.variable_args, dest="c")]
1242 self.parser = InterceptingOptionParser(usage=SUPPRESS_USAGE,
1245 def variable_args(self, option, opt, value, parser): argument
1246 self.assertTrue(value is None)
1259 def test_variable_args(self): argument
1260 self.assertParseOK(["-a3", "-5", "--callback", "foo", "bar"],
1264 def test_consume_separator_stop_at_option(self): argument
1265 self.assertParseOK(["-c", "37", "--", "xxx", "-b", "hello"],
1271 def test_positional_arg_and_variable_args(self): argument
1272 self.assertParseOK(["hello", "-c", "foo", "-", "bar"],
1278 def test_stop_at_option(self): argument
1279 self.assertParseOK(["-c", "foo", "-b"],
1283 def test_stop_at_invalid_option(self): argument
1284 self.assertParseFail(["-c", "3", "-5", "-a"], "no such option: -5")
1290 def setUp(self): argument
1293 self.parser = InterceptingOptionParser(usage=SUPPRESS_USAGE,
1296 def show_version(self, option, opt, value, parser): argument
1301 def assertTrueconflict_error(self, func): argument
1302 err = self.assertRaises(
1304 'callback' : self.show_version,
1309 self.assertEqual(err.msg, "conflicting option string(s): -v")
1310 self.assertEqual(err.option_id, "-v/--version")
1312 def test_conflict_error(self): argument
1313 self.assertTrueconflict_error(self.parser.add_option)
1315 def test_conflict_error_group(self): argument
1316 group = OptionGroup(self.parser, "Group 1")
1317 self.assertTrueconflict_error(group.add_option)
1319 def test_no_such_conflict_handler(self): argument
1320 self.assertRaises(
1321 self.parser.set_conflict_handler, ('foo',), None,
1326 def setUp(self): argument
1327 ConflictBase.setUp(self)
1328 self.parser.set_conflict_handler("resolve")
1329 self.parser.add_option("-v", "--version", action="callback",
1330 callback=self.show_version, help="show version")
1332 def test_conflict_resolve(self): argument
1333 v_opt = self.parser.get_option("-v")
1334 verbose_opt = self.parser.get_option("--verbose")
1335 version_opt = self.parser.get_option("--version")
1337 self.assertTrue(v_opt is version_opt)
1338 self.assertTrue(v_opt is not verbose_opt)
1339 self.assertEqual(v_opt._long_opts, ["--version"])
1340 self.assertEqual(version_opt._short_opts, ["-v"])
1341 self.assertEqual(version_opt._long_opts, ["--version"])
1342 self.assertEqual(verbose_opt._short_opts, [])
1343 self.assertEqual(verbose_opt._long_opts, ["--verbose"])
1345 def test_conflict_resolve_help(self): argument
1346 self.assertOutput(["-h"], """\
1353 def test_conflict_resolve_short_opt(self): argument
1354 self.assertParseOK(["-v"],
1358 def test_conflict_resolve_long_opt(self): argument
1359 self.assertParseOK(["--verbose"],
1363 def test_conflict_resolve_long_opts(self): argument
1364 self.assertParseOK(["--verbose", "--version"],
1369 def setUp(self): argument
1370 self.parser = InterceptingOptionParser(usage=SUPPRESS_USAGE)
1371 self.parser.set_conflict_handler("resolve")
1372 self.parser.add_option("-n", "--dry-run",
1375 self.parser.add_option("--dry-run", "-n",
1379 def test_conflict_override_opts(self): argument
1380 opt = self.parser.get_option("--dry-run")
1381 self.assertEqual(opt._short_opts, ["-n"])
1382 self.assertEqual(opt._long_opts, ["--dry-run"])
1384 def test_conflict_override_help(self): argument
1385 self.assertOutput(["-h"], """\
1391 def test_conflict_override_args(self): argument
1392 self.assertParseOK(["-n"],
1481 def setUp(self): argument
1482 self.parser = self.make_parser(80)
1484 def make_parser(self, columns): argument
1505 def assertHelpEquals(self, expected_output): argument
1510 self.assertOutput(["-h"], expected_output)
1514 def test_help(self): argument
1515 self.assertHelpEquals(_expected_help_basic)
1517 def test_help_old_usage(self): argument
1518 self.parser.set_usage("Usage: %prog [options]")
1519 self.assertHelpEquals(_expected_help_basic)
1521 def test_help_long_opts_first(self): argument
1522 self.parser.formatter.short_first = 0
1523 self.assertHelpEquals(_expected_help_long_opts_first)
1525 def test_help_title_formatter(self): argument
1528 self.parser.formatter = TitledHelpFormatter()
1529 self.assertHelpEquals(_expected_help_title_formatter)
1531 def test_wrap_columns(self): argument
1535 self.parser = self.make_parser(60)
1536 self.assertHelpEquals(_expected_help_short_lines)
1537 self.parser = self.make_parser(0)
1538 self.assertHelpEquals(_expected_very_help_short_lines)
1540 def test_help_unicode(self): argument
1541 self.parser = InterceptingOptionParser(usage=SUPPRESS_USAGE)
1542 self.parser.add_option("-a", action="store_true", help="ol\u00E9!")
1548 self.assertHelpEquals(expect)
1550 def test_help_unicode_description(self): argument
1551 self.parser = InterceptingOptionParser(usage=SUPPRESS_USAGE,
1559 self.assertHelpEquals(expect)
1561 def test_help_description_groups(self): argument
1562 self.parser.set_description(
1567 self.parser, "Dangerous Options",
1571 self.parser.add_option_group(group)
1593 self.assertHelpEquals(expect)
1595 self.parser.epilog = "Please report bugs to /dev/null."
1596 self.assertHelpEquals(expect + "\nPlease report bugs to /dev/null.\n")
1600 def test_match_abbrev(self): argument
1601 self.assertEqual(_match_abbrev("--f",
1608 def test_match_abbrev_error(self): argument
1611 self.assertRaises(
1617 def setUp(self): argument
1618 self.parser = InterceptingOptionParser()
1619 self.parser.add_option("-n", type=int)
1620 self.parser.add_option("-l", type=int)
1622 def test_parse_num_fail(self): argument
1623 self.assertRaises(
1627 self.assertRaises(
1632 def test_parse_num_ok(self): argument
1633 self.assertEqual(_parse_num("0", int), 0)
1634 self.assertEqual(_parse_num("0x10", int), 16)
1635 self.assertEqual(_parse_num("0XA", int), 10)
1636 self.assertEqual(_parse_num("010", int), 8)
1637 self.assertEqual(_parse_num("0b11", int), 3)
1638 self.assertEqual(_parse_num("0b", int), 0)
1640 def test_numeric_options(self): argument
1641 self.assertParseOK(["-n", "42", "-l", "0x20"],
1643 self.assertParseOK(["-n", "0b0101", "-l010"],
1645 self.assertParseFail(["-n008"],
1647 self.assertParseFail(["-l0b0123"],
1649 self.assertParseFail(["-l", "0x12x"],
1654 def test__all__(self): argument
1656 support.check__all__(self, optparse, not_exported=not_exported)