CallLogManagerTest.java revision 98e6bdc795585b0d332a7eb86245926c8d80609a 
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.server.telecom.tests;
18
19
20import android.content.ComponentName;
21import android.content.ContentProvider;
22import android.content.ContentValues;
23import android.content.Context;
24import android.content.IContentProvider;
25import android.content.pm.UserInfo;
26import android.net.Uri;
27import android.os.UserHandle;
28import android.os.UserManager;
29import android.provider.CallLog;
30import android.provider.CallLog.Calls;
31import android.telecom.DisconnectCause;
32import android.telecom.PhoneAccount;
33import android.telecom.PhoneAccountHandle;
34import android.telecom.VideoProfile;
35
36import com.android.server.telecom.Call;
37import com.android.server.telecom.CallLogManager;
38import com.android.server.telecom.CallState;
39import com.android.server.telecom.PhoneAccountRegistrar;
40import com.android.server.telecom.TelephonyUtil;
41
42import static org.mockito.Matchers.any;
43import static org.mockito.Matchers.eq;
44import static org.mockito.Mockito.mock;
45import static org.mockito.Mockito.timeout;
46import static org.mockito.Mockito.verify;
47import static org.mockito.Mockito.when;
48
49import org.mockito.ArgumentCaptor;
50import org.mockito.Mock;
51
52import java.util.Arrays;
53
54public class CallLogManagerTest extends TelecomTestCase {
55
56    private CallLogManager mCallLogManager;
57    private IContentProvider mContentProvider;
58    private PhoneAccountHandle mDefaultAccountHandle;
59    private PhoneAccountHandle mOtherUserAccountHandle;
60    private PhoneAccountHandle mManagedProfileAccountHandle;
61
62    private static final Uri TEL_PHONEHANDLE = Uri.parse("tel:5555551234");
63
64    private static final PhoneAccountHandle EMERGENCY_ACCT_HANDLE = TelephonyUtil
65            .getDefaultEmergencyPhoneAccount()
66            .getAccountHandle();
67
68    private static final int NO_VIDEO_STATE = VideoProfile.STATE_AUDIO_ONLY;
69    private static final int BIDIRECTIONAL_VIDEO_STATE = VideoProfile.STATE_BIDIRECTIONAL;
70    private static final String POST_DIAL_STRING = ";12345";
71    private static final String TEST_PHONE_ACCOUNT_ID= "testPhoneAccountId";
72
73    private static final int TEST_TIMEOUT_MILLIS = 100;
74    private static final int CURRENT_USER_ID = 0;
75    private static final int OTHER_USER_ID = 10;
76    private static final int MANAGED_USER_ID = 11;
77
78    @Mock
79    PhoneAccountRegistrar mMockPhoneAccountRegistrar;
80
81
82    @Override
83    public void setUp() throws Exception {
84        super.setUp();
85        mContext = mComponentContextFixture.getTestDouble().getApplicationContext();
86        mCallLogManager = new CallLogManager(mContext, mMockPhoneAccountRegistrar);
87        mContentProvider = mContext.getContentResolver().acquireProvider("test");
88        mDefaultAccountHandle = new PhoneAccountHandle(
89                new ComponentName("com.android.server.telecom.tests", "CallLogManagerTest"),
90                TEST_PHONE_ACCOUNT_ID,
91                UserHandle.of(CURRENT_USER_ID)
92        );
93
94        mOtherUserAccountHandle = new PhoneAccountHandle(
95                new ComponentName("com.android.server.telecom.tests", "CallLogManagerTest"),
96                TEST_PHONE_ACCOUNT_ID,
97                UserHandle.of(OTHER_USER_ID)
98        );
99
100        mManagedProfileAccountHandle = new PhoneAccountHandle(
101                new ComponentName("com.android.server.telecom.tests", "CallLogManagerTest"),
102                TEST_PHONE_ACCOUNT_ID,
103                UserHandle.of(MANAGED_USER_ID)
104        );
105
106        UserManager userManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
107        UserInfo userInfo = new UserInfo(CURRENT_USER_ID, "test", 0);
108        UserInfo otherUserInfo = new UserInfo(OTHER_USER_ID, "test2", 0);
109        UserInfo managedProfileUserInfo = new UserInfo(OTHER_USER_ID, "test3",
110                UserInfo.FLAG_MANAGED_PROFILE);
111
112        when(userManager.isUserRunning(any(UserHandle.class))).thenReturn(true);
113        when(userManager.hasUserRestriction(any(String.class), any(UserHandle.class)))
114                .thenReturn(false);
115        when(userManager.getUsers(any(Boolean.class)))
116                .thenReturn(Arrays.asList(userInfo, otherUserInfo, managedProfileUserInfo));
117        when(userManager.getUserInfo(eq(CURRENT_USER_ID))).thenReturn(userInfo);
118        when(userManager.getUserInfo(eq(OTHER_USER_ID))).thenReturn(otherUserInfo);
119        when(userManager.getUserInfo(eq(MANAGED_USER_ID))).thenReturn(managedProfileUserInfo);
120    }
121
122    public void testDontLogCancelledCall() {
123        Call fakeCall = makeFakeCall(
124                DisconnectCause.CANCELED,
125                false, // isConference
126                false, // isIncoming
127                1L, // creationTimeMillis
128                1000L, // ageMillis
129                TEL_PHONEHANDLE, // callHandle
130                mDefaultAccountHandle, // phoneAccountHandle
131                NO_VIDEO_STATE, // callVideoState
132                POST_DIAL_STRING, // postDialDigits,
133                UserHandle.of(CURRENT_USER_ID)
134        );
135        mCallLogManager.onCallStateChanged(fakeCall, CallState.DIALING, CallState.DISCONNECTED);
136        verifyNoInsertion();
137        mCallLogManager.onCallStateChanged(fakeCall, CallState.DIALING, CallState.ABORTED);
138        verifyNoInsertion();
139    }
140
141    public void testDontLogChoosingAccountCall() {
142        when(mMockPhoneAccountRegistrar.getPhoneAccountUnchecked(any(PhoneAccountHandle.class)))
143                .thenReturn(makeFakePhoneAccount(mDefaultAccountHandle, CURRENT_USER_ID));
144        Call fakeCall = makeFakeCall(
145                DisconnectCause.OTHER, // disconnectCauseCode
146                false, // isConference
147                false, // isIncoming
148                1L, // creationTimeMillis
149                1000L, // ageMillis
150                TEL_PHONEHANDLE, // callHandle
151                mDefaultAccountHandle, // phoneAccountHandle
152                NO_VIDEO_STATE, // callVideoState
153                POST_DIAL_STRING, // postDialDigits
154                UserHandle.of(CURRENT_USER_ID)
155        );
156        mCallLogManager.onCallStateChanged(fakeCall, CallState.SELECT_PHONE_ACCOUNT,
157                CallState.DISCONNECTED);
158        verifyNoInsertion();
159    }
160
161    public void testDontLogCallsFromEmergencyAccount() {
162        when(mMockPhoneAccountRegistrar.getPhoneAccountUnchecked(any(PhoneAccountHandle.class)))
163                .thenReturn(makeFakePhoneAccount(EMERGENCY_ACCT_HANDLE, 0));
164        mComponentContextFixture.putBooleanResource(R.bool.allow_emergency_numbers_in_call_log,
165                false);
166        Call fakeCall = makeFakeCall(
167                DisconnectCause.OTHER, // disconnectCauseCode
168                false, // isConference
169                false, // isIncoming
170                1L, // creationTimeMillis
171                1000L, // ageMillis
172                TEL_PHONEHANDLE, // callHandle
173                EMERGENCY_ACCT_HANDLE, // phoneAccountHandle
174                NO_VIDEO_STATE, // callVideoState
175                POST_DIAL_STRING, // postDialDigits,
176                UserHandle.of(CURRENT_USER_ID)
177        );
178        mCallLogManager.onCallStateChanged(fakeCall, CallState.ACTIVE, CallState.DISCONNECTED);
179        verifyNoInsertion();
180    }
181
182    public void testLogCallDirectionOutgoing() {
183        when(mMockPhoneAccountRegistrar.getPhoneAccountUnchecked(any(PhoneAccountHandle.class)))
184                .thenReturn(makeFakePhoneAccount(mDefaultAccountHandle, CURRENT_USER_ID));
185        Call fakeOutgoingCall = makeFakeCall(
186                DisconnectCause.OTHER, // disconnectCauseCode
187                false, // isConference
188                false, // isIncoming
189                1L, // creationTimeMillis
190                1000L, // ageMillis
191                TEL_PHONEHANDLE, // callHandle
192                mDefaultAccountHandle, // phoneAccountHandle
193                NO_VIDEO_STATE, // callVideoState
194                POST_DIAL_STRING, // postDialDigits
195                UserHandle.of(CURRENT_USER_ID)
196        );
197        mCallLogManager.onCallStateChanged(fakeOutgoingCall, CallState.ACTIVE,
198                CallState.DISCONNECTED);
199        ContentValues insertedValues = verifyInsertionWithCapture(CURRENT_USER_ID);
200        assertEquals(insertedValues.getAsInteger(CallLog.Calls.TYPE),
201                Integer.valueOf(CallLog.Calls.OUTGOING_TYPE));
202    }
203
204    public void testLogCallDirectionIncoming() {
205        when(mMockPhoneAccountRegistrar.getPhoneAccountUnchecked(any(PhoneAccountHandle.class)))
206                .thenReturn(makeFakePhoneAccount(mDefaultAccountHandle, CURRENT_USER_ID));
207        Call fakeIncomingCall = makeFakeCall(
208                DisconnectCause.OTHER, // disconnectCauseCode
209                false, // isConference
210                true, // isIncoming
211                1L, // creationTimeMillis
212                1000L, // ageMillis
213                TEL_PHONEHANDLE, // callHandle
214                mDefaultAccountHandle, // phoneAccountHandle
215                NO_VIDEO_STATE, // callVideoState
216                POST_DIAL_STRING, // postDialDigits
217                null
218        );
219        mCallLogManager.onCallStateChanged(fakeIncomingCall, CallState.ACTIVE,
220                CallState.DISCONNECTED);
221        ContentValues insertedValues = verifyInsertionWithCapture(CURRENT_USER_ID);
222        assertEquals(insertedValues.getAsInteger(CallLog.Calls.TYPE),
223                Integer.valueOf(CallLog.Calls.INCOMING_TYPE));
224    }
225
226    public void testLogCallDirectionMissed() {
227        when(mMockPhoneAccountRegistrar.getPhoneAccountUnchecked(any(PhoneAccountHandle.class)))
228                .thenReturn(makeFakePhoneAccount(mDefaultAccountHandle, CURRENT_USER_ID));
229        Call fakeMissedCall = makeFakeCall(
230                DisconnectCause.MISSED, // disconnectCauseCode
231                false, // isConference
232                true, // isIncoming
233                1L, // creationTimeMillis
234                1000L, // ageMillis
235                TEL_PHONEHANDLE, // callHandle
236                mDefaultAccountHandle, // phoneAccountHandle
237                NO_VIDEO_STATE, // callVideoState
238                POST_DIAL_STRING, // postDialDigits
239                null
240        );
241
242        mCallLogManager.onCallStateChanged(fakeMissedCall, CallState.ACTIVE,
243                CallState.DISCONNECTED);
244        ContentValues insertedValues = verifyInsertionWithCapture(CURRENT_USER_ID);
245        assertEquals(insertedValues.getAsInteger(CallLog.Calls.TYPE),
246                Integer.valueOf(CallLog.Calls.MISSED_TYPE));
247    }
248
249    public void testCreationTimeAndAge() {
250        when(mMockPhoneAccountRegistrar.getPhoneAccountUnchecked(any(PhoneAccountHandle.class)))
251                .thenReturn(makeFakePhoneAccount(mDefaultAccountHandle, CURRENT_USER_ID));
252        long currentTime = System.currentTimeMillis();
253        long duration = 1000L;
254        Call fakeCall = makeFakeCall(
255                DisconnectCause.OTHER, // disconnectCauseCode
256                false, // isConference
257                false, // isIncoming
258                currentTime, // creationTimeMillis
259                duration, // ageMillis
260                TEL_PHONEHANDLE, // callHandle
261                mDefaultAccountHandle, // phoneAccountHandle
262                NO_VIDEO_STATE, // callVideoState
263                POST_DIAL_STRING, // postDialDigits
264                UserHandle.of(CURRENT_USER_ID)
265        );
266        mCallLogManager.onCallStateChanged(fakeCall, CallState.ACTIVE, CallState.DISCONNECTED);
267        ContentValues insertedValues = verifyInsertionWithCapture(CURRENT_USER_ID);
268        assertEquals(insertedValues.getAsLong(CallLog.Calls.DATE),
269                Long.valueOf(currentTime));
270        assertEquals(insertedValues.getAsLong(CallLog.Calls.DURATION),
271                Long.valueOf(duration / 1000));
272    }
273
274    public void testLogPhoneAccountId() {
275        when(mMockPhoneAccountRegistrar.getPhoneAccountUnchecked(any(PhoneAccountHandle.class)))
276                .thenReturn(makeFakePhoneAccount(mDefaultAccountHandle, CURRENT_USER_ID));
277        Call fakeCall = makeFakeCall(
278                DisconnectCause.OTHER, // disconnectCauseCode
279                false, // isConference
280                true, // isIncoming
281                1L, // creationTimeMillis
282                1000L, // ageMillis
283                TEL_PHONEHANDLE, // callHandle
284                mDefaultAccountHandle, // phoneAccountHandle
285                NO_VIDEO_STATE, // callVideoState
286                POST_DIAL_STRING, // postDialDigits
287                UserHandle.of(CURRENT_USER_ID)
288        );
289        mCallLogManager.onCallStateChanged(fakeCall, CallState.ACTIVE, CallState.DISCONNECTED);
290        ContentValues insertedValues = verifyInsertionWithCapture(CURRENT_USER_ID);
291        assertEquals(insertedValues.getAsString(CallLog.Calls.PHONE_ACCOUNT_ID),
292                TEST_PHONE_ACCOUNT_ID);
293    }
294
295    public void testLogCorrectPhoneNumber() {
296        when(mMockPhoneAccountRegistrar.getPhoneAccountUnchecked(any(PhoneAccountHandle.class)))
297                .thenReturn(makeFakePhoneAccount(mDefaultAccountHandle, CURRENT_USER_ID));
298        Call fakeCall = makeFakeCall(
299                DisconnectCause.OTHER, // disconnectCauseCode
300                false, // isConference
301                true, // isIncoming
302                1L, // creationTimeMillis
303                1000L, // ageMillis
304                TEL_PHONEHANDLE, // callHandle
305                mDefaultAccountHandle, // phoneAccountHandle
306                NO_VIDEO_STATE, // callVideoState
307                POST_DIAL_STRING, // postDialDigits
308                UserHandle.of(CURRENT_USER_ID)
309        );
310        mCallLogManager.onCallStateChanged(fakeCall, CallState.ACTIVE, CallState.DISCONNECTED);
311        ContentValues insertedValues = verifyInsertionWithCapture(CURRENT_USER_ID);
312        assertEquals(insertedValues.getAsString(CallLog.Calls.NUMBER),
313                TEL_PHONEHANDLE.getSchemeSpecificPart());
314        assertEquals(insertedValues.getAsString(CallLog.Calls.POST_DIAL_DIGITS), POST_DIAL_STRING);
315    }
316
317    public void testLogCallVideoFeatures() {
318        when(mMockPhoneAccountRegistrar.getPhoneAccountUnchecked(any(PhoneAccountHandle.class)))
319                .thenReturn(makeFakePhoneAccount(mDefaultAccountHandle, CURRENT_USER_ID));
320        Call fakeVideoCall = makeFakeCall(
321                DisconnectCause.OTHER, // disconnectCauseCode
322                false, // isConference
323                true, // isIncoming
324                1L, // creationTimeMillis
325                1000L, // ageMillis
326                TEL_PHONEHANDLE, // callHandle
327                mDefaultAccountHandle, // phoneAccountHandle
328                BIDIRECTIONAL_VIDEO_STATE, // callVideoState
329                POST_DIAL_STRING, // postDialDigits
330                UserHandle.of(CURRENT_USER_ID)
331        );
332        mCallLogManager.onCallStateChanged(fakeVideoCall, CallState.ACTIVE, CallState.DISCONNECTED);
333        ContentValues insertedValues = verifyInsertionWithCapture(CURRENT_USER_ID);
334        assertTrue((insertedValues.getAsInteger(CallLog.Calls.FEATURES)
335                & CallLog.Calls.FEATURES_VIDEO) == CallLog.Calls.FEATURES_VIDEO);
336    }
337
338    public void testLogCallDirectionOutgoingWithMultiUserCapability() {
339        when(mMockPhoneAccountRegistrar.getPhoneAccountUnchecked(any(PhoneAccountHandle.class)))
340                .thenReturn(makeFakePhoneAccount(mOtherUserAccountHandle,
341                        PhoneAccount.CAPABILITY_MULTI_USER));
342        Call fakeOutgoingCall = makeFakeCall(
343                DisconnectCause.OTHER, // disconnectCauseCode
344                false, // isConference
345                false, // isIncoming
346                1L, // creationTimeMillis
347                1000L, // ageMillis
348                TEL_PHONEHANDLE, // callHandle
349                mDefaultAccountHandle, // phoneAccountHandle
350                NO_VIDEO_STATE, // callVideoState
351                POST_DIAL_STRING, // postDialDigits
352                UserHandle.of(CURRENT_USER_ID)
353        );
354        mCallLogManager.onCallStateChanged(fakeOutgoingCall, CallState.ACTIVE,
355                CallState.DISCONNECTED);
356
357        // Outgoing call placed through a phone account with multi user capability is inserted to
358        // all users except managed profile.
359        ContentValues insertedValues = verifyInsertionWithCapture(CURRENT_USER_ID);
360        assertEquals(insertedValues.getAsInteger(CallLog.Calls.TYPE),
361                Integer.valueOf(CallLog.Calls.OUTGOING_TYPE));
362        insertedValues = verifyInsertionWithCapture(OTHER_USER_ID);
363        assertEquals(insertedValues.getAsInteger(CallLog.Calls.TYPE),
364                Integer.valueOf(CallLog.Calls.OUTGOING_TYPE));
365        verifyNoInsertionInUser(MANAGED_USER_ID);
366    }
367
368    public void testLogCallDirectionIncomingWithMultiUserCapability() {
369        when(mMockPhoneAccountRegistrar.getPhoneAccountUnchecked(any(PhoneAccountHandle.class)))
370                .thenReturn(makeFakePhoneAccount(mOtherUserAccountHandle,
371                        PhoneAccount.CAPABILITY_MULTI_USER));
372        Call fakeIncomingCall = makeFakeCall(
373                DisconnectCause.OTHER, // disconnectCauseCode
374                false, // isConference
375                true, // isIncoming
376                1L, // creationTimeMillis
377                1000L, // ageMillis
378                TEL_PHONEHANDLE, // callHandle
379                mDefaultAccountHandle, // phoneAccountHandle
380                NO_VIDEO_STATE, // callVideoState
381                POST_DIAL_STRING, // postDialDigits
382                null
383        );
384        mCallLogManager.onCallStateChanged(fakeIncomingCall, CallState.ACTIVE,
385                CallState.DISCONNECTED);
386
387        // Incoming call using a phone account with multi user capability is inserted to all users
388        // except managed profile.
389        ContentValues insertedValues = verifyInsertionWithCapture(CURRENT_USER_ID);
390        assertEquals(insertedValues.getAsInteger(CallLog.Calls.TYPE),
391                Integer.valueOf(CallLog.Calls.INCOMING_TYPE));
392        insertedValues = verifyInsertionWithCapture(OTHER_USER_ID);
393        assertEquals(insertedValues.getAsInteger(CallLog.Calls.TYPE),
394                Integer.valueOf(CallLog.Calls.INCOMING_TYPE));
395        verifyNoInsertionInUser(MANAGED_USER_ID);
396    }
397
398
399    public void testLogCallDirectionOutgoingWithMultiUserCapabilityFromManagedProfile() {
400        when(mMockPhoneAccountRegistrar.getPhoneAccountUnchecked(any(PhoneAccountHandle.class)))
401                .thenReturn(makeFakePhoneAccount(mManagedProfileAccountHandle,
402                        PhoneAccount.CAPABILITY_MULTI_USER));
403        Call fakeOutgoingCall = makeFakeCall(
404                DisconnectCause.OTHER, // disconnectCauseCode
405                false, // isConference
406                false, // isIncoming
407                1L, // creationTimeMillis
408                1000L, // ageMillis
409                TEL_PHONEHANDLE, // callHandle
410                mManagedProfileAccountHandle, // phoneAccountHandle
411                NO_VIDEO_STATE, // callVideoState
412                POST_DIAL_STRING, // postDialDigits
413                UserHandle.of(MANAGED_USER_ID)
414        );
415        mCallLogManager.onCallStateChanged(fakeOutgoingCall, CallState.ACTIVE,
416                CallState.DISCONNECTED);
417
418        // Outgoing call placed through work dialer should be inserted to managed profile only.
419        verifyNoInsertionInUser(CURRENT_USER_ID);
420        verifyNoInsertionInUser(OTHER_USER_ID);
421        ContentValues insertedValues = verifyInsertionWithCapture(MANAGED_USER_ID);
422        assertEquals(insertedValues.getAsInteger(CallLog.Calls.TYPE),
423                Integer.valueOf(CallLog.Calls.OUTGOING_TYPE));
424    }
425
426    public void testLogCallDirectionOutgoingFromManagedProfile() {
427        when(mMockPhoneAccountRegistrar.getPhoneAccountUnchecked(any(PhoneAccountHandle.class)))
428                .thenReturn(makeFakePhoneAccount(mManagedProfileAccountHandle, 0));
429        Call fakeOutgoingCall = makeFakeCall(
430                DisconnectCause.OTHER, // disconnectCauseCode
431                false, // isConference
432                false, // isIncoming
433                1L, // creationTimeMillis
434                1000L, // ageMillis
435                TEL_PHONEHANDLE, // callHandle
436                mManagedProfileAccountHandle, // phoneAccountHandle
437                NO_VIDEO_STATE, // callVideoState
438                POST_DIAL_STRING, // postDialDigits
439                UserHandle.of(MANAGED_USER_ID)
440        );
441        mCallLogManager.onCallStateChanged(fakeOutgoingCall, CallState.ACTIVE,
442                CallState.DISCONNECTED);
443
444        // Outgoing call using phone account in managed profile should be inserted to managed
445        // profile only.
446        verifyNoInsertionInUser(CURRENT_USER_ID);
447        verifyNoInsertionInUser(OTHER_USER_ID);
448        ContentValues insertedValues = verifyInsertionWithCapture(MANAGED_USER_ID);
449        assertEquals(insertedValues.getAsInteger(CallLog.Calls.TYPE),
450                Integer.valueOf(CallLog.Calls.OUTGOING_TYPE));
451    }
452
453    public void testLogCallDirectionIngoingFromManagedProfile() {
454        when(mMockPhoneAccountRegistrar.getPhoneAccountUnchecked(any(PhoneAccountHandle.class)))
455                .thenReturn(makeFakePhoneAccount(mManagedProfileAccountHandle, 0));
456        Call fakeOutgoingCall = makeFakeCall(
457                DisconnectCause.OTHER, // disconnectCauseCode
458                false, // isConference
459                true, // isIncoming
460                1L, // creationTimeMillis
461                1000L, // ageMillis
462                TEL_PHONEHANDLE, // callHandle
463                mManagedProfileAccountHandle, // phoneAccountHandle
464                NO_VIDEO_STATE, // callVideoState
465                POST_DIAL_STRING, // postDialDigits
466                null
467        );
468        mCallLogManager.onCallStateChanged(fakeOutgoingCall, CallState.ACTIVE,
469                CallState.DISCONNECTED);
470
471        // Incoming call using phone account in managed profile should be inserted to managed
472        // profile only.
473        verifyNoInsertionInUser(CURRENT_USER_ID);
474        verifyNoInsertionInUser(OTHER_USER_ID);
475        ContentValues insertedValues = verifyInsertionWithCapture(MANAGED_USER_ID);
476        assertEquals(insertedValues.getAsInteger(CallLog.Calls.TYPE),
477                Integer.valueOf(Calls.INCOMING_TYPE));
478    }
479
480
481    private void verifyNoInsertion() {
482        try {
483            verify(mContentProvider, timeout(TEST_TIMEOUT_MILLIS).never()).insert(any(String.class),
484                    any(Uri.class), any(ContentValues.class));
485        } catch (android.os.RemoteException e) {
486            fail("Remote exception occurred during test execution");
487        }
488    }
489
490
491    private void verifyNoInsertionInUser(int userId) {
492        try {
493            Uri uri = ContentProvider.maybeAddUserId(CallLog.Calls.CONTENT_URI, userId);
494            verify(mContentProvider, timeout(TEST_TIMEOUT_MILLIS).never()).insert(any(String.class),
495                    eq(uri), any(ContentValues.class));
496        } catch (android.os.RemoteException e) {
497            fail("Remote exception occurred during test execution");
498        }
499    }
500
501    private ContentValues verifyInsertionWithCapture(int userId) {
502        ArgumentCaptor<ContentValues> captor = ArgumentCaptor.forClass(ContentValues.class);
503        try {
504            Uri uri = ContentProvider.maybeAddUserId(CallLog.Calls.CONTENT_URI, userId);
505            verify(mContentProvider, timeout(TEST_TIMEOUT_MILLIS)).insert(any(String.class),
506                    eq(uri), captor.capture());
507        } catch (android.os.RemoteException e) {
508            fail("Remote exception occurred during test execution");
509        }
510
511        return captor.getValue();
512    }
513
514
515    private Call makeFakeCall(int disconnectCauseCode, boolean isConference, boolean isIncoming,
516            long creationTimeMillis, long ageMillis, Uri callHandle,
517            PhoneAccountHandle phoneAccountHandle, int callVideoState,
518            String postDialDigits, UserHandle initiatingUser) {
519        Call fakeCall = mock(Call.class);
520        when(fakeCall.getDisconnectCause()).thenReturn(
521                new DisconnectCause(disconnectCauseCode));
522        when(fakeCall.isConference()).thenReturn(isConference);
523        when(fakeCall.isIncoming()).thenReturn(isIncoming);
524        when(fakeCall.getCreationTimeMillis()).thenReturn(creationTimeMillis);
525        when(fakeCall.getAgeMillis()).thenReturn(ageMillis);
526        when(fakeCall.getOriginalHandle()).thenReturn(callHandle);
527        when(fakeCall.getTargetPhoneAccount()).thenReturn(phoneAccountHandle);
528        when(fakeCall.getVideoStateHistory()).thenReturn(callVideoState);
529        when(fakeCall.getPostDialDigits()).thenReturn(postDialDigits);
530        when(fakeCall.getInitiatingUser()).thenReturn(initiatingUser);
531        return fakeCall;
532    }
533
534    private PhoneAccount makeFakePhoneAccount(PhoneAccountHandle phoneAccountHandle,
535            int capabilities) {
536        return PhoneAccount.builder(phoneAccountHandle, "testing")
537                .setCapabilities(capabilities).build();
538    }
539}
540