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.TreeSet;
23import java.util.SortedSet;
24import java.util.Iterator;
25import java.util.Comparator;
26
27/**
28 * Implements basic performance test functionality for java.util.TreeSet
29 */
30
31public class TreeSetTest extends PerformanceTestBase {
32    public static final int ITERATIONS = 1000;
33    public static TreeSet<Integer> sSet;
34
35    @Override
36    protected void setUp() throws Exception {
37        super.setUp();
38        sSet = new TreeSet<Integer>();
39        for (int i = ITERATIONS - 1; i >= 0; i--) {
40            sSet.add(i);
41        }
42    }
43
44    @Override
45    public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
46        intermediates.setInternalIterations(ITERATIONS);
47        return 0;
48    }
49
50    /**
51     *
52     * Tests performance for the java.util.TreeSet method Add(Object arg 0)
53     *
54     */
55
56    @SuppressWarnings("unchecked")
57    public void testTreeSetAdd() {
58        TreeSet<Integer> set = new TreeSet();
59        for (int i = ITERATIONS - 1; i >= 0; i--) {
60            set.add(i);
61            set.add(i);
62            set.add(i);
63            set.add(i);
64            set.add(i);
65            set.add(i);
66            set.add(i);
67            set.add(i);
68            set.add(i);
69            set.add(i);
70        }
71    }
72
73    /**
74     *
75     * Tests performance for the java.util.TreeSet method - first()
76     *
77     */
78
79    public void testTreeSetFirst() {
80        int value;
81        TreeSet<Integer> set = sSet;
82        for (int i = ITERATIONS - 1; i >= 0; i--) {
83            value = set.first();
84            value = set.first();
85            value = set.first();
86            value = set.first();
87            value = set.first();
88            value = set.first();
89            value = set.first();
90            value = set.first();
91            value = set.first();
92        }
93    }
94
95    /**
96     *
97     * Tests performance for the java.util.TreeSet method - last()
98     *
99     */
100
101    public void testTreeSetLast() {
102        int value;
103        TreeSet<Integer> set = sSet;
104        for (int i = ITERATIONS - 1; i >= 0; i--) {
105            value = set.last();
106            value = set.last();
107            value = set.last();
108            value = set.last();
109            value = set.last();
110            value = set.last();
111            value = set.last();
112            value = set.last();
113            value = set.last();
114        }
115    }
116
117    /**
118     *
119     * Tests performance of the java.util.TreeSet method- contains(Object arg0)
120     *
121     */
122
123    public void testTreeSetContains() {
124        Integer index = new Integer(500);
125        boolean flag;
126        TreeSet<Integer> set = sSet;
127        for (int i = ITERATIONS - 1; i >= 0; i--) {
128            flag = set.contains(index);
129            flag = set.contains(index);
130            flag = set.contains(index);
131            flag = set.contains(index);
132            flag = set.contains(index);
133            flag = set.contains(index);
134            flag = set.contains(index);
135            flag = set.contains(index);
136            flag = set.contains(index);
137        }
138    }
139
140    /**
141     *
142     * Tests performance for the java.util.TreeSet method - size()
143     *
144     */
145
146    public void testTreeSetSize() {
147        int value;
148        TreeSet<Integer> set = sSet;
149        for (int i = ITERATIONS - 1; i >= 0; i--) {
150            value = set.size();
151            value = set.size();
152            value = set.size();
153            value = set.size();
154            value = set.size();
155            value = set.size();
156            value = set.size();
157            value = set.size();
158            value = set.size();
159        }
160    }
161
162    /**
163     *
164     * Tests performance for the java.util.TreeSet method - iterator()
165     *
166     */
167
168    public void testTreeSetIterator() {
169        Iterator iterator;
170        TreeSet<Integer> set = sSet;
171        for (int i = ITERATIONS - 1; i >= 0; i--) {
172            iterator = set.iterator();
173            iterator = set.iterator();
174            iterator = set.iterator();
175            iterator = set.iterator();
176            iterator = set.iterator();
177            iterator = set.iterator();
178            iterator = set.iterator();
179            iterator = set.iterator();
180            iterator = set.iterator();
181        }
182    }
183
184    /**
185     *
186     * Tests performance for the java.util.TreeSet method - comparator()
187     *
188     */
189
190    public void testTreeSetComparator() {
191        Comparator comparator;
192        TreeSet<Integer> set = sSet;
193        for (int i = ITERATIONS - 1; i >= 0; i--) {
194            comparator = set.comparator();
195            comparator = set.comparator();
196            comparator = set.comparator();
197            comparator = set.comparator();
198            comparator = set.comparator();
199            comparator = set.comparator();
200            comparator = set.comparator();
201            comparator = set.comparator();
202            comparator = set.comparator();
203        }
204    }
205
206    /**
207     *
208     * Tests performance for the java.util.TreeSet method - clone()
209     *
210     */
211
212    public void testTreeSetClone() {
213        Object obj;
214        TreeSet<Integer> set = sSet;
215        for (int i = ITERATIONS - 1; i >= 0; i--) {
216            obj = set.clone();
217            obj = set.clone();
218            obj = set.clone();
219            obj = set.clone();
220            obj = set.clone();
221            obj = set.clone();
222            obj = set.clone();
223            obj = set.clone();
224            obj = set.clone();
225            obj = set.clone();
226        }
227    }
228
229    /**
230     *
231     * Tests performance of the java.util.TreeSet method - remove(Object arg0)
232     *
233     */
234
235    @SuppressWarnings("unchecked")
236    public void testTreeSetRemove() {
237        TreeSet<Integer> set = new TreeSet(sSet);
238        for (int i = ITERATIONS - 1; i >= 0; i--) {
239            set.remove(i);
240            set.remove(i);
241            set.remove(i);
242            set.remove(i);
243            set.remove(i);
244            set.remove(i);
245            set.remove(i);
246            set.remove(i);
247            set.remove(i);
248            set.remove(i);
249        }
250    }
251
252    /**
253     *
254     * Tests performance of the java.util.TreeSet method- headSet(Integer arg0)
255     *
256     */
257
258    public void testTreeSetHeadSet() {
259        Integer value = new Integer(100);
260        SortedSet set;
261        TreeSet<Integer> tSet = sSet;
262        for (int i = ITERATIONS - 1; i >= 0; i--) {
263            set = tSet.headSet(value);
264            set = tSet.headSet(value);
265            set = tSet.headSet(value);
266            set = tSet.headSet(value);
267            set = tSet.headSet(value);
268            set = tSet.headSet(value);
269            set = tSet.headSet(value);
270            set = tSet.headSet(value);
271            set = tSet.headSet(value);
272            set = tSet.headSet(value);
273        }
274    }
275
276    /**
277     *
278     * Tests performance of subSet(Integer arg0, Integer arg1) - TreeSet
279     *
280     */
281
282    public void testTreeSetSubSet() {
283        Integer value = new Integer(400);
284        Integer nInt = new Integer(500);
285        SortedSet set;
286        TreeSet<Integer> tSet = sSet;
287        for (int i = ITERATIONS - 1; i >= 0; i--) {
288            set = tSet.subSet(value, nInt);
289            set = tSet.subSet(value, nInt);
290            set = tSet.subSet(value, nInt);
291            set = tSet.subSet(value, nInt);
292            set = tSet.subSet(value, nInt);
293            set = tSet.subSet(value, nInt);
294            set = tSet.subSet(value, nInt);
295            set = tSet.subSet(value, nInt);
296            set = tSet.subSet(value, nInt);
297            set = tSet.subSet(value, nInt);
298
299        }
300
301    }
302
303    /**
304     *
305     * Tests performance of tailSet(Integer arg0) - TreeSet
306     *
307     */
308
309    public void testTreeSetTailSet() {
310        Integer value = new Integer(900);
311        SortedSet set;
312        TreeSet<Integer> tSet = sSet;
313        for (int i = ITERATIONS - 1; i >= 0; i--) {
314            set = tSet.tailSet(value);
315            set = tSet.tailSet(value);
316            set = tSet.tailSet(value);
317            set = tSet.tailSet(value);
318            set = tSet.tailSet(value);
319            set = tSet.tailSet(value);
320            set = tSet.tailSet(value);
321            set = tSet.tailSet(value);
322            set = tSet.tailSet(value);
323            set = tSet.tailSet(value);
324        }
325    }
326
327    /**
328     *
329     * Tests performance for the java.util.TreeSet method - isEmpty()
330     *
331     */
332
333    public void testTreeSetIsEmpty() {
334        boolean flag;
335        TreeSet<Integer> tSet = sSet;
336        for (int i = ITERATIONS - 1; i >= 0; i--) {
337            flag = tSet.isEmpty();
338            flag = tSet.isEmpty();
339            flag = tSet.isEmpty();
340            flag = tSet.isEmpty();
341            flag = tSet.isEmpty();
342            flag = tSet.isEmpty();
343            flag = tSet.isEmpty();
344            flag = tSet.isEmpty();
345            flag = tSet.isEmpty();
346            flag = tSet.isEmpty();
347        }
348    }
349}
350