changeset 99:4e65f3ea2e35

Migrate atomics.* tests to new API.
author shade
date Fri, 14 Mar 2014 00:35:06 +0400
parents dc6ce8b3a255
children 236597b2feab
files tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/booleans/AtomicBooleanInitialValueTest.java tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/booleans/AtomicBooleanPairwiseTests.java tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerArrayInitialValueTest.java tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerArrayPairwiseTests.java 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/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongArrayInitialValueTest.java tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongArrayInterleaveTest.java tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongArrayPairwiseTests.java tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongFieldUpdaterPairwiseTests.java tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongInitialValueTest.java tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongPairwiseTests.java
diffstat 13 files changed, 1484 insertions(+), 1201 deletions(-) [+]
line wrap: on
line diff
--- a/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/booleans/AtomicBooleanInitialValueTest.java	Thu Mar 13 23:43:43 2014 +0400
+++ b/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/booleans/AtomicBooleanInitialValueTest.java	Fri Mar 14 00:35:06 2014 +0400
@@ -24,36 +24,29 @@
  */
 package org.openjdk.jcstress.tests.atomics.booleans;
 
+import org.openjdk.jcstress.infra.annotations.Actor;
+import org.openjdk.jcstress.infra.annotations.ConcurrencyStressTest;
+import org.openjdk.jcstress.infra.annotations.State;
 import org.openjdk.jcstress.infra.results.IntResult1;
 import org.openjdk.jcstress.tests.Actor2_Test;
 
 import java.util.concurrent.atomic.AtomicBoolean;
 
-public class AtomicBooleanInitialValueTest implements Actor2_Test<AtomicBooleanInitialValueTest.Shell, IntResult1> {
+@ConcurrencyStressTest
+@State
+public class AtomicBooleanInitialValueTest {
 
-    public static class Shell {
-        public AtomicBoolean ai;
+    public AtomicBoolean ai;
+
+    @Actor
+    public void actor1() {
+        ai = new AtomicBoolean(true);
     }
 
-    @Override
-    public void actor1(Shell s, IntResult1 r) {
-        s.ai = new AtomicBoolean(true);
-    }
-
-    @Override
-    public void actor2(Shell s, IntResult1 r) {
-        AtomicBoolean ai = s.ai;
+    @Actor
+    public void actor2(IntResult1 r) {
+        AtomicBoolean ai = this.ai;
         r.r1 = (ai == null) ? -1 : (ai.get() ? 1 : 0);
     }
 
-    @Override
-    public Shell newState() {
-        return new Shell();
-    }
-
-    @Override
-    public IntResult1 newResult() {
-        return new IntResult1();
-    }
-
 }
--- a/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/booleans/AtomicBooleanPairwiseTests.java	Thu Mar 13 23:43:43 2014 +0400
+++ b/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/booleans/AtomicBooleanPairwiseTests.java	Fri Mar 14 00:35:06 2014 +0400
@@ -24,6 +24,9 @@
  */
 package org.openjdk.jcstress.tests.atomics.booleans;
 
+import org.openjdk.jcstress.infra.annotations.Actor;
+import org.openjdk.jcstress.infra.annotations.ConcurrencyStressTest;
+import org.openjdk.jcstress.infra.annotations.State;
 import org.openjdk.jcstress.infra.results.IntResult2;
 import org.openjdk.jcstress.tests.Actor2_Test;
 
@@ -31,40 +34,44 @@
 
 public class AtomicBooleanPairwiseTests {
 
-    public abstract static class AbstractTest implements Actor2_Test<AtomicBoolean, IntResult2> {
-        @Override public AtomicBoolean newState() { return new AtomicBoolean(); }
-        @Override public IntResult2 newResult() { return new IntResult2(); }
+    @State
+    public static class MyState extends AtomicBoolean {
     }
 
-    public static class CAS_CAS extends AbstractTest {
-        @Override public void actor1(AtomicBoolean s, IntResult2 r) { r.r1 = s.compareAndSet(false, true) ? 1 : 0; }
-        @Override public void actor2(AtomicBoolean s, IntResult2 r) { r.r2 = s.compareAndSet(false, true) ? 1 : 0; }
+    @ConcurrencyStressTest
+    public static class CAS_CAS {
+        @Actor public void actor1(MyState s, IntResult2 r) { r.r1 = s.compareAndSet(false, true) ? 1 : 0; }
+        @Actor public void actor2(MyState s, IntResult2 r) { r.r2 = s.compareAndSet(false, true) ? 1 : 0; }
     }
 
-    public static class CAS_GetAndSet extends AbstractTest {
-        @Override public void actor1(AtomicBoolean s, IntResult2 r) { r.r1 = s.compareAndSet(false, true) ? 1 : 0; }
-        @Override public void actor2(AtomicBoolean s, IntResult2 r) { r.r2 = s.getAndSet(true) ? 0 : 1; }
+    @ConcurrencyStressTest
+    public static class CAS_GetAndSet {
+        @Actor public void actor1(MyState s, IntResult2 r) { r.r1 = s.compareAndSet(false, true) ? 1 : 0; }
+        @Actor public void actor2(MyState s, IntResult2 r) { r.r2 = s.getAndSet(true) ? 0 : 1; }
     }
 
-    public static class CAS_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicBoolean s, IntResult2 r) { r.r1 = s.compareAndSet(false, true) ? 1 : 0; }
-        @Override public void actor2(AtomicBoolean s, IntResult2 r) { r.r2 = s.weakCompareAndSet(false, true) ? 1 : 0; }
+    @ConcurrencyStressTest
+    public static class CAS_WCAS {
+        @Actor public void actor1(MyState s, IntResult2 r) { r.r1 = s.compareAndSet(false, true) ? 1 : 0; }
+        @Actor public void actor2(MyState s, IntResult2 r) { r.r2 = s.weakCompareAndSet(false, true) ? 1 : 0; }
     }
 
-    public static class GetAndSet_GetAndSet extends AbstractTest {
-        @Override public void actor1(AtomicBoolean s, IntResult2 r) { r.r1 = s.getAndSet(true) ? 0 : 1; }
-        @Override public void actor2(AtomicBoolean s, IntResult2 r) { r.r2 = s.getAndSet(true) ? 0 : 1; }
+    @ConcurrencyStressTest
+    public static class GetAndSet_GetAndSet {
+        @Actor public void actor1(MyState s, IntResult2 r) { r.r1 = s.getAndSet(true) ? 0 : 1; }
+        @Actor public void actor2(MyState s, IntResult2 r) { r.r2 = s.getAndSet(true) ? 0 : 1; }
     }
 
-    public static class GetAndSet_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicBoolean s, IntResult2 r) { r.r1 = s.getAndSet(true) ? 0 : 1; }
-        @Override public void actor2(AtomicBoolean s, IntResult2 r) { r.r2 = s.weakCompareAndSet(false, true) ? 1 : 0; }
+    @ConcurrencyStressTest
+    public static class GetAndSet_WCAS {
+        @Actor public void actor1(MyState s, IntResult2 r) { r.r1 = s.getAndSet(true) ? 0 : 1; }
+        @Actor public void actor2(MyState s, IntResult2 r) { r.r2 = s.weakCompareAndSet(false, true) ? 1 : 0; }
     }
 
-    public static class WCAS_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicBoolean s, IntResult2 r) { r.r1 = s.weakCompareAndSet(false, true) ? 1 : 0; }
-        @Override public void actor2(AtomicBoolean s, IntResult2 r) { r.r2 = s.weakCompareAndSet(false, true) ? 1 : 0; }
+    @ConcurrencyStressTest
+    public static class WCAS_WCAS {
+        @Actor public void actor1(MyState s, IntResult2 r) { r.r1 = s.weakCompareAndSet(false, true) ? 1 : 0; }
+        @Actor public void actor2(MyState s, IntResult2 r) { r.r2 = s.weakCompareAndSet(false, true) ? 1 : 0; }
     }
 
-
 }
--- a/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerArrayInitialValueTest.java	Thu Mar 13 23:43:43 2014 +0400
+++ b/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerArrayInitialValueTest.java	Fri Mar 14 00:35:06 2014 +0400
@@ -24,39 +24,32 @@
  */
 package org.openjdk.jcstress.tests.atomics.integer;
 
+import org.openjdk.jcstress.infra.annotations.Actor;
+import org.openjdk.jcstress.infra.annotations.ConcurrencyStressTest;
+import org.openjdk.jcstress.infra.annotations.State;
 import org.openjdk.jcstress.infra.results.IntResult4;
 import org.openjdk.jcstress.tests.Actor2_Test;
 
 import java.util.concurrent.atomic.AtomicIntegerArray;
 
-public class AtomicIntegerArrayInitialValueTest implements Actor2_Test<AtomicIntegerArrayInitialValueTest.Shell, IntResult4> {
+@ConcurrencyStressTest
+@State
+public class AtomicIntegerArrayInitialValueTest {
 
-    public static class Shell {
-        public AtomicIntegerArray ai;
+    public AtomicIntegerArray ai;
+
+    @Actor
+    public void actor1() {
+        ai = new AtomicIntegerArray(4);
     }
 
-    @Override
-    public void actor1(Shell s, IntResult4 r) {
-        s.ai = new AtomicIntegerArray(4);
-    }
-
-    @Override
-    public void actor2(Shell s, IntResult4 r) {
-        AtomicIntegerArray ai = s.ai;
+    @Actor
+    public void actor2(IntResult4 r) {
+        AtomicIntegerArray ai = this.ai;
         r.r1 = (ai == null) ? -1 : ai.get(0);
         r.r2 = (ai == null) ? -1 : ai.get(1);
         r.r3 = (ai == null) ? -1 : ai.get(2);
         r.r4 = (ai == null) ? -1 : ai.get(3);
     }
 
-    @Override
-    public Shell newState() {
-        return new Shell();
-    }
-
-    @Override
-    public IntResult4 newResult() {
-        return new IntResult4();
-    }
-
 }
--- a/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerArrayPairwiseTests.java	Thu Mar 13 23:43:43 2014 +0400
+++ b/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerArrayPairwiseTests.java	Fri Mar 14 00:35:06 2014 +0400
@@ -24,324 +24,374 @@
  */
 package org.openjdk.jcstress.tests.atomics.integer;
 
+import org.openjdk.jcstress.infra.annotations.Actor;
+import org.openjdk.jcstress.infra.annotations.Arbiter;
+import org.openjdk.jcstress.infra.annotations.ConcurrencyStressTest;
+import org.openjdk.jcstress.infra.annotations.State;
 import org.openjdk.jcstress.infra.results.IntResult1;
 import org.openjdk.jcstress.infra.results.IntResult2;
-import org.openjdk.jcstress.tests.Actor2_Arbiter1_Test;
-import org.openjdk.jcstress.tests.Actor2_Test;
 
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.atomic.AtomicIntegerArray;
 
 public class AtomicIntegerArrayPairwiseTests {
 
-    public static class State {
+    @State
+    public static class S {
         public final int SIZE = 256; // double the maximum cache line
         public final AtomicIntegerArray a = new AtomicIntegerArray(SIZE);
         public final int idx = ThreadLocalRandom.current().nextInt(SIZE);
     }
 
-    public abstract static class AbstractTest implements Actor2_Test<State, IntResult2> {
-        @Override public State newState() { return new State(); }
-        @Override public IntResult2 newResult() { return new IntResult2(); }
+    // ------------------- first is addAndGet
+
+    @ConcurrencyStressTest
+    public static class AddAndGet_AddAndGet {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.addAndGet(s.idx, 5); }
     }
 
-    // ------------------- first is addAndGet
-
-    public static class AddAndGet_AddAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.addAndGet(s.idx, 5); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_DecAndGet {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.decrementAndGet(s.idx); }
     }
 
-    public static class AddAndGet_DecAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.decrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_GetAndAdd {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndAdd(s.idx, 5); }
     }
 
-    public static class AddAndGet_GetAndAdd extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndAdd(s.idx, 5); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_GetAndDec {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndDecrement(s.idx); }
     }
 
-    public static class AddAndGet_GetAndDec extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndDecrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_GetAndInc {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
     }
 
-    public static class AddAndGet_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_GetAndSet {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
     }
 
-    public static class AddAndGet_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_IncAndGet {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
     }
 
-    public static class AddAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_CAS {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class AddAndGet_CAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class AddAndGet_WCAS {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class AddAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
-    }
-
-    public static class AddAndGet_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class AddAndGet_Set {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is decAndGet
 
-    public static class DecAndGet_DecAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.decrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_DecAndGet {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.decrementAndGet(s.idx); }
     }
 
-    public static class DecAndGet_GetAndAdd extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndAdd(s.idx, 5); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_GetAndAdd {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndAdd(s.idx, 5); }
     }
 
-    public static class DecAndGet_GetAndDec extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndDecrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_GetAndDec {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndDecrement(s.idx); }
     }
 
-    public static class DecAndGet_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_GetAndInc {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
     }
 
-    public static class DecAndGet_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_GetAndSet {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
     }
 
-    public static class DecAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_IncAndGet {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
     }
 
-    public static class DecAndGet_CAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class DecAndGet_CAS {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class DecAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class DecAndGet_WCAS {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class DecAndGet_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class DecAndGet_Set {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is getAndAdd
 
-    public static class GetAndAdd_GetAndAdd extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndAdd(s.idx, 5); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_GetAndAdd {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndAdd(s.idx, 5); }
     }
 
-    public static class GetAndAdd_GetAndDec extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndDecrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_GetAndDec {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndDecrement(s.idx); }
     }
 
-    public static class GetAndAdd_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_GetAndInc {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
     }
 
-    public static class GetAndAdd_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_GetAndSet {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
     }
 
-    public static class GetAndAdd_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_IncAndGet {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
     }
 
-    public static class GetAndAdd_CAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_CAS {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndAdd_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_WCAS {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndAdd_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_Set {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is getAndDec
 
-    public static class GetAndDec_GetAndDec extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndDecrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndDec_GetAndDec {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndDecrement(s.idx); }
     }
 
-    public static class GetAndDec_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndDec_GetAndInc {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
     }
 
-    public static class GetAndDec_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
+    @ConcurrencyStressTest
+    public static class GetAndDec_GetAndSet {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
     }
 
-    public static class GetAndDec_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndDec_IncAndGet {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
     }
 
-    public static class GetAndDec_CAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndDec_CAS {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndDec_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndDec_WCAS {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndDec_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class GetAndDec_Set {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is getAndInc
 
-    public static class GetAndInc_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndInc_GetAndInc {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
     }
 
-    public static class GetAndInc_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
+    @ConcurrencyStressTest
+    public static class GetAndInc_GetAndSet {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
     }
 
-    public static class GetAndInc_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndInc_IncAndGet {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
     }
 
-    public static class GetAndInc_CAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndInc_CAS {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndInc_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndInc_WCAS {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndInc_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class GetAndInc_Set {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is getAndSet
 
-    public static class GetAndSet_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
+    @ConcurrencyStressTest
+    public static class GetAndSet_GetAndSet {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
     }
 
-    public static class GetAndSet_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndSet_IncAndGet {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
     }
 
-    public static class GetAndSet_CAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndSet_CAS {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndSet_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndSet_WCAS {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndSet_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
-        @Override public void actor2(State s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class GetAndSet_Set {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is incAndGet
 
-    public static class IncAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.incrementAndGet(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class IncAndGet_IncAndGet {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.incrementAndGet(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
     }
 
-    public static class IncAndGet_CAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.incrementAndGet(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class IncAndGet_CAS {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.incrementAndGet(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class IncAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.incrementAndGet(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class IncAndGet_WCAS {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.incrementAndGet(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class IncAndGet_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.incrementAndGet(s.idx); }
-        @Override public void actor2(State s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class IncAndGet_Set {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.incrementAndGet(s.idx); }
+        @Actor public void actor2(S s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is CAS
 
-    public static class CAS_CAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.compareAndSet(s.idx, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class CAS_CAS {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.compareAndSet(s.idx, 0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class CAS_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.compareAndSet(s.idx, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class CAS_WCAS {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.compareAndSet(s.idx, 0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class CAS_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.compareAndSet(s.idx, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class CAS_Set {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.compareAndSet(s.idx, 0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is WCAS
 
-    public static class WCAS_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.weakCompareAndSet(s.idx, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class WCAS_WCAS {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.weakCompareAndSet(s.idx, 0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, IntResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class WCAS_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.a.weakCompareAndSet(s.idx, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class WCAS_Set {
+        @Actor public void actor1(S s, IntResult2 r) { r.r1 = s.a.weakCompareAndSet(s.idx, 0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, IntResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is set
 
-    public static class Set_Set implements Actor2_Arbiter1_Test<State, IntResult1> {
-        @Override public void actor1(State s, IntResult1 r) { s.a.set(s.idx, 5); }
-        @Override public void actor2(State s, IntResult1 r) { s.a.set(s.idx, 10); }
-        @Override public void arbiter1(State s, IntResult1 r) { r.r1 = s.a.get(s.idx); }
-
-        @Override public State newState() { return new State();  }
-        @Override public IntResult1 newResult() { return new IntResult1(); }
+    @ConcurrencyStressTest
+    public static class Set_Set {
+        @Actor public void actor1(S s, IntResult1 r) { s.a.set(s.idx, 5); }
+        @Actor public void actor2(S s, IntResult1 r) { s.a.set(s.idx, 10); }
+        @Arbiter public void arbiter1(S s, IntResult1 r) { r.r1 = s.a.get(s.idx); }
     }
 
 }
--- a/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerFieldUpdaterPairwiseTests.java	Thu Mar 13 23:43:43 2014 +0400
+++ b/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerFieldUpdaterPairwiseTests.java	Fri Mar 14 00:35:06 2014 +0400
@@ -24,6 +24,10 @@
  */
 package org.openjdk.jcstress.tests.atomics.integer;
 
+import org.openjdk.jcstress.infra.annotations.Actor;
+import org.openjdk.jcstress.infra.annotations.Arbiter;
+import org.openjdk.jcstress.infra.annotations.ConcurrencyStressTest;
+import org.openjdk.jcstress.infra.annotations.State;
 import org.openjdk.jcstress.infra.results.IntResult1;
 import org.openjdk.jcstress.infra.results.IntResult2;
 import org.openjdk.jcstress.tests.Actor2_Arbiter1_Test;
@@ -33,313 +37,361 @@
 
 public class AtomicIntegerFieldUpdaterPairwiseTests {
 
-    public static class State {
+    @State
+    public static class S {
         public volatile int v;
-        public final AtomicIntegerFieldUpdater<State> u = AtomicIntegerFieldUpdater.newUpdater(State.class, "v");
-    }
-
-    public abstract static class AbstractTest implements Actor2_Test<State, IntResult2> {
-        @Override public State newState() { return new State(); }
-        @Override public IntResult2 newResult() { return new IntResult2(); }
+        public final AtomicIntegerFieldUpdater<S> u = AtomicIntegerFieldUpdater.newUpdater(S.class, "v");
     }
 
     // ------------------- first is addAndGet
 
-    public static class AddAndGet_AddAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.addAndGet(s, 5); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class AddAndGet_DecAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.decrementAndGet(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class AddAndGet_GetAndAdd extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndAdd(s, 5); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class AddAndGet_GetAndDec extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndDecrement(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class AddAndGet_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndIncrement(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class AddAndGet_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class AddAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.incrementAndGet(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class AddAndGet_CAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class AddAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class AddAndGet_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is decAndGet
 
-    public static class DecAndGet_DecAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.decrementAndGet(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class DecAndGet_GetAndAdd extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndAdd(s, 5); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class DecAndGet_GetAndDec extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndDecrement(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class DecAndGet_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndIncrement(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class DecAndGet_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class DecAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.incrementAndGet(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class DecAndGet_CAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class DecAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class DecAndGet_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is getAndAdd
 
-    public static class GetAndAdd_GetAndAdd extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndAdd(s, 5); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndAdd_GetAndDec extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndDecrement(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndAdd_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndIncrement(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndAdd_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndAdd_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.incrementAndGet(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndAdd_CAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class GetAndAdd_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class GetAndAdd_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is getAndDec
 
-    public static class GetAndDec_GetAndDec extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndDecrement(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndDecrement(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndDec_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndDecrement(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndIncrement(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndDec_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndDecrement(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndDec_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndDecrement(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.incrementAndGet(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndDec_CAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndDecrement(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class GetAndDec_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndDecrement(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class GetAndDec_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndDecrement(s); }
-        @Override public void actor2(State s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is getAndInc
 
-    public static class GetAndInc_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndIncrement(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndIncrement(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndInc_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndIncrement(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndInc_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndIncrement(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.incrementAndGet(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndInc_CAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndIncrement(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class GetAndInc_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndIncrement(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class GetAndInc_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndIncrement(s); }
-        @Override public void actor2(State s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is getAndSet
 
-    public static class GetAndSet_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndSet_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.incrementAndGet(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndSet_CAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class GetAndSet_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class GetAndSet_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
-        @Override public void actor2(State s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is incAndGet
 
-    public static class IncAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.incrementAndGet(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.incrementAndGet(s); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class IncAndGet_CAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.incrementAndGet(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class IncAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.incrementAndGet(s); }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class IncAndGet_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.incrementAndGet(s); }
-        @Override public void actor2(State s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is CAS
 
-    public static class CAS_CAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.compareAndSet(s, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class CAS_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.compareAndSet(s, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class CAS_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.compareAndSet(s, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is WCAS
 
-    public static class WCAS_WCAS extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.weakCompareAndSet(s, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, IntResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class WCAS_Set extends AbstractTest {
-        @Override public void actor1(State s, IntResult2 r) { r.r1 = s.u.weakCompareAndSet(s, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, IntResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is set
 
-    public static class Set_Set implements Actor2_Arbiter1_Test<State, IntResult1> {
-        @Override public void actor1(State s, IntResult1 r) { s.u.set(s, 5); }
-        @Override public void actor2(State s, IntResult1 r) { s.u.set(s, 10); }
-        @Override public void arbiter1(State s, IntResult1 r) { r.r1 = s.u.get(s); }
-
-        @Override public State newState() { return new State();  }
-        @Override public IntResult1 newResult() { return new IntResult1(); }
+    @ConcurrencyStressTest
+    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); }
+        @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	Thu Mar 13 23:43:43 2014 +0400
+++ b/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerInitialValueTest.java	Fri Mar 14 00:35:06 2014 +0400
@@ -24,36 +24,29 @@
  */
 package org.openjdk.jcstress.tests.atomics.integer;
 
+import org.openjdk.jcstress.infra.annotations.Actor;
+import org.openjdk.jcstress.infra.annotations.ConcurrencyStressTest;
+import org.openjdk.jcstress.infra.annotations.State;
 import org.openjdk.jcstress.infra.results.IntResult1;
 import org.openjdk.jcstress.tests.Actor2_Test;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
-public class AtomicIntegerInitialValueTest implements Actor2_Test<AtomicIntegerInitialValueTest.Shell, IntResult1> {
+@ConcurrencyStressTest
+@State
+public class AtomicIntegerInitialValueTest {
 
-    public static class Shell {
-        public AtomicInteger ai;
+    public AtomicInteger ai;
+
+    @Actor
+    public void actor1() {
+        ai = new AtomicInteger(1);
     }
 
-    @Override
-    public void actor1(Shell s, IntResult1 r) {
-        s.ai = new AtomicInteger(1);
-    }
-
-    @Override
-    public void actor2(Shell s, IntResult1 r) {
-        AtomicInteger ai = s.ai;
+    @Actor
+    public void actor2(IntResult1 r) {
+        AtomicInteger ai = this.ai;
         r.r1 = (ai == null) ? -1 : ai.get();
     }
 
-    @Override
-    public Shell newState() {
-        return new Shell();
-    }
-
-    @Override
-    public IntResult1 newResult() {
-        return new IntResult1();
-    }
-
 }
--- a/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerPairwiseTests.java	Thu Mar 13 23:43:43 2014 +0400
+++ b/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/integer/AtomicIntegerPairwiseTests.java	Fri Mar 14 00:35:06 2014 +0400
@@ -24,6 +24,10 @@
  */
 package org.openjdk.jcstress.tests.atomics.integer;
 
+import org.openjdk.jcstress.infra.annotations.Actor;
+import org.openjdk.jcstress.infra.annotations.Arbiter;
+import org.openjdk.jcstress.infra.annotations.ConcurrencyStressTest;
+import org.openjdk.jcstress.infra.annotations.State;
 import org.openjdk.jcstress.infra.results.IntResult1;
 import org.openjdk.jcstress.infra.results.IntResult2;
 import org.openjdk.jcstress.tests.Actor2_Arbiter1_Test;
@@ -33,308 +37,358 @@
 
 public class AtomicIntegerPairwiseTests {
 
-    public abstract static class AbstractTest implements Actor2_Test<AtomicInteger, IntResult2> {
-        @Override public AtomicInteger newState() { return new AtomicInteger(); }
-        @Override public IntResult2 newResult() { return new IntResult2(); }
+    @State
+    public static class S extends AtomicInteger {
     }
 
     // ------------------- first is addAndGet
 
-    public static class AddAndGet_AddAndGet extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.addAndGet(5); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class AddAndGet_DecAndGet extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.decrementAndGet(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class AddAndGet_GetAndAdd extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndAdd(5); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class AddAndGet_GetAndDec extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndDecrement(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class AddAndGet_GetAndInc extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndIncrement(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class AddAndGet_GetAndSet extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndSet(10); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class AddAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.incrementAndGet(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class AddAndGet_CAS extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class AddAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class AddAndGet_Set extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is decAndGet
 
-    public static class DecAndGet_DecAndGet extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.decrementAndGet(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class DecAndGet_GetAndAdd extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndAdd(5); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class DecAndGet_GetAndDec extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndDecrement(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class DecAndGet_GetAndInc extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndIncrement(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class DecAndGet_GetAndSet extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndSet(10); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class DecAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.incrementAndGet(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class DecAndGet_CAS extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class DecAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class DecAndGet_Set extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is getAndAdd
 
-    public static class GetAndAdd_GetAndAdd extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndAdd(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndAdd(5); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndAdd_GetAndDec extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndAdd(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndDecrement(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class GetAndAdd_GetAndInc extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndAdd(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndIncrement(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class GetAndAdd_GetAndSet extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndAdd(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndSet(10); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndAdd_IncAndGet extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndAdd(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.incrementAndGet(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class GetAndAdd_CAS extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndAdd(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class GetAndAdd_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndAdd(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class GetAndAdd_Set extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndAdd(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is getAndDec
 
-    public static class GetAndDec_GetAndDec extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndDecrement(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndDecrement(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class GetAndDec_GetAndInc extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndDecrement(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndIncrement(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class GetAndDec_GetAndSet extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndDecrement(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndSet(10); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndDec_IncAndGet extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndDecrement(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.incrementAndGet(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class GetAndDec_CAS extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndDecrement(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class GetAndDec_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndDecrement(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class GetAndDec_Set extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndDecrement(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is getAndInc
 
-    public static class GetAndInc_GetAndInc extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndIncrement(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndIncrement(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class GetAndInc_GetAndSet extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndIncrement(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndSet(10); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndInc_IncAndGet extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndIncrement(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.incrementAndGet(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class GetAndInc_CAS extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndIncrement(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class GetAndInc_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndIncrement(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class GetAndInc_Set extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndIncrement(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is getAndSet
 
-    public static class GetAndSet_GetAndSet extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndSet(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.getAndSet(10); }
+    @ConcurrencyStressTest
+    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); }
     }
 
-    public static class GetAndSet_IncAndGet extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndSet(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.incrementAndGet(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class GetAndSet_CAS extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndSet(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class GetAndSet_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndSet(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class GetAndSet_Set extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.getAndSet(5); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is incAndGet
 
-    public static class IncAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.incrementAndGet(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.incrementAndGet(); }
+    @ConcurrencyStressTest
+    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(); }
     }
 
-    public static class IncAndGet_CAS extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.incrementAndGet(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class IncAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.incrementAndGet(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class IncAndGet_Set extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.incrementAndGet(); }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is CAS
 
-    public static class CAS_CAS extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.compareAndSet(0, 5) ? 5 : 1; }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class CAS_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.compareAndSet(0, 5) ? 5 : 1; }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class CAS_Set extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.compareAndSet(0, 5) ? 5 : 1; }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is WCAS
 
-    public static class WCAS_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.weakCompareAndSet(0, 5) ? 5 : 1; }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    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; }
     }
 
-    public static class WCAS_Set extends AbstractTest {
-        @Override public void actor1(AtomicInteger s, IntResult2 r) { r.r1 = s.weakCompareAndSet(0, 5) ? 5 : 1; }
-        @Override public void actor2(AtomicInteger s, IntResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    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; }
     }
 
     // ------------------- first is set
 
-    public static class Set_Set implements Actor2_Arbiter1_Test<AtomicInteger, IntResult1> {
-        @Override public void actor1(AtomicInteger s, IntResult1 r) { s.set(5); }
-        @Override public void actor2(AtomicInteger s, IntResult1 r) { s.set(10); }
-        @Override public void arbiter1(AtomicInteger s, IntResult1 r) { r.r1 = s.get(); }
-
-        @Override public AtomicInteger newState() { return new AtomicInteger();  }
-        @Override public IntResult1 newResult() { return new IntResult1(); }
+    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); }
+        @Arbiter public void arbiter1(S s, IntResult1 r) { r.r1 = s.get(); }
     }
 
 }
--- a/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongArrayInitialValueTest.java	Thu Mar 13 23:43:43 2014 +0400
+++ b/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongArrayInitialValueTest.java	Fri Mar 14 00:35:06 2014 +0400
@@ -24,39 +24,32 @@
  */
 package org.openjdk.jcstress.tests.atomics.longs;
 
+import org.openjdk.jcstress.infra.annotations.Actor;
+import org.openjdk.jcstress.infra.annotations.ConcurrencyStressTest;
+import org.openjdk.jcstress.infra.annotations.State;
 import org.openjdk.jcstress.infra.results.LongResult4;
 import org.openjdk.jcstress.tests.Actor2_Test;
 
 import java.util.concurrent.atomic.AtomicLongArray;
 
-public class AtomicLongArrayInitialValueTest implements Actor2_Test<AtomicLongArrayInitialValueTest.Shell, LongResult4> {
+@ConcurrencyStressTest
+@State
+public class AtomicLongArrayInitialValueTest {
 
-    public static class Shell {
-        public AtomicLongArray ai;
+    public AtomicLongArray ai;
+
+    @Actor
+    public void actor1() {
+        ai = new AtomicLongArray(4);
     }
 
-    @Override
-    public void actor1(Shell s, LongResult4 r) {
-        s.ai = new AtomicLongArray(4);
-    }
-
-    @Override
-    public void actor2(Shell s, LongResult4 r) {
-        AtomicLongArray ai = s.ai;
+    @Actor
+    public void actor2(LongResult4 r) {
+        AtomicLongArray ai = this.ai;
         r.r1 = (ai == null) ? -1 : ai.get(0);
         r.r2 = (ai == null) ? -1 : ai.get(1);
         r.r3 = (ai == null) ? -1 : ai.get(2);
         r.r4 = (ai == null) ? -1 : ai.get(3);
     }
 
-    @Override
-    public Shell newState() {
-        return new Shell();
-    }
-
-    @Override
-    public LongResult4 newResult() {
-        return new LongResult4();
-    }
-
 }
--- a/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongArrayInterleaveTest.java	Thu Mar 13 23:43:43 2014 +0400
+++ b/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongArrayInterleaveTest.java	Fri Mar 14 00:35:06 2014 +0400
@@ -24,40 +24,43 @@
  */
 package org.openjdk.jcstress.tests.atomics.longs;
 
+import org.openjdk.jcstress.infra.annotations.Actor;
+import org.openjdk.jcstress.infra.annotations.Arbiter;
+import org.openjdk.jcstress.infra.annotations.ConcurrencyStressTest;
+import org.openjdk.jcstress.infra.annotations.State;
 import org.openjdk.jcstress.infra.results.IntResult3;
 import org.openjdk.jcstress.tests.Actor2_Arbiter1_Test;
 
 import java.util.concurrent.atomic.AtomicLongArray;
 
-public class AtomicLongArrayInterleaveTest implements Actor2_Arbiter1_Test<AtomicLongArray, IntResult3> {
+@ConcurrencyStressTest
+@State
+public class AtomicLongArrayInterleaveTest {
 
     /** Array size: 256 bytes inevitably crosses the cache line on most implementations */
     public static final int SIZE = 256;
 
-    @Override
-    public AtomicLongArray newState() {
-        return new AtomicLongArray(SIZE);
-    }
+    AtomicLongArray ala = new AtomicLongArray(SIZE);
 
-    @Override
-    public void actor1(AtomicLongArray s, IntResult3 r) {
+    @Actor
+    public void actor1() {
         for (int i = 0; i < SIZE; i += 2) {
-            s.set(i, 1);
+            ala.set(i, 1);
         }
     }
 
-    @Override
-    public void actor2(AtomicLongArray s, IntResult3 r) {
+    @Actor
+    public void actor2() {
         for (int i = 1; i < SIZE; i += 2) {
-            s.set(i, 2);
+            ala.set(i, 2);
         }
     }
 
-    @Override
-    public void arbiter1(AtomicLongArray  state, IntResult3 r) {
+    @Arbiter
+    public void arbiter1(IntResult3 r) {
         r.r1 = r.r2 = r.r3 = 0;
         for (int i = 0; i < SIZE; i++) {
-            long s = state.get(i);
+            long s = ala.get(i);
             switch ((int) s) {
                 case 0:
                     r.r1++;
@@ -74,9 +77,4 @@
         }
     }
 
-    @Override
-    public IntResult3 newResult() {
-        return new IntResult3();
-    }
-
 }
--- a/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongArrayPairwiseTests.java	Thu Mar 13 23:43:43 2014 +0400
+++ b/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongArrayPairwiseTests.java	Fri Mar 14 00:35:06 2014 +0400
@@ -24,324 +24,374 @@
  */
 package org.openjdk.jcstress.tests.atomics.longs;
 
+import org.openjdk.jcstress.infra.annotations.Actor;
+import org.openjdk.jcstress.infra.annotations.Arbiter;
+import org.openjdk.jcstress.infra.annotations.ConcurrencyStressTest;
+import org.openjdk.jcstress.infra.annotations.State;
 import org.openjdk.jcstress.infra.results.LongResult1;
 import org.openjdk.jcstress.infra.results.LongResult2;
-import org.openjdk.jcstress.tests.Actor2_Arbiter1_Test;
-import org.openjdk.jcstress.tests.Actor2_Test;
 
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.atomic.AtomicLongArray;
 
 public class AtomicLongArrayPairwiseTests {
 
-    public static class State {
+    @State
+    public static class S {
         public final int SIZE = 256; // double the maximum cache line
         public final AtomicLongArray a = new AtomicLongArray(SIZE);
         public final int idx = ThreadLocalRandom.current().nextInt(SIZE);
     }
 
-    public abstract static class AbstractTest implements Actor2_Test<State, LongResult2> {
-        @Override public State newState() { return new State(); }
-        @Override public LongResult2 newResult() { return new LongResult2(); }
+    // ------------------- first is addAndGet
+
+    @ConcurrencyStressTest
+    public static class AddAndGet_AddAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.addAndGet(s.idx, 5); }
     }
 
-    // ------------------- first is addAndGet
-
-    public static class AddAndGet_AddAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.addAndGet(s.idx, 5); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_DecAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.decrementAndGet(s.idx); }
     }
 
-    public static class AddAndGet_DecAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.decrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_GetAndAdd {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndAdd(s.idx, 5); }
     }
 
-    public static class AddAndGet_GetAndAdd extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndAdd(s.idx, 5); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_GetAndDec {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndDecrement(s.idx); }
     }
 
-    public static class AddAndGet_GetAndDec extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndDecrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_GetAndInc {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
     }
 
-    public static class AddAndGet_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
     }
 
-    public static class AddAndGet_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
     }
 
-    public static class AddAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class AddAndGet_CAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class AddAndGet_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class AddAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
-    }
-
-    public static class AddAndGet_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class AddAndGet_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.addAndGet(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is decAndGet
 
-    public static class DecAndGet_DecAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.decrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_DecAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.decrementAndGet(s.idx); }
     }
 
-    public static class DecAndGet_GetAndAdd extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndAdd(s.idx, 5); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_GetAndAdd {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndAdd(s.idx, 5); }
     }
 
-    public static class DecAndGet_GetAndDec extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndDecrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_GetAndDec {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndDecrement(s.idx); }
     }
 
-    public static class DecAndGet_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_GetAndInc {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
     }
 
-    public static class DecAndGet_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
     }
 
-    public static class DecAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
     }
 
-    public static class DecAndGet_CAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class DecAndGet_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class DecAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class DecAndGet_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class DecAndGet_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class DecAndGet_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.decrementAndGet(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is getAndAdd
 
-    public static class GetAndAdd_GetAndAdd extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndAdd(s.idx, 5); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_GetAndAdd {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndAdd(s.idx, 5); }
     }
 
-    public static class GetAndAdd_GetAndDec extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndDecrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_GetAndDec {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndDecrement(s.idx); }
     }
 
-    public static class GetAndAdd_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_GetAndInc {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
     }
 
-    public static class GetAndAdd_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
     }
 
-    public static class GetAndAdd_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
     }
 
-    public static class GetAndAdd_CAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndAdd_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndAdd_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndAdd(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is getAndDec
 
-    public static class GetAndDec_GetAndDec extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndDecrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndDec_GetAndDec {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndDecrement(s.idx); }
     }
 
-    public static class GetAndDec_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndDec_GetAndInc {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
     }
 
-    public static class GetAndDec_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
+    @ConcurrencyStressTest
+    public static class GetAndDec_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
     }
 
-    public static class GetAndDec_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndDec_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
     }
 
-    public static class GetAndDec_CAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndDec_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndDec_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndDec_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndDec_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class GetAndDec_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndDecrement(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is getAndInc
 
-    public static class GetAndInc_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndInc_GetAndInc {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndIncrement(s.idx); }
     }
 
-    public static class GetAndInc_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
+    @ConcurrencyStressTest
+    public static class GetAndInc_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
     }
 
-    public static class GetAndInc_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndInc_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
     }
 
-    public static class GetAndInc_CAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndInc_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndInc_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndInc_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndInc_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class GetAndInc_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndIncrement(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is getAndSet
 
-    public static class GetAndSet_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
+    @ConcurrencyStressTest
+    public static class GetAndSet_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.getAndSet(s.idx, 10); }
     }
 
-    public static class GetAndSet_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class GetAndSet_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
     }
 
-    public static class GetAndSet_CAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndSet_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndSet_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndSet_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndSet_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
-        @Override public void actor2(State s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class GetAndSet_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.getAndSet(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is incAndGet
 
-    public static class IncAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.incrementAndGet(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
+    @ConcurrencyStressTest
+    public static class IncAndGet_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.incrementAndGet(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.incrementAndGet(s.idx); }
     }
 
-    public static class IncAndGet_CAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.incrementAndGet(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class IncAndGet_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.incrementAndGet(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class IncAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.incrementAndGet(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class IncAndGet_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.incrementAndGet(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class IncAndGet_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.incrementAndGet(s.idx); }
-        @Override public void actor2(State s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class IncAndGet_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.incrementAndGet(s.idx); }
+        @Actor public void actor2(S s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is CAS
 
-    public static class CAS_CAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.compareAndSet(s.idx, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class CAS_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.compareAndSet(s.idx, 0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.compareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class CAS_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.compareAndSet(s.idx, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class CAS_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.compareAndSet(s.idx, 0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class CAS_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.compareAndSet(s.idx, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class CAS_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.compareAndSet(s.idx, 0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is WCAS
 
-    public static class WCAS_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.weakCompareAndSet(s.idx, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class WCAS_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.weakCompareAndSet(s.idx, 0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.a.weakCompareAndSet(s.idx, 0, 20) ? 20 : 10; }
     }
 
-    public static class WCAS_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.a.weakCompareAndSet(s.idx, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class WCAS_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.a.weakCompareAndSet(s.idx, 0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, LongResult2 r) { s.a.set(s.idx, 10); r.r2 = 0; }
     }
 
     // ------------------- first is set
 
-    public static class Set_Set implements Actor2_Arbiter1_Test<State, LongResult1> {
-        @Override public void actor1(State s, LongResult1 r) { s.a.set(s.idx, 5); }
-        @Override public void actor2(State s, LongResult1 r) { s.a.set(s.idx, 10); }
-        @Override public void arbiter1(State s, LongResult1 r) { r.r1 = s.a.get(s.idx); }
-
-        @Override public State newState() { return new State();  }
-        @Override public LongResult1 newResult() { return new LongResult1(); }
+    @ConcurrencyStressTest
+    public static class Set_Set {
+        @Actor public void actor1(S s, LongResult1 r) { s.a.set(s.idx, 5); }
+        @Actor public void actor2(S s, LongResult1 r) { s.a.set(s.idx, 10); }
+        @Arbiter public void arbiter1(S s, LongResult1 r) { r.r1 = s.a.get(s.idx); }
     }
 
 }
--- a/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongFieldUpdaterPairwiseTests.java	Thu Mar 13 23:43:43 2014 +0400
+++ b/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongFieldUpdaterPairwiseTests.java	Fri Mar 14 00:35:06 2014 +0400
@@ -24,6 +24,10 @@
  */
 package org.openjdk.jcstress.tests.atomics.longs;
 
+import org.openjdk.jcstress.infra.annotations.Actor;
+import org.openjdk.jcstress.infra.annotations.Arbiter;
+import org.openjdk.jcstress.infra.annotations.ConcurrencyStressTest;
+import org.openjdk.jcstress.infra.annotations.State;
 import org.openjdk.jcstress.infra.results.LongResult1;
 import org.openjdk.jcstress.infra.results.LongResult2;
 import org.openjdk.jcstress.tests.Actor2_Arbiter1_Test;
@@ -33,313 +37,361 @@
 
 public class AtomicLongFieldUpdaterPairwiseTests {
 
-    public static class State {
+    @State
+    public static class S {
         public volatile long v;
-        public final AtomicLongFieldUpdater<State> u = AtomicLongFieldUpdater.newUpdater(State.class, "v");
-    }
-
-    public abstract static class AbstractTest implements Actor2_Test<State, LongResult2> {
-        @Override public State newState() { return new State(); }
-        @Override public LongResult2 newResult() { return new LongResult2(); }
+        public final AtomicLongFieldUpdater<S> u = AtomicLongFieldUpdater.newUpdater(S.class, "v");
     }
 
     // ------------------- first is addAndGet
 
-    public static class AddAndGet_AddAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.addAndGet(s, 5); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_AddAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.addAndGet(s, 5); }
     }
 
-    public static class AddAndGet_DecAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.decrementAndGet(s); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_DecAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.decrementAndGet(s); }
     }
 
-    public static class AddAndGet_GetAndAdd extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndAdd(s, 5); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_GetAndAdd {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndAdd(s, 5); }
     }
 
-    public static class AddAndGet_GetAndDec extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndDecrement(s); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_GetAndDec {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndDecrement(s); }
     }
 
-    public static class AddAndGet_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndIncrement(s); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_GetAndInc {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndIncrement(s); }
     }
 
-    public static class AddAndGet_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
     }
 
-    public static class AddAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.incrementAndGet(s); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.incrementAndGet(s); }
     }
 
-    public static class AddAndGet_CAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class AddAndGet_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
-    public static class AddAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class AddAndGet_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
-    public static class AddAndGet_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class AddAndGet_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.addAndGet(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
     }
 
     // ------------------- first is decAndGet
 
-    public static class DecAndGet_DecAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.decrementAndGet(s); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_DecAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.decrementAndGet(s); }
     }
 
-    public static class DecAndGet_GetAndAdd extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndAdd(s, 5); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_GetAndAdd {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndAdd(s, 5); }
     }
 
-    public static class DecAndGet_GetAndDec extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndDecrement(s); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_GetAndDec {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndDecrement(s); }
     }
 
-    public static class DecAndGet_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndIncrement(s); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_GetAndInc {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndIncrement(s); }
     }
 
-    public static class DecAndGet_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
     }
 
-    public static class DecAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.incrementAndGet(s); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.incrementAndGet(s); }
     }
 
-    public static class DecAndGet_CAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class DecAndGet_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
-    public static class DecAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class DecAndGet_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
-    public static class DecAndGet_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
-        @Override public void actor2(State s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class DecAndGet_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.decrementAndGet(s); }
+        @Actor public void actor2(S s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
     }
 
     // ------------------- first is getAndAdd
 
-    public static class GetAndAdd_GetAndAdd extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndAdd(s, 5); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_GetAndAdd {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndAdd(s, 5); }
     }
 
-    public static class GetAndAdd_GetAndDec extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndDecrement(s); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_GetAndDec {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndDecrement(s); }
     }
 
-    public static class GetAndAdd_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndIncrement(s); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_GetAndInc {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndIncrement(s); }
     }
 
-    public static class GetAndAdd_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
     }
 
-    public static class GetAndAdd_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.incrementAndGet(s); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.incrementAndGet(s); }
     }
 
-    public static class GetAndAdd_CAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndAdd_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndAdd_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndAdd(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
     }
 
     // ------------------- first is getAndDec
 
-    public static class GetAndDec_GetAndDec extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndDecrement(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndDecrement(s); }
+    @ConcurrencyStressTest
+    public static class GetAndDec_GetAndDec {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndDecrement(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndDecrement(s); }
     }
 
-    public static class GetAndDec_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndDecrement(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndIncrement(s); }
+    @ConcurrencyStressTest
+    public static class GetAndDec_GetAndInc {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndDecrement(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndIncrement(s); }
     }
 
-    public static class GetAndDec_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndDecrement(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
+    @ConcurrencyStressTest
+    public static class GetAndDec_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndDecrement(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
     }
 
-    public static class GetAndDec_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndDecrement(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.incrementAndGet(s); }
+    @ConcurrencyStressTest
+    public static class GetAndDec_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndDecrement(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.incrementAndGet(s); }
     }
 
-    public static class GetAndDec_CAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndDecrement(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndDec_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndDecrement(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndDec_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndDecrement(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndDec_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndDecrement(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndDec_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndDecrement(s); }
-        @Override public void actor2(State s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class GetAndDec_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndDecrement(s); }
+        @Actor public void actor2(S s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
     }
 
     // ------------------- first is getAndInc
 
-    public static class GetAndInc_GetAndInc extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndIncrement(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndIncrement(s); }
+    @ConcurrencyStressTest
+    public static class GetAndInc_GetAndInc {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndIncrement(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndIncrement(s); }
     }
 
-    public static class GetAndInc_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndIncrement(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
+    @ConcurrencyStressTest
+    public static class GetAndInc_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndIncrement(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
     }
 
-    public static class GetAndInc_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndIncrement(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.incrementAndGet(s); }
+    @ConcurrencyStressTest
+    public static class GetAndInc_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndIncrement(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.incrementAndGet(s); }
     }
 
-    public static class GetAndInc_CAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndIncrement(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndInc_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndIncrement(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndInc_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndIncrement(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndInc_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndIncrement(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndInc_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndIncrement(s); }
-        @Override public void actor2(State s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class GetAndInc_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndIncrement(s); }
+        @Actor public void actor2(S s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
     }
 
     // ------------------- first is getAndSet
 
-    public static class GetAndSet_GetAndSet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
+    @ConcurrencyStressTest
+    public static class GetAndSet_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.getAndSet(s, 10); }
     }
 
-    public static class GetAndSet_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.incrementAndGet(s); }
+    @ConcurrencyStressTest
+    public static class GetAndSet_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.incrementAndGet(s); }
     }
 
-    public static class GetAndSet_CAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndSet_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndSet_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndSet_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndSet_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
-        @Override public void actor2(State s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class GetAndSet_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.getAndSet(s, 5); }
+        @Actor public void actor2(S s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
     }
 
     // ------------------- first is incAndGet
 
-    public static class IncAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.incrementAndGet(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.incrementAndGet(s); }
+    @ConcurrencyStressTest
+    public static class IncAndGet_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.incrementAndGet(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.incrementAndGet(s); }
     }
 
-    public static class IncAndGet_CAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.incrementAndGet(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class IncAndGet_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.incrementAndGet(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
-    public static class IncAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.incrementAndGet(s); }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class IncAndGet_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.incrementAndGet(s); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
-    public static class IncAndGet_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.incrementAndGet(s); }
-        @Override public void actor2(State s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class IncAndGet_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.incrementAndGet(s); }
+        @Actor public void actor2(S s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
     }
 
     // ------------------- first is CAS
 
-    public static class CAS_CAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.compareAndSet(s, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class CAS_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.compareAndSet(s, 0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.compareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
-    public static class CAS_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.compareAndSet(s, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class CAS_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.compareAndSet(s, 0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
-    public static class CAS_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.compareAndSet(s, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class CAS_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.compareAndSet(s, 0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
     }
 
     // ------------------- first is WCAS
 
-    public static class WCAS_WCAS extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.weakCompareAndSet(s, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class WCAS_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.weakCompareAndSet(s, 0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.u.weakCompareAndSet(s, 0, 20) ? 20 : 10; }
     }
 
-    public static class WCAS_Set extends AbstractTest {
-        @Override public void actor1(State s, LongResult2 r) { r.r1 = s.u.weakCompareAndSet(s, 0, 5) ? 5 : 1; }
-        @Override public void actor2(State s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class WCAS_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.u.weakCompareAndSet(s, 0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, LongResult2 r) { s.u.set(s, 10); r.r2 = 0; }
     }
 
     // ------------------- first is set
 
-    public static class Set_Set implements Actor2_Arbiter1_Test<State, LongResult1> {
-        @Override public void actor1(State s, LongResult1 r) { s.u.set(s, 5); }
-        @Override public void actor2(State s, LongResult1 r) { s.u.set(s, 10); }
-        @Override public void arbiter1(State s, LongResult1 r) { r.r1 = s.u.get(s); }
-
-        @Override public State newState() { return new State();  }
-        @Override public LongResult1 newResult() { return new LongResult1(); }
+    @ConcurrencyStressTest
+    public static class Set_Set  {
+        @Actor   public void actor1(S s, LongResult1 r) { s.u.set(s, 5); }
+        @Actor   public void actor2(S s, LongResult1 r) { s.u.set(s, 10); }
+        @Arbiter public void arbiter1(S s, LongResult1 r) { r.r1 = s.u.get(s); }
     }
 
 }
--- a/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongInitialValueTest.java	Thu Mar 13 23:43:43 2014 +0400
+++ b/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongInitialValueTest.java	Fri Mar 14 00:35:06 2014 +0400
@@ -24,36 +24,29 @@
  */
 package org.openjdk.jcstress.tests.atomics.longs;
 
+import org.openjdk.jcstress.infra.annotations.Actor;
+import org.openjdk.jcstress.infra.annotations.ConcurrencyStressTest;
+import org.openjdk.jcstress.infra.annotations.State;
 import org.openjdk.jcstress.infra.results.LongResult1;
 import org.openjdk.jcstress.tests.Actor2_Test;
 
 import java.util.concurrent.atomic.AtomicLong;
 
-public class AtomicLongInitialValueTest implements Actor2_Test<AtomicLongInitialValueTest.Shell, LongResult1> {
+@ConcurrencyStressTest
+@State
+public class AtomicLongInitialValueTest {
 
-    public static class Shell {
-        public AtomicLong ai;
+    public AtomicLong ai;
+
+    @Actor
+    public void actor1(LongResult1 r) {
+        ai = new AtomicLong(1);
     }
 
-    @Override
-    public void actor1(Shell s, LongResult1 r) {
-        s.ai = new AtomicLong(1);
-    }
-
-    @Override
-    public void actor2(Shell s, LongResult1 r) {
-        AtomicLong ai = s.ai;
+    @Actor
+    public void actor2(LongResult1 r) {
+        AtomicLong ai = this.ai;
         r.r1 = (ai == null) ? -1 : ai.get();
     }
 
-    @Override
-    public Shell newState() {
-        return new Shell();
-    }
-
-    @Override
-    public LongResult1 newResult() {
-        return new LongResult1();
-    }
-
 }
--- a/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongPairwiseTests.java	Thu Mar 13 23:43:43 2014 +0400
+++ b/tests-custom/src/main/java/org/openjdk/jcstress/tests/atomics/longs/AtomicLongPairwiseTests.java	Fri Mar 14 00:35:06 2014 +0400
@@ -24,317 +24,372 @@
  */
 package org.openjdk.jcstress.tests.atomics.longs;
 
+import org.openjdk.jcstress.infra.annotations.Actor;
+import org.openjdk.jcstress.infra.annotations.Arbiter;
+import org.openjdk.jcstress.infra.annotations.ConcurrencyStressTest;
+import org.openjdk.jcstress.infra.annotations.State;
 import org.openjdk.jcstress.infra.results.LongResult1;
 import org.openjdk.jcstress.infra.results.LongResult2;
 import org.openjdk.jcstress.tests.Actor2_Arbiter1_Test;
-import org.openjdk.jcstress.tests.Actor2_Test;
 
 import java.util.concurrent.atomic.AtomicLong;
 
 public class AtomicLongPairwiseTests {
 
-    public abstract static class AbstractTest implements Actor2_Test<AtomicLong, LongResult2> {
-        @Override public AtomicLong newState() { return new AtomicLong(); }
-        @Override public LongResult2 newResult() { return new LongResult2(); }
+    @State
+    public static class S extends AtomicLong {
+
     }
 
     // ------------------- first is addAndGet
 
-    public static class AddAndGet_AddAndGet extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.addAndGet(5); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_AddAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.addAndGet(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.addAndGet(5); }
     }
 
-    public static class AddAndGet_DecAndGet extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.decrementAndGet(); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_DecAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.addAndGet(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.decrementAndGet(); }
     }
 
-    public static class AddAndGet_GetAndAdd extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndAdd(5); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_GetAndAdd {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.addAndGet(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndAdd(5); }
     }
 
-    public static class AddAndGet_GetAndDec extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndDecrement(); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_GetAndDec {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.addAndGet(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndDecrement(); }
     }
 
-    public static class AddAndGet_GetAndInc extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndIncrement(); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_GetAndInc {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.addAndGet(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndIncrement(); }
     }
 
-    public static class AddAndGet_GetAndSet extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndSet(10); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.addAndGet(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndSet(10); }
     }
 
-    public static class AddAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.incrementAndGet(); }
+    @ConcurrencyStressTest
+    public static class AddAndGet_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.addAndGet(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.incrementAndGet(); }
     }
 
-    public static class AddAndGet_CAS extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class AddAndGet_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.addAndGet(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
     }
 
-    public static class AddAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class AddAndGet_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.addAndGet(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
-    public static class AddAndGet_Set extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.addAndGet(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class AddAndGet_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.addAndGet(5); }
+        @Actor public void actor2(S s, LongResult2 r) { s.set(10); r.r2 = 0; }
     }
 
     // ------------------- first is decAndGet
 
-    public static class DecAndGet_DecAndGet extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.decrementAndGet(); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_DecAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.decrementAndGet(); }
     }
 
-    public static class DecAndGet_GetAndAdd extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndAdd(5); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_GetAndAdd {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndAdd(5); }
     }
 
-    public static class DecAndGet_GetAndDec extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndDecrement(); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_GetAndDec {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndDecrement(); }
     }
 
-    public static class DecAndGet_GetAndInc extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndIncrement(); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_GetAndInc {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndIncrement(); }
     }
 
-    public static class DecAndGet_GetAndSet extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndSet(10); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndSet(10); }
     }
 
-    public static class DecAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.incrementAndGet(); }
+    @ConcurrencyStressTest
+    public static class DecAndGet_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.incrementAndGet(); }
     }
 
-    public static class DecAndGet_CAS extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class DecAndGet_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
     }
 
-    public static class DecAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class DecAndGet_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
-    public static class DecAndGet_Set extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class DecAndGet_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.decrementAndGet(); }
+        @Actor public void actor2(S s, LongResult2 r) { s.set(10); r.r2 = 0; }
     }
 
     // ------------------- first is getAndAdd
 
-    public static class GetAndAdd_GetAndAdd extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndAdd(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndAdd(5); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_GetAndAdd {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndAdd(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndAdd(5); }
     }
 
-    public static class GetAndAdd_GetAndDec extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndAdd(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndDecrement(); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_GetAndDec {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndAdd(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndDecrement(); }
     }
 
-    public static class GetAndAdd_GetAndInc extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndAdd(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndIncrement(); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_GetAndInc {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndAdd(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndIncrement(); }
     }
 
-    public static class GetAndAdd_GetAndSet extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndAdd(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndSet(10); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndAdd(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndSet(10); }
     }
 
-    public static class GetAndAdd_IncAndGet extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndAdd(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.incrementAndGet(); }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndAdd(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.incrementAndGet(); }
     }
 
-    public static class GetAndAdd_CAS extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndAdd(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndAdd(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndAdd_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndAdd(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndAdd(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndAdd_Set extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndAdd(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class GetAndAdd_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndAdd(5); }
+        @Actor public void actor2(S s, LongResult2 r) { s.set(10); r.r2 = 0; }
     }
 
     // ------------------- first is getAndDec
 
-    public static class GetAndDec_GetAndDec extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndDecrement(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndDecrement(); }
+    @ConcurrencyStressTest
+    public static class GetAndDec_GetAndDec {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndDecrement(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndDecrement(); }
     }
 
-    public static class GetAndDec_GetAndInc extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndDecrement(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndIncrement(); }
+    @ConcurrencyStressTest
+    public static class GetAndDec_GetAndInc {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndDecrement(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndIncrement(); }
     }
 
-    public static class GetAndDec_GetAndSet extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndDecrement(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndSet(10); }
+    @ConcurrencyStressTest
+    public static class GetAndDec_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndDecrement(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndSet(10); }
     }
 
-    public static class GetAndDec_IncAndGet extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndDecrement(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.incrementAndGet(); }
+    @ConcurrencyStressTest
+    public static class GetAndDec_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndDecrement(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.incrementAndGet(); }
     }
 
-    public static class GetAndDec_CAS extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndDecrement(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndDec_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndDecrement(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndDec_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndDecrement(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndDec_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndDecrement(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndDec_Set extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndDecrement(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class GetAndDec_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndDecrement(); }
+        @Actor public void actor2(S s, LongResult2 r) { s.set(10); r.r2 = 0; }
     }
 
     // ------------------- first is getAndInc
 
-    public static class GetAndInc_GetAndInc extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndIncrement(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndIncrement(); }
+    @ConcurrencyStressTest
+    public static class GetAndInc_GetAndInc {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndIncrement(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndIncrement(); }
     }
 
-    public static class GetAndInc_GetAndSet extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndIncrement(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndSet(10); }
+    @ConcurrencyStressTest
+    public static class GetAndInc_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndIncrement(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndSet(10); }
     }
 
-    public static class GetAndInc_IncAndGet extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndIncrement(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.incrementAndGet(); }
+    @ConcurrencyStressTest
+    public static class GetAndInc_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndIncrement(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.incrementAndGet(); }
     }
 
-    public static class GetAndInc_CAS extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndIncrement(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndInc_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndIncrement(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndInc_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndIncrement(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndInc_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndIncrement(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndInc_Set extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndIncrement(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class GetAndInc_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndIncrement(); }
+        @Actor public void actor2(S s, LongResult2 r) { s.set(10); r.r2 = 0; }
     }
 
     // ------------------- first is getAndSet
 
-    public static class GetAndSet_GetAndSet extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndSet(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.getAndSet(10); }
+    @ConcurrencyStressTest
+    public static class GetAndSet_GetAndSet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndSet(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.getAndSet(10); }
     }
 
-    public static class GetAndSet_IncAndGet extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndSet(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.incrementAndGet(); }
+    @ConcurrencyStressTest
+    public static class GetAndSet_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndSet(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.incrementAndGet(); }
     }
 
-    public static class GetAndSet_CAS extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndSet(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndSet_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndSet(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndSet_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndSet(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class GetAndSet_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndSet(5); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
-    public static class GetAndSet_Set extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.getAndSet(5); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class GetAndSet_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.getAndSet(5); }
+        @Actor public void actor2(S s, LongResult2 r) { s.set(10); r.r2 = 0; }
     }
 
     // ------------------- first is incAndGet
 
-    public static class IncAndGet_IncAndGet extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.incrementAndGet(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.incrementAndGet(); }
+    @ConcurrencyStressTest
+    public static class IncAndGet_IncAndGet {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.incrementAndGet(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.incrementAndGet(); }
     }
 
-    public static class IncAndGet_CAS extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.incrementAndGet(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class IncAndGet_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.incrementAndGet(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
     }
 
-    public static class IncAndGet_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.incrementAndGet(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class IncAndGet_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.incrementAndGet(); }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
-    public static class IncAndGet_Set extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.incrementAndGet(); }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class IncAndGet_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.incrementAndGet(); }
+        @Actor public void actor2(S s, LongResult2 r) { s.set(10); r.r2 = 0; }
     }
 
     // ------------------- first is CAS
 
-    public static class CAS_CAS extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.compareAndSet(0, 5) ? 5 : 1; }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class CAS_CAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.compareAndSet(0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.compareAndSet(0, 20) ? 20 : 10; }
     }
 
-    public static class CAS_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.compareAndSet(0, 5) ? 5 : 1; }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class CAS_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.compareAndSet(0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
-    public static class CAS_Set extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.compareAndSet(0, 5) ? 5 : 1; }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class CAS_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.compareAndSet(0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, LongResult2 r) { s.set(10); r.r2 = 0; }
     }
 
     // ------------------- first is WCAS
 
-    public static class WCAS_WCAS extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.weakCompareAndSet(0, 5) ? 5 : 1; }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
+    @ConcurrencyStressTest
+    public static class WCAS_WCAS {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.weakCompareAndSet(0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, LongResult2 r) { r.r2 = s.weakCompareAndSet(0, 20) ? 20 : 10; }
     }
 
-    public static class WCAS_Set extends AbstractTest {
-        @Override public void actor1(AtomicLong s, LongResult2 r) { r.r1 = s.weakCompareAndSet(0, 5) ? 5 : 1; }
-        @Override public void actor2(AtomicLong s, LongResult2 r) { s.set(10); r.r2 = 0; }
+    @ConcurrencyStressTest
+    public static class WCAS_Set {
+        @Actor public void actor1(S s, LongResult2 r) { r.r1 = s.weakCompareAndSet(0, 5) ? 5 : 1; }
+        @Actor public void actor2(S s, LongResult2 r) { s.set(10); r.r2 = 0; }
     }
 
     // ------------------- first is set
 
-    public static class Set_Set implements Actor2_Arbiter1_Test<AtomicLong, LongResult1> {
-        @Override public void actor1(AtomicLong s, LongResult1 r) { s.set(5); }
-        @Override public void actor2(AtomicLong s, LongResult1 r) { s.set(10); }
-        @Override public void arbiter1(AtomicLong s, LongResult1 r) { r.r1 = s.get(); }
-
-        @Override public AtomicLong newState() { return new AtomicLong();  }
-        @Override public LongResult1 newResult() { return new LongResult1(); }
+    @ConcurrencyStressTest
+    public static class Set_Set {
+        @Actor   public void actor1(S s, LongResult1 r) { s.set(5); }
+        @Actor   public void actor2(S s, LongResult1 r) { s.set(10); }
+        @Arbiter public void arbiter1(S s, LongResult1 r) { r.r1 = s.get(); }
     }
 
 }