add hg and python

1 files changed, 167 insertions, 0 deletions

diff --git a/sys/lib/python/test/test_StringIO.py b/sys/lib/python/test/test_StringIO.py
new file mode 100644
index 000000000..aa36b0984
--- /dev/null
+++ b/sys/lib/python/test/test_StringIO.py
@@ -0,0 +1,167 @@
+# Tests StringIO and cStringIO
+
+import unittest
+import StringIO
+import cStringIO
+import types
+from test import test_support
+
+
+class TestGenericStringIO(unittest.TestCase):
+    # use a class variable MODULE to define which module is being tested
+
+    # Line of data to test as string
+    _line = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!'
+
+    # Constructor to use for the test data (._line is passed to this
+    # constructor)
+    constructor = str
+
+    def setUp(self):
+        self._line = self.constructor(self._line)
+        self._lines = self.constructor((self._line + '\n') * 5)
+        self._fp = self.MODULE.StringIO(self._lines)
+
+    def test_reads(self):
+        eq = self.assertEqual
+        self.assertRaises(TypeError, self._fp.seek)
+        eq(self._fp.read(10), self._line[:10])
+        eq(self._fp.readline(), self._line[10:] + '\n')
+        eq(len(self._fp.readlines(60)), 2)
+
+    def test_writes(self):
+        f = self.MODULE.StringIO()
+        self.assertRaises(TypeError, f.seek)
+        f.write(self._line[:6])
+        f.seek(3)
+        f.write(self._line[20:26])
+        f.write(self._line[52])
+        self.assertEqual(f.getvalue(), 'abcuvwxyz!')
+
+    def test_writelines(self):
+        f = self.MODULE.StringIO()
+        f.writelines([self._line[0], self._line[1], self._line[2]])
+        f.seek(0)
+        self.assertEqual(f.getvalue(), 'abc')
+
+    def test_writelines_error(self):
+        def errorGen():
+            yield 'a'
+            raise KeyboardInterrupt()
+        f = self.MODULE.StringIO()
+        self.assertRaises(KeyboardInterrupt, f.writelines, errorGen())
+
+    def test_truncate(self):
+        eq = self.assertEqual
+        f = self.MODULE.StringIO()
+        f.write(self._lines)
+        f.seek(10)
+        f.truncate()
+        eq(f.getvalue(), 'abcdefghij')
+        f.truncate(5)
+        eq(f.getvalue(), 'abcde')
+        f.write('xyz')
+        eq(f.getvalue(), 'abcdexyz')
+        f.close()
+        self.assertRaises(ValueError, f.write, 'frobnitz')
+
+    def test_closed_flag(self):
+        f = self.MODULE.StringIO()
+        self.assertEqual(f.closed, False)
+        f.close()
+        self.assertEqual(f.closed, True)
+        f = self.MODULE.StringIO("abc")
+        self.assertEqual(f.closed, False)
+        f.close()
+        self.assertEqual(f.closed, True)
+
+    def test_isatty(self):
+        f = self.MODULE.StringIO()
+        self.assertRaises(TypeError, f.isatty, None)
+        self.assertEqual(f.isatty(), False)
+        f.close()
+        self.assertRaises(ValueError, f.isatty)
+
+    def test_iterator(self):
+        eq = self.assertEqual
+        unless = self.failUnless
+        eq(iter(self._fp), self._fp)
+        # Does this object support the iteration protocol?
+        unless(hasattr(self._fp, '__iter__'))
+        unless(hasattr(self._fp, 'next'))
+        i = 0
+        for line in self._fp:
+            eq(line, self._line + '\n')
+            i += 1
+        eq(i, 5)
+        self._fp.close()
+        self.assertRaises(ValueError, self._fp.next)
+
+class TestStringIO(TestGenericStringIO):
+    MODULE = StringIO
+
+    def test_unicode(self):
+
+        if not test_support.have_unicode: return
+
+        # The StringIO module also supports concatenating Unicode
+        # snippets to larger Unicode strings. This is tested by this
+        # method. Note that cStringIO does not support this extension.
+
+        f = self.MODULE.StringIO()
+        f.write(self._line[:6])
+        f.seek(3)
+        f.write(unicode(self._line[20:26]))
+        f.write(unicode(self._line[52]))
+        s = f.getvalue()
+        self.assertEqual(s, unicode('abcuvwxyz!'))
+        self.assertEqual(type(s), types.UnicodeType)
+
+class TestcStringIO(TestGenericStringIO):
+    MODULE = cStringIO
+
+    def test_unicode(self):
+
+        if not test_support.have_unicode: return
+
+        # The cStringIO module converts Unicode strings to character
+        # strings when writing them to cStringIO objects.
+        # Check that this works.
+
+        f = self.MODULE.StringIO()
+        f.write(unicode(self._line[:5]))
+        s = f.getvalue()
+        self.assertEqual(s, 'abcde')
+        self.assertEqual(type(s), types.StringType)
+
+        f = self.MODULE.StringIO(unicode(self._line[:5]))
+        s = f.getvalue()
+        self.assertEqual(s, 'abcde')
+        self.assertEqual(type(s), types.StringType)
+
+        self.assertRaises(UnicodeEncodeError, self.MODULE.StringIO,
+                          unicode('\xf4', 'latin-1'))
+
+import sys
+if sys.platform.startswith('java'):
+    # Jython doesn't have a buffer object, so we just do a useless
+    # fake of the buffer tests.
+    buffer = str
+
+class TestBufferStringIO(TestStringIO):
+    constructor = buffer
+
+class TestBuffercStringIO(TestcStringIO):
+    constructor = buffer
+
+
+def test_main():
+    test_support.run_unittest(
+        TestStringIO,
+        TestcStringIO,
+        TestBufferStringIO,
+        TestBuffercStringIO
+    )
+
+if __name__ == '__main__':
+    test_main()