made InterruptTest more robust

lostmsu · lostmsu · commit 831fc85c167e · 2021-02-20T18:49:06.000-08:00
should resolve this failure: https://github.com/pythonnet/pythonnet/pull/1392/checks?check_run_id=1944113649 related to #1337
diff --git a/src/embed_tests/TestInterrupt.cs b/src/embed_tests/TestInterrupt.cs
@@ -1,5 +1,6 @@
 
 using System;
+using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -30,34 +31,35 @@ public void Dispose()
         [Test]
         public void InterruptTest()
         {
-            int runSimpleStringReturnValue = int.MinValue;
-            ulong pythonThreadID = ulong.MinValue;
-            Task.Factory.StartNew(() =>
+            long pythonThreadID = 0;
+            var asyncCall = Task.Factory.StartNew(() =>
             {
                 using (Py.GIL())
                 {
-                    pythonThreadID = PythonEngine.GetPythonThreadID();
-                    runSimpleStringReturnValue = PythonEngine.RunSimpleString(@"
+                    Interlocked.Exchange(ref pythonThreadID, (long)PythonEngine.GetPythonThreadID());
+                    return PythonEngine.RunSimpleString(@"
 import time
 
 while True:
     time.sleep(0.2)");
                 }
             });
 
-            Thread.Sleep(200);
-
-            Assert.AreNotEqual(ulong.MinValue, pythonThreadID);
+            var timeout = Stopwatch.StartNew();
+            while (Interlocked.Read(ref pythonThreadID) == 0)
+            {
+                Assert.Less(timeout.Elapsed, TimeSpan.FromSeconds(5), "thread ID was not assigned in time");
+            }
 
             using (Py.GIL())
             {
-                int interruptReturnValue = PythonEngine.Interrupt(pythonThreadID);
+                int interruptReturnValue = PythonEngine.Interrupt((ulong)Interlocked.Read(ref pythonThreadID));
                 Assert.AreEqual(1, interruptReturnValue);
             }
 
-            Thread.Sleep(300);
+            Assert.IsTrue(asyncCall.Wait(TimeSpan.FromSeconds(5)), "Async thread was not interrupted in time");
 
-            Assert.AreEqual(-1, runSimpleStringReturnValue);
+            Assert.AreEqual(-1, asyncCall.Result);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`
`2`	`2`	`using System;`
	`3`	`+using System.Diagnostics;`
`3`	`4`	`using System.Threading;`
`4`	`5`	`using System.Threading.Tasks;`
`5`	`6`
`@@ -30,34 +31,35 @@ public void Dispose()`
`30`	`31`	`[Test]`
`31`	`32`	`public void InterruptTest()`
`32`	`33`	`{`
`33`		`- int runSimpleStringReturnValue = int.MinValue;`
`34`		`- ulong pythonThreadID = ulong.MinValue;`
`35`		`- Task.Factory.StartNew(() =>`
	`34`	`+ long pythonThreadID = 0;`
	`35`	`+ var asyncCall = Task.Factory.StartNew(() =>`
`36`	`36`	`{`
`37`	`37`	`using (Py.GIL())`
`38`	`38`	`{`
`39`		`- pythonThreadID = PythonEngine.GetPythonThreadID();`
`40`		`- runSimpleStringReturnValue = PythonEngine.RunSimpleString(@"`
	`39`	`+ Interlocked.Exchange(ref pythonThreadID, (long)PythonEngine.GetPythonThreadID());`
	`40`	`+ return PythonEngine.RunSimpleString(@"`
`41`	`41`	`import time`
`42`	`42`
`43`	`43`	`while True:`
`44`	`44`	`time.sleep(0.2)");`
`45`	`45`	`}`
`46`	`46`	`});`
`47`	`47`
`48`		`- Thread.Sleep(200);`
`49`		`-`
`50`		`- Assert.AreNotEqual(ulong.MinValue, pythonThreadID);`
	`48`	`+ var timeout = Stopwatch.StartNew();`
	`49`	`+ while (Interlocked.Read(ref pythonThreadID) == 0)`
	`50`	`+ {`
	`51`	`+ Assert.Less(timeout.Elapsed, TimeSpan.FromSeconds(5), "thread ID was not assigned in time");`
	`52`	`+ }`
`51`	`53`
`52`	`54`	`using (Py.GIL())`
`53`	`55`	`{`
`54`		`- int interruptReturnValue = PythonEngine.Interrupt(pythonThreadID);`
	`56`	`+ int interruptReturnValue = PythonEngine.Interrupt((ulong)Interlocked.Read(ref pythonThreadID));`
`55`	`57`	`Assert.AreEqual(1, interruptReturnValue);`
`56`	`58`	`}`
`57`	`59`
`58`		`- Thread.Sleep(300);`
	`60`	`+ Assert.IsTrue(asyncCall.Wait(TimeSpan.FromSeconds(5)), "Async thread was not interrupted in time");`
`59`	`61`
`60`		`- Assert.AreEqual(-1, runSimpleStringReturnValue);`
	`62`	`+ Assert.AreEqual(-1, asyncCall.Result);`
`61`	`63`	`}`
`62`	`64`	`}`
`63`	`65`	`}`