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