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

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

Merge "Add unit test for ProgramSelector"

parents e16dbabf 84858f04
Loading
Loading
Loading
Loading
+407 −0
Original line number Diff line number Diff line
/*
 * Copyright (C) 2022 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 android.hardware.radio.tests.unittests;

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

import static org.junit.Assert.assertThrows;

import android.annotation.Nullable;
import android.hardware.radio.ProgramSelector;
import android.hardware.radio.RadioManager;

import org.junit.Test;

public final class ProgramSelectorTest {

    private static final int FM_PROGRAM_TYPE = ProgramSelector.PROGRAM_TYPE_FM;
    private static final int DAB_PROGRAM_TYPE = ProgramSelector.PROGRAM_TYPE_DAB;
    private static final long FM_FREQUENCY = 88500;
    private static final long AM_FREQUENCY = 700;
    private static final ProgramSelector.Identifier FM_IDENTIFIER = new ProgramSelector.Identifier(
            ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY, FM_FREQUENCY);
    private static final ProgramSelector.Identifier DAB_SID_EXT_IDENTIFIER_1 =
            new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_DAB_SID_EXT,
                    /* value= */ 0x1000011);
    private static final ProgramSelector.Identifier DAB_SID_EXT_IDENTIFIER_2 =
            new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_DAB_SID_EXT,
                    /* value= */ 0x10000112);
    private static final ProgramSelector.Identifier DAB_ENSEMBLE_IDENTIFIER =
            new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_DAB_ENSEMBLE,
                    /* value= */ 0x1001);
    private static final ProgramSelector.Identifier DAB_FREQUENCY_IDENTIFIER =
            new ProgramSelector.Identifier(ProgramSelector.IDENTIFIER_TYPE_DAB_FREQUENCY,
                    /* value= */ 94500);

    @Test
    public void getType_forIdentifier() {
        assertWithMessage("Identifier type").that(FM_IDENTIFIER.getType())
                .isEqualTo(ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY);
    }

    @Test
    public void isCategoryType_withCategoryTypeForIdentifier() {
        int typeChecked = ProgramSelector.IDENTIFIER_TYPE_VENDOR_START + 1;
        ProgramSelector.Identifier fmIdentifier = new ProgramSelector.Identifier(
                typeChecked, /* value= */ 99901);

        assertWithMessage("Whether %s is a category identifier type", typeChecked)
                .that(fmIdentifier.isCategoryType()).isTrue();
    }

    @Test
    public void isCategoryType_withNonCategoryTypeForIdentifier() {
        assertWithMessage("Is AMFM_FREQUENCY category identifier type")
                .that(FM_IDENTIFIER.isCategoryType()).isFalse();
    }

    @Test
    public void getValue_forIdentifier() {
        assertWithMessage("Identifier value")
                .that(FM_IDENTIFIER.getValue()).isEqualTo(FM_FREQUENCY);
    }

    @Test
    public void equals_withDifferentTypesForIdentifiers_returnsFalse() {
        assertWithMessage("Identifier with different identifier type")
                .that(FM_IDENTIFIER).isNotEqualTo(DAB_SID_EXT_IDENTIFIER_1);
    }

    @Test
    public void equals_withDifferentValuesForIdentifiers_returnsFalse() {
        assertWithMessage("Identifier with different identifier value")
                .that(DAB_SID_EXT_IDENTIFIER_2).isNotEqualTo(DAB_SID_EXT_IDENTIFIER_1);
    }

    @Test
    public void equals_withSameKeyAndValueForIdentifiers_returnsTrue() {
        ProgramSelector.Identifier fmIdentifierSame = new ProgramSelector.Identifier(
                ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY, FM_FREQUENCY);

        assertWithMessage("Identifier of the same identifier")
                .that(FM_IDENTIFIER).isEqualTo(fmIdentifierSame);
    }

    @Test
    public void getProgramType() {
        ProgramSelector selector = getFmSelector(/* secondaryIds= */ null, /* vendorIds= */ null);

        int programType = selector.getProgramType();

        assertWithMessage("Program type").that(programType).isEqualTo(FM_PROGRAM_TYPE);
    }

    @Test
    public void getPrimaryId() {
        ProgramSelector selector = getFmSelector(/* secondaryIds= */ null, /* vendorIds= */ null);

        ProgramSelector.Identifier programId = selector.getPrimaryId();

        assertWithMessage("Program Id").that(programId).isEqualTo(FM_IDENTIFIER);
    }

    @Test
    public void getSecondaryIds_withEmptySecondaryIds() {
        ProgramSelector selector = getFmSelector(/* secondaryIds= */ null, /* vendorIds= */ null);

        ProgramSelector.Identifier[] secondaryIds = selector.getSecondaryIds();

        assertWithMessage("Secondary ids of selector initialized with empty secondary ids")
                .that(secondaryIds).isEmpty();
    }

    @Test
    public void getSecondaryIds_withNonEmptySecondaryIds() {
        ProgramSelector.Identifier[] secondaryIdsExpected = new ProgramSelector.Identifier[]{
                DAB_ENSEMBLE_IDENTIFIER, DAB_FREQUENCY_IDENTIFIER};
        ProgramSelector selector = getDabSelector(secondaryIdsExpected, /* vendorIds= */ null);

        ProgramSelector.Identifier[] secondaryIds = selector.getSecondaryIds();

        assertWithMessage("Secondary identifier got")
                .that(secondaryIds).isEqualTo(secondaryIdsExpected);
    }

    @Test
    public void getFirstId_withIdInSelector() {
        ProgramSelector.Identifier[] secondaryIds = new ProgramSelector.Identifier[]{
                DAB_ENSEMBLE_IDENTIFIER, DAB_SID_EXT_IDENTIFIER_2, DAB_FREQUENCY_IDENTIFIER};
        ProgramSelector selector = getDabSelector(secondaryIds, /* vendorIds= */ null);

        long firstIdValue = selector.getFirstId(ProgramSelector.IDENTIFIER_TYPE_DAB_SID_EXT);

        assertWithMessage("Value of the first DAB_SID_EXT identifier")
                .that(firstIdValue).isEqualTo(DAB_SID_EXT_IDENTIFIER_1.getValue());
    }

    @Test
    public void getFirstId_withIdNotInSelector() {
        ProgramSelector.Identifier[] secondaryIds = new ProgramSelector.Identifier[]{
                DAB_ENSEMBLE_IDENTIFIER, DAB_SID_EXT_IDENTIFIER_2};
        ProgramSelector selector = getDabSelector(secondaryIds, /* vendorIds= */ null);

        int idType = ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY;
        IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> {
            selector.getFirstId(idType);
        });

        assertWithMessage("Exception for getting first identifier %s", idType)
                .that(thrown).hasMessageThat().contains("Identifier " + idType + " not found");
    }

    @Test
    public void getAllIds_withIdInSelector() {
        ProgramSelector.Identifier[] secondaryIds = new ProgramSelector.Identifier[]{
                DAB_ENSEMBLE_IDENTIFIER, DAB_SID_EXT_IDENTIFIER_2, DAB_FREQUENCY_IDENTIFIER};
        ProgramSelector.Identifier[] allIdsExpected =
                {DAB_SID_EXT_IDENTIFIER_1, DAB_SID_EXT_IDENTIFIER_2};
        ProgramSelector selector = getDabSelector(secondaryIds, /* vendorIds= */ null);

        ProgramSelector.Identifier[] allIds =
                selector.getAllIds(ProgramSelector.IDENTIFIER_TYPE_DAB_SID_EXT);

        assertWithMessage("All DAB_SID_EXT identifiers in selector")
                .that(allIds).isEqualTo(allIdsExpected);
    }

    @Test
    public void getAllIds_withIdNotInSelector() {
        ProgramSelector.Identifier[] secondaryIds = new ProgramSelector.Identifier[]{
                DAB_ENSEMBLE_IDENTIFIER, DAB_FREQUENCY_IDENTIFIER};
        ProgramSelector selector = getDabSelector(secondaryIds, /* vendorIds= */ null);

        ProgramSelector.Identifier[] allIds =
                selector.getAllIds(ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY);

        assertWithMessage("AMFM frequency identifiers found in selector")
                .that(allIds).isEmpty();
    }

    @Test
    public void getVendorIds_withEmptyVendorIds() {
        ProgramSelector selector = getFmSelector(/* secondaryIds= */ null, /* vendorIds= */ null);

        long[] vendorIds = selector.getVendorIds();

        assertWithMessage("Vendor Ids of selector initialized with empty vendor ids")
                .that(vendorIds).isEmpty();
    }

    @Test
    public void getVendorIds_withNonEmptyVendorIds() {
        long[] vendorIdsExpected = {12345, 678};
        ProgramSelector selector = getFmSelector(/* secondaryIds= */ null, vendorIdsExpected);

        long[] vendorIds = selector.getVendorIds();

        assertWithMessage("Vendor Ids of selector initialized with non-empty vendor ids")
                .that(vendorIds).isEqualTo(vendorIdsExpected);
    }

    @Test
    public void withSecondaryPreferred() {
        ProgramSelector.Identifier[] secondaryIds = new ProgramSelector.Identifier[]{
                DAB_ENSEMBLE_IDENTIFIER, DAB_SID_EXT_IDENTIFIER_2, DAB_FREQUENCY_IDENTIFIER};
        long[] vendorIdsExpected = {12345, 678};
        ProgramSelector selector = getDabSelector(secondaryIds, vendorIdsExpected);
        ProgramSelector.Identifier[] secondaryIdsExpected = new ProgramSelector.Identifier[]{
                DAB_ENSEMBLE_IDENTIFIER, DAB_FREQUENCY_IDENTIFIER, DAB_SID_EXT_IDENTIFIER_1};

        ProgramSelector selectorPreferred =
                selector.withSecondaryPreferred(DAB_SID_EXT_IDENTIFIER_1);

        assertWithMessage("Program type")
                .that(selectorPreferred.getProgramType()).isEqualTo(selector.getProgramType());
        assertWithMessage("Primary identifiers")
                .that(selectorPreferred.getPrimaryId()).isEqualTo(selector.getPrimaryId());
        assertWithMessage("Secondary identifiers")
                .that(selectorPreferred.getSecondaryIds()).isEqualTo(secondaryIdsExpected);
        assertWithMessage("Vendor Ids")
                .that(selectorPreferred.getVendorIds()).isEqualTo(vendorIdsExpected);
    }

    @Test
    public void createAmFmSelector_withValidFrequencyWithoutSubChannel() {
        int band = RadioManager.BAND_AM;
        ProgramSelector.Identifier primaryIdExpected = new ProgramSelector.Identifier(
                ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY, AM_FREQUENCY);

        ProgramSelector selector = ProgramSelector.createAmFmSelector(band, (int) AM_FREQUENCY);

        assertWithMessage("Program type")
                .that(selector.getProgramType()).isEqualTo(ProgramSelector.PROGRAM_TYPE_AM);
        assertWithMessage("Primary identifiers")
                .that(selector.getPrimaryId()).isEqualTo(primaryIdExpected);
        assertWithMessage("Secondary identifiers")
                .that(selector.getSecondaryIds()).isEmpty();
    }

    @Test
    public void createAmFmSelector_withoutBandAndSubChannel() {
        ProgramSelector.Identifier primaryIdExpected = new ProgramSelector.Identifier(
                ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY, FM_FREQUENCY);

        ProgramSelector selector = ProgramSelector.createAmFmSelector(
                RadioManager.BAND_INVALID, (int) FM_FREQUENCY);

        assertWithMessage("Program type")
                .that(selector.getProgramType()).isEqualTo(ProgramSelector.PROGRAM_TYPE_FM);
        assertWithMessage("Primary identifiers")
                .that(selector.getPrimaryId()).isEqualTo(primaryIdExpected);
        assertWithMessage("Secondary identifiers")
                .that(selector.getSecondaryIds()).isEmpty();
    }

    @Test
    public void createAmFmSelector_withValidFrequencyAndSubChannel() {
        int band = RadioManager.BAND_AM_HD;
        int subChannel = 2;
        ProgramSelector.Identifier primaryIdExpected = new ProgramSelector.Identifier(
                ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY, AM_FREQUENCY);
        ProgramSelector.Identifier[] secondaryIdExpected = {
                new ProgramSelector.Identifier(
                        ProgramSelector.IDENTIFIER_TYPE_HD_SUBCHANNEL, subChannel - 1)
        };

        ProgramSelector selector = ProgramSelector.createAmFmSelector(band, (int) AM_FREQUENCY,
                subChannel);

        assertWithMessage("Program type")
                .that(selector.getProgramType()).isEqualTo(ProgramSelector.PROGRAM_TYPE_AM);
        assertWithMessage("Primary identifiers")
                .that(selector.getPrimaryId()).isEqualTo(primaryIdExpected);
        assertWithMessage("Secondary identifiers")
                .that(selector.getSecondaryIds()).isEqualTo(secondaryIdExpected);
    }

    @Test
    public void createAmFmSelector_withInvalidFrequency_throwsIllegalArgumentException() {
        int invalidFrequency = 50000;

        IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> {
            ProgramSelector.createAmFmSelector(RadioManager.BAND_AM, invalidFrequency);
        });

        assertWithMessage("Exception for using invalid frequency %s", invalidFrequency)
                .that(thrown).hasMessageThat().contains(
                "Provided value is not a valid AM/FM frequency: " + invalidFrequency);
    }

    @Test
    public void createAmFmSelector_withInvalidSubChannel_throwsIllegalArgumentException() {
        int invalidSubChannel = 9;

        IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> {
            ProgramSelector.createAmFmSelector(RadioManager.BAND_FM, (int) FM_FREQUENCY,
                    invalidSubChannel);
        });

        assertWithMessage("Exception for using invalid subchannel %s", invalidSubChannel)
                .that(thrown).hasMessageThat().contains(
                "Invalid subchannel: " + invalidSubChannel);
    }

    @Test
    public void createAmFmSelector_withSubChannelNotSupported_throwsIllegalArgumentException() {
        IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> {
            ProgramSelector.createAmFmSelector(RadioManager.BAND_FM, (int) FM_FREQUENCY,
                    /* subChannel= */ 1);
        });

        assertWithMessage("Exception for using sub-channel on radio not supporting it")
                .that(thrown)
                .hasMessageThat().contains("Subchannels are not supported for non-HD radio");
    }

    @Test
    public void equals_withDifferentSecondaryIds_returnTrue() {
        ProgramSelector.Identifier[] secondaryIds1 = new ProgramSelector.Identifier[]{
                DAB_ENSEMBLE_IDENTIFIER, DAB_FREQUENCY_IDENTIFIER};
        ProgramSelector selector1 = getDabSelector(secondaryIds1, /* vendorIds= */ null);
        ProgramSelector selector2 = getDabSelector(
                /* secondaryIds= */ null, /* vendorIds= */ null);

        assertWithMessage("Selector with different secondary id")
                .that(selector1).isEqualTo(selector2);
    }

    @Test
    public void equals_withDifferentPrimaryIds_returnFalse() {
        ProgramSelector selector1 = getFmSelector(
                /* secondaryIds= */ null, /* vendorIds= */ null);
        ProgramSelector.Identifier fmIdentifier2 = new ProgramSelector.Identifier(
                ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY, /* value= */ 88700);
        ProgramSelector selector2 = new ProgramSelector(FM_PROGRAM_TYPE, fmIdentifier2,
                /* secondaryIds= */ null, /* vendorIds= */ null);

        assertWithMessage("Selector with different primary id")
                .that(selector1).isNotEqualTo(selector2);
    }

    @Test
    public void strictEquals_withDifferentPrimaryIds_returnsFalse() {
        ProgramSelector selector1 = getFmSelector(
                /* secondaryIds= */ null, /* vendorIds= */ null);
        ProgramSelector.Identifier fmIdentifier2 = new ProgramSelector.Identifier(
                ProgramSelector.IDENTIFIER_TYPE_AMFM_FREQUENCY, /* value= */ 88700);
        ProgramSelector selector2 = new ProgramSelector(FM_PROGRAM_TYPE, fmIdentifier2,
                /* secondaryIds= */ null, /* vendorIds= */ null);

        assertWithMessage(
                "Whether two selectors with different primary ids are strictly equal")
                .that(selector1.strictEquals(selector2)).isFalse();
    }

    @Test
    public void strictEquals_withDifferentSecondaryIds_returnsFalse() {
        ProgramSelector.Identifier[] secondaryIds1 = new ProgramSelector.Identifier[]{
                DAB_ENSEMBLE_IDENTIFIER, DAB_FREQUENCY_IDENTIFIER};
        ProgramSelector selector1 = getDabSelector(secondaryIds1, /* vendorIds= */ null);
        ProgramSelector.Identifier[] secondaryIds2 = new ProgramSelector.Identifier[]{
                DAB_ENSEMBLE_IDENTIFIER};
        ProgramSelector selector2 = getDabSelector(secondaryIds2, /* vendorIds= */ null);

        assertWithMessage(
                "Whether two selectors with different secondary ids are strictly equal")
                .that(selector1.strictEquals(selector2)).isFalse();
    }

    @Test
    public void strictEquals_withDifferentSecondaryIdsOrders_returnsTrue() {
        ProgramSelector.Identifier[] secondaryIds1 = new ProgramSelector.Identifier[]{
                DAB_ENSEMBLE_IDENTIFIER, DAB_FREQUENCY_IDENTIFIER};
        ProgramSelector selector1 = getDabSelector(secondaryIds1, /* vendorIds= */ null);
        ProgramSelector.Identifier[] secondaryIds2 = new ProgramSelector.Identifier[]{
                DAB_FREQUENCY_IDENTIFIER, DAB_ENSEMBLE_IDENTIFIER};
        ProgramSelector selector2 = getDabSelector(secondaryIds2, /* vendorIds= */ null);

        assertWithMessage(
                "Whether two selectors with different secondary id orders are strictly equal")
                .that(selector1.strictEquals(selector2)).isTrue();
    }

    private ProgramSelector getFmSelector(@Nullable ProgramSelector.Identifier[] secondaryIds,
            @Nullable long[] vendorIds) {
        return new ProgramSelector(FM_PROGRAM_TYPE, FM_IDENTIFIER, secondaryIds, vendorIds);
    }

    private ProgramSelector getDabSelector(@Nullable ProgramSelector.Identifier[] secondaryIds,
            @Nullable long[] vendorIds) {
        return new ProgramSelector(DAB_PROGRAM_TYPE, DAB_SID_EXT_IDENTIFIER_1, secondaryIds,
                vendorIds);
    }
}