ViewVC Help

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

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

Comparing jsr166/src/test/tck/AbstractQueueTest.java (file contents):
Revision 1.1 by dl, Sat Jan 10 20:37:20 2004 UTC vs.
Revision 1.15 by jsr166, Mon May 29 22:44:26 2017 UTC

#	Line 1 | Line 1
1		/*
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.
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
9	+	import java.util.AbstractQueue;
10	+	import java.util.Arrays;
11	+	import java.util.Iterator;
12	+	import java.util.NoSuchElementException;
13
14	<	import junit.framework.*;
15	<	import java.util.*;
12	<	import java.util.concurrent.*;
13	<	import java.util.concurrent.locks.*;
14	<	import java.io.*;
14	>	import junit.framework.Test;
15	>	import junit.framework.TestSuite;
16
17		public class AbstractQueueTest extends JSR166TestCase {
18		public static void main(String[] args) {
19	<	junit.textui.TestRunner.run (suite());
19	>	main(suite(), args);
20		}
21		public static Test suite() {
22		return new TestSuite(AbstractQueueTest.class);
23		}
24
25		static class Succeed extends AbstractQueue<Integer> {
26	<	public boolean offer(Integer x) {
26	>	public boolean offer(Integer x) {
27		if (x == null) throw new NullPointerException();
28	<	return true;
28	>	return true;
29		}
30		public Integer peek() { return one; }
31		public Integer poll() { return one; }
#	Line 33 | Line 34 | public class AbstractQueueTest extends J
34		}
35
36		static class Fail extends AbstractQueue<Integer> {
37	<	public boolean offer(Integer x) {
37	>	public boolean offer(Integer x) {
38		if (x == null) throw new NullPointerException();
39	<	return false;
39	>	return false;
40		}
41		public Integer peek() { return null; }
42		public Integer poll() { return null; }
#	Line 52 | Line 53 | public class AbstractQueueTest extends J
53		}
54
55		/**
56	<	* add throws ISE true if offer fails
56	>	* add throws IllegalStateException true if offer fails
57		*/
58		public void testAddF() {
59		Fail q = new Fail();
60		try {
61		q.add(one);
62		shouldThrow();
63	<	} catch (IllegalStateException success) {
63	<	}
63	>	} catch (IllegalStateException success) {}
64		}
65
66		/**
67	<	* add throws NPE if offer does
67	>	* add throws NullPointerException if offer does
68		*/
69		public void testAddNPE() {
70		Succeed q = new Succeed();
71		try {
72		q.add(null);
73		shouldThrow();
74	<	} catch (NullPointerException success) {
75	<	}
74	>	} catch (NullPointerException success) {}
75		}
76
77		/**
#	Line 91 | Line 90 | public class AbstractQueueTest extends J
90		try {
91		q.remove();
92		shouldThrow();
93	<	} catch (NoSuchElementException success) {
95	<	}
93	>	} catch (NoSuchElementException success) {}
94		}
95
98	–
96		/**
97		* element returns normally if peek succeeds
98		*/
#	Line 112 | Line 109 | public class AbstractQueueTest extends J
109		try {
110		q.element();
111		shouldThrow();
112	<	} catch (NoSuchElementException success) {
116	<	}
112	>	} catch (NoSuchElementException success) {}
113		}
114
115		/**
116	<	*  addAll(null) throws NPE
116	>	* addAll(null) throws NullPointerException
117		*/
118		public void testAddAll1() {
119	+	Succeed q = new Succeed();
120		try {
124	–	Succeed q = new Succeed();
121		q.addAll(null);
122		shouldThrow();
123	<	}
128	<	catch (NullPointerException success) {}
123	>	} catch (NullPointerException success) {}
124		}
125
126		/**
127	<	* addAll(this) throws IAE
127	>	* addAll(this) throws IllegalArgumentException
128		*/
129		public void testAddAllSelf() {
130	+	Succeed q = new Succeed();
131		try {
136	–	Succeed q = new Succeed();
132		q.addAll(q);
133		shouldThrow();
134	<	}
140	<	catch (IllegalArgumentException success) {}
134	>	} catch (IllegalArgumentException success) {}
135		}
136
143	–
137		/**
138	<	*  addAll of a collection with null elements throws NPE
138	>	* addAll of a collection with null elements throws NullPointerException
139		*/
140		public void testAddAll2() {
141	+	Succeed q = new Succeed();
142	+	Integer[] ints = new Integer[SIZE];
143		try {
149	–	Succeed q = new Succeed();
150	–	Integer[] ints = new Integer[SIZE];
144		q.addAll(Arrays.asList(ints));
145		shouldThrow();
146	<	}
154	<	catch (NullPointerException success) {}
146	>	} catch (NullPointerException success) {}
147		}
148	+
149		/**
150		* addAll of a collection with any null elements throws NPE after
151		* possibly adding some elements
152		*/
153		public void testAddAll3() {
154	+	Succeed q = new Succeed();
155	+	Integer[] ints = new Integer[SIZE];
156	+	for (int i = 0; i < SIZE - 1; ++i)
157	+	ints[i] = new Integer(i);
158		try {
162	–	Succeed q = new Succeed();
163	–	Integer[] ints = new Integer[SIZE];
164	–	for (int i = 0; i < SIZE-1; ++i)
165	–	ints[i] = new Integer(i);
159		q.addAll(Arrays.asList(ints));
160		shouldThrow();
161	<	}
169	<	catch (NullPointerException success) {}
161	>	} catch (NullPointerException success) {}
162		}
163	+
164		/**
165	<	* addAll throws ISE if an add fails
165	>	* addAll throws IllegalStateException if an add fails
166		*/
167		public void testAddAll4() {
168	+	Fail q = new Fail();
169	+	Integer[] ints = new Integer[SIZE];
170	+	for (int i = 0; i < SIZE; ++i)
171	+	ints[i] = new Integer(i);
172		try {
176	–	Fail q = new Fail();
177	–	Integer[] ints = new Integer[SIZE];
178	–	for (int i = 0; i < SIZE; ++i)
179	–	ints[i] = new Integer(i);
173		q.addAll(Arrays.asList(ints));
174		shouldThrow();
175	<	}
183	<	catch (IllegalStateException success) {}
175	>	} catch (IllegalStateException success) {}
176		}
177
178		}

Diff Legend

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