Merge changes from topic "uiccprofile_test" am: 1ad8b167eb (5261a050) · Commits · e / os / android_frameworks_opt_telephony

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);
		}
		}