test/tck/SynchronousQueueTest.java

/*
 * Written by members of JCP JSR-166 Expert Group and released to the
 * public domain. Use, modify, and redistribute this code in any way
 * without acknowledgement. Other contributors include Andrew Wright,
 * Jeffrey Hayes, Pat Fischer, Mike Judd.
 */

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

public class SynchronousQueueTest extends TestCase {

    private final static int N = 1;
    private static long SHORT_DELAY_MS = 100; 
    private static long MEDIUM_DELAY_MS = 1000;
    private static long LONG_DELAY_MS = 10000; 

    public static void main(String[] args) {
        junit.textui.TestRunner.run (suite());  
    }

    public static Test suite() {
        return new TestSuite(SynchronousQueueTest.class);
    }

    public void testEmptyFull() {
        SynchronousQueue q = new SynchronousQueue();
        assertTrue(q.isEmpty());
        assertEquals(0, q.size());
        assertEquals(0, q.remainingCapacity());
        assertFalse(q.offer(new Integer(3)));
    }

    public void testOfferNull(){
        try {
            SynchronousQueue q = new SynchronousQueue();
            q.offer(null);
            fail("should throw NPE");
        } catch (NullPointerException success) { }   
    }

    public void testOffer(){
        SynchronousQueue q = new SynchronousQueue();
        assertFalse(q.offer(new Integer(1)));
    }

    public void testAdd(){
        try {
            SynchronousQueue q = new SynchronousQueue();
            assertEquals(0, q.remainingCapacity());
            q.add(new Integer(0));
        } catch (IllegalStateException success){
        }   
    }

    public void testAddAll1(){
        try {
            SynchronousQueue q = new SynchronousQueue();
            q.addAll(null);
            fail("Cannot add null collection");
        }
        catch (NullPointerException success) {}
    }
    public void testAddAll2(){
        try {
            SynchronousQueue q = new SynchronousQueue();
            Integer[] ints = new Integer[N];
            q.addAll(Arrays.asList(ints));
            fail("Cannot add null elements");
        }
        catch (NullPointerException success) {}
    }
    public void testAddAll4(){
        try {
            SynchronousQueue q = new SynchronousQueue();
            Integer[] ints = new Integer[N];
            for (int i = 0; i < N; ++i)
                ints[i] = new Integer(i);
            q.addAll(Arrays.asList(ints));
            fail("Cannot add with insufficient capacity");
        }
        catch (IllegalStateException success) {}
    }

    public void testPutNull() {
        try {
            SynchronousQueue q = new SynchronousQueue();
            q.put(null);
            fail("put should throw NPE");
        } 
        catch (NullPointerException success){
        }   
        catch (InterruptedException ie) {
            fail("Unexpected exception");
        }
     }

    public void testBlockingPut(){
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        SynchronousQueue q = new SynchronousQueue();
                        q.put(new Integer(0));
                        fail("put should block");
                    } catch (InterruptedException ie){
                    }   
                }});
        t.start();
        try { 
           Thread.sleep(SHORT_DELAY_MS); 
           t.interrupt();
           t.join();
        }
        catch (InterruptedException ie) {
            fail("Unexpected exception");
        }
    }

    public void testPutWithTake() {
        final SynchronousQueue q = new SynchronousQueue();
        Thread t = new Thread(new Runnable() {
                public void run(){
                    int added = 0;
                    try {
                        q.put(new Object());
                        ++added;
                        q.put(new Object());
                        ++added;
                        q.put(new Object());
                        ++added;
                        q.put(new Object());
                        ++added;
                        fail("Should block");
                    } catch (InterruptedException e){
                        assertTrue(added >= 1);
                    }
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            q.take();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch (Exception e){
            fail("Unexpected exception");
        }
    }

    public void testTimedOffer() {
        final SynchronousQueue q = new SynchronousQueue();
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try {

                        assertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));
                        q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
                        fail("Should block");
                    } catch (InterruptedException success){}
                }
            });
        
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch (Exception e){
            fail("Unexpected exception");
        }
    }


    public void testTakeFromEmpty() {
        final SynchronousQueue q = new SynchronousQueue();
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try {
                        q.take();
                        fail("Should block");
                    } catch (InterruptedException success){ }                
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch (Exception e){
            fail("Unexpected exception");
        }
    }

    public void testPoll(){
        SynchronousQueue q = new SynchronousQueue();
        assertNull(q.poll());
    }

    public void testTimedPoll0() {
        try {
            SynchronousQueue q = new SynchronousQueue();
            assertNull(q.poll(0, TimeUnit.MILLISECONDS));
        } catch (InterruptedException e){
            fail("Unexpected exception");
        }   
    }

    public void testTimedPoll() {
        try {
            SynchronousQueue q = new SynchronousQueue();
            assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
        } catch (InterruptedException e){
            fail("Unexpected exception");
        }   
    }

    public void testInterruptedTimedPoll(){
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        SynchronousQueue q = new SynchronousQueue();
                        assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                    } catch (InterruptedException success){
                    }   
                }});
        t.start();
        try { 
           Thread.sleep(SHORT_DELAY_MS); 
           t.interrupt();
           t.join();
        }
        catch (InterruptedException ie) {
            fail("Unexpected exception");
        }
    }

    public void testTimedPollWithOffer(){
        final SynchronousQueue q = new SynchronousQueue();
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try {
                        assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                        q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
                        q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
                        fail("Should block");
                    } catch (InterruptedException success) { }                
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS * 2);
            assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            t.interrupt();
            t.join();
        } catch (Exception e){
            fail("Unexpected exception");
        }
    }  


    public void testPeek(){
        SynchronousQueue q = new SynchronousQueue();
        assertNull(q.peek());
    }

    public void testElement(){
        SynchronousQueue q = new SynchronousQueue();
        try {
            q.element();
            fail("no such element");
        }
        catch (NoSuchElementException success) {}
    }

    public void testRemove(){
        SynchronousQueue q = new SynchronousQueue();
        try {
            q.remove();
            fail("remove should throw");
        } catch (NoSuchElementException success){
        }   
    }

    public void testRemoveElement(){
        SynchronousQueue q = new SynchronousQueue();
        for (int i = 1; i < N; i+=2) {
            assertFalse(q.remove(new Integer(i)));
        }
        assert(q.isEmpty());
    }
        
    public void testContains(){
        SynchronousQueue q = new SynchronousQueue();
        for (int i = 0; i < N; ++i) {
            assertFalse(q.contains(new Integer(i)));
        }
    }

    public void testClear(){
        SynchronousQueue q = new SynchronousQueue();
        q.clear();
        assertTrue(q.isEmpty());
    }

    public void testContainsAll(){
        SynchronousQueue q = new SynchronousQueue();
        Integer[] empty = new Integer[0];
        Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
        //        assertTrue(q.containsAll(Arrays.asList(empty)));
        assertFalse(q.containsAll(Arrays.asList(ints)));
    }

    public void testRetainAll(){
        SynchronousQueue q = new SynchronousQueue();
        Integer[] empty = new Integer[0];
        Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
        q.retainAll(Arrays.asList(ints));
        //        assertTrue(q.containsAll(Arrays.asList(empty)));
        assertFalse(q.containsAll(Arrays.asList(ints)));
    }

    public void testRemoveAll(){
        SynchronousQueue q = new SynchronousQueue();
        Integer[] empty = new Integer[0];
        Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
        q.removeAll(Arrays.asList(ints));
        //        assertTrue(q.containsAll(Arrays.asList(empty)));
        assertFalse(q.containsAll(Arrays.asList(ints)));
    }


    public void testToArray(){
        SynchronousQueue q = new SynchronousQueue();
        Object[] o = q.toArray();
        assertEquals(o.length, 0);
    }

    public void testToArray2(){
        SynchronousQueue q = new SynchronousQueue();
        Integer[] ints = new Integer[1];
        assertNull(ints[0]);
    }
    
    public void testIterator(){
        SynchronousQueue q = new SynchronousQueue();
        Iterator it = q.iterator();
        assertFalse(it.hasNext());
        try {
            Object x = it.next();
            fail("should throw");
        }
        catch (NoSuchElementException success) {}
    }

    public void testIteratorRemove(){
        SynchronousQueue q = new SynchronousQueue();
        Iterator it = q.iterator();
        try {
            it.remove();
            fail("should throw");
        }
        catch (IllegalStateException success) {}
    }

    public void testToString(){
        SynchronousQueue q = new SynchronousQueue();
        String s = q.toString();
        assertTrue(s != null);
    }        


    public void testOfferInExecutor() {
        final SynchronousQueue q = new SynchronousQueue();
        ExecutorService executor = Executors.newFixedThreadPool(2);
        final Integer one = new Integer(1);

        executor.execute(new Runnable() {
            public void run() {
                assertFalse(q.offer(one));
                try {
                    assertTrue(q.offer(one, MEDIUM_DELAY_MS * 2, TimeUnit.MILLISECONDS));
                    assertEquals(0, q.remainingCapacity());
                }
                catch (InterruptedException e) {
                    fail("should not be interrupted");
                }
            }
        });

        executor.execute(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(MEDIUM_DELAY_MS);
                    assertEquals(one, q.take());
                }
                catch (InterruptedException e) {
                    fail("should not be interrupted");
                }
            }
        });
        
        executor.shutdown();

    }

    public void testPollInExecutor() {

        final SynchronousQueue q = new SynchronousQueue();

        ExecutorService executor = Executors.newFixedThreadPool(2);

        executor.execute(new Runnable() {
            public void run() {
                assertNull(q.poll());
                try {
                    assertTrue(null != q.poll(MEDIUM_DELAY_MS * 2, TimeUnit.MILLISECONDS));
                    assertTrue(q.isEmpty());
                }
                catch (InterruptedException e) {
                    fail("should not be interrupted");
                }
            }
        });

        executor.execute(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(MEDIUM_DELAY_MS);
                    q.put(new Integer(1));
                }
                catch (InterruptedException e) {
                    fail("should not be interrupted");
                }
            }
        });
        
        executor.shutdown();

    }

}
Revision:	1.1
Committed:	Sun Aug 31 19:24:55 2003 UTC (20 years, 8 months ago) by dl
Branch:	MAIN
Log Message:	First check-in of tests to be in tck
#	User	Rev	Content
1	dl	1.1	/*
2			* Written by members of JCP JSR-166 Expert Group and released to the
3			* public domain. Use, modify, and redistribute this code in any way
4			* without acknowledgement. Other contributors include Andrew Wright,
5			* Jeffrey Hayes, Pat Fischer, Mike Judd.
6			*/
7
8			import junit.framework.*;
9			import java.util.*;
10			import java.util.concurrent.*;
11
12			public class SynchronousQueueTest extends TestCase {
13
14			private final static int N = 1;
15			private static long SHORT_DELAY_MS = 100;
16			private static long MEDIUM_DELAY_MS = 1000;
17			private static long LONG_DELAY_MS = 10000;
18
19			public static void main(String[] args) {
20			junit.textui.TestRunner.run (suite());
21			}
22
23			public static Test suite() {
24			return new TestSuite(SynchronousQueueTest.class);
25			}
26
27			public void testEmptyFull() {
28			SynchronousQueue q = new SynchronousQueue();
29			assertTrue(q.isEmpty());
30			assertEquals(0, q.size());
31			assertEquals(0, q.remainingCapacity());
32			assertFalse(q.offer(new Integer(3)));
33			}
34
35			public void testOfferNull(){
36			try {
37			SynchronousQueue q = new SynchronousQueue();
38			q.offer(null);
39			fail("should throw NPE");
40			} catch (NullPointerException success) { }
41			}
42
43			public void testOffer(){
44			SynchronousQueue q = new SynchronousQueue();
45			assertFalse(q.offer(new Integer(1)));
46			}
47
48			public void testAdd(){
49			try {
50			SynchronousQueue q = new SynchronousQueue();
51			assertEquals(0, q.remainingCapacity());
52			q.add(new Integer(0));
53			} catch (IllegalStateException success){
54			}
55			}
56
57			public void testAddAll1(){
58			try {
59			SynchronousQueue q = new SynchronousQueue();
60			q.addAll(null);
61			fail("Cannot add null collection");
62			}
63			catch (NullPointerException success) {}
64			}
65			public void testAddAll2(){
66			try {
67			SynchronousQueue q = new SynchronousQueue();
68			Integer[] ints = new Integer[N];
69			q.addAll(Arrays.asList(ints));
70			fail("Cannot add null elements");
71			}
72			catch (NullPointerException success) {}
73			}
74			public void testAddAll4(){
75			try {
76			SynchronousQueue q = new SynchronousQueue();
77			Integer[] ints = new Integer[N];
78			for (int i = 0; i < N; ++i)
79			ints[i] = new Integer(i);
80			q.addAll(Arrays.asList(ints));
81			fail("Cannot add with insufficient capacity");
82			}
83			catch (IllegalStateException success) {}
84			}
85
86			public void testPutNull() {
87			try {
88			SynchronousQueue q = new SynchronousQueue();
89			q.put(null);
90			fail("put should throw NPE");
91			}
92			catch (NullPointerException success){
93			}
94			catch (InterruptedException ie) {
95			fail("Unexpected exception");
96			}
97			}
98
99			public void testBlockingPut(){
100			Thread t = new Thread(new Runnable() {
101			public void run() {
102			try {
103			SynchronousQueue q = new SynchronousQueue();
104			q.put(new Integer(0));
105			fail("put should block");
106			} catch (InterruptedException ie){
107			}
108			}});
109			t.start();
110			try {
111			Thread.sleep(SHORT_DELAY_MS);
112			t.interrupt();
113			t.join();
114			}
115			catch (InterruptedException ie) {
116			fail("Unexpected exception");
117			}
118			}
119
120			public void testPutWithTake() {
121			final SynchronousQueue q = new SynchronousQueue();
122			Thread t = new Thread(new Runnable() {
123			public void run(){
124			int added = 0;
125			try {
126			q.put(new Object());
127			++added;
128			q.put(new Object());
129			++added;
130			q.put(new Object());
131			++added;
132			q.put(new Object());
133			++added;
134			fail("Should block");
135			} catch (InterruptedException e){
136			assertTrue(added >= 1);
137			}
138			}
139			});
140			try {
141			t.start();
142			Thread.sleep(SHORT_DELAY_MS);
143			q.take();
144			Thread.sleep(SHORT_DELAY_MS);
145			t.interrupt();
146			t.join();
147			} catch (Exception e){
148			fail("Unexpected exception");
149			}
150			}
151
152			public void testTimedOffer() {
153			final SynchronousQueue q = new SynchronousQueue();
154			Thread t = new Thread(new Runnable() {
155			public void run(){
156			try {
157
158			assertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));
159			q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
160			fail("Should block");
161			} catch (InterruptedException success){}
162			}
163			});
164
165			try {
166			t.start();
167			Thread.sleep(SHORT_DELAY_MS);
168			t.interrupt();
169			t.join();
170			} catch (Exception e){
171			fail("Unexpected exception");
172			}
173			}
174
175
176			public void testTakeFromEmpty() {
177			final SynchronousQueue q = new SynchronousQueue();
178			Thread t = new Thread(new Runnable() {
179			public void run(){
180			try {
181			q.take();
182			fail("Should block");
183			} catch (InterruptedException success){ }
184			}
185			});
186			try {
187			t.start();
188			Thread.sleep(SHORT_DELAY_MS);
189			t.interrupt();
190			t.join();
191			} catch (Exception e){
192			fail("Unexpected exception");
193			}
194			}
195
196			public void testPoll(){
197			SynchronousQueue q = new SynchronousQueue();
198			assertNull(q.poll());
199			}
200
201			public void testTimedPoll0() {
202			try {
203			SynchronousQueue q = new SynchronousQueue();
204			assertNull(q.poll(0, TimeUnit.MILLISECONDS));
205			} catch (InterruptedException e){
206			fail("Unexpected exception");
207			}
208			}
209
210			public void testTimedPoll() {
211			try {
212			SynchronousQueue q = new SynchronousQueue();
213			assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
214			} catch (InterruptedException e){
215			fail("Unexpected exception");
216			}
217			}
218
219			public void testInterruptedTimedPoll(){
220			Thread t = new Thread(new Runnable() {
221			public void run() {
222			try {
223			SynchronousQueue q = new SynchronousQueue();
224			assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
225			} catch (InterruptedException success){
226			}
227			}});
228			t.start();
229			try {
230			Thread.sleep(SHORT_DELAY_MS);
231			t.interrupt();
232			t.join();
233			}
234			catch (InterruptedException ie) {
235			fail("Unexpected exception");
236			}
237			}
238
239			public void testTimedPollWithOffer(){
240			final SynchronousQueue q = new SynchronousQueue();
241			Thread t = new Thread(new Runnable() {
242			public void run(){
243			try {
244			assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
245			q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
246			q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
247			fail("Should block");
248			} catch (InterruptedException success) { }
249			}
250			});
251			try {
252			t.start();
253			Thread.sleep(SHORT_DELAY_MS * 2);
254			assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
255			t.interrupt();
256			t.join();
257			} catch (Exception e){
258			fail("Unexpected exception");
259			}
260			}
261
262
263			public void testPeek(){
264			SynchronousQueue q = new SynchronousQueue();
265			assertNull(q.peek());
266			}
267
268			public void testElement(){
269			SynchronousQueue q = new SynchronousQueue();
270			try {
271			q.element();
272			fail("no such element");
273			}
274			catch (NoSuchElementException success) {}
275			}
276
277			public void testRemove(){
278			SynchronousQueue q = new SynchronousQueue();
279			try {
280			q.remove();
281			fail("remove should throw");
282			} catch (NoSuchElementException success){
283			}
284			}
285
286			public void testRemoveElement(){
287			SynchronousQueue q = new SynchronousQueue();
288			for (int i = 1; i < N; i+=2) {
289			assertFalse(q.remove(new Integer(i)));
290			}
291			assert(q.isEmpty());
292			}
293
294			public void testContains(){
295			SynchronousQueue q = new SynchronousQueue();
296			for (int i = 0; i < N; ++i) {
297			assertFalse(q.contains(new Integer(i)));
298			}
299			}
300
301			public void testClear(){
302			SynchronousQueue q = new SynchronousQueue();
303			q.clear();
304			assertTrue(q.isEmpty());
305			}
306
307			public void testContainsAll(){
308			SynchronousQueue q = new SynchronousQueue();
309			Integer[] empty = new Integer[0];
310			Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
311			// assertTrue(q.containsAll(Arrays.asList(empty)));
312			assertFalse(q.containsAll(Arrays.asList(ints)));
313			}
314
315			public void testRetainAll(){
316			SynchronousQueue q = new SynchronousQueue();
317			Integer[] empty = new Integer[0];
318			Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
319			q.retainAll(Arrays.asList(ints));
320			// assertTrue(q.containsAll(Arrays.asList(empty)));
321			assertFalse(q.containsAll(Arrays.asList(ints)));
322			}
323
324			public void testRemoveAll(){
325			SynchronousQueue q = new SynchronousQueue();
326			Integer[] empty = new Integer[0];
327			Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
328			q.removeAll(Arrays.asList(ints));
329			// assertTrue(q.containsAll(Arrays.asList(empty)));
330			assertFalse(q.containsAll(Arrays.asList(ints)));
331			}
332
333
334			public void testToArray(){
335			SynchronousQueue q = new SynchronousQueue();
336			Object[] o = q.toArray();
337			assertEquals(o.length, 0);
338			}
339
340			public void testToArray2(){
341			SynchronousQueue q = new SynchronousQueue();
342			Integer[] ints = new Integer[1];
343			assertNull(ints[0]);
344			}
345
346			public void testIterator(){
347			SynchronousQueue q = new SynchronousQueue();
348			Iterator it = q.iterator();
349			assertFalse(it.hasNext());
350			try {
351			Object x = it.next();
352			fail("should throw");
353			}
354			catch (NoSuchElementException success) {}
355			}
356
357			public void testIteratorRemove(){
358			SynchronousQueue q = new SynchronousQueue();
359			Iterator it = q.iterator();
360			try {
361			it.remove();
362			fail("should throw");
363			}
364			catch (IllegalStateException success) {}
365			}
366
367			public void testToString(){
368			SynchronousQueue q = new SynchronousQueue();
369			String s = q.toString();
370			assertTrue(s != null);
371			}
372
373
374			public void testOfferInExecutor() {
375			final SynchronousQueue q = new SynchronousQueue();
376			ExecutorService executor = Executors.newFixedThreadPool(2);
377			final Integer one = new Integer(1);
378
379			executor.execute(new Runnable() {
380			public void run() {
381			assertFalse(q.offer(one));
382			try {
383			assertTrue(q.offer(one, MEDIUM_DELAY_MS * 2, TimeUnit.MILLISECONDS));
384			assertEquals(0, q.remainingCapacity());
385			}
386			catch (InterruptedException e) {
387			fail("should not be interrupted");
388			}
389			}
390			});
391
392			executor.execute(new Runnable() {
393			public void run() {
394			try {
395			Thread.sleep(MEDIUM_DELAY_MS);
396			assertEquals(one, q.take());
397			}
398			catch (InterruptedException e) {
399			fail("should not be interrupted");
400			}
401			}
402			});
403
404			executor.shutdown();
405
406			}
407
408			public void testPollInExecutor() {
409
410			final SynchronousQueue q = new SynchronousQueue();
411
412			ExecutorService executor = Executors.newFixedThreadPool(2);
413
414			executor.execute(new Runnable() {
415			public void run() {
416			assertNull(q.poll());
417			try {
418			assertTrue(null != q.poll(MEDIUM_DELAY_MS * 2, TimeUnit.MILLISECONDS));
419			assertTrue(q.isEmpty());
420			}
421			catch (InterruptedException e) {
422			fail("should not be interrupted");
423			}
424			}
425			});
426
427			executor.execute(new Runnable() {
428			public void run() {
429			try {
430			Thread.sleep(MEDIUM_DELAY_MS);
431			q.put(new Integer(1));
432			}
433			catch (InterruptedException e) {
434			fail("should not be interrupted");
435			}
436			}
437			});
438
439			executor.shutdown();
440
441			}
442
443			}