Add microthreading test to ContinuationsTest

diff --git a/mcs/class/Mono.Tasklets/Test/Mono.Tasklets/ContinuationsTest.cs b/mcs/class/Mono.Tasklets/Test/Mono.Tasklets/ContinuationsTest.cs
index 5f75664666b35e0fd899e3cf7c253213a8dde125..d0b2de6542978b53e0914d753b927fddb64a709d 100644 (file)
--- a/mcs/class/Mono.Tasklets/Test/Mono.Tasklets/ContinuationsTest.cs
+++ b/mcs/class/Mono.Tasklets/Test/Mono.Tasklets/ContinuationsTest.cs
@@ -29,11 +29,13 @@ namespace MonoTests.System
                        Assert.AreEqual(total,330);
                }
 
+               private int yields = 0;
+
                [Test]
                public void Yielding() {
                        Continuation baseCont = new Continuation();
                        Continuation taskCont = new Continuation();
-                       int yields = 0;
+                       
                        baseCont.Mark();
                        taskCont.Mark();
                        
@@ -69,12 +71,102 @@ namespace MonoTests.System
                                taskCont.Restore(1);
                        }
 
-                       Assert.AreEqual(yields,9);
+                       Assert.AreEqual(9, yields);
+               }
+
+
+               public class MicroThread {
+                       
+                       public void Yield() {
+                               if (MyThread.Store(0) == 0) {
+                                       MainThread.Restore(1);
+                               }
+                       }
+
+                       public void Resume() {
+                               if (MainThread.Store(0) == 0) {
+                                       MyThread.Restore(1);
+                               }
+                       }
+
+                       public void DoWork(Action action) {
+                               if (MainThread.Store(0) == 0) {
+                                       action();
+                                       Done = true;
+                                       MainThread.Restore(1);
+                               }
+                       }
+
+                       public bool Done = false;
+                       public Continuation MainThread = new Continuation();
+                       public Continuation MyThread = new Continuation();
+               }
+               
+               public class MicroBJob {
+                       private int _Count = 0;
+                       public int Count { 
+                               get { return _Count; }
+                               set { _Count = value;}
+                       }
+
+                       public MicroThread MicroThread;
+                       public void Work() {
+                               while (Count < 100) {
+                                       ++Count;
+                                       if (Count % 10 == 0) {
+                                               MicroThread.Yield();
+                                       }
+                               }
+                       }
                }
+
+               [Test]
+               public void MicroThreadTest() {
+                       MicroThread microA = new MicroThread();
+                       MicroThread microB = new MicroThread();
+
+                       microA.MainThread.Mark();
+                       microA.MyThread.Mark();
+                       microB.MainThread.Mark();
+                       microB.MyThread.Mark();
+
+                       Assert.AreEqual(false,microA.Done);
+                       Assert.AreEqual(false,microB.Done);
                        
+                       microA.DoWork( () => {
+                               int count = 0;
+                               while (count < 100) {
+                                       ++count;
+                                       if (count % 10 == 0) {
+                                               microA.Yield();
+                                       }
+                               }
+                       });
                
+                       MicroBJob jobB = new MicroBJob();
+                       jobB.MicroThread = microB;
+
+                       microB.DoWork(jobB.Work);
+
+                       Assert.AreEqual(false,microA.Done);
+                       Assert.AreEqual(false,microB.Done);
+
+                       int yields = 0;
+                       while (yields < 20) {
+                               if (!microA.Done) microA.Resume();
+                               if (!microB.Done) microB.Resume();
+                               if (microA.Done && microB.Done) break;
+                               ++yields;
+                       }
+
+                       Assert.AreEqual(true,microA.Done);
+                       Assert.AreEqual(true,microB.Done);
+                       Assert.AreEqual(100,jobB.Count);
+                       Assert.AreEqual(9,yields);
+               }
        }
 }
+
 // vim: noexpandtab
 // Local Variables:
 // tab-width: 4