diff -r 000000000000 -r ae805ac0140d python-2.5.2/win32/Lib/test/test_cfgparser.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/python-2.5.2/win32/Lib/test/test_cfgparser.py	Fri Apr 03 17:19:34 2009 +0100
@@ -0,0 +1,426 @@
+import ConfigParser
+import StringIO
+import unittest
+
+from test import test_support
+
+
+class TestCaseBase(unittest.TestCase):
+    def newconfig(self, defaults=None):
+        if defaults is None:
+            self.cf = self.config_class()
+        else:
+            self.cf = self.config_class(defaults)
+        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):
+        cf = self.fromstring(
+            "[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"
+            )
+        L = cf.sections()
+        L.sort()
+        eq = self.assertEqual
+        eq(L, [r'Commented Bar',
+               r'Foo Bar',
+               r'Internationalized Stuff',
+               r'Long Line',
+               r'Section\with$weird%characters[' '\t',
+               r'Spaces',
+               r'Spacey Bar',
+               ])
+
+        # 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!')
+
+        self.failIf('__name__' in 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.failUnless(cf.remove_option('Foo Bar', 'foo'),
+                        "remove_option() failed to report existance of option")
+        self.failIf(cf.has_option('Foo Bar', 'foo'),
+                    "remove_option() failed to remove option")
+        self.failIf(cf.remove_option('Foo Bar', 'foo'),
+                    "remove_option() failed to report non-existance 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.failUnless(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.failUnless(
+                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.failUnless(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]\noption-without-value\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.failIf(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.failUnless(cf.getboolean('BOOLTEST', 't%d' % x))
+            self.failIf(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):
+        cf = self.fromstring(
+            "[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"
+            )
+        output = StringIO.StringIO()
+        cf.write(output)
+        self.assertEqual(
+            output.getvalue(),
+            "[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"
+            )
+
+    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, "nonexistant-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(["nonexistant-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
+
+    def test_interpolation(self):
+        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):
+        cf = 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')
+        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)
+
+
+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_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_main():
+    test_support.run_unittest(
+        ConfigParserTestCase,
+        RawConfigParserTestCase,
+        SafeConfigParserTestCase
+    )
+
+if __name__ == "__main__":
+    test_main()