[runtime] Remove all NACL support. It was unmaintained for a long time. (#4955)

[mono.git] / mono / tests / interlocked.cs

diff --git a/mono/tests/interlocked.cs b/mono/tests/interlocked.cs
index c9717878f7b577bfa22b724f73b8af7f50dfca23..d17a0a7bf7e4c548f025c9131d45725932f0b8fc 100644 (file)
--- a/mono/tests/interlocked.cs
+++ b/mono/tests/interlocked.cs
@@ -17,40 +17,71 @@ public class InterlockTest
                it.test = 0;
                int c = Interlocked.Exchange (ref it.test, 1);
                if (c != 0)
-                       return -1;
+                       return 1;
 
                if (it.test != 1)
-                       return -2;
+                       return 2;
+
+               it.test = -2;
+               c = Interlocked.CompareExchange (ref it.test, 1, -2);
+               if (c != -2)
+                       return 3;
+
+               if (it.test != 1)
+                       return 4;
+
+               a = 10;
+               c = Interlocked.Exchange (ref a, 5);
+               if (c != 10)
+                       return 5;
+               if (a != 5)
+                       return 5;
 
                a = 1;
                b = Interlocked.Increment (ref a);
                if (a != 2)
-                       return -3;
+                       return 5;
                if (b != 2)
-                       return -4;
+                       return 6;
 
                a = 2;
                b = Interlocked.Decrement (ref a);
                if (b != 1)
-                       return -3;
+                       return 7;
                if (a != 1)
-                       return -4;
+                       return 8;
 
                string s = IncTest ();
                if (s != "A1")
-                       return -5;
+                       return 9;
 
                s = IncTest ();
                if (s != "A2")
-                       return -6;
+                       return 10;
 
                Thread.MemoryBarrier ();
 
+               interlocked_regalloc1 ();
+
                Console.WriteLine ("done!");
 
                return 0;
        }
 
+       public static object[] buckets;
+       public static object segmentCache;
+
+       public static int interlocked_regalloc1 () {
+          int segment = 0;
+          buckets = new object [10];
+
+          if (buckets[segment] == null) {
+                  object newSegment = new Object ();
+                  segmentCache = Interlocked.CompareExchange (ref buckets[segment], newSegment, null) == null ? null : newSegment;
+          }
+          return 0;
+       }
+
        public static string IncTest () {
                return "A" + Interlocked.Increment (ref s_test);
        }