Python code coverage for Lib/test/test_cfgparser.py

#	count	content
1	n/a	import collections
2	n/a	import configparser
3	n/a	import io
4	n/a	import os
5	n/a	import sys
6	n/a	import textwrap
7	n/a	import unittest
8	n/a	import warnings
9	n/a
10	n/a	from test import support
11	n/a
12	n/a	class SortedDict(collections.UserDict):
13	n/a
14	n/a	def items(self):
15	n/a	return sorted(self.data.items())
16	n/a
17	n/a	def keys(self):
18	n/a	return sorted(self.data.keys())
19	n/a
20	n/a	def values(self):
21	n/a	return [i[1] for i in self.items()]
22	n/a
23	n/a	def iteritems(self): return iter(self.items())
24	n/a	def iterkeys(self): return iter(self.keys())
25	n/a	__iter__ = iterkeys
26	n/a	def itervalues(self): return iter(self.values())
27	n/a
28	n/a
29	n/a	class CfgParserTestCaseClass(unittest.TestCase):
30	n/a	allow_no_value = False
31	n/a	delimiters = ('=', ':')
32	n/a	comment_prefixes = (';', '#')
33	n/a	inline_comment_prefixes = (';', '#')
34	n/a	empty_lines_in_values = True
35	n/a	dict_type = configparser._default_dict
36	n/a	strict = False
37	n/a	default_section = configparser.DEFAULTSECT
38	n/a	interpolation = configparser._UNSET
39	n/a
40	n/a	def newconfig(self, defaults=None):
41	n/a	arguments = dict(
42	n/a	defaults=defaults,
43	n/a	allow_no_value=self.allow_no_value,
44	n/a	delimiters=self.delimiters,
45	n/a	comment_prefixes=self.comment_prefixes,
46	n/a	inline_comment_prefixes=self.inline_comment_prefixes,
47	n/a	empty_lines_in_values=self.empty_lines_in_values,
48	n/a	dict_type=self.dict_type,
49	n/a	strict=self.strict,
50	n/a	default_section=self.default_section,
51	n/a	interpolation=self.interpolation,
52	n/a	)
53	n/a	instance = self.config_class(**arguments)
54	n/a	return instance
55	n/a
56	n/a	def fromstring(self, string, defaults=None):
57	n/a	cf = self.newconfig(defaults)
58	n/a	cf.read_string(string)
59	n/a	return cf
60	n/a
61	n/a	class BasicTestCase(CfgParserTestCaseClass):
62	n/a
63	n/a	def basic_test(self, cf):
64	n/a	E = ['Commented Bar',
65	n/a	'Foo Bar',
66	n/a	'Internationalized Stuff',
67	n/a	'Long Line',
68	n/a	'Section\\with$weird%characters[\t',
69	n/a	'Spaces',
70	n/a	'Spacey Bar',
71	n/a	'Spacey Bar From The Beginning',
72	n/a	'Types',
73	n/a	]
74	n/a
75	n/a	if self.allow_no_value:
76	n/a	E.append('NoValue')
77	n/a	E.sort()
78	n/a	F = [('baz', 'qwe'), ('foo', 'bar3')]
79	n/a
80	n/a	# API access
81	n/a	L = cf.sections()
82	n/a	L.sort()
83	n/a	eq = self.assertEqual
84	n/a	eq(L, E)
85	n/a	L = cf.items('Spacey Bar From The Beginning')
86	n/a	L.sort()
87	n/a	eq(L, F)
88	n/a
89	n/a	# mapping access
90	n/a	L = [section for section in cf]
91	n/a	L.sort()
92	n/a	E.append(self.default_section)
93	n/a	E.sort()
94	n/a	eq(L, E)
95	n/a	L = cf['Spacey Bar From The Beginning'].items()
96	n/a	L = sorted(list(L))
97	n/a	eq(L, F)
98	n/a	L = cf.items()
99	n/a	L = sorted(list(L))
100	n/a	self.assertEqual(len(L), len(E))
101	n/a	for name, section in L:
102	n/a	eq(name, section.name)
103	n/a	eq(cf.defaults(), cf[self.default_section])
104	n/a
105	n/a	# The use of spaces in the section names serves as a
106	n/a	# regression test for SourceForge bug #583248:
107	n/a	# http://www.python.org/sf/583248
108	n/a
109	n/a	# API access
110	n/a	eq(cf.get('Foo Bar', 'foo'), 'bar1')
111	n/a	eq(cf.get('Spacey Bar', 'foo'), 'bar2')
112	n/a	eq(cf.get('Spacey Bar From The Beginning', 'foo'), 'bar3')
113	n/a	eq(cf.get('Spacey Bar From The Beginning', 'baz'), 'qwe')
114	n/a	eq(cf.get('Commented Bar', 'foo'), 'bar4')
115	n/a	eq(cf.get('Commented Bar', 'baz'), 'qwe')
116	n/a	eq(cf.get('Spaces', 'key with spaces'), 'value')
117	n/a	eq(cf.get('Spaces', 'another with spaces'), 'splat!')
118	n/a	eq(cf.getint('Types', 'int'), 42)
119	n/a	eq(cf.get('Types', 'int'), "42")
120	n/a	self.assertAlmostEqual(cf.getfloat('Types', 'float'), 0.44)
121	n/a	eq(cf.get('Types', 'float'), "0.44")
122	n/a	eq(cf.getboolean('Types', 'boolean'), False)
123	n/a	eq(cf.get('Types', '123'), 'strange but acceptable')
124	n/a	if self.allow_no_value:
125	n/a	eq(cf.get('NoValue', 'option-without-value'), None)
126	n/a
127	n/a	# test vars= and fallback=
128	n/a	eq(cf.get('Foo Bar', 'foo', fallback='baz'), 'bar1')
129	n/a	eq(cf.get('Foo Bar', 'foo', vars={'foo': 'baz'}), 'baz')
130	n/a	with self.assertRaises(configparser.NoSectionError):
131	n/a	cf.get('No Such Foo Bar', 'foo')
132	n/a	with self.assertRaises(configparser.NoOptionError):
133	n/a	cf.get('Foo Bar', 'no-such-foo')
134	n/a	eq(cf.get('No Such Foo Bar', 'foo', fallback='baz'), 'baz')
135	n/a	eq(cf.get('Foo Bar', 'no-such-foo', fallback='baz'), 'baz')
136	n/a	eq(cf.get('Spacey Bar', 'foo', fallback=None), 'bar2')
137	n/a	eq(cf.get('No Such Spacey Bar', 'foo', fallback=None), None)
138	n/a	eq(cf.getint('Types', 'int', fallback=18), 42)
139	n/a	eq(cf.getint('Types', 'no-such-int', fallback=18), 18)
140	n/a	eq(cf.getint('Types', 'no-such-int', fallback="18"), "18") # sic!
141	n/a	with self.assertRaises(configparser.NoOptionError):
142	n/a	cf.getint('Types', 'no-such-int')
143	n/a	self.assertAlmostEqual(cf.getfloat('Types', 'float',
144	n/a	fallback=0.0), 0.44)
145	n/a	self.assertAlmostEqual(cf.getfloat('Types', 'no-such-float',
146	n/a	fallback=0.0), 0.0)
147	n/a	eq(cf.getfloat('Types', 'no-such-float', fallback="0.0"), "0.0") # sic!
148	n/a	with self.assertRaises(configparser.NoOptionError):
149	n/a	cf.getfloat('Types', 'no-such-float')
150	n/a	eq(cf.getboolean('Types', 'boolean', fallback=True), False)
151	n/a	eq(cf.getboolean('Types', 'no-such-boolean', fallback="yes"),
152	n/a	"yes") # sic!
153	n/a	eq(cf.getboolean('Types', 'no-such-boolean', fallback=True), True)
154	n/a	with self.assertRaises(configparser.NoOptionError):
155	n/a	cf.getboolean('Types', 'no-such-boolean')
156	n/a	eq(cf.getboolean('No Such Types', 'boolean', fallback=True), True)
157	n/a	if self.allow_no_value:
158	n/a	eq(cf.get('NoValue', 'option-without-value', fallback=False), None)
159	n/a	eq(cf.get('NoValue', 'no-such-option-without-value',
160	n/a	fallback=False), False)
161	n/a
162	n/a	# mapping access
163	n/a	eq(cf['Foo Bar']['foo'], 'bar1')
164	n/a	eq(cf['Spacey Bar']['foo'], 'bar2')
165	n/a	section = cf['Spacey Bar From The Beginning']
166	n/a	eq(section.name, 'Spacey Bar From The Beginning')
167	n/a	self.assertIs(section.parser, cf)
168	n/a	with self.assertRaises(AttributeError):
169	n/a	section.name = 'Name is read-only'
170	n/a	with self.assertRaises(AttributeError):
171	n/a	section.parser = 'Parser is read-only'
172	n/a	eq(section['foo'], 'bar3')
173	n/a	eq(section['baz'], 'qwe')
174	n/a	eq(cf['Commented Bar']['foo'], 'bar4')
175	n/a	eq(cf['Commented Bar']['baz'], 'qwe')
176	n/a	eq(cf['Spaces']['key with spaces'], 'value')
177	n/a	eq(cf['Spaces']['another with spaces'], 'splat!')
178	n/a	eq(cf['Long Line']['foo'],
179	n/a	'this line is much, much longer than my editor\nlikes it.')
180	n/a	if self.allow_no_value:
181	n/a	eq(cf['NoValue']['option-without-value'], None)
182	n/a	# test vars= and fallback=
183	n/a	eq(cf['Foo Bar'].get('foo', 'baz'), 'bar1')
184	n/a	eq(cf['Foo Bar'].get('foo', fallback='baz'), 'bar1')
185	n/a	eq(cf['Foo Bar'].get('foo', vars={'foo': 'baz'}), 'baz')
186	n/a	with self.assertRaises(KeyError):
187	n/a	cf['No Such Foo Bar']['foo']
188	n/a	with self.assertRaises(KeyError):
189	n/a	cf['Foo Bar']['no-such-foo']
190	n/a	with self.assertRaises(KeyError):
191	n/a	cf['No Such Foo Bar'].get('foo', fallback='baz')
192	n/a	eq(cf['Foo Bar'].get('no-such-foo', 'baz'), 'baz')
193	n/a	eq(cf['Foo Bar'].get('no-such-foo', fallback='baz'), 'baz')
194	n/a	eq(cf['Foo Bar'].get('no-such-foo'), None)
195	n/a	eq(cf['Spacey Bar'].get('foo', None), 'bar2')
196	n/a	eq(cf['Spacey Bar'].get('foo', fallback=None), 'bar2')
197	n/a	with self.assertRaises(KeyError):
198	n/a	cf['No Such Spacey Bar'].get('foo', None)
199	n/a	eq(cf['Types'].getint('int', 18), 42)
200	n/a	eq(cf['Types'].getint('int', fallback=18), 42)
201	n/a	eq(cf['Types'].getint('no-such-int', 18), 18)
202	n/a	eq(cf['Types'].getint('no-such-int', fallback=18), 18)
203	n/a	eq(cf['Types'].getint('no-such-int', "18"), "18") # sic!
204	n/a	eq(cf['Types'].getint('no-such-int', fallback="18"), "18") # sic!
205	n/a	eq(cf['Types'].getint('no-such-int'), None)
206	n/a	self.assertAlmostEqual(cf['Types'].getfloat('float', 0.0), 0.44)
207	n/a	self.assertAlmostEqual(cf['Types'].getfloat('float',
208	n/a	fallback=0.0), 0.44)
209	n/a	self.assertAlmostEqual(cf['Types'].getfloat('no-such-float', 0.0), 0.0)
210	n/a	self.assertAlmostEqual(cf['Types'].getfloat('no-such-float',
211	n/a	fallback=0.0), 0.0)
212	n/a	eq(cf['Types'].getfloat('no-such-float', "0.0"), "0.0") # sic!
213	n/a	eq(cf['Types'].getfloat('no-such-float', fallback="0.0"), "0.0") # sic!
214	n/a	eq(cf['Types'].getfloat('no-such-float'), None)
215	n/a	eq(cf['Types'].getboolean('boolean', True), False)
216	n/a	eq(cf['Types'].getboolean('boolean', fallback=True), False)
217	n/a	eq(cf['Types'].getboolean('no-such-boolean', "yes"), "yes") # sic!
218	n/a	eq(cf['Types'].getboolean('no-such-boolean', fallback="yes"),
219	n/a	"yes") # sic!
220	n/a	eq(cf['Types'].getboolean('no-such-boolean', True), True)
221	n/a	eq(cf['Types'].getboolean('no-such-boolean', fallback=True), True)
222	n/a	eq(cf['Types'].getboolean('no-such-boolean'), None)
223	n/a	if self.allow_no_value:
224	n/a	eq(cf['NoValue'].get('option-without-value', False), None)
225	n/a	eq(cf['NoValue'].get('option-without-value', fallback=False), None)
226	n/a	eq(cf['NoValue'].get('no-such-option-without-value', False), False)
227	n/a	eq(cf['NoValue'].get('no-such-option-without-value',
228	n/a	fallback=False), False)
229	n/a
230	n/a	# Make sure the right things happen for remove_section() and
231	n/a	# remove_option(); added to include check for SourceForge bug #123324.
232	n/a
233	n/a	cf[self.default_section]['this_value'] = '1'
234	n/a	cf[self.default_section]['that_value'] = '2'
235	n/a
236	n/a	# API access
237	n/a	self.assertTrue(cf.remove_section('Spaces'))
238	n/a	self.assertFalse(cf.has_option('Spaces', 'key with spaces'))
239	n/a	self.assertFalse(cf.remove_section('Spaces'))
240	n/a	self.assertFalse(cf.remove_section(self.default_section))
241	n/a	self.assertTrue(cf.remove_option('Foo Bar', 'foo'),
242	n/a	"remove_option() failed to report existence of option")
243	n/a	self.assertFalse(cf.has_option('Foo Bar', 'foo'),
244	n/a	"remove_option() failed to remove option")
245	n/a	self.assertFalse(cf.remove_option('Foo Bar', 'foo'),
246	n/a	"remove_option() failed to report non-existence of option"
247	n/a	" that was removed")
248	n/a	self.assertTrue(cf.has_option('Foo Bar', 'this_value'))
249	n/a	self.assertFalse(cf.remove_option('Foo Bar', 'this_value'))
250	n/a	self.assertTrue(cf.remove_option(self.default_section, 'this_value'))
251	n/a	self.assertFalse(cf.has_option('Foo Bar', 'this_value'))
252	n/a	self.assertFalse(cf.remove_option(self.default_section, 'this_value'))
253	n/a
254	n/a	with self.assertRaises(configparser.NoSectionError) as cm:
255	n/a	cf.remove_option('No Such Section', 'foo')
256	n/a	self.assertEqual(cm.exception.args, ('No Such Section',))
257	n/a
258	n/a	eq(cf.get('Long Line', 'foo'),
259	n/a	'this line is much, much longer than my editor\nlikes it.')
260	n/a
261	n/a	# mapping access
262	n/a	del cf['Types']
263	n/a	self.assertFalse('Types' in cf)
264	n/a	with self.assertRaises(KeyError):
265	n/a	del cf['Types']
266	n/a	with self.assertRaises(ValueError):
267	n/a	del cf[self.default_section]
268	n/a	del cf['Spacey Bar']['foo']
269	n/a	self.assertFalse('foo' in cf['Spacey Bar'])
270	n/a	with self.assertRaises(KeyError):
271	n/a	del cf['Spacey Bar']['foo']
272	n/a	self.assertTrue('that_value' in cf['Spacey Bar'])
273	n/a	with self.assertRaises(KeyError):
274	n/a	del cf['Spacey Bar']['that_value']
275	n/a	del cf[self.default_section]['that_value']
276	n/a	self.assertFalse('that_value' in cf['Spacey Bar'])
277	n/a	with self.assertRaises(KeyError):
278	n/a	del cf[self.default_section]['that_value']
279	n/a	with self.assertRaises(KeyError):
280	n/a	del cf['No Such Section']['foo']
281	n/a
282	n/a	# Don't add new asserts below in this method as most of the options
283	n/a	# and sections are now removed.
284	n/a
285	n/a	def test_basic(self):
286	n/a	config_string = """\
287	n/a	[Foo Bar]
288	n/a	foo{0[0]}bar1
289	n/a	[Spacey Bar]
290	n/a	foo {0[0]} bar2
291	n/a	[Spacey Bar From The Beginning]
292	n/a	foo {0[0]} bar3
293	n/a	baz {0[0]} qwe
294	n/a	[Commented Bar]
295	n/a	foo{0[1]} bar4 {1[1]} comment
296	n/a	baz{0[0]}qwe {1[0]}another one
297	n/a	[Long Line]
298	n/a	foo{0[1]} this line is much, much longer than my editor
299	n/a	likes it.
300	n/a	[Section\\with$weird%characters[\t]
301	n/a	[Internationalized Stuff]
302	n/a	foo[bg]{0[1]} Bulgarian
303	n/a	foo{0[0]}Default
304	n/a	foo[en]{0[0]}English
305	n/a	foo[de]{0[0]}Deutsch
306	n/a	[Spaces]
307	n/a	key with spaces {0[1]} value
308	n/a	another with spaces {0[0]} splat!
309	n/a	[Types]
310	n/a	int {0[1]} 42
311	n/a	float {0[0]} 0.44
312	n/a	boolean {0[0]} NO
313	n/a	123 {0[1]} strange but acceptable
314	n/a	""".format(self.delimiters, self.comment_prefixes)
315	n/a	if self.allow_no_value:
316	n/a	config_string += (
317	n/a	"[NoValue]\n"
318	n/a	"option-without-value\n"
319	n/a	)
320	n/a	cf = self.fromstring(config_string)
321	n/a	self.basic_test(cf)
322	n/a	if self.strict:
323	n/a	with self.assertRaises(configparser.DuplicateOptionError):
324	n/a	cf.read_string(textwrap.dedent("""\
325	n/a	[Duplicate Options Here]
326	n/a	option {0[0]} with a value
327	n/a	option {0[1]} with another value
328	n/a	""".format(self.delimiters)))
329	n/a	with self.assertRaises(configparser.DuplicateSectionError):
330	n/a	cf.read_string(textwrap.dedent("""\
331	n/a	[And Now For Something]
332	n/a	completely different {0[0]} True
333	n/a	[And Now For Something]
334	n/a	the larch {0[1]} 1
335	n/a	""".format(self.delimiters)))
336	n/a	else:
337	n/a	cf.read_string(textwrap.dedent("""\
338	n/a	[Duplicate Options Here]
339	n/a	option {0[0]} with a value
340	n/a	option {0[1]} with another value
341	n/a	""".format(self.delimiters)))
342	n/a
343	n/a	cf.read_string(textwrap.dedent("""\
344	n/a	[And Now For Something]
345	n/a	completely different {0[0]} True
346	n/a	[And Now For Something]
347	n/a	the larch {0[1]} 1
348	n/a	""".format(self.delimiters)))
349	n/a
350	n/a	def test_basic_from_dict(self):
351	n/a	config = {
352	n/a	"Foo Bar": {
353	n/a	"foo": "bar1",
354	n/a	},
355	n/a	"Spacey Bar": {
356	n/a	"foo": "bar2",
357	n/a	},
358	n/a	"Spacey Bar From The Beginning": {
359	n/a	"foo": "bar3",
360	n/a	"baz": "qwe",
361	n/a	},
362	n/a	"Commented Bar": {
363	n/a	"foo": "bar4",
364	n/a	"baz": "qwe",
365	n/a	},
366	n/a	"Long Line": {
367	n/a	"foo": "this line is much, much longer than my editor\nlikes "
368	n/a	"it.",
369	n/a	},
370	n/a	"Section\\with$weird%characters[\t": {
371	n/a	},
372	n/a	"Internationalized Stuff": {
373	n/a	"foo[bg]": "Bulgarian",
374	n/a	"foo": "Default",
375	n/a	"foo[en]": "English",
376	n/a	"foo[de]": "Deutsch",
377	n/a	},
378	n/a	"Spaces": {
379	n/a	"key with spaces": "value",
380	n/a	"another with spaces": "splat!",
381	n/a	},
382	n/a	"Types": {
383	n/a	"int": 42,
384	n/a	"float": 0.44,
385	n/a	"boolean": False,
386	n/a	123: "strange but acceptable",
387	n/a	},
388	n/a	}
389	n/a	if self.allow_no_value:
390	n/a	config.update({
391	n/a	"NoValue": {
392	n/a	"option-without-value": None,
393	n/a	}
394	n/a	})
395	n/a	cf = self.newconfig()
396	n/a	cf.read_dict(config)
397	n/a	self.basic_test(cf)
398	n/a	if self.strict:
399	n/a	with self.assertRaises(configparser.DuplicateSectionError):
400	n/a	cf.read_dict({
401	n/a	'1': {'key': 'value'},
402	n/a	1: {'key2': 'value2'},
403	n/a	})
404	n/a	with self.assertRaises(configparser.DuplicateOptionError):
405	n/a	cf.read_dict({
406	n/a	"Duplicate Options Here": {
407	n/a	'option': 'with a value',
408	n/a	'OPTION': 'with another value',
409	n/a	},
410	n/a	})
411	n/a	else:
412	n/a	cf.read_dict({
413	n/a	'section': {'key': 'value'},
414	n/a	'SECTION': {'key2': 'value2'},
415	n/a	})
416	n/a	cf.read_dict({
417	n/a	"Duplicate Options Here": {
418	n/a	'option': 'with a value',
419	n/a	'OPTION': 'with another value',
420	n/a	},
421	n/a	})
422	n/a
423	n/a	def test_case_sensitivity(self):
424	n/a	cf = self.newconfig()
425	n/a	cf.add_section("A")
426	n/a	cf.add_section("a")
427	n/a	cf.add_section("B")
428	n/a	L = cf.sections()
429	n/a	L.sort()
430	n/a	eq = self.assertEqual
431	n/a	eq(L, ["A", "B", "a"])
432	n/a	cf.set("a", "B", "value")
433	n/a	eq(cf.options("a"), ["b"])
434	n/a	eq(cf.get("a", "b"), "value",
435	n/a	"could not locate option, expecting case-insensitive option names")
436	n/a	with self.assertRaises(configparser.NoSectionError):
437	n/a	# section names are case-sensitive
438	n/a	cf.set("b", "A", "value")
439	n/a	self.assertTrue(cf.has_option("a", "b"))
440	n/a	self.assertFalse(cf.has_option("b", "b"))
441	n/a	cf.set("A", "A-B", "A-B value")
442	n/a	for opt in ("a-b", "A-b", "a-B", "A-B"):
443	n/a	self.assertTrue(
444	n/a	cf.has_option("A", opt),
445	n/a	"has_option() returned false for option which should exist")
446	n/a	eq(cf.options("A"), ["a-b"])
447	n/a	eq(cf.options("a"), ["b"])
448	n/a	cf.remove_option("a", "B")
449	n/a	eq(cf.options("a"), [])
450	n/a
451	n/a	# SF bug #432369:
452	n/a	cf = self.fromstring(
453	n/a	"[MySection]\nOption{} first line \n\tsecond line \n".format(
454	n/a	self.delimiters[0]))
455	n/a	eq(cf.options("MySection"), ["option"])
456	n/a	eq(cf.get("MySection", "Option"), "first line\nsecond line")
457	n/a
458	n/a	# SF bug #561822:
459	n/a	cf = self.fromstring("[section]\n"
460	n/a	"nekey{}nevalue\n".format(self.delimiters[0]),
461	n/a	defaults={"key":"value"})
462	n/a	self.assertTrue(cf.has_option("section", "Key"))
463	n/a
464	n/a
465	n/a	def test_case_sensitivity_mapping_access(self):
466	n/a	cf = self.newconfig()
467	n/a	cf["A"] = {}
468	n/a	cf["a"] = {"B": "value"}
469	n/a	cf["B"] = {}
470	n/a	L = [section for section in cf]
471	n/a	L.sort()
472	n/a	eq = self.assertEqual
473	n/a	elem_eq = self.assertCountEqual
474	n/a	eq(L, sorted(["A", "B", self.default_section, "a"]))
475	n/a	eq(cf["a"].keys(), {"b"})
476	n/a	eq(cf["a"]["b"], "value",
477	n/a	"could not locate option, expecting case-insensitive option names")
478	n/a	with self.assertRaises(KeyError):
479	n/a	# section names are case-sensitive
480	n/a	cf["b"]["A"] = "value"
481	n/a	self.assertTrue("b" in cf["a"])
482	n/a	cf["A"]["A-B"] = "A-B value"
483	n/a	for opt in ("a-b", "A-b", "a-B", "A-B"):
484	n/a	self.assertTrue(
485	n/a	opt in cf["A"],
486	n/a	"has_option() returned false for option which should exist")
487	n/a	eq(cf["A"].keys(), {"a-b"})
488	n/a	eq(cf["a"].keys(), {"b"})
489	n/a	del cf["a"]["B"]
490	n/a	elem_eq(cf["a"].keys(), {})
491	n/a
492	n/a	# SF bug #432369:
493	n/a	cf = self.fromstring(
494	n/a	"[MySection]\nOption{} first line \n\tsecond line \n".format(
495	n/a	self.delimiters[0]))
496	n/a	eq(cf["MySection"].keys(), {"option"})
497	n/a	eq(cf["MySection"]["Option"], "first line\nsecond line")
498	n/a
499	n/a	# SF bug #561822:
500	n/a	cf = self.fromstring("[section]\n"
501	n/a	"nekey{}nevalue\n".format(self.delimiters[0]),
502	n/a	defaults={"key":"value"})
503	n/a	self.assertTrue("Key" in cf["section"])
504	n/a
505	n/a	def test_default_case_sensitivity(self):
506	n/a	cf = self.newconfig({"foo": "Bar"})
507	n/a	self.assertEqual(
508	n/a	cf.get(self.default_section, "Foo"), "Bar",
509	n/a	"could not locate option, expecting case-insensitive option names")
510	n/a	cf = self.newconfig({"Foo": "Bar"})
511	n/a	self.assertEqual(
512	n/a	cf.get(self.default_section, "Foo"), "Bar",
513	n/a	"could not locate option, expecting case-insensitive defaults")
514	n/a
515	n/a	def test_parse_errors(self):
516	n/a	cf = self.newconfig()
517	n/a	self.parse_error(cf, configparser.ParsingError,
518	n/a	"[Foo]\n"
519	n/a	"{}val-without-opt-name\n".format(self.delimiters[0]))
520	n/a	self.parse_error(cf, configparser.ParsingError,
521	n/a	"[Foo]\n"
522	n/a	"{}val-without-opt-name\n".format(self.delimiters[1]))
523	n/a	e = self.parse_error(cf, configparser.MissingSectionHeaderError,
524	n/a	"No Section!\n")
525	n/a	self.assertEqual(e.args, ('<???>', 1, "No Section!\n"))
526	n/a	if not self.allow_no_value:
527	n/a	e = self.parse_error(cf, configparser.ParsingError,
528	n/a	"[Foo]\n wrong-indent\n")
529	n/a	self.assertEqual(e.args, ('<???>',))
530	n/a	# read_file on a real file
531	n/a	tricky = support.findfile("cfgparser.3")
532	n/a	if self.delimiters[0] == '=':
533	n/a	error = configparser.ParsingError
534	n/a	expected = (tricky,)
535	n/a	else:
536	n/a	error = configparser.MissingSectionHeaderError
537	n/a	expected = (tricky, 1,
538	n/a	' # INI with as many tricky parts as possible\n')
539	n/a	with open(tricky, encoding='utf-8') as f:
540	n/a	e = self.parse_error(cf, error, f)
541	n/a	self.assertEqual(e.args, expected)
542	n/a
543	n/a	def parse_error(self, cf, exc, src):
544	n/a	if hasattr(src, 'readline'):
545	n/a	sio = src
546	n/a	else:
547	n/a	sio = io.StringIO(src)
548	n/a	with self.assertRaises(exc) as cm:
549	n/a	cf.read_file(sio)
550	n/a	return cm.exception
551	n/a
552	n/a	def test_query_errors(self):
553	n/a	cf = self.newconfig()
554	n/a	self.assertEqual(cf.sections(), [],
555	n/a	"new ConfigParser should have no defined sections")
556	n/a	self.assertFalse(cf.has_section("Foo"),
557	n/a	"new ConfigParser should have no acknowledged "
558	n/a	"sections")
559	n/a	with self.assertRaises(configparser.NoSectionError):
560	n/a	cf.options("Foo")
561	n/a	with self.assertRaises(configparser.NoSectionError):
562	n/a	cf.set("foo", "bar", "value")
563	n/a	e = self.get_error(cf, configparser.NoSectionError, "foo", "bar")
564	n/a	self.assertEqual(e.args, ("foo",))
565	n/a	cf.add_section("foo")
566	n/a	e = self.get_error(cf, configparser.NoOptionError, "foo", "bar")
567	n/a	self.assertEqual(e.args, ("bar", "foo"))
568	n/a
569	n/a	def get_error(self, cf, exc, section, option):
570	n/a	try:
571	n/a	cf.get(section, option)
572	n/a	except exc as e:
573	n/a	return e
574	n/a	else:
575	n/a	self.fail("expected exception type %s.%s"
576	n/a	% (exc.__module__, exc.__name__))
577	n/a
578	n/a	def test_boolean(self):
579	n/a	cf = self.fromstring(
580	n/a	"[BOOLTEST]\n"
581	n/a	"T1{equals}1\n"
582	n/a	"T2{equals}TRUE\n"
583	n/a	"T3{equals}True\n"
584	n/a	"T4{equals}oN\n"
585	n/a	"T5{equals}yes\n"
586	n/a	"F1{equals}0\n"
587	n/a	"F2{equals}FALSE\n"
588	n/a	"F3{equals}False\n"
589	n/a	"F4{equals}oFF\n"
590	n/a	"F5{equals}nO\n"
591	n/a	"E1{equals}2\n"
592	n/a	"E2{equals}foo\n"
593	n/a	"E3{equals}-1\n"
594	n/a	"E4{equals}0.1\n"
595	n/a	"E5{equals}FALSE AND MORE".format(equals=self.delimiters[0])
596	n/a	)
597	n/a	for x in range(1, 5):
598	n/a	self.assertTrue(cf.getboolean('BOOLTEST', 't%d' % x))
599	n/a	self.assertFalse(cf.getboolean('BOOLTEST', 'f%d' % x))
600	n/a	self.assertRaises(ValueError,
601	n/a	cf.getboolean, 'BOOLTEST', 'e%d' % x)
602	n/a
603	n/a	def test_weird_errors(self):
604	n/a	cf = self.newconfig()
605	n/a	cf.add_section("Foo")
606	n/a	with self.assertRaises(configparser.DuplicateSectionError) as cm:
607	n/a	cf.add_section("Foo")
608	n/a	e = cm.exception
609	n/a	self.assertEqual(str(e), "Section 'Foo' already exists")
610	n/a	self.assertEqual(e.args, ("Foo", None, None))
611	n/a
612	n/a	if self.strict:
613	n/a	with self.assertRaises(configparser.DuplicateSectionError) as cm:
614	n/a	cf.read_string(textwrap.dedent("""\
615	n/a	[Foo]
616	n/a	will this be added{equals}True
617	n/a	[Bar]
618	n/a	what about this{equals}True
619	n/a	[Foo]
620	n/a	oops{equals}this won't
621	n/a	""".format(equals=self.delimiters[0])), source='<foo-bar>')
622	n/a	e = cm.exception
623	n/a	self.assertEqual(str(e), "While reading from <foo-bar> [line 5]: "
624	n/a	"section 'Foo' already exists")
625	n/a	self.assertEqual(e.args, ("Foo", '<foo-bar>', 5))
626	n/a
627	n/a	with self.assertRaises(configparser.DuplicateOptionError) as cm:
628	n/a	cf.read_dict({'Bar': {'opt': 'val', 'OPT': 'is really `opt`'}})
629	n/a	e = cm.exception
630	n/a	self.assertEqual(str(e), "While reading from <dict>: option 'opt' "
631	n/a	"in section 'Bar' already exists")
632	n/a	self.assertEqual(e.args, ("Bar", "opt", "<dict>", None))
633	n/a
634	n/a	def test_write(self):
635	n/a	config_string = (
636	n/a	"[Long Line]\n"
637	n/a	"foo{0[0]} this line is much, much longer than my editor\n"
638	n/a	" likes it.\n"
639	n/a	"[{default_section}]\n"
640	n/a	"foo{0[1]} another very\n"
641	n/a	" long line\n"
642	n/a	"[Long Line - With Comments!]\n"
643	n/a	"test {0[1]} we {comment} can\n"
644	n/a	" also {comment} place\n"
645	n/a	" comments {comment} in\n"
646	n/a	" multiline {comment} values"
647	n/a	"\n".format(self.delimiters, comment=self.comment_prefixes[0],
648	n/a	default_section=self.default_section)
649	n/a	)
650	n/a	if self.allow_no_value:
651	n/a	config_string += (
652	n/a	"[Valueless]\n"
653	n/a	"option-without-value\n"
654	n/a	)
655	n/a
656	n/a	cf = self.fromstring(config_string)
657	n/a	for space_around_delimiters in (True, False):
658	n/a	output = io.StringIO()
659	n/a	cf.write(output, space_around_delimiters=space_around_delimiters)
660	n/a	delimiter = self.delimiters[0]
661	n/a	if space_around_delimiters:
662	n/a	delimiter = " {} ".format(delimiter)
663	n/a	expect_string = (
664	n/a	"[{default_section}]\n"
665	n/a	"foo{equals}another very\n"
666	n/a	"\tlong line\n"
667	n/a	"\n"
668	n/a	"[Long Line]\n"
669	n/a	"foo{equals}this line is much, much longer than my editor\n"
670	n/a	"\tlikes it.\n"
671	n/a	"\n"
672	n/a	"[Long Line - With Comments!]\n"
673	n/a	"test{equals}we\n"
674	n/a	"\talso\n"
675	n/a	"\tcomments\n"
676	n/a	"\tmultiline\n"
677	n/a	"\n".format(equals=delimiter,
678	n/a	default_section=self.default_section)
679	n/a	)
680	n/a	if self.allow_no_value:
681	n/a	expect_string += (
682	n/a	"[Valueless]\n"
683	n/a	"option-without-value\n"
684	n/a	"\n"
685	n/a	)
686	n/a	self.assertEqual(output.getvalue(), expect_string)
687	n/a
688	n/a	def test_set_string_types(self):
689	n/a	cf = self.fromstring("[sect]\n"
690	n/a	"option1{eq}foo\n".format(eq=self.delimiters[0]))
691	n/a	# Check that we don't get an exception when setting values in
692	n/a	# an existing section using strings:
693	n/a	class mystr(str):
694	n/a	pass
695	n/a	cf.set("sect", "option1", "splat")
696	n/a	cf.set("sect", "option1", mystr("splat"))
697	n/a	cf.set("sect", "option2", "splat")
698	n/a	cf.set("sect", "option2", mystr("splat"))
699	n/a	cf.set("sect", "option1", "splat")
700	n/a	cf.set("sect", "option2", "splat")
701	n/a
702	n/a	def test_read_returns_file_list(self):
703	n/a	if self.delimiters[0] != '=':
704	n/a	# skip reading the file if we're using an incompatible format
705	n/a	return
706	n/a	file1 = support.findfile("cfgparser.1")
707	n/a	# check when we pass a mix of readable and non-readable files:
708	n/a	cf = self.newconfig()
709	n/a	parsed_files = cf.read([file1, "nonexistent-file"])
710	n/a	self.assertEqual(parsed_files, [file1])
711	n/a	self.assertEqual(cf.get("Foo Bar", "foo"), "newbar")
712	n/a	# check when we pass only a filename:
713	n/a	cf = self.newconfig()
714	n/a	parsed_files = cf.read(file1)
715	n/a	self.assertEqual(parsed_files, [file1])
716	n/a	self.assertEqual(cf.get("Foo Bar", "foo"), "newbar")
717	n/a	# check when we pass only missing files:
718	n/a	cf = self.newconfig()
719	n/a	parsed_files = cf.read(["nonexistent-file"])
720	n/a	self.assertEqual(parsed_files, [])
721	n/a	# check when we pass no files:
722	n/a	cf = self.newconfig()
723	n/a	parsed_files = cf.read([])
724	n/a	self.assertEqual(parsed_files, [])
725	n/a
726	n/a	# shared by subclasses
727	n/a	def get_interpolation_config(self):
728	n/a	return self.fromstring(
729	n/a	"[Foo]\n"
730	n/a	"bar{equals}something %(with1)s interpolation (1 step)\n"
731	n/a	"bar9{equals}something %(with9)s lots of interpolation (9 steps)\n"
732	n/a	"bar10{equals}something %(with10)s lots of interpolation (10 steps)\n"
733	n/a	"bar11{equals}something %(with11)s lots of interpolation (11 steps)\n"
734	n/a	"with11{equals}%(with10)s\n"
735	n/a	"with10{equals}%(with9)s\n"
736	n/a	"with9{equals}%(with8)s\n"
737	n/a	"with8{equals}%(With7)s\n"
738	n/a	"with7{equals}%(WITH6)s\n"
739	n/a	"with6{equals}%(with5)s\n"
740	n/a	"With5{equals}%(with4)s\n"
741	n/a	"WITH4{equals}%(with3)s\n"
742	n/a	"with3{equals}%(with2)s\n"
743	n/a	"with2{equals}%(with1)s\n"
744	n/a	"with1{equals}with\n"
745	n/a	"\n"
746	n/a	"[Mutual Recursion]\n"
747	n/a	"foo{equals}%(bar)s\n"
748	n/a	"bar{equals}%(foo)s\n"
749	n/a	"\n"
750	n/a	"[Interpolation Error]\n"
751	n/a	# no definition for 'reference'
752	n/a	"name{equals}%(reference)s\n".format(equals=self.delimiters[0]))
753	n/a
754	n/a	def check_items_config(self, expected):
755	n/a	cf = self.fromstring("""
756	n/a	[section]
757	n/a	name {0[0]} %(value)s
758	n/a	key{0[1]} \|%(name)s\|
759	n/a	getdefault{0[1]} \|%(default)s\|
760	n/a	""".format(self.delimiters), defaults={"default": "<default>"})
761	n/a	L = list(cf.items("section", vars={'value': 'value'}))
762	n/a	L.sort()
763	n/a	self.assertEqual(L, expected)
764	n/a	with self.assertRaises(configparser.NoSectionError):
765	n/a	cf.items("no such section")
766	n/a
767	n/a
768	n/a	class StrictTestCase(BasicTestCase):
769	n/a	config_class = configparser.RawConfigParser
770	n/a	strict = True
771	n/a
772	n/a
773	n/a	class ConfigParserTestCase(BasicTestCase):
774	n/a	config_class = configparser.ConfigParser
775	n/a
776	n/a	def test_interpolation(self):
777	n/a	cf = self.get_interpolation_config()
778	n/a	eq = self.assertEqual
779	n/a	eq(cf.get("Foo", "bar"), "something with interpolation (1 step)")
780	n/a	eq(cf.get("Foo", "bar9"),
781	n/a	"something with lots of interpolation (9 steps)")
782	n/a	eq(cf.get("Foo", "bar10"),
783	n/a	"something with lots of interpolation (10 steps)")
784	n/a	e = self.get_error(cf, configparser.InterpolationDepthError, "Foo", "bar11")
785	n/a	if self.interpolation == configparser._UNSET:
786	n/a	self.assertEqual(e.args, ("bar11", "Foo", "%(with1)s"))
787	n/a	elif isinstance(self.interpolation, configparser.LegacyInterpolation):
788	n/a	self.assertEqual(e.args, ("bar11", "Foo",
789	n/a	"something %(with11)s lots of interpolation (11 steps)"))
790	n/a
791	n/a	def test_interpolation_missing_value(self):
792	n/a	cf = self.get_interpolation_config()
793	n/a	e = self.get_error(cf, configparser.InterpolationMissingOptionError,
794	n/a	"Interpolation Error", "name")
795	n/a	self.assertEqual(e.reference, "reference")
796	n/a	self.assertEqual(e.section, "Interpolation Error")
797	n/a	self.assertEqual(e.option, "name")
798	n/a	if self.interpolation == configparser._UNSET:
799	n/a	self.assertEqual(e.args, ('name', 'Interpolation Error',
800	n/a	'', 'reference'))
801	n/a	elif isinstance(self.interpolation, configparser.LegacyInterpolation):
802	n/a	self.assertEqual(e.args, ('name', 'Interpolation Error',
803	n/a	'%(reference)s', 'reference'))
804	n/a
805	n/a	def test_items(self):
806	n/a	self.check_items_config([('default', '<default>'),
807	n/a	('getdefault', '\|<default>\|'),
808	n/a	('key', '\|value\|'),
809	n/a	('name', 'value'),
810	n/a	('value', 'value')])
811	n/a
812	n/a	def test_safe_interpolation(self):
813	n/a	# See http://www.python.org/sf/511737
814	n/a	cf = self.fromstring("[section]\n"
815	n/a	"option1{eq}xxx\n"
816	n/a	"option2{eq}%(option1)s/xxx\n"
817	n/a	"ok{eq}%(option1)s/%%s\n"
818	n/a	"not_ok{eq}%(option2)s/%%s".format(
819	n/a	eq=self.delimiters[0]))
820	n/a	self.assertEqual(cf.get("section", "ok"), "xxx/%s")
821	n/a	if self.interpolation == configparser._UNSET:
822	n/a	self.assertEqual(cf.get("section", "not_ok"), "xxx/xxx/%s")
823	n/a	elif isinstance(self.interpolation, configparser.LegacyInterpolation):
824	n/a	with self.assertRaises(TypeError):
825	n/a	cf.get("section", "not_ok")
826	n/a
827	n/a	def test_set_malformatted_interpolation(self):
828	n/a	cf = self.fromstring("[sect]\n"
829	n/a	"option1{eq}foo\n".format(eq=self.delimiters[0]))
830	n/a
831	n/a	self.assertEqual(cf.get('sect', "option1"), "foo")
832	n/a
833	n/a	self.assertRaises(ValueError, cf.set, "sect", "option1", "%foo")
834	n/a	self.assertRaises(ValueError, cf.set, "sect", "option1", "foo%")
835	n/a	self.assertRaises(ValueError, cf.set, "sect", "option1", "f%oo")
836	n/a
837	n/a	self.assertEqual(cf.get('sect', "option1"), "foo")
838	n/a
839	n/a	# bug #5741: double percents are not malformed
840	n/a	cf.set("sect", "option2", "foo%%bar")
841	n/a	self.assertEqual(cf.get("sect", "option2"), "foo%bar")
842	n/a
843	n/a	def test_set_nonstring_types(self):
844	n/a	cf = self.fromstring("[sect]\n"
845	n/a	"option1{eq}foo\n".format(eq=self.delimiters[0]))
846	n/a	# Check that we get a TypeError when setting non-string values
847	n/a	# in an existing section:
848	n/a	self.assertRaises(TypeError, cf.set, "sect", "option1", 1)
849	n/a	self.assertRaises(TypeError, cf.set, "sect", "option1", 1.0)
850	n/a	self.assertRaises(TypeError, cf.set, "sect", "option1", object())
851	n/a	self.assertRaises(TypeError, cf.set, "sect", "option2", 1)
852	n/a	self.assertRaises(TypeError, cf.set, "sect", "option2", 1.0)
853	n/a	self.assertRaises(TypeError, cf.set, "sect", "option2", object())
854	n/a	self.assertRaises(TypeError, cf.set, "sect", 123, "invalid opt name!")
855	n/a	self.assertRaises(TypeError, cf.add_section, 123)
856	n/a
857	n/a	def test_add_section_default(self):
858	n/a	cf = self.newconfig()
859	n/a	self.assertRaises(ValueError, cf.add_section, self.default_section)
860	n/a
861	n/a	class ConfigParserTestCaseLegacyInterpolation(ConfigParserTestCase):
862	n/a	config_class = configparser.ConfigParser
863	n/a	interpolation = configparser.LegacyInterpolation()
864	n/a
865	n/a	def test_set_malformatted_interpolation(self):
866	n/a	cf = self.fromstring("[sect]\n"
867	n/a	"option1{eq}foo\n".format(eq=self.delimiters[0]))
868	n/a
869	n/a	self.assertEqual(cf.get('sect', "option1"), "foo")
870	n/a
871	n/a	cf.set("sect", "option1", "%foo")
872	n/a	self.assertEqual(cf.get('sect', "option1"), "%foo")
873	n/a	cf.set("sect", "option1", "foo%")
874	n/a	self.assertEqual(cf.get('sect', "option1"), "foo%")
875	n/a	cf.set("sect", "option1", "f%oo")
876	n/a	self.assertEqual(cf.get('sect', "option1"), "f%oo")
877	n/a
878	n/a	# bug #5741: double percents are not malformed
879	n/a	cf.set("sect", "option2", "foo%%bar")
880	n/a	self.assertEqual(cf.get("sect", "option2"), "foo%%bar")
881	n/a
882	n/a	class ConfigParserTestCaseNonStandardDelimiters(ConfigParserTestCase):
883	n/a	delimiters = (':=', '$')
884	n/a	comment_prefixes = ('//', '"')
885	n/a	inline_comment_prefixes = ('//', '"')
886	n/a
887	n/a	class ConfigParserTestCaseNonStandardDefaultSection(ConfigParserTestCase):
888	n/a	default_section = 'general'
889	n/a
890	n/a	class MultilineValuesTestCase(BasicTestCase):
891	n/a	config_class = configparser.ConfigParser
892	n/a	wonderful_spam = ("I'm having spam spam spam spam "
893	n/a	"spam spam spam beaked beans spam "
894	n/a	"spam spam and spam!").replace(' ', '\t\n')
895	n/a
896	n/a	def setUp(self):
897	n/a	cf = self.newconfig()
898	n/a	for i in range(100):
899	n/a	s = 'section{}'.format(i)
900	n/a	cf.add_section(s)
901	n/a	for j in range(10):
902	n/a	cf.set(s, 'lovely_spam{}'.format(j), self.wonderful_spam)
903	n/a	with open(support.TESTFN, 'w') as f:
904	n/a	cf.write(f)
905	n/a
906	n/a	def tearDown(self):
907	n/a	os.unlink(support.TESTFN)
908	n/a
909	n/a	def test_dominating_multiline_values(self):
910	n/a	# We're reading from file because this is where the code changed
911	n/a	# during performance updates in Python 3.2
912	n/a	cf_from_file = self.newconfig()
913	n/a	with open(support.TESTFN) as f:
914	n/a	cf_from_file.read_file(f)
915	n/a	self.assertEqual(cf_from_file.get('section8', 'lovely_spam4'),
916	n/a	self.wonderful_spam.replace('\t\n', '\n'))
917	n/a
918	n/a	class RawConfigParserTestCase(BasicTestCase):
919	n/a	config_class = configparser.RawConfigParser
920	n/a
921	n/a	def test_interpolation(self):
922	n/a	cf = self.get_interpolation_config()
923	n/a	eq = self.assertEqual
924	n/a	eq(cf.get("Foo", "bar"),
925	n/a	"something %(with1)s interpolation (1 step)")
926	n/a	eq(cf.get("Foo", "bar9"),
927	n/a	"something %(with9)s lots of interpolation (9 steps)")
928	n/a	eq(cf.get("Foo", "bar10"),
929	n/a	"something %(with10)s lots of interpolation (10 steps)")
930	n/a	eq(cf.get("Foo", "bar11"),
931	n/a	"something %(with11)s lots of interpolation (11 steps)")
932	n/a
933	n/a	def test_items(self):
934	n/a	self.check_items_config([('default', '<default>'),
935	n/a	('getdefault', '\|%(default)s\|'),
936	n/a	('key', '\|%(name)s\|'),
937	n/a	('name', '%(value)s'),
938	n/a	('value', 'value')])
939	n/a
940	n/a	def test_set_nonstring_types(self):
941	n/a	cf = self.newconfig()
942	n/a	cf.add_section('non-string')
943	n/a	cf.set('non-string', 'int', 1)
944	n/a	cf.set('non-string', 'list', [0, 1, 1, 2, 3, 5, 8, 13])
945	n/a	cf.set('non-string', 'dict', {'pi': 3.14159})
946	n/a	self.assertEqual(cf.get('non-string', 'int'), 1)
947	n/a	self.assertEqual(cf.get('non-string', 'list'),
948	n/a	[0, 1, 1, 2, 3, 5, 8, 13])
949	n/a	self.assertEqual(cf.get('non-string', 'dict'), {'pi': 3.14159})
950	n/a	cf.add_section(123)
951	n/a	cf.set(123, 'this is sick', True)
952	n/a	self.assertEqual(cf.get(123, 'this is sick'), True)
953	n/a	if cf._dict.__class__ is configparser._default_dict:
954	n/a	# would not work for SortedDict; only checking for the most common
955	n/a	# default dictionary (OrderedDict)
956	n/a	cf.optionxform = lambda x: x
957	n/a	cf.set('non-string', 1, 1)
958	n/a	self.assertEqual(cf.get('non-string', 1), 1)
959	n/a
960	n/a	class RawConfigParserTestCaseNonStandardDelimiters(RawConfigParserTestCase):
961	n/a	delimiters = (':=', '$')
962	n/a	comment_prefixes = ('//', '"')
963	n/a	inline_comment_prefixes = ('//', '"')
964	n/a
965	n/a	class RawConfigParserTestSambaConf(CfgParserTestCaseClass):
966	n/a	config_class = configparser.RawConfigParser
967	n/a	comment_prefixes = ('#', ';', '----')
968	n/a	inline_comment_prefixes = ('//',)
969	n/a	empty_lines_in_values = False
970	n/a
971	n/a	def test_reading(self):
972	n/a	smbconf = support.findfile("cfgparser.2")
973	n/a	# check when we pass a mix of readable and non-readable files:
974	n/a	cf = self.newconfig()
975	n/a	parsed_files = cf.read([smbconf, "nonexistent-file"], encoding='utf-8')
976	n/a	self.assertEqual(parsed_files, [smbconf])
977	n/a	sections = ['global', 'homes', 'printers',
978	n/a	'print$', 'pdf-generator', 'tmp', 'Agustin']
979	n/a	self.assertEqual(cf.sections(), sections)
980	n/a	self.assertEqual(cf.get("global", "workgroup"), "MDKGROUP")
981	n/a	self.assertEqual(cf.getint("global", "max log size"), 50)
982	n/a	self.assertEqual(cf.get("global", "hosts allow"), "127.")
983	n/a	self.assertEqual(cf.get("tmp", "echo command"), "cat %s; rm %s")
984	n/a
985	n/a	class ConfigParserTestCaseExtendedInterpolation(BasicTestCase):
986	n/a	config_class = configparser.ConfigParser
987	n/a	interpolation = configparser.ExtendedInterpolation()
988	n/a	default_section = 'common'
989	n/a
990	n/a	def test_extended_interpolation(self):
991	n/a	cf = self.fromstring(textwrap.dedent("""
992	n/a	[common]
993	n/a	favourite Beatle = Paul
994	n/a	favourite color = green
995	n/a
996	n/a	[tom]
997	n/a	favourite band = ${favourite color} day
998	n/a	favourite pope = John ${favourite Beatle} II
999	n/a	sequel = ${favourite pope}I
1000	n/a
1001	n/a	[ambv]
1002	n/a	favourite Beatle = George
1003	n/a	son of Edward VII = ${favourite Beatle} V
1004	n/a	son of George V = ${son of Edward VII}I
1005	n/a
1006	n/a	[stanley]
1007	n/a	favourite Beatle = ${ambv:favourite Beatle}
1008	n/a	favourite pope = ${tom:favourite pope}
1009	n/a	favourite color = black
1010	n/a	favourite state of mind = paranoid
1011	n/a	favourite movie = soylent ${common:favourite color}
1012	n/a	favourite song = ${favourite color} sabbath - ${favourite state of mind}
1013	n/a	""").strip())
1014	n/a
1015	n/a	eq = self.assertEqual
1016	n/a	eq(cf['common']['favourite Beatle'], 'Paul')
1017	n/a	eq(cf['common']['favourite color'], 'green')
1018	n/a	eq(cf['tom']['favourite Beatle'], 'Paul')
1019	n/a	eq(cf['tom']['favourite color'], 'green')
1020	n/a	eq(cf['tom']['favourite band'], 'green day')
1021	n/a	eq(cf['tom']['favourite pope'], 'John Paul II')
1022	n/a	eq(cf['tom']['sequel'], 'John Paul III')
1023	n/a	eq(cf['ambv']['favourite Beatle'], 'George')
1024	n/a	eq(cf['ambv']['favourite color'], 'green')
1025	n/a	eq(cf['ambv']['son of Edward VII'], 'George V')
1026	n/a	eq(cf['ambv']['son of George V'], 'George VI')
1027	n/a	eq(cf['stanley']['favourite Beatle'], 'George')
1028	n/a	eq(cf['stanley']['favourite color'], 'black')
1029	n/a	eq(cf['stanley']['favourite state of mind'], 'paranoid')
1030	n/a	eq(cf['stanley']['favourite movie'], 'soylent green')
1031	n/a	eq(cf['stanley']['favourite pope'], 'John Paul II')
1032	n/a	eq(cf['stanley']['favourite song'],
1033	n/a	'black sabbath - paranoid')
1034	n/a
1035	n/a	def test_endless_loop(self):
1036	n/a	cf = self.fromstring(textwrap.dedent("""
1037	n/a	[one for you]
1038	n/a	ping = ${one for me:pong}
1039	n/a
1040	n/a	[one for me]
1041	n/a	pong = ${one for you:ping}
1042	n/a
1043	n/a	[selfish]
1044	n/a	me = ${me}
1045	n/a	""").strip())
1046	n/a
1047	n/a	with self.assertRaises(configparser.InterpolationDepthError):
1048	n/a	cf['one for you']['ping']
1049	n/a	with self.assertRaises(configparser.InterpolationDepthError):
1050	n/a	cf['selfish']['me']
1051	n/a
1052	n/a	def test_strange_options(self):
1053	n/a	cf = self.fromstring("""
1054	n/a	[dollars]
1055	n/a	$var = $$value
1056	n/a	$var2 = ${$var}
1057	n/a	${sick} = cannot interpolate me
1058	n/a
1059	n/a	[interpolated]
1060	n/a	$other = ${dollars:$var}
1061	n/a	$trying = ${dollars:${sick}}
1062	n/a	""")
1063	n/a
1064	n/a	self.assertEqual(cf['dollars']['$var'], '$value')
1065	n/a	self.assertEqual(cf['interpolated']['$other'], '$value')
1066	n/a	self.assertEqual(cf['dollars']['${sick}'], 'cannot interpolate me')
1067	n/a	exception_class = configparser.InterpolationMissingOptionError
1068	n/a	with self.assertRaises(exception_class) as cm:
1069	n/a	cf['interpolated']['$trying']
1070	n/a	self.assertEqual(cm.exception.reference, 'dollars:${sick')
1071	n/a	self.assertEqual(cm.exception.args[2], '}') #rawval
1072	n/a
1073	n/a
1074	n/a	def test_other_errors(self):
1075	n/a	cf = self.fromstring("""
1076	n/a	[interpolation fail]
1077	n/a	case1 = ${where's the brace
1078	n/a	case2 = ${does_not_exist}
1079	n/a	case3 = ${wrong_section:wrong_value}
1080	n/a	case4 = ${i:like:colon:characters}
1081	n/a	case5 = $100 for Fail No 5!
1082	n/a	""")
1083	n/a
1084	n/a	with self.assertRaises(configparser.InterpolationSyntaxError):
1085	n/a	cf['interpolation fail']['case1']
1086	n/a	with self.assertRaises(configparser.InterpolationMissingOptionError):
1087	n/a	cf['interpolation fail']['case2']
1088	n/a	with self.assertRaises(configparser.InterpolationMissingOptionError):
1089	n/a	cf['interpolation fail']['case3']
1090	n/a	with self.assertRaises(configparser.InterpolationSyntaxError):
1091	n/a	cf['interpolation fail']['case4']
1092	n/a	with self.assertRaises(configparser.InterpolationSyntaxError):
1093	n/a	cf['interpolation fail']['case5']
1094	n/a	with self.assertRaises(ValueError):
1095	n/a	cf['interpolation fail']['case6'] = "BLACK $ABBATH"
1096	n/a
1097	n/a
1098	n/a	class ConfigParserTestCaseNoValue(ConfigParserTestCase):
1099	n/a	allow_no_value = True
1100	n/a
1101	n/a	class ConfigParserTestCaseTrickyFile(CfgParserTestCaseClass):
1102	n/a	config_class = configparser.ConfigParser
1103	n/a	delimiters = {'='}
1104	n/a	comment_prefixes = {'#'}
1105	n/a	allow_no_value = True
1106	n/a
1107	n/a	def test_cfgparser_dot_3(self):
1108	n/a	tricky = support.findfile("cfgparser.3")
1109	n/a	cf = self.newconfig()
1110	n/a	self.assertEqual(len(cf.read(tricky, encoding='utf-8')), 1)
1111	n/a	self.assertEqual(cf.sections(), ['strange',
1112	n/a	'corruption',
1113	n/a	'yeah, sections can be '
1114	n/a	'indented as well',
1115	n/a	'another one!',
1116	n/a	'no values here',
1117	n/a	'tricky interpolation',
1118	n/a	'more interpolation'])
1119	n/a	self.assertEqual(cf.getint(self.default_section, 'go',
1120	n/a	vars={'interpolate': '-1'}), -1)
1121	n/a	with self.assertRaises(ValueError):
1122	n/a	# no interpolation will happen
1123	n/a	cf.getint(self.default_section, 'go', raw=True,
1124	n/a	vars={'interpolate': '-1'})
1125	n/a	self.assertEqual(len(cf.get('strange', 'other').split('\n')), 4)
1126	n/a	self.assertEqual(len(cf.get('corruption', 'value').split('\n')), 10)
1127	n/a	longname = 'yeah, sections can be indented as well'
1128	n/a	self.assertFalse(cf.getboolean(longname, 'are they subsections'))
1129	n/a	self.assertEqual(cf.get(longname, 'lets use some Unicode'), 'ç‰‡ä»®å')
1130	n/a	self.assertEqual(len(cf.items('another one!')), 5) # 4 in section and
1131	n/a	# `go` from DEFAULT
1132	n/a	with self.assertRaises(configparser.InterpolationMissingOptionError):
1133	n/a	cf.items('no values here')
1134	n/a	self.assertEqual(cf.get('tricky interpolation', 'lets'), 'do this')
1135	n/a	self.assertEqual(cf.get('tricky interpolation', 'lets'),
1136	n/a	cf.get('tricky interpolation', 'go'))
1137	n/a	self.assertEqual(cf.get('more interpolation', 'lets'), 'go shopping')
1138	n/a
1139	n/a	def test_unicode_failure(self):
1140	n/a	tricky = support.findfile("cfgparser.3")
1141	n/a	cf = self.newconfig()
1142	n/a	with self.assertRaises(UnicodeDecodeError):
1143	n/a	cf.read(tricky, encoding='ascii')
1144	n/a
1145	n/a
1146	n/a	class Issue7005TestCase(unittest.TestCase):
1147	n/a	"""Test output when None is set() as a value and allow_no_value == False.
1148	n/a
1149	n/a	http://bugs.python.org/issue7005
1150	n/a
1151	n/a	"""
1152	n/a
1153	n/a	expected_output = "[section]\noption = None\n\n"
1154	n/a
1155	n/a	def prepare(self, config_class):
1156	n/a	# This is the default, but that's the point.
1157	n/a	cp = config_class(allow_no_value=False)
1158	n/a	cp.add_section("section")
1159	n/a	cp.set("section", "option", None)
1160	n/a	sio = io.StringIO()
1161	n/a	cp.write(sio)
1162	n/a	return sio.getvalue()
1163	n/a
1164	n/a	def test_none_as_value_stringified(self):
1165	n/a	cp = configparser.ConfigParser(allow_no_value=False)
1166	n/a	cp.add_section("section")
1167	n/a	with self.assertRaises(TypeError):
1168	n/a	cp.set("section", "option", None)
1169	n/a
1170	n/a	def test_none_as_value_stringified_raw(self):
1171	n/a	output = self.prepare(configparser.RawConfigParser)
1172	n/a	self.assertEqual(output, self.expected_output)
1173	n/a
1174	n/a
1175	n/a	class SortedTestCase(RawConfigParserTestCase):
1176	n/a	dict_type = SortedDict
1177	n/a
1178	n/a	def test_sorted(self):
1179	n/a	cf = self.fromstring("[b]\n"
1180	n/a	"o4=1\n"
1181	n/a	"o3=2\n"
1182	n/a	"o2=3\n"
1183	n/a	"o1=4\n"
1184	n/a	"[a]\n"
1185	n/a	"k=v\n")
1186	n/a	output = io.StringIO()
1187	n/a	cf.write(output)
1188	n/a	self.assertEqual(output.getvalue(),
1189	n/a	"[a]\n"
1190	n/a	"k = v\n\n"
1191	n/a	"[b]\n"
1192	n/a	"o1 = 4\n"
1193	n/a	"o2 = 3\n"
1194	n/a	"o3 = 2\n"
1195	n/a	"o4 = 1\n\n")
1196	n/a
1197	n/a
1198	n/a	class CompatibleTestCase(CfgParserTestCaseClass):
1199	n/a	config_class = configparser.RawConfigParser
1200	n/a	comment_prefixes = '#;'
1201	n/a	inline_comment_prefixes = ';'
1202	n/a
1203	n/a	def test_comment_handling(self):
1204	n/a	config_string = textwrap.dedent("""\
1205	n/a	[Commented Bar]
1206	n/a	baz=qwe ; a comment
1207	n/a	foo: bar # not a comment!
1208	n/a	# but this is a comment
1209	n/a	; another comment
1210	n/a	quirk: this;is not a comment
1211	n/a	; a space must precede an inline comment
1212	n/a	""")
1213	n/a	cf = self.fromstring(config_string)
1214	n/a	self.assertEqual(cf.get('Commented Bar', 'foo'),
1215	n/a	'bar # not a comment!')
1216	n/a	self.assertEqual(cf.get('Commented Bar', 'baz'), 'qwe')
1217	n/a	self.assertEqual(cf.get('Commented Bar', 'quirk'),
1218	n/a	'this;is not a comment')
1219	n/a
1220	n/a	class CopyTestCase(BasicTestCase):
1221	n/a	config_class = configparser.ConfigParser
1222	n/a
1223	n/a	def fromstring(self, string, defaults=None):
1224	n/a	cf = self.newconfig(defaults)
1225	n/a	cf.read_string(string)
1226	n/a	cf_copy = self.newconfig()
1227	n/a	cf_copy.read_dict(cf)
1228	n/a	# we have to clean up option duplicates that appeared because of
1229	n/a	# the magic DEFAULTSECT behaviour.
1230	n/a	for section in cf_copy.values():
1231	n/a	if section.name == self.default_section:
1232	n/a	continue
1233	n/a	for default, value in cf[self.default_section].items():
1234	n/a	if section[default] == value:
1235	n/a	del section[default]
1236	n/a	return cf_copy
1237	n/a
1238	n/a	class CoverageOneHundredTestCase(unittest.TestCase):
1239	n/a	"""Covers edge cases in the codebase."""
1240	n/a
1241	n/a	def test_duplicate_option_error(self):
1242	n/a	error = configparser.DuplicateOptionError('section', 'option')
1243	n/a	self.assertEqual(error.section, 'section')
1244	n/a	self.assertEqual(error.option, 'option')
1245	n/a	self.assertEqual(error.source, None)
1246	n/a	self.assertEqual(error.lineno, None)
1247	n/a	self.assertEqual(error.args, ('section', 'option', None, None))
1248	n/a	self.assertEqual(str(error), "Option 'option' in section 'section' "
1249	n/a	"already exists")
1250	n/a
1251	n/a	def test_interpolation_depth_error(self):
1252	n/a	error = configparser.InterpolationDepthError('option', 'section',
1253	n/a	'rawval')
1254	n/a	self.assertEqual(error.args, ('option', 'section', 'rawval'))
1255	n/a	self.assertEqual(error.option, 'option')
1256	n/a	self.assertEqual(error.section, 'section')
1257	n/a
1258	n/a	def test_parsing_error(self):
1259	n/a	with self.assertRaises(ValueError) as cm:
1260	n/a	configparser.ParsingError()
1261	n/a	self.assertEqual(str(cm.exception), "Required argument `source' not "
1262	n/a	"given.")
1263	n/a	with self.assertRaises(ValueError) as cm:
1264	n/a	configparser.ParsingError(source='source', filename='filename')
1265	n/a	self.assertEqual(str(cm.exception), "Cannot specify both `filename' "
1266	n/a	"and `source'. Use `source'.")
1267	n/a	error = configparser.ParsingError(filename='source')
1268	n/a	self.assertEqual(error.source, 'source')
1269	n/a	with warnings.catch_warnings(record=True) as w:
1270	n/a	warnings.simplefilter("always", DeprecationWarning)
1271	n/a	self.assertEqual(error.filename, 'source')
1272	n/a	error.filename = 'filename'
1273	n/a	self.assertEqual(error.source, 'filename')
1274	n/a	for warning in w:
1275	n/a	self.assertTrue(warning.category is DeprecationWarning)
1276	n/a
1277	n/a	def test_interpolation_validation(self):
1278	n/a	parser = configparser.ConfigParser()
1279	n/a	parser.read_string("""
1280	n/a	[section]
1281	n/a	invalid_percent = %
1282	n/a	invalid_reference = %(()
1283	n/a	invalid_variable = %(does_not_exist)s
1284	n/a	""")
1285	n/a	with self.assertRaises(configparser.InterpolationSyntaxError) as cm:
1286	n/a	parser['section']['invalid_percent']
1287	n/a	self.assertEqual(str(cm.exception), "'%' must be followed by '%' or "
1288	n/a	"'(', found: '%'")
1289	n/a	with self.assertRaises(configparser.InterpolationSyntaxError) as cm:
1290	n/a	parser['section']['invalid_reference']
1291	n/a	self.assertEqual(str(cm.exception), "bad interpolation variable "
1292	n/a	"reference '%(()'")
1293	n/a
1294	n/a	def test_readfp_deprecation(self):
1295	n/a	sio = io.StringIO("""
1296	n/a	[section]
1297	n/a	option = value
1298	n/a	""")
1299	n/a	parser = configparser.ConfigParser()
1300	n/a	with warnings.catch_warnings(record=True) as w:
1301	n/a	warnings.simplefilter("always", DeprecationWarning)
1302	n/a	parser.readfp(sio, filename='StringIO')
1303	n/a	for warning in w:
1304	n/a	self.assertTrue(warning.category is DeprecationWarning)
1305	n/a	self.assertEqual(len(parser), 2)
1306	n/a	self.assertEqual(parser['section']['option'], 'value')
1307	n/a
1308	n/a	def test_safeconfigparser_deprecation(self):
1309	n/a	with warnings.catch_warnings(record=True) as w:
1310	n/a	warnings.simplefilter("always", DeprecationWarning)
1311	n/a	parser = configparser.SafeConfigParser()
1312	n/a	for warning in w:
1313	n/a	self.assertTrue(warning.category is DeprecationWarning)
1314	n/a
1315	n/a	def test_sectionproxy_repr(self):
1316	n/a	parser = configparser.ConfigParser()
1317	n/a	parser.read_string("""
1318	n/a	[section]
1319	n/a	key = value
1320	n/a	""")
1321	n/a	self.assertEqual(repr(parser['section']), '<Section: section>')
1322	n/a
1323	n/a	def test_main():
1324	n/a	support.run_unittest(
1325	n/a	ConfigParserTestCase,
1326	n/a	ConfigParserTestCaseNonStandardDelimiters,
1327	n/a	ConfigParserTestCaseNoValue,
1328	n/a	ConfigParserTestCaseExtendedInterpolation,
1329	n/a	ConfigParserTestCaseLegacyInterpolation,
1330	n/a	ConfigParserTestCaseTrickyFile,
1331	n/a	MultilineValuesTestCase,
1332	n/a	RawConfigParserTestCase,
1333	n/a	RawConfigParserTestCaseNonStandardDelimiters,
1334	n/a	RawConfigParserTestSambaConf,
1335	n/a	SortedTestCase,
1336	n/a	Issue7005TestCase,
1337	n/a	StrictTestCase,
1338	n/a	CompatibleTestCase,
1339	n/a	CopyTestCase,
1340	n/a	ConfigParserTestCaseNonStandardDefaultSection,
1341	n/a	CoverageOneHundredTestCase,
1342	n/a	)