1/**
2 * Copyright (C) 2009 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.internal.telephony;
18
19import com.android.internal.telephony.RetryManager;
20import junit.framework.TestCase;
21import android.test.suitebuilder.annotation.SmallTest;
22
23public class TelephonyUtilsTest extends TestCase {
24
25    /**
26     * After first creating the RetryManager
27     * isRetryNeeded should be false and the time 0
28     */
29    @SmallTest
30    public void testRetryManagerEmpty() throws Exception {
31        RetryManager rm = new RetryManager();
32
33        assertEquals(0, rm.getRetryCount());
34        assertFalse(rm.isRetryForever());
35        assertFalse(rm.isRetryNeeded());
36        assertEquals(0, rm.getRetryCount());
37        assertEquals(0, rm.getRetryTimer());
38
39        rm.increaseRetryCount();
40        assertFalse(rm.isRetryForever());
41        assertFalse(rm.isRetryNeeded());
42        assertEquals(0, rm.getRetryCount());
43        assertEquals(0, rm.getRetryTimer());
44
45        rm.setRetryCount(123);
46        assertFalse(rm.isRetryForever());
47        assertFalse(rm.isRetryNeeded());
48        assertEquals(0, rm.getRetryCount());
49        assertEquals(0, rm.getRetryTimer());
50
51        rm.retryForeverUsingLastTimeout();
52        assertTrue(rm.isRetryForever());
53        assertTrue(rm.isRetryNeeded());
54        assertEquals(0, rm.getRetryCount());
55        assertEquals(0, rm.getRetryTimer());
56
57        rm.setRetryCount(2);
58        assertTrue(rm.isRetryForever());
59        assertTrue(rm.isRetryNeeded());
60        assertEquals(0, rm.getRetryCount());
61        assertEquals(0, rm.getRetryTimer());
62    }
63
64    /**
65     * A simple test and that randomization is doing something.
66     */
67    @SmallTest
68    public void testRetryManagerSimplest() throws Exception {
69        RetryManager rm = new RetryManager();
70
71        assertTrue(rm.configure(1, 500, 10));
72        int loops = 10;
73        int count = 0;
74        for (int i = 0; i < loops; i++) {
75            assertTrue(rm.isRetryNeeded());
76            int time = rm.getRetryTimer();
77            assertTrue((time >= 500) && (time < 600));
78            if (time == 500) {
79                count++;
80            }
81        }
82        assertFalse(count == loops);
83        rm.increaseRetryCount();
84        assertFalse(rm.isRetryNeeded());
85        rm.setRetryCount(0);
86        assertTrue(rm.isRetryNeeded());
87    }
88
89    /**
90     * Test multiple values using simple configuration.
91     */
92    @SmallTest
93    public void testRetryManagerSimple() throws Exception {
94        RetryManager rm = new RetryManager();
95
96        assertTrue(rm.configure(3, 1000, 0));
97        assertTrue(rm.isRetryNeeded());
98        assertEquals(1000, rm.getRetryTimer());
99        assertEquals(rm.getRetryTimer(), 1000);
100        rm.increaseRetryCount();
101        assertTrue(rm.isRetryNeeded());
102        assertEquals(1000, rm.getRetryTimer());
103        rm.increaseRetryCount();
104        assertTrue(rm.isRetryNeeded());
105        assertEquals(1000, rm.getRetryTimer());
106        rm.increaseRetryCount();
107        assertFalse(rm.isRetryNeeded());
108        assertEquals(1000, rm.getRetryTimer());
109    }
110
111    /**
112     * Test string configuration, simplest
113     */
114    @SmallTest
115    public void testRetryManageSimpleString() throws Exception {
116        RetryManager rm = new RetryManager();
117
118        assertTrue(rm.configure("101"));
119        assertTrue(rm.isRetryNeeded());
120        assertEquals(101, rm.getRetryTimer());
121        rm.increaseRetryCount();
122        assertFalse(rm.isRetryNeeded());
123    }
124
125    /**
126     * Test infinite retires
127     */
128    @SmallTest
129    public void testRetryManageInfinite() throws Exception {
130        RetryManager rm = new RetryManager();
131
132        assertTrue(rm.configure("1000,2000,3000,max_retries=infinite"));
133        assertTrue(rm.isRetryNeeded());
134        assertEquals(1000, rm.getRetryTimer());
135        rm.increaseRetryCount();
136        assertTrue(rm.isRetryNeeded());
137        assertEquals(2000, rm.getRetryTimer());
138        rm.increaseRetryCount();
139        assertTrue(rm.isRetryNeeded());
140        // All others are 3000 and isRetryNeeded is always true
141        for (int i=0; i < 100; i++) {
142            assertEquals(3000, rm.getRetryTimer());
143            rm.increaseRetryCount();
144            assertTrue(rm.isRetryNeeded());
145        }
146    }
147
148    /**
149     * Test string configuration using all options and with quotes.
150     */
151    @SmallTest
152    public void testRetryManageString() throws Exception {
153        RetryManager rm = new RetryManager();
154        int time;
155
156        assertTrue(rm.configure(
157                "\"max_retries=4, default_randomization=100,1000, 2000 :200 , 3000\""));
158        assertTrue(rm.isRetryNeeded());
159        time = rm.getRetryTimer();
160        assertTrue((time >= 1000) && (time < 1100));
161
162        rm.increaseRetryCount();
163        assertTrue(rm.isRetryNeeded());
164        time = rm.getRetryTimer();
165        assertTrue((time >= 2000) && (time < 2200));
166
167        rm.increaseRetryCount();
168        assertTrue(rm.isRetryNeeded());
169        time = rm.getRetryTimer();
170        assertTrue((time >= 3000) && (time < 3100));
171
172        rm.increaseRetryCount();
173        assertTrue(rm.isRetryNeeded());
174        time = rm.getRetryTimer();
175        assertTrue((time >= 3000) && (time < 3100));
176
177        rm.increaseRetryCount();
178        assertFalse(rm.isRetryNeeded());
179    }
180
181    /**
182     * Test string configuration using all options.
183     */
184    @SmallTest
185    public void testRetryManageForever() throws Exception {
186        RetryManager rm = new RetryManager();
187        int time;
188
189        assertTrue(rm.configure("1000, 2000, 3000"));
190        assertTrue(rm.isRetryNeeded());
191        assertFalse(rm.isRetryForever());
192        assertEquals(0, rm.getRetryCount());
193        assertEquals(1000, rm.getRetryTimer());
194
195        rm.retryForeverUsingLastTimeout();
196        rm.increaseRetryCount();
197        rm.increaseRetryCount();
198        rm.increaseRetryCount();
199        assertTrue(rm.isRetryNeeded());
200        assertTrue(rm.isRetryForever());
201        assertEquals(3, rm.getRetryCount());
202        assertEquals(3000, rm.getRetryTimer());
203
204        rm.setRetryCount(1);
205        assertTrue(rm.isRetryNeeded());
206        assertTrue(rm.isRetryForever());
207        assertEquals(1, rm.getRetryCount());
208        assertEquals(2000, rm.getRetryTimer());
209
210        rm.retryForeverUsingLastTimeout();
211        assertTrue(rm.isRetryNeeded());
212        assertTrue(rm.isRetryForever());
213        rm.resetRetryCount();
214        assertTrue(rm.isRetryNeeded());
215        assertTrue(rm.isRetryForever());
216        assertEquals(0, rm.getRetryCount());
217        assertEquals(1000, rm.getRetryTimer());
218    }
219}
220