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
17package com.android.unit_tests;
18
19import java.util.Collection;
20import java.util.HashMap;
21import java.util.Set;
22
23import android.test.PerformanceTestBase;
24import android.test.PerformanceTestCase;
25
26public class HashMapTest 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