1 /* 2 * Copyright (C) 2018 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.phone; 18 19 import static junit.framework.TestCase.assertFalse; 20 21 import static org.junit.Assert.assertTrue; 22 import static org.mockito.ArgumentMatchers.anyInt; 23 import static org.mockito.Mockito.mock; 24 import static org.mockito.Mockito.never; 25 import static org.mockito.Mockito.times; 26 import static org.mockito.Mockito.verify; 27 import static org.mockito.Mockito.when; 28 29 import android.platform.test.annotations.RequiresFlagsEnabled; 30 import android.platform.test.flag.junit.CheckFlagsRule; 31 import android.platform.test.flag.junit.DeviceFlagsValueProvider; 32 import android.telephony.NumberVerificationCallback; 33 import android.telephony.PhoneNumberRange; 34 import android.telephony.ServiceState; 35 36 import com.android.internal.telephony.Call; 37 import com.android.internal.telephony.INumberVerificationCallback; 38 import com.android.internal.telephony.Phone; 39 import com.android.internal.telephony.flags.Flags; 40 41 import org.junit.Before; 42 import org.junit.Rule; 43 import org.junit.Test; 44 import org.junit.runner.RunWith; 45 import org.junit.runners.JUnit4; 46 import org.mockito.Mock; 47 import org.mockito.MockitoAnnotations; 48 49 @RunWith(JUnit4.class) 50 public class NumberVerificationManagerTest { 51 @Rule 52 public final CheckFlagsRule mCheckFlagsRule = 53 DeviceFlagsValueProvider.createCheckFlagsRule(); 54 55 private static final PhoneNumberRange SAMPLE_RANGE = 56 new PhoneNumberRange("1", "650555", "0000", "8999"); 57 private static final long DEFAULT_VERIFICATION_TIMEOUT = 100; 58 @Mock private Phone mPhone1; 59 @Mock private Phone mPhone2; 60 @Mock private Call mRingingCall; 61 @Mock private Call mForegroundCall; 62 @Mock private Call mBackgroundCall; 63 @Mock private INumberVerificationCallback mCallback; 64 65 @Before setUp()66 public void setUp() { 67 MockitoAnnotations.initMocks(this); 68 ServiceState ss = mock(ServiceState.class); 69 when(ss.getState()).thenReturn(ServiceState.STATE_IN_SERVICE); 70 when(mPhone1.getServiceState()).thenReturn(ss); 71 when(mPhone1.getForegroundCall()).thenReturn(mForegroundCall); 72 when(mPhone1.getRingingCall()).thenReturn(mRingingCall); 73 when(mPhone1.getBackgroundCall()).thenReturn(mBackgroundCall); 74 when(mPhone2.getServiceState()).thenReturn(ss); 75 when(mPhone2.getForegroundCall()).thenReturn(mForegroundCall); 76 when(mPhone2.getRingingCall()).thenReturn(mRingingCall); 77 when(mPhone2.getBackgroundCall()).thenReturn(mBackgroundCall); 78 79 when(mForegroundCall.getState()).thenReturn(Call.State.IDLE); 80 when(mRingingCall.getState()).thenReturn(Call.State.IDLE); 81 when(mBackgroundCall.getState()).thenReturn(Call.State.IDLE); 82 } 83 84 @Test testConcurrentRequestFailure()85 public void testConcurrentRequestFailure() throws Exception { 86 NumberVerificationManager manager = 87 new NumberVerificationManager(() -> new Phone[]{mPhone1}); 88 manager.requestVerification(SAMPLE_RANGE, mCallback, DEFAULT_VERIFICATION_TIMEOUT); 89 manager.requestVerification(SAMPLE_RANGE, mCallback, DEFAULT_VERIFICATION_TIMEOUT); 90 verify(mCallback, times(1)).onVerificationFailed( 91 NumberVerificationCallback.REASON_CONCURRENT_REQUESTS); 92 } 93 94 @Test testEcbmFailure()95 public void testEcbmFailure() throws Exception { 96 NumberVerificationManager manager = 97 new NumberVerificationManager(() -> new Phone[]{mPhone1}); 98 when(mPhone1.isInEcm()).thenReturn(true); 99 100 manager.requestVerification(SAMPLE_RANGE, mCallback, DEFAULT_VERIFICATION_TIMEOUT); 101 verify(mCallback, times(1)).onVerificationFailed( 102 NumberVerificationCallback.REASON_IN_ECBM); 103 } 104 105 @Test testEmergencyCallFailure()106 public void testEmergencyCallFailure() throws Exception { 107 NumberVerificationManager manager = 108 new NumberVerificationManager(() -> new Phone[]{mPhone1}); 109 when(mPhone1.isInEmergencyCall()).thenReturn(true); 110 111 manager.requestVerification(SAMPLE_RANGE, mCallback, DEFAULT_VERIFICATION_TIMEOUT); 112 verify(mCallback, times(1)).onVerificationFailed( 113 NumberVerificationCallback.REASON_IN_EMERGENCY_CALL); 114 } 115 116 @Test testNoPhoneInServiceFailure()117 public void testNoPhoneInServiceFailure() throws Exception { 118 ServiceState ss = mock(ServiceState.class); 119 when(ss.getState()).thenReturn(ServiceState.STATE_POWER_OFF); 120 when(mPhone1.getServiceState()).thenReturn(ss); 121 when(mPhone2.getServiceState()).thenReturn(ss); 122 NumberVerificationManager manager = 123 new NumberVerificationManager(() -> new Phone[]{mPhone1, mPhone2}); 124 125 manager.requestVerification(SAMPLE_RANGE, mCallback, DEFAULT_VERIFICATION_TIMEOUT); 126 verify(mCallback, times(1)).onVerificationFailed( 127 NumberVerificationCallback.REASON_NETWORK_NOT_AVAILABLE); 128 } 129 130 @Test testAllLinesFullFailure()131 public void testAllLinesFullFailure() throws Exception { 132 NumberVerificationManager manager = 133 new NumberVerificationManager(() -> new Phone[]{mPhone1, mPhone2}); 134 when(mRingingCall.getState()).thenReturn(Call.State.ALERTING); 135 136 manager.requestVerification(SAMPLE_RANGE, mCallback, DEFAULT_VERIFICATION_TIMEOUT); 137 verify(mCallback, times(1)).onVerificationFailed( 138 NumberVerificationCallback.REASON_TOO_MANY_CALLS); 139 } 140 verifyDefaultRangeMatching(NumberVerificationManager manager)141 private void verifyDefaultRangeMatching(NumberVerificationManager manager) throws Exception { 142 String testNumber = "6505550000"; 143 assertTrue(manager.checkIncomingCall(testNumber, "US")); 144 verify(mCallback).onCallReceived(testNumber); 145 } 146 147 @Test testVerificationWorksWithOnePhoneInService()148 public void testVerificationWorksWithOnePhoneInService() throws Exception { 149 ServiceState ss = mock(ServiceState.class); 150 when(ss.getState()).thenReturn(ServiceState.STATE_POWER_OFF); 151 when(mPhone1.getServiceState()).thenReturn(ss); 152 NumberVerificationManager manager = 153 new NumberVerificationManager(() -> new Phone[]{mPhone1, mPhone2}); 154 155 manager.requestVerification(SAMPLE_RANGE, mCallback, DEFAULT_VERIFICATION_TIMEOUT); 156 verify(mCallback, never()).onVerificationFailed(anyInt()); 157 verifyDefaultRangeMatching(manager); 158 } 159 160 /** 161 * Verifies that numbers starting with '0' prefix from the network and lacking the country code 162 * will be correctly compared to a range with the `44` country code. 163 * @throws Exception 164 */ 165 @Test 166 @RequiresFlagsEnabled(Flags.FLAG_ROBUST_NUMBER_VERIFICATION) testVerificationOfUkNumbersWithZeroPrefix()167 public void testVerificationOfUkNumbersWithZeroPrefix() throws Exception { 168 NumberVerificationManager manager = 169 new NumberVerificationManager(() -> new Phone[]{mPhone1}); 170 171 manager.requestVerification(new PhoneNumberRange("44", "7445", "000000", "999999"), 172 mCallback, DEFAULT_VERIFICATION_TIMEOUT); 173 verify(mCallback, never()).onVerificationFailed(anyInt()); 174 String testNumber = "0 7445 032046"; 175 assertTrue(manager.checkIncomingCall(testNumber, "GB")); 176 verify(mCallback).onCallReceived(testNumber); 177 } 178 179 /** 180 * Similar to {@link #testVerificationOfUkNumbersWithZeroPrefix()}, except verifies that if the 181 * network sent a full qualified UK phone number with the `+44` country code that it would 182 * match the range. 183 * @throws Exception 184 */ 185 @Test 186 @RequiresFlagsEnabled(Flags.FLAG_ROBUST_NUMBER_VERIFICATION) testVerificationOfUkNumbersWithCountryPrefix()187 public void testVerificationOfUkNumbersWithCountryPrefix() throws Exception { 188 NumberVerificationManager manager = 189 new NumberVerificationManager(() -> new Phone[]{mPhone1}); 190 191 manager.requestVerification(new PhoneNumberRange("44", "7445", "000000", "999999"), 192 mCallback, DEFAULT_VERIFICATION_TIMEOUT); 193 verify(mCallback, never()).onVerificationFailed(anyInt()); 194 String testNumber = "+447445032046"; 195 assertTrue(manager.checkIncomingCall(testNumber, "GB")); 196 verify(mCallback).onCallReceived(testNumber); 197 } 198 199 @Test testVerificationWorksWithOnePhoneFull()200 public void testVerificationWorksWithOnePhoneFull() throws Exception { 201 Call fakeCall = mock(Call.class); 202 when(fakeCall.getState()).thenReturn(Call.State.ACTIVE); 203 when(mPhone1.getForegroundCall()).thenReturn(fakeCall); 204 when(mPhone1.getRingingCall()).thenReturn(fakeCall); 205 when(mPhone1.getBackgroundCall()).thenReturn(fakeCall); 206 NumberVerificationManager manager = 207 new NumberVerificationManager(() -> new Phone[]{mPhone1, mPhone2}); 208 209 manager.requestVerification(SAMPLE_RANGE, mCallback, DEFAULT_VERIFICATION_TIMEOUT); 210 verify(mCallback, never()).onVerificationFailed(anyInt()); 211 verifyDefaultRangeMatching(manager); 212 } 213 214 @Test testDoubleVerificationFailure()215 public void testDoubleVerificationFailure() throws Exception { 216 NumberVerificationManager manager = 217 new NumberVerificationManager(() -> new Phone[]{mPhone1, mPhone2}); 218 manager.requestVerification(SAMPLE_RANGE, mCallback, DEFAULT_VERIFICATION_TIMEOUT); 219 verifyDefaultRangeMatching(manager); 220 assertFalse(manager.checkIncomingCall("this doesn't even matter", "US")); 221 } 222 } 223