ViewVC Help

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

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

Comparing jsr166/src/test/tck/ScheduledExecutorTest.java (file contents):
Revision 1.9 by dl, Thu Dec 4 20:54:46 2003 UTC vs.
Revision 1.10 by dl, Mon Dec 22 00:48:56 2003 UTC

#	Line 606 | Line 606 | public class ScheduledExecutorTest exten
606		}
607		}
608
609	+	/**
610	+	* completed submit of callable returns result
611	+	*/
612	+	public void testSubmitCallable() {
613	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
614	+	try {
615	+	Future<String> future = e.submit(new StringTask());
616	+	String result = future.get();
617	+	assertSame(TEST_STRING, result);
618	+	}
619	+	catch (ExecutionException ex) {
620	+	unexpectedException();
621	+	}
622	+	catch (InterruptedException ex) {
623	+	unexpectedException();
624	+	} finally {
625	+	joinPool(e);
626	+	}
627	+	}
628	+
629	+	/**
630	+	* completed submit of runnable returns successfully
631	+	*/
632	+	public void testSubmitRunnable() {
633	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
634	+	try {
635	+	Future<?> future = e.submit(new NoOpRunnable());
636	+	future.get();
637	+	assertTrue(future.isDone());
638	+	}
639	+	catch (ExecutionException ex) {
640	+	unexpectedException();
641	+	}
642	+	catch (InterruptedException ex) {
643	+	unexpectedException();
644	+	} finally {
645	+	joinPool(e);
646	+	}
647	+	}
648	+
649	+	/**
650	+	* completed submit of (runnable, result) returns result
651	+	*/
652	+	public void testSubmitRunnable2() {
653	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
654	+	try {
655	+	Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
656	+	String result = future.get();
657	+	assertSame(TEST_STRING, result);
658	+	}
659	+	catch (ExecutionException ex) {
660	+	unexpectedException();
661	+	}
662	+	catch (InterruptedException ex) {
663	+	unexpectedException();
664	+	} finally {
665	+	joinPool(e);
666	+	}
667	+	}
668	+
669	+
670	+
671	+
672	+
673	+	/**
674	+	* invokeAny(null) throws NPE
675	+	*/
676	+	public void testInvokeAny1() {
677	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
678	+	try {
679	+	e.invokeAny(null);
680	+	} catch (NullPointerException success) {
681	+	} catch(Exception ex) {
682	+	unexpectedException();
683	+	} finally {
684	+	joinPool(e);
685	+	}
686	+	}
687	+
688	+	/**
689	+	* invokeAny(empty collection) throws IAE
690	+	*/
691	+	public void testInvokeAny2() {
692	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
693	+	try {
694	+	e.invokeAny(new ArrayList<Callable<String>>());
695	+	} catch (IllegalArgumentException success) {
696	+	} catch(Exception ex) {
697	+	unexpectedException();
698	+	} finally {
699	+	joinPool(e);
700	+	}
701	+	}
702	+
703	+	/**
704	+	* invokeAny(c) throws NPE if c has null elements
705	+	*/
706	+	public void testInvokeAny3() {
707	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
708	+	try {
709	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
710	+	l.add(new StringTask());
711	+	l.add(null);
712	+	e.invokeAny(l);
713	+	} catch (NullPointerException success) {
714	+	} catch(Exception ex) {
715	+	unexpectedException();
716	+	} finally {
717	+	joinPool(e);
718	+	}
719	+	}
720	+
721	+	/**
722	+	* invokeAny(c) throws ExecutionException if no task completes
723	+	*/
724	+	public void testInvokeAny4() {
725	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
726	+	try {
727	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
728	+	l.add(new NPETask());
729	+	e.invokeAny(l);
730	+	} catch (ExecutionException success) {
731	+	} catch(Exception ex) {
732	+	unexpectedException();
733	+	} finally {
734	+	joinPool(e);
735	+	}
736	+	}
737	+
738	+	/**
739	+	* invokeAny(c) returns result of some task
740	+	*/
741	+	public void testInvokeAny5() {
742	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
743	+	try {
744	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
745	+	l.add(new StringTask());
746	+	l.add(new StringTask());
747	+	String result = e.invokeAny(l);
748	+	assertSame(TEST_STRING, result);
749	+	} catch (ExecutionException success) {
750	+	} catch(Exception ex) {
751	+	unexpectedException();
752	+	} finally {
753	+	joinPool(e);
754	+	}
755	+	}
756	+
757	+	/**
758	+	* invokeAll(null) throws NPE
759	+	*/
760	+	public void testInvokeAll1() {
761	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
762	+	try {
763	+	e.invokeAll(null);
764	+	} catch (NullPointerException success) {
765	+	} catch(Exception ex) {
766	+	unexpectedException();
767	+	} finally {
768	+	joinPool(e);
769	+	}
770	+	}
771	+
772	+	/**
773	+	* invokeAll(empty collection) returns empty collection
774	+	*/
775	+	public void testInvokeAll2() {
776	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
777	+	try {
778	+	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
779	+	assertTrue(r.isEmpty());
780	+	} catch(Exception ex) {
781	+	unexpectedException();
782	+	} finally {
783	+	joinPool(e);
784	+	}
785	+	}
786	+
787	+	/**
788	+	* invokeAll(c) throws NPE if c has null elements
789	+	*/
790	+	public void testInvokeAll3() {
791	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
792	+	try {
793	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
794	+	l.add(new StringTask());
795	+	l.add(null);
796	+	e.invokeAll(l);
797	+	} catch (NullPointerException success) {
798	+	} catch(Exception ex) {
799	+	unexpectedException();
800	+	} finally {
801	+	joinPool(e);
802	+	}
803	+	}
804	+
805	+	/**
806	+	* get of invokeAll(c) throws exception on failed task
807	+	*/
808	+	public void testInvokeAll4() {
809	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
810	+	try {
811	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
812	+	l.add(new NPETask());
813	+	List<Future<String>> result = e.invokeAll(l);
814	+	assertEquals(1, result.size());
815	+	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
816	+	it.next().get();
817	+	} catch(ExecutionException success) {
818	+	} catch(Exception ex) {
819	+	unexpectedException();
820	+	} finally {
821	+	joinPool(e);
822	+	}
823	+	}
824	+
825	+	/**
826	+	* invokeAll(c) returns results of all completed tasks
827	+	*/
828	+	public void testInvokeAll5() {
829	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
830	+	try {
831	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
832	+	l.add(new StringTask());
833	+	l.add(new StringTask());
834	+	List<Future<String>> result = e.invokeAll(l);
835	+	assertEquals(2, result.size());
836	+	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
837	+	assertSame(TEST_STRING, it.next().get());
838	+	} catch (ExecutionException success) {
839	+	} catch(Exception ex) {
840	+	unexpectedException();
841	+	} finally {
842	+	joinPool(e);
843	+	}
844	+	}
845	+
846	+
847		}

Diff Legend

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