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

Commit 2bf843fb authored by Brad Ebinger's avatar Brad Ebinger
Browse files

Move IMS tests back to opt/net/ims 

These classes are defined in opt/net/ims, so it makes sense
to move them there organizationally.

Test: atest FrameworksTelephonyTests
Merged-In: I0e6e4ef4fb2d2042c317f8f7f8416cafa53ca6c6
Change-Id: I0e6e4ef4fb2d2042c317f8f7f8416cafa53ca6c6
parent 1dfcdf39

tests/telephonytests/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -25,7 +25,6 @@ android_test { 
        "testables",

    ],



    platform_apis: true,

    jarjar_rules: ":jarjar-rules-telephony-tests",



    test_suites: [

tests/telephonytests/src/com/android/internal/telephony/ims/FeatureConnectionTest.java

deleted100644 → 0
+0 −220
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package com.android.internal.telephony.ims;



import junit.framework.AssertionFailedError;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertTrue;

import static org.mockito.ArgumentMatchers.anyInt;

import static org.mockito.Mockito.doReturn;

import static org.mockito.Mockito.when;



import android.content.Context;

import android.content.pm.PackageManager;

import android.os.IBinder;

import android.os.RemoteException;

import android.telephony.ims.aidl.IImsRegistration;

import android.telephony.ims.feature.ImsFeature;

import android.telephony.ims.stub.ImsRegistrationImplBase;

import android.test.suitebuilder.annotation.SmallTest;



import com.android.ims.FeatureConnection;

import com.android.ims.ImsManager;

import com.android.ims.internal.IImsServiceFeatureCallback;

import com.android.internal.telephony.TelephonyTest;



import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import org.mockito.Mock;



import java.util.concurrent.Executor;



public class FeatureConnectionTest extends TelephonyTest {



    private Executor mSimpleExecutor = new Executor() {

        @Override

        public void execute(Runnable r) {

            r.run();

        }

    };



    private class TestFeatureConnection extends FeatureConnection {

        private Integer mFeatureState = ImsFeature.STATE_READY;



        public boolean isFeatureCreatedCalled = false;

        public boolean isFeatureRemovedCalled = false;

        public int mNewStatus = ImsFeature.STATE_UNAVAILABLE;



        TestFeatureConnection(Context context, int slotId) {

            super(context, slotId);

            if (!ImsManager.isImsSupportedOnDevice(context)) {

                sImsSupportedOnDevice = false;

            }

        }



        @Override

        public void checkServiceIsReady() throws RemoteException {

            super.checkServiceIsReady();

        }



        @Override

        protected void handleImsFeatureCreatedCallback(int slotId, int feature) {

            isFeatureCreatedCalled = true;

        }



        @Override

        protected void handleImsFeatureRemovedCallback(int slotId, int feature) {

            isFeatureRemovedCalled = true;

        }



        @Override

        protected void handleImsStatusChangedCallback(int slotId, int feature, int status) {

            mNewStatus = status;

        }



        @Override

        protected Integer retrieveFeatureState() {

            return mFeatureState;

        }



        @Override

        protected IImsRegistration getRegistrationBinder() {

            return getTestRegistrationBinder();

        }



        public void setFeatureState(int state) {

            mFeatureState = state;

        }

    };



    private int mPhoneId;

    private TestFeatureConnection mTestFeatureConnection;

    @Mock IBinder mBinder;

    @Mock IImsRegistration mRegistrationBinder;



    @Before

    public void setUp() throws Exception {

        super.setUp("FeatureConnectionTest");

        mPhoneId = mPhone.getPhoneId();



        doReturn(null).when(mContext).getMainLooper();

        doReturn(true).when(mPackageManager).hasSystemFeature(PackageManager.FEATURE_TELEPHONY_IMS);



        mTestFeatureConnection = new TestFeatureConnection(mContext, mPhoneId);

        mTestFeatureConnection.mExecutor = mSimpleExecutor;

        mTestFeatureConnection.setBinder(mBinder);

    }



    @After

    public void tearDown() throws Exception {

        super.tearDown();

    }



    /**

     * Test service is ready when binder is alive and IMS status is ready.

     */

    @Test

    @SmallTest

    public void testServiceIsReady() {

        when(mBinder.isBinderAlive()).thenReturn(true);

        mTestFeatureConnection.setFeatureState(ImsFeature.STATE_READY);



        try {

            mTestFeatureConnection.checkServiceIsReady();

        } catch (RemoteException e) {

            throw new AssertionFailedError("Exception in testServiceIsReady: " + e);

        }

    }



    /**

     * Test service is not ready when binder is not alive or status is not ready.

     */

    @Test

    @SmallTest

    public void testServiceIsNotReady() {

        // Binder is not alive

        when(mBinder.isBinderAlive()).thenReturn(false);



        try {

            mTestFeatureConnection.checkServiceIsReady();

            throw new AssertionFailedError("testServiceIsNotReady: binder isn't alive");

        } catch (RemoteException e) {

            // expected result

        }



        // IMS feature status is unavailable

        when(mBinder.isBinderAlive()).thenReturn(true);

        mTestFeatureConnection.setFeatureState(ImsFeature.STATE_UNAVAILABLE);



        try {

            mTestFeatureConnection.checkServiceIsReady();

            throw new AssertionFailedError("testServiceIsNotReady: status unavailable");

        } catch (RemoteException e) {

            // expected result

        }

    }



    /**

     * Test registration tech callbacks.

     */

    @Test

    @SmallTest

    public void testRegistrationTech() throws Exception {

        when(mRegistrationBinder.getRegistrationTechnology()).thenReturn(

                ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN);



        assertEquals(ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN,

                mTestFeatureConnection.getRegistrationTech());



    }



    /**

     * Test callback is called when IMS feature created/removed/changed.

     */

    @Test

    @SmallTest

    public void testListenerCallback() {

        IImsServiceFeatureCallback featureCallback = mTestFeatureConnection.getListener();



        try {

            featureCallback.imsFeatureCreated(anyInt(), anyInt());

            assertTrue(mTestFeatureConnection.isFeatureCreatedCalled);

        } catch (RemoteException e) {

            throw new AssertionFailedError("testListenerCallback(Created): " + e);

        }



        try {

            featureCallback.imsFeatureRemoved(anyInt(), anyInt());

            assertTrue(mTestFeatureConnection.isFeatureRemovedCalled);

        } catch (RemoteException e) {

            throw new AssertionFailedError("testListenerCallback(Removed): " + e);

        }



        try {

            featureCallback.imsStatusChanged(anyInt(), anyInt(), ImsFeature.STATE_READY);

            assertEquals(mTestFeatureConnection.mNewStatus, ImsFeature.STATE_READY);

        } catch (RemoteException e) {

            throw new AssertionFailedError("testListenerCallback(Changed): " + e);

        }

    }



    private IImsRegistration getTestRegistrationBinder() {

        return mRegistrationBinder;

    }

}

tests/telephonytests/src/com/android/internal/telephony/ims/FeatureConnectorTest.java

deleted100644 → 0
+0 −155
Original line number Diff line number Diff line 
/*

 * Copyright 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package com.android.internal.telephony.ims;



import junit.framework.AssertionFailedError;



import static org.mockito.ArgumentMatchers.anyObject;

import static org.mockito.Mockito.doReturn;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.reset;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;



import android.content.pm.PackageManager;

import android.os.HandlerThread;

import android.os.Looper;

import android.telephony.ims.feature.ImsFeature;

import android.test.suitebuilder.annotation.SmallTest;



import com.android.ims.FeatureConnector;

import com.android.ims.ImsException;

import com.android.ims.ImsManager;

import com.android.internal.telephony.TelephonyTest;



import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import org.mockito.Mock;



import java.util.concurrent.Executor;



public class FeatureConnectorTest extends TelephonyTest {



    private Executor mExecutor = new Executor() {

        @Override

        public void execute(Runnable r) {

            r.run();

        }

    };



    private HandlerThread mHandlerThread;

    private FeatureConnector<ImsManager> mFeatureConnector;

    @Mock

    ImsManager mImsManager;

    @Mock

    FeatureConnector.Listener<ImsManager> mListener;

    @Mock

    FeatureConnector.RetryTimeout mRetryTimeout;



    @Before

    public void setUp() throws Exception {

        super.setUp("FeatureConnectorTest");

        if (Looper.myLooper() == null) {

            Looper.prepare();

        }



        int phoneId = mPhone.getPhoneId();

        mHandlerThread = new HandlerThread("ConnectorHandlerThread");

        mHandlerThread.start();



        mFeatureConnector = new FeatureConnector<>(mContext, phoneId,

            mListener, mExecutor, mHandlerThread.getLooper());

        mFeatureConnector.mListener = mListener;

    }



    @After

    public void tearDown() throws Exception {

        mHandlerThread.quit();

        super.tearDown();

    }



    @Test

    @SmallTest

    public void testConnect() {

        // ImsManager is supported on device

        setImsSupportedFeature(true);

        when(mListener.getFeatureManager()).thenReturn(mImsManager);



        mFeatureConnector.connect();

        waitForHandlerAction(mFeatureConnector, 1000);



        // Verify that mListener will retrieve feature manager

        verify(mListener).getFeatureManager();



        reset(mListener);



        // ImsManager is NOT supported on device

        setImsSupportedFeature(false);

        when(mListener.getFeatureManager()).thenReturn(mImsManager);



        mFeatureConnector.connect();

        waitForHandlerAction(mFeatureConnector, 1000);



        // Verify that mListener won't retrieve feature manager

        verify(mListener, never()).getFeatureManager();

    }



    @Test

    @SmallTest

    public void testDisconnect() {

        // Verify mListener will call connectionUnavailable if disconnect() is called.

        mFeatureConnector.disconnect();

        verify(mListener).connectionUnavailable();

    }



    @Test

    @SmallTest

    public void testNotifyStateChanged() {

        try {

            mFeatureConnector.mManager = mImsManager;

            when(mImsManager.getImsServiceState()).thenReturn(ImsFeature.STATE_READY);

            // Trigger status changed

            mFeatureConnector.mNotifyStatusChangedCallback.notifyStateChanged();

            // Verify NotifyReady is called

            verify(mListener).connectionReady(anyObject());

        } catch (ImsException e) {

            throw new AssertionFailedError("Exception in testNotifyStateChanged: " + e);

        }

    }



    @Test

    @SmallTest

    public void testRetryGetImsService() {

        mFeatureConnector.mManager = mImsManager;

        mFeatureConnector.mRetryTimeout = mRetryTimeout;



        when(mRetryTimeout.get()).thenReturn(1);

        when(mListener.getFeatureManager()).thenReturn(mImsManager);



        mFeatureConnector.retryGetImsService();

        waitForHandlerAction(mFeatureConnector, 2000);



        // Verify removeNotifyStatusChangedCallback will be called if ImsManager is not null.

        verify(mImsManager).removeNotifyStatusChangedCallback(anyObject());

    }



    private void setImsSupportedFeature(boolean isSupported) {

        doReturn(isSupported).when(mPackageManager).hasSystemFeature(

                PackageManager.FEATURE_TELEPHONY_IMS);

    }

}

tests/telephonytests/src/com/android/internal/telephony/ims/ImsManagerTest.java

deleted100644 → 0
+0 −899

File deleted.

Preview size limit exceeded, changes collapsed.

tests/telephonytests/src/com/android/internal/telephony/ims/ImsUtTest.java

deleted100644 → 0
+0 −153
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package com.android.internal.telephony.ims;



import static junit.framework.Assert.assertEquals;

import static junit.framework.Assert.assertNotNull;

import static junit.framework.TestCase.fail;



import static org.mockito.Mockito.doReturn;

import static org.mockito.Mockito.verify;



import android.os.AsyncResult;

import android.os.Bundle;

import android.os.Handler;

import android.os.Looper;

import android.os.Message;

import android.telephony.ims.ImsSsInfo;

import android.telephony.ims.ImsUtListener;

import android.testing.AndroidTestingRunner;

import android.testing.TestableLooper;



import androidx.test.filters.SmallTest;



import com.android.ims.ImsUt;

import com.android.ims.internal.IImsUt;

import com.android.internal.telephony.TelephonyTest;



import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.ArgumentCaptor;

import org.mockito.Mock;



import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.TimeUnit;



@RunWith(AndroidTestingRunner.class)

@TestableLooper.RunWithLooper

public class ImsUtTest extends TelephonyTest {



    private static final int MSG_QUERY = 1;

    private static final int TEST_TIMEOUT_MS = 5000;



    private class TestHandler extends Handler {



        TestHandler(Looper looper) {

            super(looper);

        }



        private final LinkedBlockingQueue<ImsSsInfo> mPendingSsInfos = new LinkedBlockingQueue<>(1);

        @Override

        public void handleMessage(Message msg) {

            if (msg.what == MSG_QUERY) {

                AsyncResult ar = (AsyncResult) msg.obj;

                mPendingSsInfos.offer((ImsSsInfo) ar.result);

            }

        }

        public ImsSsInfo getPendingImsSsInfo() {

            try {

                return mPendingSsInfos.poll(TEST_TIMEOUT_MS, TimeUnit.MILLISECONDS);

            } catch (InterruptedException e) {

                fail("test interrupted!");

            }

            return null;

        }

    }



    @Mock IImsUt mImsUtBinder;



    private TestHandler mHandler;



    @Before

    public void setUp() throws Exception {

        super.setUp("ImsUtTest");

        mHandler = new TestHandler(Looper.myLooper());

        processAllMessages();

    }



    @After

    public void tearDown() throws Exception {

        super.tearDown();

    }



    @Test

    @SmallTest

    public void testClirConversionCompat() throws Exception {

        ArgumentCaptor<ImsUt.IImsUtListenerProxy> captor =

                ArgumentCaptor.forClass(ImsUt.IImsUtListenerProxy.class);

        ImsUt mImsUt = new ImsUt(mImsUtBinder);

        verify(mImsUtBinder).setListener(captor.capture());

        ImsUt.IImsUtListenerProxy proxy = captor.getValue();

        assertNotNull(proxy);



        doReturn(2).when(mImsUtBinder).queryCLIR();

        mImsUt.queryCLIR(Message.obtain(mHandler, MSG_QUERY));



        Bundle result = new Bundle();

        result.putIntArray(ImsUtListener.BUNDLE_KEY_CLIR, new int[] {

                ImsSsInfo.CLIR_OUTGOING_INVOCATION, ImsSsInfo.CLIR_STATUS_PROVISIONED_PERMANENT});

        // This is deprecated, will be converted from Bundle -> ImsSsInfo

        proxy.utConfigurationQueried(null, 2 /*id*/, result);

        processAllMessages();





        ImsSsInfo info = mHandler.getPendingImsSsInfo();

        assertNotNull(info);

        assertEquals(ImsSsInfo.CLIR_OUTGOING_INVOCATION, info.getClirOutgoingState());

        assertEquals(ImsSsInfo.CLIR_STATUS_PROVISIONED_PERMANENT,

                info.getClirInterrogationStatus());

    }



    @Test

    @SmallTest

    public void testClipConversionCompat() throws Exception {

        ArgumentCaptor<ImsUt.IImsUtListenerProxy> captor =

                ArgumentCaptor.forClass(ImsUt.IImsUtListenerProxy.class);

        ImsUt mImsUt = new ImsUt(mImsUtBinder);

        verify(mImsUtBinder).setListener(captor.capture());

        ImsUt.IImsUtListenerProxy proxy = captor.getValue();

        assertNotNull(proxy);



        doReturn(2).when(mImsUtBinder).queryCLIP();

        mImsUt.queryCLIP(Message.obtain(mHandler, MSG_QUERY));



        ImsSsInfo info = new ImsSsInfo.Builder(ImsSsInfo.ENABLED).setProvisionStatus(

                ImsSsInfo.CLIR_STATUS_PROVISIONED_PERMANENT).build();

        Bundle result = new Bundle();

        result.putParcelable(ImsUtListener.BUNDLE_KEY_SSINFO, info);

        // This is deprecated, will be converted from Bundle -> ImsSsInfo

        proxy.utConfigurationQueried(null, 2 /*id*/, result);

        processAllMessages();



        ImsSsInfo resultInfo = mHandler.getPendingImsSsInfo();

        assertNotNull(resultInfo);

        assertEquals(info.getStatus(), resultInfo.getStatus());

        assertEquals(info.getProvisionStatus(), resultInfo.getProvisionStatus());

    }

}