Domain reload work: port previous commit to Windows

Nothing major: - python platform.machine() returns x86_64 on mac, and AMD64 on windows, for the same platform. Parse them properly. - Microsoft's runtime C# compiler wants language version 2.0, so no $"{foo}" syntax in our debug printing. - Microsoft has decided you can't catch SEGV even in a unit test, so disable that test on windows. Most of my time was spent trying to convince VS to see the unit tests.
pythonnet · benoithudson · Sep 14, 2018 · Sep 14, 2018 · Sep 26, 2018 · Sep 26, 2018
commit bb76ff30fbbb96704d24bc7fe7611702efca72c6
diff --git a/src/embed_tests/TestDomainReload.cs b/src/embed_tests/TestDomainReload.cs
@@ -65,31 +65,34 @@ public static void DomainReloadAndGC()
         //
         // What matters in the python code is gc.collect and clr.AddReference.
         //
+        // Note that the language version is 2.0, so no $"foo{bar}" syntax.
+        //
         const string TestCode = @"
             using Python.Runtime;
             using System;
             class PythonRunner {
                 public static void RunPython() {
                     AppDomain.CurrentDomain.DomainUnload += OnDomainUnload;
                     string name = AppDomain.CurrentDomain.FriendlyName;
-                    Console.WriteLine($""[{name} in .NET] In PythonRunner.RunPython"");
+                    Console.WriteLine(string.Format(""[{0} in .NET] In PythonRunner.RunPython"", name));
                     using (Py.GIL()) {
                         try {
-                            var pyScript = ""import clr\n""
-                                + $""print('[{name} in python] imported clr')\n""
+                            var pyScript = string.Format(""import clr\n""
+                                + ""print('[{0} in python] imported clr')\n""
                                 + ""clr.AddReference('System')\n""
-                                + $""print('[{name} in python] allocated a clr object')\n""
+                                + ""print('[{0} in python] allocated a clr object')\n""
                                 + ""import gc\n""
                                 + ""gc.collect()\n""
-                                + $""print('[{name} in python] collected garbage')\n"";
+                                + ""print('[{0} in python] collected garbage')\n"",
+                                name);
                             PythonEngine.Exec(pyScript);
                         } catch(Exception e) {
-                            Console.WriteLine($""[{name} in .NET] Caught exception: {e}"");
+                            Console.WriteLine(string.Format(""[{0} in .NET] Caught exception: {1}"", name, e));
                         }
                     }
                 }
                 static void OnDomainUnload(object sender, EventArgs e) {
-                    System.Console.WriteLine(string.Format($""[{AppDomain.CurrentDomain.FriendlyName} in .NET] unloading""));
+                    System.Console.WriteLine(string.Format(""[{0} in .NET] unloading"", AppDomain.CurrentDomain.FriendlyName));
                 }
             }";
 
@@ -139,7 +142,7 @@ class Proxy : MarshalByRefObject
 
             public void InitAssembly(string assemblyPath)
             {
-                theAssembly = Assembly.LoadFile(assemblyPath);
+                theAssembly = Assembly.LoadFile(System.IO.Path.GetFullPath(assemblyPath));
             }
 
             public void RunPython()

diff --git a/src/embed_tests/TestTypeManager.cs b/src/embed_tests/TestTypeManager.cs
@@ -31,13 +31,19 @@ public static void TestMemoryMapping()
             Assert.That(() => { Marshal.WriteInt64(page, 17); }, Throws.Nothing);
             Assert.That(Marshal.ReadInt64(page), Is.EqualTo(17));
 
-            // Mark it read-execute, now we can't write anymore (I'm not testing we can execute).
-            // We should be getting AccessViolationException, but Mono translates
-            // SIGSEGV to NullReferenceException instead, so just check for some exception.
+            // Mark it read-execute, now we can't write anymore.
+            // We can't actually test access protectoin under Windows,
+            // because AccessViolationException is assumed to mean we're in a
+            // corrupted state:
+            //   https://stackoverflow.com/questions/3469368/how-to-handle-accessviolationexception
             mapper.SetReadExec(page, len);
             Assert.That(Marshal.ReadInt64(page), Is.EqualTo(17));
-            Assert.That(() => { Marshal.WriteInt64(page, 18); }, Throws.Exception);
-            Assert.That(Marshal.ReadInt64(page), Is.EqualTo(17));
+            if (Runtime.Runtime.OperatingSystem != Runtime.Runtime.OperatingSystemType.Windows)
+            {
+                // Mono throws NRE instead of AccessViolationException for some reason.
+                Assert.That(() => { Marshal.WriteInt64(page, 73); }, Throws.TypeOf<System.NullReferenceException>());
+                Assert.That(Marshal.ReadInt64(page), Is.EqualTo(17));
+            }
 
             Runtime.Runtime.Shutdown();
         }

diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
@@ -231,10 +231,17 @@ public enum MachineType
             Other
         };
 
+        /// <summary>
+	/// Map lower-case version of the python machine name to the processor
+	/// type.  There are aliases, e.g. x86_64 and amd64 are two names for
+	/// the same thing.  Make sure to lower-case the search string, because
+	/// capitalization can differ.
+        /// </summary>
         static readonly Dictionary<string, MachineType> MachineTypeMapping = new Dictionary<string, MachineType>()
         {
             { "i386", MachineType.i386 },
             { "x86_64", MachineType.x86_64 },
+            { "amd64", MachineType.x86_64 },
         };
 
         /// <summary>
@@ -444,7 +451,7 @@ private static void InitializePlatformData()
             OperatingSystem = OSType;
 
             MachineType MType;
-            if (!MachineTypeMapping.TryGetValue(MachineName, out MType))
+            if (!MachineTypeMapping.TryGetValue(MachineName.ToLower(), out MType))
             {
                 MType = MachineType.Other;
             }

diff --git a/src/runtime/typemanager.cs b/src/runtime/typemanager.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Reflection;
@@ -507,7 +507,7 @@ public static NativeCode Active
                         case Runtime.MachineType.x86_64:
                             return X86_64;
                         default:
-                            throw new NotImplementedException($"No support for ${Runtime.MachineName}");
+                            throw new NotImplementedException($"No support for {Runtime.MachineName}");
                     }
                 }
             }