changeset 176:0ccda6e7f6e3

Migrate atomics.integer.* tests to annotation API.
author shade
date Tue, 12 Aug 2014 02:01:21 +0400
parents 2e9029fc1878
children 2478e0e5a85f
files tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerFieldUpdaterPairwiseTests.java tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerInitialValueTest.java tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerPairwiseTests.java tests-custom/src/main/resources/org/openjdk/jcstress/desc/atomic-integer-updater.xml tests-custom/src/main/resources/org/openjdk/jcstress/desc/atomic-integer.xml
diffstat 5 files changed, 360 insertions(+), 2199 deletions(-) [+]
line wrap: on
line diff
--- a/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerFieldUpdaterPairwiseTests.java	Tue Aug 12 01:46:23 2014 +0400
+++ b/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerFieldUpdaterPairwiseTests.java	Tue Aug 12 02:01:21 2014 +0400
@@ -26,7 +26,11 @@
 
 import org.openjdk.jcstress.annotations.Actor;
 import org.openjdk.jcstress.annotations.Arbiter;
+import org.openjdk.jcstress.annotations.Description;
+import org.openjdk.jcstress.annotations.Expect;
+import org.openjdk.jcstress.annotations.JCStressMeta;
 import org.openjdk.jcstress.annotations.JCStressTest;
+import org.openjdk.jcstress.annotations.Outcome;
 import org.openjdk.jcstress.annotations.State;
 import org.openjdk.jcstress.infra.results.IntResult1;
 import org.openjdk.jcstress.infra.results.IntResult2;
@@ -41,63 +45,98 @@
         public final AtomicIntegerFieldUpdater<S> u = AtomicIntegerFieldUpdater.newUpdater(S.class, "v");
     }
 
+    @Description("Tests pairwise operations on AtomicIntegerArray")
+    public static class G {
+
+    }
+
     // ------------------- first is addAndGet
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 10]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 5]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_AddAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.addAndGet(s, 5); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 4]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[4, -1]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_DecAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.decrementAndGet(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 5]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_GetAndAdd {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndAdd(s, 5); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 5]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[4, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_GetAndDec {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndDecrement(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 5]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[6, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_GetAndInc {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndIncrement(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 5]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[15, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_GetAndSet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 6]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[6, 1]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_IncAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.incrementAndGet(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[25, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_CAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[25, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 0]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[15, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
@@ -106,54 +145,81 @@
     // ------------------- first is decAndGet
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, -2]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[-2, -1]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_DecAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.decrementAndGet(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, -1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[4, 0]",   expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_GetAndAdd {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndAdd(s, 5); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, -1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[-2, 0]",  expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_GetAndDec {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndDecrement(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, -1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[0, 0]",   expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_GetAndInc {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndIncrement(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, -1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[9, 0]",   expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_GetAndSet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, 0]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[0, 1]",  expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_IncAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.incrementAndGet(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, 10]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[19, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_CAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, 10]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[19, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, 0]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[9, 0]",  expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
         @Actor public void actor2(S s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
@@ -162,48 +228,72 @@
     // ------------------- first is getAndAdd
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 5]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[5, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndAdd_GetAndAdd {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndAdd(s, 5); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 5]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[-1, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndAdd_GetAndDec {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndDecrement(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 5]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndAdd_GetAndInc {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndIncrement(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 5]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndAdd_GetAndSet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 6]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 1]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndAdd_IncAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.incrementAndGet(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[20, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndAdd_CAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[20, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndAdd_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 0]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndAdd_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
@@ -212,42 +302,63 @@
     // ------------------- first is getAndDec
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, -1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[-1, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndDec_GetAndDec {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndDecrement(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndDecrement(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, -1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 0]",  expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndDec_GetAndInc {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndDecrement(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndIncrement(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, -1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndDec_GetAndSet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndDecrement(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 0]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 1]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndDec_IncAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndDecrement(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.incrementAndGet(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[20, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndDec_CAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndDecrement(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[20, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndDec_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndDecrement(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 0]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndDec_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndDecrement(s); }
         @Actor public void actor2(S s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
@@ -256,36 +367,54 @@
     // ------------------- first is getAndInc
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndInc_GetAndInc {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndIncrement(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndIncrement(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndInc_GetAndSet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndIncrement(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 2]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 1]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndInc_IncAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndIncrement(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.incrementAndGet(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[20, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndInc_CAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndIncrement(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[20, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndInc_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndIncrement(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 0]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndInc_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndIncrement(s); }
         @Actor public void actor2(S s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
@@ -294,30 +423,45 @@
     // ------------------- first is getAndSet
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 5]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndSet_GetAndSet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 6]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 1]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndSet_IncAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.incrementAndGet(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[20, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndSet_CAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[20, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndSet_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 0]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndSet_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
         @Actor public void actor2(S s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
@@ -326,24 +470,36 @@
     // ------------------- first is incAndGet
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[1, 2]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[2, 1]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class IncAndGet_IncAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.incrementAndGet(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.incrementAndGet(s); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[1, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[21, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class IncAndGet_CAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.incrementAndGet(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[1, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[21, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class IncAndGet_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.incrementAndGet(s); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[1, 0]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[11, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class IncAndGet_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.incrementAndGet(s); }
         @Actor public void actor2(S s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
@@ -352,18 +508,27 @@
     // ------------------- first is CAS
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 10]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class CAS_CAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.compareAndSet(s, 0, 5) ? 5 : 1; }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 10]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class CAS_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.compareAndSet(s, 0, 5) ? 5 : 1; }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 0]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class CAS_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.compareAndSet(s, 0, 5) ? 5 : 1; }
         @Actor public void actor2(S s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
@@ -372,12 +537,18 @@
     // ------------------- first is WCAS
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 10]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class WCAS_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.weakCompareAndSet(s, 0, 5) ? 5 : 1; }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 0]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class WCAS_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.u.weakCompareAndSet(s, 0, 5) ? 5 : 1; }
         @Actor public void actor2(S s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
@@ -386,9 +557,12 @@
     // ------------------- first is set
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class Set_Set {
-        @Actor   public void actor1(S s, IntResult1 r) { s.u.set(s, 5); }
-        @Actor   public void actor2(S s, IntResult1 r) { s.u.set(s, 10); }
+        @Actor public void actor1(S s, IntResult1 r) { s.u.set(s, 5); }
+        @Actor public void actor2(S s, IntResult1 r) { s.u.set(s, 10); }
         @Arbiter public void arbiter1(S s, IntResult1 r) { r.r1 = s.u.get(s); }
     }
 
--- a/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerInitialValueTest.java	Tue Aug 12 01:46:23 2014 +0400
+++ b/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerInitialValueTest.java	Tue Aug 12 02:01:21 2014 +0400
@@ -25,13 +25,20 @@
 package org.openjdk.jcstress.tests.atomics.integer;
 
 import org.openjdk.jcstress.annotations.Actor;
+import org.openjdk.jcstress.annotations.Description;
+import org.openjdk.jcstress.annotations.Expect;
 import org.openjdk.jcstress.annotations.JCStressTest;
+import org.openjdk.jcstress.annotations.Outcome;
 import org.openjdk.jcstress.annotations.State;
 import org.openjdk.jcstress.infra.results.IntResult1;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
 @JCStressTest
+@Description("Tests the visibility of AtomicIntegerArray initial values.")
+@Outcome(id = "[-1]", expect = Expect.ACCEPTABLE, desc = "Seeing null AtomicX, this is a legal race.")
+@Outcome(id = "[1]",  expect = Expect.ACCEPTABLE, desc = "Acceptable to see the initial value.")
+@Outcome(id = "[0]",  expect = Expect.ACCEPTABLE, desc = "Acceptable to see a default value!")
 @State
 public class AtomicIntegerInitialValueTest {
 
--- a/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerPairwiseTests.java	Tue Aug 12 01:46:23 2014 +0400
+++ b/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerPairwiseTests.java	Tue Aug 12 02:01:21 2014 +0400
@@ -26,7 +26,11 @@
 
 import org.openjdk.jcstress.annotations.Actor;
 import org.openjdk.jcstress.annotations.Arbiter;
+import org.openjdk.jcstress.annotations.Description;
+import org.openjdk.jcstress.annotations.Expect;
+import org.openjdk.jcstress.annotations.JCStressMeta;
 import org.openjdk.jcstress.annotations.JCStressTest;
+import org.openjdk.jcstress.annotations.Outcome;
 import org.openjdk.jcstress.annotations.State;
 import org.openjdk.jcstress.infra.results.IntResult1;
 import org.openjdk.jcstress.infra.results.IntResult2;
@@ -39,63 +43,98 @@
     public static class S extends AtomicInteger {
     }
 
+    @Description("Tests pairwise operations on AtomicInteger")
+    public static class G {
+
+    }
+
     // ------------------- first is addAndGet
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 10]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 5]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_AddAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.addAndGet(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.addAndGet(5); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 4]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[4, -1]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_DecAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.addAndGet(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.decrementAndGet(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 5]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_GetAndAdd {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.addAndGet(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndAdd(5); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 5]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[4, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_GetAndDec {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.addAndGet(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndDecrement(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 5]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[6, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_GetAndInc {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.addAndGet(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndIncrement(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 5]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[15, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_GetAndSet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.addAndGet(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndSet(10); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 6]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[6, 1]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_IncAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.addAndGet(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.incrementAndGet(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[25, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_CAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.addAndGet(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[25, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.addAndGet(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 0]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[15, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class AddAndGet_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.addAndGet(5); }
         @Actor public void actor2(S s, IntResult2 r) { s.set(10); r.r2 = 0; }
@@ -104,54 +143,81 @@
     // ------------------- first is decAndGet
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, -2]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[-2, -1]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_DecAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.decrementAndGet(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, -1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[4, 0]",   expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_GetAndAdd {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndAdd(5); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, -1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[-2, 0]",  expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_GetAndDec {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndDecrement(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, -1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[0, 0]",   expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_GetAndInc {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndIncrement(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, -1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[9, 0]",   expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_GetAndSet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndSet(10); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, 0]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[0, 1]",  expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_IncAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.incrementAndGet(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, 10]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[19, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_CAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, 10]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[19, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[-1, 0]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[9, 0]",  expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class DecAndGet_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
         @Actor public void actor2(S s, IntResult2 r) { s.set(10); r.r2 = 0; }
@@ -160,48 +226,72 @@
     // ------------------- first is getAndAdd
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 5]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[5, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndAdd_GetAndAdd {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndAdd(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndAdd(5); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 5]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[-1, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndAdd_GetAndDec {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndAdd(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndDecrement(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 5]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndAdd_GetAndInc {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndAdd(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndIncrement(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 5]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndAdd_GetAndSet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndAdd(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndSet(10); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 6]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 1]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndAdd_IncAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndAdd(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.incrementAndGet(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[20, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndAdd_CAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndAdd(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[20, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndAdd_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndAdd(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 0]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndAdd_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndAdd(5); }
         @Actor public void actor2(S s, IntResult2 r) { s.set(10); r.r2 = 0; }
@@ -210,42 +300,63 @@
     // ------------------- first is getAndDec
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, -1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[-1, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndDec_GetAndDec {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndDecrement(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndDecrement(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, -1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 0]",  expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndDec_GetAndInc {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndDecrement(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndIncrement(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, -1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndDec_GetAndSet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndDecrement(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndSet(10); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 0]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 1]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndDec_IncAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndDecrement(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.incrementAndGet(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[20, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndDec_CAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndDecrement(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[20, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndDec_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndDecrement(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 0]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndDec_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndDecrement(); }
         @Actor public void actor2(S s, IntResult2 r) { s.set(10); r.r2 = 0; }
@@ -254,36 +365,54 @@
     // ------------------- first is getAndInc
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndInc_GetAndInc {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndIncrement(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndIncrement(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 1]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndInc_GetAndSet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndIncrement(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndSet(10); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 2]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 1]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndInc_IncAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndIncrement(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.incrementAndGet(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[20, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndInc_CAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndIncrement(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[20, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndInc_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndIncrement(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 0]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndInc_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndIncrement(); }
         @Actor public void actor2(S s, IntResult2 r) { s.set(10); r.r2 = 0; }
@@ -292,30 +421,45 @@
     // ------------------- first is getAndSet
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 5]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndSet_GetAndSet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndSet(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.getAndSet(10); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 6]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 1]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndSet_IncAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndSet(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.incrementAndGet(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[20, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndSet_CAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndSet(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[20, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndSet_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndSet(5); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[0, 0]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class GetAndSet_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.getAndSet(5); }
         @Actor public void actor2(S s, IntResult2 r) { s.set(10); r.r2 = 0; }
@@ -324,24 +468,36 @@
     // ------------------- first is incAndGet
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[1, 2]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[2, 1]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class IncAndGet_IncAndGet {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.incrementAndGet(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.incrementAndGet(); }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[1, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[21, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class IncAndGet_CAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.incrementAndGet(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[1, 10]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[21, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class IncAndGet_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.incrementAndGet(); }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[1, 0]",  expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[11, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class IncAndGet_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.incrementAndGet(); }
         @Actor public void actor2(S s, IntResult2 r) { s.set(10); r.r2 = 0; }
@@ -350,18 +506,27 @@
     // ------------------- first is CAS
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 10]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class CAS_CAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.compareAndSet(0, 5) ? 5 : 1; }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 10]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class CAS_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.compareAndSet(0, 5) ? 5 : 1; }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 0]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class CAS_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.compareAndSet(0, 5) ? 5 : 1; }
         @Actor public void actor2(S s, IntResult2 r) { s.set(10); r.r2 = 0; }
@@ -370,12 +535,18 @@
     // ------------------- first is WCAS
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 10]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 20]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class WCAS_WCAS {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.weakCompareAndSet(0, 5) ? 5 : 1; }
         @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
     @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5, 0]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[1, 0]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class WCAS_Set {
         @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.weakCompareAndSet(0, 5) ? 5 : 1; }
         @Actor public void actor2(S s, IntResult2 r) { s.set(10); r.r2 = 0; }
@@ -383,9 +554,13 @@
 
     // ------------------- first is set
 
+    @JCStressTest
+    @JCStressMeta(G.class)
+    @Outcome(id = "[5]", expect = Expect.ACCEPTABLE, desc = "T1 -> T2 execution")
+    @Outcome(id = "[10]", expect = Expect.ACCEPTABLE, desc = "T2 -> T1 execution")
     public static class Set_Set {
-        @Actor   public void actor1(S s, IntResult1 r) { s.set(5); }
-        @Actor   public void actor2(S s, IntResult1 r) { s.set(10); }
+        @Actor public void actor1(S s, IntResult1 r) { s.set(5); }
+        @Actor public void actor2(S s, IntResult1 r) { s.set(10); }
         @Arbiter public void arbiter1(S s, IntResult1 r) { r.r1 = s.get(); }
     }
 
--- a/tests-custom/src/main/resources/org/openjdk/jcstress/desc/atomic-integer-updater.xml	Tue Aug 12 01:46:23 2014 +0400
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1079 +0,0 @@
-<!--
-
-    Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
-    DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
-
-    This code is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License version 2 only, as
-    published by the Free Software Foundation.  Oracle designates this
-    particular file as subject to the "Classpath" exception as provided
-    by Oracle in the LICENSE file that accompanied this code.
-
-    This code is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    version 2 for more details (a copy is included in the LICENSE file that
-    accompanied this code).
-
-    You should have received a copy of the GNU General Public License version
-    2 along with this work; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
-
-    Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
-    or visit www.oracle.com if you need additional information or have any
-    questions.
-
--->
-<testsuite>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$AddAndGet_AddAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[5, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$AddAndGet_DecAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[5, 4]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[4, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$AddAndGet_CAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[5, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[25, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$AddAndGet_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[5, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[25, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$AddAndGet_GetAndAdd">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[5, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$AddAndGet_GetAndDec">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[5, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[4, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$AddAndGet_GetAndInc">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[5, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[6, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$AddAndGet_GetAndSet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[5, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[15, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$AddAndGet_IncAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[5, 6]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[6, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$AddAndGet_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[5, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[15, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$DecAndGet_CAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[-1, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[19, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$DecAndGet_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[-1, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[19, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$DecAndGet_DecAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[-1, -2]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[-2, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$DecAndGet_GetAndAdd">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[-1, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[4, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$DecAndGet_GetAndDec">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[-1, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[-2, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$DecAndGet_GetAndInc">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[-1, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[0, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$DecAndGet_GetAndSet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[-1, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[9, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$DecAndGet_IncAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[-1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[0, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$DecAndGet_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[-1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[9, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndAdd_CAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[20, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndAdd_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[20, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndAdd_GetAndAdd">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[5, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndAdd_GetAndDec">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[-1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndAdd_GetAndInc">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndAdd_GetAndSet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndAdd_IncAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 6]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndAdd_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndDec_CAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[20, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndDec_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[20, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndDec_GetAndDec">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[-1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndDec_GetAndInc">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndDec_GetAndSet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndDec_IncAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndDec_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndInc_CAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[20, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndInc_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[20, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndInc_GetAndInc">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndInc_GetAndSet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndInc_IncAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 2]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndInc_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndSet_CAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[20, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndSet_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[20, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndSet_GetAndSet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndSet_IncAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 6]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$GetAndSet_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[0, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$IncAndGet_CAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[1, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[21, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$IncAndGet_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[1, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[21, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$IncAndGet_IncAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[1, 2]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[2, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$IncAndGet_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[11, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$Set_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$CAS_CAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[5, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$CAS_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[5, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[1, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$CAS_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[5, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$WCAS_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[5, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[1, 10]</match>
-            <expect>ACCEPTABLE_INTERESTING</expect>
-            <description>Tx[fail] -> Tx[fail]</description>
-        </case>
-        <case>
-            <match>[1, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerFieldUpdaterPairwiseTests$WCAS_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicIntegerFieldUpdater pair-wise operations.</description>
-        <case>
-            <match>[5, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-</testsuite>
--- a/tests-custom/src/main/resources/org/openjdk/jcstress/desc/atomic-integer.xml	Tue Aug 12 01:46:23 2014 +0400
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1116 +0,0 @@
-<!--
-
-    Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
-    DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
-
-    This code is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License version 2 only, as
-    published by the Free Software Foundation.  Oracle designates this
-    particular file as subject to the "Classpath" exception as provided
-    by Oracle in the LICENSE file that accompanied this code.
-
-    This code is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    version 2 for more details (a copy is included in the LICENSE file that
-    accompanied this code).
-
-    You should have received a copy of the GNU General Public License version
-    2 along with this work; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
-
-    Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
-    or visit www.oracle.com if you need additional information or have any
-    questions.
-
--->
-<testsuite>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerInitialValueTest">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>
-            Tests the visibility of AtomicInteger initial value.
-        </description>
-        <case>
-            <match>[0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>
-                Possible to see the default value, since the instance is published via race.
-            </description>
-            <refs>
-                <url>http://cs.oswego.edu/pipermail/concurrency-interest/2013-November/011951.html</url>
-            </refs>
-        </case>
-        <case>
-            <match>[1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>
-                Required to see the initial value.
-            </description>
-        </case>
-        <case>
-            <match>[-1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>
-                Seeing the null AtomicInteger. This is a legal race.
-            </description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>
-                Other cases are not expected.
-            </description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$AddAndGet_AddAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[5, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$AddAndGet_DecAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[5, 4]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[4, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$AddAndGet_CAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[5, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[25, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$AddAndGet_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[5, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[25, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$AddAndGet_GetAndAdd">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[5, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$AddAndGet_GetAndDec">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[5, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[4, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$AddAndGet_GetAndInc">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[5, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[6, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$AddAndGet_GetAndSet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[5, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[15, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$AddAndGet_IncAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[5, 6]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[6, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$AddAndGet_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[5, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[15, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$DecAndGet_CAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[-1, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[19, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$DecAndGet_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[-1, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[19, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$DecAndGet_DecAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[-1, -2]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[-2, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$DecAndGet_GetAndAdd">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[-1, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[4, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$DecAndGet_GetAndDec">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[-1, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[-2, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$DecAndGet_GetAndInc">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[-1, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[0, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$DecAndGet_GetAndSet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[-1, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[9, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$DecAndGet_IncAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[-1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[0, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$DecAndGet_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[-1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[9, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndAdd_CAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[20, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndAdd_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[20, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndAdd_GetAndAdd">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[5, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndAdd_GetAndDec">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[-1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndAdd_GetAndInc">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndAdd_GetAndSet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndAdd_IncAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 6]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndAdd_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndDec_CAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[20, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndDec_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[20, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndDec_GetAndDec">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[-1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndDec_GetAndInc">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndDec_GetAndSet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, -1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndDec_IncAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndDec_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndInc_CAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[20, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndInc_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[20, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndInc_GetAndInc">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndInc_GetAndSet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndInc_IncAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 2]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndInc_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndSet_CAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[20, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndSet_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[20, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndSet_GetAndSet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndSet_IncAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 6]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$GetAndSet_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[0, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$IncAndGet_CAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[1, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[21, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$IncAndGet_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[1, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[21, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$IncAndGet_IncAndGet">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[1, 2]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[2, 1]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$IncAndGet_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[11, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$Set_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[5]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$CAS_CAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[5, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$CAS_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[5, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[1, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$CAS_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[5, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$WCAS_WCAS">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[5, 10]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution, or T2[fail] -> T1 execution.</description>
-        </case>
-        <case>
-            <match>[1, 10]</match>
-            <expect>ACCEPTABLE_INTERESTING</expect>
-            <description>Tx[fail] -> Tx[fail]</description>
-        </case>
-        <case>
-            <match>[1, 20]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-    <test name="org.openjdk.jcstress.tests.atomics.integer.AtomicIntegerPairwiseTests$WCAS_Set">
-        <contributed-by>Aleksey Shipilev (aleksey.shipilev@oracle.com)</contributed-by>
-        <description>Tests the atomicity of AtomicInteger pair-wise operations.</description>
-        <case>
-            <match>[5, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T1 -> T2 execution.</description>
-        </case>
-        <case>
-            <match>[1, 0]</match>
-            <expect>ACCEPTABLE</expect>
-            <description>T2 -> T1 execution.</description>
-        </case>
-        <unmatched>
-            <expect>FORBIDDEN</expect>
-            <description>Other cases are not expected.</description>
-        </unmatched>
-    </test>
-
-</testsuite>