1 /* 2 * Copyright (C) 2016 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 17 package com.android; 18 19 import static org.mockito.Mockito.spy; 20 21 import android.os.Handler; 22 import android.os.Looper; 23 import android.util.Log; 24 25 import com.android.internal.telephony.PhoneConfigurationManager; 26 27 import org.junit.Rule; 28 import org.mockito.junit.MockitoJUnit; 29 import org.mockito.junit.MockitoRule; 30 31 import java.util.concurrent.CountDownLatch; 32 import java.util.concurrent.Executor; 33 import java.util.concurrent.TimeUnit; 34 35 /** 36 * Helper class to load Mockito Resources into a test. 37 */ 38 public class TelephonyTestBase { 39 @Rule public final MockitoRule mocks = MockitoJUnit.rule(); 40 41 protected TestContext mContext; 42 setUp()43 public void setUp() throws Exception { 44 mContext = spy(new TestContext()); 45 // Set up the looper if it does not exist on the test thread. 46 if (Looper.myLooper() == null) { 47 Looper.prepare(); 48 // Wait until the looper is not null anymore 49 for(int i = 0; i < 5; i++) { 50 if (Looper.myLooper() != null) { 51 break; 52 } 53 Looper.prepare(); 54 Thread.sleep(100); 55 } 56 } 57 } 58 tearDown()59 public void tearDown() throws Exception { 60 // Ensure there are no static references to handlers after test completes. 61 PhoneConfigurationManager.unregisterAllMultiSimConfigChangeRegistrants(); 62 } 63 waitForExecutorAction(Executor executor, long timeoutMillis)64 protected final boolean waitForExecutorAction(Executor executor, long timeoutMillis) { 65 final CountDownLatch lock = new CountDownLatch(1); 66 executor.execute(() -> { 67 lock.countDown(); 68 }); 69 while (lock.getCount() > 0) { 70 try { 71 return lock.await(timeoutMillis, TimeUnit.MILLISECONDS); 72 } catch (InterruptedException e) { 73 // do nothing 74 } 75 } 76 return true; 77 } 78 waitForHandlerAction(Handler h, long timeoutMillis)79 protected final void waitForHandlerAction(Handler h, long timeoutMillis) { 80 final CountDownLatch lock = new CountDownLatch(1); 81 h.post(lock::countDown); 82 while (lock.getCount() > 0) { 83 try { 84 lock.await(timeoutMillis, TimeUnit.MILLISECONDS); 85 } catch (InterruptedException e) { 86 // do nothing 87 } 88 } 89 } 90 waitForHandlerActionDelayed(Handler h, long timeoutMillis, long delayMs)91 protected final void waitForHandlerActionDelayed(Handler h, long timeoutMillis, long delayMs) { 92 final CountDownLatch lock = new CountDownLatch(1); 93 h.postDelayed(lock::countDown, delayMs); 94 while (lock.getCount() > 0) { 95 try { 96 lock.await(timeoutMillis, TimeUnit.MILLISECONDS); 97 } catch (InterruptedException e) { 98 // do nothing 99 } 100 } 101 } 102 waitForMs(long ms)103 protected void waitForMs(long ms) { 104 try { 105 Thread.sleep(ms); 106 } catch (InterruptedException e) { 107 Log.e("TelephonyTestBase", "InterruptedException while waiting: " + e); 108 } 109 } 110 getTestContext()111 protected TestContext getTestContext() { 112 return mContext; 113 } 114 } 115