test/tck/Atomic8Test.java

/*
 * Written by Doug Lea and Martin Buchholz with assistance from
 * members of JCP JSR-166 Expert Group and released to the public
 * domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicLongArray;
import java.util.concurrent.atomic.AtomicLongFieldUpdater;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicReferenceArray;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;

import junit.framework.Test;
import junit.framework.TestSuite;

/**
 * Tests of atomic class methods accepting lambdas introduced in JDK8.
 */
public class Atomic8Test extends JSR166TestCase {

    public static void main(String[] args) {
        main(suite(), args);
    }
    public static Test suite() {
        return new TestSuite(Atomic8Test.class);
    }

    static long addLong17(long x) { return x + 17; }
    static int addInt17(int x) { return x + 17; }
    static Item addItem17(Item x) {
        return new Item(x.intValue() + 17);
    }
    static Item sumItem(Item x, Item y) {
        return new Item(x.intValue() + y.intValue());
    }

    volatile long aLongField;
    volatile int anIntField;
    volatile Item anItemField;

    AtomicLongFieldUpdater<Atomic8Test> aLongFieldUpdater() {
        return AtomicLongFieldUpdater.newUpdater
            (Atomic8Test.class, "aLongField");
    }

    AtomicIntegerFieldUpdater<Atomic8Test> anIntFieldUpdater() {
        return AtomicIntegerFieldUpdater.newUpdater
            (Atomic8Test.class, "anIntField");
    }

    AtomicReferenceFieldUpdater<Atomic8Test,Item> anItemFieldUpdater() {
        return AtomicReferenceFieldUpdater.newUpdater
            (Atomic8Test.class, Item.class, "anItemField");
    }

    /**
     * AtomicLong getAndUpdate returns previous value and updates
     * result of supplied function
     */
    public void testLongGetAndUpdate() {
        AtomicLong a = new AtomicLong(1L);
        mustEqual(1L, a.getAndUpdate(Atomic8Test::addLong17));
        mustEqual(18L, a.getAndUpdate(Atomic8Test::addLong17));
        mustEqual(35L, a.get());
    }

    /**
     * AtomicLong updateAndGet updates with supplied function and
     * returns result.
     */
    public void testLongUpdateAndGet() {
        AtomicLong a = new AtomicLong(1L);
        mustEqual(18L, a.updateAndGet(Atomic8Test::addLong17));
        mustEqual(35L, a.updateAndGet(Atomic8Test::addLong17));
    }

    /**
     * AtomicLong getAndAccumulate returns previous value and updates
     * with supplied function.
     */
    public void testLongGetAndAccumulate() {
        AtomicLong a = new AtomicLong(1L);
        mustEqual(1L, a.getAndAccumulate(2L, Long::sum));
        mustEqual(3L, a.getAndAccumulate(3L, Long::sum));
        mustEqual(6L, a.get());
    }

    /**
     * AtomicLong accumulateAndGet updates with supplied function and
     * returns result.
     */
    public void testLongAccumulateAndGet() {
        AtomicLong a = new AtomicLong(1L);
        mustEqual(7L, a.accumulateAndGet(6L, Long::sum));
        mustEqual(10L, a.accumulateAndGet(3L, Long::sum));
        mustEqual(10L, a.get());
    }

    /**
     * AtomicInteger getAndUpdate returns previous value and updates
     * result of supplied function
     */
    public void testIntGetAndUpdate() {
        AtomicInteger a = new AtomicInteger(1);
        mustEqual(1, a.getAndUpdate(Atomic8Test::addInt17));
        mustEqual(18, a.getAndUpdate(Atomic8Test::addInt17));
        mustEqual(35, a.get());
    }

    /**
     * AtomicInteger updateAndGet updates with supplied function and
     * returns result.
     */
    public void testIntUpdateAndGet() {
        AtomicInteger a = new AtomicInteger(1);
        mustEqual(18, a.updateAndGet(Atomic8Test::addInt17));
        mustEqual(35, a.updateAndGet(Atomic8Test::addInt17));
        mustEqual(35, a.get());
    }

    /**
     * AtomicInteger getAndAccumulate returns previous value and updates
     * with supplied function.
     */
    public void testIntGetAndAccumulate() {
        AtomicInteger a = new AtomicInteger(1);
        mustEqual(1, a.getAndAccumulate(2, Integer::sum));
        mustEqual(3, a.getAndAccumulate(3, Integer::sum));
        mustEqual(6, a.get());
    }

    /**
     * AtomicInteger accumulateAndGet updates with supplied function and
     * returns result.
     */
    public void testIntAccumulateAndGet() {
        AtomicInteger a = new AtomicInteger(1);
        mustEqual(7, a.accumulateAndGet(6, Integer::sum));
        mustEqual(10, a.accumulateAndGet(3, Integer::sum));
        mustEqual(10, a.get());
    }

    /**
     * AtomicReference getAndUpdate returns previous value and updates
     * result of supplied function
     */
    public void testReferenceGetAndUpdate() {
        AtomicReference<Item> a = new AtomicReference<>(one);
        mustEqual(1, a.getAndUpdate(Atomic8Test::addItem17));
        mustEqual(18, a.getAndUpdate(Atomic8Test::addItem17));
        mustEqual(35, a.get());
    }

    /**
     * AtomicReference updateAndGet updates with supplied function and
     * returns result.
     */
    public void testReferenceUpdateAndGet() {
        AtomicReference<Item> a = new AtomicReference<>(one);
        mustEqual(18, a.updateAndGet(Atomic8Test::addItem17));
        mustEqual(35, a.updateAndGet(Atomic8Test::addItem17));
        mustEqual(35, a.get());
    }

    /**
     * AtomicReference getAndAccumulate returns previous value and updates
     * with supplied function.
     */
    public void testReferenceGetAndAccumulate() {
        AtomicReference<Item> a = new AtomicReference<>(one);
        mustEqual( 1, a.getAndAccumulate(two, Atomic8Test::sumItem));
        mustEqual( 3, a.getAndAccumulate(three, Atomic8Test::sumItem));
        mustEqual( 6, a.get());
    }

    /**
     * AtomicReference accumulateAndGet updates with supplied function and
     * returns result.
     */
    public void testReferenceAccumulateAndGet() {
        AtomicReference<Item> a = new AtomicReference<>(one);
        mustEqual( 7, a.accumulateAndGet(six, Atomic8Test::sumItem));
        mustEqual( 10, a.accumulateAndGet(three, Atomic8Test::sumItem));
        mustEqual( 10, a.get());
    }

    /**
     * AtomicLongArray getAndUpdate returns previous value and updates
     * result of supplied function
     */
    public void testLongArrayGetAndUpdate() {
        AtomicLongArray a = new AtomicLongArray(1);
        a.set(0, 1);
        mustEqual(1L, a.getAndUpdate(0, Atomic8Test::addLong17));
        mustEqual(18L, a.getAndUpdate(0, Atomic8Test::addLong17));
        mustEqual(35L, a.get(0));
    }

    /**
     * AtomicLongArray updateAndGet updates with supplied function and
     * returns result.
     */
    public void testLongArrayUpdateAndGet() {
        AtomicLongArray a = new AtomicLongArray(1);
        a.set(0, 1);
        mustEqual(18L, a.updateAndGet(0, Atomic8Test::addLong17));
        mustEqual(35L, a.updateAndGet(0, Atomic8Test::addLong17));
        mustEqual(35L, a.get(0));
    }

    /**
     * AtomicLongArray getAndAccumulate returns previous value and updates
     * with supplied function.
     */
    public void testLongArrayGetAndAccumulate() {
        AtomicLongArray a = new AtomicLongArray(1);
        a.set(0, 1);
        mustEqual(1L, a.getAndAccumulate(0, 2L, Long::sum));
        mustEqual(3L, a.getAndAccumulate(0, 3L, Long::sum));
        mustEqual(6L, a.get(0));
    }

    /**
     * AtomicLongArray accumulateAndGet updates with supplied function and
     * returns result.
     */
    public void testLongArrayAccumulateAndGet() {
        AtomicLongArray a = new AtomicLongArray(1);
        a.set(0, 1);
        mustEqual(7L, a.accumulateAndGet(0, 6L, Long::sum));
        mustEqual(10L, a.accumulateAndGet(0, 3L, Long::sum));
        mustEqual(10L, a.get(0));
    }

    /**
     * AtomicIntegerArray getAndUpdate returns previous value and updates
     * result of supplied function
     */
    public void testIntArrayGetAndUpdate() {
        AtomicIntegerArray a = new AtomicIntegerArray(1);
        a.set(0, 1);
        mustEqual(1, a.getAndUpdate(0, Atomic8Test::addInt17));
        mustEqual(18, a.getAndUpdate(0, Atomic8Test::addInt17));
        mustEqual(35, a.get(0));
    }

    /**
     * AtomicIntegerArray updateAndGet updates with supplied function and
     * returns result.
     */
    public void testIntArrayUpdateAndGet() {
        AtomicIntegerArray a = new AtomicIntegerArray(1);
        a.set(0, 1);
        mustEqual(18, a.updateAndGet(0, Atomic8Test::addInt17));
        mustEqual(35, a.updateAndGet(0, Atomic8Test::addInt17));
        mustEqual(35, a.get(0));
    }

    /**
     * AtomicIntegerArray getAndAccumulate returns previous value and updates
     * with supplied function.
     */
    public void testIntArrayGetAndAccumulate() {
        AtomicIntegerArray a = new AtomicIntegerArray(1);
        a.set(0, 1);
        mustEqual(1, a.getAndAccumulate(0, 2, Integer::sum));
        mustEqual(3, a.getAndAccumulate(0, 3, Integer::sum));
        mustEqual(6, a.get(0));
    }

    /**
     * AtomicIntegerArray accumulateAndGet updates with supplied function and
     * returns result.
     */
    public void testIntArrayAccumulateAndGet() {
        AtomicIntegerArray a = new AtomicIntegerArray(1);
        a.set(0, 1);
        mustEqual(7, a.accumulateAndGet(0, 6, Integer::sum));
        mustEqual(10, a.accumulateAndGet(0, 3, Integer::sum));
    }

    /**
     * AtomicReferenceArray getAndUpdate returns previous value and updates
     * result of supplied function
     */
    public void testReferenceArrayGetAndUpdate() {
        AtomicReferenceArray<Item> a = new AtomicReferenceArray<>(1);
        a.set(0, one);
        mustEqual( 1, a.getAndUpdate(0, Atomic8Test::addItem17));
        mustEqual( 18, a.getAndUpdate(0, Atomic8Test::addItem17));
        mustEqual( 35, a.get(0));
    }

    /**
     * AtomicReferenceArray updateAndGet updates with supplied function and
     * returns result.
     */
    public void testReferenceArrayUpdateAndGet() {
        AtomicReferenceArray<Item> a = new AtomicReferenceArray<>(1);
        a.set(0, one);
        mustEqual( 18, a.updateAndGet(0, Atomic8Test::addItem17));
        mustEqual( 35, a.updateAndGet(0, Atomic8Test::addItem17));
    }

    /**
     * AtomicReferenceArray getAndAccumulate returns previous value and updates
     * with supplied function.
     */
    public void testReferenceArrayGetAndAccumulate() {
        AtomicReferenceArray<Item> a = new AtomicReferenceArray<>(1);
        a.set(0, one);
        mustEqual( 1, a.getAndAccumulate(0, two, Atomic8Test::sumItem));
        mustEqual( 3, a.getAndAccumulate(0, three, Atomic8Test::sumItem));
        mustEqual( 6, a.get(0));
    }

    /**
     * AtomicReferenceArray accumulateAndGet updates with supplied function and
     * returns result.
     */
    public void testReferenceArrayAccumulateAndGet() {
        AtomicReferenceArray<Item> a = new AtomicReferenceArray<>(1);
        a.set(0, one);
        mustEqual( 7, a.accumulateAndGet(0, six, Atomic8Test::sumItem));
        mustEqual( 10, a.accumulateAndGet(0, three, Atomic8Test::sumItem));
    }

    /**
     * AtomicLongFieldUpdater getAndUpdate returns previous value and updates
     * result of supplied function
     */
    public void testLongFieldUpdaterGetAndUpdate() {
        AtomicLongFieldUpdater<Atomic8Test> a = aLongFieldUpdater();
        a.set(this, 1L);
        mustEqual(1L, a.getAndUpdate(this, Atomic8Test::addLong17));
        mustEqual(18L, a.getAndUpdate(this, Atomic8Test::addLong17));
        mustEqual(35L, a.get(this));
        mustEqual(35L, aLongField);
    }

    /**
     * AtomicLongFieldUpdater updateAndGet updates with supplied function and
     * returns result.
     */
    public void testLongFieldUpdaterUpdateAndGet() {
        AtomicLongFieldUpdater<Atomic8Test> a = aLongFieldUpdater();
        a.set(this, 1L);
        mustEqual(18L, a.updateAndGet(this, Atomic8Test::addLong17));
        mustEqual(35L, a.updateAndGet(this, Atomic8Test::addLong17));
        mustEqual(35L, a.get(this));
        mustEqual(35L, aLongField);
    }

    /**
     * AtomicLongFieldUpdater getAndAccumulate returns previous value
     * and updates with supplied function.
     */
    public void testLongFieldUpdaterGetAndAccumulate() {
        AtomicLongFieldUpdater<Atomic8Test> a = aLongFieldUpdater();
        a.set(this, 1L);
        mustEqual(1L, a.getAndAccumulate(this, 2L, Long::sum));
        mustEqual(3L, a.getAndAccumulate(this, 3L, Long::sum));
        mustEqual(6L, a.get(this));
        mustEqual(6L, aLongField);
    }

    /**
     * AtomicLongFieldUpdater accumulateAndGet updates with supplied
     * function and returns result.
     */
    public void testLongFieldUpdaterAccumulateAndGet() {
        AtomicLongFieldUpdater<Atomic8Test> a = aLongFieldUpdater();
        a.set(this, 1L);
        mustEqual(7L, a.accumulateAndGet(this, 6L, Long::sum));
        mustEqual(10L, a.accumulateAndGet(this, 3L, Long::sum));
        mustEqual(10L, a.get(this));
        mustEqual(10L, aLongField);
    }

    /**
     * AtomicIntegerFieldUpdater getAndUpdate returns previous value and updates
     * result of supplied function
     */
    public void testIntegerFieldUpdaterGetAndUpdate() {
        AtomicIntegerFieldUpdater<Atomic8Test> a = anIntFieldUpdater();
        a.set(this, 1);
        mustEqual(1, a.getAndUpdate(this, Atomic8Test::addInt17));
        mustEqual(18, a.getAndUpdate(this, Atomic8Test::addInt17));
        mustEqual(35, a.get(this));
        mustEqual(35, anIntField);
    }

    /**
     * AtomicIntegerFieldUpdater updateAndGet updates with supplied function and
     * returns result.
     */
    public void testIntegerFieldUpdaterUpdateAndGet() {
        AtomicIntegerFieldUpdater<Atomic8Test> a = anIntFieldUpdater();
        a.set(this, 1);
        mustEqual(18, a.updateAndGet(this, Atomic8Test::addInt17));
        mustEqual(35, a.updateAndGet(this, Atomic8Test::addInt17));
        mustEqual(35, a.get(this));
        mustEqual(35, anIntField);
    }

    /**
     * AtomicIntegerFieldUpdater getAndAccumulate returns previous value
     * and updates with supplied function.
     */
    public void testIntegerFieldUpdaterGetAndAccumulate() {
        AtomicIntegerFieldUpdater<Atomic8Test> a = anIntFieldUpdater();
        a.set(this, 1);
        mustEqual(1, a.getAndAccumulate(this, 2, Integer::sum));
        mustEqual(3, a.getAndAccumulate(this, 3, Integer::sum));
        mustEqual(6, a.get(this));
        mustEqual(6, anIntField);
    }

    /**
     * AtomicIntegerFieldUpdater accumulateAndGet updates with supplied
     * function and returns result.
     */
    public void testIntegerFieldUpdaterAccumulateAndGet() {
        AtomicIntegerFieldUpdater<Atomic8Test> a = anIntFieldUpdater();
        a.set(this, 1);
        mustEqual(7, a.accumulateAndGet(this, 6, Integer::sum));
        mustEqual(10, a.accumulateAndGet(this, 3, Integer::sum));
        mustEqual(10, a.get(this));
        mustEqual(10, anIntField);
    }

    /**
     * AtomicReferenceFieldUpdater getAndUpdate returns previous value
     * and updates result of supplied function
     */
    public void testReferenceFieldUpdaterGetAndUpdate() {
        AtomicReferenceFieldUpdater<Atomic8Test,Item> a = anItemFieldUpdater();
        a.set(this, one);
        mustEqual( 1, a.getAndUpdate(this, Atomic8Test::addItem17));
        mustEqual( 18, a.getAndUpdate(this, Atomic8Test::addItem17));
        mustEqual( 35, a.get(this));
        mustEqual( 35, anItemField);
    }

    /**
     * AtomicReferenceFieldUpdater updateAndGet updates with supplied
     * function and returns result.
     */
    public void testReferenceFieldUpdaterUpdateAndGet() {
        AtomicReferenceFieldUpdater<Atomic8Test,Item> a = anItemFieldUpdater();
        a.set(this, one);
        mustEqual( 18, a.updateAndGet(this, Atomic8Test::addItem17));
        mustEqual( 35, a.updateAndGet(this, Atomic8Test::addItem17));
        mustEqual( 35, a.get(this));
        mustEqual( 35, anItemField);
    }

    /**
     * AtomicReferenceFieldUpdater returns previous value and updates
     * with supplied function.
     */
    public void testReferenceFieldUpdaterGetAndAccumulate() {
        AtomicReferenceFieldUpdater<Atomic8Test,Item> a = anItemFieldUpdater();
        a.set(this, one);
        mustEqual( 1, a.getAndAccumulate(this, two, Atomic8Test::sumItem));
        mustEqual( 3, a.getAndAccumulate(this, three, Atomic8Test::sumItem));
        mustEqual( 6, a.get(this));
        mustEqual( 6, anItemField);
    }

    /**
     * AtomicReferenceFieldUpdater accumulateAndGet updates with
     * supplied function and returns result.
     */
    public void testReferenceFieldUpdaterAccumulateAndGet() {
        AtomicReferenceFieldUpdater<Atomic8Test,Item> a = anItemFieldUpdater();
        a.set(this, one);
        mustEqual( 7, a.accumulateAndGet(this, six, Atomic8Test::sumItem));
        mustEqual( 10, a.accumulateAndGet(this, three, Atomic8Test::sumItem));
        mustEqual( 10, a.get(this));
        mustEqual( 10, anItemField);
    }

    /**
     * All Atomic getAndUpdate methods throw NullPointerException on
     * null function argument
     */
    @SuppressWarnings("unchecked")
    public void testGetAndUpdateNPE() {
        assertThrows(
            NullPointerException.class,
            () -> new AtomicLong().getAndUpdate(null),
            () -> new AtomicInteger().getAndUpdate(null),
            () -> new AtomicReference().getAndUpdate(null),
            () -> new AtomicLongArray(1).getAndUpdate(0, null),
            () -> new AtomicIntegerArray(1).getAndUpdate(0, null),
            () -> new AtomicReferenceArray(1).getAndUpdate(0, null),
            () -> aLongFieldUpdater().getAndUpdate(this, null),
            () -> anIntFieldUpdater().getAndUpdate(this, null),
            () -> anItemFieldUpdater().getAndUpdate(this, null));
    }

    /**
     * All Atomic updateAndGet methods throw NullPointerException on null function argument
     */
    @SuppressWarnings("unchecked")
    public void testUpdateAndGetNPE() {
        assertThrows(
            NullPointerException.class,
            () -> new AtomicLong().updateAndGet(null),
            () -> new AtomicInteger().updateAndGet(null),
            () -> new AtomicReference().updateAndGet(null),
            () -> new AtomicLongArray(1).updateAndGet(0, null),
            () -> new AtomicIntegerArray(1).updateAndGet(0, null),
            () -> new AtomicReferenceArray(1).updateAndGet(0, null),
            () -> aLongFieldUpdater().updateAndGet(this, null),
            () -> anIntFieldUpdater().updateAndGet(this, null),
            () -> anItemFieldUpdater().updateAndGet(this, null));
    }

    /**
     * All Atomic getAndAccumulate methods throw NullPointerException
     * on null function argument
     */
    @SuppressWarnings("unchecked")
    public void testGetAndAccumulateNPE() {
        assertThrows(
            NullPointerException.class,
            () -> new AtomicLong().getAndAccumulate(1L, null),
            () -> new AtomicInteger().getAndAccumulate(1, null),
            () -> new AtomicReference().getAndAccumulate(one, null),
            () -> new AtomicLongArray(1).getAndAccumulate(0, 1L, null),
            () -> new AtomicIntegerArray(1).getAndAccumulate(0, 1, null),
            () -> new AtomicReferenceArray(1).getAndAccumulate(0, one, null),
            () -> aLongFieldUpdater().getAndAccumulate(this, 1L, null),
            () -> anIntFieldUpdater().getAndAccumulate(this, 1, null),
            () -> anItemFieldUpdater().getAndAccumulate(this, one, null));
    }

    /**
     * All Atomic accumulateAndGet methods throw NullPointerException
     * on null function argument
     */
    @SuppressWarnings("unchecked")
    public void testAccumulateAndGetNPE() {
        assertThrows(
            NullPointerException.class,
            () -> new AtomicLong().accumulateAndGet(1L, null),
            () -> new AtomicInteger().accumulateAndGet(1, null),
            () -> new AtomicReference().accumulateAndGet(one, null),
            () -> new AtomicLongArray(1).accumulateAndGet(0, 1L, null),
            () -> new AtomicIntegerArray(1).accumulateAndGet(0, 1, null),
            () -> new AtomicReferenceArray(1).accumulateAndGet(0, one, null),
            () -> aLongFieldUpdater().accumulateAndGet(this, 1L, null),
            () -> anIntFieldUpdater().accumulateAndGet(this, 1, null),
            () -> anItemFieldUpdater().accumulateAndGet(this, one, null));
    }

    /**
     * Object arguments for parameters of type T that are not
     * instances of the class passed to the newUpdater call will
     * result in a ClassCastException being thrown.
     */
    @SuppressWarnings("unchecked")
    public void testFieldUpdaters_ClassCastException() {
        // Use raw types to allow passing wrong object type, provoking CCE
        final AtomicLongFieldUpdater longUpdater = aLongFieldUpdater();
        final AtomicIntegerFieldUpdater intUpdater = anIntFieldUpdater();
        final AtomicReferenceFieldUpdater refUpdater = anItemFieldUpdater();
        for (Object x : new Object[]{ new Object(), null }) {
            assertThrows(
                ClassCastException.class,
                () -> longUpdater.get(x),
                () -> intUpdater.get(x),
                () -> refUpdater.get(x),

                () -> longUpdater.set(x, 17L),
                () -> intUpdater.set(x, 17),
                () -> refUpdater.set(x,  new Item(17)),

                () -> longUpdater.addAndGet(x, 17L),
                () -> intUpdater.addAndGet(x, 17),

                () -> longUpdater.getAndUpdate(x, y -> y),
                () -> intUpdater.getAndUpdate(x, y -> y),
                () -> refUpdater.getAndUpdate(x, y -> y),

                () -> longUpdater.compareAndSet(x, 17L, 42L),
                () -> intUpdater.compareAndSet(x, 17, 42),
                () -> refUpdater.compareAndSet(x,  17,  fortytwo));
        }
    }

}
Revision:	1.11
Committed:	Tue Jan 26 13:33:05 2021 UTC (3 years, 2 months ago) by dl
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.10:	+159 -154 lines
Log Message:	Replace Integer with Item class
#	Content
1	/*
2	* Written by Doug Lea and Martin Buchholz with assistance from
3	* members of JCP JSR-166 Expert Group and released to the public
4	* domain, as explained at
5	* http://creativecommons.org/publicdomain/zero/1.0/
6	*/
7
8	import java.util.concurrent.atomic.AtomicInteger;
9	import java.util.concurrent.atomic.AtomicIntegerArray;
10	import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
11	import java.util.concurrent.atomic.AtomicLong;
12	import java.util.concurrent.atomic.AtomicLongArray;
13	import java.util.concurrent.atomic.AtomicLongFieldUpdater;
14	import java.util.concurrent.atomic.AtomicReference;
15	import java.util.concurrent.atomic.AtomicReferenceArray;
16	import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
17
18	import junit.framework.Test;
19	import junit.framework.TestSuite;
20
21	/**
22	* Tests of atomic class methods accepting lambdas introduced in JDK8.
23	*/
24	public class Atomic8Test extends JSR166TestCase {
25
26	public static void main(String[] args) {
27	main(suite(), args);
28	}
29	public static Test suite() {
30	return new TestSuite(Atomic8Test.class);
31	}
32
33	static long addLong17(long x) { return x + 17; }
34	static int addInt17(int x) { return x + 17; }
35	static Item addItem17(Item x) {
36	return new Item(x.intValue() + 17);
37	}
38	static Item sumItem(Item x, Item y) {
39	return new Item(x.intValue() + y.intValue());
40	}
41
42	volatile long aLongField;
43	volatile int anIntField;
44	volatile Item anItemField;
45
46	AtomicLongFieldUpdater<Atomic8Test> aLongFieldUpdater() {
47	return AtomicLongFieldUpdater.newUpdater
48	(Atomic8Test.class, "aLongField");
49	}
50
51	AtomicIntegerFieldUpdater<Atomic8Test> anIntFieldUpdater() {
52	return AtomicIntegerFieldUpdater.newUpdater
53	(Atomic8Test.class, "anIntField");
54	}
55
56	AtomicReferenceFieldUpdater<Atomic8Test,Item> anItemFieldUpdater() {
57	return AtomicReferenceFieldUpdater.newUpdater
58	(Atomic8Test.class, Item.class, "anItemField");
59	}
60
61	/**
62	* AtomicLong getAndUpdate returns previous value and updates
63	* result of supplied function
64	*/
65	public void testLongGetAndUpdate() {
66	AtomicLong a = new AtomicLong(1L);
67	mustEqual(1L, a.getAndUpdate(Atomic8Test::addLong17));
68	mustEqual(18L, a.getAndUpdate(Atomic8Test::addLong17));
69	mustEqual(35L, a.get());
70	}
71
72	/**
73	* AtomicLong updateAndGet updates with supplied function and
74	* returns result.
75	*/
76	public void testLongUpdateAndGet() {
77	AtomicLong a = new AtomicLong(1L);
78	mustEqual(18L, a.updateAndGet(Atomic8Test::addLong17));
79	mustEqual(35L, a.updateAndGet(Atomic8Test::addLong17));
80	}
81
82	/**
83	* AtomicLong getAndAccumulate returns previous value and updates
84	* with supplied function.
85	*/
86	public void testLongGetAndAccumulate() {
87	AtomicLong a = new AtomicLong(1L);
88	mustEqual(1L, a.getAndAccumulate(2L, Long::sum));
89	mustEqual(3L, a.getAndAccumulate(3L, Long::sum));
90	mustEqual(6L, a.get());
91	}
92
93	/**
94	* AtomicLong accumulateAndGet updates with supplied function and
95	* returns result.
96	*/
97	public void testLongAccumulateAndGet() {
98	AtomicLong a = new AtomicLong(1L);
99	mustEqual(7L, a.accumulateAndGet(6L, Long::sum));
100	mustEqual(10L, a.accumulateAndGet(3L, Long::sum));
101	mustEqual(10L, a.get());
102	}
103
104	/**
105	* AtomicInteger getAndUpdate returns previous value and updates
106	* result of supplied function
107	*/
108	public void testIntGetAndUpdate() {
109	AtomicInteger a = new AtomicInteger(1);
110	mustEqual(1, a.getAndUpdate(Atomic8Test::addInt17));
111	mustEqual(18, a.getAndUpdate(Atomic8Test::addInt17));
112	mustEqual(35, a.get());
113	}
114
115	/**
116	* AtomicInteger updateAndGet updates with supplied function and
117	* returns result.
118	*/
119	public void testIntUpdateAndGet() {
120	AtomicInteger a = new AtomicInteger(1);
121	mustEqual(18, a.updateAndGet(Atomic8Test::addInt17));
122	mustEqual(35, a.updateAndGet(Atomic8Test::addInt17));
123	mustEqual(35, a.get());
124	}
125
126	/**
127	* AtomicInteger getAndAccumulate returns previous value and updates
128	* with supplied function.
129	*/
130	public void testIntGetAndAccumulate() {
131	AtomicInteger a = new AtomicInteger(1);
132	mustEqual(1, a.getAndAccumulate(2, Integer::sum));
133	mustEqual(3, a.getAndAccumulate(3, Integer::sum));
134	mustEqual(6, a.get());
135	}
136
137	/**
138	* AtomicInteger accumulateAndGet updates with supplied function and
139	* returns result.
140	*/
141	public void testIntAccumulateAndGet() {
142	AtomicInteger a = new AtomicInteger(1);
143	mustEqual(7, a.accumulateAndGet(6, Integer::sum));
144	mustEqual(10, a.accumulateAndGet(3, Integer::sum));
145	mustEqual(10, a.get());
146	}
147
148	/**
149	* AtomicReference getAndUpdate returns previous value and updates
150	* result of supplied function
151	*/
152	public void testReferenceGetAndUpdate() {
153	AtomicReference<Item> a = new AtomicReference<>(one);
154	mustEqual(1, a.getAndUpdate(Atomic8Test::addItem17));
155	mustEqual(18, a.getAndUpdate(Atomic8Test::addItem17));
156	mustEqual(35, a.get());
157	}
158
159	/**
160	* AtomicReference updateAndGet updates with supplied function and
161	* returns result.
162	*/
163	public void testReferenceUpdateAndGet() {
164	AtomicReference<Item> a = new AtomicReference<>(one);
165	mustEqual(18, a.updateAndGet(Atomic8Test::addItem17));
166	mustEqual(35, a.updateAndGet(Atomic8Test::addItem17));
167	mustEqual(35, a.get());
168	}
169
170	/**
171	* AtomicReference getAndAccumulate returns previous value and updates
172	* with supplied function.
173	*/
174	public void testReferenceGetAndAccumulate() {
175	AtomicReference<Item> a = new AtomicReference<>(one);
176	mustEqual( 1, a.getAndAccumulate(two, Atomic8Test::sumItem));
177	mustEqual( 3, a.getAndAccumulate(three, Atomic8Test::sumItem));
178	mustEqual( 6, a.get());
179	}
180
181	/**
182	* AtomicReference accumulateAndGet updates with supplied function and
183	* returns result.
184	*/
185	public void testReferenceAccumulateAndGet() {
186	AtomicReference<Item> a = new AtomicReference<>(one);
187	mustEqual( 7, a.accumulateAndGet(six, Atomic8Test::sumItem));
188	mustEqual( 10, a.accumulateAndGet(three, Atomic8Test::sumItem));
189	mustEqual( 10, a.get());
190	}
191
192	/**
193	* AtomicLongArray getAndUpdate returns previous value and updates
194	* result of supplied function
195	*/
196	public void testLongArrayGetAndUpdate() {
197	AtomicLongArray a = new AtomicLongArray(1);
198	a.set(0, 1);
199	mustEqual(1L, a.getAndUpdate(0, Atomic8Test::addLong17));
200	mustEqual(18L, a.getAndUpdate(0, Atomic8Test::addLong17));
201	mustEqual(35L, a.get(0));
202	}
203
204	/**
205	* AtomicLongArray updateAndGet updates with supplied function and
206	* returns result.
207	*/
208	public void testLongArrayUpdateAndGet() {
209	AtomicLongArray a = new AtomicLongArray(1);
210	a.set(0, 1);
211	mustEqual(18L, a.updateAndGet(0, Atomic8Test::addLong17));
212	mustEqual(35L, a.updateAndGet(0, Atomic8Test::addLong17));
213	mustEqual(35L, a.get(0));
214	}
215
216	/**
217	* AtomicLongArray getAndAccumulate returns previous value and updates
218	* with supplied function.
219	*/
220	public void testLongArrayGetAndAccumulate() {
221	AtomicLongArray a = new AtomicLongArray(1);
222	a.set(0, 1);
223	mustEqual(1L, a.getAndAccumulate(0, 2L, Long::sum));
224	mustEqual(3L, a.getAndAccumulate(0, 3L, Long::sum));
225	mustEqual(6L, a.get(0));
226	}
227
228	/**
229	* AtomicLongArray accumulateAndGet updates with supplied function and
230	* returns result.
231	*/
232	public void testLongArrayAccumulateAndGet() {
233	AtomicLongArray a = new AtomicLongArray(1);
234	a.set(0, 1);
235	mustEqual(7L, a.accumulateAndGet(0, 6L, Long::sum));
236	mustEqual(10L, a.accumulateAndGet(0, 3L, Long::sum));
237	mustEqual(10L, a.get(0));
238	}
239
240	/**
241	* AtomicIntegerArray getAndUpdate returns previous value and updates
242	* result of supplied function
243	*/
244	public void testIntArrayGetAndUpdate() {
245	AtomicIntegerArray a = new AtomicIntegerArray(1);
246	a.set(0, 1);
247	mustEqual(1, a.getAndUpdate(0, Atomic8Test::addInt17));
248	mustEqual(18, a.getAndUpdate(0, Atomic8Test::addInt17));
249	mustEqual(35, a.get(0));
250	}
251
252	/**
253	* AtomicIntegerArray updateAndGet updates with supplied function and
254	* returns result.
255	*/
256	public void testIntArrayUpdateAndGet() {
257	AtomicIntegerArray a = new AtomicIntegerArray(1);
258	a.set(0, 1);
259	mustEqual(18, a.updateAndGet(0, Atomic8Test::addInt17));
260	mustEqual(35, a.updateAndGet(0, Atomic8Test::addInt17));
261	mustEqual(35, a.get(0));
262	}
263
264	/**
265	* AtomicIntegerArray getAndAccumulate returns previous value and updates
266	* with supplied function.
267	*/
268	public void testIntArrayGetAndAccumulate() {
269	AtomicIntegerArray a = new AtomicIntegerArray(1);
270	a.set(0, 1);
271	mustEqual(1, a.getAndAccumulate(0, 2, Integer::sum));
272	mustEqual(3, a.getAndAccumulate(0, 3, Integer::sum));
273	mustEqual(6, a.get(0));
274	}
275
276	/**
277	* AtomicIntegerArray accumulateAndGet updates with supplied function and
278	* returns result.
279	*/
280	public void testIntArrayAccumulateAndGet() {
281	AtomicIntegerArray a = new AtomicIntegerArray(1);
282	a.set(0, 1);
283	mustEqual(7, a.accumulateAndGet(0, 6, Integer::sum));
284	mustEqual(10, a.accumulateAndGet(0, 3, Integer::sum));
285	}
286
287	/**
288	* AtomicReferenceArray getAndUpdate returns previous value and updates
289	* result of supplied function
290	*/
291	public void testReferenceArrayGetAndUpdate() {
292	AtomicReferenceArray<Item> a = new AtomicReferenceArray<>(1);
293	a.set(0, one);
294	mustEqual( 1, a.getAndUpdate(0, Atomic8Test::addItem17));
295	mustEqual( 18, a.getAndUpdate(0, Atomic8Test::addItem17));
296	mustEqual( 35, a.get(0));
297	}
298
299	/**
300	* AtomicReferenceArray updateAndGet updates with supplied function and
301	* returns result.
302	*/
303	public void testReferenceArrayUpdateAndGet() {
304	AtomicReferenceArray<Item> a = new AtomicReferenceArray<>(1);
305	a.set(0, one);
306	mustEqual( 18, a.updateAndGet(0, Atomic8Test::addItem17));
307	mustEqual( 35, a.updateAndGet(0, Atomic8Test::addItem17));
308	}
309
310	/**
311	* AtomicReferenceArray getAndAccumulate returns previous value and updates
312	* with supplied function.
313	*/
314	public void testReferenceArrayGetAndAccumulate() {
315	AtomicReferenceArray<Item> a = new AtomicReferenceArray<>(1);
316	a.set(0, one);
317	mustEqual( 1, a.getAndAccumulate(0, two, Atomic8Test::sumItem));
318	mustEqual( 3, a.getAndAccumulate(0, three, Atomic8Test::sumItem));
319	mustEqual( 6, a.get(0));
320	}
321
322	/**
323	* AtomicReferenceArray accumulateAndGet updates with supplied function and
324	* returns result.
325	*/
326	public void testReferenceArrayAccumulateAndGet() {
327	AtomicReferenceArray<Item> a = new AtomicReferenceArray<>(1);
328	a.set(0, one);
329	mustEqual( 7, a.accumulateAndGet(0, six, Atomic8Test::sumItem));
330	mustEqual( 10, a.accumulateAndGet(0, three, Atomic8Test::sumItem));
331	}
332
333	/**
334	* AtomicLongFieldUpdater getAndUpdate returns previous value and updates
335	* result of supplied function
336	*/
337	public void testLongFieldUpdaterGetAndUpdate() {
338	AtomicLongFieldUpdater<Atomic8Test> a = aLongFieldUpdater();
339	a.set(this, 1L);
340	mustEqual(1L, a.getAndUpdate(this, Atomic8Test::addLong17));
341	mustEqual(18L, a.getAndUpdate(this, Atomic8Test::addLong17));
342	mustEqual(35L, a.get(this));
343	mustEqual(35L, aLongField);
344	}
345
346	/**
347	* AtomicLongFieldUpdater updateAndGet updates with supplied function and
348	* returns result.
349	*/
350	public void testLongFieldUpdaterUpdateAndGet() {
351	AtomicLongFieldUpdater<Atomic8Test> a = aLongFieldUpdater();
352	a.set(this, 1L);
353	mustEqual(18L, a.updateAndGet(this, Atomic8Test::addLong17));
354	mustEqual(35L, a.updateAndGet(this, Atomic8Test::addLong17));
355	mustEqual(35L, a.get(this));
356	mustEqual(35L, aLongField);
357	}
358
359	/**
360	* AtomicLongFieldUpdater getAndAccumulate returns previous value
361	* and updates with supplied function.
362	*/
363	public void testLongFieldUpdaterGetAndAccumulate() {
364	AtomicLongFieldUpdater<Atomic8Test> a = aLongFieldUpdater();
365	a.set(this, 1L);
366	mustEqual(1L, a.getAndAccumulate(this, 2L, Long::sum));
367	mustEqual(3L, a.getAndAccumulate(this, 3L, Long::sum));
368	mustEqual(6L, a.get(this));
369	mustEqual(6L, aLongField);
370	}
371
372	/**
373	* AtomicLongFieldUpdater accumulateAndGet updates with supplied
374	* function and returns result.
375	*/
376	public void testLongFieldUpdaterAccumulateAndGet() {
377	AtomicLongFieldUpdater<Atomic8Test> a = aLongFieldUpdater();
378	a.set(this, 1L);
379	mustEqual(7L, a.accumulateAndGet(this, 6L, Long::sum));
380	mustEqual(10L, a.accumulateAndGet(this, 3L, Long::sum));
381	mustEqual(10L, a.get(this));
382	mustEqual(10L, aLongField);
383	}
384
385	/**
386	* AtomicIntegerFieldUpdater getAndUpdate returns previous value and updates
387	* result of supplied function
388	*/
389	public void testIntegerFieldUpdaterGetAndUpdate() {
390	AtomicIntegerFieldUpdater<Atomic8Test> a = anIntFieldUpdater();
391	a.set(this, 1);
392	mustEqual(1, a.getAndUpdate(this, Atomic8Test::addInt17));
393	mustEqual(18, a.getAndUpdate(this, Atomic8Test::addInt17));
394	mustEqual(35, a.get(this));
395	mustEqual(35, anIntField);
396	}
397
398	/**
399	* AtomicIntegerFieldUpdater updateAndGet updates with supplied function and
400	* returns result.
401	*/
402	public void testIntegerFieldUpdaterUpdateAndGet() {
403	AtomicIntegerFieldUpdater<Atomic8Test> a = anIntFieldUpdater();
404	a.set(this, 1);
405	mustEqual(18, a.updateAndGet(this, Atomic8Test::addInt17));
406	mustEqual(35, a.updateAndGet(this, Atomic8Test::addInt17));
407	mustEqual(35, a.get(this));
408	mustEqual(35, anIntField);
409	}
410
411	/**
412	* AtomicIntegerFieldUpdater getAndAccumulate returns previous value
413	* and updates with supplied function.
414	*/
415	public void testIntegerFieldUpdaterGetAndAccumulate() {
416	AtomicIntegerFieldUpdater<Atomic8Test> a = anIntFieldUpdater();
417	a.set(this, 1);
418	mustEqual(1, a.getAndAccumulate(this, 2, Integer::sum));
419	mustEqual(3, a.getAndAccumulate(this, 3, Integer::sum));
420	mustEqual(6, a.get(this));
421	mustEqual(6, anIntField);
422	}
423
424	/**
425	* AtomicIntegerFieldUpdater accumulateAndGet updates with supplied
426	* function and returns result.
427	*/
428	public void testIntegerFieldUpdaterAccumulateAndGet() {
429	AtomicIntegerFieldUpdater<Atomic8Test> a = anIntFieldUpdater();
430	a.set(this, 1);
431	mustEqual(7, a.accumulateAndGet(this, 6, Integer::sum));
432	mustEqual(10, a.accumulateAndGet(this, 3, Integer::sum));
433	mustEqual(10, a.get(this));
434	mustEqual(10, anIntField);
435	}
436
437	/**
438	* AtomicReferenceFieldUpdater getAndUpdate returns previous value
439	* and updates result of supplied function
440	*/
441	public void testReferenceFieldUpdaterGetAndUpdate() {
442	AtomicReferenceFieldUpdater<Atomic8Test,Item> a = anItemFieldUpdater();
443	a.set(this, one);
444	mustEqual( 1, a.getAndUpdate(this, Atomic8Test::addItem17));
445	mustEqual( 18, a.getAndUpdate(this, Atomic8Test::addItem17));
446	mustEqual( 35, a.get(this));
447	mustEqual( 35, anItemField);
448	}
449
450	/**
451	* AtomicReferenceFieldUpdater updateAndGet updates with supplied
452	* function and returns result.
453	*/
454	public void testReferenceFieldUpdaterUpdateAndGet() {
455	AtomicReferenceFieldUpdater<Atomic8Test,Item> a = anItemFieldUpdater();
456	a.set(this, one);
457	mustEqual( 18, a.updateAndGet(this, Atomic8Test::addItem17));
458	mustEqual( 35, a.updateAndGet(this, Atomic8Test::addItem17));
459	mustEqual( 35, a.get(this));
460	mustEqual( 35, anItemField);
461	}
462
463	/**
464	* AtomicReferenceFieldUpdater returns previous value and updates
465	* with supplied function.
466	*/
467	public void testReferenceFieldUpdaterGetAndAccumulate() {
468	AtomicReferenceFieldUpdater<Atomic8Test,Item> a = anItemFieldUpdater();
469	a.set(this, one);
470	mustEqual( 1, a.getAndAccumulate(this, two, Atomic8Test::sumItem));
471	mustEqual( 3, a.getAndAccumulate(this, three, Atomic8Test::sumItem));
472	mustEqual( 6, a.get(this));
473	mustEqual( 6, anItemField);
474	}
475
476	/**
477	* AtomicReferenceFieldUpdater accumulateAndGet updates with
478	* supplied function and returns result.
479	*/
480	public void testReferenceFieldUpdaterAccumulateAndGet() {
481	AtomicReferenceFieldUpdater<Atomic8Test,Item> a = anItemFieldUpdater();
482	a.set(this, one);
483	mustEqual( 7, a.accumulateAndGet(this, six, Atomic8Test::sumItem));
484	mustEqual( 10, a.accumulateAndGet(this, three, Atomic8Test::sumItem));
485	mustEqual( 10, a.get(this));
486	mustEqual( 10, anItemField);
487	}
488
489	/**
490	* All Atomic getAndUpdate methods throw NullPointerException on
491	* null function argument
492	*/
493	@SuppressWarnings("unchecked")
494	public void testGetAndUpdateNPE() {
495	assertThrows(
496	NullPointerException.class,
497	() -> new AtomicLong().getAndUpdate(null),
498	() -> new AtomicInteger().getAndUpdate(null),
499	() -> new AtomicReference().getAndUpdate(null),
500	() -> new AtomicLongArray(1).getAndUpdate(0, null),
501	() -> new AtomicIntegerArray(1).getAndUpdate(0, null),
502	() -> new AtomicReferenceArray(1).getAndUpdate(0, null),
503	() -> aLongFieldUpdater().getAndUpdate(this, null),
504	() -> anIntFieldUpdater().getAndUpdate(this, null),
505	() -> anItemFieldUpdater().getAndUpdate(this, null));
506	}
507
508	/**
509	* All Atomic updateAndGet methods throw NullPointerException on null function argument
510	*/
511	@SuppressWarnings("unchecked")
512	public void testUpdateAndGetNPE() {
513	assertThrows(
514	NullPointerException.class,
515	() -> new AtomicLong().updateAndGet(null),
516	() -> new AtomicInteger().updateAndGet(null),
517	() -> new AtomicReference().updateAndGet(null),
518	() -> new AtomicLongArray(1).updateAndGet(0, null),
519	() -> new AtomicIntegerArray(1).updateAndGet(0, null),
520	() -> new AtomicReferenceArray(1).updateAndGet(0, null),
521	() -> aLongFieldUpdater().updateAndGet(this, null),
522	() -> anIntFieldUpdater().updateAndGet(this, null),
523	() -> anItemFieldUpdater().updateAndGet(this, null));
524	}
525
526	/**
527	* All Atomic getAndAccumulate methods throw NullPointerException
528	* on null function argument
529	*/
530	@SuppressWarnings("unchecked")
531	public void testGetAndAccumulateNPE() {
532	assertThrows(
533	NullPointerException.class,
534	() -> new AtomicLong().getAndAccumulate(1L, null),
535	() -> new AtomicInteger().getAndAccumulate(1, null),
536	() -> new AtomicReference().getAndAccumulate(one, null),
537	() -> new AtomicLongArray(1).getAndAccumulate(0, 1L, null),
538	() -> new AtomicIntegerArray(1).getAndAccumulate(0, 1, null),
539	() -> new AtomicReferenceArray(1).getAndAccumulate(0, one, null),
540	() -> aLongFieldUpdater().getAndAccumulate(this, 1L, null),
541	() -> anIntFieldUpdater().getAndAccumulate(this, 1, null),
542	() -> anItemFieldUpdater().getAndAccumulate(this, one, null));
543	}
544
545	/**
546	* All Atomic accumulateAndGet methods throw NullPointerException
547	* on null function argument
548	*/
549	@SuppressWarnings("unchecked")
550	public void testAccumulateAndGetNPE() {
551	assertThrows(
552	NullPointerException.class,
553	() -> new AtomicLong().accumulateAndGet(1L, null),
554	() -> new AtomicInteger().accumulateAndGet(1, null),
555	() -> new AtomicReference().accumulateAndGet(one, null),
556	() -> new AtomicLongArray(1).accumulateAndGet(0, 1L, null),
557	() -> new AtomicIntegerArray(1).accumulateAndGet(0, 1, null),
558	() -> new AtomicReferenceArray(1).accumulateAndGet(0, one, null),
559	() -> aLongFieldUpdater().accumulateAndGet(this, 1L, null),
560	() -> anIntFieldUpdater().accumulateAndGet(this, 1, null),
561	() -> anItemFieldUpdater().accumulateAndGet(this, one, null));
562	}
563
564	/**
565	* Object arguments for parameters of type T that are not
566	* instances of the class passed to the newUpdater call will
567	* result in a ClassCastException being thrown.
568	*/
569	@SuppressWarnings("unchecked")
570	public void testFieldUpdaters_ClassCastException() {
571	// Use raw types to allow passing wrong object type, provoking CCE
572	final AtomicLongFieldUpdater longUpdater = aLongFieldUpdater();
573	final AtomicIntegerFieldUpdater intUpdater = anIntFieldUpdater();
574	final AtomicReferenceFieldUpdater refUpdater = anItemFieldUpdater();
575	for (Object x : new Object[]{ new Object(), null }) {
576	assertThrows(
577	ClassCastException.class,
578	() -> longUpdater.get(x),
579	() -> intUpdater.get(x),
580	() -> refUpdater.get(x),
581
582	() -> longUpdater.set(x, 17L),
583	() -> intUpdater.set(x, 17),
584	() -> refUpdater.set(x, new Item(17)),
585
586	() -> longUpdater.addAndGet(x, 17L),
587	() -> intUpdater.addAndGet(x, 17),
588
589	() -> longUpdater.getAndUpdate(x, y -> y),
590	() -> intUpdater.getAndUpdate(x, y -> y),
591	() -> refUpdater.getAndUpdate(x, y -> y),
592
593	() -> longUpdater.compareAndSet(x, 17L, 42L),
594	() -> intUpdater.compareAndSet(x, 17, 42),
595	() -> refUpdater.compareAndSet(x, 17, fortytwo));
596	}
597	}
598
599	}