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.2
Committed:	Mon Nov 2 20:28:31 2009 UTC (14 years, 6 months ago) by jsr166
Branch:	MAIN
Changes since 1.1:	+6 -6 lines
Log Message:	whitespace
#	User	Rev	Content
1	dl	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	jsr166	1.2	* Other contributors include Andrew Wright, Jeffrey Hayes,
6			* Pat Fisher, Mike Judd.
7	dl	1.1	*/
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	jsr166	1.2	public boolean offer(Integer x) {
26	dl	1.1	if (x == null) throw new NullPointerException();
27	jsr166	1.2	return true;
28	dl	1.1	}
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	jsr166	1.2	public boolean offer(Integer x) {
37	dl	1.1	if (x == null) throw new NullPointerException();
38	jsr166	1.2	return false;
39	dl	1.1	}
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			/**
67			* add throws NPE 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			}
76			}
77
78			/**
79			* remove returns normally if poll succeeds
80			*/
81			public void testRemoveS() {
82			Succeed q = new Succeed();
83			q.remove();
84			}
85
86			/**
87			* remove throws NSEE if poll returns null
88			*/
89			public void testRemoveF() {
90			Fail q = new Fail();
91			try {
92			q.remove();
93			shouldThrow();
94			} catch (NoSuchElementException success) {
95			}
96			}
97
98
99			/**
100			* element returns normally if peek succeeds
101			*/
102			public void testElementS() {
103			Succeed q = new Succeed();
104			q.element();
105			}
106
107			/**
108			* element throws NSEE if peek returns null
109			*/
110			public void testElementF() {
111			Fail q = new Fail();
112			try {
113			q.element();
114			shouldThrow();
115			} catch (NoSuchElementException success) {
116			}
117			}
118
119			/**
120			* addAll(null) throws NPE
121			*/
122			public void testAddAll1() {
123			try {
124			Succeed q = new Succeed();
125			q.addAll(null);
126			shouldThrow();
127			}
128			catch (NullPointerException success) {}
129			}
130
131			/**
132			* addAll(this) throws IAE
133			*/
134			public void testAddAllSelf() {
135			try {
136			Succeed q = new Succeed();
137			q.addAll(q);
138			shouldThrow();
139			}
140			catch (IllegalArgumentException success) {}
141			}
142
143
144			/**
145			* addAll of a collection with null elements throws NPE
146			*/
147			public void testAddAll2() {
148			try {
149			Succeed q = new Succeed();
150			Integer[] ints = new Integer[SIZE];
151			q.addAll(Arrays.asList(ints));
152			shouldThrow();
153			}
154			catch (NullPointerException success) {}
155			}
156			/**
157			* addAll of a collection with any null elements throws NPE after
158			* possibly adding some elements
159			*/
160			public void testAddAll3() {
161			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);
166			q.addAll(Arrays.asList(ints));
167			shouldThrow();
168			}
169			catch (NullPointerException success) {}
170			}
171			/**
172			* addAll throws ISE if an add fails
173			*/
174			public void testAddAll4() {
175			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);
180			q.addAll(Arrays.asList(ints));
181			shouldThrow();
182			}
183			catch (IllegalStateException success) {}
184			}
185
186			}