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

Commit 5efab684 authored by Weilin Xu's avatar Weilin Xu Committed by Android (Google) Code Review
Browse files

Merge changes I2d3a911d,I88353fe9 into main 

* changes:
  Add announcement listener and session unit test
  Add tuner session and conversion utils unit tests
parents c1b6e58b 5025dda9

core/tests/BroadcastRadioTests/src/com/android/server/broadcastradio/IRadioServiceHidlImplTest.java

+15 −0
Original line number Diff line number Diff line
@@ -24,6 +24,8 @@ import static org.mockito.ArgumentMatchers.anyBoolean; 
import static org.mockito.ArgumentMatchers.anyInt;

import static org.mockito.Mockito.doAnswer;

import static org.mockito.Mockito.doNothing;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;
@@ -33,6 +35,7 @@ import android.hardware.radio.ICloseHandle; 
import android.hardware.radio.ITuner;

import android.hardware.radio.ITunerCallback;

import android.hardware.radio.RadioManager;

import android.os.IBinder;



import org.junit.Before;

import org.junit.Test;
@@ -132,6 +135,7 @@ public final class IRadioServiceHidlImplTest { 
    @Test

    public void addAnnouncementListener_forHidlImpl() {

        when(mHal2Mock.hasAnyModules()).thenReturn(true);



        ICloseHandle closeHandle = mHidlImpl.addAnnouncementListener(ENABLE_TYPES, mListenerMock);



        verify(mHal2Mock).addAnnouncementListener(ENABLE_TYPES, mListenerMock);
@@ -139,4 +143,15 @@ public final class IRadioServiceHidlImplTest { 
                .that(closeHandle).isEqualTo(mICloseHandle);

    }



    @Test

    public void addAnnouncementListener_withoutAnyModules() throws Exception {

        when(mHal2Mock.hasAnyModules()).thenReturn(false);

        IBinder binderMock = mock(IBinder.class);

        when(mListenerMock.asBinder()).thenReturn(binderMock);



        mHidlImpl.addAnnouncementListener(ENABLE_TYPES, mListenerMock);



        verify(mHal2Mock, never()).addAnnouncementListener(ENABLE_TYPES, mListenerMock);

        verify(binderMock).linkToDeath(any(), anyInt());

    }

}

core/tests/BroadcastRadioTests/src/com/android/server/broadcastradio/aidl/AidlTestUtils.java

+10 −2
Original line number Diff line number Diff line
@@ -112,13 +112,21 @@ final class AidlTestUtils { 
            android.hardware.broadcastradio.ProgramSelector hwSel,

            ProgramIdentifier logicallyTunedTo, ProgramIdentifier physicallyTunedTo,

            int hwSignalQuality) {

        return makeHalProgramInfo(hwSel, logicallyTunedTo, physicallyTunedTo, hwSignalQuality,

                new ProgramIdentifier[]{}, new Metadata[]{});

    }



    static ProgramInfo makeHalProgramInfo(

            android.hardware.broadcastradio.ProgramSelector hwSel,

            ProgramIdentifier logicallyTunedTo, ProgramIdentifier physicallyTunedTo,

            int hwSignalQuality, ProgramIdentifier[] relatedContent, Metadata[] metadata) {

        ProgramInfo hwInfo = new ProgramInfo();

        hwInfo.selector = hwSel;

        hwInfo.logicallyTunedTo = logicallyTunedTo;

        hwInfo.physicallyTunedTo = physicallyTunedTo;

        hwInfo.signalQuality = hwSignalQuality;

        hwInfo.relatedContent = new ProgramIdentifier[]{};

        hwInfo.metadata = new Metadata[]{};

        hwInfo.relatedContent = relatedContent;

        hwInfo.metadata = metadata;

        return hwInfo;

    }

core/tests/BroadcastRadioTests/src/com/android/server/broadcastradio/aidl/ConversionUtilsTest.java

+213 −8
Original line number Diff line number Diff line
@@ -42,6 +42,7 @@ import android.hardware.radio.RadioMetadata; 
import android.hardware.radio.UniqueProgramIdentifier;

import android.os.ServiceSpecificException;

import android.platform.test.flag.junit.SetFlagsRule;

import android.util.ArrayMap;

import android.util.ArraySet;



import com.android.dx.mockito.inline.extended.StaticMockitoSessionBuilder;
@@ -54,6 +55,7 @@ import org.junit.Rule; 
import org.junit.Test;

import org.mockito.stubbing.Answer;



import java.util.List;

import java.util.Map;

import java.util.Set;
@@ -86,6 +88,7 @@ public final class ConversionUtilsTest extends ExtendedRadioMockitoTestCase { 


    private static final int TEST_SIGNAL_QUALITY = 1;

    private static final long TEST_DAB_DMB_SID_EXT_VALUE = 0xA000000111L;

    private static final long TEST_DAB_SID_EXT_LEGACY_VALUE = 0xA00111L;

    private static final long TEST_DAB_ENSEMBLE_VALUE = 0x1001;

    private static final long TEST_DAB_FREQUENCY_VALUE = 220_352;

    private static final long TEST_FM_FREQUENCY_VALUE = 92_100;
@@ -103,6 +106,9 @@ public final class ConversionUtilsTest extends ExtendedRadioMockitoTestCase { 
    private static final ProgramSelector.Identifier TEST_DAB_SID_EXT_ID =

            new ProgramSelector.Identifier(

                    ProgramSelector.IDENTIFIER_TYPE_DAB_DMB_SID_EXT, TEST_DAB_DMB_SID_EXT_VALUE);

    private static final ProgramSelector.Identifier TEST_DAB_SID_EXT_LEGACY_ID =

            new ProgramSelector.Identifier(

                    ProgramSelector.IDENTIFIER_TYPE_DAB_SID_EXT, TEST_DAB_SID_EXT_LEGACY_VALUE);

    private static final ProgramSelector.Identifier TEST_DAB_ENSEMBLE_ID =

            new ProgramSelector.Identifier(

                    ProgramSelector.IDENTIFIER_TYPE_DAB_ENSEMBLE, TEST_DAB_ENSEMBLE_VALUE);
@@ -125,6 +131,10 @@ public final class ConversionUtilsTest extends ExtendedRadioMockitoTestCase { 
            ProgramSelector.PROGRAM_TYPE_DAB, TEST_DAB_SID_EXT_ID,

            new ProgramSelector.Identifier[]{TEST_DAB_FREQUENCY_ID, TEST_DAB_ENSEMBLE_ID},

            /* vendorIds= */ null);

    private static final ProgramSelector TEST_DAB_SELECTOR_LEGACY = new ProgramSelector(

            ProgramSelector.PROGRAM_TYPE_DAB, TEST_DAB_SID_EXT_LEGACY_ID,

            new ProgramSelector.Identifier[]{TEST_DAB_FREQUENCY_ID, TEST_DAB_ENSEMBLE_ID},

            /* vendorIds= */ null);

    private static final ProgramSelector TEST_FM_SELECTOR =

            AidlTestUtils.makeFmSelector(TEST_FM_FREQUENCY_VALUE);
@@ -132,6 +142,9 @@ public final class ConversionUtilsTest extends ExtendedRadioMockitoTestCase { 
            new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_HD_STATION_ID_EXT,

                    TEST_HD_STATION_ID_EXT_VALUE);



    private static final ProgramIdentifier TEST_HAL_HD_STATION_EXT_ID =

            AidlTestUtils.makeHalIdentifier(IdentifierType.HD_STATION_ID_EXT,

                    TEST_HD_STATION_ID_EXT_VALUE);

    private static final ProgramIdentifier TEST_HAL_HD_STATION_LOCATION_ID =

            AidlTestUtils.makeHalIdentifier(IdentifierType.HD_STATION_LOCATION,

                    TEST_HD_LOCATION_VALUE);
@@ -220,6 +233,27 @@ public final class ConversionUtilsTest extends ExtendedRadioMockitoTestCase { 
                .hasMessageThat().contains("tune: CANCELED");

    }



    @Test

    public void throwOnError_withInvalidArgumentException() {

        ServiceSpecificException halException = new ServiceSpecificException(

                Result.INVALID_ARGUMENTS);



        RuntimeException thrown = ConversionUtils.throwOnError(halException, "tune");



        expect.withMessage("Exception thrown for invalid argument error")

                .that(thrown).hasMessageThat().contains("tune: INVALID_ARGUMENTS");

    }



    @Test

    public void throwOnError_withTimeoutException() {

        ServiceSpecificException halException = new ServiceSpecificException(Result.TIMEOUT);



        RuntimeException thrown = ConversionUtils.throwOnError(halException, "seek");



        expect.withMessage("Exception thrown for timeout error")

                .that(thrown).hasMessageThat().contains("seek: TIMEOUT");

    }



    @Test

    public void propertiesFromHalProperties_idsMatch() {

        expect.withMessage("Properties id")
@@ -300,7 +334,7 @@ public final class ConversionUtilsTest extends ExtendedRadioMockitoTestCase { 
    @Test

    public void propertiesFromHalProperties_withoutAmFmAndDabConfigs() {

        RadioManager.ModuleProperties properties = createModuleProperties(/* amFmConfig= */ null,

                new DabTableEntry[]{});

                /* dabTableEntries= */ null);



        expect.withMessage("Empty AM/FM config")

                .that(properties.getBands()).asList().isEmpty();
@@ -498,6 +532,22 @@ public final class ConversionUtilsTest extends ExtendedRadioMockitoTestCase { 
                .that(programInfo.getSignalStrength()).isEqualTo(TEST_SIGNAL_QUALITY);

    }



    @Test

    public void programInfoFromHalProgramInfo_withRelatedContent() {

        android.hardware.broadcastradio.ProgramSelector halDabSelector =

                AidlTestUtils.makeHalSelector(TEST_HAL_DAB_SID_EXT_ID, new ProgramIdentifier[]{

                        TEST_HAL_DAB_ENSEMBLE_ID, TEST_HAL_DAB_FREQUENCY_ID});

        ProgramInfo halProgramInfo = AidlTestUtils.makeHalProgramInfo(halDabSelector,

                TEST_HAL_DAB_SID_EXT_ID, TEST_HAL_DAB_FREQUENCY_ID, TEST_SIGNAL_QUALITY,

                new ProgramIdentifier[]{TEST_HAL_HD_STATION_EXT_ID}, new Metadata[]{});



        RadioManager.ProgramInfo programInfo =

                ConversionUtils.programInfoFromHalProgramInfo(halProgramInfo);



        expect.withMessage("Related content of converted program info")

                .that(programInfo.getRelatedContent()).containsExactly(TEST_HD_STATION_EXT_ID);

    }



    @Test

    public void programInfoFromHalProgramInfo_withInvalidDabProgramInfo() {

        android.hardware.broadcastradio.ProgramSelector invalidHalDabSelector =
@@ -557,6 +607,29 @@ public final class ConversionUtilsTest extends ExtendedRadioMockitoTestCase { 
                        T_APP_UID)).isFalse();

    }



    @Test

    public void programInfoMeetsSdkVersionRequirement_withLowerVersionIdForLogicallyTunedTo() {

        RadioManager.ProgramInfo dabProgramInfo = AidlTestUtils.makeProgramInfo(

                TEST_DAB_SELECTOR_LEGACY, TEST_DAB_SID_EXT_ID, TEST_DAB_FREQUENCY_ID,

                TEST_SIGNAL_QUALITY);



        expect.withMessage("Program info %s with logically tuned to ID not of required SDK version",

                        dabProgramInfo).that(ConversionUtils.programInfoMeetsSdkVersionRequirement(

                                dabProgramInfo, T_APP_UID)).isFalse();

    }



    @Test

    public void programInfoMeetsSdkVersionRequirement_withLowerVersionIdForRelatedContent() {

        RadioManager.ProgramInfo dabProgramInfo = new RadioManager.ProgramInfo(

                TEST_DAB_SELECTOR_LEGACY, TEST_DAB_SID_EXT_ID, TEST_DAB_FREQUENCY_ID,

                List.of(TEST_DAB_SID_EXT_ID), /* infoFlags= */ 0, TEST_SIGNAL_QUALITY,

                new RadioMetadata.Builder().build(), new ArrayMap<>());



        expect.withMessage("Program info %s with related content not of required SDK version",

                dabProgramInfo).that(ConversionUtils.programInfoMeetsSdkVersionRequirement(

                dabProgramInfo, T_APP_UID)).isFalse();

    }



    @Test

    public void programInfoMeetsSdkVersionRequirement_withRequiredVersionId_returnsTrue() {

        RadioManager.ProgramInfo fmProgramInfo = AidlTestUtils.makeProgramInfo(TEST_FM_SELECTOR,
@@ -675,20 +748,122 @@ public final class ConversionUtilsTest extends ExtendedRadioMockitoTestCase { 
    }



    @Test

    public void radioMetadataFromHalMetadata_withFlagEnabled() {

        mSetFlagsRule.enableFlags(Flags.FLAG_HD_RADIO_IMPROVED);



    public void radioMetadataFromHalMetadata() {

        int rdsPtyValue = 3;

        int rbdsPtyValue = 4;

        String rdsRtValue = "rdsRtTest";

        String songAlbumValue = "songAlbumTest";

        String programNameValue = "programNameTest";

        RadioMetadata convertedMetadata = ConversionUtils.radioMetadataFromHalMetadata(

                new Metadata[]{TEST_HAL_SONG_TITLE, TEST_HAL_HD_SUBCHANNELS, TEST_HAL_ALBUM_ART});

                new Metadata[]{TEST_HAL_SONG_TITLE, TEST_HAL_ALBUM_ART,

                        Metadata.rdsPty(rdsPtyValue), Metadata.rbdsPty(rbdsPtyValue),

                        Metadata.rdsRt(rdsRtValue), Metadata.songAlbum(songAlbumValue),

                        Metadata.programName(programNameValue)});



        expect.withMessage("Metadata with flag enabled").that(convertedMetadata.size())

                .isEqualTo(3);

        expect.withMessage("Song title with flag enabled")

                .that(convertedMetadata.getString(RadioMetadata.METADATA_KEY_TITLE))

                .isEqualTo(TEST_SONG_TITLE);

        expect.withMessage("Album art with flag enabled")

                .that(convertedMetadata.getInt(RadioMetadata.METADATA_KEY_ART))

                .isEqualTo(TEST_ALBUM_ART);

        expect.withMessage("RDS PTY with flag enabled")

                .that(convertedMetadata.getInt(RadioMetadata.METADATA_KEY_RDS_PTY))

                .isEqualTo(rdsPtyValue);

        expect.withMessage("RBDS PTY with flag enabled")

                .that(convertedMetadata.getInt(RadioMetadata.METADATA_KEY_RBDS_PTY))

                .isEqualTo(rbdsPtyValue);

        expect.withMessage("RDS RT with flag enabled")

                .that(convertedMetadata.getString(RadioMetadata.METADATA_KEY_RDS_RT))

                .isEqualTo(rdsRtValue);

        expect.withMessage("Album with flag enabled")

                .that(convertedMetadata.getString(RadioMetadata.METADATA_KEY_ALBUM))

                .isEqualTo(songAlbumValue);

        expect.withMessage("Program name with flag enabled")

                .that(convertedMetadata.getString(RadioMetadata.METADATA_KEY_PROGRAM_NAME))

                .isEqualTo(programNameValue);

    }



    @Test

    public void radioMetadataFromHalMetadata_withDabMetadata() {

        String dabEnsembleNameValue = "dabEnsembleNameTest";

        String dabEnsembleNameShortValue = "dabEnsembleNameShortTest";

        String dabServiceNameValue = "dabServiceNameTest";

        String dabServiceNameShortValue = "dabServiceNameShortTest";

        String dabComponentNameValue = "dabComponentNameTest";

        String dabComponentNameShortValue = "dabComponentNameShortTest";

        RadioMetadata convertedMetadata = ConversionUtils.radioMetadataFromHalMetadata(

                new Metadata[]{Metadata.dabEnsembleName(dabEnsembleNameValue),

                        Metadata.dabEnsembleNameShort(dabEnsembleNameShortValue),

                        Metadata.dabServiceName(dabServiceNameValue),

                        Metadata.dabServiceNameShort(dabServiceNameShortValue),

                        Metadata.dabComponentName(dabComponentNameValue),

                        Metadata.dabComponentNameShort(dabComponentNameShortValue)});



        expect.withMessage("DAB Ensemble name with flag enabled")

                .that(convertedMetadata.getString(

                        RadioMetadata.METADATA_KEY_DAB_ENSEMBLE_NAME))

                .isEqualTo(dabEnsembleNameValue);

        expect.withMessage("DAB Ensemble short name with flag enabled")

                .that(convertedMetadata.getString(

                        RadioMetadata.METADATA_KEY_DAB_ENSEMBLE_NAME_SHORT))

                .isEqualTo(dabEnsembleNameShortValue);

        expect.withMessage("DAB service service name with flag enabled")

                .that(convertedMetadata.getString(RadioMetadata.METADATA_KEY_DAB_SERVICE_NAME))

                .isEqualTo(dabServiceNameValue);

        expect.withMessage("DAB service service short name with flag enabled")

                .that(convertedMetadata.getString(

                        RadioMetadata.METADATA_KEY_DAB_SERVICE_NAME_SHORT))

                .isEqualTo(dabServiceNameShortValue);

        expect.withMessage("DAB component name with flag enabled")

                .that(convertedMetadata.getString(RadioMetadata.METADATA_KEY_DAB_COMPONENT_NAME))

                .isEqualTo(dabComponentNameValue);

        expect.withMessage("DAB component short name with flag enabled")

                .that(convertedMetadata.getString(

                        RadioMetadata.METADATA_KEY_DAB_COMPONENT_NAME_SHORT))

                .isEqualTo(dabComponentNameShortValue);

    }



    @Test

    public void radioMetadataFromHalMetadata_withHdMedatadataAndFlagEnabled() {

        mSetFlagsRule.enableFlags(Flags.FLAG_HD_RADIO_IMPROVED);

        String genreValue = "genreTest";

        String commentShortDescriptionValue = "commentShortDescriptionTest";

        String commentActualTextValue = "commentActualTextTest";

        String commercialValue = "commercialTest";

        List<String> ufidsValue = List.of("ufids1Test", "ufids2Test");

        String hdStationNameShortValue = "hdStationNameShortTest";

        String hdStationNameLongValue = "hdStationNameLongTest";

        RadioMetadata convertedMetadata = ConversionUtils.radioMetadataFromHalMetadata(

                new Metadata[]{TEST_HAL_HD_SUBCHANNELS, Metadata.genre(genreValue),

                        Metadata.commentShortDescription(commentShortDescriptionValue),

                        Metadata.commentActualText(commentActualTextValue),

                        Metadata.commercial(commercialValue),

                        Metadata.ufids(ufidsValue.toArray(new String[0])),

                        Metadata.hdStationNameShort(hdStationNameShortValue),

                        Metadata.hdStationNameLong(hdStationNameLongValue)});



        expect.withMessage("Genre with flag enabled")

                .that(convertedMetadata.getString(RadioMetadata.METADATA_KEY_GENRE))

                .isEqualTo(genreValue);

        expect.withMessage("Short description of comment with flag enabled")

                .that(convertedMetadata.getString(

                        RadioMetadata.METADATA_KEY_COMMENT_SHORT_DESCRIPTION))

                .isEqualTo(commentShortDescriptionValue);

        expect.withMessage("Actual text of comment with flag enabled")

                .that(convertedMetadata.getString(RadioMetadata.METADATA_KEY_COMMENT_ACTUAL_TEXT))

                .isEqualTo(commentActualTextValue);

        expect.withMessage("Commercial with flag enabled")

                .that(convertedMetadata.getString(RadioMetadata.METADATA_KEY_COMMERCIAL))

                .isEqualTo(commercialValue);

        expect.withMessage("UFIDs with flag enabled")

                .that(convertedMetadata.getStringArray(RadioMetadata.METADATA_KEY_UFIDS)).asList()

                .containsExactlyElementsIn(ufidsValue);

        expect.withMessage("HD station short name with flag enabled")

                .that(convertedMetadata.getString(RadioMetadata.METADATA_KEY_HD_STATION_NAME_SHORT))

                .isEqualTo(hdStationNameShortValue);

        expect.withMessage("HD station long name with flag enabled")

                .that(convertedMetadata.getString(RadioMetadata.METADATA_KEY_HD_STATION_NAME_LONG))

                .isEqualTo(hdStationNameLongValue);

        expect.withMessage("HD sub-channels with flag enabled")

                .that(convertedMetadata.getInt(RadioMetadata

                        .METADATA_KEY_HD_SUBCHANNELS_AVAILABLE)).isEqualTo(TEST_HD_SUBCHANNELS);
@@ -742,6 +917,35 @@ public final class ConversionUtilsTest extends ExtendedRadioMockitoTestCase { 
                        ConversionUtils.identifierToHalProgramIdentifier(TEST_DAB_SID_EXT_ID));

    }



    @Test

    public void vendorInfoToHalVendorKeyValues_withNull() {

        expect.withMessage("Null vendor info converted to HAL")

                .that(ConversionUtils.vendorInfoToHalVendorKeyValues(/* info= */ null)).asList()

                .isEmpty();

    }



    @Test

    public void vendorInfoToHalVendorKeyValues_withNullValue() {

        Map<String, String> vendorInfo = new ArrayMap<>();

        vendorInfo.put(VENDOR_INFO_KEY_1, null);



        expect.withMessage("Vendor info with null value converted to HAL")

                .that(ConversionUtils.vendorInfoToHalVendorKeyValues(vendorInfo)).asList()

                .isEmpty();

    }



    @Test

    public void vendorInfoFromHalVendorKeyValues_withNullElements() {

        VendorKeyValue halVendorInfo = new VendorKeyValue();

        halVendorInfo.key = null;

        halVendorInfo.value = VENDOR_INFO_VALUE_1;

        VendorKeyValue[] halVendorInfoArray = new VendorKeyValue[]{halVendorInfo};



        expect.withMessage("Null vendor info converted from HAL")

                .that(ConversionUtils.vendorInfoFromHalVendorKeyValues(halVendorInfoArray))

                .isEmpty();

    }



    private static RadioManager.ModuleProperties createModuleProperties() {

        AmFmRegionConfig amFmConfig = createAmFmRegionConfig();

        DabTableEntry[] dabTableEntries = new DabTableEntry[]{
@@ -785,7 +989,8 @@ public final class ConversionUtilsTest extends ExtendedRadioMockitoTestCase { 
    private static Properties createHalProperties() {

        Properties halProperties = new Properties();

        halProperties.supportedIdentifierTypes = new int[]{IdentifierType.AMFM_FREQUENCY_KHZ,

                IdentifierType.RDS_PI, IdentifierType.DAB_SID_EXT};

                IdentifierType.RDS_PI, IdentifierType.DAB_SID_EXT, IdentifierType.HD_STATION_ID_EXT,

                IdentifierType.DRMO_SERVICE_ID};

        halProperties.maker = TEST_MAKER;

        halProperties.product = TEST_PRODUCT;

        halProperties.version = TEST_VERSION;

core/tests/BroadcastRadioTests/src/com/android/server/broadcastradio/aidl/TunerSessionTest.java

+27 −0
Original line number Diff line number Diff line
@@ -50,6 +50,7 @@ import android.hardware.radio.RadioManager; 
import android.hardware.radio.RadioTuner;

import android.hardware.radio.UniqueProgramIdentifier;

import android.os.Binder;

import android.os.DeadObjectException;

import android.os.ParcelableException;

import android.os.RemoteException;

import android.os.ServiceSpecificException;
@@ -307,6 +308,20 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase { 
                .that(mTunerSessions[0].isClosed()).isTrue();

    }



    @Test

    public void close_forMultipleTimes() throws Exception {

        openAidlClients(/* numClients= */ 1);

        int errorCode = RadioTuner.ERROR_SERVER_DIED;

        mTunerSessions[0].close(errorCode);

        verify(mAidlTunerCallbackMocks[0], CALLBACK_TIMEOUT).onError(errorCode);



        mTunerSessions[0].close(errorCode);



        verify(mAidlTunerCallbackMocks[0], CALLBACK_TIMEOUT).onError(errorCode);

        expect.withMessage("Close state of broadcast radio service session for multiple times")

                .that(mTunerSessions[0].isClosed()).isTrue();

    }



    @Test

    public void closeSessions_withMultipleSessions_withError() throws Exception {

        int numSessions = 3;
@@ -365,6 +380,18 @@ public final class TunerSessionTest extends ExtendedRadioMockitoTestCase { 
        }

    }



    @Test

    public void tune_withDeadTunerCallback_removesDeadSession() throws Exception {

        openAidlClients(/* numClients= */ 1);

        ProgramSelector sel = AidlTestUtils.makeFmSelector(AM_FM_FREQUENCY_LIST[1]);

        doThrow(new DeadObjectException()).when(mAidlTunerCallbackMocks[0])

                .onCurrentProgramInfoChanged(any());



        mTunerSessions[0].tune(sel);



        verify(mBroadcastRadioMock, CALLBACK_TIMEOUT).unsetTunerCallback();

    }



    @Test

    public void tune_withUnsupportedSelector_throwsException() throws Exception {

        openAidlClients(/* numClients= */ 1);

core/tests/BroadcastRadioTests/src/com/android/server/broadcastradio/hal2/ConvertTest.java

+88 −1

File changed.

Preview size limit exceeded, changes collapsed.