ViewVC Help

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

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

Comparing jsr166/src/test/tck/TreeSubMapTest.java (file contents):
Revision 1.2 by dl, Wed Apr 19 15:10:54 2006 UTC vs.
Revision 1.4 by jsr166, Mon Nov 2 20:28:32 2009 UTC

#	Line 11 | Line 11 | import java.io.*;
11
12		public class TreeSubMapTest extends JSR166TestCase {
13		public static void main(String[] args) {
14	<	junit.textui.TestRunner.run (suite());
14	>	junit.textui.TestRunner.run (suite());
15		}
16		public static Test suite() {
17		return new TestSuite(TreeSubMapTest.class);
#	Line 20 | Line 20 | public class TreeSubMapTest extends JSR1
20		/**
21		* Create a map from Integers 1-5 to Strings "A"-"E".
22		*/
23	<	private static NavigableMap map5() {
23	>	private static NavigableMap map5() {
24		TreeMap map = new TreeMap();
25		assertTrue(map.isEmpty());
26		map.put(zero, "Z");
#	Line 32 | Line 32 | public class TreeSubMapTest extends JSR1
32		map.put(seven, "F");
33		assertFalse(map.isEmpty());
34		assertEquals(7, map.size());
35	<	return map.navigableSubMap(one, true, seven, false);
35	>	return map.subMap(one, true, seven, false);
36		}
37
38	<	private static NavigableMap map0() {
38	>	private static NavigableMap map0() {
39		TreeMap map = new TreeMap();
40		assertTrue(map.isEmpty());
41	<	return map.navigableTailMap(one, true);
41	>	return map.tailMap(one, true);
42	>	}
43	>
44	>	/**
45	>	* Create a map from Integers -5 to -1 to Strings "A"-"E".
46	>	*/
47	>	private static NavigableMap dmap5() {
48	>	TreeMap map = new TreeMap();
49	>	assertTrue(map.isEmpty());
50	>	map.put(m1, "A");
51	>	map.put(m5, "E");
52	>	map.put(m3, "C");
53	>	map.put(m2, "B");
54	>	map.put(m4, "D");
55	>	assertFalse(map.isEmpty());
56	>	assertEquals(5, map.size());
57	>	return map.descendingMap();
58	>	}
59	>
60	>	private static NavigableMap dmap0() {
61	>	TreeMap map = new TreeMap();
62	>	assertTrue(map.isEmpty());
63	>	return map;
64		}
65
66		/**
#	Line 174 | Line 196 | public class TreeSubMapTest extends JSR1
196		Iterator it = s.iterator();
197		while (it.hasNext()) {
198		Map.Entry e = (Map.Entry) it.next();
199	<	assertTrue(
199	>	assertTrue(
200		(e.getKey().equals(one) && e.getValue().equals("A")) ||
201		(e.getKey().equals(two) && e.getValue().equals("B")) ||
202		(e.getKey().equals(three) && e.getValue().equals("C")) ||
#	Line 362 | Line 384 | public class TreeSubMapTest extends JSR1
384		for (int i = 1; i <= 5; ++i) {
385		assertTrue(s.indexOf(String.valueOf(i)) >= 0);
386		}
387	<	}
387	>	}
388
389		// Exception tests
390
#	Line 571 | Line 593 | public class TreeSubMapTest extends JSR1
593		assertEquals(3, sm.size());
594		assertEquals(4, map.size());
595		}
596	<
596	>
597	>	/**
598	>	*  clear removes all pairs
599	>	*/
600	>	public void testDescendingClear() {
601	>	NavigableMap map = dmap5();
602	>	map.clear();
603	>	assertEquals(map.size(), 0);
604	>	}
605	>
606	>
607	>	/**
608	>	*  Maps with same contents are equal
609	>	*/
610	>	public void testDescendingEquals() {
611	>	NavigableMap map1 = dmap5();
612	>	NavigableMap map2 = dmap5();
613	>	assertEquals(map1, map2);
614	>	assertEquals(map2, map1);
615	>	map1.clear();
616	>	assertFalse(map1.equals(map2));
617	>	assertFalse(map2.equals(map1));
618	>	}
619	>
620	>	/**
621	>	*  containsKey returns true for contained key
622	>	*/
623	>	public void testDescendingContainsKey() {
624	>	NavigableMap map = dmap5();
625	>	assertTrue(map.containsKey(m1));
626	>	assertFalse(map.containsKey(zero));
627	>	}
628	>
629	>	/**
630	>	*  containsValue returns true for held values
631	>	*/
632	>	public void testDescendingContainsValue() {
633	>	NavigableMap map = dmap5();
634	>	assertTrue(map.containsValue("A"));
635	>	assertFalse(map.containsValue("Z"));
636	>	}
637	>
638	>	/**
639	>	*  get returns the correct element at the given key,
640	>	*  or null if not present
641	>	*/
642	>	public void testDescendingGet() {
643	>	NavigableMap map = dmap5();
644	>	assertEquals("A", (String)map.get(m1));
645	>	NavigableMap empty = dmap0();
646	>	assertNull(empty.get(m1));
647	>	}
648	>
649	>	/**
650	>	*  isEmpty is true of empty map and false for non-empty
651	>	*/
652	>	public void testDescendingIsEmpty() {
653	>	NavigableMap empty = dmap0();
654	>	NavigableMap map = dmap5();
655	>	assertTrue(empty.isEmpty());
656	>	assertFalse(map.isEmpty());
657	>	}
658	>
659	>	/**
660	>	*   firstKey returns first key
661	>	*/
662	>	public void testDescendingFirstKey() {
663	>	NavigableMap map = dmap5();
664	>	assertEquals(m1, map.firstKey());
665	>	}
666	>
667	>	/**
668	>	*   lastKey returns last key
669	>	*/
670	>	public void testDescendingLastKey() {
671	>	NavigableMap map = dmap5();
672	>	assertEquals(m5, map.lastKey());
673	>	}
674	>
675	>
676	>	/**
677	>	*   keySet returns a Set containing all the keys
678	>	*/
679	>	public void testDescendingKeySet() {
680	>	NavigableMap map = dmap5();
681	>	Set s = map.keySet();
682	>	assertEquals(5, s.size());
683	>	assertTrue(s.contains(m1));
684	>	assertTrue(s.contains(m2));
685	>	assertTrue(s.contains(m3));
686	>	assertTrue(s.contains(m4));
687	>	assertTrue(s.contains(m5));
688	>	}
689	>
690	>	/**
691	>	*   keySet is ordered
692	>	*/
693	>	public void testDescendingKeySetOrder() {
694	>	NavigableMap map = dmap5();
695	>	Set s = map.keySet();
696	>	Iterator i = s.iterator();
697	>	Integer last = (Integer)i.next();
698	>	assertEquals(last, m1);
699	>	while (i.hasNext()) {
700	>	Integer k = (Integer)i.next();
701	>	assertTrue(last.compareTo(k) > 0);
702	>	last = k;
703	>	}
704	>	}
705	>
706	>	/**
707	>	* values collection contains all values
708	>	*/
709	>	public void testDescendingValues() {
710	>	NavigableMap map = dmap5();
711	>	Collection s = map.values();
712	>	assertEquals(5, s.size());
713	>	assertTrue(s.contains("A"));
714	>	assertTrue(s.contains("B"));
715	>	assertTrue(s.contains("C"));
716	>	assertTrue(s.contains("D"));
717	>	assertTrue(s.contains("E"));
718	>	}
719	>
720	>	/**
721	>	*  keySet.toArray returns contains all keys
722	>	*/
723	>	public void testDescendingAscendingKeySetToArray() {
724	>	NavigableMap map = dmap5();
725	>	Set s = map.keySet();
726	>	Object[] ar = s.toArray();
727	>	assertTrue(s.containsAll(Arrays.asList(ar)));
728	>	assertEquals(5, ar.length);
729	>	ar[0] = m10;
730	>	assertFalse(s.containsAll(Arrays.asList(ar)));
731	>	}
732	>
733	>	/**
734	>	*  descendingkeySet.toArray returns contains all keys
735	>	*/
736	>	public void testDescendingDescendingKeySetToArray() {
737	>	NavigableMap map = dmap5();
738	>	Set s = map.descendingKeySet();
739	>	Object[] ar = s.toArray();
740	>	assertEquals(5, ar.length);
741	>	assertTrue(s.containsAll(Arrays.asList(ar)));
742	>	ar[0] = m10;
743	>	assertFalse(s.containsAll(Arrays.asList(ar)));
744	>	}
745	>
746	>	/**
747	>	*  Values.toArray contains all values
748	>	*/
749	>	public void testDescendingValuesToArray() {
750	>	NavigableMap map = dmap5();
751	>	Collection v = map.values();
752	>	Object[] ar = v.toArray();
753	>	ArrayList s = new ArrayList(Arrays.asList(ar));
754	>	assertEquals(5, ar.length);
755	>	assertTrue(s.contains("A"));
756	>	assertTrue(s.contains("B"));
757	>	assertTrue(s.contains("C"));
758	>	assertTrue(s.contains("D"));
759	>	assertTrue(s.contains("E"));
760	>	}
761	>
762	>
763	>	/**
764	>	* entrySet contains all pairs
765	>	*/
766	>	public void testDescendingEntrySet() {
767	>	NavigableMap map = dmap5();
768	>	Set s = map.entrySet();
769	>	assertEquals(5, s.size());
770	>	Iterator it = s.iterator();
771	>	while (it.hasNext()) {
772	>	Map.Entry e = (Map.Entry) it.next();
773	>	assertTrue(
774	>	(e.getKey().equals(m1) && e.getValue().equals("A")) ||
775	>	(e.getKey().equals(m2) && e.getValue().equals("B")) ||
776	>	(e.getKey().equals(m3) && e.getValue().equals("C")) ||
777	>	(e.getKey().equals(m4) && e.getValue().equals("D")) ||
778	>	(e.getKey().equals(m5) && e.getValue().equals("E")));
779	>	}
780	>	}
781	>
782	>	/**
783	>	*   putAll  adds all key-value pairs from the given map
784	>	*/
785	>	public void testDescendingPutAll() {
786	>	NavigableMap empty = dmap0();
787	>	NavigableMap map = dmap5();
788	>	empty.putAll(map);
789	>	assertEquals(5, empty.size());
790	>	assertTrue(empty.containsKey(m1));
791	>	assertTrue(empty.containsKey(m2));
792	>	assertTrue(empty.containsKey(m3));
793	>	assertTrue(empty.containsKey(m4));
794	>	assertTrue(empty.containsKey(m5));
795	>	}
796	>
797	>
798	>	/**
799	>	*   remove removes the correct key-value pair from the map
800	>	*/
801	>	public void testDescendingRemove() {
802	>	NavigableMap map = dmap5();
803	>	map.remove(m5);
804	>	assertEquals(4, map.size());
805	>	assertFalse(map.containsKey(m5));
806	>	}
807	>
808	>	/**
809	>	* lowerEntry returns preceding entry.
810	>	*/
811	>	public void testDescendingLowerEntry() {
812	>	NavigableMap map = dmap5();
813	>	Map.Entry e1 = map.lowerEntry(m3);
814	>	assertEquals(m2, e1.getKey());
815	>
816	>	Map.Entry e2 = map.lowerEntry(m6);
817	>	assertEquals(m5, e2.getKey());
818	>
819	>	Map.Entry e3 = map.lowerEntry(m1);
820	>	assertNull(e3);
821	>
822	>	Map.Entry e4 = map.lowerEntry(zero);
823	>	assertNull(e4);
824	>
825	>	}
826	>
827	>	/**
828	>	* higherEntry returns next entry.
829	>	*/
830	>	public void testDescendingHigherEntry() {
831	>	NavigableMap map = dmap5();
832	>	Map.Entry e1 = map.higherEntry(m3);
833	>	assertEquals(m4, e1.getKey());
834	>
835	>	Map.Entry e2 = map.higherEntry(zero);
836	>	assertEquals(m1, e2.getKey());
837	>
838	>	Map.Entry e3 = map.higherEntry(m5);
839	>	assertNull(e3);
840	>
841	>	Map.Entry e4 = map.higherEntry(m6);
842	>	assertNull(e4);
843	>
844	>	}
845	>
846	>	/**
847	>	* floorEntry returns preceding entry.
848	>	*/
849	>	public void testDescendingFloorEntry() {
850	>	NavigableMap map = dmap5();
851	>	Map.Entry e1 = map.floorEntry(m3);
852	>	assertEquals(m3, e1.getKey());
853	>
854	>	Map.Entry e2 = map.floorEntry(m6);
855	>	assertEquals(m5, e2.getKey());
856	>
857	>	Map.Entry e3 = map.floorEntry(m1);
858	>	assertEquals(m1, e3.getKey());
859	>
860	>	Map.Entry e4 = map.floorEntry(zero);
861	>	assertNull(e4);
862	>
863	>	}
864	>
865	>	/**
866	>	* ceilingEntry returns next entry.
867	>	*/
868	>	public void testDescendingCeilingEntry() {
869	>	NavigableMap map = dmap5();
870	>	Map.Entry e1 = map.ceilingEntry(m3);
871	>	assertEquals(m3, e1.getKey());
872	>
873	>	Map.Entry e2 = map.ceilingEntry(zero);
874	>	assertEquals(m1, e2.getKey());
875	>
876	>	Map.Entry e3 = map.ceilingEntry(m5);
877	>	assertEquals(m5, e3.getKey());
878	>
879	>	Map.Entry e4 = map.ceilingEntry(m6);
880	>	assertNull(e4);
881	>
882	>	}
883	>
884	>	/**
885	>	* pollFirstEntry returns entries in order
886	>	*/
887	>	public void testDescendingPollFirstEntry() {
888	>	NavigableMap map = dmap5();
889	>	Map.Entry e = map.pollFirstEntry();
890	>	assertEquals(m1, e.getKey());
891	>	assertEquals("A", e.getValue());
892	>	e = map.pollFirstEntry();
893	>	assertEquals(m2, e.getKey());
894	>	map.put(m1, "A");
895	>	e = map.pollFirstEntry();
896	>	assertEquals(m1, e.getKey());
897	>	assertEquals("A", e.getValue());
898	>	e = map.pollFirstEntry();
899	>	assertEquals(m3, e.getKey());
900	>	map.remove(m4);
901	>	e = map.pollFirstEntry();
902	>	assertEquals(m5, e.getKey());
903	>	try {
904	>	e.setValue("A");
905	>	shouldThrow();
906	>	} catch (Exception ok) {
907	>	}
908	>	e = map.pollFirstEntry();
909	>	assertNull(e);
910	>	}
911	>
912	>	/**
913	>	* pollLastEntry returns entries in order
914	>	*/
915	>	public void testDescendingPollLastEntry() {
916	>	NavigableMap map = dmap5();
917	>	Map.Entry e = map.pollLastEntry();
918	>	assertEquals(m5, e.getKey());
919	>	assertEquals("E", e.getValue());
920	>	e = map.pollLastEntry();
921	>	assertEquals(m4, e.getKey());
922	>	map.put(m5, "E");
923	>	e = map.pollLastEntry();
924	>	assertEquals(m5, e.getKey());
925	>	assertEquals("E", e.getValue());
926	>	e = map.pollLastEntry();
927	>	assertEquals(m3, e.getKey());
928	>	map.remove(m2);
929	>	e = map.pollLastEntry();
930	>	assertEquals(m1, e.getKey());
931	>	try {
932	>	e.setValue("E");
933	>	shouldThrow();
934	>	} catch (Exception ok) {
935	>	}
936	>	e = map.pollLastEntry();
937	>	assertNull(e);
938	>	}
939	>
940	>	/**
941	>	*   size returns the correct values
942	>	*/
943	>	public void testDescendingSize() {
944	>	NavigableMap map = dmap5();
945	>	NavigableMap empty = dmap0();
946	>	assertEquals(0, empty.size());
947	>	assertEquals(5, map.size());
948	>	}
949	>
950	>	/**
951	>	* toString contains toString of elements
952	>	*/
953	>	public void testDescendingToString() {
954	>	NavigableMap map = dmap5();
955	>	String s = map.toString();
956	>	for (int i = 1; i <= 5; ++i) {
957	>	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
958	>	}
959	>	}
960	>
961	>	// Exception testDescendings
962	>
963	>	/**
964	>	* get(null) of nonempty map throws NPE
965	>	*/
966	>	public void testDescendingGet_NullPointerException() {
967	>	try {
968	>	NavigableMap c = dmap5();
969	>	c.get(null);
970	>	shouldThrow();
971	>	} catch(NullPointerException e){}
972	>	}
973	>
974	>	/**
975	>	* put(null,x) throws NPE
976	>	*/
977	>	public void testDescendingPut1_NullPointerException() {
978	>	try {
979	>	NavigableMap c = dmap5();
980	>	c.put(null, "whatever");
981	>	shouldThrow();
982	>	} catch(NullPointerException e){}
983	>	}
984	>
985	>	/**
986	>	* A deserialized map equals original
987	>	*/
988	>	public void testDescendingSerialization() {
989	>	NavigableMap q = dmap5();
990	>
991	>	try {
992	>	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
993	>	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
994	>	out.writeObject(q);
995	>	out.close();
996	>
997	>	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
998	>	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
999	>	NavigableMap r = (NavigableMap)in.readObject();
1000	>	assertEquals(q.size(), r.size());
1001	>	assertTrue(q.equals(r));
1002	>	assertTrue(r.equals(q));
1003	>	} catch(Exception e){
1004	>	e.printStackTrace();
1005	>	unexpectedException();
1006	>	}
1007	>	}
1008	>
1009	>
1010	>
1011	>	/**
1012	>	* subMap returns map with keys in requested range
1013	>	*/
1014	>	public void testDescendingSubMapContents() {
1015	>	NavigableMap map = dmap5();
1016	>	SortedMap sm = map.subMap(m2, m4);
1017	>	assertEquals(m2, sm.firstKey());
1018	>	assertEquals(m3, sm.lastKey());
1019	>	assertEquals(2, sm.size());
1020	>	assertFalse(sm.containsKey(m1));
1021	>	assertTrue(sm.containsKey(m2));
1022	>	assertTrue(sm.containsKey(m3));
1023	>	assertFalse(sm.containsKey(m4));
1024	>	assertFalse(sm.containsKey(m5));
1025	>	Iterator i = sm.keySet().iterator();
1026	>	Object k;
1027	>	k = (Integer)(i.next());
1028	>	assertEquals(m2, k);
1029	>	k = (Integer)(i.next());
1030	>	assertEquals(m3, k);
1031	>	assertFalse(i.hasNext());
1032	>	Iterator j = sm.keySet().iterator();
1033	>	j.next();
1034	>	j.remove();
1035	>	assertFalse(map.containsKey(m2));
1036	>	assertEquals(4, map.size());
1037	>	assertEquals(1, sm.size());
1038	>	assertEquals(m3, sm.firstKey());
1039	>	assertEquals(m3, sm.lastKey());
1040	>	assertTrue(sm.remove(m3) != null);
1041	>	assertTrue(sm.isEmpty());
1042	>	assertEquals(3, map.size());
1043	>	}
1044	>
1045	>	public void testDescendingSubMapContents2() {
1046	>	NavigableMap map = dmap5();
1047	>	SortedMap sm = map.subMap(m2, m3);
1048	>	assertEquals(1, sm.size());
1049	>	assertEquals(m2, sm.firstKey());
1050	>	assertEquals(m2, sm.lastKey());
1051	>	assertFalse(sm.containsKey(m1));
1052	>	assertTrue(sm.containsKey(m2));
1053	>	assertFalse(sm.containsKey(m3));
1054	>	assertFalse(sm.containsKey(m4));
1055	>	assertFalse(sm.containsKey(m5));
1056	>	Iterator i = sm.keySet().iterator();
1057	>	Object k;
1058	>	k = (Integer)(i.next());
1059	>	assertEquals(m2, k);
1060	>	assertFalse(i.hasNext());
1061	>	Iterator j = sm.keySet().iterator();
1062	>	j.next();
1063	>	j.remove();
1064	>	assertFalse(map.containsKey(m2));
1065	>	assertEquals(4, map.size());
1066	>	assertEquals(0, sm.size());
1067	>	assertTrue(sm.isEmpty());
1068	>	assertTrue(sm.remove(m3) == null);
1069	>	assertEquals(4, map.size());
1070	>	}
1071	>
1072	>	/**
1073	>	* headMap returns map with keys in requested range
1074	>	*/
1075	>	public void testDescendingHeadMapContents() {
1076	>	NavigableMap map = dmap5();
1077	>	SortedMap sm = map.headMap(m4);
1078	>	assertTrue(sm.containsKey(m1));
1079	>	assertTrue(sm.containsKey(m2));
1080	>	assertTrue(sm.containsKey(m3));
1081	>	assertFalse(sm.containsKey(m4));
1082	>	assertFalse(sm.containsKey(m5));
1083	>	Iterator i = sm.keySet().iterator();
1084	>	Object k;
1085	>	k = (Integer)(i.next());
1086	>	assertEquals(m1, k);
1087	>	k = (Integer)(i.next());
1088	>	assertEquals(m2, k);
1089	>	k = (Integer)(i.next());
1090	>	assertEquals(m3, k);
1091	>	assertFalse(i.hasNext());
1092	>	sm.clear();
1093	>	assertTrue(sm.isEmpty());
1094	>	assertEquals(2, map.size());
1095	>	assertEquals(m4, map.firstKey());
1096	>	}
1097	>
1098	>	/**
1099	>	* headMap returns map with keys in requested range
1100	>	*/
1101	>	public void testDescendingTailMapContents() {
1102	>	NavigableMap map = dmap5();
1103	>	SortedMap sm = map.tailMap(m2);
1104	>	assertFalse(sm.containsKey(m1));
1105	>	assertTrue(sm.containsKey(m2));
1106	>	assertTrue(sm.containsKey(m3));
1107	>	assertTrue(sm.containsKey(m4));
1108	>	assertTrue(sm.containsKey(m5));
1109	>	Iterator i = sm.keySet().iterator();
1110	>	Object k;
1111	>	k = (Integer)(i.next());
1112	>	assertEquals(m2, k);
1113	>	k = (Integer)(i.next());
1114	>	assertEquals(m3, k);
1115	>	k = (Integer)(i.next());
1116	>	assertEquals(m4, k);
1117	>	k = (Integer)(i.next());
1118	>	assertEquals(m5, k);
1119	>	assertFalse(i.hasNext());
1120	>
1121	>	Iterator ei = sm.entrySet().iterator();
1122	>	Map.Entry e;
1123	>	e = (Map.Entry)(ei.next());
1124	>	assertEquals(m2, e.getKey());
1125	>	assertEquals("B", e.getValue());
1126	>	e = (Map.Entry)(ei.next());
1127	>	assertEquals(m3, e.getKey());
1128	>	assertEquals("C", e.getValue());
1129	>	e = (Map.Entry)(ei.next());
1130	>	assertEquals(m4, e.getKey());
1131	>	assertEquals("D", e.getValue());
1132	>	e = (Map.Entry)(ei.next());
1133	>	assertEquals(m5, e.getKey());
1134	>	assertEquals("E", e.getValue());
1135	>	assertFalse(i.hasNext());
1136	>
1137	>	SortedMap ssm = sm.tailMap(m4);
1138	>	assertEquals(m4, ssm.firstKey());
1139	>	assertEquals(m5, ssm.lastKey());
1140	>	assertTrue(ssm.remove(m4) != null);
1141	>	assertEquals(1, ssm.size());
1142	>	assertEquals(3, sm.size());
1143	>	assertEquals(4, map.size());
1144	>	}
1145	>
1146		}

Diff Legend

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