Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1ad8b167 authored by Ying Xu's avatar Ying Xu Committed by Gerrit Code Review
Browse files

Merge changes from topic "uiccprofile_test" 

* changes:
  Expose the update() and dispose() methods of UiccProfile
  Add unit test for UiccProfile
parents 251f21db 2ffd14a1

src/java/com/android/internal/telephony/uicc/UiccProfile.java

+8 −2
Original line number Diff line number Diff line
@@ -105,7 +105,10 @@ public class UiccProfile { 
        update(c, ci, ics);

    }



    void dispose() {

    /**

     * Dispose the UiccProfile.

     */

    public void dispose() {

        synchronized (mLock) {

            if (DBG) log("Disposing profile");

            if (mCatService != null) mCatService.dispose();
@@ -120,7 +123,10 @@ public class UiccProfile { 
        }

    }



    void update(Context c, CommandsInterface ci, IccCardStatus ics) {

    /**

     * Update the UiccProfile.

     */

    public void update(Context c, CommandsInterface ci, IccCardStatus ics) {

        synchronized (mLock) {

            mUniversalPinState = ics.mUniversalPinState;

            mGsmUmtsSubscriptionAppIndex = ics.mGsmUmtsSubscriptionAppIndex;

tests/telephonytests/src/com/android/internal/telephony/uicc/UiccProfileTest.java

0 → 100644
+272 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2017 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package com.android.internal.telephony.uicc;



import static com.android.internal.telephony.TelephonyTestUtils.waitForMs;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNull;

import static org.junit.Assert.assertTrue;

import static org.mockito.Matchers.any;

import static org.mockito.Mockito.anyInt;

import static org.mockito.Mockito.anyString;

import static org.mockito.Mockito.doAnswer;

import static org.mockito.Mockito.isA;

import static org.mockito.Mockito.times;

import static org.mockito.Mockito.verify;



import android.os.AsyncResult;

import android.os.Handler;

import android.os.HandlerThread;

import android.os.Message;

import android.test.suitebuilder.annotation.SmallTest;



import com.android.internal.telephony.TelephonyTest;

import com.android.internal.telephony.cat.CatService;



import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import org.mockito.ArgumentCaptor;

import org.mockito.Mock;

import org.mockito.invocation.InvocationOnMock;

import org.mockito.stubbing.Answer;



public class UiccProfileTest extends TelephonyTest {

    private UiccProfile mUiccProfile;



    public UiccProfileTest() {

        super();

    }



    private IccIoResult mIccIoResult;



    private UiccProfileHandlerThread mTestHandlerThread;

    private Handler mHandler;

    private static final int UICCPROFILE_UPDATE_PROFILE_EVENT = 1;

    private static final int UICCPROFILE_UPDATE_APPLICATION_EVENT = 2;

    private static final int UICCPROFILE_CARRIER_PRIVILEDGE_LOADED_EVENT = 3;



    @Mock

    private CatService mCAT;

    @Mock

    private IccCardStatus mIccCardStatus;

    @Mock

    private Handler mMockedHandler;

    @Mock

    private UiccCard mUiccCard;





    private class UiccProfileHandlerThread extends HandlerThread {



        private UiccProfileHandlerThread(String name) {

            super(name);

        }



        @Override

        public void onLooperPrepared() {

            mUiccProfile = new UiccProfile(mContextFixture.getTestDouble(),

                                           mSimulatedCommands, mIccCardStatus, 0 /* phoneId */,

                                           mUiccCard);

            /* create a custom handler for the Handler Thread */

            mHandler = new Handler(mTestHandlerThread.getLooper()) {

                @Override

                public void handleMessage(Message msg) {

                    switch (msg.what) {

                        case UICCPROFILE_UPDATE_PROFILE_EVENT:

                            /* Upon handling this event, new CarrierPrivilegeRule

                            will be created with the looper of HandlerThread */

                            logd("Update UICC Profile");

                            mUiccProfile.update(mContextFixture.getTestDouble(),

                                    mSimulatedCommands, mIccCardStatus);

                            setReady(true);

                            break;

                        case UICCPROFILE_UPDATE_APPLICATION_EVENT:

                            logd("Update UICC Profile Applications");

                            mUiccProfile.update(mContextFixture.getTestDouble(),

                                    mSimulatedCommands, mIccCardStatus);

                            setReady(true);

                            break;

                        default:

                            logd("Unknown Event " + msg.what);

                    }

                }

            };

            /* wait for the carrier privilege rules to be loaded */

            waitForMs(50);

            setReady(true);

            logd("Create UiccProfile");

        }

    }



    private IccCardApplicationStatus composeUiccApplicationStatus(

            IccCardApplicationStatus.AppType appType,

            IccCardApplicationStatus.AppState appState, String aid) {

        IccCardApplicationStatus mIccCardAppStatus = new IccCardApplicationStatus();

        mIccCardAppStatus.aid = aid;

        mIccCardAppStatus.app_type = appType;

        mIccCardAppStatus.app_state = appState;

        mIccCardAppStatus.pin1 = mIccCardAppStatus.pin2 =

                IccCardStatus.PinState.PINSTATE_ENABLED_VERIFIED;

        return mIccCardAppStatus;

    }



    @Before

    public void setUp() throws Exception {

        super.setUp(getClass().getSimpleName());

        /* initially there are no application available */

        mIccCardStatus.mApplications = new IccCardApplicationStatus[]{};

        mIccCardStatus.mCdmaSubscriptionAppIndex =

                mIccCardStatus.mImsSubscriptionAppIndex =

                        mIccCardStatus.mGsmUmtsSubscriptionAppIndex = -1;

        testHelper("FF40");

        /* starting the Handler Thread */

        mTestHandlerThread = new UiccProfileHandlerThread(TAG);

        mTestHandlerThread.start();



        waitUntilReady();

        replaceInstance(UiccProfile.class, "mCatService", mUiccProfile, mCAT);

    }



    @After

    public void tearDown() throws Exception {

        mTestHandlerThread.quit();

        super.tearDown();

    }



    private void testHelper(String hexString) {

        doAnswer(new Answer<Void>() {

            @Override

            public Void answer(InvocationOnMock invocation) throws Throwable {

                logd("Open");

                Message message = (Message) invocation.getArguments()[2];

                AsyncResult ar = new AsyncResult(null, new int[]{0}, null);

                message.obj = ar;

                message.sendToTarget();

                return null;

            }

        }).when(mUiccCard).iccOpenLogicalChannel(anyString(), anyInt(), any(Message.class));



        doAnswer(new Answer<Void>() {

            @Override

            public Void answer(InvocationOnMock invocation) throws Throwable {

                logd("Transmit");

                Message message = (Message) invocation.getArguments()[7];

                IccIoResult iir = new IccIoResult(0x90, 0x00, IccUtils.hexStringToBytes(hexString));

                AsyncResult ar = new AsyncResult(null, iir, null);

                message.obj = ar;

                message.sendToTarget();

                return null;

            }

        }).when(mUiccCard).iccTransmitApduLogicalChannel(anyInt(), anyInt(), anyInt(), anyInt(),

                anyInt(), anyInt(), anyString(), any(Message.class));



        doAnswer(new Answer<Void>() {

            @Override

            public Void answer(InvocationOnMock invocation) throws Throwable {

                logd("Close");

                Message message = (Message) invocation.getArguments()[1];

                message.sendToTarget();

                return null;

            }

        }).when(mUiccCard).iccCloseLogicalChannel(anyInt(), any(Message.class));

    }



    @Test

    @SmallTest

    public void tesUiccProfileInfoSanity() {

        assertEquals(0, mUiccProfile.getNumApplications());

        assertNull(mUiccProfile.getUniversalPinState());

        assertNull(mUiccProfile.getOperatorBrandOverride());

        for (IccCardApplicationStatus.AppType mAppType :

                IccCardApplicationStatus.AppType.values()) {

            assertFalse(mUiccProfile.isApplicationOnIcc(mAppType));

        }

    }



    @Test

    @SmallTest

    public void testUpdateUiccProfileApplication() {

        /* update app status and index */

        IccCardApplicationStatus cdmaApp = composeUiccApplicationStatus(

                IccCardApplicationStatus.AppType.APPTYPE_CSIM,

                IccCardApplicationStatus.AppState.APPSTATE_UNKNOWN, "0xA0");

        IccCardApplicationStatus imsApp = composeUiccApplicationStatus(

                IccCardApplicationStatus.AppType.APPTYPE_ISIM,

                IccCardApplicationStatus.AppState.APPSTATE_UNKNOWN, "0xA1");

        IccCardApplicationStatus umtsApp = composeUiccApplicationStatus(

                IccCardApplicationStatus.AppType.APPTYPE_USIM,

                IccCardApplicationStatus.AppState.APPSTATE_UNKNOWN, "0xA2");

        mIccCardStatus.mApplications = new IccCardApplicationStatus[]{cdmaApp, imsApp, umtsApp};

        mIccCardStatus.mCdmaSubscriptionAppIndex = 0;

        mIccCardStatus.mImsSubscriptionAppIndex = 1;

        mIccCardStatus.mGsmUmtsSubscriptionAppIndex = 2;

        Message mProfileUpdate = mHandler.obtainMessage(UICCPROFILE_UPDATE_APPLICATION_EVENT);

        setReady(false);

        mProfileUpdate.sendToTarget();



        waitUntilReady();



        assertEquals(3, mUiccProfile.getNumApplications());

        assertTrue(mUiccProfile.isApplicationOnIcc(IccCardApplicationStatus.AppType.APPTYPE_CSIM));

        assertTrue(mUiccProfile.isApplicationOnIcc(IccCardApplicationStatus.AppType.APPTYPE_ISIM));

        assertTrue(mUiccProfile.isApplicationOnIcc(IccCardApplicationStatus.AppType.APPTYPE_USIM));

    }



    @Test

    @SmallTest

    public void testUpdateUiccProfile() {

        Message mCardUpdate = mHandler.obtainMessage(UICCPROFILE_UPDATE_PROFILE_EVENT);

        setReady(false);

        mCardUpdate.sendToTarget();

        /* try to create a new CarrierPrivilege, loading state -> loaded state */

        /* wait till the async result and message delay */

        waitUntilReady();

        /* wait for the carrier privilege rules to be loaded */

        waitForMs(50);



        assertTrue(mUiccProfile.areCarrierPriviligeRulesLoaded());

        verify(mUiccCard, times(2)).iccOpenLogicalChannel(isA(String.class),

                anyInt(), isA(Message.class));

        verify(mUiccCard, times(2)).iccTransmitApduLogicalChannel(

                anyInt(), anyInt(), anyInt(), anyInt(), anyInt(), anyInt(), anyString(),

                isA(Message.class)

        );

    }



    @Test

    @SmallTest

    public void testUpdateUiccProfilePinState() {

        mIccCardStatus.mUniversalPinState = IccCardStatus.PinState.PINSTATE_ENABLED_VERIFIED;

        mUiccProfile.update(mContextFixture.getTestDouble(), mSimulatedCommands, mIccCardStatus);

        assertEquals(IccCardStatus.PinState.PINSTATE_ENABLED_VERIFIED,

                mUiccProfile.getUniversalPinState());

    }



    @Test

    @SmallTest

    public void testCarrierPriviledgeLoadedListener() {

        mUiccProfile.registerForCarrierPrivilegeRulesLoaded(mMockedHandler,

                UICCPROFILE_CARRIER_PRIVILEDGE_LOADED_EVENT, null);

        ArgumentCaptor<Message> mCaptorMessage = ArgumentCaptor.forClass(Message.class);

        ArgumentCaptor<Long> mCaptorLong = ArgumentCaptor.forClass(Long.class);

        testUpdateUiccProfile();

        verify(mMockedHandler, times(1)).sendMessageDelayed(mCaptorMessage.capture(),

                mCaptorLong.capture());

        assertEquals(UICCPROFILE_CARRIER_PRIVILEDGE_LOADED_EVENT, mCaptorMessage.getValue().what);

    }

}