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.4 by dl, Mon Feb 19 00:46:06 2007 UTC vs.
Revision 1.5 by jsr166, Thu Oct 29 23:09:07 2009 UTC

# Line 38 | Line 38 | public class NavigableMapCheck {
38          }
39  
40  
41 <        if (args.length > 1)
41 >        if (args.length > 1)
42              numTests = Integer.parseInt(args[1]);
43  
44 <        if (args.length > 2)
44 >        if (args.length > 2)
45              size = Integer.parseInt(args[2]);
46  
47          System.out.println("Testing " + mapClass.getName() + " trials: " + numTests + " size: " + size);
# Line 52 | Line 52 | public class NavigableMapCheck {
52          absentMask = absentSize - 1;
53          absent = new Integer[absentSize];
54  
55 <        for (int i = 0; i < absentSize; ++i)
55 >        for (int i = 0; i < absentSize; ++i)
56              absent[i] = new Integer(i * 2);
57  
58          Integer[] key = new Integer[size];
59 <        for (int i = 0; i < size; ++i)
59 >        for (int i = 0; i < size; ++i)
60              key[i] = new Integer(i * 2 + 1);
61  
62  
# Line 95 | Line 95 | public class NavigableMapCheck {
95                  if (s.get(key[i]) != null) ++sum;
96              }
97          }
98 <        timer.finish();
98 >        timer.finish();
99          reallyAssert (sum == expect * iters);
100      }
101  
# Line 105 | Line 105 | public class NavigableMapCheck {
105          for (int i = 0; i < n; i++) {
106              if (s.remove(key[i]) != null) ++sum;
107          }
108 <        timer.finish();
108 >        timer.finish();
109          reallyAssert (sum == expect);
110      }
111  
# Line 115 | Line 115 | public class NavigableMapCheck {
115          for (int i = 0; i < n; i++) {
116              if (s.put(key[i], absent[i & absentMask]) == null) ++sum;
117          }
118 <        timer.finish();
118 >        timer.finish();
119          reallyAssert (sum == expect);
120      }
121  
# Line 125 | Line 125 | public class NavigableMapCheck {
125          for (int i = 0; i < n; i++) {
126              if (s.containsKey(key[i])) ++sum;
127          }
128 <        timer.finish();
128 >        timer.finish();
129          reallyAssert (sum == expect);
130      }
131  
# Line 135 | Line 135 | public class NavigableMapCheck {
135          for (int i = n-2; i >= 0; i-=2) {
136              if (s.remove(key[i]) != null) ++sum;
137          }
138 <        timer.finish();
138 >        timer.finish();
139          reallyAssert (sum == expect);
140      }
141  
# Line 146 | Line 146 | public class NavigableMapCheck {
146              if (s.get(k1[i]) != null) ++sum;
147              if (s.get(k2[i & absentMask]) != null) ++sum;
148          }
149 <        timer.finish();
149 >        timer.finish();
150          reallyAssert (sum == n);
151      }
152  
# Line 157 | Line 157 | public class NavigableMapCheck {
157              if (s.containsKey(k1[i])) ++sum;
158              if (s.containsKey(k2[i & absentMask])) ++sum;
159          }
160 <        timer.finish();
160 >        timer.finish();
161          reallyAssert (sum == n);
162      }
163  
# Line 167 | Line 167 | public class NavigableMapCheck {
167          for (int i = 0; i < n; i++) {
168              if (s.get(key[i]) != null) ++sum;
169          }
170 <        timer.finish();
170 >        timer.finish();
171          reallyAssert (sum == expect);
172      }
173  
# Line 179 | Line 179 | public class NavigableMapCheck {
179          int step = absentSize / iters;
180          for (int i = 0; i < absentSize; i += step)
181              if (s.containsValue(absent[i])) ++sum;
182 <        timer.finish();
182 >        timer.finish();
183          reallyAssert (sum != 0);
184      }
185  
# Line 192 | Line 192 | public class NavigableMapCheck {
192              ++sum;
193              e = s.higherEntry(e.getKey());
194          }
195 <        timer.finish();
195 >        timer.finish();
196          reallyAssert (sum == iters);
197      }
198  
# Line 205 | Line 205 | public class NavigableMapCheck {
205              ++sum;
206              e = s.higherEntry(e.getKey());
207          }
208 <        timer.finish();
208 >        timer.finish();
209          reallyAssert (sum == iters);
210      }
211  
# Line 219 | Line 219 | public class NavigableMapCheck {
219              if (e != null)
220                  ++sum;
221          }
222 <        timer.finish();
222 >        timer.finish();
223          reallyAssert (sum == iters);
224      }
225  
# Line 233 | Line 233 | public class NavigableMapCheck {
233              if (e != null)
234                  ++sum;
235          }
236 <        timer.finish();
236 >        timer.finish();
237          reallyAssert (sum == iters-1);
238      }
239  
# Line 245 | Line 245 | public class NavigableMapCheck {
245          for (int i = 0; i < size; i++) {
246              if (ks.contains(key[i])) ++sum;
247          }
248 <        timer.finish();
248 >        timer.finish();
249          reallyAssert (sum == size);
250      }
251  
# Line 257 | Line 257 | public class NavigableMapCheck {
257              if(it.next() != MISSING)
258                  ++sum;
259          }
260 <        timer.finish();
260 >        timer.finish();
261          reallyAssert (sum == size);
262      }
263  
# Line 268 | Line 268 | public class NavigableMapCheck {
268              if(it.next() != MISSING)
269                  ++sum;
270          }
271 <        timer.finish();
271 >        timer.finish();
272          reallyAssert (sum == size);
273      }
274      static void ittest3(NavigableMap s, int size) {
# Line 278 | Line 278 | public class NavigableMapCheck {
278              if(it.next() != MISSING)
279                  ++sum;
280          }
281 <        timer.finish();
281 >        timer.finish();
282          reallyAssert (sum == size);
283      }
284  
# Line 295 | Line 295 | public class NavigableMapCheck {
295              if(it.next() != MISSING)
296                  ++sum;
297          }
298 <        timer.finish();
298 >        timer.finish();
299          reallyAssert (sum == size);
300      }
301  
# Line 312 | Line 312 | public class NavigableMapCheck {
312              it.next();
313              it.remove();
314          }
315 <        timer.finish();
315 >        timer.finish();
316      }
317  
318      static void rvtest(NavigableMap s, int size) {
# Line 321 | Line 321 | public class NavigableMapCheck {
321              it.next();
322              it.remove();
323          }
324 <        timer.finish();
324 >        timer.finish();
325      }
326  
327  
# Line 333 | Line 333 | public class NavigableMapCheck {
333              s2.putAll(s);
334          }
335          catch (Exception e) { e.printStackTrace(); return; }
336 <        timer.finish();
337 <    
336 >        timer.finish();
337 >
338          timer.start("Iter Equals            ", size * 2);
339          boolean eqt = s2.equals(s) && s.equals(s2);
340          reallyAssert (eqt);
341 <        timer.finish();
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);
347 <        timer.finish();
347 >        timer.finish();
348  
349          timer.start("Put (present)          ", size);
350          s2.putAll(s);
351 <        timer.finish();
351 >        timer.finish();
352  
353          timer.start("Iter EntrySet contains ", size * 2);
354          Set es2 = s2.entrySet();
# Line 357 | Line 357 | public class NavigableMapCheck {
357              Object entry = i1.next();
358              if (es2.contains(entry)) ++sum;
359          }
360 <        timer.finish();
360 >        timer.finish();
361          reallyAssert (sum == size);
362  
363          t6("Get                    ", size, s2, key, absent);
# Line 367 | Line 367 | public class NavigableMapCheck {
367          timer.start("Iter Equals            ", size * 2);
368          eqt = s2.equals(s) && s.equals(s2);
369          reallyAssert (!eqt);
370 <        timer.finish();
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);
376 <        timer.finish();
376 >        timer.finish();
377  
378          s2.put(key[size-1], hold);
379          timer.start("Remove (iterator)      ", size * 2);
# Line 381 | Line 381 | public class NavigableMapCheck {
381          Set es = s.entrySet();
382          while (s2i.hasNext())
383              es.remove(s2i.next());
384 <        timer.finish();
384 >        timer.finish();
385  
386          reallyAssert (s.isEmpty());
387  
388          timer.start("Clear                  ", size);
389          s2.clear();
390 <        timer.finish();
390 >        timer.finish();
391          reallyAssert (s2.isEmpty() && s.isEmpty());
392      }
393  
394  
395 <    
395 >
396      static void test(NavigableMap s, Integer[] key) {
397          int size = key.length;
398  
# Line 431 | Line 431 | public class NavigableMapCheck {
431          private String cname;
432  
433          static final java.util.TreeMap accum = new java.util.TreeMap();
434 <    
434 >
435          static void printStats() {
436              for (Iterator it = accum.entrySet().iterator(); it.hasNext(); ) {
437                  Map.Entry e = (Map.Entry)(it.next());
438                  Stats stats = ((Stats)(e.getValue()));
439                  int n = stats.number;
440                  double t;
441 <                if (n > 0)
441 >                if (n > 0)
442                      t = stats.sum / n;
443                  else
444                      t = stats.least;
# Line 446 | Line 446 | public class NavigableMapCheck {
446                  System.out.println(e.getKey() + ": " + nano);
447              }
448          }
449 <    
449 >
450          void start(String name, long numOps) {
451              this.name = name;
452              this.cname = classify();
453              this.numOps = numOps;
454              startTime = System.currentTimeMillis();
455          }
456 <    
456 >
457  
458          String classify() {
459              if (name.startsWith("Get"))
# Line 464 | Line 464 | public class NavigableMapCheck {
464                  return "Remove                 ";
465              else if (name.startsWith("Iter"))
466                  return "Iter                   ";
467 <            else
467 >            else
468                  return null;
469          }
470  
# Line 519 | Line 519 | public class NavigableMapCheck {
519      }
520  
521   }
522 –

Diff Legend

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