ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/AtomicIntegerArrayTest.java

Comparing jsr166/src/test/tck/AtomicIntegerArrayTest.java (file contents):
Revision 1.10 by dl, Wed May 25 14:27:37 2005 UTC vs.
Revision 1.11 by jsr166, Mon Nov 2 20:28:31 2009 UTC

#	Line 2 | Line 2
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4		* http://creativecommons.org/licenses/publicdomain
5	<	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	<	* Pat Fisher, Mike Judd.
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
9		import junit.framework.*;
#	Line 26 | Line 26 | public class AtomicIntegerArrayTest exte
26		*/
27		public void testConstructor() {
28		AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
29	<	for (int i = 0; i < SIZE; ++i)
29	>	for (int i = 0; i < SIZE; ++i)
30		assertEquals(0,ai.get(i));
31		}
32
#	Line 50 | Line 50 | public class AtomicIntegerArrayTest exte
50		int[] a = { 17, 3, -42, 99, -7};
51		AtomicIntegerArray ai = new AtomicIntegerArray(a);
52		assertEquals(a.length, ai.length());
53	<	for (int i = 0; i < a.length; ++i)
53	>	for (int i = 0; i < a.length; ++i)
54		assertEquals(a[i], ai.get(i));
55		}
56
#	Line 81 | Line 81 | public class AtomicIntegerArrayTest exte
81		* get returns the last value set at index
82		*/
83		public void testGetSet() {
84	<	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
84	>	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
85		for (int i = 0; i < SIZE; ++i) {
86		ai.set(i, 1);
87		assertEquals(1,ai.get(i));
#	Line 96 | Line 96 | public class AtomicIntegerArrayTest exte
96		* get returns the last value lazySet at index by same thread
97		*/
98		public void testGetLazySet() {
99	<	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
99	>	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
100		for (int i = 0; i < SIZE; ++i) {
101		ai.lazySet(i, 1);
102		assertEquals(1,ai.get(i));
#	Line 111 | Line 111 | public class AtomicIntegerArrayTest exte
111		* compareAndSet succeeds in changing value if equal to expected else fails
112		*/
113		public void testCompareAndSet() {
114	<	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
114	>	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
115		for (int i = 0; i < SIZE; ++i) {
116		ai.set(i, 1);
117		assertTrue(ai.compareAndSet(i, 1,2));
#	Line 149 | Line 149 | public class AtomicIntegerArrayTest exte
149
150		/**
151		* repeated weakCompareAndSet succeeds in changing value when equal
152	<	* to expected
152	>	* to expected
153		*/
154		public void testWeakCompareAndSet() {
155	<	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
155	>	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
156		for (int i = 0; i < SIZE; ++i) {
157		ai.set(i, 1);
158		while(!ai.weakCompareAndSet(i, 1,2));
#	Line 167 | Line 167 | public class AtomicIntegerArrayTest exte
167		*  getAndSet returns previous value and sets to given value at given index
168		*/
169		public void testGetAndSet() {
170	<	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
170	>	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
171		for (int i = 0; i < SIZE; ++i) {
172		ai.set(i, 1);
173		assertEquals(1,ai.getAndSet(i,0));
#	Line 180 | Line 180 | public class AtomicIntegerArrayTest exte
180		*  getAndAdd returns previous value and adds given value
181		*/
182		public void testGetAndAdd() {
183	<	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
183	>	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
184		for (int i = 0; i < SIZE; ++i) {
185		ai.set(i, 1);
186		assertEquals(1,ai.getAndAdd(i,2));
#	Line 194 | Line 194 | public class AtomicIntegerArrayTest exte
194		* getAndDecrement returns previous value and decrements
195		*/
196		public void testGetAndDecrement() {
197	<	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
197	>	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
198		for (int i = 0; i < SIZE; ++i) {
199		ai.set(i, 1);
200		assertEquals(1,ai.getAndDecrement(i));
#	Line 207 | Line 207 | public class AtomicIntegerArrayTest exte
207		* getAndIncrement returns previous value and increments
208		*/
209		public void testGetAndIncrement() {
210	<	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
210	>	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
211		for (int i = 0; i < SIZE; ++i) {
212		ai.set(i, 1);
213		assertEquals(1,ai.getAndIncrement(i));
#	Line 224 | Line 224 | public class AtomicIntegerArrayTest exte
224		*  addAndGet adds given value to current, and returns current value
225		*/
226		public void testAddAndGet() {
227	<	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
227	>	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
228		for (int i = 0; i < SIZE; ++i) {
229		ai.set(i, 1);
230		assertEquals(3,ai.addAndGet(i,2));
#	Line 238 | Line 238 | public class AtomicIntegerArrayTest exte
238		* decrementAndGet decrements and returns current value
239		*/
240		public void testDecrementAndGet() {
241	<	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
241	>	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
242		for (int i = 0; i < SIZE; ++i) {
243		ai.set(i, 1);
244		assertEquals(0,ai.decrementAndGet(i));
#	Line 252 | Line 252 | public class AtomicIntegerArrayTest exte
252		*  incrementAndGet increments and returns current value
253		*/
254		public void testIncrementAndGet() {
255	<	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
255	>	AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
256		for (int i = 0; i < SIZE; ++i) {
257		ai.set(i, 1);
258		assertEquals(2,ai.incrementAndGet(i));
#	Line 266 | Line 266 | public class AtomicIntegerArrayTest exte
266		}
267
268		static final int COUNTDOWN = 100000;
269	<
269	>
270		class Counter implements Runnable {
271		final AtomicIntegerArray ai;
272		volatile int counts;
#	Line 295 | Line 295 | public class AtomicIntegerArrayTest exte
295		*/
296		public void testCountingInMultipleThreads() {
297		try {
298	<	final AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
299	<	for (int i = 0; i < SIZE; ++i)
298	>	final AtomicIntegerArray ai = new AtomicIntegerArray(SIZE);
299	>	for (int i = 0; i < SIZE; ++i)
300		ai.set(i, COUNTDOWN);
301		Counter c1 = new Counter(ai);
302		Counter c2 = new Counter(ai);
#	Line 318 | Line 318 | public class AtomicIntegerArrayTest exte
318		* a deserialized serialized array holds same values
319		*/
320		public void testSerialization() {
321	<	AtomicIntegerArray l = new AtomicIntegerArray(SIZE);
322	<	for (int i = 0; i < SIZE; ++i)
321	>	AtomicIntegerArray l = new AtomicIntegerArray(SIZE);
322	>	for (int i = 0; i < SIZE; ++i)
323		l.set(i, -i);
324
325		try {
#	Line 343 | Line 343 | public class AtomicIntegerArrayTest exte
343
344		/**
345		* toString returns current value.
346	<	*/
346	>	*/
347		public void testToString() {
348		int[] a = { 17, 3, -42, 99, -7};
349		AtomicIntegerArray ai = new AtomicIntegerArray(a);

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines