Lines Matching refs:self
16 def items(self):
17 return sorted(self.data.items())
19 def keys(self):
20 return sorted(self.data.keys())
22 def values(self):
23 return [i[1] for i in self.items()]
25 def iteritems(self):
26 return iter(self.items())
28 def iterkeys(self):
29 return iter(self.keys())
31 def itervalues(self):
32 return iter(self.values())
48 def newconfig(self, defaults=None):
51 allow_no_value=self.allow_no_value,
52 delimiters=self.delimiters,
53 comment_prefixes=self.comment_prefixes,
54 inline_comment_prefixes=self.inline_comment_prefixes,
55 empty_lines_in_values=self.empty_lines_in_values,
56 dict_type=self.dict_type,
57 strict=self.strict,
58 default_section=self.default_section,
59 interpolation=self.interpolation,
61 instance = self.config_class(**arguments)
64 def fromstring(self, string, defaults=None):
65 cf = self.newconfig(defaults)
72 def basic_test(self, cf):
85 if self.allow_no_value:
93 eq = self.assertEqual
102 E.append(self.default_section)
110 self.assertEqual(len(L), len(E))
113 eq(cf.defaults(), cf[self.default_section])
130 self.assertAlmostEqual(cf.getfloat('Types', 'float'), 0.44)
135 if self.allow_no_value:
141 with self.assertRaises(configparser.NoSectionError):
143 with self.assertRaises(configparser.NoOptionError):
152 with self.assertRaises(configparser.NoOptionError):
154 self.assertAlmostEqual(cf.getfloat('Types', 'float',
156 self.assertAlmostEqual(cf.getfloat('Types', 'no-such-float',
159 with self.assertRaises(configparser.NoOptionError):
165 with self.assertRaises(configparser.NoOptionError):
168 if self.allow_no_value:
178 self.assertIs(section.parser, cf)
179 with self.assertRaises(AttributeError):
181 with self.assertRaises(AttributeError):
191 if self.allow_no_value:
197 with self.assertRaises(KeyError):
199 with self.assertRaises(KeyError):
201 with self.assertRaises(KeyError):
208 with self.assertRaises(KeyError):
217 self.assertAlmostEqual(cf['Types'].getfloat('float', 0.0), 0.44)
218 self.assertAlmostEqual(cf['Types'].getfloat('float',
220 self.assertAlmostEqual(cf['Types'].getfloat('no-such-float', 0.0), 0.0)
221 self.assertAlmostEqual(cf['Types'].getfloat('no-such-float',
234 if self.allow_no_value:
244 cf[self.default_section]['this_value'] = '1'
245 cf[self.default_section]['that_value'] = '2'
248 self.assertTrue(cf.remove_section('Spaces'))
249 self.assertFalse(cf.has_option('Spaces', 'key with spaces'))
250 self.assertFalse(cf.remove_section('Spaces'))
251 self.assertFalse(cf.remove_section(self.default_section))
252 self.assertTrue(cf.remove_option('Foo Bar', 'foo'),
254 self.assertFalse(cf.has_option('Foo Bar', 'foo'),
256 self.assertFalse(cf.remove_option('Foo Bar', 'foo'),
259 self.assertTrue(cf.has_option('Foo Bar', 'this_value'))
260 self.assertFalse(cf.remove_option('Foo Bar', 'this_value'))
261 self.assertTrue(cf.remove_option(self.default_section, 'this_value'))
262 self.assertFalse(cf.has_option('Foo Bar', 'this_value'))
263 self.assertFalse(cf.remove_option(self.default_section, 'this_value'))
265 with self.assertRaises(configparser.NoSectionError) as cm:
267 self.assertEqual(cm.exception.args, ('No Such Section',))
274 self.assertFalse('Types' in cf)
275 with self.assertRaises(KeyError):
277 with self.assertRaises(ValueError):
278 del cf[self.default_section]
280 self.assertFalse('foo' in cf['Spacey Bar'])
281 with self.assertRaises(KeyError):
283 self.assertTrue('that_value' in cf['Spacey Bar'])
284 with self.assertRaises(KeyError):
286 del cf[self.default_section]['that_value']
287 self.assertFalse('that_value' in cf['Spacey Bar'])
288 with self.assertRaises(KeyError):
289 del cf[self.default_section]['that_value']
290 with self.assertRaises(KeyError):
296 def test_basic(self):
327 """.format(self.delimiters, self.comment_prefixes)
328 if self.allow_no_value:
333 cf = self.fromstring(config_string)
334 self.basic_test(cf)
335 if self.strict:
336 with self.assertRaises(configparser.DuplicateOptionError):
341 """.format(self.delimiters)))
342 with self.assertRaises(configparser.DuplicateSectionError):
348 """.format(self.delimiters)))
354 """.format(self.delimiters)))
361 """.format(self.delimiters)))
363 def test_basic_from_dict(self):
405 if self.allow_no_value:
411 cf = self.newconfig()
413 self.basic_test(cf)
414 if self.strict:
415 with self.assertRaises(configparser.DuplicateSectionError):
420 with self.assertRaises(configparser.DuplicateOptionError):
439 def test_case_sensitivity(self):
440 cf = self.newconfig()
446 eq = self.assertEqual
452 with self.assertRaises(configparser.NoSectionError):
455 self.assertTrue(cf.has_option("a", "b"))
456 self.assertFalse(cf.has_option("b", "b"))
459 self.assertTrue(
468 cf = self.fromstring(
470 self.delimiters[0]))
475 cf = self.fromstring("[section]\n"
476 "nekey{}nevalue\n".format(self.delimiters[0]),
478 self.assertTrue(cf.has_option("section", "Key"))
481 def test_case_sensitivity_mapping_access(self):
482 cf = self.newconfig()
488 eq = self.assertEqual
489 elem_eq = self.assertCountEqual
490 eq(L, sorted(["A", "B", self.default_section, "a"]))
494 with self.assertRaises(KeyError):
497 self.assertTrue("b" in cf["a"])
500 self.assertTrue(
509 cf = self.fromstring(
511 self.delimiters[0]))
516 cf = self.fromstring("[section]\n"
517 "nekey{}nevalue\n".format(self.delimiters[0]),
519 self.assertTrue("Key" in cf["section"])
521 def test_default_case_sensitivity(self):
522 cf = self.newconfig({"foo": "Bar"})
523 self.assertEqual(
524 cf.get(self.default_section, "Foo"), "Bar",
526 cf = self.newconfig({"Foo": "Bar"})
527 self.assertEqual(
528 cf.get(self.default_section, "Foo"), "Bar",
531 def test_parse_errors(self):
532 cf = self.newconfig()
533 self.parse_error(cf, configparser.ParsingError,
535 "{}val-without-opt-name\n".format(self.delimiters[0]))
536 self.parse_error(cf, configparser.ParsingError,
538 "{}val-without-opt-name\n".format(self.delimiters[1]))
539 e = self.parse_error(cf, configparser.MissingSectionHeaderError,
541 self.assertEqual(e.args, ('<???>', 1, "No Section!\n"))
542 if not self.allow_no_value:
543 e = self.parse_error(cf, configparser.ParsingError,
545 self.assertEqual(e.args, ('<???>',))
548 if self.delimiters[0] == '=':
556 e = self.parse_error(cf, error, f)
557 self.assertEqual(e.args, expected)
559 def parse_error(self, cf, exc, src):
564 with self.assertRaises(exc) as cm:
568 def test_query_errors(self):
569 cf = self.newconfig()
570 self.assertEqual(cf.sections(), [],
572 self.assertFalse(cf.has_section("Foo"),
575 with self.assertRaises(configparser.NoSectionError):
577 with self.assertRaises(configparser.NoSectionError):
579 e = self.get_error(cf, configparser.NoSectionError, "foo", "bar")
580 self.assertEqual(e.args, ("foo",))
582 e = self.get_error(cf, configparser.NoOptionError, "foo", "bar")
583 self.assertEqual(e.args, ("bar", "foo"))
585 def get_error(self, cf, exc, section, option):
591 self.fail("expected exception type %s.%s"
594 def test_boolean(self):
595 cf = self.fromstring(
611 "E5{equals}FALSE AND MORE".format(equals=self.delimiters[0])
614 self.assertTrue(cf.getboolean('BOOLTEST', 't%d' % x))
615 self.assertFalse(cf.getboolean('BOOLTEST', 'f%d' % x))
616 self.assertRaises(ValueError,
619 def test_weird_errors(self):
620 cf = self.newconfig()
622 with self.assertRaises(configparser.DuplicateSectionError) as cm:
625 self.assertEqual(str(e), "Section 'Foo' already exists")
626 self.assertEqual(e.args, ("Foo", None, None))
628 if self.strict:
629 with self.assertRaises(configparser.DuplicateSectionError) as cm:
637 """.format(equals=self.delimiters[0])), source='<foo-bar>')
639 self.assertEqual(str(e), "While reading from '<foo-bar>' "
641 self.assertEqual(e.args, ("Foo", '<foo-bar>', 5))
643 with self.assertRaises(configparser.DuplicateOptionError) as cm:
646 self.assertEqual(str(e), "While reading from '<dict>': option "
648 self.assertEqual(e.args, ("Bar", "opt", "<dict>", None))
650 def test_write(self):
663 "\n".format(self.delimiters, comment=self.comment_prefixes[0],
664 default_section=self.default_section)
666 if self.allow_no_value:
672 cf = self.fromstring(config_string)
676 delimiter = self.delimiters[0]
694 default_section=self.default_section)
696 if self.allow_no_value:
702 self.assertEqual(output.getvalue(), expect_string)
704 def test_set_string_types(self):
705 cf = self.fromstring("[sect]\n"
706 "option1{eq}foo\n".format(eq=self.delimiters[0]))
718 def test_read_returns_file_list(self):
719 if self.delimiters[0] != '=':
720 self.skipTest('incompatible format')
723 cf = self.newconfig()
725 self.assertEqual(parsed_files, [file1])
726 self.assertEqual(cf.get("Foo Bar", "foo"), "newbar")
728 cf = self.newconfig()
730 self.assertEqual(parsed_files, [file1])
731 self.assertEqual(cf.get("Foo Bar", "foo"), "newbar")
733 cf = self.newconfig()
735 self.assertEqual(parsed_files, [file1])
736 self.assertEqual(cf.get("Foo Bar", "foo"), "newbar")
738 cf = self.newconfig()
740 self.assertEqual(parsed_files, [file1, file1])
741 self.assertEqual(cf.get("Foo Bar", "foo"), "newbar")
743 cf = self.newconfig()
745 self.assertEqual(parsed_files, [])
747 cf = self.newconfig()
749 self.assertEqual(parsed_files, [])
751 def test_read_returns_file_list_with_bytestring_path(self):
752 if self.delimiters[0] != '=':
753 self.skipTest('incompatible format')
756 cf = self.newconfig()
758 self.assertEqual(parsed_files, [file1_bytestring])
760 cf = self.newconfig()
762 self.assertEqual(parsed_files, [])
764 cf = self.newconfig()
766 self.assertEqual(parsed_files, [file1_bytestring])
769 def get_interpolation_config(self):
770 return self.fromstring(
794 "name{equals}%(reference)s\n".format(equals=self.delimiters[0]))
796 def check_items_config(self, expected):
797 cf = self.fromstring("""
802 """.format(self.delimiters), defaults={"default": "<default>"})
805 self.assertEqual(L, expected)
806 with self.assertRaises(configparser.NoSectionError):
809 def test_popitem(self):
810 cf = self.fromstring("""
817 """.format(self.delimiters), defaults={"default": "<default>"})
818 self.assertEqual(cf.popitem()[0], 'section1')
819 self.assertEqual(cf.popitem()[0], 'section2')
820 self.assertEqual(cf.popitem()[0], 'section3')
821 with self.assertRaises(KeyError):
824 def test_clear(self):
825 cf = self.newconfig({"foo": "Bar"})
826 self.assertEqual(
827 cf.get(self.default_section, "Foo"), "Bar",
830 self.assertEqual(cf.sections(), ['zing'])
831 self.assertEqual(set(cf['zing'].keys()), {'option1', 'option2', 'foo'})
833 self.assertEqual(set(cf.sections()), set())
834 self.assertEqual(set(cf[self.default_section].keys()), {'foo'})
836 def test_setitem(self):
837 cf = self.fromstring("""
844 """.format(self.delimiters), defaults={"nameD": "valueD"})
845 self.assertEqual(set(cf['section1'].keys()), {'name1', 'named'})
846 self.assertEqual(set(cf['section2'].keys()), {'name2', 'named'})
847 self.assertEqual(set(cf['section3'].keys()), {'name3', 'named'})
848 self.assertEqual(cf['section1']['name1'], 'value1')
849 self.assertEqual(cf['section2']['name2'], 'value2')
850 self.assertEqual(cf['section3']['name3'], 'value3')
851 self.assertEqual(cf.sections(), ['section1', 'section2', 'section3'])
853 self.assertEqual(set(cf['section2'].keys()), {'name22', 'named'})
854 self.assertEqual(cf['section2']['name22'], 'value22')
855 self.assertNotIn('name2', cf['section2'])
856 self.assertEqual(cf.sections(), ['section1', 'section2', 'section3'])
858 self.assertEqual(set(cf['section3'].keys()), {'named'})
859 self.assertNotIn('name3', cf['section3'])
860 self.assertEqual(cf.sections(), ['section1', 'section2', 'section3'])
862 cf[self.default_section] = cf[self.default_section]
863 self.assertNotEqual(set(cf[self.default_section].keys()), set())
864 cf[self.default_section] = {}
865 self.assertEqual(set(cf[self.default_section].keys()), set())
866 self.assertEqual(set(cf['section1'].keys()), {'name1'})
867 self.assertEqual(set(cf['section2'].keys()), {'name22'})
868 self.assertEqual(set(cf['section3'].keys()), set())
869 self.assertEqual(cf.sections(), ['section1', 'section2', 'section3'])
872 self.assertEqual(set(cf['section2'].keys()), {'name22'})
874 def test_invalid_multiline_value(self):
875 if self.allow_no_value:
876 self.skipTest('if no_value is allowed, ParsingError is not raised')
881 invalid""".format(self.delimiters[0])
883 cf = self.newconfig()
884 with self.assertRaises(configparser.ParsingError):
886 self.assertEqual(cf.get('DEFAULT', 'test'), 'test')
887 self.assertEqual(cf['DEFAULT']['test'], 'test')
898 def test_interpolation(self):
899 cf = self.get_interpolation_config()
900 eq = self.assertEqual
906 e = self.get_error(cf, configparser.InterpolationDepthError, "Foo", "bar11")
907 if self.interpolation == configparser._UNSET:
908 self.assertEqual(e.args, ("bar11", "Foo",
910 elif isinstance(self.interpolation, configparser.LegacyInterpolation):
911 self.assertEqual(e.args, ("bar11", "Foo",
914 def test_interpolation_missing_value(self):
915 cf = self.get_interpolation_config()
916 e = self.get_error(cf, configparser.InterpolationMissingOptionError,
918 self.assertEqual(e.reference, "reference")
919 self.assertEqual(e.section, "Interpolation Error")
920 self.assertEqual(e.option, "name")
921 if self.interpolation == configparser._UNSET:
922 self.assertEqual(e.args, ('name', 'Interpolation Error',
924 elif isinstance(self.interpolation, configparser.LegacyInterpolation):
925 self.assertEqual(e.args, ('name', 'Interpolation Error',
928 def test_items(self):
929 self.check_items_config([('default', '<default>'),
934 def test_safe_interpolation(self):
936 cf = self.fromstring("[section]\n"
941 eq=self.delimiters[0]))
942 self.assertEqual(cf.get("section", "ok"), "xxx/%s")
943 if self.interpolation == configparser._UNSET:
944 self.assertEqual(cf.get("section", "not_ok"), "xxx/xxx/%s")
945 elif isinstance(self.interpolation, configparser.LegacyInterpolation):
946 with self.assertRaises(TypeError):
949 def test_set_malformatted_interpolation(self):
950 cf = self.fromstring("[sect]\n"
951 "option1{eq}foo\n".format(eq=self.delimiters[0]))
953 self.assertEqual(cf.get('sect', "option1"), "foo")
955 self.assertRaises(ValueError, cf.set, "sect", "option1", "%foo")
956 self.assertRaises(ValueError, cf.set, "sect", "option1", "foo%")
957 self.assertRaises(ValueError, cf.set, "sect", "option1", "f%oo")
959 self.assertEqual(cf.get('sect', "option1"), "foo")
963 self.assertEqual(cf.get("sect", "option2"), "foo%bar")
965 def test_set_nonstring_types(self):
966 cf = self.fromstring("[sect]\n"
967 "option1{eq}foo\n".format(eq=self.delimiters[0]))
970 self.assertRaises(TypeError, cf.set, "sect", "option1", 1)
971 self.assertRaises(TypeError, cf.set, "sect", "option1", 1.0)
972 self.assertRaises(TypeError, cf.set, "sect", "option1", object())
973 self.assertRaises(TypeError, cf.set, "sect", "option2", 1)
974 self.assertRaises(TypeError, cf.set, "sect", "option2", 1.0)
975 self.assertRaises(TypeError, cf.set, "sect", "option2", object())
976 self.assertRaises(TypeError, cf.set, "sect", 123, "invalid opt name!")
977 self.assertRaises(TypeError, cf.add_section, 123)
979 def test_add_section_default(self):
980 cf = self.newconfig()
981 self.assertRaises(ValueError, cf.add_section, self.default_section)
983 def test_defaults_keyword(self):
985 cf = self.newconfig(defaults={1: 2.4})
986 self.assertEqual(cf[self.default_section]['1'], '2.4')
987 self.assertAlmostEqual(cf[self.default_section].getfloat('1'), 2.4)
988 cf = self.newconfig(defaults={"A": 5.2})
989 self.assertEqual(cf[self.default_section]['a'], '5.2')
990 self.assertAlmostEqual(cf[self.default_section].getfloat('a'), 5.2)
1006 def assertMatchesIni(self, cf):
1007 self.assertEqual(cf['numbers']['one'], '1')
1008 self.assertEqual(cf['numbers']['two'], '%(one)s * 2')
1009 self.assertEqual(cf['numbers']['three'], '${common:one} * 3')
1010 self.assertEqual(cf['hexen']['sixteen'], '${numbers:two} * 8')
1012 def test_no_interpolation(self):
1013 cf = self.fromstring(self.ini)
1014 self.assertMatchesIni(cf)
1016 def test_empty_case(self):
1017 cf = self.newconfig()
1018 self.assertIsNone(cf.read_string(""))
1020 def test_none_as_default_interpolation(self):
1025 cf.read_string(self.ini)
1026 self.assertMatchesIni(cf)
1035 def test_set_malformatted_interpolation(self):
1036 cf = self.fromstring("[sect]\n"
1037 "option1{eq}foo\n".format(eq=self.delimiters[0]))
1039 self.assertEqual(cf.get('sect', "option1"), "foo")
1042 self.assertEqual(cf.get('sect', "option1"), "%foo")
1044 self.assertEqual(cf.get('sect', "option1"), "foo%")
1046 self.assertEqual(cf.get('sect', "option1"), "f%oo")
1050 self.assertEqual(cf.get("sect", "option2"), "foo%%bar")
1054 def test_error_on_wrong_type_for_interpolation(self):
1056 with self.subTest(value=value):
1057 with self.assertRaises(TypeError):
1077 def setUp(self):
1078 cf = self.newconfig()
1083 cf.set(s, 'lovely_spam{}'.format(j), self.wonderful_spam)
1087 def tearDown(self):
1090 def test_dominating_multiline_values(self):
1093 cf_from_file = self.newconfig()
1096 self.assertEqual(cf_from_file.get('section8', 'lovely_spam4'),
1097 self.wonderful_spam.replace('\t\n', '\n'))
1103 def test_interpolation(self):
1104 cf = self.get_interpolation_config()
1105 eq = self.assertEqual
1115 def test_items(self):
1116 self.check_items_config([('default', '<default>'),
1121 def test_set_nonstring_types(self):
1122 cf = self.newconfig()
1127 self.assertEqual(cf.get('non-string', 'int'), 1)
1128 self.assertEqual(cf.get('non-string', 'list'),
1130 self.assertEqual(cf.get('non-string', 'dict'), {'pi': 3.14159})
1133 self.assertEqual(cf.get(123, 'this is sick'), True)
1139 self.assertEqual(cf.get('non-string', 1), 1)
1141 def test_defaults_keyword(self):
1143 with self.assertRaises(AttributeError) as ctx:
1144 self.newconfig(defaults={1: 2.4})
1146 self.assertEqual(str(err), "'int' object has no attribute 'lower'")
1147 cf = self.newconfig(defaults={"A": 5.2})
1148 self.assertAlmostEqual(cf[self.default_section]['a'], 5.2)
1163 def test_reading(self):
1166 cf = self.newconfig()
1168 self.assertEqual(parsed_files, [smbconf])
1171 self.assertEqual(cf.sections(), sections)
1172 self.assertEqual(cf.get("global", "workgroup"), "MDKGROUP")
1173 self.assertEqual(cf.getint("global", "max log size"), 50)
1174 self.assertEqual(cf.get("global", "hosts allow"), "127.")
1175 self.assertEqual(cf.get("tmp", "echo command"), "cat %s; rm %s")
1183 def fromstring(self, string, defaults=None, optionxform=None):
1184 cf = self.newconfig(defaults)
1190 def test_extended_interpolation(self):
1191 cf = self.fromstring(textwrap.dedent("""
1215 eq = self.assertEqual
1235 def test_endless_loop(self):
1236 cf = self.fromstring(textwrap.dedent("""
1247 with self.assertRaises(configparser.InterpolationDepthError):
1249 with self.assertRaises(configparser.InterpolationDepthError):
1252 def test_strange_options(self):
1253 cf = self.fromstring("""
1264 self.assertEqual(cf['dollars']['$var'], '$value')
1265 self.assertEqual(cf['interpolated']['$other'], '$value')
1266 self.assertEqual(cf['dollars']['${sick}'], 'cannot interpolate me')
1268 with self.assertRaises(exception_class) as cm:
1270 self.assertEqual(cm.exception.reference, 'dollars:${sick')
1271 self.assertEqual(cm.exception.args[2], '${dollars:${sick}}') #rawval
1273 def test_case_sensitivity_basic(self):
1288 cf = self.fromstring(ini)
1289 eq = self.assertEqual
1297 def test_case_sensitivity_conflicts(self):
1311 with self.assertRaises(configparser.DuplicateOptionError):
1312 cf = self.fromstring(ini)
1315 cf = self.fromstring(ini, optionxform=lambda opt: opt)
1316 eq = self.assertEqual
1324 def test_other_errors(self):
1325 cf = self.fromstring("""
1334 with self.assertRaises(configparser.InterpolationSyntaxError):
1336 with self.assertRaises(configparser.InterpolationMissingOptionError):
1338 with self.assertRaises(configparser.InterpolationMissingOptionError):
1340 with self.assertRaises(configparser.InterpolationSyntaxError):
1342 with self.assertRaises(configparser.InterpolationSyntaxError):
1344 with self.assertRaises(ValueError):
1358 def test_cfgparser_dot_3(self):
1360 cf = self.newconfig()
1361 self.assertEqual(len(cf.read(tricky, encoding='utf-8')), 1)
1362 self.assertEqual(cf.sections(), ['strange',
1370 self.assertEqual(cf.getint(self.default_section, 'go',
1372 with self.assertRaises(ValueError):
1374 cf.getint(self.default_section, 'go', raw=True,
1376 self.assertEqual(len(cf.get('strange', 'other').split('\n')), 4)
1377 self.assertEqual(len(cf.get('corruption', 'value').split('\n')), 10)
1379 self.assertFalse(cf.getboolean(longname, 'are they subsections'))
1380 self.assertEqual(cf.get(longname, 'lets use some Unicode'), '片仮名')
1381 self.assertEqual(len(cf.items('another one!')), 5) # 4 in section and
1383 with self.assertRaises(configparser.InterpolationMissingOptionError):
1385 self.assertEqual(cf.get('tricky interpolation', 'lets'), 'do this')
1386 self.assertEqual(cf.get('tricky interpolation', 'lets'),
1388 self.assertEqual(cf.get('more interpolation', 'lets'), 'go shopping')
1390 def test_unicode_failure(self):
1392 cf = self.newconfig()
1393 with self.assertRaises(UnicodeDecodeError):
1406 def prepare(self, config_class):
1415 def test_none_as_value_stringified(self):
1418 with self.assertRaises(TypeError):
1421 def test_none_as_value_stringified_raw(self):
1422 output = self.prepare(configparser.RawConfigParser)
1423 self.assertEqual(output, self.expected_output)
1429 def test_sorted(self):
1430 cf = self.fromstring("[b]\n"
1439 self.assertEqual(output.getvalue(),
1454 def test_comment_handling(self):
1464 cf = self.fromstring(config_string)
1465 self.assertEqual(cf.get('Commented Bar', 'foo'),
1467 self.assertEqual(cf.get('Commented Bar', 'baz'), 'qwe')
1468 self.assertEqual(cf.get('Commented Bar', 'quirk'),
1474 def fromstring(self, string, defaults=None):
1475 cf = self.newconfig(defaults)
1477 cf_copy = self.newconfig()
1482 if section.name == self.default_section:
1484 for default, value in cf[self.default_section].items():
1491 def __init__(self):
1494 self.lines = f.readlines()
1495 self.lines.reverse()
1497 def readline(self):
1498 if len(self.lines):
1499 return self.lines.pop()
1512 def test_file(self):
1522 self.assertIn("Foo Bar", parser)
1523 self.assertIn("foo", parser["Foo Bar"])
1524 self.assertEqual(parser["Foo Bar"]["foo"], "newbar")
1526 def test_iterable(self):
1532 self.assertIn("Foo Bar", parser)
1533 self.assertIn("foo", parser["Foo Bar"])
1534 self.assertEqual(parser["Foo Bar"]["foo"], "newbar")
1536 def test_readline_generator(self):
1539 with self.assertRaises(TypeError):
1542 self.assertIn("Foo Bar", parser)
1543 self.assertIn("foo", parser["Foo Bar"])
1544 self.assertEqual(parser["Foo Bar"]["foo"], "newbar")
1546 def test_source_as_bytes(self):
1552 with self.assertRaises(configparser.DuplicateSectionError) as dse:
1554 self.assertEqual(
1564 with self.assertRaises(configparser.DuplicateOptionError) as dse:
1566 self.assertEqual(
1575 with self.assertRaises(configparser.ParsingError) as dse:
1577 self.assertEqual(
1585 with self.assertRaises(configparser.MissingSectionHeaderError) as dse:
1587 self.assertEqual(
1597 def test_duplicate_option_error(self):
1599 self.assertEqual(error.section, 'section')
1600 self.assertEqual(error.option, 'option')
1601 self.assertEqual(error.source, None)
1602 self.assertEqual(error.lineno, None)
1603 self.assertEqual(error.args, ('section', 'option', None, None))
1604 self.assertEqual(str(error), "Option 'option' in section 'section' "
1607 def test_interpolation_depth_error(self):
1610 self.assertEqual(error.args, ('option', 'section', 'rawval'))
1611 self.assertEqual(error.option, 'option')
1612 self.assertEqual(error.section, 'section')
1614 def test_parsing_error(self):
1615 with self.assertRaises(ValueError) as cm:
1617 self.assertEqual(str(cm.exception), "Required argument `source' not "
1619 with self.assertRaises(ValueError) as cm:
1621 self.assertEqual(str(cm.exception), "Cannot specify both `filename' "
1624 self.assertEqual(error.source, 'source')
1627 self.assertEqual(error.filename, 'source')
1629 self.assertEqual(error.source, 'filename')
1631 self.assertTrue(warning.category is DeprecationWarning)
1633 def test_interpolation_validation(self):
1641 with self.assertRaises(configparser.InterpolationSyntaxError) as cm:
1643 self.assertEqual(str(cm.exception), "'%' must be followed by '%' or "
1645 with self.assertRaises(configparser.InterpolationSyntaxError) as cm:
1647 self.assertEqual(str(cm.exception), "bad interpolation variable "
1650 def test_readfp_deprecation(self):
1660 self.assertTrue(warning.category is DeprecationWarning)
1661 self.assertEqual(len(parser), 2)
1662 self.assertEqual(parser['section']['option'], 'value')
1664 def test_safeconfigparser_deprecation(self):
1669 self.assertTrue(warning.category is DeprecationWarning)
1671 def test_legacyinterpolation_deprecation(self):
1675 self.assertGreaterEqual(len(w), 1)
1677 self.assertIs(warning.category, DeprecationWarning)
1679 def test_sectionproxy_repr(self):
1685 self.assertEqual(repr(parser['section']), '<Section: section>')
1687 def test_inconsistent_converters_state(self):
1697 self.assertIn('decimal', parser.converters)
1698 self.assertEqual(parser.getdecimal('s1', 'one'), 1)
1699 self.assertEqual(parser.getdecimal('s2', 'two'), 2)
1700 self.assertEqual(parser['s1'].getdecimal('one'), 1)
1701 self.assertEqual(parser['s2'].getdecimal('two'), 2)
1703 with self.assertRaises(AttributeError):
1705 self.assertIn('decimal', parser.converters)
1707 self.assertNotIn('decimal', parser.converters)
1708 with self.assertRaises(AttributeError):
1710 with self.assertRaises(AttributeError):
1712 with self.assertRaises(AttributeError):
1719 def test_error(self):
1725 self.assertEqual(e1.message, e2.message)
1726 self.assertEqual(repr(e1), repr(e2))
1728 def test_nosectionerror(self):
1734 self.assertEqual(e1.message, e2.message)
1735 self.assertEqual(e1.args, e2.args)
1736 self.assertEqual(e1.section, e2.section)
1737 self.assertEqual(repr(e1), repr(e2))
1739 def test_nooptionerror(self):
1745 self.assertEqual(e1.message, e2.message)
1746 self.assertEqual(e1.args, e2.args)
1747 self.assertEqual(e1.section, e2.section)
1748 self.assertEqual(e1.option, e2.option)
1749 self.assertEqual(repr(e1), repr(e2))
1751 def test_duplicatesectionerror(self):
1757 self.assertEqual(e1.message, e2.message)
1758 self.assertEqual(e1.args, e2.args)
1759 self.assertEqual(e1.section, e2.section)
1760 self.assertEqual(e1.source, e2.source)
1761 self.assertEqual(e1.lineno, e2.lineno)
1762 self.assertEqual(repr(e1), repr(e2))
1764 def test_duplicateoptionerror(self):
1771 self.assertEqual(e1.message, e2.message)
1772 self.assertEqual(e1.args, e2.args)
1773 self.assertEqual(e1.section, e2.section)
1774 self.assertEqual(e1.option, e2.option)
1775 self.assertEqual(e1.source, e2.source)
1776 self.assertEqual(e1.lineno, e2.lineno)
1777 self.assertEqual(repr(e1), repr(e2))
1779 def test_interpolationerror(self):
1785 self.assertEqual(e1.message, e2.message)
1786 self.assertEqual(e1.args, e2.args)
1787 self.assertEqual(e1.section, e2.section)
1788 self.assertEqual(e1.option, e2.option)
1789 self.assertEqual(repr(e1), repr(e2))
1791 def test_interpolationmissingoptionerror(self):
1798 self.assertEqual(e1.message, e2.message)
1799 self.assertEqual(e1.args, e2.args)
1800 self.assertEqual(e1.section, e2.section)
1801 self.assertEqual(e1.option, e2.option)
1802 self.assertEqual(e1.reference, e2.reference)
1803 self.assertEqual(repr(e1), repr(e2))
1805 def test_interpolationsyntaxerror(self):
1811 self.assertEqual(e1.message, e2.message)
1812 self.assertEqual(e1.args, e2.args)
1813 self.assertEqual(e1.section, e2.section)
1814 self.assertEqual(e1.option, e2.option)
1815 self.assertEqual(repr(e1), repr(e2))
1817 def test_interpolationdeptherror(self):
1824 self.assertEqual(e1.message, e2.message)
1825 self.assertEqual(e1.args, e2.args)
1826 self.assertEqual(e1.section, e2.section)
1827 self.assertEqual(e1.option, e2.option)
1828 self.assertEqual(repr(e1), repr(e2))
1830 def test_parsingerror(self):
1839 self.assertEqual(e1.message, e2.message)
1840 self.assertEqual(e1.args, e2.args)
1841 self.assertEqual(e1.source, e2.source)
1842 self.assertEqual(e1.errors, e2.errors)
1843 self.assertEqual(repr(e1), repr(e2))
1851 self.assertEqual(e1.message, e2.message)
1852 self.assertEqual(e1.args, e2.args)
1853 self.assertEqual(e1.source, e2.source)
1854 self.assertEqual(e1.errors, e2.errors)
1855 self.assertEqual(repr(e1), repr(e2))
1857 def test_missingsectionheadererror(self):
1863 self.assertEqual(e1.message, e2.message)
1864 self.assertEqual(e1.args, e2.args)
1865 self.assertEqual(e1.line, e2.line)
1866 self.assertEqual(e1.source, e2.source)
1867 self.assertEqual(e1.lineno, e2.lineno)
1868 self.assertEqual(repr(e1), repr(e2))
1875 def test_stripping(self):
1894 self.assertEqual(s['k1'], 'v1;still v1')
1895 self.assertEqual(s['k2'], 'v2')
1896 self.assertEqual(s['k3'], 'v3')
1897 self.assertEqual(s['k4'], 'v4;still v4')
1898 self.assertEqual(s['k5'], 'v5;still v5')
1899 self.assertEqual(s['k6'], 'v6;still v6; and still v6')
1900 self.assertEqual(s['k7'], 'v7;still v7; and still v7')
1902 self.assertEqual(s['k1'], 'v1;still v1')
1903 self.assertEqual(s['k2'], 'v2')
1904 self.assertEqual(s['k3'], 'v3;#//still v3# and still v3')
1911 def test_get_basic_interpolation(self):
1919 cm = self.assertRaises(configparser.InterpolationMissingOptionError)
1922 self.assertIs(cm.exception.__suppress_context__, True)
1924 def test_get_extended_interpolation(self):
1933 cm = self.assertRaises(configparser.InterpolationMissingOptionError)
1936 self.assertIs(cm.exception.__suppress_context__, True)
1938 def test_missing_options(self):
1944 with self.assertRaises(configparser.NoSectionError) as cm:
1946 self.assertIs(cm.exception.__suppress_context__, True)
1948 def test_missing_section(self):
1950 with self.assertRaises(configparser.NoSectionError) as cm:
1952 self.assertIs(cm.exception.__suppress_context__, True)
1954 def test_remove_option(self):
1956 with self.assertRaises(configparser.NoSectionError) as cm:
1958 self.assertIs(cm.exception.__suppress_context__, True)
1966 def newconfig(self, defaults=None):
1972 def test_converters(self):
1973 cfg = self.newconfig()
1974 self.assertIn('boolean', cfg.converters)
1975 self.assertIn('list', cfg.converters)
1976 self.assertIsNone(cfg.converters['int'])
1977 self.assertIsNone(cfg.converters['float'])
1978 self.assertIsNone(cfg.converters['boolean'])
1979 self.assertIsNotNone(cfg.converters['list'])
1980 self.assertEqual(len(cfg.converters), 4)
1981 with self.assertRaises(ValueError):
1983 with self.assertRaises(ValueError):
1994 self.assertEqual(s['str'], 'string')
1995 self.assertEqual(s['int'], '1')
1996 self.assertEqual(s['float'], '0.5')
1997 self.assertEqual(s['list'], 'a b c d e f g')
1998 self.assertEqual(s['bool'], 'yes')
1999 self.assertEqual(cfg.get('s', 'str'), 'string')
2000 self.assertEqual(cfg.get('s', 'int'), '1')
2001 self.assertEqual(cfg.get('s', 'float'), '0.5')
2002 self.assertEqual(cfg.get('s', 'list'), 'a b c d e f g')
2003 self.assertEqual(cfg.get('s', 'bool'), 'yes')
2004 self.assertEqual(cfg.get('s', 'str'), 'string')
2005 self.assertEqual(cfg.getint('s', 'int'), 1)
2006 self.assertEqual(cfg.getfloat('s', 'float'), 0.5)
2007 self.assertEqual(cfg.getlist('s', 'list'), ['a', 'b', 'c', 'd',
2009 self.assertEqual(cfg.getboolean('s', 'bool'), True)
2010 self.assertEqual(s.get('str'), 'string')
2011 self.assertEqual(s.getint('int'), 1)
2012 self.assertEqual(s.getfloat('float'), 0.5)
2013 self.assertEqual(s.getlist('list'), ['a', 'b', 'c', 'd',
2015 self.assertEqual(s.getboolean('bool'), True)
2016 with self.assertRaises(AttributeError):
2018 with self.assertRaises(AttributeError):
2022 self.assertIn('decimal', cfg.converters)
2023 self.assertIsNotNone(cfg.converters['decimal'])
2024 self.assertEqual(len(cfg.converters), 5)
2026 self.assertEqual(cfg.getdecimal('s', 'float'), dec0_5)
2027 self.assertEqual(s.getdecimal('float'), dec0_5)
2029 self.assertNotIn('decimal', cfg.converters)
2030 self.assertEqual(len(cfg.converters), 4)
2031 with self.assertRaises(AttributeError):
2033 with self.assertRaises(AttributeError):
2035 with self.assertRaises(KeyError):
2037 with self.assertRaises(KeyError):
2039 with self.assertRaises(KeyError):
2059 def test_converters_at_init(self):
2061 cfg.read_string(self.config)
2062 self._test_len(cfg)
2063 self.assertIsNotNone(cfg.converters['len'])
2065 def test_inheritance(self):
2069 def getboolean(self, section, option, *, raw=False, vars=None,
2075 def getlen(self, section, option, *, raw=False, vars=None,
2077 return self._get_conv(section, option, len, raw=raw, vars=vars,
2081 cfg.read_string(self.config)
2082 self._test_len(cfg)
2083 self.assertIsNone(cfg.converters['len'])
2084 self.assertTrue(cfg.getboolean('one', 'one'))
2085 self.assertTrue(cfg.getboolean('two', 'two'))
2086 self.assertFalse(cfg.getboolean('one', 'two'))
2087 self.assertFalse(cfg.getboolean('two', 'one'))
2089 self.assertFalse(cfg.getboolean('one', 'one'))
2090 self.assertFalse(cfg.getboolean('two', 'two'))
2091 self.assertFalse(cfg.getboolean('one', 'two'))
2092 self.assertFalse(cfg.getboolean('two', 'one'))
2094 def _test_len(self, cfg):
2095 self.assertEqual(len(cfg.converters), 4)
2096 self.assertIn('boolean', cfg.converters)
2097 self.assertIn('len', cfg.converters)
2098 self.assertNotIn('tysburg', cfg.converters)
2099 self.assertIsNone(cfg.converters['int'])
2100 self.assertIsNone(cfg.converters['float'])
2101 self.assertIsNone(cfg.converters['boolean'])
2102 self.assertEqual(cfg.getlen('one', 'one'), 5)
2103 self.assertEqual(cfg.getlen('one', 'two'), 5)
2104 self.assertEqual(cfg.getlen('one', 'three'), 16)
2105 self.assertEqual(cfg.getlen('two', 'one'), 5)
2106 self.assertEqual(cfg.getlen('two', 'two'), 5)
2107 self.assertEqual(cfg.getlen('two', 'three'), 4)
2108 self.assertEqual(cfg.getlen('two', 'four', fallback=0), 0)
2109 with self.assertRaises(configparser.NoOptionError):
2111 self.assertEqual(cfg['one'].getlen('one'), 5)
2112 self.assertEqual(cfg['one'].getlen('two'), 5)
2113 self.assertEqual(cfg['one'].getlen('three'), 16)
2114 self.assertEqual(cfg['two'].getlen('one'), 5)
2115 self.assertEqual(cfg['two'].getlen('two'), 5)
2116 self.assertEqual(cfg['two'].getlen('three'), 4)
2117 self.assertEqual(cfg['two'].getlen('four', 0), 0)
2118 self.assertEqual(cfg['two'].getlen('four'), None)
2120 def test_instance_assignment(self):
2124 cfg.read_string(self.config)
2125 self.assertEqual(len(cfg.converters), 3)
2126 self.assertIn('boolean', cfg.converters)
2127 self.assertNotIn('len', cfg.converters)
2128 self.assertIsNone(cfg.converters['int'])
2129 self.assertIsNone(cfg.converters['float'])
2130 self.assertIsNone(cfg.converters['boolean'])
2131 self.assertTrue(cfg.getboolean('one', 'one'))
2132 self.assertTrue(cfg.getboolean('two', 'two'))
2133 self.assertTrue(cfg.getboolean('one', 'two'))
2134 self.assertTrue(cfg.getboolean('two', 'one'))
2136 self.assertFalse(cfg.getboolean('one', 'one'))
2137 self.assertFalse(cfg.getboolean('two', 'two'))
2138 self.assertFalse(cfg.getboolean('one', 'two'))
2139 self.assertFalse(cfg.getboolean('two', 'one'))
2140 self.assertEqual(cfg.getlen('one', 'one'), 5)
2141 self.assertEqual(cfg.getlen('one', 'two'), 5)
2142 self.assertEqual(cfg.getlen('one', 'three'), 16)
2143 self.assertEqual(cfg.getlen('two', 'one'), 5)
2144 self.assertEqual(cfg.getlen('two', 'two'), 5)
2145 self.assertEqual(cfg.getlen('two', 'three'), 4)
2148 with self.assertRaises(AttributeError):
2149 self.assertEqual(cfg['one'].getlen('one'), 5)
2150 with self.assertRaises(AttributeError):
2151 self.assertEqual(cfg['two'].getlen('one'), 5)
2155 def test__all__(self):
2156 support.check__all__(self, configparser, not_exported={"Error"})