Print this page


Split Close
Expand all
Collapse all
          --- old/test/java/util/concurrent/ConcurrentHashMap/MapCheck.java
          +++ new/test/java/util/concurrent/ConcurrentHashMap/MapCheck.java
↓ open down ↓ 26 lines elided ↑ open up ↑
  27   27   * file:
  28   28   *
  29   29   * Written by Doug Lea with assistance from members of JCP JSR-166
  30   30   * Expert Group and released to the public domain, as explained at
  31   31   * http://creativecommons.org/licenses/publicdomain
  32   32   */
  33   33  
  34   34  /*
  35   35   * @test
  36   36   * @bug 4486658
  37      - * @compile MapCheck.java
       37 + * @compile -source 1.5 MapCheck.java
  38   38   * @run main/timeout=240 MapCheck
  39   39   * @summary Times and checks basic map operations
  40   40   */
  41   41  
  42   42  import java.util.*;
  43   43  import java.io.*;
  44   44  
  45   45  public class MapCheck {
  46   46  
  47   47      static final int absentSize = 1 << 17;
↓ open down ↓ 9 lines elided ↑ open up ↑
  57   57      }
  58   58  
  59   59      public static void main(String[] args) throws Exception {
  60   60          Class mapClass = java.util.concurrent.ConcurrentHashMap.class;
  61   61          int numTests = 8;
  62   62          int size = 50000;
  63   63  
  64   64          if (args.length > 0) {
  65   65              try {
  66   66                  mapClass = Class.forName(args[0]);
  67      -            } catch(ClassNotFoundException e) {
       67 +            } catch (ClassNotFoundException e) {
  68   68                  throw new RuntimeException("Class " + args[0] + " not found.");
  69   69              }
  70   70          }
  71   71  
  72   72  
  73   73          if (args.length > 1)
  74   74              numTests = Integer.parseInt(args[1]);
  75   75  
  76   76          if (args.length > 2)
  77   77              size = Integer.parseInt(args[2]);
↓ open down ↓ 17 lines elided ↑ open up ↑
  95   95  
  96   96  
  97   97          if (doSerializeTest)
  98   98              stest(newMap(mapClass), size);
  99   99      }
 100  100  
 101  101      static Map newMap(Class cl) {
 102  102          try {
 103  103              Map m = (Map)cl.newInstance();
 104  104              return m;
 105      -        } catch(Exception e) {
      105 +        } catch (Exception e) {
 106  106              throw new RuntimeException("Can't instantiate " + cl + ": " + e);
 107  107          }
 108  108      }
 109  109  
 110  110  
 111  111      static void runTest(Map s, Object[] key) {
 112  112          shuffle(key);
 113  113          int size = key.length;
 114  114          long startTime = System.currentTimeMillis();
 115  115          test(s, key);
↓ open down ↓ 16 lines elided ↑ open up ↑
 132  132      static void t1(String nm, int n, Map s, Object[] key, int expect) {
 133  133          int sum = 0;
 134  134          int iters = 4;
 135  135          timer.start(nm, n * iters);
 136  136          for (int j = 0; j < iters; ++j) {
 137  137              for (int i = 0; i < n; i++) {
 138  138                  if (s.get(key[i]) != null) ++sum;
 139  139              }
 140  140          }
 141  141          timer.finish();
 142      -        reallyAssert (sum == expect * iters);
      142 +        reallyAssert(sum == expect * iters);
 143  143      }
 144  144  
 145  145      static void t2(String nm, int n, Map s, Object[] key, int expect) {
 146  146          int sum = 0;
 147  147          timer.start(nm, n);
 148  148          for (int i = 0; i < n; i++) {
 149  149              if (s.remove(key[i]) != null) ++sum;
 150  150          }
 151  151          timer.finish();
 152      -        reallyAssert (sum == expect);
      152 +        reallyAssert(sum == expect);
 153  153      }
 154  154  
 155  155      static void t3(String nm, int n, Map s, Object[] key, int expect) {
 156  156          int sum = 0;
 157  157          timer.start(nm, n);
 158  158          for (int i = 0; i < n; i++) {
 159  159              if (s.put(key[i], absent[i & absentMask]) == null) ++sum;
 160  160          }
 161  161          timer.finish();
 162      -        reallyAssert (sum == expect);
      162 +        reallyAssert(sum == expect);
 163  163      }
 164  164  
 165  165      static void t4(String nm, int n, Map s, Object[] key, int expect) {
 166  166          int sum = 0;
 167  167          timer.start(nm, n);
 168  168          for (int i = 0; i < n; i++) {
 169  169              if (s.containsKey(key[i])) ++sum;
 170  170          }
 171  171          timer.finish();
 172      -        reallyAssert (sum == expect);
      172 +        reallyAssert(sum == expect);
 173  173      }
 174  174  
 175  175      static void t5(String nm, int n, Map s, Object[] key, int expect) {
 176  176          int sum = 0;
 177  177          timer.start(nm, n/2);
 178  178          for (int i = n-2; i >= 0; i-=2) {
 179  179              if (s.remove(key[i]) != null) ++sum;
 180  180          }
 181  181          timer.finish();
 182      -        reallyAssert (sum == expect);
      182 +        reallyAssert(sum == expect);
 183  183      }
 184  184  
 185  185      static void t6(String nm, int n, Map s, Object[] k1, Object[] k2) {
 186  186          int sum = 0;
 187  187          timer.start(nm, n * 2);
 188  188          for (int i = 0; i < n; i++) {
 189  189              if (s.get(k1[i]) != null) ++sum;
 190  190              if (s.get(k2[i & absentMask]) != null) ++sum;
 191  191          }
 192  192          timer.finish();
 193      -        reallyAssert (sum == n);
      193 +        reallyAssert(sum == n);
 194  194      }
 195  195  
 196  196      static void t7(String nm, int n, Map s, Object[] k1, Object[] k2) {
 197  197          int sum = 0;
 198  198          timer.start(nm, n * 2);
 199  199          for (int i = 0; i < n; i++) {
 200  200              if (s.containsKey(k1[i])) ++sum;
 201  201              if (s.containsKey(k2[i & absentMask])) ++sum;
 202  202          }
 203  203          timer.finish();
 204      -        reallyAssert (sum == n);
      204 +        reallyAssert(sum == n);
 205  205      }
 206  206  
 207  207      static void t8(String nm, int n, Map s, Object[] key, int expect) {
 208  208          int sum = 0;
 209  209          timer.start(nm, n);
 210  210          for (int i = 0; i < n; i++) {
 211  211              if (s.get(key[i]) != null) ++sum;
 212  212          }
 213  213          timer.finish();
 214      -        reallyAssert (sum == expect);
      214 +        reallyAssert(sum == expect);
 215  215      }
 216  216  
 217  217  
 218  218      static void t9(Map s) {
 219  219          int sum = 0;
 220  220          int iters = 20;
 221  221          timer.start("ContainsValue (/n)     ", iters * s.size());
 222  222          int step = absentSize / iters;
 223  223          for (int i = 0; i < absentSize; i += step)
 224  224              if (s.containsValue(absent[i])) ++sum;
 225  225          timer.finish();
 226      -        reallyAssert (sum != 0);
      226 +        reallyAssert(sum != 0);
 227  227      }
 228  228  
 229  229  
 230  230      static void ktest(Map s, int size, Object[] key) {
 231  231          timer.start("ContainsKey            ", size);
 232  232          Set ks = s.keySet();
 233  233          int sum = 0;
 234  234          for (int i = 0; i < size; i++) {
 235  235              if (ks.contains(key[i])) ++sum;
 236  236          }
 237  237          timer.finish();
 238      -        reallyAssert (sum == size);
      238 +        reallyAssert(sum == size);
 239  239      }
 240  240  
 241  241  
 242  242      static void ittest1(Map s, int size) {
 243  243          int sum = 0;
 244  244          timer.start("Iter Key               ", size);
 245  245          for (Iterator it = s.keySet().iterator(); it.hasNext(); ) {
 246      -            if(it.next() != MISSING)
      246 +            if (it.next() != MISSING)
 247  247                  ++sum;
 248  248          }
 249  249          timer.finish();
 250      -        reallyAssert (sum == size);
      250 +        reallyAssert(sum == size);
 251  251      }
 252  252  
 253  253      static void ittest2(Map s, int size) {
 254  254          int sum = 0;
 255  255          timer.start("Iter Value             ", size);
 256  256          for (Iterator it = s.values().iterator(); it.hasNext(); ) {
 257      -            if(it.next() != MISSING)
      257 +            if (it.next() != MISSING)
 258  258                  ++sum;
 259  259          }
 260  260          timer.finish();
 261      -        reallyAssert (sum == size);
      261 +        reallyAssert(sum == size);
 262  262      }
 263  263      static void ittest3(Map s, int size) {
 264  264          int sum = 0;
 265  265          timer.start("Iter Entry             ", size);
 266  266          for (Iterator it = s.entrySet().iterator(); it.hasNext(); ) {
 267      -            if(it.next() != MISSING)
      267 +            if (it.next() != MISSING)
 268  268                  ++sum;
 269  269          }
 270  270          timer.finish();
 271      -        reallyAssert (sum == size);
      271 +        reallyAssert(sum == size);
 272  272      }
 273  273  
 274  274      static void ittest4(Map s, int size, int pos) {
 275  275          IdentityHashMap seen = new IdentityHashMap(size);
 276      -        reallyAssert (s.size() == size);
      276 +        reallyAssert(s.size() == size);
 277  277          int sum = 0;
 278  278          timer.start("Iter XEntry            ", size);
 279  279          Iterator it = s.entrySet().iterator();
 280  280          Object k = null;
 281  281          Object v = null;
 282  282          for (int i = 0; i < size-pos; ++i) {
 283  283              Map.Entry x = (Map.Entry)(it.next());
 284  284              k = x.getKey();
 285  285              v = x.getValue();
 286  286              seen.put(k, k);
 287  287              if (x != MISSING)
 288  288                  ++sum;
 289  289          }
 290      -        reallyAssert (s.containsKey(k));
      290 +        reallyAssert(s.containsKey(k));
 291  291          it.remove();
 292      -        reallyAssert (!s.containsKey(k));
      292 +        reallyAssert(!s.containsKey(k));
 293  293          while (it.hasNext()) {
 294  294              Map.Entry x = (Map.Entry)(it.next());
 295  295              Object k2 = x.getKey();
 296  296              seen.put(k2, k2);
 297  297              if (x != MISSING)
 298  298                  ++sum;
 299  299          }
 300  300  
 301      -        reallyAssert (s.size() == size-1);
      301 +        reallyAssert(s.size() == size-1);
 302  302          s.put(k, v);
 303      -        reallyAssert (seen.size() == size);
      303 +        reallyAssert(seen.size() == size);
 304  304          timer.finish();
 305      -        reallyAssert (sum == size);
 306      -        reallyAssert (s.size() == size);
      305 +        reallyAssert(sum == size);
      306 +        reallyAssert(s.size() == size);
 307  307      }
 308  308  
 309  309  
 310  310      static void ittest(Map s, int size) {
 311  311          ittest1(s, size);
 312  312          ittest2(s, size);
 313  313          ittest3(s, size);
 314  314          //        for (int i = 0; i < size-1; ++i)
 315  315          //            ittest4(s, size, i);
 316  316      }
 317  317  
 318  318      static void entest1(Hashtable ht, int size) {
 319  319          int sum = 0;
 320  320  
 321  321          timer.start("Iter Enumeration Key   ", size);
 322  322          for (Enumeration en = ht.keys(); en.hasMoreElements(); ) {
 323  323              if (en.nextElement() != MISSING)
 324  324                  ++sum;
 325  325          }
 326  326          timer.finish();
 327      -        reallyAssert (sum == size);
      327 +        reallyAssert(sum == size);
 328  328      }
 329  329  
 330  330      static void entest2(Hashtable ht, int size) {
 331  331          int sum = 0;
 332  332          timer.start("Iter Enumeration Value ", size);
 333  333          for (Enumeration en = ht.elements(); en.hasMoreElements(); ) {
 334  334              if (en.nextElement() != MISSING)
 335  335                  ++sum;
 336  336          }
 337  337          timer.finish();
 338      -        reallyAssert (sum == size);
      338 +        reallyAssert(sum == size);
 339  339      }
 340  340  
 341  341  
 342  342      static void entest3(Hashtable ht, int size) {
 343  343          int sum = 0;
 344  344  
 345  345          timer.start("Iterf Enumeration Key  ", size);
 346  346          Enumeration en = ht.keys();
 347  347          for (int i = 0; i < size; ++i) {
 348  348              if (en.nextElement() != MISSING)
 349  349                  ++sum;
 350  350          }
 351  351          timer.finish();
 352      -        reallyAssert (sum == size);
      352 +        reallyAssert(sum == size);
 353  353      }
 354  354  
 355  355      static void entest4(Hashtable ht, int size) {
 356  356          int sum = 0;
 357  357          timer.start("Iterf Enumeration Value", size);
 358  358          Enumeration en = ht.elements();
 359  359          for (int i = 0; i < size; ++i) {
 360  360              if (en.nextElement() != MISSING)
 361  361                  ++sum;
 362  362          }
 363  363          timer.finish();
 364      -        reallyAssert (sum == size);
      364 +        reallyAssert(sum == size);
 365  365      }
 366  366  
 367  367      static void entest(Map s, int size) {
 368  368          if (s instanceof Hashtable) {
 369  369              Hashtable ht = (Hashtable)s;
 370  370              //            entest3(ht, size);
 371  371              //            entest4(ht, size);
 372  372              entest1(ht, size);
 373  373              entest2(ht, size);
 374  374              entest1(ht, size);
↓ open down ↓ 27 lines elided ↑ open up ↑
 402  402          Map s2 = null;
 403  403          try {
 404  404              s2 = (Map) (s.getClass().newInstance());
 405  405              s2.putAll(s);
 406  406          }
 407  407          catch (Exception e) { e.printStackTrace(); return; }
 408  408          timer.finish();
 409  409  
 410  410          timer.start("Iter Equals            ", size * 2);
 411  411          boolean eqt = s2.equals(s) && s.equals(s2);
 412      -        reallyAssert (eqt);
      412 +        reallyAssert(eqt);
 413  413          timer.finish();
 414  414  
 415  415          timer.start("Iter HashCode          ", size * 2);
 416  416          int shc = s.hashCode();
 417  417          int s2hc = s2.hashCode();
 418      -        reallyAssert (shc == s2hc);
      418 +        reallyAssert(shc == s2hc);
 419  419          timer.finish();
 420  420  
 421  421          timer.start("Put (present)          ", size);
 422  422          s2.putAll(s);
 423  423          timer.finish();
 424  424  
 425  425          timer.start("Iter EntrySet contains ", size * 2);
 426  426          Set es2 = s2.entrySet();
 427  427          int sum = 0;
 428  428          for (Iterator i1 = s.entrySet().iterator(); i1.hasNext(); ) {
 429  429              Object entry = i1.next();
 430  430              if (es2.contains(entry)) ++sum;
 431  431          }
 432  432          timer.finish();
 433      -        reallyAssert (sum == size);
      433 +        reallyAssert(sum == size);
 434  434  
 435  435          t6("Get                    ", size, s2, key, absent);
 436  436  
 437  437          Object hold = s2.get(key[size-1]);
 438  438          s2.put(key[size-1], absent[0]);
 439  439          timer.start("Iter Equals            ", size * 2);
 440  440          eqt = s2.equals(s) && s.equals(s2);
 441      -        reallyAssert (!eqt);
      441 +        reallyAssert(!eqt);
 442  442          timer.finish();
 443  443  
 444  444          timer.start("Iter HashCode          ", size * 2);
 445  445          int s1h = s.hashCode();
 446  446          int s2h = s2.hashCode();
 447      -        reallyAssert (s1h != s2h);
      447 +        reallyAssert(s1h != s2h);
 448  448          timer.finish();
 449  449  
 450  450          s2.put(key[size-1], hold);
 451  451          timer.start("Remove (iterator)      ", size * 2);
 452  452          Iterator s2i = s2.entrySet().iterator();
 453  453          Set es = s.entrySet();
 454  454          while (s2i.hasNext())
 455  455              es.remove(s2i.next());
 456  456          timer.finish();
 457  457  
 458      -        reallyAssert (s.isEmpty());
      458 +        reallyAssert(s.isEmpty());
 459  459  
 460  460          timer.start("Clear                  ", size);
 461  461          s2.clear();
 462  462          timer.finish();
 463      -        reallyAssert (s2.isEmpty() && s.isEmpty());
      463 +        reallyAssert(s2.isEmpty() && s.isEmpty());
 464  464      }
 465  465  
 466  466      static void stest(Map s, int size) throws Exception {
 467  467          if (!(s instanceof Serializable))
 468  468              return;
 469  469          System.out.print("Serialize              : ");
 470  470  
 471  471          for (int i = 0; i < size; i++) {
 472  472              s.put(new Integer(i), Boolean.TRUE);
 473  473          }
↓ open down ↓ 8 lines elided ↑ open up ↑
 482  482          FileInputStream is = new FileInputStream("MapCheck.dat");
 483  483          ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(is));
 484  484          Map m = (Map)in.readObject();
 485  485  
 486  486          long endTime = System.currentTimeMillis();
 487  487          long time = endTime - startTime;
 488  488  
 489  489          System.out.print(time + "ms");
 490  490  
 491  491          if (s instanceof IdentityHashMap) return;
 492      -        reallyAssert (s.equals(m));
      492 +        reallyAssert(s.equals(m));
 493  493      }
 494  494  
 495  495  
 496  496      static void test(Map s, Object[] key) {
 497  497          int size = key.length;
 498  498  
 499  499          t3("Put (absent)           ", size, s, key, size);
 500  500          t3("Put (present)          ", size, s, key, 0);
 501  501          t7("ContainsKey            ", size, s, key, absent);
 502  502          t4("ContainsKey            ", size, s, key, size);
↓ open down ↓ 115 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX