1/**
2 * Copyright (C) 2015 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.dataconnection;
18
19import android.os.PersistableBundle;
20import android.telephony.CarrierConfigManager;
21import android.test.suitebuilder.annotation.SmallTest;
22
23import com.android.internal.telephony.RetryManager;
24import com.android.internal.telephony.SubscriptionController;
25import com.android.internal.telephony.TelephonyTest;
26import com.android.internal.telephony.uicc.UiccController;
27
28import org.junit.After;
29import org.junit.Before;
30import org.junit.Test;
31
32import java.util.ArrayList;
33
34import static org.junit.Assert.assertEquals;
35import static org.junit.Assert.assertTrue;
36
37/**
38 * APN retry manager tests
39 */
40public class RetryManagerTest extends TelephonyTest {
41
42    // This is the real APN data for the Japanese carrier NTT Docomo.
43    private ApnSetting mApn1 = new ApnSetting(
44            2163,                   // id
45            "44010",                // numeric
46            "sp-mode",              // name
47            "spmode.ne.jp",         // apn
48            "",                     // proxy
49            "",                     // port
50            "",                     // mmsc
51            "",                     // mmsproxy
52            "",                     // mmsport
53            "",                     // user
54            "",                     // password
55            -1,                     // authtype
56            new String[]{"default", "supl"},     // types
57            "IP",                   // protocol
58            "IP",                   // roaming_protocol
59            true,                   // carrier_enabled
60            0,                      // bearer
61            0,                      // bearer_bitmask
62            0,                      // profile_id
63            false,                  // modem_cognitive
64            0,                      // max_conns
65            0,                      // wait_time
66            0,                      // max_conns_time
67            0,                      // mtu
68            "",                     // mvno_type
69            "");                    // mnvo_match_data
70
71    private ApnSetting mApn2 = new ApnSetting(
72            2164,                   // id
73            "44010",                // numeric
74            "mopera U",             // name
75            "mopera.net",           // apn
76            "",                     // proxy
77            "",                     // port
78            "",                     // mmsc
79            "",                     // mmsproxy
80            "",                     // mmsport
81            "",                     // user
82            "",                     // password
83            -1,                     // authtype
84            new String[]{"default", "supl"},     // types
85            "IP",                   // protocol
86            "IP",                   // roaming_protocol
87            true,                   // carrier_enabled
88            0,                      // bearer
89            0,                      // bearer_bitmask
90            0,                      // profile_id
91            false,                  // modem_cognitive
92            0,                      // max_conns
93            0,                      // wait_time
94            0,                      // max_conns_time
95            0,                      // mtu
96            "",                     // mvno_type
97            "");                    // mnvo_match_data
98
99    private ApnSetting mApn3 = new ApnSetting(
100            2165,                   // id
101            "44010",                // numeric
102            "b-mobile for Nexus",   // name
103            "bmobile.ne.jp",        // apn
104            "",                     // proxy
105            "",                     // port
106            "",                     // mmsc
107            "",                     // mmsproxy
108            "",                     // mmsport
109            "",                     // user
110            "",                     // password
111            3,                      // authtype
112            new String[]{"default", "supl"},     // types
113            "IP",                   // protocol
114            "IP",                   // roaming_protocol
115            true,                   // carrier_enabled
116            0,                      // bearer
117            0,                      // bearer_bitmask
118            0,                      // profile_id
119            false,                  // modem_cognitive
120            0,                      // max_conns
121            0,                      // wait_time
122            0,                      // max_conns_time
123            0,                      // mtu
124            "",                     // mvno_type
125            "");                    // mnvo_match_data
126
127    private PersistableBundle mBundle;
128
129    @Before
130    public void setUp() throws Exception {
131        super.setUp(getClass().getSimpleName());
132        mBundle = mContextFixture.getCarrierConfigBundle();
133
134        replaceInstance(SubscriptionController.class, "sInstance", null, mSubscriptionController);
135        replaceInstance(UiccController.class, "mInstance", null, mUiccController);
136    }
137
138    @After
139    public void tearDown() throws Exception {
140        super.tearDown();
141    }
142
143    /**
144     * Test the behavior of a retry manager with no waiting APNs set.
145     */
146    @Test
147    @SmallTest
148    public void testRetryManagerEmpty() throws Exception {
149
150        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
151                new String[]{"default:2000"});
152
153        RetryManager rm = new RetryManager(mPhone, "default");
154
155        long delay = rm.getDelayForNextApn(false);
156        assertEquals(RetryManager.NO_RETRY, delay);
157
158        ApnSetting nextApn = rm.getNextApnSetting();
159        assertTrue(nextApn == null);
160        delay = rm.getDelayForNextApn(false);
161        assertEquals(RetryManager.NO_RETRY, delay);
162    }
163
164    /**
165     * Test the basic retry scenario where only one APN and no retry configured.
166     */
167    @Test
168    @SmallTest
169    public void testRetryManagerOneApnNoRetry() throws Exception {
170
171        mBundle.putStringArray(
172                CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
173                new String[]{"default:"});
174
175        ArrayList<ApnSetting> waitingApns = new ArrayList<ApnSetting>();
176        waitingApns.add(new ApnSetting(mApn1));
177
178        RetryManager rm = new RetryManager(mPhone, "default");
179        rm.setWaitingApns(waitingApns);
180
181        ApnSetting nextApn = rm.getNextApnSetting();
182        assertTrue(nextApn.equals(mApn1));
183        long delay = rm.getDelayForNextApn(false);
184        assertEquals(RetryManager.NO_RETRY, delay);
185    }
186
187    /**
188     * Test the basic retry scenario where only one APN with two retries configured.
189     */
190    @Test
191    @SmallTest
192    public void testRetryManagerOneApnTwoRetries() throws Exception {
193
194        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
195                new String[]{"supl:2000,3000"});
196
197        ArrayList<ApnSetting> waitingApns = new ArrayList<ApnSetting>();
198        waitingApns.add(new ApnSetting(mApn1));
199
200        RetryManager rm = new RetryManager(mPhone, "supl");
201        rm.setWaitingApns(waitingApns);
202
203        ApnSetting nextApn = rm.getNextApnSetting();
204        assertTrue(nextApn.equals(mApn1));
205        long delay = rm.getDelayForNextApn(false);
206        assertEquals(2000, delay);
207
208        nextApn = rm.getNextApnSetting();
209        assertTrue(nextApn.equals(mApn1));
210        delay = rm.getDelayForNextApn(false);
211        assertEquals(3000, delay);
212
213        nextApn = rm.getNextApnSetting();
214        assertTrue(nextApn.equals(mApn1));
215        delay = rm.getDelayForNextApn(false);
216        assertEquals(RetryManager.NO_RETRY, delay);
217
218        // No matter how many times we call getNextApnSetting, it should always return the next APN
219        // with NO_RETRY because we've already reached the maximum retry count.
220        nextApn = rm.getNextApnSetting();
221        assertTrue(nextApn.equals(mApn1));
222        delay = rm.getDelayForNextApn(false);
223        assertEquals(RetryManager.NO_RETRY, delay);
224
225        nextApn = rm.getNextApnSetting();
226        assertTrue(nextApn.equals(mApn1));
227        delay = rm.getDelayForNextApn(false);
228        assertEquals(RetryManager.NO_RETRY, delay);
229
230        nextApn = rm.getNextApnSetting();
231        assertTrue(nextApn.equals(mApn1));
232        delay = rm.getDelayForNextApn(false);
233        assertEquals(RetryManager.NO_RETRY, delay);
234
235        nextApn = rm.getNextApnSetting();
236        assertTrue(nextApn.equals(mApn1));
237        delay = rm.getDelayForNextApn(false);
238        assertEquals(RetryManager.NO_RETRY, delay);
239    }
240
241    /**
242     * Test the basic retry scenario where two waiting APNs with one retry configured.
243     */
244    @Test
245    @SmallTest
246    public void testRetryManagerTwoApnsOneRetry() throws Exception {
247
248        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
249                new String[]{"others:2000"});
250
251        ArrayList<ApnSetting> waitingApns = new ArrayList<ApnSetting>();
252        waitingApns.add(new ApnSetting(mApn1));
253        waitingApns.add(new ApnSetting(mApn2));
254
255        RetryManager rm = new RetryManager(mPhone, "default");
256        rm.setWaitingApns(waitingApns);
257
258        ApnSetting nextApn = rm.getNextApnSetting();
259        assertTrue(nextApn.equals(mApn1));
260        long delay = rm.getDelayForNextApn(false);
261        assertEquals(20000, delay);
262
263        nextApn = rm.getNextApnSetting();
264        assertTrue(nextApn.equals(mApn2));
265        delay = rm.getDelayForNextApn(false);
266        assertEquals(2000, delay);
267
268        nextApn = rm.getNextApnSetting();
269        assertTrue(nextApn.equals(mApn1));
270        delay = rm.getDelayForNextApn(false);
271        assertEquals(20000, delay);
272
273        nextApn = rm.getNextApnSetting();
274        assertTrue(nextApn.equals(mApn2));
275        delay = rm.getDelayForNextApn(false);
276        assertEquals(RetryManager.NO_RETRY, delay);
277    }
278
279    /**
280     * Test the basic retry scenario where two waiting APNs with two retries configured.
281     */
282    @Test
283    @SmallTest
284    public void testRetryManagerTwoApnsTwoRetries() throws Exception {
285
286        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
287                new String[]{"dun:2000,5000"});
288
289        ArrayList<ApnSetting> waitingApns = new ArrayList<ApnSetting>();
290        waitingApns.add(new ApnSetting(mApn1));
291        waitingApns.add(new ApnSetting(mApn2));
292
293        RetryManager rm = new RetryManager(mPhone, "dun");
294        rm.setWaitingApns(waitingApns);
295
296        ApnSetting nextApn = rm.getNextApnSetting();
297        assertTrue(nextApn.equals(mApn1));
298        long delay = rm.getDelayForNextApn(false);
299        assertEquals(20000, delay);
300
301        nextApn = rm.getNextApnSetting();
302        assertTrue(nextApn.equals(mApn2));
303        delay = rm.getDelayForNextApn(false);
304        assertEquals(2000, delay);
305
306        nextApn = rm.getNextApnSetting();
307        assertTrue(nextApn.equals(mApn1));
308        delay = rm.getDelayForNextApn(false);
309        assertEquals(20000, delay);
310
311        nextApn = rm.getNextApnSetting();
312        assertTrue(nextApn.equals(mApn2));
313        delay = rm.getDelayForNextApn(false);
314        assertEquals(5000, delay);
315
316        nextApn = rm.getNextApnSetting();
317        assertTrue(nextApn.equals(mApn1));
318        delay = rm.getDelayForNextApn(false);
319        assertEquals(20000, delay);
320
321        nextApn = rm.getNextApnSetting();
322        assertTrue(nextApn.equals(mApn2));
323        delay = rm.getDelayForNextApn(false);
324        assertEquals(RetryManager.NO_RETRY, delay);
325    }
326
327    /**
328     * Test the basic retry scenario where two mms APNs with two retries configured.
329     */
330    @Test
331    @SmallTest
332    public void testRetryManagerTwoMmsApnsTwoRetries() throws Exception {
333
334        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
335                new String[]{"mms:      3000,6000"});
336
337        ArrayList<ApnSetting> waitingApns = new ArrayList<ApnSetting>();
338        waitingApns.add(new ApnSetting(mApn1));
339        waitingApns.add(new ApnSetting(mApn2));
340
341        RetryManager rm = new RetryManager(mPhone, "mms");
342        rm.setWaitingApns(waitingApns);
343
344        ApnSetting nextApn = rm.getNextApnSetting();
345        assertTrue(nextApn.equals(mApn1));
346        long delay = rm.getDelayForNextApn(false);
347        assertEquals(20000, delay);
348
349        nextApn = rm.getNextApnSetting();
350        assertTrue(nextApn.equals(mApn2));
351        delay = rm.getDelayForNextApn(false);
352        assertEquals(3000, delay);
353
354        nextApn = rm.getNextApnSetting();
355        assertTrue(nextApn.equals(mApn1));
356        delay = rm.getDelayForNextApn(false);
357        assertEquals(20000, delay);
358
359        nextApn = rm.getNextApnSetting();
360        assertTrue(nextApn.equals(mApn2));
361        delay = rm.getDelayForNextApn(false);
362        assertEquals(6000, delay);
363
364        nextApn = rm.getNextApnSetting();
365        assertTrue(nextApn.equals(mApn1));
366        delay = rm.getDelayForNextApn(false);
367        assertEquals(20000, delay);
368
369        nextApn = rm.getNextApnSetting();
370        assertTrue(nextApn.equals(mApn2));
371        delay = rm.getDelayForNextApn(false);
372        assertEquals(RetryManager.NO_RETRY, delay);
373    }
374
375    /**
376     * Test the permanent fail scenario with one APN configured.
377     */
378    @Test
379    @SmallTest
380    public void testRetryManagerApnPermanentFailed() throws Exception {
381
382        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
383                new String[]{"fota:1000,4000,7000"});
384
385        ArrayList<ApnSetting> waitingApns = new ArrayList<ApnSetting>();
386        ApnSetting apn = new ApnSetting(mApn1);
387        waitingApns.add(apn);
388
389        RetryManager rm = new RetryManager(mPhone, "fota");
390        rm.setWaitingApns(waitingApns);
391
392        ApnSetting nextApn = rm.getNextApnSetting();
393        assertTrue(nextApn.equals(mApn1));
394        long delay = rm.getDelayForNextApn(false);
395        assertEquals(1000, delay);
396
397        nextApn = rm.getNextApnSetting();
398        assertTrue(nextApn.equals(mApn1));
399        delay = rm.getDelayForNextApn(false);
400        assertEquals(4000, delay);
401
402        rm.markApnPermanentFailed(apn);
403
404        nextApn = rm.getNextApnSetting();
405        assertTrue(nextApn == null);
406    }
407
408    /**
409     * Test the permanent fail scenario with two APNs configured.
410     */
411    @Test
412    @SmallTest
413    public void testRetryManagerApnPermanentFailedWithTwoApns() throws Exception {
414
415        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
416                new String[]{"xyz  :   1000,4000,7000"});
417
418        ArrayList<ApnSetting> waitingApns = new ArrayList<ApnSetting>();
419        ApnSetting myApn1 = new ApnSetting(mApn1);
420        ApnSetting myApn2 = new ApnSetting(mApn2);
421        waitingApns.add(myApn1);
422        waitingApns.add(myApn2);
423
424        RetryManager rm = new RetryManager(mPhone, "xyz");
425        rm.setWaitingApns(waitingApns);
426
427        ApnSetting nextApn = rm.getNextApnSetting();
428        assertTrue(nextApn.equals(mApn1));
429        long delay = rm.getDelayForNextApn(false);
430        assertEquals(20000, delay);
431
432        nextApn = rm.getNextApnSetting();
433        assertTrue(nextApn.equals(mApn2));
434        delay = rm.getDelayForNextApn(false);
435        assertEquals(1000, delay);
436
437        nextApn = rm.getNextApnSetting();
438        assertTrue(nextApn.equals(mApn1));
439        delay = rm.getDelayForNextApn(false);
440        assertEquals(20000, delay);
441
442        rm.markApnPermanentFailed(myApn1);
443
444        nextApn = rm.getNextApnSetting();
445        assertTrue(nextApn.equals(mApn2));
446        delay = rm.getDelayForNextApn(false);
447        assertEquals(4000, delay);
448
449        nextApn = rm.getNextApnSetting();
450        assertTrue(nextApn.equals(mApn2));
451        delay = rm.getDelayForNextApn(false);
452        assertEquals(7000, delay);
453
454        nextApn = rm.getNextApnSetting();
455        assertTrue(nextApn.equals(mApn2));
456        delay = rm.getDelayForNextApn(false);
457        assertEquals(RetryManager.NO_RETRY, delay);
458
459        nextApn = rm.getNextApnSetting();
460        assertTrue(nextApn.equals(mApn2));
461        delay = rm.getDelayForNextApn(false);
462        assertEquals(RetryManager.NO_RETRY, delay);
463    }
464
465    /**
466     * Test the permanent fail scenario with three APNs configured.
467     */
468    @Test
469    @SmallTest
470    public void testRetryManagerApnPermanentFailedWithThreeApns() throws Exception {
471
472        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
473                new String[]{"default:2000:2000,3000:3000", "ims:1000,4000"});
474
475        ArrayList<ApnSetting> waitingApns = new ArrayList<ApnSetting>();
476        ApnSetting myApn1 = new ApnSetting(mApn1);
477        ApnSetting myApn2 = new ApnSetting(mApn2);
478        ApnSetting myApn3 = new ApnSetting(mApn3);
479        waitingApns.add(myApn1);
480        waitingApns.add(myApn2);
481        waitingApns.add(myApn3);
482
483        RetryManager rm = new RetryManager(mPhone, "ims");
484        rm.setWaitingApns(waitingApns);
485
486        ApnSetting nextApn = rm.getNextApnSetting();
487        assertTrue(nextApn.equals(mApn1));
488        long delay = rm.getDelayForNextApn(false);
489        assertEquals(20000, delay);
490
491        nextApn = rm.getNextApnSetting();
492        assertTrue(nextApn.equals(mApn2));
493        delay = rm.getDelayForNextApn(false);
494        assertEquals(20000, delay);
495
496        rm.markApnPermanentFailed(myApn2);
497
498        nextApn = rm.getNextApnSetting();
499        assertTrue(nextApn.equals(mApn3));
500        delay = rm.getDelayForNextApn(false);
501        assertEquals(1000, delay);
502
503        nextApn = rm.getNextApnSetting();
504        assertTrue(nextApn.equals(mApn1));
505        delay = rm.getDelayForNextApn(false);
506        assertEquals(20000, delay);
507
508        nextApn = rm.getNextApnSetting();
509        assertTrue(nextApn.equals(mApn3));
510        delay = rm.getDelayForNextApn(false);
511        assertEquals(4000, delay);
512
513        nextApn = rm.getNextApnSetting();
514        assertTrue(nextApn.equals(mApn1));
515        delay = rm.getDelayForNextApn(false);
516        assertEquals(20000, delay);
517
518        nextApn = rm.getNextApnSetting();
519        assertTrue(nextApn.equals(mApn3));
520        delay = rm.getDelayForNextApn(false);
521        assertEquals(RetryManager.NO_RETRY, delay);
522    }
523
524    /**
525     * Test the permanent fail scenario with two APN all failed
526     */
527    @Test
528    @SmallTest
529    public void testRetryManagerApnPermanentFailedAll() throws Exception {
530
531        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
532                new String[]{"default:1000,4000,7000,9000", "mms:1234,4123"});
533
534        ArrayList<ApnSetting> waitingApns = new ArrayList<ApnSetting>();
535        ApnSetting myApn1 = new ApnSetting(mApn1);
536        ApnSetting myApn2 = new ApnSetting(mApn2);
537        waitingApns.add(myApn1);
538        waitingApns.add(myApn2);
539
540        RetryManager rm = new RetryManager(mPhone, "default");
541        rm.setWaitingApns(waitingApns);
542
543        ApnSetting nextApn = rm.getNextApnSetting();
544        assertTrue(nextApn.equals(mApn1));
545        long delay = rm.getDelayForNextApn(false);
546        assertEquals(20000, delay);
547
548        nextApn = rm.getNextApnSetting();
549        assertTrue(nextApn.equals(mApn2));
550        delay = rm.getDelayForNextApn(false);
551        assertEquals(1000, delay);
552
553        nextApn = rm.getNextApnSetting();
554        assertTrue(nextApn.equals(mApn1));
555        delay = rm.getDelayForNextApn(false);
556        assertEquals(20000, delay);
557
558        rm.markApnPermanentFailed(myApn1);
559
560        nextApn = rm.getNextApnSetting();
561        assertTrue(nextApn.equals(mApn2));
562        delay = rm.getDelayForNextApn(false);
563        assertEquals(4000, delay);
564
565        nextApn = rm.getNextApnSetting();
566        assertTrue(nextApn.equals(mApn2));
567        delay = rm.getDelayForNextApn(false);
568        assertEquals(7000, delay);
569
570        rm.markApnPermanentFailed(myApn2);
571
572        nextApn = rm.getNextApnSetting();
573        assertTrue(nextApn == null);
574
575        nextApn = rm.getNextApnSetting();
576        assertTrue(nextApn == null);
577    }
578
579    /**
580     * Test the randomized delay scenario.
581     */
582    @Test
583    @SmallTest
584    public void testRetryManagerDelayWithRandomization() throws Exception {
585
586        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
587                new String[]{"default:default_randomization=1000,3000:2000,6000:3000,10000"});
588
589        ArrayList<ApnSetting> waitingApns = new ArrayList<ApnSetting>();
590        waitingApns.add(new ApnSetting(mApn1));
591
592        RetryManager rm = new RetryManager(mPhone, "default");
593        rm.setWaitingApns(waitingApns);
594
595        ApnSetting nextApn = rm.getNextApnSetting();
596        assertTrue(nextApn.equals(mApn1));
597        long delay = rm.getDelayForNextApn(false);
598        assertTrue(delay >= 3000 && delay < 5000);    // 3s + 2s rand
599
600        nextApn = rm.getNextApnSetting();
601        assertTrue(nextApn.equals(mApn1));
602        delay = rm.getDelayForNextApn(false);
603        assertTrue(delay >= 6000 && delay < 9000);    // 6s + 3s rand
604
605        nextApn = rm.getNextApnSetting();
606        assertTrue(nextApn.equals(mApn1));
607        delay = rm.getDelayForNextApn(false);
608        assertTrue(delay >= 10000 && delay < 11000);  // 10s + 1s default rand
609
610        nextApn = rm.getNextApnSetting();
611        assertTrue(nextApn.equals(mApn1));
612        delay = rm.getDelayForNextApn(false);
613        assertEquals(RetryManager.NO_RETRY, delay);
614    }
615
616    /**
617     * Test the retry forever scenario
618     */
619    @Test
620    @SmallTest
621    public void testRetryManagerRetryForever() throws Exception {
622
623        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
624                new String[]{"default:max_retries=infinite,1000,2000"});
625
626        ArrayList<ApnSetting> waitingApns = new ArrayList<ApnSetting>();
627        waitingApns.add(new ApnSetting(mApn1));
628        waitingApns.add(new ApnSetting(mApn2));
629
630        RetryManager rm = new RetryManager(mPhone, "default");
631        rm.setWaitingApns(waitingApns);
632
633        ApnSetting nextApn = rm.getNextApnSetting();
634        assertTrue(nextApn.equals(mApn1));
635        long delay = rm.getDelayForNextApn(false);
636        assertEquals(20000, delay);
637
638        nextApn = rm.getNextApnSetting();
639        assertTrue(nextApn.equals(mApn2));
640        delay = rm.getDelayForNextApn(false);
641        assertEquals(1000, delay);
642
643        nextApn = rm.getNextApnSetting();
644        assertTrue(nextApn.equals(mApn1));
645        delay = rm.getDelayForNextApn(false);
646        assertEquals(20000, delay);
647
648        nextApn = rm.getNextApnSetting();
649        assertTrue(nextApn.equals(mApn2));
650        delay = rm.getDelayForNextApn(false);
651        assertEquals(2000, delay);
652
653        nextApn = rm.getNextApnSetting();
654        assertTrue(nextApn.equals(mApn1));
655        delay = rm.getDelayForNextApn(false);
656        assertEquals(20000, delay);
657
658        nextApn = rm.getNextApnSetting();
659        assertTrue(nextApn.equals(mApn2));
660        delay = rm.getDelayForNextApn(false);
661        assertEquals(2000, delay);
662
663        nextApn = rm.getNextApnSetting();
664        assertTrue(nextApn.equals(mApn1));
665        delay = rm.getDelayForNextApn(false);
666        assertEquals(20000, delay);
667
668        nextApn = rm.getNextApnSetting();
669        assertTrue(nextApn.equals(mApn2));
670        delay = rm.getDelayForNextApn(false);
671        assertEquals(2000, delay);
672    }
673
674    /**
675     * Test the explicit max retry scenario.
676     */
677    @Test
678    @SmallTest
679    public void testRetryManagerExplicitMaxRetry() throws Exception {
680
681        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
682                new String[]{"hipri:  max_retries=4,1000,2000"});
683
684        ArrayList<ApnSetting> waitingApns = new ArrayList<ApnSetting>();
685        waitingApns.add(new ApnSetting(mApn1));
686        waitingApns.add(new ApnSetting(mApn2));
687
688        RetryManager rm = new RetryManager(mPhone, "hipri");
689        rm.setWaitingApns(waitingApns);
690
691        ApnSetting nextApn = rm.getNextApnSetting();
692        assertTrue(nextApn.equals(mApn1));
693        long delay = rm.getDelayForNextApn(false);
694        assertEquals(20000, delay);
695
696        nextApn = rm.getNextApnSetting();
697        assertTrue(nextApn.equals(mApn2));
698        delay = rm.getDelayForNextApn(false);
699        assertEquals(1000, delay);
700
701        nextApn = rm.getNextApnSetting();
702        assertTrue(nextApn.equals(mApn1));
703        delay = rm.getDelayForNextApn(false);
704        assertEquals(20000, delay);
705
706        nextApn = rm.getNextApnSetting();
707        assertTrue(nextApn.equals(mApn2));
708        delay = rm.getDelayForNextApn(false);
709        assertEquals(2000, delay);
710
711        nextApn = rm.getNextApnSetting();
712        assertTrue(nextApn.equals(mApn1));
713        delay = rm.getDelayForNextApn(false);
714        assertEquals(20000, delay);
715
716        nextApn = rm.getNextApnSetting();
717        assertTrue(nextApn.equals(mApn2));
718        delay = rm.getDelayForNextApn(false);
719        assertEquals(2000, delay);
720
721        nextApn = rm.getNextApnSetting();
722        assertTrue(nextApn.equals(mApn1));
723        delay = rm.getDelayForNextApn(false);
724        assertEquals(20000, delay);
725
726        nextApn = rm.getNextApnSetting();
727        assertTrue(nextApn.equals(mApn2));
728        delay = rm.getDelayForNextApn(false);
729        assertEquals(2000, delay);
730
731        nextApn = rm.getNextApnSetting();
732        assertTrue(nextApn.equals(mApn1));
733        delay = rm.getDelayForNextApn(false);
734        assertEquals(20000, delay);
735
736        nextApn = rm.getNextApnSetting();
737        assertTrue(nextApn.equals(mApn2));
738        delay = rm.getDelayForNextApn(false);
739        assertEquals(RetryManager.NO_RETRY, delay);
740    }
741
742    /**
743     * Test the fail fast scenario.
744     */
745    @Test
746    @SmallTest
747    public void testRetryManagerFailFast() throws Exception {
748
749        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
750                new String[]{"default:1000,5000"});
751
752        mBundle.putLong(CarrierConfigManager.KEY_CARRIER_DATA_CALL_APN_DELAY_FASTER_LONG, 2000);
753
754        ArrayList<ApnSetting> waitingApns = new ArrayList<ApnSetting>();
755        waitingApns.add(new ApnSetting(mApn1));
756        waitingApns.add(new ApnSetting(mApn2));
757
758        RetryManager rm = new RetryManager(mPhone, "default");
759        rm.setWaitingApns(waitingApns);
760
761        ApnSetting nextApn = rm.getNextApnSetting();
762        assertTrue(nextApn.equals(mApn1));
763        long delay = rm.getDelayForNextApn(true);
764        assertEquals(2000, delay);
765
766        nextApn = rm.getNextApnSetting();
767        assertTrue(nextApn.equals(mApn2));
768        delay = rm.getDelayForNextApn(true);
769        assertEquals(1000, delay);
770
771        nextApn = rm.getNextApnSetting();
772        assertTrue(nextApn.equals(mApn1));
773        delay = rm.getDelayForNextApn(false);
774        assertEquals(20000, delay);
775
776        nextApn = rm.getNextApnSetting();
777        assertTrue(nextApn.equals(mApn2));
778        delay = rm.getDelayForNextApn(true);
779        assertEquals(2000, delay);
780
781        nextApn = rm.getNextApnSetting();
782        assertTrue(nextApn.equals(mApn1));
783        delay = rm.getDelayForNextApn(true);
784        assertEquals(2000, delay);
785
786        nextApn = rm.getNextApnSetting();
787        assertTrue(nextApn.equals(mApn2));
788        delay = rm.getDelayForNextApn(true);
789        assertEquals(RetryManager.NO_RETRY, delay);
790    }
791
792    /**
793     * Test the permanent fail scenario with two APN all failed and then reset
794     */
795    @Test
796    @SmallTest
797    public void testRetryManagerApnPermanentFailedAllAndThenReset() throws Exception {
798
799        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
800                new String[]{"dun:1000,4000,7000,9000"});
801
802        ArrayList<ApnSetting> waitingApns = new ArrayList<ApnSetting>();
803        ApnSetting myApn1 = new ApnSetting(mApn1);
804        ApnSetting myApn2 = new ApnSetting(mApn2);
805        waitingApns.add(myApn1);
806        waitingApns.add(myApn2);
807
808        RetryManager rm = new RetryManager(mPhone, "dun");
809        rm.setWaitingApns(waitingApns);
810
811        ApnSetting nextApn = rm.getNextApnSetting();
812        assertTrue(nextApn.equals(mApn1));
813        long delay = rm.getDelayForNextApn(false);
814        assertEquals(20000, delay);
815
816        nextApn = rm.getNextApnSetting();
817        assertTrue(nextApn.equals(mApn2));
818        delay = rm.getDelayForNextApn(false);
819        assertEquals(1000, delay);
820
821        nextApn = rm.getNextApnSetting();
822        assertTrue(nextApn.equals(mApn1));
823        delay = rm.getDelayForNextApn(false);
824        assertEquals(20000, delay);
825
826        rm.markApnPermanentFailed(myApn1);
827
828        nextApn = rm.getNextApnSetting();
829        assertTrue(nextApn.equals(mApn2));
830        delay = rm.getDelayForNextApn(false);
831        assertEquals(4000, delay);
832
833        nextApn = rm.getNextApnSetting();
834        assertTrue(nextApn.equals(mApn2));
835        delay = rm.getDelayForNextApn(false);
836        assertEquals(7000, delay);
837
838        rm.markApnPermanentFailed(myApn2);
839
840        nextApn = rm.getNextApnSetting();
841        assertTrue(nextApn == null);
842
843        nextApn = rm.getNextApnSetting();
844        assertTrue(nextApn == null);
845
846        // reset the retry manager
847
848        ApnSetting myApn3 = new ApnSetting(mApn3);
849        waitingApns.clear();
850        waitingApns.add(myApn3);
851
852        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
853                new String[]{"dun:3000,8000"});
854
855        rm.setWaitingApns(waitingApns);
856
857        nextApn = rm.getNextApnSetting();
858        assertTrue(nextApn.equals(mApn3));
859        delay = rm.getDelayForNextApn(false);
860        assertEquals(3000, delay);
861
862        nextApn = rm.getNextApnSetting();
863        assertTrue(nextApn.equals(mApn3));
864        delay = rm.getDelayForNextApn(false);
865        assertEquals(8000, delay);
866
867        nextApn = rm.getNextApnSetting();
868        assertTrue(nextApn.equals(mApn3));
869        delay = rm.getDelayForNextApn(false);
870        assertEquals(RetryManager.NO_RETRY, delay);
871    }
872
873    /**
874     * Test the scenario where modem suggests retry the current APN once
875     */
876    @Test
877    @SmallTest
878    public void testRetryManagerModemSuggestedRetryOnce() throws Exception {
879
880        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
881                new String[]{"others:1000,4000,7000,9000"});
882
883        ArrayList<ApnSetting> waitingApns = new ArrayList<ApnSetting>();
884        ApnSetting myApn1 = new ApnSetting(mApn1);
885        ApnSetting myApn2 = new ApnSetting(mApn2);
886        waitingApns.add(myApn1);
887        waitingApns.add(myApn2);
888
889        RetryManager rm = new RetryManager(mPhone, "mms");
890        rm.setWaitingApns(waitingApns);
891
892        ApnSetting nextApn = rm.getNextApnSetting();
893        assertTrue(nextApn.equals(mApn1));
894        long delay = rm.getDelayForNextApn(false);
895        assertEquals(20000, delay);
896
897        nextApn = rm.getNextApnSetting();
898        assertTrue(nextApn.equals(mApn2));
899        delay = rm.getDelayForNextApn(false);
900        assertEquals(1000, delay);
901
902        nextApn = rm.getNextApnSetting();
903        assertTrue(nextApn.equals(mApn1));
904        // Modem suggests retrying the current APN
905        rm.setModemSuggestedDelay(2500);
906        delay = rm.getDelayForNextApn(false);
907        assertEquals(2500, delay);
908
909        nextApn = rm.getNextApnSetting();
910        assertTrue(nextApn.equals(mApn1));
911        rm.setModemSuggestedDelay(RetryManager.NO_SUGGESTED_RETRY_DELAY);
912        delay = rm.getDelayForNextApn(false);
913        assertEquals(20000, delay);
914
915        nextApn = rm.getNextApnSetting();
916        assertTrue(nextApn.equals(mApn2));
917        // Modem suggests retrying the current APN
918        rm.setModemSuggestedDelay(30000);
919        delay = rm.getDelayForNextApn(false);
920        assertEquals(30000, delay);
921
922        nextApn = rm.getNextApnSetting();
923        assertTrue(nextApn.equals(mApn2));
924        rm.setModemSuggestedDelay(RetryManager.NO_SUGGESTED_RETRY_DELAY);
925        delay = rm.getDelayForNextApn(false);
926        assertEquals(4000, delay);
927    }
928
929    /**
930     * Test the scenario where modem suggests not retrying
931     */
932    @Test
933    @SmallTest
934    public void testRetryManagerModemSuggestedNoRetry() throws Exception {
935
936        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
937                new String[]{"default:1000,4000,7000,9000"});
938
939        ArrayList<ApnSetting> waitingApns = new ArrayList<ApnSetting>();
940        ApnSetting myApn1 = new ApnSetting(mApn1);
941        ApnSetting myApn2 = new ApnSetting(mApn2);
942        waitingApns.add(myApn1);
943        waitingApns.add(myApn2);
944
945        RetryManager rm = new RetryManager(mPhone, "default");
946        rm.setWaitingApns(waitingApns);
947
948        ApnSetting nextApn = rm.getNextApnSetting();
949        assertTrue(nextApn.equals(mApn1));
950        long delay = rm.getDelayForNextApn(false);
951        assertEquals(20000, delay);
952
953        nextApn = rm.getNextApnSetting();
954        assertTrue(nextApn.equals(mApn2));
955        delay = rm.getDelayForNextApn(false);
956        assertEquals(1000, delay);
957
958        nextApn = rm.getNextApnSetting();
959        assertTrue(nextApn.equals(mApn1));
960        // Modem suggests retrying the current APN
961        rm.setModemSuggestedDelay(2500);
962        delay = rm.getDelayForNextApn(false);
963        assertEquals(2500, delay);
964
965        nextApn = rm.getNextApnSetting();
966        assertTrue(nextApn.equals(mApn1));
967        rm.setModemSuggestedDelay(RetryManager.NO_RETRY);
968        delay = rm.getDelayForNextApn(false);
969        assertEquals(RetryManager.NO_RETRY, delay);
970    }
971
972    /**
973     * Test the scenario where modem suggests the same retry for too many times
974     */
975    @Test
976    @SmallTest
977    public void testRetryManagerModemSuggestedRetryTooManyTimes() throws Exception {
978
979        mBundle.putStringArray(CarrierConfigManager.KEY_CARRIER_DATA_CALL_RETRY_CONFIG_STRINGS,
980                new String[]{"mms:2000,3000", "default:1000,4000,7000,9000"});
981
982        ArrayList<ApnSetting> waitingApns = new ArrayList<ApnSetting>();
983        ApnSetting myApn1 = new ApnSetting(mApn1);
984        ApnSetting myApn2 = new ApnSetting(mApn2);
985        waitingApns.add(myApn1);
986        waitingApns.add(myApn2);
987
988        RetryManager rm = new RetryManager(mPhone, "default");
989        rm.setWaitingApns(waitingApns);
990
991        ApnSetting nextApn = rm.getNextApnSetting();
992        assertTrue(nextApn.equals(mApn1));
993        long delay = rm.getDelayForNextApn(false);
994        assertEquals(20000, delay);
995
996        nextApn = rm.getNextApnSetting();
997        assertTrue(nextApn.equals(mApn2));
998        delay = rm.getDelayForNextApn(false);
999        assertEquals(1000, delay);
1000
1001        nextApn = rm.getNextApnSetting();
1002        assertTrue(nextApn.equals(mApn1));
1003        rm.setModemSuggestedDelay(2500);
1004        delay = rm.getDelayForNextApn(false);
1005        assertEquals(2500, delay);
1006
1007        nextApn = rm.getNextApnSetting();
1008        assertTrue(nextApn.equals(mApn1));
1009        rm.setModemSuggestedDelay(2500);
1010        delay = rm.getDelayForNextApn(false);
1011        assertEquals(2500, delay);
1012
1013        nextApn = rm.getNextApnSetting();
1014        assertTrue(nextApn.equals(mApn1));
1015        rm.setModemSuggestedDelay(2500);
1016        delay = rm.getDelayForNextApn(false);
1017        assertEquals(2500, delay);
1018
1019        nextApn = rm.getNextApnSetting();
1020        assertTrue(nextApn.equals(mApn1));
1021        rm.setModemSuggestedDelay(2500);
1022        delay = rm.getDelayForNextApn(false);
1023        assertEquals(20000, delay);
1024
1025        nextApn = rm.getNextApnSetting();
1026        assertTrue(nextApn.equals(mApn2));
1027        rm.setModemSuggestedDelay(RetryManager.NO_SUGGESTED_RETRY_DELAY);
1028        delay = rm.getDelayForNextApn(false);
1029        assertEquals(4000, delay);
1030    }
1031}
1032