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 android.core;
18
19import android.test.PerformanceTestBase;
20import android.test.PerformanceTestCase;
21
22import java.util.Vector;
23import java.util.Enumeration;
24
25/**
26 * Basic Performance Tests for java.util.Vector
27 */
28
29@SuppressWarnings("unchecked")
30public class VectorTest extends PerformanceTestBase {
31    public static final int ITERATIONS = 1000;
32    private Vector<Integer> mVector;
33    private Vector<String> mStrVector;
34    private String mTestString = "Hello Android";
35
36    @Override
37    protected void setUp() throws Exception {
38        super.setUp();
39        mVector = new Vector();
40        mStrVector = new Vector();
41        for (int i = ITERATIONS - 1; i >= 0; i--) {
42            assertTrue(mVector.add(i));
43            assertTrue(mStrVector.add(Integer.toString(i)));
44        }
45    }
46
47    @Override
48    public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
49        intermediates.setInternalIterations(ITERATIONS);
50        return 0;
51    }
52
53    public void testVectorAdd() {
54        Vector<Integer> vector = new Vector();
55        for (int i = ITERATIONS - 1; i >= 0; i--) {
56            vector.add(i);
57            vector.add(i);
58            vector.add(i);
59            vector.add(i);
60            vector.add(i);
61            vector.add(i);
62            vector.add(i);
63            vector.add(i);
64            vector.add(i);
65            vector.add(i);
66        }
67    }
68
69    public void testVectorAdd1() {
70        Vector<Integer> vector = new Vector();
71        for (int i = ITERATIONS - 1; i >= 0; i--) {
72            vector.add(0, i);
73            vector.add(0, i);
74            vector.add(0, i);
75            vector.add(0, i);
76            vector.add(0, i);
77            vector.add(0, i);
78            vector.add(0, i);
79            vector.add(0, i);
80            vector.add(0, i);
81            vector.add(0, i);
82        }
83    }
84
85    public void testVectorToArray() {
86        Object array;
87        Vector<Integer> vector = mVector;
88        for (int i = ITERATIONS - 1; i >= 0; i--) {
89            array = vector.toArray();
90            array = vector.toArray();
91            array = vector.toArray();
92            array = vector.toArray();
93            array = vector.toArray();
94            array = vector.toArray();
95            array = vector.toArray();
96            array = vector.toArray();
97            array = vector.toArray();
98            array = vector.toArray();
99        }
100    }
101
102    /**
103     *
104     */
105    public void testVectorSize() {
106        Vector<Integer> vector = mVector;
107        for (int i = ITERATIONS - 1; i >= 0; i--) {
108            int mLen;
109            mLen = vector.size();
110            mLen = vector.size();
111            mLen = vector.size();
112            mLen = vector.size();
113            mLen = vector.size();
114            mLen = vector.size();
115            mLen = vector.size();
116            mLen = vector.size();
117            mLen = vector.size();
118            mLen = vector.size();
119        }
120    }
121
122    public void testVectorGet() {
123        int element;
124        Vector<Integer> vector = mVector;
125        for (int i = ITERATIONS - 1; i >= 0; i--) {
126            element = vector.get(i);
127            element = vector.get(i);
128            element = vector.get(i);
129            element = vector.get(i);
130            element = vector.get(i);
131            element = vector.get(i);
132            element = vector.get(i);
133            element = vector.get(i);
134            element = vector.get(i);
135            element = vector.get(i);
136        }
137
138    }
139
140    public void testVectorContains() {
141        boolean flag;
142        Vector<Integer> vector = mVector;
143        for (int i = ITERATIONS - 1; i >= 0; i--) {
144            flag = vector.contains(i);
145            flag = vector.contains(i);
146            flag = vector.contains(i);
147            flag = vector.contains(i);
148            flag = vector.contains(i);
149            flag = vector.contains(i);
150            flag = vector.contains(i);
151            flag = vector.contains(i);
152            flag = vector.contains(i);
153            flag = vector.contains(i);
154        }
155    }
156
157    public void testVectorToArray1() {
158        Integer[] rArray = new Integer[100];
159        Integer[] array;
160        Vector<Integer> vector = mVector;
161        for (int i = ITERATIONS - 1; i >= 0; i--) {
162            array = vector.toArray(rArray);
163            array = vector.toArray(rArray);
164            array = vector.toArray(rArray);
165            array = vector.toArray(rArray);
166            array = vector.toArray(rArray);
167            array = vector.toArray(rArray);
168            array = vector.toArray(rArray);
169            array = vector.toArray(rArray);
170            array = vector.toArray(rArray);
171            array = vector.toArray(rArray);
172        }
173    }
174
175    public void testVectorSet() {
176        Vector<Integer> vector = mVector;
177        int pos = 5, value = 0;
178        for (int i = ITERATIONS - 1; i >= 0; i--) {
179            vector.set(pos, value);
180            vector.set(pos, value);
181            vector.set(pos, value);
182            vector.set(pos, value);
183            vector.set(pos, value);
184            vector.set(pos, value);
185            vector.set(pos, value);
186            vector.set(pos, value);
187            vector.set(pos, value);
188            vector.set(pos, value);
189        }
190    }
191
192    public void testVectorIndexOf() {
193        int index, value = 0;
194        Vector<Integer> vector = mVector;
195        for (int i = ITERATIONS - 1; i >= 0; i--) {
196            index = vector.indexOf(value);
197            index = vector.indexOf(value);
198            index = vector.indexOf(value);
199            index = vector.indexOf(value);
200            index = vector.indexOf(value);
201            index = vector.indexOf(value);
202            index = vector.indexOf(value);
203            index = vector.indexOf(value);
204            index = vector.indexOf(value);
205            index = vector.indexOf(value);
206        }
207    }
208
209    public void testVectorLastIndexOf() {
210        int index, value = 0;
211        Vector<Integer> vector = mVector;
212        for (int i = ITERATIONS - 1; i >= 0; i--) {
213            index = vector.lastIndexOf(value);
214            index = vector.lastIndexOf(value);
215            index = vector.lastIndexOf(value);
216            index = vector.lastIndexOf(value);
217            index = vector.lastIndexOf(value);
218            index = vector.lastIndexOf(value);
219            index = vector.lastIndexOf(value);
220            index = vector.lastIndexOf(value);
221            index = vector.lastIndexOf(value);
222            index = vector.lastIndexOf(value);
223        }
224    }
225
226    public void testVectorRemove() {
227        int index, value = 0;
228        Vector<Integer> vector = new Vector(mVector);
229        for (int i = 10; i > 0; i--) {
230            index = vector.remove(value);
231            index = vector.remove(value);
232            index = vector.remove(value);
233            index = vector.remove(value);
234            index = vector.remove(value);
235            index = vector.remove(value);
236            index = vector.remove(value);
237            index = vector.remove(value);
238            index = vector.remove(value);
239            index = vector.remove(value);
240        }
241    }
242
243    public void testVectorRemoveElement() {
244        Vector<Integer> vector = new Vector(mVector);
245        for (int i = 10; i > 0; i--) {
246            vector.removeElement(i);
247            vector.removeElement(i);
248            vector.removeElement(i);
249            vector.removeElement(i);
250            vector.removeElement(i);
251            vector.removeElement(i);
252            vector.removeElement(i);
253            vector.removeElement(i);
254            vector.removeElement(i);
255            vector.removeElement(i);
256        }
257    }
258
259    public void VectorRemoveElementAt() {
260        Vector<Integer> vector = new Vector(mVector);
261        for (int i = 10; i > 0; i--) {
262            vector.removeElementAt(i);
263            vector.removeElementAt(i);
264            vector.removeElementAt(i);
265            vector.removeElementAt(i);
266            vector.removeElementAt(i);
267            vector.removeElementAt(i);
268            vector.removeElementAt(i);
269            vector.removeElementAt(i);
270            vector.removeElementAt(i);
271            vector.removeElementAt(i);
272        }
273    }
274
275    public void VectorAddAll() {
276        Vector<Integer> vector = new Vector(), vector1 = mVector;
277
278        boolean flag;
279        for (int i = 10; i > 0; i--) {
280            flag = vector.addAll(vector1);
281            flag = vector.addAll(vector1);
282            flag = vector.addAll(vector1);
283            flag = vector.addAll(vector1);
284            flag = vector.addAll(vector1);
285            flag = vector.addAll(vector1);
286            flag = vector.addAll(vector1);
287            flag = vector.addAll(vector1);
288            flag = vector.addAll(vector1);
289            flag = vector.addAll(vector1);
290        }
291    }
292
293    public void VectorRemove1() {
294        Vector<String> vector = mStrVector;
295        for (int j = 1000; j > 0; j--) {
296            vector.add("a");
297            vector.add("b");
298        }
299        String s = new String("a");
300        boolean flag;
301        for (int i = 10; i > 0; i--) {
302            flag = vector.remove(s);
303            flag = vector.remove(s);
304            flag = vector.remove(s);
305            flag = vector.remove(s);
306            flag = vector.remove(s);
307            flag = vector.remove(s);
308            flag = vector.remove(s);
309            flag = vector.remove(s);
310            flag = vector.remove(s);
311            flag = vector.remove(s);
312        }
313    }
314
315    public void testVectorAddAll1() {
316        Vector<Integer> mEmptyVector = new Vector();
317        boolean flag;
318        int pos = 0;
319        Vector<Integer> vector1 = mVector;
320        Vector<Integer> vector = mEmptyVector;
321        for (int i = 10; i > 0; i--) {
322            flag = vector.addAll(pos, vector1);
323            flag = vector.addAll(pos, vector1);
324            flag = vector.addAll(pos, vector1);
325            flag = vector.addAll(pos, vector1);
326            flag = vector.addAll(pos, vector1);
327            flag = vector.addAll(pos, vector1);
328            flag = vector.addAll(pos, vector1);
329            flag = vector.addAll(pos, vector1);
330            flag = vector.addAll(pos, vector1);
331            flag = vector.addAll(pos, vector1);
332        }
333    }
334
335    public void testVectorClone() {
336        Object obj;
337        Vector<Integer> vector = mVector;
338        for (int i = ITERATIONS - 1; i > 0; i--) {
339            obj = vector.clone();
340            obj = vector.clone();
341            obj = vector.clone();
342            obj = vector.clone();
343            obj = vector.clone();
344            obj = vector.clone();
345            obj = vector.clone();
346            obj = vector.clone();
347            obj = vector.clone();
348            obj = vector.clone();
349        }
350    }
351
352    public void testVectorCapacity() {
353        int capacity;
354        Vector<Integer> vector = mVector;
355        for (int i = ITERATIONS - 1; i > 0; i--) {
356            capacity = vector.capacity();
357            capacity = vector.capacity();
358            capacity = vector.capacity();
359            capacity = vector.capacity();
360            capacity = vector.capacity();
361            capacity = vector.capacity();
362            capacity = vector.capacity();
363            capacity = vector.capacity();
364            capacity = vector.capacity();
365            capacity = vector.capacity();
366        }
367    }
368
369    public void testVectorHashcode() {
370        int element;
371        Vector<Integer> vector = mVector;
372        for (int i = ITERATIONS - 1; i > 0; i--) {
373            element = vector.hashCode();
374            element = vector.hashCode();
375            element = vector.hashCode();
376            element = vector.hashCode();
377            element = vector.hashCode();
378            element = vector.hashCode();
379            element = vector.hashCode();
380            element = vector.hashCode();
381            element = vector.hashCode();
382            element = vector.hashCode();
383        }
384    }
385
386    public void testVectorElements() {
387        Enumeration<Integer> elements;
388        Vector<Integer> vector = mVector;
389        for (int i = ITERATIONS - 1; i > 0; i--) {
390            elements = vector.elements();
391            elements = vector.elements();
392            elements = vector.elements();
393            elements = vector.elements();
394            elements = vector.elements();
395            elements = vector.elements();
396            elements = vector.elements();
397            elements = vector.elements();
398            elements = vector.elements();
399            elements = vector.elements();
400        }
401    }
402
403    public void testVectorToString() {
404        String str;
405        Vector<Integer> vector = mVector;
406        for (int i = ITERATIONS - 1; i > 0; i--) {
407            str = vector.toString();
408            str = vector.toString();
409            str = vector.toString();
410            str = vector.toString();
411            str = vector.toString();
412            str = vector.toString();
413            str = vector.toString();
414            str = vector.toString();
415            str = vector.toString();
416            str = vector.toString();
417        }
418    }
419
420    public void testVectorElementAt() {
421        int element;
422        Vector<Integer> vector = mVector;
423        for (int i = ITERATIONS - 1; i > 0; i--) {
424            element = vector.elementAt(50);
425            element = vector.elementAt(50);
426            element = vector.elementAt(50);
427            element = vector.elementAt(50);
428            element = vector.elementAt(50);
429            element = vector.elementAt(50);
430            element = vector.elementAt(50);
431            element = vector.elementAt(50);
432            element = vector.elementAt(50);
433            element = vector.elementAt(50);
434        }
435    }
436
437    public void testVectorAddElement() {
438        int element;
439        Vector<String> vector = mStrVector;
440        for (int i = ITERATIONS - 1; i > 0; i--) {
441            vector.addElement(mTestString);
442            vector.addElement(mTestString);
443            vector.addElement(mTestString);
444            vector.addElement(mTestString);
445            vector.addElement(mTestString);
446            vector.addElement(mTestString);
447            vector.addElement(mTestString);
448            vector.addElement(mTestString);
449            vector.addElement(mTestString);
450            vector.addElement(mTestString);
451        }
452    }
453
454    public void testVectorFirstElement() {
455        int element;
456        Vector<Integer> vector = mVector;
457        for (int i = ITERATIONS - 1; i > 0; i--) {
458            element = vector.firstElement();
459            element = vector.firstElement();
460            element = vector.firstElement();
461            element = vector.firstElement();
462            element = vector.firstElement();
463            element = vector.firstElement();
464            element = vector.firstElement();
465            element = vector.firstElement();
466            element = vector.firstElement();
467            element = vector.firstElement();
468        }
469    }
470
471    public void testVectorLastElement() {
472        int element;
473        Vector<Integer> vector = mVector;
474        for (int i = ITERATIONS - 1; i > 0; i--) {
475            element = vector.lastElement();
476            element = vector.lastElement();
477            element = vector.lastElement();
478            element = vector.lastElement();
479            element = vector.lastElement();
480            element = vector.lastElement();
481            element = vector.lastElement();
482            element = vector.lastElement();
483            element = vector.lastElement();
484            element = vector.lastElement();
485        }
486    }
487
488    public void testVectorSetElementAt() {
489        Vector<Integer> vector = mVector;
490        int value1 = 500, value2 = 50;
491        for (int i = ITERATIONS - 1; i > 0; i--) {
492            vector.setElementAt(value1, value2);
493            vector.setElementAt(value1, value2);
494            vector.setElementAt(value1, value2);
495            vector.setElementAt(value1, value2);
496            vector.setElementAt(value1, value2);
497            vector.setElementAt(value1, value2);
498            vector.setElementAt(value1, value2);
499            vector.setElementAt(value1, value2);
500            vector.setElementAt(value1, value2);
501            vector.setElementAt(value1, value2);
502        }
503    }
504
505    public void testVectorIsEmpty() {
506        boolean flag;
507        Vector<Integer> vector = mVector;
508        for (int i = ITERATIONS - 1; i > 0; i--) {
509            flag = vector.isEmpty();
510            flag = vector.isEmpty();
511            flag = vector.isEmpty();
512            flag = vector.isEmpty();
513            flag = vector.isEmpty();
514            flag = vector.isEmpty();
515            flag = vector.isEmpty();
516            flag = vector.isEmpty();
517            flag = vector.isEmpty();
518            flag = vector.isEmpty();
519        }
520    }
521
522    public void testVectorCopyInto() {
523        Integer[] rArray = new Integer[ITERATIONS];
524        Vector<Integer> vector = mVector;
525        for (int i = ITERATIONS - 1; i > 0; i--) {
526            vector.copyInto(rArray);
527            vector.copyInto(rArray);
528            vector.copyInto(rArray);
529            vector.copyInto(rArray);
530            vector.copyInto(rArray);
531            vector.copyInto(rArray);
532            vector.copyInto(rArray);
533            vector.copyInto(rArray);
534            vector.copyInto(rArray);
535            vector.copyInto(rArray);
536        }
537    }
538
539    public void testVectorInsertElementAt() {
540        Vector<String> vector = mStrVector;
541        String string = mTestString;
542        for (int i = ITERATIONS - 1; i > 0; i--) {
543            vector.insertElementAt(string, i);
544            vector.insertElementAt(string, i);
545            vector.insertElementAt(string, i);
546            vector.insertElementAt(string, i);
547            vector.insertElementAt(string, i);
548            vector.insertElementAt(string, i);
549            vector.insertElementAt(string, i);
550            vector.insertElementAt(string, i);
551            vector.insertElementAt(string, i);
552            vector.insertElementAt(string, i);
553        }
554    }
555}
556