test/tck/AbstractQueueTest.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/licenses/publicdomain
 * Other contributors include Andrew Wright, Jeffrey Hayes,
 * Pat Fisher, Mike Judd.
 */


import junit.framework.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;
import java.io.*;

public class AbstractQueueTest extends JSR166TestCase {
    public static void main(String[] args) {
        junit.textui.TestRunner.run (suite());
    }
    public static Test suite() {
        return new TestSuite(AbstractQueueTest.class);
    }

    static class Succeed extends AbstractQueue<Integer> {
        public boolean offer(Integer x) {
            if (x == null) throw new NullPointerException();
            return true;
        }
        public Integer peek() { return one; }
        public Integer poll() { return one; }
        public int size() { return 0; }
        public Iterator iterator() { return null; } // not needed
    }

    static class Fail extends AbstractQueue<Integer> {
        public boolean offer(Integer x) {
            if (x == null) throw new NullPointerException();
            return false;
        }
        public Integer peek() { return null; }
        public Integer poll() { return null; }
        public int size() { return 0; }
        public Iterator iterator() { return null; } // not needed
    }

    /**
     * add returns true if offer succeeds
     */
    public void testAddS() {
        Succeed q = new Succeed();
        assertTrue(q.add(two));
    }

    /**
     * add throws ISE true if offer fails
     */
    public void testAddF() {
        Fail q = new Fail();
        try {
            q.add(one);
            shouldThrow();
        } catch (IllegalStateException success) {}
    }

    /**
     * add throws NPE if offer does
     */
    public void testAddNPE() {
        Succeed q = new Succeed();
        try {
            q.add(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * remove returns normally if poll succeeds
     */
    public void testRemoveS() {
        Succeed q = new Succeed();
        q.remove();
    }

    /**
     * remove throws NSEE if poll returns null
     */
    public void testRemoveF() {
        Fail q = new Fail();
        try {
            q.remove();
            shouldThrow();
        } catch (NoSuchElementException success) {}
    }


    /**
     * element returns normally if peek succeeds
     */
    public void testElementS() {
        Succeed q = new Succeed();
        q.element();
    }

    /**
     * element throws NSEE if peek returns null
     */
    public void testElementF() {
        Fail q = new Fail();
        try {
            q.element();
            shouldThrow();
        } catch (NoSuchElementException success) {}
    }

    /**
     *  addAll(null) throws NPE
     */
    public void testAddAll1() {
        try {
            Succeed q = new Succeed();
            q.addAll(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * addAll(this) throws IAE
     */
    public void testAddAllSelf() {
        try {
            Succeed q = new Succeed();
            q.addAll(q);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
    }


    /**
     *  addAll of a collection with null elements throws NPE
     */
    public void testAddAll2() {
        try {
            Succeed q = new Succeed();
            Integer[] ints = new Integer[SIZE];
            q.addAll(Arrays.asList(ints));
            shouldThrow();
        } catch (NullPointerException success) {}
    }
    /**
     * addAll of a collection with any null elements throws NPE after
     * possibly adding some elements
     */
    public void testAddAll3() {
        try {
            Succeed q = new Succeed();
            Integer[] ints = new Integer[SIZE];
            for (int i = 0; i < SIZE-1; ++i)
                ints[i] = new Integer(i);
            q.addAll(Arrays.asList(ints));
            shouldThrow();
        } catch (NullPointerException success) {}
    }
    /**
     * addAll throws ISE if an add fails
     */
    public void testAddAll4() {
        try {
            Fail q = new Fail();
            Integer[] ints = new Integer[SIZE];
            for (int i = 0; i < SIZE; ++i)
                ints[i] = new Integer(i);
            q.addAll(Arrays.asList(ints));
            shouldThrow();
        } catch (IllegalStateException success) {}
    }

}
Revision:	1.3
Committed:	Sat Nov 21 10:25:05 2009 UTC (14 years, 5 months ago) by jsr166
Branch:	MAIN
Changes since 1.2:	+9 -18 lines
Log Message:	improve exception handling
#	Content
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.
7	*/
8
9
10	import junit.framework.*;
11	import java.util.*;
12	import java.util.concurrent.*;
13	import java.util.concurrent.locks.*;
14	import java.io.*;
15
16	public class AbstractQueueTest extends JSR166TestCase {
17	public static void main(String[] args) {
18	junit.textui.TestRunner.run (suite());
19	}
20	public static Test suite() {
21	return new TestSuite(AbstractQueueTest.class);
22	}
23
24	static class Succeed extends AbstractQueue<Integer> {
25	public boolean offer(Integer x) {
26	if (x == null) throw new NullPointerException();
27	return true;
28	}
29	public Integer peek() { return one; }
30	public Integer poll() { return one; }
31	public int size() { return 0; }
32	public Iterator iterator() { return null; } // not needed
33	}
34
35	static class Fail extends AbstractQueue<Integer> {
36	public boolean offer(Integer x) {
37	if (x == null) throw new NullPointerException();
38	return false;
39	}
40	public Integer peek() { return null; }
41	public Integer poll() { return null; }
42	public int size() { return 0; }
43	public Iterator iterator() { return null; } // not needed
44	}
45
46	/**
47	* add returns true if offer succeeds
48	*/
49	public void testAddS() {
50	Succeed q = new Succeed();
51	assertTrue(q.add(two));
52	}
53
54	/**
55	* add throws ISE true if offer fails
56	*/
57	public void testAddF() {
58	Fail q = new Fail();
59	try {
60	q.add(one);
61	shouldThrow();
62	} catch (IllegalStateException success) {}
63	}
64
65	/**
66	* add throws NPE if offer does
67	*/
68	public void testAddNPE() {
69	Succeed q = new Succeed();
70	try {
71	q.add(null);
72	shouldThrow();
73	} catch (NullPointerException success) {}
74	}
75
76	/**
77	* remove returns normally if poll succeeds
78	*/
79	public void testRemoveS() {
80	Succeed q = new Succeed();
81	q.remove();
82	}
83
84	/**
85	* remove throws NSEE if poll returns null
86	*/
87	public void testRemoveF() {
88	Fail q = new Fail();
89	try {
90	q.remove();
91	shouldThrow();
92	} catch (NoSuchElementException success) {}
93	}
94
95
96	/**
97	* element returns normally if peek succeeds
98	*/
99	public void testElementS() {
100	Succeed q = new Succeed();
101	q.element();
102	}
103
104	/**
105	* element throws NSEE if peek returns null
106	*/
107	public void testElementF() {
108	Fail q = new Fail();
109	try {
110	q.element();
111	shouldThrow();
112	} catch (NoSuchElementException success) {}
113	}
114
115	/**
116	* addAll(null) throws NPE
117	*/
118	public void testAddAll1() {
119	try {
120	Succeed q = new Succeed();
121	q.addAll(null);
122	shouldThrow();
123	} catch (NullPointerException success) {}
124	}
125
126	/**
127	* addAll(this) throws IAE
128	*/
129	public void testAddAllSelf() {
130	try {
131	Succeed q = new Succeed();
132	q.addAll(q);
133	shouldThrow();
134	} catch (IllegalArgumentException success) {}
135	}
136
137
138	/**
139	* addAll of a collection with null elements throws NPE
140	*/
141	public void testAddAll2() {
142	try {
143	Succeed q = new Succeed();
144	Integer[] ints = new Integer[SIZE];
145	q.addAll(Arrays.asList(ints));
146	shouldThrow();
147	} catch (NullPointerException success) {}
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	try {
155	Succeed q = new Succeed();
156	Integer[] ints = new Integer[SIZE];
157	for (int i = 0; i < SIZE-1; ++i)
158	ints[i] = new Integer(i);
159	q.addAll(Arrays.asList(ints));
160	shouldThrow();
161	} catch (NullPointerException success) {}
162	}
163	/**
164	* addAll throws ISE if an add fails
165	*/
166	public void testAddAll4() {
167	try {
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	q.addAll(Arrays.asList(ints));
173	shouldThrow();
174	} catch (IllegalStateException success) {}
175	}
176
177	}