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

Comparing jsr166/src/test/loops/NavigableMapCheck.java (file contents):
Revision 1.8 by jsr166, Tue Nov 3 01:04:02 2009 UTC vs.
Revision 1.9 by jsr166, Wed Sep 1 07:47:27 2010 UTC

# Line 96 | Line 96 | public class NavigableMapCheck {
96              }
97          }
98          timer.finish();
99 <        reallyAssert (sum == expect * iters);
99 >        reallyAssert(sum == expect * iters);
100      }
101  
102      static void t2(String nm, int n, NavigableMap s, Integer[] key, int expect) {
# Line 106 | Line 106 | public class NavigableMapCheck {
106              if (s.remove(key[i]) != null) ++sum;
107          }
108          timer.finish();
109 <        reallyAssert (sum == expect);
109 >        reallyAssert(sum == expect);
110      }
111  
112      static void t3(String nm, int n, NavigableMap s, Integer[] key, int expect) {
# Line 116 | Line 116 | public class NavigableMapCheck {
116              if (s.put(key[i], absent[i & absentMask]) == null) ++sum;
117          }
118          timer.finish();
119 <        reallyAssert (sum == expect);
119 >        reallyAssert(sum == expect);
120      }
121  
122      static void t4(String nm, int n, NavigableMap s, Integer[] key, int expect) {
# Line 126 | Line 126 | public class NavigableMapCheck {
126              if (s.containsKey(key[i])) ++sum;
127          }
128          timer.finish();
129 <        reallyAssert (sum == expect);
129 >        reallyAssert(sum == expect);
130      }
131  
132      static void t5(String nm, int n, NavigableMap s, Integer[] key, int expect) {
# Line 136 | Line 136 | public class NavigableMapCheck {
136              if (s.remove(key[i]) != null) ++sum;
137          }
138          timer.finish();
139 <        reallyAssert (sum == expect);
139 >        reallyAssert(sum == expect);
140      }
141  
142      static void t6(String nm, int n, NavigableMap s, Integer[] k1, Integer[] k2) {
# Line 147 | Line 147 | public class NavigableMapCheck {
147              if (s.get(k2[i & absentMask]) != null) ++sum;
148          }
149          timer.finish();
150 <        reallyAssert (sum == n);
150 >        reallyAssert(sum == n);
151      }
152  
153      static void t7(String nm, int n, NavigableMap s, Integer[] k1, Integer[] k2) {
# Line 158 | Line 158 | public class NavigableMapCheck {
158              if (s.containsKey(k2[i & absentMask])) ++sum;
159          }
160          timer.finish();
161 <        reallyAssert (sum == n);
161 >        reallyAssert(sum == n);
162      }
163  
164      static void t8(String nm, int n, NavigableMap s, Integer[] key, int expect) {
# Line 168 | Line 168 | public class NavigableMapCheck {
168              if (s.get(key[i]) != null) ++sum;
169          }
170          timer.finish();
171 <        reallyAssert (sum == expect);
171 >        reallyAssert(sum == expect);
172      }
173  
174  
# Line 180 | Line 180 | public class NavigableMapCheck {
180          for (int i = 0; i < absentSize; i += step)
181              if (s.containsValue(absent[i])) ++sum;
182          timer.finish();
183 <        reallyAssert (sum != 0);
183 >        reallyAssert(sum != 0);
184      }
185  
186      static void higherTest(NavigableMap s) {
# Line 193 | Line 193 | public class NavigableMapCheck {
193              e = s.higherEntry(e.getKey());
194          }
195          timer.finish();
196 <        reallyAssert (sum == iters);
196 >        reallyAssert(sum == iters);
197      }
198  
199      static void lowerTest(NavigableMap s) {
# Line 206 | Line 206 | public class NavigableMapCheck {
206              e = s.higherEntry(e.getKey());
207          }
208          timer.finish();
209 <        reallyAssert (sum == iters);
209 >        reallyAssert(sum == iters);
210      }
211  
212      static void ceilingTest(NavigableMap s) {
# Line 220 | Line 220 | public class NavigableMapCheck {
220                  ++sum;
221          }
222          timer.finish();
223 <        reallyAssert (sum == iters);
223 >        reallyAssert(sum == iters);
224      }
225  
226      static void floorTest(NavigableMap s) {
# Line 234 | Line 234 | public class NavigableMapCheck {
234                  ++sum;
235          }
236          timer.finish();
237 <        reallyAssert (sum == iters-1);
237 >        reallyAssert(sum == iters-1);
238      }
239  
240  
# Line 246 | Line 246 | public class NavigableMapCheck {
246              if (ks.contains(key[i])) ++sum;
247          }
248          timer.finish();
249 <        reallyAssert (sum == size);
249 >        reallyAssert(sum == size);
250      }
251  
252  
# Line 258 | Line 258 | public class NavigableMapCheck {
258                  ++sum;
259          }
260          timer.finish();
261 <        reallyAssert (sum == size);
261 >        reallyAssert(sum == size);
262      }
263  
264      static void ittest2(NavigableMap s, int size) {
# Line 269 | Line 269 | public class NavigableMapCheck {
269                  ++sum;
270          }
271          timer.finish();
272 <        reallyAssert (sum == size);
272 >        reallyAssert(sum == size);
273      }
274      static void ittest3(NavigableMap s, int size) {
275          int sum = 0;
# Line 279 | Line 279 | public class NavigableMapCheck {
279                  ++sum;
280          }
281          timer.finish();
282 <        reallyAssert (sum == size);
282 >        reallyAssert(sum == size);
283      }
284  
285      static void ittest(NavigableMap s, int size) {
# Line 296 | Line 296 | public class NavigableMapCheck {
296                  ++sum;
297          }
298          timer.finish();
299 <        reallyAssert (sum == size);
299 >        reallyAssert(sum == size);
300      }
301  
302  
# Line 337 | Line 337 | public class NavigableMapCheck {
337  
338          timer.start("Iter Equals            ", size * 2);
339          boolean eqt = s2.equals(s) && s.equals(s2);
340 <        reallyAssert (eqt);
340 >        reallyAssert(eqt);
341          timer.finish();
342  
343          timer.start("Iter HashCode          ", size * 2);
344          int shc = s.hashCode();
345          int s2hc = s2.hashCode();
346 <        reallyAssert (shc == s2hc);
346 >        reallyAssert(shc == s2hc);
347          timer.finish();
348  
349          timer.start("Put (present)          ", size);
# Line 358 | Line 358 | public class NavigableMapCheck {
358              if (es2.contains(entry)) ++sum;
359          }
360          timer.finish();
361 <        reallyAssert (sum == size);
361 >        reallyAssert(sum == size);
362  
363          t6("Get                    ", size, s2, key, absent);
364  
# Line 366 | Line 366 | public class NavigableMapCheck {
366          s2.put(key[size-1], absent[0]);
367          timer.start("Iter Equals            ", size * 2);
368          eqt = s2.equals(s) && s.equals(s2);
369 <        reallyAssert (!eqt);
369 >        reallyAssert(!eqt);
370          timer.finish();
371  
372          timer.start("Iter HashCode          ", size * 2);
373          int s1h = s.hashCode();
374          int s2h = s2.hashCode();
375 <        reallyAssert (s1h != s2h);
375 >        reallyAssert(s1h != s2h);
376          timer.finish();
377  
378          s2.put(key[size-1], hold);
# Line 383 | Line 383 | public class NavigableMapCheck {
383              es.remove(s2i.next());
384          timer.finish();
385  
386 <        reallyAssert (s.isEmpty());
386 >        reallyAssert(s.isEmpty());
387  
388          timer.start("Clear                  ", size);
389          s2.clear();
390          timer.finish();
391 <        reallyAssert (s2.isEmpty() && s.isEmpty());
391 >        reallyAssert(s2.isEmpty() && s.isEmpty());
392      }
393  
394  

Diff Legend

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