Home | History | Annotate | Download | only in core
      1 /*
      2  * Copyright (C) 2007 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package android.core;
     18 
     19 import java.util.Collection;
     20 import java.util.HashMap;
     21 import java.util.Set;
     22 
     23 import android.test.PerformanceTestBase;
     24 import android.test.PerformanceTestCase;
     25 
     26 public class HashMapPerformanceTest extends PerformanceTestBase {
     27     public static final int ITERATIONS = 1000;
     28     public HashMap mMap;
     29     public String[] mKeys;
     30 
     31     @Override
     32     @SuppressWarnings("unchecked")
     33     protected void setUp() throws Exception {
     34         super.setUp();
     35         mMap = new HashMap();
     36         mKeys = new String[ITERATIONS];
     37 
     38         for (int i = ITERATIONS - 1; i >= 0; i--) {
     39             mKeys[i] = Integer.toString(i, 16);
     40             mMap.put(mKeys[i], i);
     41         }
     42     }
     43 
     44     @Override
     45     public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
     46         intermediates.setInternalIterations(ITERATIONS);
     47         return 0;
     48     }
     49 
     50     public void testHashMapGet() {
     51         int num;
     52         for (int i = ITERATIONS - 1; i >= 0; i--) {
     53             num = (Integer) mMap.get(mKeys[i]);
     54             num = (Integer) mMap.get(mKeys[i]);
     55             num = (Integer) mMap.get(mKeys[i]);
     56             num = (Integer) mMap.get(mKeys[i]);
     57             num = (Integer) mMap.get(mKeys[i]);
     58             num = (Integer) mMap.get(mKeys[i]);
     59             num = (Integer) mMap.get(mKeys[i]);
     60             num = (Integer) mMap.get(mKeys[i]);
     61             num = (Integer) mMap.get(mKeys[i]);
     62             num = (Integer) mMap.get(mKeys[i]);
     63         }
     64     }
     65 
     66     public void testHashMapKeySet() {
     67         Set keyset;
     68         for (int i = ITERATIONS - 1; i >= 0; i--) {
     69             keyset = mMap.keySet();
     70             keyset = mMap.keySet();
     71             keyset = mMap.keySet();
     72             keyset = mMap.keySet();
     73             keyset = mMap.keySet();
     74             keyset = mMap.keySet();
     75             keyset = mMap.keySet();
     76             keyset = mMap.keySet();
     77             keyset = mMap.keySet();
     78             keyset = mMap.keySet();
     79         }
     80     }
     81 
     82     public void testHashMapEntrySet() {
     83         Set keyset;
     84         for (int i = ITERATIONS - 1; i >= 0; i--) {
     85             keyset = mMap.entrySet();
     86             keyset = mMap.entrySet();
     87             keyset = mMap.entrySet();
     88             keyset = mMap.entrySet();
     89             keyset = mMap.entrySet();
     90             keyset = mMap.entrySet();
     91             keyset = mMap.entrySet();
     92             keyset = mMap.entrySet();
     93             keyset = mMap.entrySet();
     94             keyset = mMap.entrySet();
     95 
     96 
     97         }
     98     }
     99 
    100     public void testHashMapValues() {
    101         Collection c;
    102         for (int i = ITERATIONS - 1; i >= 0; i--) {
    103             c = mMap.values();
    104             c = mMap.values();
    105             c = mMap.values();
    106             c = mMap.values();
    107             c = mMap.values();
    108             c = mMap.values();
    109             c = mMap.values();
    110             c = mMap.values();
    111             c = mMap.values();
    112             c = mMap.values();
    113 
    114 
    115         }
    116     }
    117 
    118     public void testHashMapSize() {
    119         int len;
    120         for (int i = ITERATIONS - 1; i >= 0; i--) {
    121             len = mMap.size();
    122             len = mMap.size();
    123             len = mMap.size();
    124             len = mMap.size();
    125             len = mMap.size();
    126             len = mMap.size();
    127             len = mMap.size();
    128             len = mMap.size();
    129             len = mMap.size();
    130             len = mMap.size();
    131 
    132 
    133         }
    134     }
    135 
    136     public void testHashMapContainsValue() {
    137         boolean flag;
    138         for (int i = ITERATIONS - 1; i >= 0; i--) {
    139             flag = mMap.containsValue(i);
    140             flag = mMap.containsValue(i);
    141             flag = mMap.containsValue(i);
    142             flag = mMap.containsValue(i);
    143             flag = mMap.containsValue(i);
    144             flag = mMap.containsValue(i);
    145             flag = mMap.containsValue(i);
    146             flag = mMap.containsValue(i);
    147             flag = mMap.containsValue(i);
    148             flag = mMap.containsValue(i);
    149 
    150 
    151         }
    152     }
    153 
    154     public void testHashMapRemove() {
    155         for (int i = ITERATIONS - 1; i >= 0; i--) {
    156             mMap.remove(mKeys[i]);
    157             mMap.remove(mKeys[i]);
    158             mMap.remove(mKeys[i]);
    159             mMap.remove(mKeys[i]);
    160             mMap.remove(mKeys[i]);
    161             mMap.remove(mKeys[i]);
    162             mMap.remove(mKeys[i]);
    163             mMap.remove(mKeys[i]);
    164             mMap.remove(mKeys[i]);
    165             mMap.remove(mKeys[i]);
    166         }
    167     }
    168 
    169 
    170     public void testHashMapClone() {
    171         HashMap cMap;
    172         for (int i = ITERATIONS - 1; i >= 0; i--) {
    173             cMap = (HashMap) mMap.clone();
    174             cMap = (HashMap) mMap.clone();
    175             cMap = (HashMap) mMap.clone();
    176             cMap = (HashMap) mMap.clone();
    177             cMap = (HashMap) mMap.clone();
    178             cMap = (HashMap) mMap.clone();
    179             cMap = (HashMap) mMap.clone();
    180             cMap = (HashMap) mMap.clone();
    181             cMap = (HashMap) mMap.clone();
    182             cMap = (HashMap) mMap.clone();
    183         }
    184     }
    185 }
    186