Ticket #5830: test_text.patch

twisted/python/text.py

@@ -8 +8 @@
 Miscellany of text-munging functions.
 """
 
-import string
-import types
-
 
 def stringyString(object, indentation=''):
     """
@@ -26 +23 @@
     braces = ''
     sl = []
 
-    if type(object) is types.DictType:
+    if isinstance(object, dict):
         braces = '{}'
         for key, value in object.items():
             value = stringyString(value, indentation + '   ')
@@ -39 +36 @@
                 sl.append("%s %s: %s" % (indentation, key,
                                          value[len(indentation) + 3:]))
 
-    elif type(object) in (types.TupleType, types.ListType):
-        if type(object) is types.TupleType:
+    elif isinstance(object, (tuple, list)):
+        if isinstance(object, tuple):
             braces = '()'
         else:
             braces = '[]'
 
         for element in object:
             element = stringyString(element, indentation + ' ')
-            sl.append(string.rstrip(element) + ',')
+            sl.append(element.rstrip() + ',')
     else:
         sl[:] = map(lambda s, i=indentation: i+s,
-                    string.split(str(object),'\n'))
+                    str(object).split('\n'))
 
     if not sl:
         sl.append(indentation)
@@ -59 +56 @@
         sl[0] = indentation + braces[0] + sl[0][len(indentation) + 1:]
         sl[-1] = sl[-1] + braces[-1]
 
-    s = string.join(sl, "\n")
+    s = "\n".join(sl)
 
     if isMultiline(s) and not endsInNewline(s):
         s = s + '\n'
@@ -68 +65 @@
 
 def isMultiline(s):
     """Returns True if this string has a newline in it."""
-    return (string.find(s, '\n') != -1)
+    return (s.find('\n') != -1)
 
 def endsInNewline(s):
     """Returns True if this string ends in a newline."""
@@ -88 +85 @@
 
     #eww, evil hacks to allow paragraphs delimited by two \ns :(
     if inString.find('\n\n') >= 0:
-        paragraphs = string.split(inString, '\n\n')
+        paragraphs = inString.split('\n\n')
         for para in paragraphs:
             outLines.extend(greedyWrap(para, width) + [''])
         return outLines
-    inWords = string.split(inString)
+    inWords = inString.split()
 
     column = 0
     ptr_line = 0
@@ -108 +105 @@
                 # We've gone too far, stop the line one word back.
                 ptr_line = ptr_line - 1
             (l, inWords) = (inWords[0:ptr_line], inWords[ptr_line:])
-            outLines.append(string.join(l,' '))
+            outLines.append(' '.join(l))
 
             ptr_line = 0
             column = 0
         elif not (len(inWords) > ptr_line):
             # Clean up the last bit.
-            outLines.append(string.join(inWords, ' '))
+            outLines.append(' '.join(inWords))
             del inWords[:]
         else:
             # Space

twisted/test/test_text.py

@@ -155 +155 @@
 
 
 
-testCases = [WrapTest, SplitTest, StrFileTest]
+class NewLineTest(unittest.TestCase):
+    """
+    Tests for misc methods related to finding newlines in strings.
+    """
+
+    def test_isMultiLine(self):
+        """
+        L{isMultiline} only returns true if the string has a newline in it.
+        """
+        s1 = "multi\nline string"
+        s2 = "single line string"
+        self.assertTrue(text.isMultiline(s1))
+        self.assertFalse(text.isMultiline(s2))
+
+
+    def test_endsInNewline(self):
+        """
+        L{endsInNewline} returns true if the string ends in a newline.
+        """
+        s1 = "a string\n"
+        s2 = "another string"
+        self.assertTrue(text.endsInNewline(s1))
+        self.assertFalse(text.endsInNewline(s2))
+
+
+
+class SequenceTypeStringTests(unittest.TestCase):
+    """
+    Tests for expansive printing of sequence types.
+    """
+
+    def test_tuples(self):
+        """
+        Tuples are printed with each element on a separate line.
+        """
+        t = (1, 2, 3)
+        self.assertEqual(text.stringyString(t), '(1,\n 2,\n 3,)\n')
+
+
+    def test_lists(self):
+        """
+        Lists are printed with each element on a separate line.
+        """
+        l = [1, 2, 3]
+        self.assertEqual(text.stringyString(l), '[1,\n 2,\n 3,]\n')
+
+
+    def test_dicts(self):
+        """
+        Dicts are printed with each element on a separate line.
+
+        Because ordering inside dicts is implementation-dependant, test just the
+        trivial case.
+        """
+        d1 = {'one': 1}
+        self.assertEqual(text.stringyString(d1), '{one: 1}')
+
+
+
+testCases = [WrapTest, SplitTest, StrFileTest, NewLineTest, SequenceTypeStringTests]