/*
 * Copyright (C) 2018 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.euicc;

import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import android.content.res.Resources;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.service.carrier.CarrierIdentifier;
import android.service.euicc.EuiccProfileInfo;
import android.telephony.UiccAccessRule;
import android.telephony.euicc.EuiccCardManager;
import android.telephony.euicc.EuiccNotification;
import android.telephony.euicc.EuiccRulesAuthTable;
import android.util.ExceptionUtils;
import android.util.Log;

import com.android.internal.telephony.CommandsInterface;
import com.android.internal.telephony.TelephonyTest;
import com.android.internal.telephony.uicc.IccCardApplicationStatus;
import com.android.internal.telephony.uicc.IccCardStatus;
import com.android.internal.telephony.uicc.IccUtils;
import com.android.internal.telephony.uicc.asn1.Asn1Node;
import com.android.internal.telephony.uicc.asn1.InvalidAsn1DataException;
import com.android.internal.telephony.uicc.asn1.TagNotFoundException;
import com.android.internal.telephony.uicc.euicc.apdu.LogicalChannelMocker;
import com.android.internal.telephony.uicc.euicc.async.AsyncResultCallback;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;

import java.util.Arrays;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class EuiccCardTest extends TelephonyTest {
    private static final long WAIT_TIMEOUT_MLLIS = 5000;

    private static class ResultCaptor<T> extends AsyncResultCallback<T> {
        public T result;
        public Throwable exception;

        private CountDownLatch mLatch;

        private ResultCaptor() {
            mLatch = new CountDownLatch(1);
        }

        public void await() {
            try {
                mLatch.await(WAIT_TIMEOUT_MLLIS, TimeUnit.MILLISECONDS);
            } catch (InterruptedException e) {
                fail("Execution is interrupted: " + e);
            }
        }

        @Override
        public void onResult(T r) {
            result = r;
            mLatch.countDown();
        }

        @Override
        public void onException(Throwable e) {
            exception = e;
            mLatch.countDown();
        }
    }

    private class UiccCardHandlerThread extends HandlerThread {
        private UiccCardHandlerThread(String name) {
            super(name);
        }

        @Override
        public void onLooperPrepared() {
            mEuiccCard =
                    new EuiccCard(mContextFixture.getTestDouble(), mMockCi, mMockIccCardStatus,
                            0 /* phoneId */, new Object()) {
                        @Override
                        protected byte[] getDeviceId() {
                            return IccUtils.bcdToBytes("987654321012345");
                        }

                        @Override
                        protected void loadEidAndNotifyRegistrants() {}

                        @Override
                        protected Resources getResources() {
                            return mMockResources;
                        }

                    };
            mHandler = new Handler(mTestHandlerThread.getLooper());
            setReady(true);
        }
    }

    @Mock
    private CommandsInterface mMockCi;
    @Mock
    private IccCardStatus mMockIccCardStatus;

    private UiccCardHandlerThread mTestHandlerThread;
    private Handler mHandler;

    private EuiccCard mEuiccCard;

    @Mock
    private Resources mMockResources;

    @Before
    public void setUp() throws Exception {
        super.setUp(getClass().getSimpleName());

        mMockIccCardStatus.mApplications = new IccCardApplicationStatus[]{};
        mMockIccCardStatus.mCdmaSubscriptionAppIndex =
                mMockIccCardStatus.mImsSubscriptionAppIndex =
                        mMockIccCardStatus.mGsmUmtsSubscriptionAppIndex = -1;
        mMockIccCardStatus.mCardState = IccCardStatus.CardState.CARDSTATE_PRESENT;

        mTestHandlerThread = new UiccCardHandlerThread(getClass().getSimpleName());
        mTestHandlerThread.start();

        waitUntilReady();
    }

    @After
    public void tearDown() throws Exception {
        mTestHandlerThread.quit();
        super.tearDown();
    }

    private void assertUnexpectedException(Throwable e) {
        if (e != null) {
            fail("Unexpected exception: " + ExceptionUtils.getCompleteMessage(e) + "\n-----\n"
                    + Log.getStackTraceString(e.getCause()) + "-----");
        }
    }

    @Test
    public void testLoadEidAndNotifyRegistrants() throws InterruptedException {
        int channel = mockLogicalChannelResponses("BF3E065A041A2B3C4D9000");

        {
            final CountDownLatch latch = new CountDownLatch(1);
            mHandler.post(() -> {
                mEuiccCard = new EuiccCard(mContextFixture.getTestDouble(), mMockCi,
                        mMockIccCardStatus, 0 /* phoneId */, new Object());
                latch.countDown();
            });
            assertTrue(latch.await(WAIT_TIMEOUT_MLLIS, TimeUnit.MILLISECONDS));
        }

        final int eventEidReady = 0;
        final CountDownLatch latch = new CountDownLatch(1);
        Handler handler = new Handler(mTestHandlerThread.getLooper()) {
            @Override
            public void handleMessage(Message msg) {
                if (msg.what == eventEidReady) {
                    assertEquals("1A2B3C4D", mEuiccCard.getEid());
                    latch.countDown();
                }
            }
        };

        mEuiccCard.registerForEidReady(handler, eventEidReady, null /* obj */);
        assertTrue(latch.await(WAIT_TIMEOUT_MLLIS, TimeUnit.MILLISECONDS));

        verifyStoreData(channel, "BF3E035C015A");
    }

    @Test
    public void testGetAllProfiles() {
        int channel = mockLogicalChannelResponses(
                "BF2D14A012E3105A0A896700000000004523019F7001019000");

        ResultCaptor<EuiccProfileInfo[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.getAllProfiles(resultCaptor, mHandler);
        resultCaptor.await();

        assertUnexpectedException(resultCaptor.exception);
        EuiccProfileInfo[] profiles = resultCaptor.result;
        assertEquals(1, profiles.length);
        assertEquals("98760000000000543210", profiles[0].getIccid());
        assertEquals(EuiccProfileInfo.PROFILE_STATE_ENABLED, profiles[0].getState());
        verifyStoreData(channel, "BF2D0D5C0B5A909192B79F709599BF76");
    }

    @Test
    public void testFSuffix() {
        // iccID is 987600000000005432FF.
        int channel = mockLogicalChannelResponses(
                "BF2D14A012E3105A0A896700000000004523FF9F7001019000");

        ResultCaptor<EuiccProfileInfo[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.getAllProfiles(resultCaptor, mHandler);
        resultCaptor.await();

        EuiccProfileInfo[] profiles = resultCaptor.result;
        assertEquals(1, profiles.length);
        assertEquals("987600000000005432", profiles[0].getIccid());
        assertEquals(EuiccProfileInfo.PROFILE_STATE_ENABLED, profiles[0].getState());
        verifyStoreData(channel, "BF2D0D5C0B5A909192B79F709599BF76");
    }

    @Test
    public void testGetProfile() {
        int channel = mockLogicalChannelResponses("BF2D8184A08181E37F"
                + "5A0A89670000000000452301" // ICCID
                + "90046E69636B" // Nickname
                + "9103746D6F" // Service provider name
                + "92027031" // Profile name
                + "B70F800312F34581030102038203040506" // Operator id
                + "9F700101" // Profile state
                + "950101" // Profile class
                + "990206C0" // Policy rules
                + "BF7645E243E135C114ABCD92CBB156B280FA4E1429A6ECEEB6E5C1BFE4"
                + "CA1D636F6D2E676F6F676C652E616E64726F69642E617070732E6D79617070"
                + "E30ADB080000000000000001" // Carrier privilege rules
                + "9000");

        ResultCaptor<EuiccProfileInfo> resultCaptor = new ResultCaptor<>();
        mEuiccCard.getProfile("98760000000000543210", resultCaptor, mHandler);
        resultCaptor.await();

        EuiccProfileInfo profile = resultCaptor.result;
        assertEquals("98760000000000543210", profile.getIccid());
        assertEquals("nick", profile.getNickname());
        assertEquals("tmo", profile.getServiceProviderName());
        assertEquals("p1", profile.getProfileName());
        assertEquals("213", profile.getCarrierIdentifier().getMcc());
        assertEquals("54", profile.getCarrierIdentifier().getMnc());
        assertEquals("010203", profile.getCarrierIdentifier().getGid1());
        assertEquals("040506", profile.getCarrierIdentifier().getGid2());
        assertEquals(EuiccProfileInfo.PROFILE_STATE_ENABLED, profile.getState());
        assertEquals(EuiccProfileInfo.PROFILE_CLASS_PROVISIONING, profile.getProfileClass());
        assertEquals(
                EuiccProfileInfo.POLICY_RULE_DO_NOT_DELETE
                        | EuiccProfileInfo.POLICY_RULE_DO_NOT_DISABLE,
                profile.getPolicyRules());
        assertArrayEquals(
                new UiccAccessRule[] {
                        new UiccAccessRule(
                                IccUtils.hexStringToBytes(
                                        "ABCD92CBB156B280FA4E1429A6ECEEB6E5C1BFE4"),
                                "com.google.android.apps.myapp", 1)
                },
                profile.getUiccAccessRules().toArray());
        verifyStoreData(channel, "BF2D1BA00C5A0A896700000000004523015C0B5A909192B79F709599BF76");
    }

    @Test
    public void testDisableProfile() {
        int channel = mockLogicalChannelResponses("BF32038001009000");

        ResultCaptor<Void> resultCaptor = new ResultCaptor<>();
        mEuiccCard.disableProfile("98760000000000543210", true, resultCaptor, mHandler);
        resultCaptor.await();

        assertUnexpectedException(resultCaptor.exception);
        verifyStoreData(channel, "BF3211A00C5A0A896700000000004523018101FF");
    }

    @Test
    public void testDisableProfile_SimRefresh() {
        int channel = mockLogicalChannelResponses("6106", "6f00");

        ResultCaptor<Void> resultCaptor = new ResultCaptor<>();
        mEuiccCard.disableProfile("98760000000000543210", true, resultCaptor, mHandler);
        resultCaptor.await();

        assertUnexpectedException(resultCaptor.exception);
        verifyStoreData(channel, "BF3211A00C5A0A896700000000004523018101FF");
    }

    @Test
    public void testDisableProfile_Error() {
        int channel = mockLogicalChannelResponses("BF32038001039000");

        ResultCaptor<Void> resultCaptor = new ResultCaptor<>();
        mEuiccCard.disableProfile("98760000000000543210", true, resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals(3, ((EuiccCardErrorException) resultCaptor.exception).getErrorCode());
        verifyStoreData(channel, "BF3211A00C5A0A896700000000004523018101FF");
    }

    @Test
    public void testSwitchToProfile() {
        int channel = mockLogicalChannelResponses("BF31038001009000");

        ResultCaptor<Void> resultCaptor = new ResultCaptor<>();
        mEuiccCard.switchToProfile("98760000000000543210", true, resultCaptor, mHandler);
        resultCaptor.await();

        assertUnexpectedException(resultCaptor.exception);
        verifyStoreData(channel, "BF3111A00C5A0A896700000000004523018101FF");
    }

    @Test
    public void testSwitchToProfile_SimRefresh() {
        int channel = mockLogicalChannelResponses("6106", "6f00");

        ResultCaptor<Void> resultCaptor = new ResultCaptor<>();
        mEuiccCard.switchToProfile("98760000000000543210", true, resultCaptor, mHandler);
        resultCaptor.await();

        assertUnexpectedException(resultCaptor.exception);
        verifyStoreData(channel, "BF3111A00C5A0A896700000000004523018101FF");
    }

    @Test
    public void testSwitchToProfile_Error() {
        int channel = mockLogicalChannelResponses("BF31038001039000");

        ResultCaptor<Void> resultCaptor = new ResultCaptor<>();
        mEuiccCard.switchToProfile("98760000000000543210", true, resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals(3, ((EuiccCardErrorException) resultCaptor.exception).getErrorCode());
        verifyStoreData(channel, "BF3111A00C5A0A896700000000004523018101FF");
    }

    @Test
    public void testGetEid() {
        int channel = mockLogicalChannelResponses("BF3E065A041A2B3C4D9000");

        ResultCaptor<String> resultCaptor = new ResultCaptor<>();
        mEuiccCard.getEid(resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals("1A2B3C4D", resultCaptor.result);
        verifyStoreData(channel, "BF3E035C015A");
    }

    @Test
    public void testSetNickname() {
        int channel = mockLogicalChannelResponses("BF29038001009000");

        ResultCaptor<Void> resultCaptor = new ResultCaptor<>();
        mEuiccCard.setNickname("98760000000000543210", "new nickname", resultCaptor, mHandler);
        resultCaptor.await();

        assertUnexpectedException(resultCaptor.exception);
        verifyStoreData(channel, "BF291A5A0A89670000000000452301900C6E6577206E69636B6E616D65");
    }

    @Test
    public void testDeleteProfile() {
        int channel = mockLogicalChannelResponses("BF33038001009000");

        ResultCaptor<Void> resultCaptor = new ResultCaptor<>();
        mEuiccCard.deleteProfile("98760000000000543210", resultCaptor, mHandler);
        resultCaptor.await();

        assertUnexpectedException(resultCaptor.exception);
        verifyStoreData(channel, "BF330C5A0A89670000000000452301");
    }

    @Test
    public void testDeleteProfile_Error() {
        int channel = mockLogicalChannelResponses("BF33038001039000");

        ResultCaptor<Void> resultCaptor = new ResultCaptor<>();
        mEuiccCard.deleteProfile("98760000000000543210", resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals(3, ((EuiccCardErrorException) resultCaptor.exception).getErrorCode());
        verifyStoreData(channel, "BF330C5A0A89670000000000452301");
    }

    @Test
    public void testGetDefaultSmdpAddress() {
        int channel = mockLogicalChannelResponses(
                "BF3C148008534D44502E434F4D8108736D64732E636F6D9000");

        ResultCaptor<String> resultCaptor = new ResultCaptor<>();
        mEuiccCard.getDefaultSmdpAddress(resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals("SMDP.COM", resultCaptor.result);
        verifyStoreData(channel, "BF3C00");
    }

    @Test
    public void testGetSmdsAddress() {
        int channel = mockLogicalChannelResponses(
                "BF3C148008534D44502E434F4D8108736D64732E636F6D9000");

        ResultCaptor<String> resultCaptor = new ResultCaptor<>();
        mEuiccCard.getSmdsAddress(resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals("smds.com", resultCaptor.result);
        verifyStoreData(channel, "BF3C00");
    }

    @Test
    public void testSetDefaultSmdpAddress() {
        int channel = mockLogicalChannelResponses("BF3F038001009000");

        ResultCaptor<Void> resultCaptor = new ResultCaptor<>();
        mEuiccCard.setDefaultSmdpAddress("smdp.gsma.com", resultCaptor, mHandler);
        resultCaptor.await();

        assertUnexpectedException(resultCaptor.exception);
        verifyStoreData(channel, "BF3F0F800D736D64702E67736D612E636F6D");
    }

    @Test
    public void testGetRulesAuthTable() {
        int channel = mockLogicalChannelResponses("BF4347"
                + "A021" // Rule #1
                + "800206C0" // Policy rules: DO_NOT_DELETE | DO_NOT_DISABLE
                + "A118" // Operator IDs
                + "B70A800312F3458103010203" // ID #1: 213, 54, [1,2,3], null
                + "B70A800312F3458203040506" // ID #2: 213, 54, null, [4,5,6]
                + "820108" // Flag (no user consent)
                + "A022" // Rule #2
                + "80020780" // Policy rules: DO_NOT_DISABLE
                + "A118" // Operator IDs
                + "B70A800312E3458103010203" // ID #1: 213, 54E, [1,2,3], null
                + "B70A8003EEEE458203040506" // ID #2: EEE, 54E, null, [4,5,6]
                + "82020780" // Flag (user consent)
                + "9000");

        ResultCaptor<EuiccRulesAuthTable> resultCaptor = new ResultCaptor<>();
        mEuiccCard.getRulesAuthTable(resultCaptor, mHandler);
        resultCaptor.await();

        EuiccRulesAuthTable rat = resultCaptor.result;
        assertEquals(-1,
                rat.findIndex(EuiccProfileInfo.POLICY_RULE_DO_NOT_DELETE,
                        new CarrierIdentifier(new byte[] {0x12, (byte) 0xF3, 0x45}, null, null)));
        assertEquals(1,
                rat.findIndex(EuiccProfileInfo.POLICY_RULE_DO_NOT_DISABLE,
                        new CarrierIdentifier(new byte[] {0x23, 0x67, 0x45}, null, "040506")));
        assertFalse(rat.hasPolicyRuleFlag(0,
                EuiccRulesAuthTable.POLICY_RULE_FLAG_CONSENT_REQUIRED));
        assertTrue(rat.hasPolicyRuleFlag(1,
                EuiccRulesAuthTable.POLICY_RULE_FLAG_CONSENT_REQUIRED));
        verifyStoreData(channel, "BF4300");
    }

    @Test
    public void testResetMemory() {
        int channel = mockLogicalChannelResponses("BF34038001009000");

        ResultCaptor<Void> resultCaptor = new ResultCaptor<>();
        mEuiccCard.resetMemory(EuiccCardManager.RESET_OPTION_DELETE_FIELD_LOADED_TEST_PROFILES,
                resultCaptor, mHandler);
        resultCaptor.await();

        assertUnexpectedException(resultCaptor.exception);
        verifyStoreData(channel, "BF340482020640");
    }

    @Test
    public void testResetMemory_SimRefresh() {
        int channel = mockLogicalChannelResponses("6106", "6f00");

        ResultCaptor<Void> resultCaptor = new ResultCaptor<>();
        mEuiccCard.resetMemory(EuiccCardManager.RESET_OPTION_DELETE_FIELD_LOADED_TEST_PROFILES,
                resultCaptor, mHandler);
        resultCaptor.await();

        assertUnexpectedException(resultCaptor.exception);
        verifyStoreData(channel, "BF340482020640");
    }

    @Test
    public void testGetEuiccChallenge() {
        int channel = mockLogicalChannelResponses("BF2E0580030102039000");

        ResultCaptor<byte[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.getEuiccChallenge(resultCaptor, mHandler);
        resultCaptor.await();

        assertArrayEquals(new byte[] {1, 2, 3}, resultCaptor.result);
        verifyStoreData(channel, "BF2E00");
    }

    @Test
    public void testGetEuiccInfo1() {
        int channel = mockLogicalChannelResponses("BF20030102039000");

        ResultCaptor<byte[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.getEuiccInfo1(resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals("BF2003010203", IccUtils.bytesToHexString(resultCaptor.result));
        verifyStoreData(channel, "BF2000");
    }

    @Test
    public void testGetEuiccInfo2() {
        int channel = mockLogicalChannelResponses("BF22030102039000");

        ResultCaptor<byte[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.getEuiccInfo2(resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals("BF2203010203", IccUtils.bytesToHexString(resultCaptor.result));
        verifyStoreData(channel, "BF2200");
    }

    @Test
    public void testAuthenticateServer() {
        when(mMockResources.getStringArray(
                com.android.internal.R.array.config_telephonyEuiccDeviceCapabilities))
                .thenReturn(new String[] {});

        int channel = mockLogicalChannelResponses("BF3802A0009000");

        ResultCaptor<byte[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.authenticateServer("A1B2C3-X4Y5Z6", // Matching id
                Asn1Node.newBuilder(0xA0).build().toBytes(),
                Asn1Node.newBuilder(0xA1).build().toBytes(),
                Asn1Node.newBuilder(0xA2).build().toBytes(),
                Asn1Node.newBuilder(0xA3).build().toBytes(), resultCaptor, mHandler);
        resultCaptor.await();

        assertUnexpectedException(resultCaptor.exception);
        assertEquals("BF3802A000", IccUtils.bytesToHexString(resultCaptor.result));
        verifyStoreData(channel,
                "BF382D" + "A000" + "A100" + "A200" + "A300" + "A023"
                        + "800D4131423243332D583459355A36" // Matching id
                        + "A112800489674523" // TAC
                        + "A100" // Device capabilities
                        + "82088967452301214305"); // IMEI
    }

    @Test
    public void testAuthenticateServer_Error() {
        when(mMockResources.getStringArray(
                com.android.internal.R.array.config_telephonyEuiccDeviceCapabilities))
                .thenReturn(new String[] {});

        int channel = mockLogicalChannelResponses("BF38038101039000");

        ResultCaptor<byte[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.authenticateServer("A1B2C3-X4Y5Z6", // Matching id
                Asn1Node.newBuilder(0xA0).build().toBytes(),
                Asn1Node.newBuilder(0xA1).build().toBytes(),
                Asn1Node.newBuilder(0xA2).build().toBytes(),
                Asn1Node.newBuilder(0xA3).build().toBytes(), resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals(3, ((EuiccCardErrorException) resultCaptor.exception).getErrorCode());
        verifyStoreData(channel,
                "BF382D" + "A000" + "A100" + "A200" + "A300" + "A023"
                        + "800D4131423243332D583459355A36" // Matching id
                        + "A112800489674523" // TAC
                        + "A100" // Device capabilities
                        + "82088967452301214305"); // IMEI
    }

    @Test
    public void testAuthenticateService_devCap() {
        when(mMockResources.getStringArray(
                com.android.internal.R.array.config_telephonyEuiccDeviceCapabilities))
                .thenReturn(new String[] {
                        "gsm,11",
                        "utran,11",
                        "cdma1x,1",
                        "hrpd,3",
                        "ehrpd,12",
                        "eutran,11"});

        int channel = mockLogicalChannelResponses("BF3802A0009000");

        ResultCaptor<byte[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.authenticateServer("A1B2C3-X4Y5Z6", // Matching id
                Asn1Node.newBuilder(0xA0).build().toBytes(),
                Asn1Node.newBuilder(0xA1).build().toBytes(),
                Asn1Node.newBuilder(0xA2).build().toBytes(),
                Asn1Node.newBuilder(0xA3).build().toBytes(), resultCaptor, mHandler);
        resultCaptor.await();

        assertUnexpectedException(resultCaptor.exception);
        assertEquals("BF3802A000", IccUtils.bytesToHexString(resultCaptor.result));
        verifyStoreData(channel,
                "BF384B" + "A000" + "A100" + "A200" + "A300" + "A041"
                        + "800D4131423243332D583459355A36" // Matching id
                        + "A130800489674523" // TAC
                        // Device capabilities
                        + "A11E80030B000081030B00008203010000830303000084030C000085030B0000"
                        + "82088967452301214305"); // IMEI
    }

    @Test
    public void testPrepareDownload() {
        int channel = mockLogicalChannelResponses("BF2102A0009000");

        ResultCaptor<byte[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.prepareDownload(
                IccUtils.hexStringToBytes("4131423243332D583459355A36"), // hashCc
                Asn1Node.newBuilder(0xA0).build().toBytes(),
                Asn1Node.newBuilder(0xA1).build().toBytes(),
                Asn1Node.newBuilder(0xA2).build().toBytes(), resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals("BF2102A000", IccUtils.bytesToHexString(resultCaptor.result));
        verifyStoreData(channel,
                "BF2115" + "A000" + "A100"
                        + "040D4131423243332D583459355A36" // hashCc
                        + "A200");
    }

    @Test
    public void testPrepareDownload_Error() {
        int channel = mockLogicalChannelResponses("BF2105A1030201039000");

        ResultCaptor<byte[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.prepareDownload(
                IccUtils.hexStringToBytes("4131423243332D583459355A36"), // hashCc
                Asn1Node.newBuilder(0xA0).build().toBytes(),
                Asn1Node.newBuilder(0xA1).build().toBytes(),
                Asn1Node.newBuilder(0xA2).build().toBytes(), resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals(3, ((EuiccCardErrorException) resultCaptor.exception).getErrorCode());
        verifyStoreData(channel,
                "BF2115" + "A000" + "A100"
                        + "040D4131423243332D583459355A36" // hashCc
                        + "A200");
    }

    @Test
    public void testLoadBoundProfilePackage() {
        int channel = mockLogicalChannelResponses(
                // For boundProfilePackage head + initialiseSecureChannelRequest
                // (ES8+.InitialiseSecureChannel)
                "9000",
                // For firstSequenceOf87 (ES8+.ConfigureISDP)
                "9000",
                // For head of sequenceOf88 (ES8+.StoreMetadata)
                "9000",
                // For body (element 1) of sequenceOf88 (ES8+.StoreMetadata)
                "9000",
                "9000",
                // For head of sequenceOf86 (ES8+.LoadProfileElements)
                "9000",
                // For body (element 1) of sequenceOf86 (ES8+.LoadProfileElements)
                "9000",
                // Profile installation result (element 2 of sequenceOf86)
                "BF37009000");

        ResultCaptor<byte[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.loadBoundProfilePackage(
                Asn1Node.newBuilder(0xBF36)
                        .addChild(Asn1Node.newBuilder(0xBF23))
                        .addChild(Asn1Node.newBuilder(0xA0)
                                .addChildAsBytes(0x87, new byte[] {1, 2, 3}))
                        .addChild(Asn1Node.newBuilder(0xA1)
                                .addChildAsBytes(0x88, new byte[] {4, 5, 6}))
                        .addChild(Asn1Node.newBuilder(0xA2))
                        .addChild(Asn1Node.newBuilder(0xA3)
                                .addChildAsBytes(0x86, new byte[] {7, 8, 9})
                                .addChildAsBytes(0x86, new byte[] {0xA, 0xB, 0xC}))
                        .build().toBytes(),
                resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals("BF3700", IccUtils.bytesToHexString(resultCaptor.result));
        verifyStoreData(channel, "BF361FBF2300"); // ES8+.InitialiseSecureChannel
        verifyStoreData(channel, "A0058703010203"); // ES8+.ConfigureISDP
        verifyStoreData(channel, "A105"); // ES8+.StoreMetadata
        verifyStoreData(channel, "8803040506"); // ES8+.StoreMetadata
        verifyStoreData(channel, "A200");
        verifyStoreData(channel, "A30A"); // ES8+.LoadProfileElements
        verifyStoreData(channel, "8603070809"); // ES8+.LoadProfileElements
        verifyStoreData(channel, "86030A0B0C"); // ES8+.LoadProfileElements
    }

    @Test
    public void testLoadBoundProfilePackage_Error() {
        int channel = mockLogicalChannelResponses(
                // For boundProfilePackage head + initialiseSecureChannelRequest
                // (ES8+.InitialiseSecureChannel)
                "9000",
                // For firstSequenceOf87 (ES8+.ConfigureISDP)
                "9000",
                // For head of sequenceOf88 (ES8+.StoreMetadata)
                "9000",
                // For body (element 1) of sequenceOf88 (ES8+.StoreMetadata)
                "9000",
                "9000",
                // For head of sequenceOf86 (ES8+.LoadProfileElements)
                "9000",
                // For body (element 1) of sequenceOf86 (ES8+.LoadProfileElements)
                "9000",
                // Profile installation result (element 2 of sequenceOf86)
                "BF370ABF2707A205A1038101039000");

        ResultCaptor<byte[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.loadBoundProfilePackage(
                Asn1Node.newBuilder(0xBF36)
                        .addChild(Asn1Node.newBuilder(0xBF23))
                        .addChild(Asn1Node.newBuilder(0xA0)
                                .addChildAsBytes(0x87, new byte[] {1, 2, 3}))
                        .addChild(Asn1Node.newBuilder(0xA1)
                                .addChildAsBytes(0x88, new byte[] {4, 5, 6}))
                        .addChild(Asn1Node.newBuilder(0xA2))
                        .addChild(Asn1Node.newBuilder(0xA3)
                                .addChildAsBytes(0x86, new byte[] {7, 8, 9})
                                .addChildAsBytes(0x86, new byte[] {0xA, 0xB, 0xC}))
                        .build().toBytes(),
                resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals(3, ((EuiccCardErrorException) resultCaptor.exception).getErrorCode());
        verifyStoreData(channel, "BF361FBF2300"); // ES8+.InitialiseSecureChannel
        verifyStoreData(channel, "A0058703010203"); // ES8+.ConfigureISDP
        verifyStoreData(channel, "A105"); // ES8+.StoreMetadata
        verifyStoreData(channel, "8803040506"); // ES8+.StoreMetadata
        verifyStoreData(channel, "A200");
        verifyStoreData(channel, "A30A"); // ES8+.LoadProfileElements
        verifyStoreData(channel, "8603070809"); // ES8+.LoadProfileElements
        verifyStoreData(channel, "86030A0B0C"); // ES8+.LoadProfileElements
    }

    @Test
    public void testCancelSession() {
        int channel = mockLogicalChannelResponses("BF41009000");

        ResultCaptor<byte[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.cancelSession(IccUtils.hexStringToBytes("A1B2C3"),
                EuiccCardManager.CANCEL_REASON_POSTPONED, resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals("BF4100", IccUtils.bytesToHexString(resultCaptor.result));
        verifyStoreData(channel, "BF41088003A1B2C3810101");
    }

    @Test
    public void testCancelSession_Error() {
        int channel = mockLogicalChannelResponses("BF41038101039000");

        ResultCaptor<byte[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.cancelSession(IccUtils.hexStringToBytes("A1B2C3"),
                EuiccCardManager.CANCEL_REASON_POSTPONED, resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals(3, ((EuiccCardErrorException) resultCaptor.exception).getErrorCode());
        verifyStoreData(channel, "BF41088003A1B2C3810101");
    }

    @Test
    public void testListNotifications() {
        int channel = mockLogicalChannelResponses("BF282BA029"
                + "BF2F118001010C08736D64702E636F6D81020410" // Notification #1
                + "BF2F128001020C09736D6470322E636F6D81020420" // Notification #2
                + "9000");

        ResultCaptor<EuiccNotification[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.listNotifications(
                EuiccNotification.EVENT_DELETE | EuiccNotification.EVENT_DISABLE,
                resultCaptor, mHandler);
        resultCaptor.await();

        assertArrayEquals(
                new EuiccNotification[] {
                        new EuiccNotification(1, "smdp.com", EuiccNotification.EVENT_DELETE, null),
                        new EuiccNotification(2, "smdp2.com", EuiccNotification.EVENT_DISABLE, null)
                },
                resultCaptor.result);
        verifyStoreData(channel, "BF280481020430");
    }

    @Test
    public void testListNotifications_Error() {
        int channel = mockLogicalChannelResponses("BF28038101039000");

        ResultCaptor<EuiccNotification[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.listNotifications(
                EuiccNotification.EVENT_DELETE | EuiccNotification.EVENT_DISABLE,
                resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals(3, ((EuiccCardErrorException) resultCaptor.exception).getErrorCode());
        verifyStoreData(channel, "BF280481020430");
    }

    @Test
    public void testRetrieveNotificationList() {
        int channel = mockLogicalChannelResponses("BF2B2FA02D"
                // Notification #1
                + "3014BF2F118001010C08736D64702E636F6D81020410"
                // Notification #2
                + "3015BF2F128001020C09736D6470322E636F6D81020420"
                + "9000");

        ResultCaptor<EuiccNotification[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.retrieveNotificationList(
                EuiccNotification.EVENT_DELETE | EuiccNotification.EVENT_DISABLE,
                resultCaptor, mHandler);
        resultCaptor.await();

        assertArrayEquals(
                new EuiccNotification[] {
                        new EuiccNotification(1, "smdp.com", EuiccNotification.EVENT_DELETE,
                                IccUtils.hexStringToBytes(
                                        "3014BF2F118001010C08736D64702E636F6D81020410")),
                        new EuiccNotification(2, "smdp2.com", EuiccNotification.EVENT_DISABLE,
                                IccUtils.hexStringToBytes(
                                        "3015BF2F128001020C09736D6470322E636F6D81020420"))
                },
                resultCaptor.result);
        verifyStoreData(channel, "BF2B06A00481020430");
    }

    @Test
    public void testRetrieveNotificationList_Empty() {
        int channel = mockLogicalChannelResponses("BF2B038101019000");

        ResultCaptor<EuiccNotification[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.retrieveNotificationList(
                EuiccNotification.EVENT_DELETE | EuiccNotification.EVENT_DISABLE,
                resultCaptor, mHandler);
        resultCaptor.await();

        assertArrayEquals(new EuiccNotification[0], resultCaptor.result);
        verifyStoreData(channel, "BF2B06A00481020430");
    }

    @Test
    public void testRetrieveNotificationList_Error() {
        int channel = mockLogicalChannelResponses("BF2B038101039000");

        ResultCaptor<EuiccNotification[]> resultCaptor = new ResultCaptor<>();
        mEuiccCard.retrieveNotificationList(
                EuiccNotification.EVENT_DELETE | EuiccNotification.EVENT_DISABLE,
                resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals(3, ((EuiccCardErrorException) resultCaptor.exception).getErrorCode());
        verifyStoreData(channel, "BF2B06A00481020430");
    }

    @Test
    public void testRetrieveNotification() {
        int channel = mockLogicalChannelResponses("BF2B18A016"
                + "3014BF2F118001010C08736D64702E636F6D81020410" // Notification
                + "9000");

        ResultCaptor<EuiccNotification> resultCaptor = new ResultCaptor<>();
        mEuiccCard.retrieveNotification(5, resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals(
                new EuiccNotification(1, "smdp.com", EuiccNotification.EVENT_DELETE,
                        IccUtils.hexStringToBytes("3014BF2F118001010C08736D64702E636F6D81020410")),
                resultCaptor.result);
        verifyStoreData(channel, "BF2B05A003800105");
    }

    @Test
    public void testRetrieveNotification_Error() {
        int channel = mockLogicalChannelResponses("BF2B038101019000");

        ResultCaptor<EuiccNotification> resultCaptor = new ResultCaptor<>();
        mEuiccCard.retrieveNotification(5, resultCaptor, mHandler);
        resultCaptor.await();

        assertEquals(1, ((EuiccCardErrorException) resultCaptor.exception).getErrorCode());
        verifyStoreData(channel, "BF2B05A003800105");
    }

    @Test
    public void testRemoveNotificationFromList() {
        int channel = mockLogicalChannelResponses("BF30038001009000");

        ResultCaptor<Void> resultCaptor = new ResultCaptor<>();
        mEuiccCard.removeNotificationFromList(5, resultCaptor, mHandler);
        resultCaptor.await();

        assertUnexpectedException(resultCaptor.exception);
        verifyStoreData(channel, "BF3003800105");
    }

    @Test
    public void testAddDeviceCapability() throws InvalidAsn1DataException, TagNotFoundException {
        Asn1Node.Builder devCapsBuilder = Asn1Node.newBuilder(Tags.TAG_CTX_COMP_1);

        String devCapItem = "gsm,11";
        mEuiccCard.addDeviceCapability(devCapsBuilder, devCapItem);
        Asn1Node node = devCapsBuilder.build();

        assertTrue(node.hasChild(Tags.TAG_CTX_0));
        Asn1Node child = node.getChild(Tags.TAG_CTX_0);
        assertTrue(Arrays.equals(new byte[] {11, 0 , 0}, child.asBytes()));

        devCapItem = "utran,11";
        mEuiccCard.addDeviceCapability(devCapsBuilder, devCapItem);
        node = devCapsBuilder.build();

        assertTrue(node.hasChild(Tags.TAG_CTX_1));
        child = node.getChild(Tags.TAG_CTX_1);
        assertTrue(Arrays.equals(new byte[] {11, 0 , 0}, child.asBytes()));

        devCapItem = "cdma1x,1";
        mEuiccCard.addDeviceCapability(devCapsBuilder, devCapItem);
        node = devCapsBuilder.build();

        assertTrue(node.hasChild(Tags.TAG_CTX_2));
        child = node.getChild(Tags.TAG_CTX_2);
        assertTrue(Arrays.equals(new byte[] {1, 0 , 0}, child.asBytes()));

        devCapItem = "hrpd,1";
        mEuiccCard.addDeviceCapability(devCapsBuilder, devCapItem);
        node = devCapsBuilder.build();

        assertTrue(node.hasChild(Tags.TAG_CTX_3));
        child = node.getChild(Tags.TAG_CTX_3);
        assertTrue(Arrays.equals(new byte[] {1, 0 , 0}, child.asBytes()));

        devCapItem = "ehrpd,12";
        mEuiccCard.addDeviceCapability(devCapsBuilder, devCapItem);
        node = devCapsBuilder.build();

        assertTrue(node.hasChild(Tags.TAG_CTX_4));
        child = node.getChild(Tags.TAG_CTX_4);
        assertTrue(Arrays.equals(new byte[] {12, 0 , 0}, child.asBytes()));

        devCapItem = "eutran,11";
        mEuiccCard.addDeviceCapability(devCapsBuilder, devCapItem);
        node = devCapsBuilder.build();

        assertTrue(node.hasChild(Tags.TAG_CTX_5));
        child = node.getChild(Tags.TAG_CTX_5);
        assertTrue(Arrays.equals(new byte[] {11, 0 , 0}, child.asBytes()));

        devCapItem = "nfc,0";
        mEuiccCard.addDeviceCapability(devCapsBuilder, devCapItem);
        node = devCapsBuilder.build();

        assertTrue(node.hasChild(Tags.TAG_CTX_6));
        child = node.getChild(Tags.TAG_CTX_6);
        assertTrue(Arrays.equals(new byte[] {0, 0 , 0}, child.asBytes()));

        devCapItem = "crl,0";
        mEuiccCard.addDeviceCapability(devCapsBuilder, devCapItem);
        node = devCapsBuilder.build();

        assertTrue(node.hasChild(Tags.TAG_CTX_7));
        child = node.getChild(Tags.TAG_CTX_7);
        assertTrue(Arrays.equals(new byte[] {0, 0 , 0}, child.asBytes()));

        // Array length should not be 3.
        Asn1Node.Builder devCapsBuilder2 = Asn1Node.newBuilder(Tags.TAG_CTX_COMP_1);
        devCapItem = "gsm,1,1";
        mEuiccCard.addDeviceCapability(devCapsBuilder2, devCapItem);
        node = devCapsBuilder2.build();

        assertFalse(node.hasChild(Tags.TAG_CTX_0));
    }

    private void verifyStoreData(int channel, String command) {
        verify(mMockCi, times(1))
                .iccTransmitApduLogicalChannel(eq(channel), eq(0x80 | channel), eq(0xE2), eq(0x91),
                        eq(0), eq(command.length() / 2), eq(command), any());
    }

    private int mockLogicalChannelResponses(Object... responses) {
        int channel = LogicalChannelMocker.mockOpenLogicalChannelResponse(mMockCi,
                "E00582030200009000");
        LogicalChannelMocker.mockSendToLogicalChannel(mMockCi, channel, responses);
        LogicalChannelMocker.mockCloseLogicalChannel(mMockCi, channel);
        return channel;
    }
}