Enable test_stdmodules (#1048)

Author: slozier

Src/IronPythonTest/Cases/IronPythonCasesManifest.ini

@@ -107,9 +107,6 @@ IsolationLevel=PROCESS # https://github.com/IronLanguages/ironpython3/issues/489
 [IronPython.test_stdconsole]
 Ignore=true
 
-[IronPython.test_stdmodules]
-Ignore=true
-
 [IronPython.test_superconsole]
 Ignore=true
 Reason=Uses MAUI framework, which was MS internal?

Tests/test_stdmodules.py

@@ -12,68 +12,70 @@
 import sys
 import unittest
 
-from iptest import IronPythonTestCase, is_cpython, is_netcoreapp, is_posix, run_test, skipUnlessIronPython
+from iptest import IronPythonTestCase, is_cli, is_cpython, is_posix, run_test, skipUnlessIronPython
 
 class StdModulesTest(IronPythonTestCase):
 
     def test_cp8678(self):
-        from itertools import izip
         x = iter(range(4))
         expected = ([0, 1], [2, 3])
         actual = []
-        
-        for i, j in izip(x, x):
+
+        for i, j in zip(x, x):
             actual.append([i, j])
 
         self.assertEqual(len(expected), len(actual))
-        for i in xrange(len(expected)):
+        for i in range(len(expected)):
             self.assertEqual(expected[i], actual[i])
 
     def test_cp10825(self):
-        import urllib
+        import urllib.request
         from time import sleep
-        
+
         #Give it five chances to connect
         temp_url = None
-        
-        for i in xrange(5):
+        err = None
+
+        for i in range(5):
             try:
-                temp_url = urllib.urlopen("http://www.microsoft.com")
+                temp_url = urllib.request.urlopen("http://www.microsoft.com")
                 break
             except Exception as e:
+                err = e
                 print(".", end="")
                 sleep(5)
                 continue
-        if temp_url==None: raise e
-        
+        if temp_url is None: raise err
+
         try:
             self.assertTrue(temp_url.url.startswith("http://www.microsoft.com"))
         finally:
             temp_url.close()
 
     def test_cp5566(self):
         import base64
-        self.assertEqual(base64.decodestring('w/=='), '\xc3')
-        test_str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~!@#$%^&*()_+-=[]\{}|;':,.//<>?\""
-        test_str+= "/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z/A/B/C/D/E/F/G/H/I/J/K/L/M/N/O/P/Q/R/S/T/U/V/W/X/Y/Z/0/1/2/3/4/5/6/7/8/9/~/!/@/#/$/%/^/&/*/(/)/_/+/-/=/[/]/\/{/}/|/;/'/:/,/.///</>/?\""
-        
-        for str_function in [str, unicode]:
-            self.assertEqual(base64.decodestring(str_function(test_str)),
-                    'i\xb7\x1dy\xf8!\x8a9%\x9az)\xaa\xbb-\xba\xfc1\xcb0\x01\x081\x05\x18r\t(\xb3\r8\xf4\x11I5\x15Yv\x19\xd3]\xb7\xe3\x9e\xbb\xf3\xdf')
+        self.assertEqual(base64.decodebytes(b'w/=='), b'\xc3')
+
+        test_str = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~!@#$%^&*()_+-=[]\{}|;':,.//<>?\""
+        test_str+= b"/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z/A/B/C/D/E/F/G/H/I/J/K/L/M/N/O/P/Q/R/S/T/U/V/W/X/Y/Z/0/1/2/3/4/5/6/7/8/9/~/!/@/#/$/%/^/&/*/(/)/_/+/-/=/[/]/\/{/}/|/;/'/:/,/.///</>/?\""
+        self.assertEqual(base64.decodebytes(test_str),
+                b'i\xb7\x1dy\xf8!\x8a9%\x9az)\xaa\xbb-\xba\xfc1\xcb0\x01\x081\x05\x18r\t(\xb3\r8\xf4\x11I5\x15Yv\x19\xd3]\xb7\xe3\x9e\xbb\xf3\xdf')
 
     def test_cp35507(self):
         import base64
-        self.assertEqual(base64.b64decode('MTIzNP8='), '1234\xff')
-        self.assertEqual(base64.b64decode(b'MTIzNP8='), '1234\xff')
-        self.assertEqual(base64.b64encode('1234\xff'), 'MTIzNP8=')
-        self.assertEqual(base64.b64encode(b'1234\xff'), 'MTIzNP8=')
-
-        import cPickle
-        one = cPickle.dumps(1)
-        self.assertEqual(1, cPickle.loads("I1\n."))
-        self.assertEqual(1, cPickle.loads(b"I1\n."))
-        self.assertEqual(1, cPickle.loads(one))
-        self.assertEqual(1, cPickle.loads(bytes(one)))
+        self.assertEqual(base64.b64decode('MTIzNP8='), b'1234\xff')
+        self.assertEqual(base64.b64decode(b'MTIzNP8='), b'1234\xff')
+        with self.assertRaises(TypeError):
+            base64.b64encode('1234\xff')
+        self.assertEqual(base64.b64encode(b'1234\xff'), b'MTIzNP8=')
+
+        import pickle
+        one = pickle.dumps(1)
+        with self.assertRaises(TypeError):
+            pickle.loads("I1\n.")
+        self.assertEqual(1, pickle.loads(b"I1\n."))
+        self.assertEqual(1, pickle.loads(one))
+        self.assertEqual(1, pickle.loads(bytes(one)))
 
     @skipUnlessIronPython()
     def test_cp13618(self):
@@ -84,7 +86,7 @@ def test_cp13618(self):
     def test_cp12907(self):
         #from codeop import compile_command, PyCF_DONT_IMPLY_DEDENT
         from os import unlink
-        
+
         f_name = "fake_stdout.txt"
         test_list = [
                         ("print(1)",
@@ -103,25 +105,25 @@ def test_cp12907(self):
                             "exec", ["1\n"]),
                     ]
 
-        if is_cpython: #http://ironpython.codeplex.com/workitem/28221
+        if is_cpython: # https://github.com/IronLanguages/ironpython3/issues/1047
             test_list.append(("if 1:\n    print(1)", "exec", ["1\n"]))
-                    
+
         for test_case, kind, expected in test_list:
-            
+
             c = compile(test_case, "", kind, 0x200, 1)
             try:
                 orig_stdout = sys.stdout
-                
+
                 sys.stdout = open(f_name, "w")
                 exec(c)
                 sys.stdout.close()
-                
+
                 t_file = open(f_name, "r")
                 lines = t_file.readlines()
                 t_file.close()
-                
+
                 self.assertEqual(lines, expected)
-                
+
             finally:
                 sys.stdout = orig_stdout
         os.unlink(f_name)
@@ -133,24 +135,24 @@ def test_cp12907(self):
                         ("def f(n):\n    return n*n\n\nf(3)\n", "single"),
                         ("if 1:\n    print(1)",                  "single"),
                     ]
-        if not is_cpython: #http://ironpython.codeplex.com/workitem/28221
+        if not is_cpython: # https://github.com/IronLanguages/ironpython3/issues/1047
             bad_test_list.append(("if 1:\n    print(1)",                  "exec"))
-                    
+
         for test_case, kind in bad_test_list:
             print(test_case, kind)
             self.assertRaises(SyntaxError, compile, test_case, "", kind, 0x200, 1)
 
     def test_cp12009(self):
         import os
         import shutil
-        
+
         dir1 = "temp_test_stdmodules_dir"
         dir2 = dir1 + "2"
-        
+
         os.mkdir(dir1)
         f = open(os.path.join(dir1, "stuff.txt"), "w")
         f.close()
-        
+
         try:
             shutil.copytree(dir1, dir2)
             self.assertTrue("stuff.txt" in os.listdir(dir2))
@@ -159,25 +161,24 @@ def test_cp12009(self):
                 os.unlink(os.path.join(t_dir, "stuff.txt"))
                 os.rmdir(t_dir)
 
-    @unittest.skipIf(is_netcoreapp and is_posix, 'TODO: figure out')
     def test_cp17040(self):
-        ec = os.system("%s -tt -c \"import os\"" %
-                    (sys.executable))
+        import subprocess
+        ec = subprocess.call([sys.executable, "-tt", "-c", "import os"])
         self.assertEqual(ec, 0)
 
     @skipUnlessIronPython()
     def test_cp13401(self):
         import System
         import copy
-        
+
         #A few special cases
         StringSplitOptions_None = getattr(System.StringSplitOptions, "None")
         self.assertEqual(System.Char.MinValue, copy.copy(System.Char.MinValue))
         self.assertTrue(System.Char.MinValue != copy.copy(System.Char.MaxValue))
         self.assertEqual(StringSplitOptions_None, copy.copy(StringSplitOptions_None))
         self.assertEqual(System.StringSplitOptions.RemoveEmptyEntries, copy.copy(System.StringSplitOptions.RemoveEmptyEntries))
         self.assertTrue(StringSplitOptions_None != copy.copy(System.StringSplitOptions.RemoveEmptyEntries))
-        
+
         #Normal cases
         test_dict = {   System.Byte : [System.Byte.MinValue, System.Byte.MinValue+1, System.Byte.MaxValue, System.Byte.MaxValue-1],
                         System.Char : [],
@@ -187,12 +188,12 @@ def test_cp13401(self):
                         System.Int64   : [System.Int64.MinValue, System.Int64.MinValue+1, System.Int64.MaxValue, System.Int64.MaxValue-1],
                         System.Double  : [0.00, 3.14],
                         }
-        
+
         for key in test_dict.keys():
             temp_type = key
-            self.assertTrue(hasattr(temp_type, "__reduce_ex__"), 
+            self.assertTrue(hasattr(temp_type, "__reduce_ex__"),
                 "%s has no attribute '%s'" % (str(temp_type), "__reduce_ex__"))
-        
+
             for temp_value in test_dict[key]:
                 x = temp_type(temp_value)
                 x_copy = copy.copy(x)
@@ -202,33 +203,32 @@ def test_cp13401(self):
     def test_cp7008(self):
         import os
         import sys
-        
+
         self.assertTrue(os.path.isfile(sys.executable))
         self.assertTrue(not os.path.isfile('"' + sys.executable + '"'))
-    
+
     @skipUnlessIronPython()
     def test_get_set_locale(self):
         import locale
         locale.setlocale(locale.LC_ALL, 'en-US')
         loc = locale.getlocale(locale.LC_ALL)
         self.assertEqual(loc, ('en_US','ISO8859-1'))
-        
+
         locale.setlocale(locale.LC_ALL, 'C')
         loc = locale.getlocale(locale.LC_ALL)
         self.assertEqual(loc, (None,None))
 
-        self.assertTrue(locale.setlocale(locale.LC_ALL, '') != None)
+        self.assertTrue(locale.setlocale(locale.LC_ALL, '') is not None)
         if not is_posix: # TODO: figure this out
-            self.assertTrue(locale.getlocale() != None)
+            self.assertTrue(locale.getlocale() is not None)
 
     def test_cp17819(self):
         import xml.sax
         self.assertEqual(xml.sax._false, 0)
 
-    #@unittest.skipIf(is_cli, 'CPython')
     def test_cp20162(self):
         import collections
-        self.assertRaisesMessage(TypeError, "deque() takes at most 2 arguments (3 given)",
+        self.assertRaisesMessage(TypeError, "__init__() takes at most 2 arguments (3 given)" if is_cli else "deque() takes at most 2 arguments (3 given)",
                             collections.deque, 'abc', 2, 2)
 
     def test_cp20603(self):
@@ -248,13 +248,14 @@ def test_cp21929(self):
 
     def test_cp34188(self):
         import locale
+        import functools
         locale.setlocale(locale.LC_COLLATE,"de_CH")
-        self.assertTrue(sorted([u'a', u'z', u'�'], cmp=locale.strcoll) == sorted([u'a', u'z', u'�'], key=locale.strxfrm))
+        self.assertTrue(sorted([u'a', u'z', u'�'], key=functools.cmp_to_key(locale.strcoll)) == sorted([u'a', u'z', u'�'], key=locale.strxfrm))
 
     def test_gh1144(self):
         from collections import deque
         a = deque(maxlen=0)
         a.append("a")
         self.assertEqual(len(a), 0)
 
-run_test(__name__)
+run_test(__name__)