/*
 * 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.
 */

/* Contributed by Orange */

package android.omapi.cts;

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.*;
import static org.junit.Assume.assumeTrue;

import android.content.pm.PackageManager;
import android.os.Build;
import android.os.SystemProperties;
import android.se.omapi.Channel;
import android.se.omapi.Reader;
import android.se.omapi.SEService;
import android.se.omapi.SEService.OnConnectedListener;
import android.se.omapi.Session;

import androidx.test.InstrumentationRegistry;

import com.android.compatibility.common.util.ApiTest;
import com.android.compatibility.common.util.PropertyUtil;

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

import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeoutException;

public class OmapiTest {

    private final static String UICC_READER_PREFIX = "SIM";
    private final static String ESE_READER_PREFIX = "eSE";
    private final static String SD_READER_PREFIX = "SD";
    private final static String OMAPI_VERSION = "3.3";
    private final static byte[] SELECTABLE_AID =
            new byte[]{(byte) 0xA0, 0x00, 0x00, 0x04, 0x76, 0x41, 0x6E, 0x64,
                    0x72, 0x6F, 0x69, 0x64, 0x43, 0x54, 0x53, 0x31};
    private final static byte[] LONG_SELECT_RESPONSE_AID =
            new byte[]{(byte) 0xA0, 0x00, 0x00, 0x04, 0x76, 0x41, 0x6E, 0x64,
                    0x72, 0x6F, 0x69, 0x64, 0x43, 0x54, 0x53, 0x32};
    private final static byte[] NON_SELECTABLE_AID =
            new byte[]{(byte) 0xA0, 0x00, 0x00, 0x04, 0x76, 0x41, 0x6E, 0x64,
                    0x72, 0x6F, 0x69, 0x64, 0x43, 0x54, 0x53, (byte) 0xFF};

    /* MANAGE open/close and SELECT AID */
    private final static byte[][] ILLEGAL_COMMANDS_TRANSMIT = new byte[][]{{0x00, 0x70, 0x00, 0x00},
            {0x00, 0x70, (byte) 0x80, 0x00},
            {0x00, (byte) 0xA4, 0x04, 0x04, 0x10, 0x4A, 0x53,
                    0x52, 0x31, 0x37, 0x37, 0x54, 0x65, 0x73,
                    0x74, 0x65, 0x72, 0x20, 0x31, 0x2E, 0x30}
    };

    /* OMAPI APDU Test case 1 and 3 */
    private final static byte[][] NO_DATA_APDU = new byte[][]{{0x00, 0x06, 0x00, 0x00},
            {(byte) 0x80, 0x06, 0x00, 0x00},
            {(byte) 0xA0, 0x06, 0x00, 0x00},
            {(byte) 0x94, 0x06, 0x00, 0x00},
            {0x00, 0x0A, 0x00, 0x00, 0x01, (byte) 0xAA},
            {(byte) 0x80, 0x0A, 0x00, 0x00, 0x01, (byte) 0xAA},
            {(byte) 0xA0, 0x0A, 0x00, 0x00, 0x01, (byte) 0xAA},
            {(byte) 0x94, 0x0A, 0x00, 0x00, 0x01, (byte) 0xAA}
    };
    /* OMAPI APDU Test case 2 and 4 */
    private final static byte[][] DATA_APDU = new byte[][]{{0x00, 0x08, 0x00, 0x00, 0x00},
            {(byte) 0x80, 0x08, 0x00, 0x00, 0x00},
            {(byte) 0xA0, 0x08, 0x00, 0x00, 0x00},
            {(byte) 0x94, 0x08, 0x00, 0x00, 0x00},
            {0x00, (byte) 0x0C, 0x00, 0x00, 0x01, (byte) 0xAA, 0x00},
            {(byte) 0x80, (byte) 0x0C, 0x00, 0x00, 0x01, (byte) 0xAA, 0x00},
            {(byte) 0xA0, (byte) 0x0C, 0x00, 0x00, 0x01, (byte) 0xAA, 0x00},
            {(byte) 0x94, (byte) 0x0C, 0x00, 0x00, 0x01, (byte) 0xAA, 0x00}
    };

    /* Case 2 APDU command expects the P2 received in the SELECT command as 1-byte outgoing data */
    private static final byte[] CHECK_SELECT_P2_APDU = new byte[] {
            0x00, (byte) 0xF4, 0x00, 0x00, 0x00
    };

    /* OMAPI APDU Test case 1 and 3 */
    private final static byte[][] SW_62xx_NO_DATA_APDU =
            new byte[][]{{0x00, (byte) 0xF3, 0x00, 0x06},
                    {0x00, (byte) 0xF3, 0x00, 0x0A, 0x01, (byte) 0xAA}
            };
    /* OMAPI APDU Test case 2 and 4 */
    private final static byte[] SW_62xx_DATA_APDU = new byte[]{0x00, (byte) 0xF3, 0x00, 0x08, 0x00};
    private final static byte[] SW_62xx_VALIDATE_DATA_APDU =
            new byte[]{0x00, (byte) 0xF3, 0x00, 0x0C, 0x01, (byte) 0xAA, 0x00};
    private final static byte[][] SW_62xx =
            new byte[][]{{0x62, 0x00}, {0x62, (byte) 0x81}, {0x62, (byte) 0x82},
                    {0x62, (byte) 0x83},
                    {0x62, (byte) 0x85}, {0x62, (byte) 0xF1}, {0x62, (byte) 0xF2},
                    {0x63, (byte) 0xF1},
                    {0x63, (byte) 0xF2}, {0x63, (byte) 0xC2}, {0x62, 0x02}, {0x62, (byte) 0x80},
                    {0x62, (byte) 0x84}, {0x62, (byte) 0x86}, {0x63, 0x00}, {0x63, (byte) 0x81}
            };
    private final static byte[][] SEGMENTED_RESP_APDU = new byte[][]{
            //Get response Case2 61FF+61XX with answer length (P1P2) of 0x0800, 2048 bytes
            {0x00, (byte) 0xC2, 0x08, 0x00, 0x00},
            //Get response Case4 61FF+61XX with answer length (P1P2) of 0x0800, 2048 bytes
            {0x00, (byte) 0xC4, 0x08, 0x00, 0x02, 0x12, 0x34, 0x00},
            //Get response Case2 6100+61XX with answer length (P1P2) of 0x0800, 2048 bytes
            {0x00, (byte) 0xC6, 0x08, 0x00, 0x00},
            //Get response Case4 6100+61XX with answer length (P1P2) of 0x0800, 2048 bytes
            {0x00, (byte) 0xC8, 0x08, 0x00, 0x02, 0x12, 0x34, 0x00},
            //Test device buffer capacity 7FFF data
            {0x00, (byte) 0xC2, (byte) 0x7F, (byte) 0xFF, 0x00},
            //Get response 6CFF+61XX with answer length (P1P2) of 0x0800, 2048 bytes
            {0x00, (byte) 0xCF, 0x08, 0x00, 0x00},
            //Get response with another CLA  with answer length (P1P2) of 0x0800, 2048 bytes
            {(byte) 0x94, (byte) 0xC2, 0x08, 0x00, 0x00}
    };
    private final long SERVICE_CONNECTION_TIME_OUT = 3000;
    private SEService seService;
    private Object serviceMutex = new Object();
    private Timer connectionTimer;
    private ServiceConnectionTimerTask mTimerTask = new ServiceConnectionTimerTask();
    private boolean connected = false;
    private final OnConnectedListener mListener = new OnConnectedListener() {
                @Override
                public void onConnected() {
                    synchronized (serviceMutex) {
                        connected = true;
                        serviceMutex.notify();
                    }
                }
            };

    class SynchronousExecutor implements Executor {
        public void execute(Runnable r) {
            r.run();
        }
    }

    private boolean supportsHardware() {
        final PackageManager pm = InstrumentationRegistry.getContext().getPackageManager();
        boolean lowRamDevice = SystemProperties.getBoolean("ro.config.low_ram", false);
        return !lowRamDevice || pm.hasSystemFeature("android.hardware.type.watch")
                || hasSecureElementPackage(pm);
    }

    private boolean hasSecureElementPackage(PackageManager pm) {
        try {
            pm.getPackageInfo("com.android.se", 0 /* flags*/);
            return true;
        } catch (PackageManager.NameNotFoundException e) {
            return false;
        }
    }

    private boolean supportUICCReaders() {
        final PackageManager pm = InstrumentationRegistry.getContext().getPackageManager();
        return pm.hasSystemFeature(PackageManager.FEATURE_SE_OMAPI_UICC);
    }

    private boolean supportESEReaders() {
        final PackageManager pm = InstrumentationRegistry.getContext().getPackageManager();
        return pm.hasSystemFeature(PackageManager.FEATURE_SE_OMAPI_ESE);
    }

    private boolean supportSDReaders() {
        final PackageManager pm = InstrumentationRegistry.getContext().getPackageManager();
        return pm.hasSystemFeature(PackageManager.FEATURE_SE_OMAPI_SD);
    }

    private boolean supportOMAPIReaders() {
        final PackageManager pm = InstrumentationRegistry.getContext().getPackageManager();
        return (pm.hasSystemFeature(PackageManager.FEATURE_SE_OMAPI_UICC)
            || pm.hasSystemFeature(PackageManager.FEATURE_SE_OMAPI_ESE)
            || pm.hasSystemFeature(PackageManager.FEATURE_SE_OMAPI_SD));
    }


    private void assertGreaterOrEqual(long greater, long lesser) {
        assertTrue("" + greater + " expected to be greater than or equal to " + lesser,
                greater >= lesser);
    }

    @Before
    public void setUp() throws Exception {
        assumeTrue(PropertyUtil.getFirstApiLevel() > Build.VERSION_CODES.O_MR1);
        assumeTrue(supportsHardware());
        seService = new SEService(InstrumentationRegistry.getContext(), new SynchronousExecutor(), mListener);
        connectionTimer = new Timer();
        connectionTimer.schedule(mTimerTask, SERVICE_CONNECTION_TIME_OUT);
    }

    @After
    public void tearDown() throws Exception {
        if (seService != null && seService.isConnected()) {
            seService.shutdown();
            connected = false;
        }
    }

    private void waitForConnection() throws TimeoutException {
        synchronized (serviceMutex) {
            if (!connected) {
                try {
                    serviceMutex.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if (!connected) {
                throw new TimeoutException(
                        "Service could not be connected after " + SERVICE_CONNECTION_TIME_OUT
                                + " ms");
            }
            if (connectionTimer != null) {
                connectionTimer.cancel();
            }
        }
    }

    /** Tests getReaders API */
    @Test
    public void testGetReaders() {
        try {
            waitForConnection();
            Reader[] readers = seService.getReaders();
            ArrayList<Reader> uiccReaders = new ArrayList<Reader>();
            ArrayList<Reader> eseReaders = new ArrayList<Reader>();
            ArrayList<Reader> sdReaders = new ArrayList<Reader>();

            for (Reader reader : readers) {
                assertTrue(reader.isSecureElementPresent());
                String name = reader.getName();
                if (!(name.startsWith(UICC_READER_PREFIX) || name.startsWith(ESE_READER_PREFIX)
                        || name.startsWith(SD_READER_PREFIX))) {
                    fail("Incorrect Reader name");
                }
                assertNotNull("getseService returned null", reader.getSEService());

                if (reader.getName().startsWith(UICC_READER_PREFIX)) {
                    uiccReaders.add(reader);
                }
                if (reader.getName().startsWith(ESE_READER_PREFIX)) {
                    eseReaders.add(reader);
                }
                if (reader.getName().startsWith(SD_READER_PREFIX)) {
                    sdReaders.add(reader);
                }
            }

            if (supportUICCReaders()) {
                assertGreaterOrEqual(uiccReaders.size(), 1);
                // Test API getUiccReader(int slotNumber)
                // The result should be the same as getReaders() with UICC reader prefix
                for (int i = 1; i <= uiccReaders.size(); i++) {
                    try {
                        Reader uiccReader = seService.getUiccReader(i);
                        if (!uiccReaders.contains(uiccReader))
                            fail("Incorrect reader object - getUiccReader(" + i + ")");
                    } catch (IllegalArgumentException e) {
                        fail("Fail to get Reader object by calling getUiccReader(" + i + ")");
                    }
                }
            } else {
                assertTrue(uiccReaders.size() == 0);
            }

            if (supportESEReaders()) {
                assertGreaterOrEqual(eseReaders.size(), 1);
            } else {
                assertTrue(eseReaders.size() == 0);
            }

            if (supportSDReaders()) {
                assertGreaterOrEqual(sdReaders.size(), 1);
            } else {
                assertTrue(sdReaders.size() == 0);
            }
        } catch (Exception e) {
            fail("Unexpected Exception " + e);
        }
    }

    /** Tests getATR API */
    @Test
    public void testATR() {
        assumeTrue(supportOMAPIReaders());
        try {
            waitForConnection();
            Reader[] readers = seService.getReaders();
            ArrayList<Reader> uiccReaders = new ArrayList<Reader>();
            if (readers != null && readers.length > 0) {
                for (int i = 0; i < readers.length; i++) {
                    if (readers[i].getName().startsWith(UICC_READER_PREFIX)) {
                        uiccReaders.add(readers[i]);
                    }
                }

                for (Reader reader : uiccReaders) {
                    Session session = null;
                    try {
                        session = reader.openSession();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    assertNotNull("Could not open session", session);
                    byte[] atr = session.getATR();
                    session.close();
                    assertNotNull("ATR is Null", atr);
                }
            }
        } catch (Exception e) {
            fail("Unexpected Exception " + e);
        }
    }

    /** Tests OpenBasicChannel API when aid is null */
    @Test
    public void testOpenBasicChannelNullAid() {
        assumeTrue(supportOMAPIReaders());
        try {
            waitForConnection();
            Reader[] readers = seService.getReaders();

            for (Reader reader : readers) {
                Session session = null;
                Channel channel = null;
                try {
                    session = reader.openSession();
                    assertNotNull("Could not open session", session);
                    channel = session.openBasicChannel(null, (byte) 0x00);
                } finally {
                    if (channel != null) channel.close();
                    if (session != null) session.close();
                }
                if (reader.getName().startsWith(UICC_READER_PREFIX)) {
                    assertNull("Basic channel on UICC can be opened", channel);
                } else {
                    assertNotNull("Basic Channel cannot be opened", channel);
                }
            }
        } catch (Exception e) {
            fail("Unexpected Exception " + e);
        }
    }

    /** Tests OpenBasicChannel API when aid is provided */
    @Test
    public void testOpenBasicChannelNonNullAid() {
        assumeTrue(supportOMAPIReaders());
        try {
            waitForConnection();
            Reader[] readers = seService.getReaders();

            for (Reader reader : readers) {
                Session session = null;
                Channel channel = null;
                try {
                    session = reader.openSession();
                    assertNotNull("Could not open session", session);
                    channel = session.openBasicChannel(SELECTABLE_AID, (byte) 0x00);
                } finally {
                    if (channel != null) channel.close();
                    if (session != null) session.close();
                }
                if (reader.getName().startsWith(UICC_READER_PREFIX)) {
                    assertNull("Basic channel on UICC can be opened", channel);
                } else {
                    assertNotNull("Basic Channel cannot be opened", channel);
                }
            }
        } catch (Exception e) {
            fail("Unexpected Exception " + e);
        }
    }

    /** Tests Select API */
    @Test
    public void testSelectableAid() {
        assumeTrue(supportOMAPIReaders());
        try {
            waitForConnection();
            Reader[] readers = seService.getReaders();
            for (Reader reader : readers) {
                testSelectableAid(reader, SELECTABLE_AID);
            }
        } catch (Exception e) {
            fail("unexpected exception " + e);
        }
    }

    @Test
    public void testLongSelectResponse() {
        assumeTrue(supportOMAPIReaders());
        try {
            waitForConnection();
            Reader[] readers = seService.getReaders();
            for (Reader reader : readers) {
                byte[] selectResponse = testSelectableAid(reader, LONG_SELECT_RESPONSE_AID);
                assertTrue("Select Response is not complete", verifyBerTlvData(selectResponse));
            }
        } catch (Exception e) {
            fail("unexpected exception " + e);
        }
    }

    private byte[] testSelectableAid(Reader reader, byte[] aid) throws IOException {
        byte[] selectResponse = null;
        Session session = null;
        Channel channel = null;
        try {
            assertTrue(reader.isSecureElementPresent());
            session = reader.openSession();
            assertNotNull("Null Session", session);
            channel = session.openLogicalChannel(aid, (byte) 0x00);
            assertNotNull("Null Channel", channel);
            selectResponse = channel.getSelectResponse();
        } finally {
            if (channel != null) channel.close();
            if (session != null) session.close();
        }
        assertNotNull("Null Select Response", selectResponse);
        assertGreaterOrEqual(selectResponse.length, 2);
        assertThat(selectResponse[selectResponse.length - 1] & 0xFF, is(0x00));
        assertThat(selectResponse[selectResponse.length - 2] & 0xFF, is(0x90));
        return selectResponse;
    }

    /** Tests if NoSuchElementException in Select */
    @Test
    public void testWrongAid() {
        assumeTrue(supportOMAPIReaders());
        try {
            waitForConnection();
            Reader[] readers = seService.getReaders();
            for (Reader reader : readers) {
                testNonSelectableAid(reader, NON_SELECTABLE_AID);
            }
        } catch (Exception e) {
            fail("unexpected exception " + e);
        }
    }

    private void testNonSelectableAid(Reader reader, byte[] aid) throws IOException {
        Session session = null;
        Channel channel = null;
        try {
            assertTrue(reader.isSecureElementPresent());
            session = reader.openSession();
            assertNotNull("null session", session);
            channel = session.openLogicalChannel(aid, (byte) 0x00);
            fail("Exception expected for this test");
        } catch (NoSuchElementException e) {
            // Catch the expected exception here.
        } finally {
            if (channel != null) channel.close();
            if (session != null) session.close();
        }
    }

    /** Tests if Security Exception in Transmit */
    @Test
    public void testSecurityExceptionInTransmit() {
        assumeTrue(supportOMAPIReaders());
        try {
            waitForConnection();
            Reader[] readers = seService.getReaders();

            for (Reader reader : readers) {
                Session session = null;
                Channel channel = null;
                try {
                    assertTrue(reader.isSecureElementPresent());
                    session = reader.openSession();
                    assertNotNull("null session", session);
                    channel = session.openLogicalChannel(SELECTABLE_AID, (byte) 0x00);
                    assertNotNull("Null Channel", channel);
                    byte[] selectResponse = channel.getSelectResponse();
                    assertNotNull("Null Select Response", selectResponse);
                    assertGreaterOrEqual(selectResponse.length, 2);
                    assertThat(selectResponse[selectResponse.length - 1] & 0xFF, is(0x00));
                    assertThat(selectResponse[selectResponse.length - 2] & 0xFF, is(0x90));
                    for (byte[] cmd : ILLEGAL_COMMANDS_TRANSMIT) {
                        try {
                            byte[] response = channel.transmit(cmd);
                            fail("Exception expected for this test");
                        } catch (SecurityException e) {
                            // Catch the expected exception here.
                        }
                    }
                } finally {
                    if (channel != null) channel.close();
                    if (session != null) session.close();
                }
            }
        } catch (Exception e) {
            fail("unexpected exception " + e);
        }
    }

    private byte[] internalTransmitApdu(Reader reader, byte[] apdu) throws IOException {
        byte[] transmitResponse = null;
        Session session = null;
        Channel channel = null;
        try {
            assertTrue(reader.isSecureElementPresent());
            session = reader.openSession();
            assertNotNull("null session", session);
            channel = session.openLogicalChannel(SELECTABLE_AID, (byte) 0x00);
            assertNotNull("Null Channel", channel);
            byte[] selectResponse = channel.getSelectResponse();
            assertNotNull("Null Select Response", selectResponse);
            assertGreaterOrEqual(selectResponse.length, 2);
            transmitResponse = channel.transmit(apdu);
        } finally {
            if (channel != null) channel.close();
            if (session != null) session.close();
        }
        return transmitResponse;
    }

    private byte[] internalTransmitApduWithoutP2(Reader reader, byte[] apdu,
            boolean testLogicalChannel) throws IOException {
        byte[] transmitResponse = null;
        Session session = null;
        Channel channel = null;
        try {
            assertTrue(reader.isSecureElementPresent());
            session = reader.openSession();
            assertNotNull("null session", session);
            if (testLogicalChannel) {
                channel = session.openLogicalChannel(SELECTABLE_AID);
            } else {
                channel = session.openBasicChannel(SELECTABLE_AID);
            }
            assertNotNull("Null Channel", channel);
            byte[] selectResponse = channel.getSelectResponse();
            assertNotNull("Null Select Response", selectResponse);
            assertGreaterOrEqual(selectResponse.length, 2);
            transmitResponse = channel.transmit(apdu);
        } finally {
            if (channel != null) channel.close();
            if (session != null) session.close();
        }
        return transmitResponse;
    }

    /**
     * Tests Transmit API for all readers.
     *
     * Checks the return status and verifies the size of the
     * response.
     */
    @Test
    public void testTransmitApdu() {
        assumeTrue(supportOMAPIReaders());
        try {
            waitForConnection();
            Reader[] readers = seService.getReaders();

            for (Reader reader : readers) {
                for (byte[] apdu : NO_DATA_APDU) {
                    byte[] response = internalTransmitApdu(reader, apdu);
                    assertThat(response.length, is(2));
                    assertThat(response[response.length - 1] & 0xFF, is(0x00));
                    assertThat(response[response.length - 2] & 0xFF, is(0x90));
                }

                for (byte[] apdu : DATA_APDU) {
                    byte[] response = internalTransmitApdu(reader, apdu);
                    /* 256 byte data and 2 bytes of status word */
                    assertThat(response.length, is(258));
                    assertThat(response[response.length - 1] & 0xFF, is(0x00));
                    assertThat(response[response.length - 2] & 0xFF, is(0x90));
                }
            }
        } catch (Exception e) {
            fail("unexpected exception " + e);
        }
    }

    /**
     * Tests if underlying implementations returns the correct Status Word
     *
     * TO verify that :
     * - the device does not modify the APDU sent to the Secure Element
     * - the warning code is properly received by the application layer as SW answer
     * - the verify that the application layer can fetch the additionnal data (when present)
     */
    @Test
    public void testStatusWordTransmit() {
        assumeTrue(supportOMAPIReaders());
        try {
            waitForConnection();
            Reader[] readers = seService.getReaders();

            for (Reader reader : readers) {
                for (byte[] apdu : SW_62xx_NO_DATA_APDU) {
                    for (byte i = 0x00; i < SW_62xx.length; i++) {
                        apdu[2] = (byte)(i+1);
                        byte[] response = internalTransmitApdu(reader, apdu);
                        byte[] SW = SW_62xx[i];
                        assertThat(response[response.length - 1], is(SW[1]));
                        assertThat(response[response.length - 2], is(SW[0]));
                    }
                }

                for (byte i = 0x00; i < SW_62xx.length; i++) {
                    byte[] apdu = SW_62xx_DATA_APDU;
                    apdu[2] = (byte)(i+1);
                    byte[] response = internalTransmitApdu(reader, apdu);
                    byte[] SW = SW_62xx[i];
                    assertGreaterOrEqual(response.length, 3);
                    assertThat(response[response.length - 1], is(SW[1]));
                    assertThat(response[response.length - 2], is(SW[0]));
                }

                for (byte i = 0x00; i < SW_62xx.length; i++) {
                    byte[] apdu = SW_62xx_VALIDATE_DATA_APDU;
                    apdu[2] = (byte)(i+1);
                    byte[] response = internalTransmitApdu(reader, apdu);
                    assertGreaterOrEqual(response.length, apdu.length + 2);
                    byte[] responseSubstring = Arrays.copyOfRange(response, 0, apdu.length);
                    // We should not care about which channel number is actually assigned.
                    responseSubstring[0] = apdu[0];
                    assertTrue(Arrays.equals(responseSubstring, apdu));
                    byte[] SW = SW_62xx[i];
                    assertThat(response[response.length - 1], is(SW[1]));
                    assertThat(response[response.length - 2], is(SW[0]));
                }
            }
        } catch (Exception e) {
            fail("unexpected exception " + e);
        }
    }

    /** Test if the responses are segmented by the underlying implementation */
    @Test
    public void testSegmentedResponseTransmit() {
        assumeTrue(supportOMAPIReaders());
        try {
            waitForConnection();
            Reader[] readers = seService.getReaders();

            for (Reader reader : readers) {
                for (byte[] apdu : SEGMENTED_RESP_APDU) {
                    byte[] response = internalTransmitApdu(reader, apdu);
                    byte[] b = { 0x00, 0x00, apdu[2], apdu[3] };
                    ByteBuffer wrapped = ByteBuffer.wrap(b);
                    int expectedLength = wrapped.getInt();
                    assertThat(response.length, is(expectedLength + 2));
                    assertThat(response[response.length - 1] & 0xFF, is(0x00));
                    assertThat(response[response.length - 2] & 0xFF, is(0x90));
                    assertThat(response[response.length - 3] & 0xFF, is(0xFF));
                }
            }
        } catch (Exception e) {
            fail("unexpected exception " + e);
        }
    }

    /**
     * Tests the P2 value of the select command.
     *
     * Verifies that the default P2 value (0x00) is not modified by the underlying implementation.
     */
    @Test
    @ApiTest(apis = {"android.se.omapi.Session#openBasicChannel",
            "android.se.omapi.Session#openLogicalChannel"})
    public void testP2Value() {
        assumeTrue(supportOMAPIReaders());
        try {
            waitForConnection();
            Reader[] readers = seService.getReaders();

            for (Reader reader : readers) {
                byte[] response = internalTransmitApduWithoutP2(reader, CHECK_SELECT_P2_APDU, true);
                assertGreaterOrEqual(response.length, 3);
                assertThat(response[response.length - 1] & 0xFF, is(0x00));
                assertThat(response[response.length - 2] & 0xFF, is(0x90));
                assertThat(response[response.length - 3] & 0xFF, is(0x00));

                // skip basic channel verification for UICC reader
                if (reader.getName().startsWith(UICC_READER_PREFIX)) {
                    continue;
                }
                response = internalTransmitApduWithoutP2(reader, CHECK_SELECT_P2_APDU, false);
                assertGreaterOrEqual(response.length, 3);
                assertThat(response[response.length - 1] & 0xFF, is(0x00));
                assertThat(response[response.length - 2] & 0xFF, is(0x90));
            }
        } catch (Exception e) {
          fail("unexpected exception " + e);
        }
    }

    /** Tests closeChannels API */
    @Test
    public void testCloseChannels() {
        assumeTrue(supportOMAPIReaders());
        try {
            waitForConnection();
            Reader[] readers = seService.getReaders();

            for (Reader reader : readers) {
                Session session = null;
                Channel channelA = null;
                Channel channelB = null;
                try {
                    assertTrue(reader.isSecureElementPresent());
                    session = reader.openSession();
                    assertNotNull("null session", session);
                    channelA = session.openLogicalChannel(SELECTABLE_AID, (byte) 0x00);
                    assertNotNull("Null Channel", channelA);
                    channelB = session.openLogicalChannel(LONG_SELECT_RESPONSE_AID, (byte) 0x00);
                    assertNotNull("Null Channel", channelB);
                    session.closeChannels();
                    assertFalse("channel is still open", channelA.isOpen());
                    assertFalse("channel is still open", channelB.isOpen());
                } finally {
                    if (session != null) session.close();
                }
            }
        } catch (Exception e) {
            fail("unexpected exception " + e);
        }
    }

    /** Tests SEService getVersion API */
    @Test
    @ApiTest(apis = "android.se.omapi.SEService#getVersion")
    public void testGetOmapiVersion() {
        try {
            waitForConnection();
            assertTrue("Unexpected OMAPI version", seService.getVersion().equals(OMAPI_VERSION));
        } catch (Exception e) {
            fail("unexpected exception " + e);
        }
    }

    /** Tests Reader closeSession API */
    @Test
    @ApiTest(apis = {"android.se.omapi.Reader#closeSessions", "android.se.omapi.Session#isClosed"})
    public void testCloseSessions() {
        assumeTrue(supportOMAPIReaders());
        try {
            waitForConnection();
            Reader[] readers = seService.getReaders();

            for (Reader reader : readers) {
                Session sessionA = null;
                Session sessionB = null;
                try {
                    assertTrue(reader.isSecureElementPresent());
                    sessionA = reader.openSession();
                    assertNotNull("null session", sessionA);
                    assertFalse("session is closed", sessionA.isClosed());

                    sessionB = reader.openSession();
                    assertNotNull("null session", sessionB);
                    assertFalse("session is closed", sessionB.isClosed());

                    sessionA.getReader().closeSessions();
                    assertTrue("session is still open", sessionA.isClosed());
                    assertTrue("session is still open", sessionB.isClosed());
                } finally {
                    if (sessionA != null) sessionA.close();
                    if (sessionB != null) sessionB.close();
                }
            }
        } catch (Exception e) {
            fail("unexpected exception " + e);
        }
    }

    /** Tests Reader reset API */
    @Test
    @ApiTest(apis = "android.se.omapi.Reader#reset")
    public void testOmapiReaderReset() {
        assumeTrue(supportOMAPIReaders());
        try {
            waitForConnection();
            Reader[] readers = seService.getReaders();

            for (Reader reader : readers) {
                try {
                    reader.reset();
                    fail("reset function is not blocked by permission ");
                } catch (SecurityException e) {
                    // Catch the expected exception here
                }
            }
        } catch (Exception e) {
            fail("unexpected exception " + e);
        }
    }

    /** Tests Channel getSession API */
    @Test
    @ApiTest(apis = {"android.se.omapi.Channel#getSession", "android.se.omapi.Session#isClosed",
            "android.se.omapi.Channel#isBasicChannel"})
    public void testGetSession() {
        assumeTrue(supportOMAPIReaders());
        try {
            waitForConnection();
            Reader[] readers = seService.getReaders();

            for (Reader reader : readers) {
                Session session = null;
                Channel channel = null;
                try {
                    session = reader.openSession();
                    assertNotNull("Could not open session", session);
                    channel = session.openLogicalChannel(SELECTABLE_AID, (byte) 0x00);
                    assertFalse("channel is not LogicalChannel", channel.isBasicChannel());

                    channel.getSession().close();
                    assertTrue(session.isClosed());
                } finally {
                    if (channel != null) channel.close();
                    if (session != null) session.close();
                }
            }
        } catch (Exception e) {
            fail("unexpected exception " + e);
        }
    }

    /** Tests Channel selectNext API */
    @Test
    @ApiTest(apis = "android.se.omapi.Channel#selectNext")
    public void testSelectNext() {
        assumeTrue(supportOMAPIReaders());
        try {
            waitForConnection();
            Reader[] readers = seService.getReaders();

            for (Reader reader : readers) {
                Session session = null;
                Channel channel = null;
                try {
                    session = reader.openSession();
                    assertNotNull("Could not open session", session);
                    channel = session.openLogicalChannel(SELECTABLE_AID, (byte) 0x00);
                    // no further Applet exists with this AID
                    assertFalse(channel.selectNext());

                    // send APDU to check selected applet stays selected on this channel
                    for (byte[] apdu : NO_DATA_APDU) {
                        byte[] response = channel.transmit(apdu);
                        assertThat(response.length, is(2));
                        assertThat(response[response.length - 1] & 0xFF, is(0x00));
                        assertThat(response[response.length - 2] & 0xFF, is(0x90));
                    }
                } finally {
                    if (channel != null) channel.close();
                    if (session != null) session.close();
                }
            }
        } catch (Exception e) {
            fail("unexpected exception " + e);
        }
    }

    /**
     * Verifies TLV data
     * @param tlv
     * @return true if the data is tlv formatted, false otherwise
     */
    private static boolean verifyBerTlvData(byte[] tlv){
        if (tlv == null || tlv.length == 0) {
            throw new RuntimeException("Invalid tlv, null");
        }
        int i = 0;
        if ((tlv[i++] & 0x1F) == 0x1F) {
            // extra byte for TAG field
            i++;
        }

        int len = tlv[i++] & 0xFF;
        if (len > 127) {
            // more than 1 byte for length
            int bytesLength = len-128;
            len = 0;
            for(int j = bytesLength; j > 0; j--) {
                len += (len << 8) + (tlv[i++] & 0xFF);
            }
        }
        // Additional 2 bytes for the SW
        return (tlv.length == (i+len+2));
    }

    class ServiceConnectionTimerTask extends TimerTask {
        @Override
        public void run() {
            synchronized (serviceMutex) {
                serviceMutex.notifyAll();
            }
        }
    }
}