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.10 by dl, Mon Dec 22 00:48:56 2003 UTC vs.
Revision 1.11 by dl, Tue Dec 23 19:40:24 2003 UTC

#	Line 843 | Line 843 | public class ScheduledExecutorTest exten
843		}
844		}
845
846	+	/**
847	+	* timed invokeAny(null) throws NPE
848	+	*/
849	+	public void testTimedInvokeAny1() {
850	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
851	+	try {
852	+	e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
853	+	} catch (NullPointerException success) {
854	+	} catch(Exception ex) {
855	+	unexpectedException();
856	+	} finally {
857	+	joinPool(e);
858	+	}
859	+	}
860	+
861	+	/**
862	+	* timed invokeAny(,,null) throws NPE
863	+	*/
864	+	public void testTimedInvokeAnyNullTimeUnit() {
865	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
866	+	try {
867	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
868	+	l.add(new StringTask());
869	+	e.invokeAny(l, MEDIUM_DELAY_MS, null);
870	+	} catch (NullPointerException success) {
871	+	} catch(Exception ex) {
872	+	unexpectedException();
873	+	} finally {
874	+	joinPool(e);
875	+	}
876	+	}
877	+
878	+	/**
879	+	* timed invokeAny(empty collection) throws IAE
880	+	*/
881	+	public void testTimedInvokeAny2() {
882	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
883	+	try {
884	+	e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
885	+	} catch (IllegalArgumentException success) {
886	+	} catch(Exception ex) {
887	+	unexpectedException();
888	+	} finally {
889	+	joinPool(e);
890	+	}
891	+	}
892	+
893	+	/**
894	+	* timed invokeAny(c) throws NPE if c has null elements
895	+	*/
896	+	public void testTimedInvokeAny3() {
897	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
898	+	try {
899	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
900	+	l.add(new StringTask());
901	+	l.add(null);
902	+	e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
903	+	} catch (NullPointerException success) {
904	+	} catch(Exception ex) {
905	+	ex.printStackTrace();
906	+	unexpectedException();
907	+	} finally {
908	+	joinPool(e);
909	+	}
910	+	}
911	+
912	+	/**
913	+	* timed invokeAny(c) throws ExecutionException if no task completes
914	+	*/
915	+	public void testTimedInvokeAny4() {
916	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
917	+	try {
918	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
919	+	l.add(new NPETask());
920	+	e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
921	+	} catch(ExecutionException success) {
922	+	} catch(Exception ex) {
923	+	unexpectedException();
924	+	} finally {
925	+	joinPool(e);
926	+	}
927	+	}
928	+
929	+	/**
930	+	* timed invokeAny(c) returns result of some task
931	+	*/
932	+	public void testTimedInvokeAny5() {
933	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
934	+	try {
935	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
936	+	l.add(new StringTask());
937	+	l.add(new StringTask());
938	+	String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
939	+	assertSame(TEST_STRING, result);
940	+	} catch (ExecutionException success) {
941	+	} catch(Exception ex) {
942	+	unexpectedException();
943	+	} finally {
944	+	joinPool(e);
945	+	}
946	+	}
947	+
948	+	/**
949	+	* timed invokeAll(null) throws NPE
950	+	*/
951	+	public void testTimedInvokeAll1() {
952	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
953	+	try {
954	+	e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
955	+	} catch (NullPointerException success) {
956	+	} catch(Exception ex) {
957	+	unexpectedException();
958	+	} finally {
959	+	joinPool(e);
960	+	}
961	+	}
962	+
963	+	/**
964	+	* timed invokeAll(,,null) throws NPE
965	+	*/
966	+	public void testTimedInvokeAllNullTimeUnit() {
967	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
968	+	try {
969	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
970	+	l.add(new StringTask());
971	+	e.invokeAll(l, MEDIUM_DELAY_MS, null);
972	+	} catch (NullPointerException success) {
973	+	} catch(Exception ex) {
974	+	unexpectedException();
975	+	} finally {
976	+	joinPool(e);
977	+	}
978	+	}
979	+
980	+	/**
981	+	* timed invokeAll(empty collection) returns empty collection
982	+	*/
983	+	public void testTimedInvokeAll2() {
984	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
985	+	try {
986	+	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
987	+	assertTrue(r.isEmpty());
988	+	} catch(Exception ex) {
989	+	unexpectedException();
990	+	} finally {
991	+	joinPool(e);
992	+	}
993	+	}
994	+
995	+	/**
996	+	* timed invokeAll(c) throws NPE if c has null elements
997	+	*/
998	+	public void testTimedInvokeAll3() {
999	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
1000	+	try {
1001	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1002	+	l.add(new StringTask());
1003	+	l.add(null);
1004	+	e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1005	+	} catch (NullPointerException success) {
1006	+	} catch(Exception ex) {
1007	+	unexpectedException();
1008	+	} finally {
1009	+	joinPool(e);
1010	+	}
1011	+	}
1012	+
1013	+	/**
1014	+	* get of element of invokeAll(c) throws exception on failed task
1015	+	*/
1016	+	public void testTimedInvokeAll4() {
1017	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
1018	+	try {
1019	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1020	+	l.add(new NPETask());
1021	+	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1022	+	assertEquals(1, result.size());
1023	+	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1024	+	it.next().get();
1025	+	} catch(ExecutionException success) {
1026	+	} catch(Exception ex) {
1027	+	unexpectedException();
1028	+	} finally {
1029	+	joinPool(e);
1030	+	}
1031	+	}
1032	+
1033	+	/**
1034	+	* timed invokeAll(c) returns results of all completed tasks
1035	+	*/
1036	+	public void testTimedInvokeAll5() {
1037	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
1038	+	try {
1039	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1040	+	l.add(new StringTask());
1041	+	l.add(new StringTask());
1042	+	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1043	+	assertEquals(2, result.size());
1044	+	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1045	+	assertSame(TEST_STRING, it.next().get());
1046	+	} catch (ExecutionException success) {
1047	+	} catch(Exception ex) {
1048	+	unexpectedException();
1049	+	} finally {
1050	+	joinPool(e);
1051	+	}
1052	+	}
1053	+
1054	+	/**
1055	+	* timed invokeAll(c) cancels tasks not completed by timeout
1056	+	*/
1057	+	public void testTimedInvokeAll6() {
1058	+	ExecutorService e = new ScheduledThreadPoolExecutor(2);
1059	+	try {
1060	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1061	+	l.add(new StringTask());
1062	+	l.add(Executors.callable(new MediumInterruptedRunnable(), TEST_STRING));
1063	+	List<Future<String>> result = e.invokeAll(l, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
1064	+	assertEquals(2, result.size());
1065	+	Iterator<Future<String>> it = result.iterator();
1066	+	Future<String> f1 = it.next();
1067	+	Future<String> f2 = it.next();
1068	+	assertTrue(f1.isDone());
1069	+	assertFalse(f1.isCancelled());
1070	+	assertTrue(f2.isDone());
1071	+	assertTrue(f2.isCancelled());
1072	+	} catch(Exception ex) {
1073	+	unexpectedException();
1074	+	} finally {
1075	+	joinPool(e);
1076	+	}
1077	+	}
1078	+
1079
1080		}

Diff Legend

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