ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ConcurrentSkipListSubMapTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ConcurrentSkipListSubMapTest.java (file contents):
Revision 1.8 by jsr166, Mon Nov 16 05:30:07 2009 UTC vs.
Revision 1.9 by jsr166, Sat Nov 21 02:07:26 2009 UTC

# Line 11 | Line 11 | import java.io.*;
11  
12   public class ConcurrentSkipListSubMapTest 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(ConcurrentSkipListSubMapTest.class);
17 >        return new TestSuite(ConcurrentSkipListSubMapTest.class);
18      }
19  
20      /**
21       * Create a map from Integers 1-5 to Strings "A"-"E".
22       */
23      private static ConcurrentNavigableMap map5() {
24 <        ConcurrentSkipListMap map = new ConcurrentSkipListMap();
24 >        ConcurrentSkipListMap map = new ConcurrentSkipListMap();
25          assertTrue(map.isEmpty());
26 <        map.put(zero, "Z");
27 <        map.put(one, "A");
28 <        map.put(five, "E");
29 <        map.put(three, "C");
30 <        map.put(two, "B");
31 <        map.put(four, "D");
32 <        map.put(seven, "F");
26 >        map.put(zero, "Z");
27 >        map.put(one, "A");
28 >        map.put(five, "E");
29 >        map.put(three, "C");
30 >        map.put(two, "B");
31 >        map.put(four, "D");
32 >        map.put(seven, "F");
33          assertFalse(map.isEmpty());
34          assertEquals(7, map.size());
35          return map.subMap(one, true, seven, false);
# Line 39 | Line 39 | public class ConcurrentSkipListSubMapTes
39       * Create a map from Integers -5 to -1 to Strings "A"-"E".
40       */
41      private static ConcurrentNavigableMap dmap5() {
42 <        ConcurrentSkipListMap map = new ConcurrentSkipListMap();
42 >        ConcurrentSkipListMap map = new ConcurrentSkipListMap();
43          assertTrue(map.isEmpty());
44 <        map.put(m1, "A");
45 <        map.put(m5, "E");
46 <        map.put(m3, "C");
47 <        map.put(m2, "B");
48 <        map.put(m4, "D");
44 >        map.put(m1, "A");
45 >        map.put(m5, "E");
46 >        map.put(m3, "C");
47 >        map.put(m2, "B");
48 >        map.put(m4, "D");
49          assertFalse(map.isEmpty());
50          assertEquals(5, map.size());
51 <        return map.descendingMap();
51 >        return map.descendingMap();
52      }
53  
54      private static ConcurrentNavigableMap map0() {
55 <        ConcurrentSkipListMap map = new ConcurrentSkipListMap();
55 >        ConcurrentSkipListMap map = new ConcurrentSkipListMap();
56          assertTrue(map.isEmpty());
57          return map.tailMap(one, true);
58      }
59  
60      private static ConcurrentNavigableMap dmap0() {
61 <        ConcurrentSkipListMap map = new ConcurrentSkipListMap();
61 >        ConcurrentSkipListMap map = new ConcurrentSkipListMap();
62          assertTrue(map.isEmpty());
63          return map;
64      }
# Line 68 | Line 68 | public class ConcurrentSkipListSubMapTes
68       */
69      public void testClear() {
70          ConcurrentNavigableMap map = map5();
71 <        map.clear();
72 <        assertEquals(map.size(), 0);
71 >        map.clear();
72 >        assertEquals(map.size(), 0);
73      }
74  
75  
# Line 81 | Line 81 | public class ConcurrentSkipListSubMapTes
81          ConcurrentNavigableMap map2 = map5();
82          assertEquals(map1, map2);
83          assertEquals(map2, map1);
84 <        map1.clear();
84 >        map1.clear();
85          assertFalse(map1.equals(map2));
86          assertFalse(map2.equals(map1));
87      }
# Line 91 | Line 91 | public class ConcurrentSkipListSubMapTes
91       */
92      public void testContainsKey() {
93          ConcurrentNavigableMap map = map5();
94 <        assertTrue(map.containsKey(one));
94 >        assertTrue(map.containsKey(one));
95          assertFalse(map.containsKey(zero));
96      }
97  
# Line 100 | Line 100 | public class ConcurrentSkipListSubMapTes
100       */
101      public void testContainsValue() {
102          ConcurrentNavigableMap map = map5();
103 <        assertTrue(map.containsValue("A"));
103 >        assertTrue(map.containsValue("A"));
104          assertFalse(map.containsValue("Z"));
105      }
106  
# Line 110 | Line 110 | public class ConcurrentSkipListSubMapTes
110       */
111      public void testGet() {
112          ConcurrentNavigableMap map = map5();
113 <        assertEquals("A", (String)map.get(one));
113 >        assertEquals("A", (String)map.get(one));
114          ConcurrentNavigableMap empty = map0();
115          assertNull(empty.get(one));
116      }
# Line 121 | Line 121 | public class ConcurrentSkipListSubMapTes
121      public void testIsEmpty() {
122          ConcurrentNavigableMap empty = map0();
123          ConcurrentNavigableMap map = map5();
124 <        assertTrue(empty.isEmpty());
124 >        assertTrue(empty.isEmpty());
125          assertFalse(map.isEmpty());
126      }
127  
# Line 130 | Line 130 | public class ConcurrentSkipListSubMapTes
130       */
131      public void testFirstKey() {
132          ConcurrentNavigableMap map = map5();
133 <        assertEquals(one, map.firstKey());
133 >        assertEquals(one, map.firstKey());
134      }
135  
136      /**
# Line 138 | Line 138 | public class ConcurrentSkipListSubMapTes
138       */
139      public void testLastKey() {
140          ConcurrentNavigableMap map = map5();
141 <        assertEquals(five, map.lastKey());
141 >        assertEquals(five, map.lastKey());
142      }
143  
144  
# Line 147 | Line 147 | public class ConcurrentSkipListSubMapTes
147       */
148      public void testKeySet() {
149          ConcurrentNavigableMap map = map5();
150 <        Set s = map.keySet();
151 <        assertEquals(5, s.size());
152 <        assertTrue(s.contains(one));
153 <        assertTrue(s.contains(two));
154 <        assertTrue(s.contains(three));
155 <        assertTrue(s.contains(four));
156 <        assertTrue(s.contains(five));
150 >        Set s = map.keySet();
151 >        assertEquals(5, s.size());
152 >        assertTrue(s.contains(one));
153 >        assertTrue(s.contains(two));
154 >        assertTrue(s.contains(three));
155 >        assertTrue(s.contains(four));
156 >        assertTrue(s.contains(five));
157      }
158  
159      /**
# Line 161 | Line 161 | public class ConcurrentSkipListSubMapTes
161       */
162      public void testKeySetOrder() {
163          ConcurrentNavigableMap map = map5();
164 <        Set s = map.keySet();
164 >        Set s = map.keySet();
165          Iterator i = s.iterator();
166          Integer last = (Integer)i.next();
167          assertEquals(last, one);
# Line 177 | Line 177 | public class ConcurrentSkipListSubMapTes
177       */
178      public void testValues() {
179          ConcurrentNavigableMap map = map5();
180 <        Collection s = map.values();
181 <        assertEquals(5, s.size());
182 <        assertTrue(s.contains("A"));
183 <        assertTrue(s.contains("B"));
184 <        assertTrue(s.contains("C"));
185 <        assertTrue(s.contains("D"));
186 <        assertTrue(s.contains("E"));
180 >        Collection s = map.values();
181 >        assertEquals(5, s.size());
182 >        assertTrue(s.contains("A"));
183 >        assertTrue(s.contains("B"));
184 >        assertTrue(s.contains("C"));
185 >        assertTrue(s.contains("D"));
186 >        assertTrue(s.contains("E"));
187      }
188  
189      /**
# Line 191 | Line 191 | public class ConcurrentSkipListSubMapTes
191       */
192      public void testKeySetToArray() {
193          ConcurrentNavigableMap map = map5();
194 <        Set s = map.keySet();
194 >        Set s = map.keySet();
195          Object[] ar = s.toArray();
196          assertTrue(s.containsAll(Arrays.asList(ar)));
197 <        assertEquals(5, ar.length);
197 >        assertEquals(5, ar.length);
198          ar[0] = m10;
199          assertFalse(s.containsAll(Arrays.asList(ar)));
200      }
# Line 204 | Line 204 | public class ConcurrentSkipListSubMapTes
204       */
205      public void testDescendingKeySetToArray() {
206          ConcurrentNavigableMap map = map5();
207 <        Set s = map.descendingKeySet();
207 >        Set s = map.descendingKeySet();
208          Object[] ar = s.toArray();
209 <        assertEquals(5, ar.length);
209 >        assertEquals(5, ar.length);
210          assertTrue(s.containsAll(Arrays.asList(ar)));
211          ar[0] = m10;
212          assertFalse(s.containsAll(Arrays.asList(ar)));
# Line 217 | Line 217 | public class ConcurrentSkipListSubMapTes
217       */
218      public void testValuesToArray() {
219          ConcurrentNavigableMap map = map5();
220 <        Collection v = map.values();
220 >        Collection v = map.values();
221          Object[] ar = v.toArray();
222          ArrayList s = new ArrayList(Arrays.asList(ar));
223 <        assertEquals(5, ar.length);
224 <        assertTrue(s.contains("A"));
225 <        assertTrue(s.contains("B"));
226 <        assertTrue(s.contains("C"));
227 <        assertTrue(s.contains("D"));
228 <        assertTrue(s.contains("E"));
223 >        assertEquals(5, ar.length);
224 >        assertTrue(s.contains("A"));
225 >        assertTrue(s.contains("B"));
226 >        assertTrue(s.contains("C"));
227 >        assertTrue(s.contains("D"));
228 >        assertTrue(s.contains("E"));
229      }
230  
231  
# Line 234 | Line 234 | public class ConcurrentSkipListSubMapTes
234       */
235      public void testEntrySet() {
236          ConcurrentNavigableMap map = map5();
237 <        Set s = map.entrySet();
238 <        assertEquals(5, s.size());
237 >        Set s = map.entrySet();
238 >        assertEquals(5, s.size());
239          Iterator it = s.iterator();
240          while (it.hasNext()) {
241              Map.Entry e = (Map.Entry) it.next();
# Line 254 | Line 254 | public class ConcurrentSkipListSubMapTes
254      public void testPutAll() {
255          ConcurrentNavigableMap empty = map0();
256          ConcurrentNavigableMap map = map5();
257 <        empty.putAll(map);
258 <        assertEquals(5, empty.size());
259 <        assertTrue(empty.containsKey(one));
260 <        assertTrue(empty.containsKey(two));
261 <        assertTrue(empty.containsKey(three));
262 <        assertTrue(empty.containsKey(four));
263 <        assertTrue(empty.containsKey(five));
257 >        empty.putAll(map);
258 >        assertEquals(5, empty.size());
259 >        assertTrue(empty.containsKey(one));
260 >        assertTrue(empty.containsKey(two));
261 >        assertTrue(empty.containsKey(three));
262 >        assertTrue(empty.containsKey(four));
263 >        assertTrue(empty.containsKey(five));
264      }
265  
266      /**
# Line 268 | Line 268 | public class ConcurrentSkipListSubMapTes
268       */
269      public void testPutIfAbsent() {
270          ConcurrentNavigableMap map = map5();
271 <        map.putIfAbsent(six, "Z");
271 >        map.putIfAbsent(six, "Z");
272          assertTrue(map.containsKey(six));
273      }
274  
# Line 285 | Line 285 | public class ConcurrentSkipListSubMapTes
285       */
286      public void testReplace() {
287          ConcurrentNavigableMap map = map5();
288 <        assertNull(map.replace(six, "Z"));
288 >        assertNull(map.replace(six, "Z"));
289          assertFalse(map.containsKey(six));
290      }
291  
# Line 305 | Line 305 | public class ConcurrentSkipListSubMapTes
305      public void testReplaceValue() {
306          ConcurrentNavigableMap map = map5();
307          assertEquals("A", map.get(one));
308 <        assertFalse(map.replace(one, "Z", "Z"));
308 >        assertFalse(map.replace(one, "Z", "Z"));
309          assertEquals("A", map.get(one));
310      }
311  
# Line 315 | Line 315 | public class ConcurrentSkipListSubMapTes
315      public void testReplaceValue2() {
316          ConcurrentNavigableMap map = map5();
317          assertEquals("A", map.get(one));
318 <        assertTrue(map.replace(one, "A", "Z"));
318 >        assertTrue(map.replace(one, "A", "Z"));
319          assertEquals("Z", map.get(one));
320      }
321  
# Line 325 | Line 325 | public class ConcurrentSkipListSubMapTes
325       */
326      public void testRemove() {
327          ConcurrentNavigableMap map = map5();
328 <        map.remove(five);
329 <        assertEquals(4, map.size());
330 <        assertFalse(map.containsKey(five));
328 >        map.remove(five);
329 >        assertEquals(4, map.size());
330 >        assertFalse(map.containsKey(five));
331      }
332  
333      /**
# Line 335 | Line 335 | public class ConcurrentSkipListSubMapTes
335       */
336      public void testRemove2() {
337          ConcurrentNavigableMap map = map5();
338 <        assertTrue(map.containsKey(five));
338 >        assertTrue(map.containsKey(five));
339          assertEquals("E", map.get(five));
340 <        map.remove(five, "E");
341 <        assertEquals(4, map.size());
342 <        assertFalse(map.containsKey(five));
343 <        map.remove(four, "A");
344 <        assertEquals(4, map.size());
345 <        assertTrue(map.containsKey(four));
340 >        map.remove(five, "E");
341 >        assertEquals(4, map.size());
342 >        assertFalse(map.containsKey(five));
343 >        map.remove(four, "A");
344 >        assertEquals(4, map.size());
345 >        assertTrue(map.containsKey(four));
346  
347      }
348  
# Line 484 | Line 484 | public class ConcurrentSkipListSubMapTes
484      public void testSize() {
485          ConcurrentNavigableMap map = map5();
486          ConcurrentNavigableMap empty = map0();
487 <        assertEquals(0, empty.size());
488 <        assertEquals(5, map.size());
487 >        assertEquals(0, empty.size());
488 >        assertEquals(5, map.size());
489      }
490  
491      /**
# Line 767 | Line 767 | public class ConcurrentSkipListSubMapTes
767       */
768      public void testDescendingClear() {
769          ConcurrentNavigableMap map = dmap5();
770 <        map.clear();
771 <        assertEquals(map.size(), 0);
770 >        map.clear();
771 >        assertEquals(map.size(), 0);
772      }
773  
774  
# Line 780 | Line 780 | public class ConcurrentSkipListSubMapTes
780          ConcurrentNavigableMap map2 = dmap5();
781          assertEquals(map1, map2);
782          assertEquals(map2, map1);
783 <        map1.clear();
783 >        map1.clear();
784          assertFalse(map1.equals(map2));
785          assertFalse(map2.equals(map1));
786      }
# Line 790 | Line 790 | public class ConcurrentSkipListSubMapTes
790       */
791      public void testDescendingContainsKey() {
792          ConcurrentNavigableMap map = dmap5();
793 <        assertTrue(map.containsKey(m1));
793 >        assertTrue(map.containsKey(m1));
794          assertFalse(map.containsKey(zero));
795      }
796  
# Line 799 | Line 799 | public class ConcurrentSkipListSubMapTes
799       */
800      public void testDescendingContainsValue() {
801          ConcurrentNavigableMap map = dmap5();
802 <        assertTrue(map.containsValue("A"));
802 >        assertTrue(map.containsValue("A"));
803          assertFalse(map.containsValue("Z"));
804      }
805  
# Line 809 | Line 809 | public class ConcurrentSkipListSubMapTes
809       */
810      public void testDescendingGet() {
811          ConcurrentNavigableMap map = dmap5();
812 <        assertEquals("A", (String)map.get(m1));
812 >        assertEquals("A", (String)map.get(m1));
813          ConcurrentNavigableMap empty = dmap0();
814          assertNull(empty.get(m1));
815      }
# Line 820 | Line 820 | public class ConcurrentSkipListSubMapTes
820      public void testDescendingIsEmpty() {
821          ConcurrentNavigableMap empty = dmap0();
822          ConcurrentNavigableMap map = dmap5();
823 <        assertTrue(empty.isEmpty());
823 >        assertTrue(empty.isEmpty());
824          assertFalse(map.isEmpty());
825      }
826  
# Line 829 | Line 829 | public class ConcurrentSkipListSubMapTes
829       */
830      public void testDescendingFirstKey() {
831          ConcurrentNavigableMap map = dmap5();
832 <        assertEquals(m1, map.firstKey());
832 >        assertEquals(m1, map.firstKey());
833      }
834  
835      /**
# Line 837 | Line 837 | public class ConcurrentSkipListSubMapTes
837       */
838      public void testDescendingLastKey() {
839          ConcurrentNavigableMap map = dmap5();
840 <        assertEquals(m5, map.lastKey());
840 >        assertEquals(m5, map.lastKey());
841      }
842  
843  
# Line 846 | Line 846 | public class ConcurrentSkipListSubMapTes
846       */
847      public void testDescendingKeySet() {
848          ConcurrentNavigableMap map = dmap5();
849 <        Set s = map.keySet();
850 <        assertEquals(5, s.size());
851 <        assertTrue(s.contains(m1));
852 <        assertTrue(s.contains(m2));
853 <        assertTrue(s.contains(m3));
854 <        assertTrue(s.contains(m4));
855 <        assertTrue(s.contains(m5));
849 >        Set s = map.keySet();
850 >        assertEquals(5, s.size());
851 >        assertTrue(s.contains(m1));
852 >        assertTrue(s.contains(m2));
853 >        assertTrue(s.contains(m3));
854 >        assertTrue(s.contains(m4));
855 >        assertTrue(s.contains(m5));
856      }
857  
858      /**
# Line 860 | Line 860 | public class ConcurrentSkipListSubMapTes
860       */
861      public void testDescendingKeySetOrder() {
862          ConcurrentNavigableMap map = dmap5();
863 <        Set s = map.keySet();
863 >        Set s = map.keySet();
864          Iterator i = s.iterator();
865          Integer last = (Integer)i.next();
866          assertEquals(last, m1);
# Line 876 | Line 876 | public class ConcurrentSkipListSubMapTes
876       */
877      public void testDescendingValues() {
878          ConcurrentNavigableMap map = dmap5();
879 <        Collection s = map.values();
880 <        assertEquals(5, s.size());
881 <        assertTrue(s.contains("A"));
882 <        assertTrue(s.contains("B"));
883 <        assertTrue(s.contains("C"));
884 <        assertTrue(s.contains("D"));
885 <        assertTrue(s.contains("E"));
879 >        Collection s = map.values();
880 >        assertEquals(5, s.size());
881 >        assertTrue(s.contains("A"));
882 >        assertTrue(s.contains("B"));
883 >        assertTrue(s.contains("C"));
884 >        assertTrue(s.contains("D"));
885 >        assertTrue(s.contains("E"));
886      }
887  
888      /**
# Line 890 | Line 890 | public class ConcurrentSkipListSubMapTes
890       */
891      public void testDescendingAscendingKeySetToArray() {
892          ConcurrentNavigableMap map = dmap5();
893 <        Set s = map.keySet();
893 >        Set s = map.keySet();
894          Object[] ar = s.toArray();
895          assertTrue(s.containsAll(Arrays.asList(ar)));
896 <        assertEquals(5, ar.length);
896 >        assertEquals(5, ar.length);
897          ar[0] = m10;
898          assertFalse(s.containsAll(Arrays.asList(ar)));
899      }
# Line 903 | Line 903 | public class ConcurrentSkipListSubMapTes
903       */
904      public void testDescendingDescendingKeySetToArray() {
905          ConcurrentNavigableMap map = dmap5();
906 <        Set s = map.descendingKeySet();
906 >        Set s = map.descendingKeySet();
907          Object[] ar = s.toArray();
908 <        assertEquals(5, ar.length);
908 >        assertEquals(5, ar.length);
909          assertTrue(s.containsAll(Arrays.asList(ar)));
910          ar[0] = m10;
911          assertFalse(s.containsAll(Arrays.asList(ar)));
# Line 916 | Line 916 | public class ConcurrentSkipListSubMapTes
916       */
917      public void testDescendingValuesToArray() {
918          ConcurrentNavigableMap map = dmap5();
919 <        Collection v = map.values();
919 >        Collection v = map.values();
920          Object[] ar = v.toArray();
921          ArrayList s = new ArrayList(Arrays.asList(ar));
922 <        assertEquals(5, ar.length);
923 <        assertTrue(s.contains("A"));
924 <        assertTrue(s.contains("B"));
925 <        assertTrue(s.contains("C"));
926 <        assertTrue(s.contains("D"));
927 <        assertTrue(s.contains("E"));
922 >        assertEquals(5, ar.length);
923 >        assertTrue(s.contains("A"));
924 >        assertTrue(s.contains("B"));
925 >        assertTrue(s.contains("C"));
926 >        assertTrue(s.contains("D"));
927 >        assertTrue(s.contains("E"));
928      }
929  
930  
# Line 933 | Line 933 | public class ConcurrentSkipListSubMapTes
933       */
934      public void testDescendingEntrySet() {
935          ConcurrentNavigableMap map = dmap5();
936 <        Set s = map.entrySet();
937 <        assertEquals(5, s.size());
936 >        Set s = map.entrySet();
937 >        assertEquals(5, s.size());
938          Iterator it = s.iterator();
939          while (it.hasNext()) {
940              Map.Entry e = (Map.Entry) it.next();
# Line 953 | Line 953 | public class ConcurrentSkipListSubMapTes
953      public void testDescendingPutAll() {
954          ConcurrentNavigableMap empty = dmap0();
955          ConcurrentNavigableMap map = dmap5();
956 <        empty.putAll(map);
957 <        assertEquals(5, empty.size());
958 <        assertTrue(empty.containsKey(m1));
959 <        assertTrue(empty.containsKey(m2));
960 <        assertTrue(empty.containsKey(m3));
961 <        assertTrue(empty.containsKey(m4));
962 <        assertTrue(empty.containsKey(m5));
956 >        empty.putAll(map);
957 >        assertEquals(5, empty.size());
958 >        assertTrue(empty.containsKey(m1));
959 >        assertTrue(empty.containsKey(m2));
960 >        assertTrue(empty.containsKey(m3));
961 >        assertTrue(empty.containsKey(m4));
962 >        assertTrue(empty.containsKey(m5));
963      }
964  
965      /**
# Line 967 | Line 967 | public class ConcurrentSkipListSubMapTes
967       */
968      public void testDescendingPutIfAbsent() {
969          ConcurrentNavigableMap map = dmap5();
970 <        map.putIfAbsent(six, "Z");
970 >        map.putIfAbsent(six, "Z");
971          assertTrue(map.containsKey(six));
972      }
973  
# Line 984 | Line 984 | public class ConcurrentSkipListSubMapTes
984       */
985      public void testDescendingReplace() {
986          ConcurrentNavigableMap map = dmap5();
987 <        assertNull(map.replace(six, "Z"));
987 >        assertNull(map.replace(six, "Z"));
988          assertFalse(map.containsKey(six));
989      }
990  
# Line 1004 | Line 1004 | public class ConcurrentSkipListSubMapTes
1004      public void testDescendingReplaceValue() {
1005          ConcurrentNavigableMap map = dmap5();
1006          assertEquals("A", map.get(m1));
1007 <        assertFalse(map.replace(m1, "Z", "Z"));
1007 >        assertFalse(map.replace(m1, "Z", "Z"));
1008          assertEquals("A", map.get(m1));
1009      }
1010  
# Line 1014 | Line 1014 | public class ConcurrentSkipListSubMapTes
1014      public void testDescendingReplaceValue2() {
1015          ConcurrentNavigableMap map = dmap5();
1016          assertEquals("A", map.get(m1));
1017 <        assertTrue(map.replace(m1, "A", "Z"));
1017 >        assertTrue(map.replace(m1, "A", "Z"));
1018          assertEquals("Z", map.get(m1));
1019      }
1020  
# Line 1024 | Line 1024 | public class ConcurrentSkipListSubMapTes
1024       */
1025      public void testDescendingRemove() {
1026          ConcurrentNavigableMap map = dmap5();
1027 <        map.remove(m5);
1028 <        assertEquals(4, map.size());
1029 <        assertFalse(map.containsKey(m5));
1027 >        map.remove(m5);
1028 >        assertEquals(4, map.size());
1029 >        assertFalse(map.containsKey(m5));
1030      }
1031  
1032      /**
# Line 1034 | Line 1034 | public class ConcurrentSkipListSubMapTes
1034       */
1035      public void testDescendingRemove2() {
1036          ConcurrentNavigableMap map = dmap5();
1037 <        assertTrue(map.containsKey(m5));
1037 >        assertTrue(map.containsKey(m5));
1038          assertEquals("E", map.get(m5));
1039 <        map.remove(m5, "E");
1040 <        assertEquals(4, map.size());
1041 <        assertFalse(map.containsKey(m5));
1042 <        map.remove(m4, "A");
1043 <        assertEquals(4, map.size());
1044 <        assertTrue(map.containsKey(m4));
1039 >        map.remove(m5, "E");
1040 >        assertEquals(4, map.size());
1041 >        assertFalse(map.containsKey(m5));
1042 >        map.remove(m4, "A");
1043 >        assertEquals(4, map.size());
1044 >        assertTrue(map.containsKey(m4));
1045  
1046      }
1047  
# Line 1183 | Line 1183 | public class ConcurrentSkipListSubMapTes
1183      public void testDescendingSize() {
1184          ConcurrentNavigableMap map = dmap5();
1185          ConcurrentNavigableMap empty = dmap0();
1186 <        assertEquals(0, empty.size());
1187 <        assertEquals(5, map.size());
1186 >        assertEquals(0, empty.size());
1187 >        assertEquals(5, map.size());
1188      }
1189  
1190      /**

Diff Legend

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