Add stdlib string tests (#181)

Makefile

@@ -80,6 +80,10 @@ STDLIB_TESTS := \
   tempfile_test \
   test/seq_tests \
   test/test_tuple \
+  test/mapping_tests \
+  test/test_dict \
+  test/string_tests \
+  test/test_string \
   threading_test \
   time_test \
   types_test \

third_party/stdlib/string.py

@@ -82,7 +82,7 @@ def maketrans(fromstr, tostr):
 
 
 ####################################################################
-#import re as _re
+import re as _re
 
 class _multimap(object):
     """Helper class for combining multiple mappings.
@@ -101,36 +101,47 @@ class _multimap(object):
             return self._secondary[key]
 
 
-# class _TemplateMetaclass(type):
-#     pattern = r"""
-#     %(delim)s(?:
-#       (?P<escaped>%(delim)s) |   # Escape sequence of two delimiters
-#       (?P<named>%(id)s)      |   # delimiter and a Python identifier
-#       {(?P<braced>%(id)s)}   |   # delimiter and a braced identifier
-#       (?P<invalid>)              # Other ill-formed delimiter exprs
-#     )
-#     """
-
-#     def __init__(cls, name, bases, dct):
-#         super(_TemplateMetaclass, cls).__init__(name, bases, dct)
-#         if 'pattern' in dct:
-#             pattern = cls.pattern
-#         else:
-#             pattern = _TemplateMetaclass.pattern % {
-#                 'delim' : _re.escape(cls.delimiter),
-#                 'id'    : cls.idpattern,
-#                 }
-#         cls.pattern = _re.compile(pattern, _re.IGNORECASE | _re.VERBOSE)
+class _TemplateMetaclass(type):
+    # pattern = r"""
+    # %(delim)s(?:
+    #   (?P<escaped>%(delim)s) |   # Escape sequence of two delimiters
+    #   (?P<named>%(id)s)      |   # delimiter and a Python identifier
+    #   {(?P<braced>%(id)s)}   |   # delimiter and a braced identifier
+    #   (?P<invalid>)              # Other ill-formed delimiter exprs
+    # )
+    # """
+    pattern = r"""
+    %s(?:
+      (?P<escaped>%s) |   # Escape sequence of two delimiters
+      (?P<named>%s)      |   # delimiter and a Python identifier
+      {(?P<braced>%s)}   |   # delimiter and a braced identifier
+      (?P<invalid>)              # Other ill-formed delimiter exprs
+    )
+    """
+
+    def __init__(cls, name, bases, dct):
+        # super(_TemplateMetaclass, cls).__init__(name, bases, dct)
+        super(_TemplateMetaclass, cls)
+        if 'pattern' in dct:
+            pattern = cls.pattern
+        else:
+            # pattern = _TemplateMetaclass.pattern % {
+            #     'delim' : _re.escape(cls.delimiter),
+            #     'id'    : cls.idpattern,
+            #     }
+            cls_delim, cls_id = _re.escape(cls.delimiter), cls.idpattern
+            pattern = _TemplateMetaclass.pattern % (cls_delim, cls_delim, cls_id, cls_id)
+        cls.pattern = _re.compile(pattern, _re.IGNORECASE | _re.VERBOSE)
 
 
 class Template(object):
     """A string class for supporting $-substitutions."""
-    # __metaclass__ = _TemplateMetaclass
+    __metaclass__ = _TemplateMetaclass
 
     delimiter = '$'
     idpattern = r'[_a-z][_a-z0-9]*'
 
-    def __init__(self, template):
+    def __init__(self, template, *arg):
         self.template = template
 
     # Search for $$, $identifier, ${identifier}, and any bare $'s

third_party/stdlib/test/test_dict.py

@@ -42,7 +42,6 @@ class DictTest(unittest.TestCase):
         self.assertTrue(d.has_key('b'))
         self.assertRaises(TypeError, d.keys, None)
 
-    @unittest.expectedFailure
     def test_values(self):
         d = {}
         self.assertEqual(d.values(), [])
@@ -727,8 +726,4 @@ def test_main():
         )
 
 if __name__ == "__main__":
-    import traceback
-    try:
-        test_main()
-    except:
-        traceback.print_exc()
+    test_main()

third_party/stdlib/test/test_support.py

@@ -1273,7 +1273,7 @@ def check_py3k_warnings(*filters, **kwargs):
 # _2G = 2 * _1G
 # _4G = 4 * _1G
 
-# MAX_Py_ssize_t = sys.maxsize
+MAX_Py_ssize_t = sys.maxsize
 
 # def set_memlimit(limit):
 #     global max_memuse

third_party/stdlib/types.py

@@ -50,7 +50,7 @@ GeneratorType = type(_g())
 
 class _C(object):
     def _m(self): pass
-#ClassType = type(_C)
+ClassType = type(_C)
 UnboundMethodType = type(_C._m)         # Same as MethodType
 _x = _C()
 #InstanceType = type(_x)