summaryrefslogtreecommitdiff
path: root/lib/python2.7/test/test_cfgparser.py
diff options
context:
space:
mode:
Diffstat (limited to 'lib/python2.7/test/test_cfgparser.py')
-rw-r--r--lib/python2.7/test/test_cfgparser.py738
1 files changed, 738 insertions, 0 deletions
diff --git a/lib/python2.7/test/test_cfgparser.py b/lib/python2.7/test/test_cfgparser.py
new file mode 100644
index 0000000..f0073f0
--- /dev/null
+++ b/lib/python2.7/test/test_cfgparser.py
@@ -0,0 +1,738 @@
+import ConfigParser
+import StringIO
+import os
+import unittest
+import UserDict
+
+from test import test_support
+
+
+class SortedDict(UserDict.UserDict):
+ def items(self):
+ result = self.data.items()
+ result.sort()
+ return result
+
+ def keys(self):
+ result = self.data.keys()
+ result.sort()
+ return result
+
+ def values(self):
+ # XXX never used?
+ result = self.items()
+ return [i[1] for i in result]
+
+ def iteritems(self): return iter(self.items())
+ def iterkeys(self): return iter(self.keys())
+ __iter__ = iterkeys
+ def itervalues(self): return iter(self.values())
+
+
+class TestCaseBase(unittest.TestCase):
+ allow_no_value = False
+
+ def newconfig(self, defaults=None):
+ if defaults is None:
+ self.cf = self.config_class(allow_no_value=self.allow_no_value)
+ else:
+ self.cf = self.config_class(defaults,
+ allow_no_value=self.allow_no_value)
+ return self.cf
+
+ def fromstring(self, string, defaults=None):
+ cf = self.newconfig(defaults)
+ sio = StringIO.StringIO(string)
+ cf.readfp(sio)
+ return cf
+
+ def test_basic(self):
+ config_string = (
+ "[Foo Bar]\n"
+ "foo=bar\n"
+ "[Spacey Bar]\n"
+ "foo = bar\n"
+ "[Commented Bar]\n"
+ "foo: bar ; comment\n"
+ "[Long Line]\n"
+ "foo: this line is much, much longer than my editor\n"
+ " likes it.\n"
+ "[Section\\with$weird%characters[\t]\n"
+ "[Internationalized Stuff]\n"
+ "foo[bg]: Bulgarian\n"
+ "foo=Default\n"
+ "foo[en]=English\n"
+ "foo[de]=Deutsch\n"
+ "[Spaces]\n"
+ "key with spaces : value\n"
+ "another with spaces = splat!\n"
+ )
+ if self.allow_no_value:
+ config_string += (
+ "[NoValue]\n"
+ "option-without-value\n"
+ )
+
+ cf = self.fromstring(config_string)
+ L = cf.sections()
+ L.sort()
+ E = [r'Commented Bar',
+ r'Foo Bar',
+ r'Internationalized Stuff',
+ r'Long Line',
+ r'Section\with$weird%characters[' '\t',
+ r'Spaces',
+ r'Spacey Bar',
+ ]
+ if self.allow_no_value:
+ E.append(r'NoValue')
+ E.sort()
+ eq = self.assertEqual
+ eq(L, E)
+
+ # The use of spaces in the section names serves as a
+ # regression test for SourceForge bug #583248:
+ # http://www.python.org/sf/583248
+ eq(cf.get('Foo Bar', 'foo'), 'bar')
+ eq(cf.get('Spacey Bar', 'foo'), 'bar')
+ eq(cf.get('Commented Bar', 'foo'), 'bar')
+ eq(cf.get('Spaces', 'key with spaces'), 'value')
+ eq(cf.get('Spaces', 'another with spaces'), 'splat!')
+ if self.allow_no_value:
+ eq(cf.get('NoValue', 'option-without-value'), None)
+
+ self.assertNotIn('__name__', cf.options("Foo Bar"),
+ '__name__ "option" should not be exposed by the API!')
+
+ # Make sure the right things happen for remove_option();
+ # added to include check for SourceForge bug #123324:
+ self.assertTrue(cf.remove_option('Foo Bar', 'foo'),
+ "remove_option() failed to report existence of option")
+ self.assertFalse(cf.has_option('Foo Bar', 'foo'),
+ "remove_option() failed to remove option")
+ self.assertFalse(cf.remove_option('Foo Bar', 'foo'),
+ "remove_option() failed to report non-existence of option"
+ " that was removed")
+
+ self.assertRaises(ConfigParser.NoSectionError,
+ cf.remove_option, 'No Such Section', 'foo')
+
+ eq(cf.get('Long Line', 'foo'),
+ 'this line is much, much longer than my editor\nlikes it.')
+
+ def test_case_sensitivity(self):
+ cf = self.newconfig()
+ cf.add_section("A")
+ cf.add_section("a")
+ L = cf.sections()
+ L.sort()
+ eq = self.assertEqual
+ eq(L, ["A", "a"])
+ cf.set("a", "B", "value")
+ eq(cf.options("a"), ["b"])
+ eq(cf.get("a", "b"), "value",
+ "could not locate option, expecting case-insensitive option names")
+ self.assertTrue(cf.has_option("a", "b"))
+ cf.set("A", "A-B", "A-B value")
+ for opt in ("a-b", "A-b", "a-B", "A-B"):
+ self.assertTrue(
+ cf.has_option("A", opt),
+ "has_option() returned false for option which should exist")
+ eq(cf.options("A"), ["a-b"])
+ eq(cf.options("a"), ["b"])
+ cf.remove_option("a", "B")
+ eq(cf.options("a"), [])
+
+ # SF bug #432369:
+ cf = self.fromstring(
+ "[MySection]\nOption: first line\n\tsecond line\n")
+ eq(cf.options("MySection"), ["option"])
+ eq(cf.get("MySection", "Option"), "first line\nsecond line")
+
+ # SF bug #561822:
+ cf = self.fromstring("[section]\nnekey=nevalue\n",
+ defaults={"key":"value"})
+ self.assertTrue(cf.has_option("section", "Key"))
+
+
+ def test_default_case_sensitivity(self):
+ cf = self.newconfig({"foo": "Bar"})
+ self.assertEqual(
+ cf.get("DEFAULT", "Foo"), "Bar",
+ "could not locate option, expecting case-insensitive option names")
+ cf = self.newconfig({"Foo": "Bar"})
+ self.assertEqual(
+ cf.get("DEFAULT", "Foo"), "Bar",
+ "could not locate option, expecting case-insensitive defaults")
+
+ def test_parse_errors(self):
+ self.newconfig()
+ self.parse_error(ConfigParser.ParsingError,
+ "[Foo]\n extra-spaces: splat\n")
+ self.parse_error(ConfigParser.ParsingError,
+ "[Foo]\n extra-spaces= splat\n")
+ self.parse_error(ConfigParser.ParsingError,
+ "[Foo]\n:value-without-option-name\n")
+ self.parse_error(ConfigParser.ParsingError,
+ "[Foo]\n=value-without-option-name\n")
+ self.parse_error(ConfigParser.MissingSectionHeaderError,
+ "No Section!\n")
+
+ def parse_error(self, exc, src):
+ sio = StringIO.StringIO(src)
+ self.assertRaises(exc, self.cf.readfp, sio)
+
+ def test_query_errors(self):
+ cf = self.newconfig()
+ self.assertEqual(cf.sections(), [],
+ "new ConfigParser should have no defined sections")
+ self.assertFalse(cf.has_section("Foo"),
+ "new ConfigParser should have no acknowledged "
+ "sections")
+ self.assertRaises(ConfigParser.NoSectionError,
+ cf.options, "Foo")
+ self.assertRaises(ConfigParser.NoSectionError,
+ cf.set, "foo", "bar", "value")
+ self.get_error(ConfigParser.NoSectionError, "foo", "bar")
+ cf.add_section("foo")
+ self.get_error(ConfigParser.NoOptionError, "foo", "bar")
+
+ def get_error(self, exc, section, option):
+ try:
+ self.cf.get(section, option)
+ except exc, e:
+ return e
+ else:
+ self.fail("expected exception type %s.%s"
+ % (exc.__module__, exc.__name__))
+
+ def test_boolean(self):
+ cf = self.fromstring(
+ "[BOOLTEST]\n"
+ "T1=1\n"
+ "T2=TRUE\n"
+ "T3=True\n"
+ "T4=oN\n"
+ "T5=yes\n"
+ "F1=0\n"
+ "F2=FALSE\n"
+ "F3=False\n"
+ "F4=oFF\n"
+ "F5=nO\n"
+ "E1=2\n"
+ "E2=foo\n"
+ "E3=-1\n"
+ "E4=0.1\n"
+ "E5=FALSE AND MORE"
+ )
+ for x in range(1, 5):
+ self.assertTrue(cf.getboolean('BOOLTEST', 't%d' % x))
+ self.assertFalse(cf.getboolean('BOOLTEST', 'f%d' % x))
+ self.assertRaises(ValueError,
+ cf.getboolean, 'BOOLTEST', 'e%d' % x)
+
+ def test_weird_errors(self):
+ cf = self.newconfig()
+ cf.add_section("Foo")
+ self.assertRaises(ConfigParser.DuplicateSectionError,
+ cf.add_section, "Foo")
+
+ def test_write(self):
+ config_string = (
+ "[Long Line]\n"
+ "foo: this line is much, much longer than my editor\n"
+ " likes it.\n"
+ "[DEFAULT]\n"
+ "foo: another very\n"
+ " long line\n"
+ )
+ if self.allow_no_value:
+ config_string += (
+ "[Valueless]\n"
+ "option-without-value\n"
+ )
+
+ cf = self.fromstring(config_string)
+ output = StringIO.StringIO()
+ cf.write(output)
+ expect_string = (
+ "[DEFAULT]\n"
+ "foo = another very\n"
+ "\tlong line\n"
+ "\n"
+ "[Long Line]\n"
+ "foo = this line is much, much longer than my editor\n"
+ "\tlikes it.\n"
+ "\n"
+ )
+ if self.allow_no_value:
+ expect_string += (
+ "[Valueless]\n"
+ "option-without-value\n"
+ "\n"
+ )
+ self.assertEqual(output.getvalue(), expect_string)
+
+ def test_set_string_types(self):
+ cf = self.fromstring("[sect]\n"
+ "option1=foo\n")
+ # Check that we don't get an exception when setting values in
+ # an existing section using strings:
+ class mystr(str):
+ pass
+ cf.set("sect", "option1", "splat")
+ cf.set("sect", "option1", mystr("splat"))
+ cf.set("sect", "option2", "splat")
+ cf.set("sect", "option2", mystr("splat"))
+ try:
+ unicode
+ except NameError:
+ pass
+ else:
+ cf.set("sect", "option1", unicode("splat"))
+ cf.set("sect", "option2", unicode("splat"))
+
+ def test_read_returns_file_list(self):
+ file1 = test_support.findfile("cfgparser.1")
+ # check when we pass a mix of readable and non-readable files:
+ cf = self.newconfig()
+ parsed_files = cf.read([file1, "nonexistent-file"])
+ self.assertEqual(parsed_files, [file1])
+ self.assertEqual(cf.get("Foo Bar", "foo"), "newbar")
+ # check when we pass only a filename:
+ cf = self.newconfig()
+ parsed_files = cf.read(file1)
+ self.assertEqual(parsed_files, [file1])
+ self.assertEqual(cf.get("Foo Bar", "foo"), "newbar")
+ # check when we pass only missing files:
+ cf = self.newconfig()
+ parsed_files = cf.read(["nonexistent-file"])
+ self.assertEqual(parsed_files, [])
+ # check when we pass no files:
+ cf = self.newconfig()
+ parsed_files = cf.read([])
+ self.assertEqual(parsed_files, [])
+
+ # shared by subclasses
+ def get_interpolation_config(self):
+ return self.fromstring(
+ "[Foo]\n"
+ "bar=something %(with1)s interpolation (1 step)\n"
+ "bar9=something %(with9)s lots of interpolation (9 steps)\n"
+ "bar10=something %(with10)s lots of interpolation (10 steps)\n"
+ "bar11=something %(with11)s lots of interpolation (11 steps)\n"
+ "with11=%(with10)s\n"
+ "with10=%(with9)s\n"
+ "with9=%(with8)s\n"
+ "with8=%(With7)s\n"
+ "with7=%(WITH6)s\n"
+ "with6=%(with5)s\n"
+ "With5=%(with4)s\n"
+ "WITH4=%(with3)s\n"
+ "with3=%(with2)s\n"
+ "with2=%(with1)s\n"
+ "with1=with\n"
+ "\n"
+ "[Mutual Recursion]\n"
+ "foo=%(bar)s\n"
+ "bar=%(foo)s\n"
+ "\n"
+ "[Interpolation Error]\n"
+ "name=%(reference)s\n",
+ # no definition for 'reference'
+ defaults={"getname": "%(__name__)s"})
+
+ def check_items_config(self, expected):
+ cf = self.fromstring(
+ "[section]\n"
+ "name = value\n"
+ "key: |%(name)s| \n"
+ "getdefault: |%(default)s|\n"
+ "getname: |%(__name__)s|",
+ defaults={"default": "<default>"})
+ L = list(cf.items("section"))
+ L.sort()
+ self.assertEqual(L, expected)
+
+
+class ConfigParserTestCase(TestCaseBase):
+ config_class = ConfigParser.ConfigParser
+ allow_no_value = True
+
+ def test_interpolation(self):
+ rawval = {
+ ConfigParser.ConfigParser: ("something %(with11)s "
+ "lots of interpolation (11 steps)"),
+ ConfigParser.SafeConfigParser: "%(with1)s",
+ }
+ cf = self.get_interpolation_config()
+ eq = self.assertEqual
+ eq(cf.get("Foo", "getname"), "Foo")
+ eq(cf.get("Foo", "bar"), "something with interpolation (1 step)")
+ eq(cf.get("Foo", "bar9"),
+ "something with lots of interpolation (9 steps)")
+ eq(cf.get("Foo", "bar10"),
+ "something with lots of interpolation (10 steps)")
+ self.get_error(ConfigParser.InterpolationDepthError, "Foo", "bar11")
+
+ def test_interpolation_missing_value(self):
+ self.get_interpolation_config()
+ e = self.get_error(ConfigParser.InterpolationError,
+ "Interpolation Error", "name")
+ self.assertEqual(e.reference, "reference")
+ self.assertEqual(e.section, "Interpolation Error")
+ self.assertEqual(e.option, "name")
+
+ def test_items(self):
+ self.check_items_config([('default', '<default>'),
+ ('getdefault', '|<default>|'),
+ ('getname', '|section|'),
+ ('key', '|value|'),
+ ('name', 'value')])
+
+ def test_set_nonstring_types(self):
+ cf = self.newconfig()
+ cf.add_section('non-string')
+ cf.set('non-string', 'int', 1)
+ cf.set('non-string', 'list', [0, 1, 1, 2, 3, 5, 8, 13, '%('])
+ cf.set('non-string', 'dict', {'pi': 3.14159, '%(': 1,
+ '%(list)': '%(list)'})
+ cf.set('non-string', 'string_with_interpolation', '%(list)s')
+ cf.set('non-string', 'no-value')
+ self.assertEqual(cf.get('non-string', 'int', raw=True), 1)
+ self.assertRaises(TypeError, cf.get, 'non-string', 'int')
+ self.assertEqual(cf.get('non-string', 'list', raw=True),
+ [0, 1, 1, 2, 3, 5, 8, 13, '%('])
+ self.assertRaises(TypeError, cf.get, 'non-string', 'list')
+ self.assertEqual(cf.get('non-string', 'dict', raw=True),
+ {'pi': 3.14159, '%(': 1, '%(list)': '%(list)'})
+ self.assertRaises(TypeError, cf.get, 'non-string', 'dict')
+ self.assertEqual(cf.get('non-string', 'string_with_interpolation',
+ raw=True), '%(list)s')
+ self.assertRaises(ValueError, cf.get, 'non-string',
+ 'string_with_interpolation', raw=False)
+ self.assertEqual(cf.get('non-string', 'no-value'), None)
+
+class MultilineValuesTestCase(TestCaseBase):
+ config_class = ConfigParser.ConfigParser
+ wonderful_spam = ("I'm having spam spam spam spam "
+ "spam spam spam beaked beans spam "
+ "spam spam and spam!").replace(' ', '\t\n')
+
+ def setUp(self):
+ cf = self.newconfig()
+ for i in range(100):
+ s = 'section{}'.format(i)
+ cf.add_section(s)
+ for j in range(10):
+ cf.set(s, 'lovely_spam{}'.format(j), self.wonderful_spam)
+ with open(test_support.TESTFN, 'w') as f:
+ cf.write(f)
+
+ def tearDown(self):
+ os.unlink(test_support.TESTFN)
+
+ def test_dominating_multiline_values(self):
+ # we're reading from file because this is where the code changed
+ # during performance updates in Python 3.2
+ cf_from_file = self.newconfig()
+ with open(test_support.TESTFN) as f:
+ cf_from_file.readfp(f)
+ self.assertEqual(cf_from_file.get('section8', 'lovely_spam4'),
+ self.wonderful_spam.replace('\t\n', '\n'))
+
+class RawConfigParserTestCase(TestCaseBase):
+ config_class = ConfigParser.RawConfigParser
+
+ def test_interpolation(self):
+ cf = self.get_interpolation_config()
+ eq = self.assertEqual
+ eq(cf.get("Foo", "getname"), "%(__name__)s")
+ eq(cf.get("Foo", "bar"),
+ "something %(with1)s interpolation (1 step)")
+ eq(cf.get("Foo", "bar9"),
+ "something %(with9)s lots of interpolation (9 steps)")
+ eq(cf.get("Foo", "bar10"),
+ "something %(with10)s lots of interpolation (10 steps)")
+ eq(cf.get("Foo", "bar11"),
+ "something %(with11)s lots of interpolation (11 steps)")
+
+ def test_items(self):
+ self.check_items_config([('default', '<default>'),
+ ('getdefault', '|%(default)s|'),
+ ('getname', '|%(__name__)s|'),
+ ('key', '|%(name)s|'),
+ ('name', 'value')])
+
+ def test_set_nonstring_types(self):
+ cf = self.newconfig()
+ cf.add_section('non-string')
+ cf.set('non-string', 'int', 1)
+ cf.set('non-string', 'list', [0, 1, 1, 2, 3, 5, 8, 13])
+ cf.set('non-string', 'dict', {'pi': 3.14159})
+ self.assertEqual(cf.get('non-string', 'int'), 1)
+ self.assertEqual(cf.get('non-string', 'list'),
+ [0, 1, 1, 2, 3, 5, 8, 13])
+ self.assertEqual(cf.get('non-string', 'dict'), {'pi': 3.14159})
+
+
+class SafeConfigParserTestCase(ConfigParserTestCase):
+ config_class = ConfigParser.SafeConfigParser
+
+ def test_safe_interpolation(self):
+ # See http://www.python.org/sf/511737
+ cf = self.fromstring("[section]\n"
+ "option1=xxx\n"
+ "option2=%(option1)s/xxx\n"
+ "ok=%(option1)s/%%s\n"
+ "not_ok=%(option2)s/%%s")
+ self.assertEqual(cf.get("section", "ok"), "xxx/%s")
+ self.assertEqual(cf.get("section", "not_ok"), "xxx/xxx/%s")
+
+ def test_set_malformatted_interpolation(self):
+ cf = self.fromstring("[sect]\n"
+ "option1=foo\n")
+
+ self.assertEqual(cf.get('sect', "option1"), "foo")
+
+ self.assertRaises(ValueError, cf.set, "sect", "option1", "%foo")
+ self.assertRaises(ValueError, cf.set, "sect", "option1", "foo%")
+ self.assertRaises(ValueError, cf.set, "sect", "option1", "f%oo")
+
+ self.assertEqual(cf.get('sect', "option1"), "foo")
+
+ # bug #5741: double percents are *not* malformed
+ cf.set("sect", "option2", "foo%%bar")
+ self.assertEqual(cf.get("sect", "option2"), "foo%bar")
+
+ def test_set_nonstring_types(self):
+ cf = self.fromstring("[sect]\n"
+ "option1=foo\n")
+ # Check that we get a TypeError when setting non-string values
+ # in an existing section:
+ self.assertRaises(TypeError, cf.set, "sect", "option1", 1)
+ self.assertRaises(TypeError, cf.set, "sect", "option1", 1.0)
+ self.assertRaises(TypeError, cf.set, "sect", "option1", object())
+ self.assertRaises(TypeError, cf.set, "sect", "option2", 1)
+ self.assertRaises(TypeError, cf.set, "sect", "option2", 1.0)
+ self.assertRaises(TypeError, cf.set, "sect", "option2", object())
+
+ def test_add_section_default_1(self):
+ cf = self.newconfig()
+ self.assertRaises(ValueError, cf.add_section, "default")
+
+ def test_add_section_default_2(self):
+ cf = self.newconfig()
+ self.assertRaises(ValueError, cf.add_section, "DEFAULT")
+
+
+class SafeConfigParserTestCaseNoValue(SafeConfigParserTestCase):
+ allow_no_value = True
+
+class TestChainMap(unittest.TestCase):
+ def test_issue_12717(self):
+ d1 = dict(red=1, green=2)
+ d2 = dict(green=3, blue=4)
+ dcomb = d2.copy()
+ dcomb.update(d1)
+ cm = ConfigParser._Chainmap(d1, d2)
+ self.assertIsInstance(cm.keys(), list)
+ self.assertEqual(set(cm.keys()), set(dcomb.keys())) # keys()
+ self.assertEqual(set(cm.values()), set(dcomb.values())) # values()
+ self.assertEqual(set(cm.items()), set(dcomb.items())) # items()
+ self.assertEqual(set(cm), set(dcomb)) # __iter__ ()
+ self.assertEqual(cm, dcomb) # __eq__()
+ self.assertEqual([cm[k] for k in dcomb], dcomb.values()) # __getitem__()
+ klist = 'red green blue black brown'.split()
+ self.assertEqual([cm.get(k, 10) for k in klist],
+ [dcomb.get(k, 10) for k in klist]) # get()
+ self.assertEqual([k in cm for k in klist],
+ [k in dcomb for k in klist]) # __contains__()
+ with test_support.check_py3k_warnings():
+ self.assertEqual([cm.has_key(k) for k in klist],
+ [dcomb.has_key(k) for k in klist]) # has_key()
+
+class Issue7005TestCase(unittest.TestCase):
+ """Test output when None is set() as a value and allow_no_value == False.
+
+ http://bugs.python.org/issue7005
+
+ """
+
+ expected_output = "[section]\noption = None\n\n"
+
+ def prepare(self, config_class):
+ # This is the default, but that's the point.
+ cp = config_class(allow_no_value=False)
+ cp.add_section("section")
+ cp.set("section", "option", None)
+ sio = StringIO.StringIO()
+ cp.write(sio)
+ return sio.getvalue()
+
+ def test_none_as_value_stringified(self):
+ output = self.prepare(ConfigParser.ConfigParser)
+ self.assertEqual(output, self.expected_output)
+
+ def test_none_as_value_stringified_raw(self):
+ output = self.prepare(ConfigParser.RawConfigParser)
+ self.assertEqual(output, self.expected_output)
+
+
+class SortedTestCase(RawConfigParserTestCase):
+ def newconfig(self, defaults=None):
+ self.cf = self.config_class(defaults=defaults, dict_type=SortedDict)
+ return self.cf
+
+ def test_sorted(self):
+ self.fromstring("[b]\n"
+ "o4=1\n"
+ "o3=2\n"
+ "o2=3\n"
+ "o1=4\n"
+ "[a]\n"
+ "k=v\n")
+ output = StringIO.StringIO()
+ self.cf.write(output)
+ self.assertEqual(output.getvalue(),
+ "[a]\n"
+ "k = v\n\n"
+ "[b]\n"
+ "o1 = 4\n"
+ "o2 = 3\n"
+ "o3 = 2\n"
+ "o4 = 1\n\n")
+
+
+class ExceptionPicklingTestCase(unittest.TestCase):
+ """Tests for issue #13760: ConfigParser exceptions are not picklable."""
+
+ def test_error(self):
+ import pickle
+ e1 = ConfigParser.Error('value')
+ pickled = pickle.dumps(e1)
+ e2 = pickle.loads(pickled)
+ self.assertEqual(e1.message, e2.message)
+ self.assertEqual(repr(e1), repr(e2))
+
+ def test_nosectionerror(self):
+ import pickle
+ e1 = ConfigParser.NoSectionError('section')
+ pickled = pickle.dumps(e1)
+ e2 = pickle.loads(pickled)
+ self.assertEqual(e1.message, e2.message)
+ self.assertEqual(e1.args, e2.args)
+ self.assertEqual(e1.section, e2.section)
+ self.assertEqual(repr(e1), repr(e2))
+
+ def test_nooptionerror(self):
+ import pickle
+ e1 = ConfigParser.NoOptionError('option', 'section')
+ pickled = pickle.dumps(e1)
+ e2 = pickle.loads(pickled)
+ self.assertEqual(e1.message, e2.message)
+ self.assertEqual(e1.args, e2.args)
+ self.assertEqual(e1.section, e2.section)
+ self.assertEqual(e1.option, e2.option)
+ self.assertEqual(repr(e1), repr(e2))
+
+ def test_duplicatesectionerror(self):
+ import pickle
+ e1 = ConfigParser.DuplicateSectionError('section')
+ pickled = pickle.dumps(e1)
+ e2 = pickle.loads(pickled)
+ self.assertEqual(e1.message, e2.message)
+ self.assertEqual(e1.args, e2.args)
+ self.assertEqual(e1.section, e2.section)
+ self.assertEqual(repr(e1), repr(e2))
+
+ def test_interpolationerror(self):
+ import pickle
+ e1 = ConfigParser.InterpolationError('option', 'section', 'msg')
+ pickled = pickle.dumps(e1)
+ e2 = pickle.loads(pickled)
+ self.assertEqual(e1.message, e2.message)
+ self.assertEqual(e1.args, e2.args)
+ self.assertEqual(e1.section, e2.section)
+ self.assertEqual(e1.option, e2.option)
+ self.assertEqual(repr(e1), repr(e2))
+
+ def test_interpolationmissingoptionerror(self):
+ import pickle
+ e1 = ConfigParser.InterpolationMissingOptionError('option', 'section',
+ 'rawval', 'reference')
+ pickled = pickle.dumps(e1)
+ e2 = pickle.loads(pickled)
+ self.assertEqual(e1.message, e2.message)
+ self.assertEqual(e1.args, e2.args)
+ self.assertEqual(e1.section, e2.section)
+ self.assertEqual(e1.option, e2.option)
+ self.assertEqual(e1.reference, e2.reference)
+ self.assertEqual(repr(e1), repr(e2))
+
+ def test_interpolationsyntaxerror(self):
+ import pickle
+ e1 = ConfigParser.InterpolationSyntaxError('option', 'section', 'msg')
+ pickled = pickle.dumps(e1)
+ e2 = pickle.loads(pickled)
+ self.assertEqual(e1.message, e2.message)
+ self.assertEqual(e1.args, e2.args)
+ self.assertEqual(e1.section, e2.section)
+ self.assertEqual(e1.option, e2.option)
+ self.assertEqual(repr(e1), repr(e2))
+
+ def test_interpolationdeptherror(self):
+ import pickle
+ e1 = ConfigParser.InterpolationDepthError('option', 'section',
+ 'rawval')
+ pickled = pickle.dumps(e1)
+ e2 = pickle.loads(pickled)
+ self.assertEqual(e1.message, e2.message)
+ self.assertEqual(e1.args, e2.args)
+ self.assertEqual(e1.section, e2.section)
+ self.assertEqual(e1.option, e2.option)
+ self.assertEqual(repr(e1), repr(e2))
+
+ def test_parsingerror(self):
+ import pickle
+ e1 = ConfigParser.ParsingError('source')
+ e1.append(1, 'line1')
+ e1.append(2, 'line2')
+ e1.append(3, 'line3')
+ pickled = pickle.dumps(e1)
+ e2 = pickle.loads(pickled)
+ self.assertEqual(e1.message, e2.message)
+ self.assertEqual(e1.args, e2.args)
+ self.assertEqual(e1.filename, e2.filename)
+ self.assertEqual(e1.errors, e2.errors)
+ self.assertEqual(repr(e1), repr(e2))
+
+ def test_missingsectionheadererror(self):
+ import pickle
+ e1 = ConfigParser.MissingSectionHeaderError('filename', 123, 'line')
+ pickled = pickle.dumps(e1)
+ e2 = pickle.loads(pickled)
+ self.assertEqual(e1.message, e2.message)
+ self.assertEqual(e1.args, e2.args)
+ self.assertEqual(e1.line, e2.line)
+ self.assertEqual(e1.filename, e2.filename)
+ self.assertEqual(e1.lineno, e2.lineno)
+ self.assertEqual(repr(e1), repr(e2))
+
+
+def test_main():
+ test_support.run_unittest(
+ ConfigParserTestCase,
+ MultilineValuesTestCase,
+ RawConfigParserTestCase,
+ SafeConfigParserTestCase,
+ SafeConfigParserTestCaseNoValue,
+ SortedTestCase,
+ Issue7005TestCase,
+ TestChainMap,
+ ExceptionPicklingTestCase,
+ )
+
+
+if __name__ == "__main__":
+ test_main()
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-15 00:05:52 +0000