android/phone/SimPhonebookProviderTest.java

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

import static android.provider.SimPhonebookContract.ElementaryFiles.EF_ADN;
import static android.provider.SimPhonebookContract.ElementaryFiles.EF_FDN;
import static android.provider.SimPhonebookContract.ElementaryFiles.EF_SDN;

import static com.android.internal.telephony.testing.CursorSubject.assertThat;
import static com.android.internal.telephony.testing.TelephonyAssertions.assertThrows;

import static com.google.common.truth.Truth.assertThat;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import android.content.ContentResolver;
import android.content.ContentValues;
import android.database.Cursor;
import android.net.Uri;
import android.provider.SimPhonebookContract;
import android.provider.SimPhonebookContract.ElementaryFiles;
import android.provider.SimPhonebookContract.SimRecords;
import android.telephony.SubscriptionInfo;
import android.telephony.SubscriptionManager;
import android.util.Pair;

import androidx.test.core.app.ApplicationProvider;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.platform.app.InstrumentationRegistry;
import androidx.test.rule.provider.ProviderTestRule;

import com.android.internal.telephony.IIccPhoneBook;
import com.android.internal.telephony.uicc.AdnCapacity;
import com.android.internal.telephony.uicc.AdnRecord;
import com.android.internal.telephony.uicc.IccConstants;

import com.google.common.collect.ImmutableList;
import com.google.common.io.Closeables;
import com.google.common.truth.Correspondence;

import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.AdditionalAnswers;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Predicate;
import java.util.stream.Collectors;

@RunWith(AndroidJUnit4.class)
public final class SimPhonebookProviderTest {

    private static final String EMOJI = new String(Character.toChars(0x1F642));
    private static final Correspondence<AdnRecord, AdnRecord> ADN_RECORD_IS_EQUAL =
            Correspondence.from(AdnRecord::isEqual, "isEqual");

    @Rule
    public final ProviderTestRule mProviderRule = new ProviderTestRule.Builder(
            TestableSimPhonebookProvider.class, SimPhonebookContract.AUTHORITY).build();

    private ContentResolver mResolver;
    private FakeIccPhoneBook mIccPhoneBook;
    private SubscriptionManager mMockSubscriptionManager;

    private static List<SubscriptionInfo> createSubscriptionsWithIds(int... subscriptionIds) {
        ImmutableList.Builder<SubscriptionInfo> builder = ImmutableList.builderWithExpectedSize(
                subscriptionIds.length);
        for (int i = 0; i < subscriptionIds.length; i++) {
            builder.add(createSubscriptionInfo(i, subscriptionIds[i]));
        }
        return builder.build();
    }

    private static SubscriptionInfo createSubscriptionInfo(int slotIndex, int subscriptiondId) {
        return new SubscriptionInfo(
                subscriptiondId, "", slotIndex, null, null, 0, 0, null, 0, null, null, null, null,
                false, null, null);
    }

    @Before
    public void setUp() {
        mMockSubscriptionManager = spy(
                Objects.requireNonNull(ApplicationProvider.getApplicationContext()
                        .getSystemService(SubscriptionManager.class)));
        mIccPhoneBook = new FakeIccPhoneBook();
        mResolver = mProviderRule.getResolver();

        TestableSimPhonebookProvider.setup(mResolver, mMockSubscriptionManager, mIccPhoneBook);
    }

    @Test
    public void query_entityFiles_returnsCursorWithCorrectProjection() {
        // Null projection
        try (Cursor cursor = mResolver.query(ElementaryFiles.CONTENT_URI, null, null,
                null)) {
            assertThat(Objects.requireNonNull(cursor).getColumnNames()).asList()
                    .containsExactlyElementsIn(
                            SimPhonebookProvider.ELEMENTARY_FILES_ALL_COLUMNS);
        }

        // Empty projection
        try (Cursor cursor = mResolver.query(ElementaryFiles.CONTENT_URI, new String[0], null,
                null)) {
            assertThat(cursor).hasColumnNames();
        }

        // Single column
        try (Cursor cursor = mResolver.query(ElementaryFiles.CONTENT_URI, new String[]{
                ElementaryFiles.EF_TYPE
        }, null, null)) {
            assertThat(cursor).hasColumnNames(ElementaryFiles.EF_TYPE);
        }

        // Duplicate column
        try (Cursor cursor = mResolver.query(ElementaryFiles.CONTENT_URI, new String[]{
                ElementaryFiles.SUBSCRIPTION_ID, ElementaryFiles.SUBSCRIPTION_ID
        }, null, null)) {
            assertThat(cursor).hasColumnNames(ElementaryFiles.SUBSCRIPTION_ID,
                    ElementaryFiles.SUBSCRIPTION_ID);
        }

        // Random order of all columns
        String[] projection = Arrays.copyOf(
                SimPhonebookProvider.ELEMENTARY_FILES_ALL_COLUMNS,
                SimPhonebookProvider.ELEMENTARY_FILES_ALL_COLUMNS.length);
        Collections.shuffle(Arrays.asList(projection));
        try (Cursor cursor = mResolver.query(ElementaryFiles.CONTENT_URI, projection, null, null)) {
            assertThat(cursor).hasColumnNames(projection);
        }
    }

    @Test
    public void query_entityFiles_unrecognizedColumn_throwsIllegalArgumentException() {
        assertThrows(IllegalArgumentException.class, () ->
                mResolver.query(ElementaryFiles.CONTENT_URI, new String[]{"invalid_column"}, null,
                        null));
    }

    @Test
    public void query_entityFiles_noSim_returnsEmptyCursor() {
        when(mMockSubscriptionManager.getActiveSubscriptionInfoList()).thenReturn(
                ImmutableList.of());

        try (Cursor cursor = mResolver.query(ElementaryFiles.CONTENT_URI, null, null, null)) {
            assertThat(cursor).hasCount(0);
        }
    }

    @Test
    public void query_entityFiles_multiSim_returnsCursorWithRowForEachSimEf() {
        setupSimsWithSubscriptionIds(2, 3, 7);

        mIccPhoneBook.setupEfWithSizes(2, IccConstants.EF_ADN, 10, 25);
        mIccPhoneBook.setupEfWithSizes(2, IccConstants.EF_FDN, 5, 20);
        mIccPhoneBook.setupEfWithSizes(2, IccConstants.EF_SDN, 15, 20);
        mIccPhoneBook.setupEfWithSizes(3, IccConstants.EF_ADN, 100, 30);
        // These Will be omitted from results because zero size indicates the EF is not supported.
        mIccPhoneBook.setupEfWithSizes(3, IccConstants.EF_FDN, 0, 0);
        mIccPhoneBook.setupEfWithSizes(3, IccConstants.EF_SDN, 0, 0);
        mIccPhoneBook.setupEfWithSizes(7, IccConstants.EF_ADN, 0, 0);
        mIccPhoneBook.setupEfWithSizes(7, IccConstants.EF_FDN, 0, 0);
        mIccPhoneBook.setupEfWithSizes(7, IccConstants.EF_SDN, 0, 0);

        String[] projection = {
                ElementaryFiles.SLOT_INDEX, ElementaryFiles.SUBSCRIPTION_ID,
                ElementaryFiles.EF_TYPE, ElementaryFiles.MAX_RECORDS,
                ElementaryFiles.NAME_MAX_LENGTH, ElementaryFiles.PHONE_NUMBER_MAX_LENGTH
        };
        try (Cursor cursor = mResolver.query(ElementaryFiles.CONTENT_URI, projection, null, null)) {
            assertThat(cursor).hasColumnNames(projection);

            assertThat(cursor)
                    .atRow(0).hasRowValues(0, 2, ElementaryFiles.EF_ADN, 10, 11, 20)
                    .atRow(1).hasRowValues(0, 2, ElementaryFiles.EF_FDN, 5, 6, 20)
                    .atRow(2).hasRowValues(0, 2, ElementaryFiles.EF_SDN, 15, 6, 20)
                    .atRow(3).hasRowValues(1, 3, ElementaryFiles.EF_ADN, 100, 16, 20);
        }
    }

    @Test
    public void query_entityFiles_simWithZeroSizes_returnsEmptyCursor() {
        setupSimsWithSubscriptionIds(1);

        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_ADN, 0, 0);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_FDN, 0, 0);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_SDN, 0, 0);

        try (Cursor cursor = mResolver.query(ElementaryFiles.CONTENT_URI, null, null, null)) {
            assertThat(cursor).hasCount(0);
        }
    }

    /**
     * USIM cards support more than 255 records by having multiple files for one EF type but
     * IIccPhoneBook.getAdnRecordsSizeForSubscriber returns the size for a single file and so is
     * inaccurate for such SIMs.
     *
     * <p>See b/201385523#comment4 and b/201685690
     */
    @Test
    public void query_entityFiles_adnRecordCountExceedsSize_returnsAdnRecordCountAsMaxRecords() {
        setupSimsWithSubscriptionIds(1);

        // There are 400 records returned by getAdnRecordsInEfForSubscriber but the count returned
        // by getAdnRecordsSizeForSubscriber is only 200.
        AdnRecord[] records = mIccPhoneBook.createEmptyRecords(IccConstants.EF_ADN, 400);
        mIccPhoneBook.setRecordsSize(1, IccConstants.EF_ADN, 200, 20);
        mIccPhoneBook.setRecords(1, IccConstants.EF_ADN, records);

        String[] projection = {
                ElementaryFiles.SUBSCRIPTION_ID, ElementaryFiles.EF_TYPE,
                ElementaryFiles.MAX_RECORDS
        };
        try (Cursor cursor = mResolver.query(
                ElementaryFiles.CONTENT_URI, projection, null, null)) {
            assertThat(cursor).hasCount(1);
            assertThat(cursor)
                    .atRow(0).hasRowValues(1, ElementaryFiles.EF_ADN, 400);
        }
    }

    @Test
    public void query_entityFilesItem_nullProjection_returnsCursorWithCorrectProjection() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);

        // Null projection
        try (Cursor cursor = mResolver.query(ElementaryFiles.getItemUri(1, EF_ADN), null, null,
                null)) {
            assertThat(Objects.requireNonNull(cursor).getColumnNames()).asList()
                    .containsExactlyElementsIn(
                            SimPhonebookProvider.ELEMENTARY_FILES_ALL_COLUMNS);
        }
    }

    @Test
    public void query_elementaryFilesItem_nonExistentSubscriptionId_returnsEmptyCursor() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);

        // Subscription ID 2 does not exist
        Uri nonExistentElementaryFileItemUri = ElementaryFiles.getItemUri(2, EF_ADN);

        try (Cursor cursor = mResolver.query(nonExistentElementaryFileItemUri, null, null, null)) {
            assertThat(Objects.requireNonNull(cursor)).hasCount(0);
        }
    }

    @Test
    public void query_adnRecords_returnsCursorWithMatchingProjection() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);
        Uri contentAdn = SimRecords.getContentUri(1, EF_ADN);

        // Null projection
        try (Cursor cursor = mResolver.query(contentAdn, null, null, null)) {
            assertThat(Objects.requireNonNull(cursor).getColumnNames()).asList()
                    .containsExactlyElementsIn(SimPhonebookProvider.SIM_RECORDS_ALL_COLUMNS);
        }

        // Empty projection
        try (Cursor cursor = mResolver.query(contentAdn, new String[0], null, null)) {
            assertThat(cursor).hasColumnNames();
        }

        // Single column
        try (Cursor cursor = mResolver.query(contentAdn, new String[]{
                SimRecords.PHONE_NUMBER
        }, null, null)) {
            assertThat(cursor).hasColumnNames(SimRecords.PHONE_NUMBER);
        }

        // Duplicate column
        try (Cursor cursor = mResolver.query(contentAdn, new String[]{
                SimRecords.PHONE_NUMBER, SimRecords.PHONE_NUMBER
        }, null, null)) {
            assertThat(cursor).hasColumnNames(SimRecords.PHONE_NUMBER, SimRecords.PHONE_NUMBER);
        }

        // Random order of all columns
        String[] projection = Arrays.copyOf(
                SimPhonebookProvider.SIM_RECORDS_ALL_COLUMNS,
                SimPhonebookProvider.SIM_RECORDS_ALL_COLUMNS.length);
        Collections.shuffle(Arrays.asList(projection));
        try (Cursor cursor = mResolver.query(contentAdn, projection, null, null)) {
            assertThat(cursor).hasColumnNames(projection);
        }
    }

    @Test
    public void query_adnRecords_invalidColumnProjection_throwsIllegalArgumentException() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);
        Uri contentAdn = SimRecords.getContentUri(1, EF_ADN);

        assertThrows(IllegalArgumentException.class, () -> Closeables.close(
                mResolver.query(contentAdn, new String[] {
                        "an_unsupported_column",
                }, null, null), false)
        );

        assertThrows(IllegalArgumentException.class, () -> Closeables.close(
                mResolver.query(contentAdn, new String[] {
                        SimRecords.RECORD_NUMBER,
                        "an_unsupported_column"
                }, null, null), false)
        );

        assertThrows(IllegalArgumentException.class, () -> Closeables.close(
                mResolver.query(contentAdn, new String[] {
                        "an_unsupported_column",
                        SimRecords.RECORD_NUMBER
                }, null, null), false)
        );
    }

    @Test
    public void query_adnRecords_noRecords_returnsEmptyCursor() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);

        try (Cursor cursor = mResolver.query(SimRecords.getContentUri(1, EF_ADN), null, null,
                null)) {
            assertThat(cursor).hasCount(0);
        }
    }

    @Test
    public void query_simRecords_nullRecordList_returnsEmptyCursor() throws Exception {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);
        // Use a mock so that a null list can be returned
        IIccPhoneBook mockIccPhoneBook = mock(
                IIccPhoneBook.class, AdditionalAnswers.delegatesTo(mIccPhoneBook));
        when(mockIccPhoneBook.getAdnRecordsInEfForSubscriber(anyInt(), anyInt())).thenReturn(null);
        TestableSimPhonebookProvider.setup(mResolver, mMockSubscriptionManager, mockIccPhoneBook);

        try (Cursor adnCursor = mResolver.query(SimRecords.getContentUri(1, EF_ADN), null, null,
                null);
             Cursor fdnCursor = mResolver.query(SimRecords.getContentUri(1, EF_FDN), null, null,
                     null);
             Cursor sdnCursor = mResolver.query(SimRecords.getContentUri(1, EF_SDN), null, null,
                     null)
        ) {
            assertThat(adnCursor).hasCount(0);
            assertThat(fdnCursor).hasCount(0);
            assertThat(sdnCursor).hasCount(0);
        }
    }

    @Test
    public void query_simRecords_singleSim_returnsDataForCorrectEf() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.addRecord(1, IccConstants.EF_ADN, "Person Adn1", "8005550101");
        mIccPhoneBook.addRecord(1, IccConstants.EF_ADN, "Person Adn2", "8005550102");
        mIccPhoneBook.addRecord(1, IccConstants.EF_FDN, "Person Fdn", "8005550103");
        mIccPhoneBook.addRecord(1, IccConstants.EF_SDN, "Person Sdn", "8005550104");
        mIccPhoneBook.setDefaultSubscriptionId(1);

        String[] projection = {
                SimRecords.SUBSCRIPTION_ID,
                SimRecords.ELEMENTARY_FILE_TYPE,
                SimRecords.RECORD_NUMBER,
                SimRecords.NAME,
                SimRecords.PHONE_NUMBER
        };
        try (Cursor adnCursor = mResolver.query(SimRecords.getContentUri(1, EF_ADN),
                projection, null, null);
             Cursor fdnCursor = mResolver.query(SimRecords.getContentUri(1, EF_FDN),
                     projection, null, null);
             Cursor sdnCursor = mResolver.query(SimRecords.getContentUri(1, EF_SDN),
                     projection, null, null)
        ) {

            assertThat(adnCursor)
                    .atRow(0).hasRowValues(1, ElementaryFiles.EF_ADN, 1, "Person Adn1",
                    "8005550101")
                    .atRow(1).hasRowValues(1, ElementaryFiles.EF_ADN, 2, "Person Adn2",
                    "8005550102");
            assertThat(fdnCursor)
                    .atRow(0).hasRowValues(1, ElementaryFiles.EF_FDN, 1, "Person Fdn",
                    "8005550103");
            assertThat(sdnCursor)
                    .atRow(0).hasRowValues(1, ElementaryFiles.EF_SDN, 1, "Person Sdn",
                    "8005550104");
        }
    }

    @Test
    public void query_adnRecords_returnsAdnData() {
        setupSimsWithSubscriptionIds(1, 2, 4);
        mIccPhoneBook.addRecord(1, IccConstants.EF_ADN, "Person Sim1", "8005550101");
        mIccPhoneBook.addRecord(1, IccConstants.EF_FDN, "Omitted Sim1", "8005550199");
        mIccPhoneBook.addRecord(2, IccConstants.EF_ADN, "Person Sim2a", "8005550103");
        mIccPhoneBook.addRecord(2, IccConstants.EF_ADN, "Person Sim2b", "8005550104");
        mIccPhoneBook.addRecord(2, IccConstants.EF_ADN, "Person Sim2c", "8005550105");
        mIccPhoneBook.addRecord(2, IccConstants.EF_SDN, "Omitted Sim2", "8005550198");
        mIccPhoneBook.addRecord(4, IccConstants.EF_ADN, "Person Sim4", "8005550106");
        mIccPhoneBook.setDefaultSubscriptionId(1);

        String[] projection = {
                SimRecords.SUBSCRIPTION_ID,
                SimRecords.ELEMENTARY_FILE_TYPE,
                SimRecords.RECORD_NUMBER,
                SimRecords.NAME,
                SimRecords.PHONE_NUMBER
        };
        try (Cursor cursorSim1 = mResolver.query(SimRecords.getContentUri(1, EF_ADN),
                projection, null, null);
             Cursor cursorSim2 = mResolver.query(SimRecords.getContentUri(2, EF_ADN),
                     projection, null, null);
             Cursor cursorSim4 = mResolver.query(SimRecords.getContentUri(4, EF_ADN),
                     projection, null, null)
        ) {

            assertThat(cursorSim1).hasData(new Object[][]{
                    {1, ElementaryFiles.EF_ADN, 1, "Person Sim1", "8005550101"},
            });
            assertThat(cursorSim2).hasData(new Object[][]{
                    {2, ElementaryFiles.EF_ADN, 1, "Person Sim2a", "8005550103"},
                    {2, ElementaryFiles.EF_ADN, 2, "Person Sim2b", "8005550104"},
                    {2, ElementaryFiles.EF_ADN, 3, "Person Sim2c", "8005550105"},
            });
            assertThat(cursorSim4).hasData(new Object[][]{
                    {4, ElementaryFiles.EF_ADN, 1, "Person Sim4", "8005550106"},
            });
        }
    }

    @Test
    public void query_fdnRecords_returnsFdnData() {
        setupSimsWithSubscriptionIds(1, 2, 4);
        mIccPhoneBook.makeAllEfsSupported(1, 2, 4);
        mIccPhoneBook.addRecord(1, IccConstants.EF_ADN, "Person Sim1", "8005550101");
        mIccPhoneBook.addRecord(2, IccConstants.EF_ADN, "Person Sim2a", "8005550103");
        mIccPhoneBook.addRecord(2, IccConstants.EF_FDN, "Person Sim2b", "8005550104");
        mIccPhoneBook.addRecord(2, IccConstants.EF_FDN, "Person Sim2c", "8005550105");
        mIccPhoneBook.addRecord(4, IccConstants.EF_SDN, "Person Sim4", "8005550106");
        mIccPhoneBook.setDefaultSubscriptionId(1);

        String[] projection = {
                SimRecords.SUBSCRIPTION_ID,
                SimRecords.ELEMENTARY_FILE_TYPE,
                SimRecords.RECORD_NUMBER,
                SimRecords.NAME,
                SimRecords.PHONE_NUMBER
        };
        try (Cursor cursorSim1Fdn = mResolver.query(SimRecords.getContentUri(1, EF_FDN),
                projection, null, null);
             Cursor cursorSim2Fdn = mResolver.query(SimRecords.getContentUri(2, EF_FDN),
                     projection, null, null);
             Cursor cursorSim4Fdn = mResolver.query(SimRecords.getContentUri(4, EF_FDN),
                     projection, null, null)
        ) {

            assertThat(cursorSim1Fdn).hasCount(0);
            assertThat(cursorSim2Fdn).hasData(new Object[][]{
                    {2, ElementaryFiles.EF_FDN, 1, "Person Sim2b", "8005550104"},
                    {2, ElementaryFiles.EF_FDN, 2, "Person Sim2c", "8005550105"},
            });
            assertThat(cursorSim4Fdn).hasCount(0);
        }
    }

    @Test
    public void query_sdnRecords_returnsSdnData() {
        setupSimsWithSubscriptionIds(1, 2, 4);
        mIccPhoneBook.makeAllEfsSupported(1, 2, 4);
        mIccPhoneBook.addRecord(1, IccConstants.EF_ADN, "Person Adn1", "8005550101");
        mIccPhoneBook.addRecord(1, IccConstants.EF_FDN, "Person Fdn1", "8005550102");
        mIccPhoneBook.addRecord(1, IccConstants.EF_SDN, "Person Sdn1", "8005550103");
        mIccPhoneBook.addRecord(2, IccConstants.EF_ADN, "Person Adn2a", "8005550104");
        mIccPhoneBook.addRecord(2, IccConstants.EF_FDN, "Person Fdn2b", "8005550105");
        mIccPhoneBook.addRecord(4, IccConstants.EF_SDN, "Person Sdn4a", "8005550106");
        mIccPhoneBook.addRecord(4, IccConstants.EF_SDN, "Person Sdn4b", "8005550107");
        mIccPhoneBook.setDefaultSubscriptionId(1);

        String[] projection = {
                SimRecords.SUBSCRIPTION_ID,
                SimRecords.ELEMENTARY_FILE_TYPE,
                SimRecords.RECORD_NUMBER,
                SimRecords.NAME,
                SimRecords.PHONE_NUMBER
        };
        try (Cursor cursorSim1Sdn = mResolver.query(SimRecords.getContentUri(1, EF_SDN),
                projection, null, null);
             Cursor cursorSim2Sdn = mResolver.query(SimRecords.getContentUri(2, EF_SDN),
                     projection, null, null);
             Cursor cursorSim4Sdn = mResolver.query(SimRecords.getContentUri(4, EF_SDN),
                     projection, null, null)
        ) {

            assertThat(cursorSim1Sdn)
                    .atRow(0).hasRowValues(1, ElementaryFiles.EF_SDN, 1, "Person Sdn1",
                    "8005550103");
            assertThat(cursorSim2Sdn).hasCount(0);
            assertThat(cursorSim4Sdn)
                    .atRow(0).hasRowValues(4, ElementaryFiles.EF_SDN, 1, "Person Sdn4a",
                    "8005550106")
                    .atRow(1).hasRowValues(4, ElementaryFiles.EF_SDN, 2, "Person Sdn4b",
                    "8005550107");
        }
    }

    @Test
    public void query_adnRecords_nonExistentSim_throwsCorrectException() {
        setupSimsWithSubscriptionIds(1);

        IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
                () -> mResolver.query(SimRecords.getContentUri(123, EF_ADN), null, null, null));
        assertThat(e).hasMessageThat().isEqualTo("No active SIM with subscription ID 123");
    }

    @Test
    public void insert_nonExistentSim_throwsCorrectException() {
        setupSimsWithSubscriptionIds(1);
        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "Name");
        values.put(SimRecords.PHONE_NUMBER, "123");

        IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
                () -> mResolver.insert(SimRecords.getContentUri(123, EF_ADN), values));
        assertThat(e).hasMessageThat().isEqualTo("No active SIM with subscription ID 123");
    }

    @Test
    public void update_nonExistentSim_throwsCorrectException() {
        setupSimsWithSubscriptionIds(1);
        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "Name");
        values.put(SimRecords.PHONE_NUMBER, "123");

        IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
                () -> mResolver.update(SimRecords.getItemUri(123, EF_ADN, 1), values, null));
        assertThat(e).hasMessageThat().isEqualTo("No active SIM with subscription ID 123");
    }

    @Test
    public void delete_nonExistentSim_throwsCorrectException() {
        setupSimsWithSubscriptionIds(1);

        IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
                () -> mResolver.delete(SimRecords.getItemUri(123, EF_ADN, 1), null));
        assertThat(e).hasMessageThat().isEqualTo("No active SIM with subscription ID 123");
    }

    @Test
    public void query_adnRecords_zeroSizeEf_throwsCorrectException() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_ADN, 0, 0);

        IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
                () -> mResolver.query(SimRecords.getContentUri(1, EF_ADN), null, null, null));
        assertThat(e).hasMessageThat().isEqualTo(
                "adn is not supported for SIM with subscription ID 1");
    }

    @Test
    public void query_itemUri_returnsCorrectRow() {
        setupSimsWithSubscriptionIds(1, 2);
        mIccPhoneBook.addRecord(1,
                new AdnRecord(IccConstants.EF_ADN, 1, "Name@Adn1[1]", "8005550101"));
        mIccPhoneBook.addRecord(1,
                new AdnRecord(IccConstants.EF_ADN, 2, "Name@Adn1[2]", "8005550102"));
        mIccPhoneBook.addRecord(1,
                new AdnRecord(IccConstants.EF_ADN, 3, "Name@Adn1[3]", "8005550103"));
        mIccPhoneBook.addRecord(2,
                new AdnRecord(IccConstants.EF_ADN, 3, "Name@Adn2[3]", "8005550104"));
        mIccPhoneBook.addRecord(1,
                new AdnRecord(IccConstants.EF_FDN, 1, "Name@Fdn1[1]", "8005550105"));
        mIccPhoneBook.addRecord(2,
                new AdnRecord(IccConstants.EF_SDN, 1, "Name@Sdn2[1]", "8005550106"));

        String[] projection = {
                SimRecords.SUBSCRIPTION_ID, SimRecords.ELEMENTARY_FILE_TYPE,
                SimRecords.RECORD_NUMBER, SimRecords.NAME, SimRecords.PHONE_NUMBER
        };
        try (Cursor item1 = mResolver.query(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 1),
                projection, null, null);
             Cursor item2 = mResolver.query(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 3),
                     projection, null, null);
             Cursor item3 = mResolver.query(SimRecords.getItemUri(2, ElementaryFiles.EF_ADN, 3),
                     projection, null, null);
             Cursor item4 = mResolver.query(SimRecords.getItemUri(1, ElementaryFiles.EF_FDN, 1),
                     projection, null, null);
             Cursor item5 = mResolver.query(SimRecords.getItemUri(2, ElementaryFiles.EF_SDN, 1),
                     projection, null, null)
        ) {
            assertThat(item1).hasSingleRow(1, ElementaryFiles.EF_ADN, 1, "Name@Adn1[1]",
                    "8005550101");
            assertThat(item2).hasSingleRow(1, ElementaryFiles.EF_ADN, 3, "Name@Adn1[3]",
                    "8005550103");
            assertThat(item3).hasSingleRow(2, ElementaryFiles.EF_ADN, 3, "Name@Adn2[3]",
                    "8005550104");
            assertThat(item4).hasSingleRow(1, ElementaryFiles.EF_FDN, 1, "Name@Fdn1[1]",
                    "8005550105");
            assertThat(item5).hasSingleRow(2, ElementaryFiles.EF_SDN, 1, "Name@Sdn2[1]",
                    "8005550106");
        }
    }

    @Test
    public void query_itemUriNullProjection_returnsCursorWithAllColumns() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);

        try (Cursor cursor = mResolver.query(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 1),
                null, null, null)
        ) {
            assertThat(Objects.requireNonNull(
                    cursor).getColumnNames()).asList().containsExactlyElementsIn(
                    SimPhonebookProvider.SIM_RECORDS_ALL_COLUMNS);
        }
    }

    @Test
    public void query_itemUriEmptyRecord_returnsEmptyCursor() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_ADN, 1, 30);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_FDN, 1, 30);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_SDN, 1, 30);

        try (Cursor adnItem = mResolver.query(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 1),
                null, null, null);
             Cursor fdnItem = mResolver.query(SimRecords.getItemUri(1, ElementaryFiles.EF_FDN, 1),
                     null, null, null);
             Cursor sdnItem = mResolver.query(SimRecords.getItemUri(1, ElementaryFiles.EF_SDN, 1),
                     null, null, null)
        ) {
            assertThat(adnItem).hasCount(0);
            assertThat(fdnItem).hasCount(0);
            assertThat(sdnItem).hasCount(0);
        }
    }

    @Test
    public void query_itemUriIndexExceedsMax_returnsEmptyCursor() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_ADN, 1, 30);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_FDN, 1, 30);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_SDN, 1, 30);

        try (Cursor adnItem = mResolver.query(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 2),
                null, null, null);
             Cursor fdnItem = mResolver.query(SimRecords.getItemUri(1, ElementaryFiles.EF_FDN, 2),
                     null, null, null);
             Cursor sdnItem = mResolver.query(SimRecords.getItemUri(1, ElementaryFiles.EF_SDN, 2),
                     null, null, null)
        ) {
            assertThat(adnItem).hasCount(0);
            assertThat(fdnItem).hasCount(0);
            assertThat(sdnItem).hasCount(0);
        }
    }

    @Test
    public void query_invalidItemIndex_throwsIllegalArgumentException() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);

        assertThrows(IllegalArgumentException.class, () ->
                mResolver.query(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, -1),
                        null, null, null));
        assertThrows(IllegalArgumentException.class, () ->
                mResolver.query(SimRecords.getItemUri(1, ElementaryFiles.EF_FDN, -1),
                        null, null, null));
        assertThrows(IllegalArgumentException.class, () ->
                mResolver.query(SimRecords.getItemUri(1, ElementaryFiles.EF_SDN, -1),
                        null, null, null));
        assertThrows(IllegalArgumentException.class, () ->
                mResolver.query(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 0),
                        null, null, null));
        assertThrows(IllegalArgumentException.class, () ->
                mResolver.query(SimRecords.getItemUri(1, ElementaryFiles.EF_FDN, 0),
                        null, null, null));
        assertThrows(IllegalArgumentException.class, () ->
                mResolver.query(SimRecords.getItemUri(1, ElementaryFiles.EF_SDN, 0),
                        null, null, null));
    }

    @Test
    public void insert_adnRecord_addsAdnRecordAndReturnsUriForNewRecord() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);

        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "First Last");
        values.put(SimRecords.PHONE_NUMBER, "8005550101");

        Uri uri = mResolver.insert(SimRecords.getContentUri(1, EF_ADN), values);

        List<AdnRecord> records = mIccPhoneBook.getAdnRecordsInEfForSubscriber(
                1, IccConstants.EF_ADN).stream()
                .filter(((Predicate<AdnRecord>) AdnRecord::isEmpty).negate())
                .collect(Collectors.toList());

        assertThat(records)
                .comparingElementsUsing(ADN_RECORD_IS_EQUAL)
                .containsExactly(new AdnRecord(IccConstants.EF_ADN, 1, "First Last", "8005550101"));

        assertThat(uri).isEqualTo(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 1));
    }

    @Test
    public void insert_adnRecordWithExistingRecords_returnsUriWithCorrectIndex() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.setDefaultSubscriptionId(1);
        mIccPhoneBook.addRecord(new AdnRecord(IccConstants.EF_ADN, 2, "Existing1", "8005550101"));
        mIccPhoneBook.addRecord(new AdnRecord(IccConstants.EF_ADN, 3, "Existing2", "8005550102"));
        mIccPhoneBook.addRecord(new AdnRecord(IccConstants.EF_ADN, 5, "Existing3", "8005550103"));

        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "New1");
        values.put(SimRecords.PHONE_NUMBER, "8005550104");

        Uri insert1 = mResolver.insert(SimRecords.getContentUri(1, EF_ADN), values);
        values.put(SimRecords.NAME, "New2");
        values.put(SimRecords.PHONE_NUMBER, "8005550105");
        Uri insert2 = mResolver.insert(SimRecords.getContentUri(1, EF_ADN), values);
        values.put(SimRecords.NAME, "New3");
        values.put(SimRecords.PHONE_NUMBER, "8005550106");
        Uri insert3 = mResolver.insert(SimRecords.getContentUri(1, EF_ADN), values);

        assertThat(
                mIccPhoneBook.getAdnRecordsInEfForSubscriber(1, IccConstants.EF_ADN).subList(0, 6))
                .comparingElementsUsing(ADN_RECORD_IS_EQUAL)
                .containsExactly(
                        new AdnRecord(IccConstants.EF_ADN, 1, "New1", "8005550104"),
                        new AdnRecord(IccConstants.EF_ADN, 2, "Existing1", "8005550101"),
                        new AdnRecord(IccConstants.EF_ADN, 3, "Existing2", "8005550102"),
                        new AdnRecord(IccConstants.EF_ADN, 4, "New2", "8005550105"),
                        new AdnRecord(IccConstants.EF_ADN, 5, "Existing3", "8005550103"),
                        new AdnRecord(IccConstants.EF_ADN, 6, "New3", "8005550106"));
        assertThat(insert1).isEqualTo(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 1));
        assertThat(insert2).isEqualTo(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 4));
        assertThat(insert3).isEqualTo(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 6));
    }

    @Test
    public void insert_efFull_throwsCorrectException() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_ADN, 1, 30);
        mIccPhoneBook.addRecord(1, IccConstants.EF_ADN, "Existing", "8005550101");

        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "New");
        values.put(SimRecords.PHONE_NUMBER, "8005550102");

        Uri uri = SimRecords.getContentUri(1, EF_ADN);
        IllegalStateException e = assertThrows(IllegalStateException.class,
                () -> mResolver.insert(uri, values));
        assertThat(e).hasMessageThat().isEqualTo(
                uri + " is full. Please delete records to add new ones.");
    }

    @Test
    public void insert_nameWithNonGsmCharacters_addsAdnRecord() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);

        ContentValues values = new ContentValues();
        String name = "abc日本" + EMOJI;
        values.put(SimRecords.NAME, name);
        values.put(SimRecords.PHONE_NUMBER, "8005550101");

        Uri uri = mResolver.insert(SimRecords.getContentUri(1, EF_ADN), values);

        List<AdnRecord> records = mIccPhoneBook.getAdnRecordsInEfForSubscriber(
                1, IccConstants.EF_ADN).stream()
                .filter(((Predicate<AdnRecord>) AdnRecord::isEmpty).negate())
                .collect(Collectors.toList());

        assertThat(records)
                .comparingElementsUsing(ADN_RECORD_IS_EQUAL)
                .containsExactly(new AdnRecord(IccConstants.EF_ADN, 1, name, "8005550101"));

        assertThat(uri).isEqualTo(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 1));
    }

    @Test
    public void insert_nullValues_returnsNull() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);

        Uri result = mResolver.insert(SimRecords.getContentUri(1, EF_ADN), null);

        assertThat(result).isNull();
    }

    @Test
    public void update_nullValues_returnsZero() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);
        mIccPhoneBook.addAdnRecord(1, "Name", "5550101");

        int result = mResolver.update(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 1), null,
                null);

        assertThat(result).isEqualTo(0);
    }

    @Test
    public void insert_emptyValues_returnsNull() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);

        Uri result = mResolver.insert(SimRecords.getContentUri(1, EF_ADN), new ContentValues());

        assertThat(result).isNull();
    }

    @Test
    public void insert_nameOmitted_createsRecordWithJustPhoneNumber() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);

        ContentValues values = new ContentValues();
        // No name
        values.put(SimRecords.PHONE_NUMBER, "18005550101");

        mResolver.insert(SimRecords.getContentUri(1, EF_ADN), values);

        // Null name
        values.putNull(SimRecords.NAME);
        values.put(SimRecords.PHONE_NUMBER, "18005550102");
        mResolver.insert(SimRecords.getContentUri(1, EF_ADN), values);

        // Empty name
        values.put(SimRecords.NAME, "");
        values.put(SimRecords.PHONE_NUMBER, "18005550103");
        mResolver.insert(SimRecords.getContentUri(1, EF_ADN), values);

        assertThat(mIccPhoneBook.getAllValidRecords())
                .comparingElementsUsing(ADN_RECORD_IS_EQUAL)
                .containsExactly(
                        new AdnRecord(IccConstants.EF_ADN, 1, "", "18005550101"),
                        new AdnRecord(IccConstants.EF_ADN, 2, "", "18005550102"),
                        new AdnRecord(IccConstants.EF_ADN, 3, "", "18005550103"));
    }

    @Test
    public void insert_phoneNumberOmitted_throwsCorrectException() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_ADN, 1, 25);

        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "Name");

        IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
                () -> mResolver.insert(SimRecords.getContentUri(1, EF_ADN), values));
        assertThat(e).hasMessageThat().isEqualTo(SimRecords.PHONE_NUMBER + " is required.");
    }

    @Test
    public void insert_nameTooLong_throwsCorrectException() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_ADN, 1, 25);

        ContentValues values = new ContentValues();
        // Name is limited to 11 characters when the max record size is 25
        values.put(SimRecords.NAME, "1234567890ab");
        values.put(SimRecords.PHONE_NUMBER, "8005550102");

        IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
                () -> mResolver.insert(SimRecords.getContentUri(1, EF_ADN), values));

        assertThat(e).hasMessageThat().isEqualTo(SimRecords.NAME + " is too long.");

        // 2 bytes per character and 4 for the emoji. So this is 14 characters long.
        values.put(SimRecords.NAME, "abc日本" + EMOJI);
        e = assertThrows(IllegalArgumentException.class,
                () -> mResolver.insert(SimRecords.getContentUri(1, EF_ADN), values));

        assertThat(e).hasMessageThat().isEqualTo(SimRecords.NAME + " is too long.");
    }

    @Test
    public void insert_phoneNumberTooLong_throwsCorrectException() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_ADN, 1, 25);

        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "Name");
        // 21 digits is longer than max of 20
        values.put(SimRecords.PHONE_NUMBER, "123456789012345678901");

        IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
                () -> mResolver.insert(SimRecords.getContentUri(1, EF_ADN), values));

        assertThat(e).hasMessageThat().isEqualTo(SimRecords.PHONE_NUMBER + " is too long.");
    }

    @Test
    public void insert_numberWithInvalidCharacters_throwsCorrectException() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_ADN, 1, 32);

        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "Name");
        values.put(SimRecords.PHONE_NUMBER, "(800)555-0190 x7777");

        IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
                () -> mResolver.insert(SimRecords.getContentUri(1, ElementaryFiles.EF_ADN),
                        values,
                        null));
        assertThat(e).hasMessageThat().isEqualTo(
                SimRecords.PHONE_NUMBER + " contains unsupported characters.");

        // The insert didn't actually change the data.
        assertThat(mIccPhoneBook.getAllValidRecords()).isEmpty();
    }

    @Test
    public void insert_unsupportedColumn_throwsCorrectException() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_ADN, 1, 25);

        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "Name");
        values.put(SimRecords.PHONE_NUMBER, "18005550101");
        values.put(SimRecords.RECORD_NUMBER, 8);
        values.put("extra_phone2", "18005550102");

        IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
                () -> mResolver.insert(SimRecords.getContentUri(1, EF_ADN), values));
        assertThat(e).hasMessageThat().isEqualTo("Unsupported columns: "
                + SimRecords.RECORD_NUMBER + ",extra_phone2");
    }

    @Test
    public void update_existingRecord_updatesRecord() {
        setupSimsWithSubscriptionIds(1, 2);
        AdnRecord[] unchanged = new AdnRecord[]{
                new AdnRecord(IccConstants.EF_ADN, 3, "Other1", "8005550102"),
                new AdnRecord(IccConstants.EF_ADN, 2, "Other2", "8005550103"),
                new AdnRecord(IccConstants.EF_FDN, 2, "Other3", "8005550104")
        };
        mIccPhoneBook.addRecord(1, unchanged[0]);
        mIccPhoneBook.addRecord(2, unchanged[1]);
        mIccPhoneBook.addRecord(2, unchanged[2]);
        mIccPhoneBook.addRecord(1,
                new AdnRecord(IccConstants.EF_ADN, 2, "Initial Name", "8005550101"));

        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "Updated Name");
        values.put(SimRecords.PHONE_NUMBER, "8005550105");

        int result = mResolver.update(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 2), values,
                null);

        assertThat(result).isEqualTo(1);

        List<AdnRecord> finalRecords = mIccPhoneBook.getAllValidRecords();

        assertThat(finalRecords).comparingElementsUsing(ADN_RECORD_IS_EQUAL)
                .containsAtLeastElementsIn(unchanged);
        assertThat(finalRecords).comparingElementsUsing(ADN_RECORD_IS_EQUAL)
                .doesNotContain(
                        new AdnRecord(IccConstants.EF_ADN, 2, "Initial Name", "80005550101"));
        assertThat(finalRecords).comparingElementsUsing(ADN_RECORD_IS_EQUAL)
                .contains(new AdnRecord(IccConstants.EF_ADN, 2, "Updated Name", "8005550105"));
    }

    @Test
    public void update_emptyRecord_updatesRecord() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);

        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "name");
        values.put(SimRecords.PHONE_NUMBER, "18005550101");
        // No record actually exists with record number 10 but we allow clients to update it
        // as a way to set the information at a specific record number.
        int result = mResolver.update(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 10),
                values, null);

        assertThat(result).isEqualTo(1);
        List<AdnRecord> finalRecords = mIccPhoneBook.getAllValidRecords();
        assertThat(finalRecords).comparingElementsUsing(ADN_RECORD_IS_EQUAL)
                .containsExactly(new AdnRecord(IccConstants.EF_ADN, 10, "name", "18005550101"));
    }

    @Test
    public void delete_existingRecord_deletesRecord() {
        setupSimsWithSubscriptionIds(1, 2);
        AdnRecord[] unchanged = new AdnRecord[]{
                new AdnRecord(IccConstants.EF_ADN, 3, "Other1", "8005550102"),
                new AdnRecord(IccConstants.EF_ADN, 2, "Other2", "8005550103"),
                new AdnRecord(IccConstants.EF_FDN, 2, "Other3", "8005550104")
        };
        mIccPhoneBook.addRecord(1,
                new AdnRecord(IccConstants.EF_ADN, 2, "Initial Name", "8005550101"));
        mIccPhoneBook.addRecord(1, unchanged[0]);
        mIccPhoneBook.addRecord(2, unchanged[1]);
        mIccPhoneBook.addRecord(2, unchanged[2]);

        int result = mResolver.delete(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 2), null);

        assertThat(result).isEqualTo(1);

        assertThat(mIccPhoneBook.getAllValidRecords()).comparingElementsUsing(ADN_RECORD_IS_EQUAL)
                .containsExactlyElementsIn(unchanged);
    }

    @Test
    public void update_indexExceedingMax_returnsZero() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_ADN, 1, 30);

        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "name");
        values.put(SimRecords.PHONE_NUMBER, "18005551010");
        int result = mResolver.update(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 2),
                values, null);

        assertThat(result).isEqualTo(0);
    }

    @Test
    public void update_indexOverflow_throwsIllegalArgumentException() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);

        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "name");
        values.put(SimRecords.PHONE_NUMBER, "18005551010");
        assertThrows(IllegalArgumentException.class, () -> mResolver.update(
                SimRecords.getContentUri(1, EF_ADN).buildUpon().appendPath(
                        String.valueOf((Long.MAX_VALUE))).build(),
                values, null));
    }

    @Test
    public void delete_emptyRecord_returnsZero() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);

        int result = mResolver.delete(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 2), null);

        assertThat(result).isEqualTo(0);
    }

    @Test
    public void delete_indexExceedingMax_returnsZero() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_ADN, 1, 30);

        int result = mResolver.delete(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 2), null);

        assertThat(result).isEqualTo(0);
    }

    @Test
    public void delete_indexOverflow_throwsIllegalArgumentException() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);

        assertThrows(IllegalArgumentException.class, () -> mResolver.delete(
                SimRecords.getContentUri(1, EF_ADN).buildUpon().appendPath(
                        String.valueOf((Long.MAX_VALUE))).build(),
                null));
    }

    @Test
    public void update_nameOrNumberTooLong_throwsCorrectException() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_ADN, 1, 25);
        mIccPhoneBook.addRecord(1, IccConstants.EF_ADN, "Initial", "8005550101");

        ContentValues values = new ContentValues();
        // Name is limited to 11 characters
        values.put(SimRecords.NAME, "1234567890ab");
        values.put(SimRecords.PHONE_NUMBER, "8005550102");

        IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
                () -> mResolver.update(SimRecords.getItemUri(
                        1, ElementaryFiles.EF_ADN, 1), values, null));
        assertThat(e).hasMessageThat().isEqualTo(SimRecords.NAME + " is too long.");

        values.put(SimRecords.NAME, "abc");
        values.put(SimRecords.PHONE_NUMBER, "123456789012345678901");

        e = assertThrows(IllegalArgumentException.class,
                () -> mResolver.update(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 1),
                        values,
                        null));
        assertThat(e).hasMessageThat().isEqualTo(SimRecords.PHONE_NUMBER + " is too long.");
        // The updates didn't actually change the data
        assertThat(mIccPhoneBook.getAllValidRecords())
                .comparingElementsUsing(Correspondence.from(AdnRecord::isEqual, "isEqual"))
                .containsExactly(new AdnRecord(IccConstants.EF_ADN, 1, "Initial", "8005550101"));
    }

    @Test
    public void update_numberWithInvalidCharacters_throwsCorrectException() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.setupEfWithSizes(1, IccConstants.EF_ADN, 1, 32);
        mIccPhoneBook.addRecord(1, IccConstants.EF_ADN, "Initial", "8005550101");

        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "Name");
        values.put(SimRecords.PHONE_NUMBER, "(800)555-0190 x7777");

        IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
                () -> mResolver.update(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 1),
                        values,
                        null));
        assertThat(e).hasMessageThat().isEqualTo(
                SimRecords.PHONE_NUMBER + " contains unsupported characters.");

        // The update didn't actually change the data.
        assertThat(mIccPhoneBook.getAllValidRecords())
                .comparingElementsUsing(Correspondence.from(AdnRecord::isEqual, "isEqual"))
                .containsExactly(new AdnRecord(IccConstants.EF_ADN, 1, "Initial", "8005550101"));
    }

    @Test
    public void insert_nonAdnDirUris_throwsUnsupportedOperationException() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);

        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "Name");
        values.put(SimRecords.PHONE_NUMBER, "8005550101");

        assertThrows(UnsupportedOperationException.class, () ->
                mResolver.insert(ElementaryFiles.CONTENT_URI, values));
        assertThrows(UnsupportedOperationException.class,
                () -> mResolver.insert(SimRecords.getContentUri(1, EF_FDN), values));
        assertThrows(UnsupportedOperationException.class,
                () -> mResolver.insert(SimRecords.getContentUri(1, EF_SDN), values));
        assertThrows(UnsupportedOperationException.class, () ->
                mResolver.insert(SimRecords.getItemUri(1, ElementaryFiles.EF_FDN, 1), values));
        assertThrows(UnsupportedOperationException.class, () ->
                mResolver.insert(SimRecords.getItemUri(1, ElementaryFiles.EF_SDN, 1), values));
    }

    @Test
    public void update_nonAdnDirUris_throwsUnsupportedOperationException() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);

        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "Name");
        values.put(SimRecords.PHONE_NUMBER, "8005550101");

        assertThrows(UnsupportedOperationException.class, () ->
                mResolver.update(ElementaryFiles.CONTENT_URI, values, null));
        assertThrows(UnsupportedOperationException.class,
                () -> mResolver.update(SimRecords.getContentUri(1, EF_FDN), values, null));
        assertThrows(UnsupportedOperationException.class,
                () -> mResolver.update(SimRecords.getContentUri(1, EF_SDN), values, null));
        assertThrows(UnsupportedOperationException.class,
                () -> mResolver.update(SimRecords.getContentUri(1, EF_SDN), values, null));
        assertThrows(UnsupportedOperationException.class, () ->
                mResolver.update(SimRecords.getItemUri(1, ElementaryFiles.EF_FDN, 1), values,
                        null));
        assertThrows(UnsupportedOperationException.class, () ->
                mResolver.update(SimRecords.getItemUri(1, ElementaryFiles.EF_SDN, 1), values,
                        null));
    }

    @Test
    public void delete_nonAdnDirUris_throwsUnsupportedOperationException() {
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);

        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "Name");
        values.put(SimRecords.PHONE_NUMBER, "8005550101");

        assertThrows(UnsupportedOperationException.class, () ->
                mResolver.delete(ElementaryFiles.CONTENT_URI, null));
        assertThrows(UnsupportedOperationException.class,
                () -> mResolver.delete(SimRecords.getContentUri(1, EF_FDN), null));
        assertThrows(UnsupportedOperationException.class,
                () -> mResolver.delete(SimRecords.getContentUri(1, EF_SDN), null));
        assertThrows(UnsupportedOperationException.class,
                () -> mResolver.delete(SimRecords.getContentUri(1, EF_SDN), null));
        assertThrows(UnsupportedOperationException.class, () ->
                mResolver.delete(SimRecords.getItemUri(1, ElementaryFiles.EF_FDN, 1), null));
        assertThrows(UnsupportedOperationException.class, () ->
                mResolver.delete(SimRecords.getItemUri(1, ElementaryFiles.EF_SDN, 1), null));
    }

    @Test
    public void subscriptionsChange_callsNotifyChange() {
        // Clear invocations that happened in setUp
        Mockito.reset(mMockSubscriptionManager);
        // Stubbing this prevents the spied instance from calling the listener when it is added
        // which may cause flakiness.
        doNothing().when(mMockSubscriptionManager)
                .addOnSubscriptionsChangedListener(any(), any());
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);
        SimPhonebookProvider.ContentNotifier mockNotifier = mock(
                SimPhonebookProvider.ContentNotifier.class);
        ArgumentCaptor<SubscriptionManager.OnSubscriptionsChangedListener> listenerCaptor =
                ArgumentCaptor.forClass(SubscriptionManager.OnSubscriptionsChangedListener.class);

        TestableSimPhonebookProvider.setup(
                mResolver, mMockSubscriptionManager, mIccPhoneBook, mockNotifier);
        verify(mMockSubscriptionManager).addOnSubscriptionsChangedListener(
                any(), listenerCaptor.capture());

        // Fake the initial call that is made by SubscriptionManager when a listener is registered
        // with addOnSubscriptionsChangedListener
        listenerCaptor.getValue().onSubscriptionsChanged();

        // First subscription change
        setupSimsWithSubscriptionIds(1, 2);
        listenerCaptor.getValue().onSubscriptionsChanged();

        // Second subscription change
        setupSimsWithSubscriptionIds(1);
        listenerCaptor.getValue().onSubscriptionsChanged();

        // Listener is called but subscriptions didn't change so this won't notify
        listenerCaptor.getValue().onSubscriptionsChanged();

        verify(mockNotifier, times(2)).notifyChange(eq(SimPhonebookContract.AUTHORITY_URI));
    }

    @Test
    public void insert_callsNotifyChange() {
        // Clear invocations that happened in setUp
        Mockito.reset(mMockSubscriptionManager);
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.makeAllEfsSupported(1);
        SimPhonebookProvider.ContentNotifier mockNotifier = mock(
                SimPhonebookProvider.ContentNotifier.class);

        TestableSimPhonebookProvider.setup(
                mResolver, mMockSubscriptionManager, mIccPhoneBook, mockNotifier);

        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "name");
        values.put(SimRecords.PHONE_NUMBER, "5550101");
        mResolver.insert(SimRecords.getContentUri(1, EF_ADN), values);

        verify(mockNotifier).notifyChange(eq(SimPhonebookContract.AUTHORITY_URI));
    }

    @Test
    public void update_callsNotifyChange() {
        // Clear invocations that happened in setUp
        Mockito.reset(mMockSubscriptionManager);
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.addAdnRecord(1, "Initial", "5550101");
        SimPhonebookProvider.ContentNotifier mockNotifier = mock(
                SimPhonebookProvider.ContentNotifier.class);

        TestableSimPhonebookProvider.setup(
                mResolver, mMockSubscriptionManager, mIccPhoneBook, mockNotifier);

        ContentValues values = new ContentValues();
        values.put(SimRecords.NAME, "Updated");
        values.put(SimRecords.PHONE_NUMBER, "5550102");
        mResolver.update(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 1), values, null);

        verify(mockNotifier).notifyChange(eq(SimPhonebookContract.AUTHORITY_URI));
    }

    @Test
    public void delete_callsNotifyChange() {
        // Clear invocations that happened in setUp
        Mockito.reset(mMockSubscriptionManager);
        setupSimsWithSubscriptionIds(1);
        mIccPhoneBook.addAdnRecord(1, "Initial", "5550101");
        SimPhonebookProvider.ContentNotifier mockNotifier = mock(
                SimPhonebookProvider.ContentNotifier.class);

        TestableSimPhonebookProvider.setup(
                mResolver, mMockSubscriptionManager, mIccPhoneBook, mockNotifier);

        mResolver.delete(SimRecords.getItemUri(1, ElementaryFiles.EF_ADN, 1), null);

        verify(mockNotifier).notifyChange(eq(SimPhonebookContract.AUTHORITY_URI));
    }

    @Test
    public void getEncodedNameLength_returnsValueIsCorrect() {
        String name = "";
        int length = SimRecords.getEncodedNameLength(mResolver, name);
        assertThat(length).isEqualTo(0);

        name = "First Last";
        length = SimRecords.getEncodedNameLength(mResolver, name);
        assertThat(length).isEqualTo(name.length());

        name = "日本";
        length = SimRecords.getEncodedNameLength(mResolver, name);
        assertThat(length).isEqualTo(name.length() * 2 + 1);

        name = EMOJI;
        length = SimRecords.getEncodedNameLength(mResolver, name);
        assertThat(length).isEqualTo(name.length() * 2 + 1);

        name = "abc日本" + EMOJI;
        length = SimRecords.getEncodedNameLength(mResolver, name);
        assertThat(length).isEqualTo(name.length() * 2 + 1);
    }

    private void setupSimsWithSubscriptionIds(int... subscriptionIds) {
        when(mMockSubscriptionManager.getActiveSubscriptionIdList()).thenReturn(subscriptionIds);
        when(mMockSubscriptionManager.getActiveSubscriptionInfoCount())
                .thenReturn(subscriptionIds.length);
        List<SubscriptionInfo> subscriptions = createSubscriptionsWithIds(subscriptionIds);
        when(mMockSubscriptionManager.getActiveSubscriptionInfoList()).thenReturn(subscriptions);
        for (SubscriptionInfo info : subscriptions) {
            when(mMockSubscriptionManager.getActiveSubscriptionInfo(info.getSubscriptionId()))
                    .thenReturn(info);
        }
    }

    public static class FakeIccPhoneBook extends IIccPhoneBook.Default {

        private static final int DEFAULT_RECORD_SIZE = 30;
        private static final int DEFAULT_RECORDS_COUNT = 100;

        // The key for both maps is the (subscription ID, efid)
        private Map<Pair<Integer, Integer>, AdnRecord[]> mRecords = new HashMap<>();
        // The value is the single record size
        private Map<Pair<Integer, Integer>, int[]> mRecordSizes = new HashMap<>();

        private int mDefaultSubscriptionId = 101;

        private void addRecord(Pair<Integer, Integer> key, AdnRecord record) {
            // Assume that if records are being added then the test wants it to be a valid
            // elementary file so set sizes as well.
            if (!mRecordSizes.containsKey(key)) {
                setupEfWithSizes(key.first, key.second,
                        Math.max(record.getRecId(), DEFAULT_RECORDS_COUNT), DEFAULT_RECORD_SIZE);
            }
            mRecords.get(key)[record.getRecId() - 1] = record;
        }

        public void addRecord(AdnRecord record) {
            addRecord(Pair.create(mDefaultSubscriptionId, record.getEfid()), record);
        }

        public void addRecord(int subscriptionId, AdnRecord record) {
            addRecord(Pair.create(subscriptionId, record.getEfid()), record);
        }

        public void addRecord(int subscriptionId, int efId, String name, String phoneNumber) {
            Pair<Integer, Integer> key = Pair.create(subscriptionId, efId);
            AdnRecord[] records = mRecords.computeIfAbsent(key, unused ->
                    createEmptyRecords(efId, 100));
            int recordIndex = -1;
            for (int i = 0; i < records.length; i++) {
                if (records[i].isEmpty()) {
                    recordIndex = i;
                    break;
                }
            }
            if (recordIndex == -1) {
                throw new IllegalStateException("");
            }
            addRecord(key, new AdnRecord(efId, recordIndex + 1, name, phoneNumber));
        }

        public void addAdnRecord(int subscriptionId, String name, String phoneNumber) {
            addRecord(subscriptionId, IccConstants.EF_ADN, name, phoneNumber);
        }

        public void addAdnRecord(String name, String phoneNumber) {
            addRecord(mDefaultSubscriptionId, IccConstants.EF_ADN, name, phoneNumber);
        }

        public List<AdnRecord> getAllValidRecords() {
            List<AdnRecord> result = new ArrayList<>();
            for (AdnRecord[] records : mRecords.values()) {
                for (AdnRecord record : records) {
                    if (!record.isEmpty()) {
                        result.add(record);
                    }
                }
            }
            return result;
        }

        public void makeAllEfsSupported() {
            makeAllEfsSupported(mDefaultSubscriptionId);
        }

        /**
         * Sets up the fake to return valid records size for all elementary files for the provided
         * subscription IDs.
         */
        public void makeAllEfsSupported(int... subscriptionIds) {
            for (int subId : subscriptionIds) {
                makeAllEfsSupported(subId);
            }
        }

        /**
         * Sets up the fake to return valid records size for all elementary files for the provided
         * subscription IDs.
         */
        public void makeAllEfsSupported(int subscriptionId) {
            setupEfWithSizes(subscriptionId, IccConstants.EF_ADN, DEFAULT_RECORDS_COUNT,
                    DEFAULT_RECORD_SIZE);
            setupEfWithSizes(subscriptionId, IccConstants.EF_FDN, DEFAULT_RECORDS_COUNT,
                    DEFAULT_RECORD_SIZE);
            setupEfWithSizes(subscriptionId, IccConstants.EF_SDN, DEFAULT_RECORDS_COUNT,
                    DEFAULT_RECORD_SIZE);
        }

        public void setRecords(int subscriptionId, int efid, AdnRecord[] records) {
            mRecords.put(Pair.create(subscriptionId, efid), records);
        }

        public void setRecordsSize(int subscriptionId, int efid, int maxRecordCount,
                int maxRecordSize) {
            setRecordsSize(Pair.create(subscriptionId, efid), maxRecordCount, maxRecordSize);
        }

        private void setRecordsSize(Pair<Integer, Integer> key, int maxRecordCount,
                int maxRecordSize) {
            int[] sizes = { maxRecordSize, maxRecordSize * maxRecordCount, maxRecordCount };
            mRecordSizes.put(key, sizes);
        }

        public void setupEfWithSizes(int subscriptionId, int efid, int maxRecordCount,
                int maxRecordSize) {
            Pair<Integer, Integer> key = Pair.create(subscriptionId, efid);
            setRecordsSize(key, maxRecordCount, maxRecordSize);
            AdnRecord[] records = mRecords.computeIfAbsent(key, unused ->
                    createEmptyRecords(efid, maxRecordCount));
            if (records.length < maxRecordCount) {
                throw new IllegalStateException("Records already initialized with a smaller size");
            }
        }

        AdnRecord[] createEmptyRecords(int efid, int count) {
            AdnRecord[] records = new AdnRecord[count];
            for (int i = 0; i < records.length; i++) {
                if (records[i] == null) {
                    records[i] = new AdnRecord(efid, i + 1, "", "");
                }
            }
            return records;
        }

        public void setDefaultSubscriptionId(int defaultSubscriptionId) {
            mDefaultSubscriptionId = defaultSubscriptionId;
        }

        public void reset() {
            mRecords.clear();
            mRecordSizes.clear();
        }

        @Override
        public List<AdnRecord> getAdnRecordsInEf(int efid) {
            return getAdnRecordsInEfForSubscriber(mDefaultSubscriptionId, efid);
        }

        @Override
        public List<AdnRecord> getAdnRecordsInEfForSubscriber(int subId, int efid) {
            return Arrays.asList(
                    mRecords.getOrDefault(Pair.create(subId, efid), new AdnRecord[0]));
        }

        @Override
        public boolean updateAdnRecordsInEfBySearchForSubscriber(int subId, int efid,
                ContentValues values, String pin2) {
            final String oldTag = values.getAsString(IccProvider.STR_TAG);
            final String oldPhoneNumber = values.getAsString(IccProvider.STR_NUMBER);
            final String newTag = values.getAsString(IccProvider.STR_NEW_TAG);
            final String newPhoneNumber = values.getAsString(IccProvider.STR_NEW_NUMBER);
            return updateAdnRecordsInEfBySearchForSubscriber(subId, efid, oldTag, oldPhoneNumber,
                    newTag, newPhoneNumber, pin2);

        }

        private boolean updateAdnRecordsInEfBySearchForSubscriber(int subId, int efid, String oldTag,
                String oldPhoneNumber, String newTag, String newPhoneNumber, String pin2) {
            if (!oldTag.isEmpty() || !oldPhoneNumber.isEmpty()) {
                throw new IllegalArgumentException(
                        "updateAdnRecordsInEfBySearchForSubscriber only supports insert");
            }
            addRecord(subId, efid, newTag, newPhoneNumber);
            return true;
        }

        @Override
        public boolean updateAdnRecordsInEfByIndexForSubscriber(int subId, int efid,
                ContentValues values, int index, String pin2) {
            final String newTag = values.getAsString(IccProvider.STR_NEW_TAG);
            final String newPhoneNumber = values.getAsString(IccProvider.STR_NEW_NUMBER);
            return updateAdnRecordsInEfByIndexForSubscriber(subId, efid, newTag, newPhoneNumber,
                    index, pin2);

        }

        private boolean updateAdnRecordsInEfByIndexForSubscriber(int subId, int efid, String newTag,
                String newPhoneNumber, int index, String pin2) {
            AdnRecord[] records = mRecords.computeIfAbsent(Pair.create(subId, efid), unused ->
                    createEmptyRecords(efid, 100));
            records[index - 1] = new AdnRecord(efid, index, newTag, newPhoneNumber);
            return true;
        }

        @Override
        public int[] getAdnRecordsSize(int efid) {
            return getAdnRecordsSizeForSubscriber(mDefaultSubscriptionId, efid);
        }

        @Override
        public int[] getAdnRecordsSizeForSubscriber(int subId, int efid) {
            Pair<Integer, Integer> key = Pair.create(subId, efid);
            int[] recordsSize = mRecordSizes.get(key);
            if (recordsSize == null) {
                return new int[]{0, 0, 0};
            }
            return recordsSize;
        }

        @Override
        public AdnCapacity getAdnRecordsCapacityForSubscriber(int subId) {
            return new AdnCapacity(0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
        }
    }

    /**
     * Implementation of SimPhonebookProvider that allows test-doubles to be injected.
     *
     * <p>The ProviderTestRule doesn't seem to allow a better way to do this since it just
     * invokes the constructor.
     */
    public static class TestableSimPhonebookProvider extends SimPhonebookProvider {

        public static void setup(
                ContentResolver resolver,
                SubscriptionManager subscriptionManager,
                IIccPhoneBook iccPhoneBook) {
            setup(resolver, subscriptionManager, iccPhoneBook, uri -> {
            });
        }

        public static void setup(
                ContentResolver resolver,
                SubscriptionManager subscriptionManager,
                IIccPhoneBook iccPhoneBook,
                ContentNotifier notifier) {
            TestableSimPhonebookProvider provider =
                    (TestableSimPhonebookProvider) Objects.requireNonNull(
                            resolver.acquireContentProviderClient(
                                    SimPhonebookContract.AUTHORITY))
                            .getLocalContentProvider();
            InstrumentationRegistry.getInstrumentation().runOnMainSync(() ->
                    provider.onCreate(subscriptionManager, () -> iccPhoneBook, notifier));
        }

        @Override
        public boolean onCreate() {
            // We stub super.onCreate because it initializes services which causes an
            // IllegalArgumentException because of the context used for the test.
            return true;
        }
    }
}