Test cleanup (#1400)

* Test cleanup

* Add missing import

* Re-add skipIf is_mono

Author: slozier

Src/IronPython/Runtime/PythonContext.cs

@@ -1192,7 +1192,7 @@ internal bool TryLoadAssemblyFromFileWithPath(string path, out Assembly res) {
         }
 
         internal Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args) {
-            if (args.RequestingAssembly != null && !_loadedAssemblies.Contains(args.RequestingAssembly)) {
+            if (args.RequestingAssembly != null && !(args.RequestingAssembly == typeof(PythonContext).Assembly || _loadedAssemblies.Contains(args.RequestingAssembly))) {
                 return null;
             }
 

Tests/modules/io_related/test_codecs.py

@@ -2050,11 +2050,11 @@ def handler1(ex):
             return ("", ex.end + 1)
 
         codecs.register_error("test_unicode_error1", handler1)
-        if is_cpython:
-            res = "+++\xac\u1234\u20ac\u8000---".encode("ptcp154", "test_unicode_error1")
-            self.assertEqual(res, b"+++\xac--")
-        else:
+        if is_cli:
             with self.assertRaises(NotImplementedError):
                 res = "+++\xac\u1234\u20ac\u8000---".encode("ptcp154", "test_unicode_error1")
+        else:
+            res = "+++\xac\u1234\u20ac\u8000---".encode("ptcp154", "test_unicode_error1")
+            self.assertEqual(res, b"+++\xac--")
 
 run_test(__name__)

Tests/modules/io_related/test_copyreg.py

@@ -22,35 +22,35 @@ class CopyRegTest(unittest.TestCase):
     def test_constructor_neg(self):
         'https://github.com/IronLanguages/main/issues/443'
         class KOld: pass
-        
+
         self.assertRaises(TypeError, copyreg.constructor, KOld)
 
- 
+
     def test_constructor(self):
         #the argument can be callable
         copyreg.constructor(testclass)
-        
+
         #the argument can not be callable
         self.assertRaises(TypeError,copyreg.constructor,0)
         self.assertRaises(TypeError,copyreg.constructor,"Hello")
         self.assertRaises(TypeError,copyreg.constructor,True)
 
 
     def test__newobj__(self):
-        
+
         #the second argument is omitted
         result = None
         result = copyreg.__newobj__(object)
         self.assertTrue(result != None,
             "The method __newobj__ did not return an object")
-                        
+
         #the second argument is an int object
         result = None
         a = 1
         result = copyreg.__newobj__(int,a)
         self.assertTrue(result != None,
             "The method __newobj__ did not return an object")
-            
+
         #the method accept multiple arguments
         reseult = None
         class customtype(object):
@@ -121,27 +121,27 @@ def test_extension_registry(self):
         code = result[key]
         self.assertTrue(code == 123,
                 "The _extension_registry attribute did not return the correct value")
-                
+
         copyreg.add_extension('1','2',999)
         result = copyreg._extension_registry
         code = result[('1','2')]
         self.assertTrue(code == 999,
                 "The _extension_registry attribute did not return the correct value")
-        
+
         #general test, try to set the attribute then to get it
         myvalue = 3885
         copyreg._extension_registry["key"] = myvalue
         result = copyreg._extension_registry["key"]
         self.assertTrue(result == myvalue,
             "The set or the get of the attribute failed")
-    
+
     def test_inverted_registry(self):
         copyreg.add_extension('obj1','obj2',64)
         #get
         result = copyreg._inverted_registry[64]
         self.assertTrue(result == ('obj1','obj2'),
                 "The _inverted_registry attribute did not return the correct value")
-        
+
         #set
         value = ('newmodule','newobj')
         copyreg._inverted_registry[10001] = value
@@ -158,7 +158,7 @@ def test_extension_cache(self):
         result = copyreg._extension_cache['cache1']
         self.assertTrue(result == value,
             "The get and set of the attribute failed")
-        
+
         value = rand.getrandbits(16)
         copyreg._extension_cache['cache2'] = value
         result = copyreg._extension_cache['cache2']
@@ -171,18 +171,18 @@ def test_extension_cache(self):
         result = copyreg._extension_cache['cache1']
         self.assertTrue(result == value2,
             "The get and set of the attribute failed")
-        
+
         if 'cache1' not in copyreg._extension_cache or 'cache2' not in copyreg._extension_cache:
             Fail("Set of the attribute failed")
-            
+
         copyreg.clear_extension_cache()
         if 'cache1' in copyreg._extension_cache or 'cache2' in copyreg._extension_cache:
             Fail("The method clear_extension_cache did not work correctly ")
 
     def test_reconstructor(self):
         reconstructor_copy = copyreg._reconstructor
         try:
-            obj = copyreg._reconstructor(object, object, None)   
+            obj = copyreg._reconstructor(object, object, None)
             self.assertTrue(type(obj) is object)
 
             #set,get, the value is a random int
@@ -192,82 +192,81 @@ def test_reconstructor(self):
             result = copyreg._reconstructor
             self.assertTrue(result == value,
                 "set or get of the attribute failed!")
-        
+
             #the value is a string
             value2 = "value2"
             copyreg._reconstructor = value2
             result = copyreg._reconstructor
             self.assertTrue(result == value2,
                 "set or get of the attribute failed!")
-        
+
             #the value is a custom type object
             value3 = testclass()
             copyreg._reconstructor = value3
             result = copyreg._reconstructor
             self.assertTrue(result == value3,
                 "set or get of the attribute failed!")
-        finally:               
+        finally:
             copyreg._reconstructor = reconstructor_copy
-   
+
 
     def test_pickle(self):
         def testfun():
             return testclass()
-            
+
         # type is a custom type
         copyreg.pickle(type(testclass), testfun)
-        
+
         #type is a system type
         systype = type(random.Random())
         copyreg.pickle(systype,random.Random.random)
-        
+
         #function is not callable
         func = "hello"
         self.assertRaises(TypeError,copyreg.pickle,testclass,func)
         func = 1
         self.assertRaises(TypeError,copyreg.pickle,testclass,func)
         func = random.Random()
         self.assertRaises(TypeError,copyreg.pickle,testclass,func)
-    
+
     def test_dispatch_table(self):
         result = copyreg.dispatch_table
         #CodePlex Work Item 8522
         #self.assertEqual(5,len(result))
-        
+
         temp = {
                 "abc":"abc123",
                 "def":"def123",
                 "ghi":"ghi123"
             }
         copyreg.dispatch_table = temp
         self.assertEqual(temp,copyreg.dispatch_table)
-        
+
         temp = {
                 1:"abc123",
                 2:"def123",
                 3:"ghi123"
             }
         copyreg.dispatch_table = temp
         self.assertEqual(temp,copyreg.dispatch_table)
-        
+
         temp = {
                 1:123,
                 8:789,
                 16:45465
             }
         copyreg.dispatch_table = temp
         self.assertEqual(temp,copyreg.dispatch_table)
-        
+
         #set dispathc_table as empty
         temp ={}
         copyreg.dispatch_table = temp
         self.assertEqual(temp,copyreg.dispatch_table)
 
     def test_pickle_complex(self):
         #http://ironpython.codeplex.com/WorkItem/View.aspx?WorkItemId=21908
-        #if not is_cli:
         self.assertEqual(copyreg.pickle_complex(1), (complex, (1, 0)))
-        
+
         #negative tests
         self.assertRaises(AttributeError,copyreg.pickle_complex,"myargu")
         obj2 = myCustom2()

Tests/modules/network_related/test__socket.py

@@ -186,28 +186,38 @@ def test_getprotobyname(self):
         '''Tests _socket.getprotobyname'''
         #IP and CPython
         proto_map = {
-                    "icmp": _socket.IPPROTO_ICMP,
-                    "ip": _socket.IPPROTO_IP,
-                    "tcp": _socket.IPPROTO_TCP,
-                    "udp": _socket.IPPROTO_UDP,
+            "icmp": _socket.IPPROTO_ICMP,
+            "ip": _socket.IPPROTO_IP,
+            "tcp": _socket.IPPROTO_TCP,
+            "udp": _socket.IPPROTO_UDP,
         }
 
-        #supported only by IP
-        if is_cli:
-            proto_map.update(
-                {"dstopts": _socket.IPPROTO_DSTOPTS,
+        if is_cli or sys.version_info >= (3,8):
+            proto_map.update({
+                "ipv6": _socket.IPPROTO_IPV6,
+                "esp": _socket.IPPROTO_ESP,
+                "pup": _socket.IPPROTO_PUP, #http://ironpython.codeplex.com/WorkItem/View.aspx?WorkItemId=21918
+                "ggp": _socket.IPPROTO_GGP, #http://ironpython.codeplex.com/WorkItem/View.aspx?WorkItemId=21918
+            })
+
+            proto_map_cli_only = {
+                "dstopts": _socket.IPPROTO_DSTOPTS,
                 "none": _socket.IPPROTO_NONE,
                 "raw": _socket.IPPROTO_RAW,
                 "ipv4": _socket.IPPROTO_IPV4,
-                "ipv6": _socket.IPPROTO_IPV6,
-                "esp": _socket.IPPROTO_ESP,
                 "fragment": _socket.IPPROTO_FRAGMENT,
                 "nd": _socket.IPPROTO_ND,
                 "icmpv6": _socket.IPPROTO_ICMPV6,
                 "routing": _socket.IPPROTO_ROUTING,
-                "pup": _socket.IPPROTO_PUP, #http://ironpython.codeplex.com/WorkItem/View.aspx?WorkItemId=21918
-                "ggp": _socket.IPPROTO_GGP, #http://ironpython.codeplex.com/WorkItem/View.aspx?WorkItemId=21918
-                })
+            }
+
+            for proto_name, good_val in proto_map_cli_only.items():
+                if is_cli:
+                    temp_val = _socket.getprotobyname(proto_name)
+                    self.assertEqual(temp_val, good_val)
+                else:
+                    with self.assertRaises(OSError):
+                        _socket.getprotobyname(proto_name)
 
         for proto_name, good_val in proto_map.items():
             temp_val = _socket.getprotobyname(proto_name)

Tests/modules/network_related/test__ssl.py

@@ -94,11 +94,6 @@ def test___doc__(self):
 for documentation."""
         self.assertEqual(_ssl.__doc__, expected_doc)
 
-    def test__test_decode_cert(self):
-        if is_cli and hasattr(_ssl, "decode_cert"):
-            self.fail("Please add a test for _ssl.decode_cert")
-        print('TODO: no implementation to test yet.')
-
     def test_SSLType_ssl(self):
         '''
         Should be essentially the same as _ssl.sslwrap.  It's not though and will

Tests/modules/system_related/test_nt.py

@@ -356,7 +356,7 @@ def test_putenv(self):
         self.assertRaises(TypeError, nt.putenv, 1, "xyz")
         self.assertRaises(TypeError, nt.putenv, "ABC", 1)
 
-    @unittest.skipUnless(is_cli, "CPython has no nt.unsetenv function")
+    @unittest.skipUnless(is_cli or sys.version_info >= (3,9), "CPython has no nt.unsetenv function")
     def test_unsetenv(self):
         #simple sanity check
         nt.putenv("ipy_test_env_var", "xyz")
@@ -470,7 +470,7 @@ def test_spawnv(self):
         ping_cmd = os.path.join(os.environ["windir"], "system32", "ping")
         nt.spawnv(nt.P_WAIT, ping_cmd , ["ping"])
         nt.spawnv(nt.P_WAIT, ping_cmd , ["ping","127.0.0.1","-n","1"])
- 
+
     @unittest.skipUnless(sys.platform == "win32", 'windir is Windows specific')
     def test_spawnve(self):
         ping_cmd = os.path.join(os.environ["windir"], "system32", "ping")
@@ -946,7 +946,7 @@ def test_popen_cp34837(self):
         p = subprocess.Popen("whoami", env=os.environ)
         self.assertTrue(p!=None)
         p.wait()
- 
+
     def test_fsync(self):
         fsync_file_name = 'text_fsync.txt'
         fd = nt.open(fsync_file_name, nt.O_WRONLY | nt.O_CREAT)

Tests/modules/system_related/test_signal.py

@@ -9,7 +9,7 @@
 '''
 
 import signal
-import unittest
+import sys
 
 from iptest import IronPythonTestCase, is_cli, run_test
 
@@ -53,27 +53,29 @@ def test_module_constants(self):
         self.assertEqual(signal.SIG_IGN, 1)
 
     def test_doc(self):
-        self.assertTrue("get the signal action for a given signal" in signal.__doc__)
+        if sys.version_info >= (3,5):
+            self.assertIsNone(signal.__doc__)
+        else:
+            self.assertTrue("get the signal action for a given signal" in signal.__doc__)
         self.assertTrue("The default handler for SIGINT installed by Python" in signal.default_int_handler.__doc__)
         self.assertTrue("Return the current action for the given signal" in signal.getsignal.__doc__)
         self.assertTrue("Set the action for the given signal" in signal.signal.__doc__)
 
-    @unittest.skipUnless(is_cli, 'http://bugs.python.org/issue9324')
     def test_signal_signal_neg(self):
         def a(b, c):
             pass
 
-        WEIRD_WORKING_CASES = [6]
+        WEIRD_WORKING_CASES = [6] if is_cli else []
         NO_SUCH_DIR = [21]
 
         for x in range(1, 23):
             if x in SUPPORTED_SIGNALS: continue
             if x in WEIRD_WORKING_CASES: continue
-            self.assertRaises(RuntimeError,
+            self.assertRaises(RuntimeError if is_cli else ValueError,
                         signal.signal, x, a)
 
         for x in [-2, -1, 0, 23, 24, 25]:
-            self.assertRaisesMessage(ValueError, "signal number out of range",
+            self.assertRaisesMessage(ValueError, "signal number out of range" if is_cli else "invalid signal value",
                                 signal.signal, x, a)
 
         def bad_sig0(): pass
@@ -86,9 +88,10 @@ def bad_sig3(a,b,c): pass
                 self.assertRaisesMessage(TypeError, "signal handler must be signal.SIG_IGN, signal.SIG_DFL, or a callable object",
                                     signal.signal, y, x)
 
-    @unittest.skipUnless(is_cli, 'http://bugs.python.org/issue9324')
     def test_signal_signal(self):
-        WORKING_CASES = SUPPORTED_SIGNALS + [6]
+        WORKING_CASES = SUPPORTED_SIGNALS
+        if is_cli:
+            WORKING_CASES += [6]
         WEIRD_CASES = {
                     6: None,
                     2: signal.default_int_handler}