1a66bb5cf33417ba945d33457e81e2f1944de26c
[android/platform/frameworks/opt/telephony.git] / tests / telephonytests / src / com / android / internal / telephony / ImsSMSDispatcherTest.java
1 /*
2  * Copyright (C) 2016 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package com.android.internal.telephony;
18
19 import static com.android.internal.telephony.TelephonyTestUtils.waitForMs;
20
21 import static org.junit.Assert.assertEquals;
22 import static org.junit.Assert.assertNull;
23 import static org.junit.Assert.assertTrue;
24 import static org.mockito.Matchers.any;
25 import static org.mockito.Matchers.anyString;
26 import static org.mockito.Matchers.isNull;
27 import static org.mockito.Mockito.anyInt;
28 import static org.mockito.Mockito.doReturn;
29 import static org.mockito.Mockito.eq;
30 import static org.mockito.Mockito.times;
31 import static org.mockito.Mockito.verify;
32
33 import android.app.ActivityManager;
34 import android.app.PendingIntent;
35 import android.content.BroadcastReceiver;
36 import android.content.Context;
37 import android.content.Intent;
38 import android.content.IntentFilter;
39 import android.os.HandlerThread;
40 import android.os.Message;
41 import android.test.FlakyTest;
42 import android.test.suitebuilder.annotation.SmallTest;
43 import android.util.Singleton;
44
45 import org.junit.After;
46 import org.junit.Before;
47 import org.junit.Ignore;
48 import org.junit.Test;
49 import org.mockito.ArgumentCaptor;
50 import org.mockito.Mock;
51
52 public class ImsSMSDispatcherTest extends TelephonyTest {
53     @Mock
54     private SMSDispatcher.SmsTracker mTracker;
55
56     private ImsSMSDispatcher mImsSmsDispatcher;
57     private ImsSmsDispatcherTestHandler mImsSmsDispatcherTestHandler;
58     private boolean mReceivedTestIntent = false;
59     private Object mLock = new Object();
60     private static final String TEST_INTENT = "com.android.internal.telephony.TEST_INTENT";
61     private BroadcastReceiver mTestReceiver = new BroadcastReceiver() {
62         @Override
63         public void onReceive(Context context, Intent intent) {
64             logd("onReceive");
65             synchronized (mLock) {
66                 mReceivedTestIntent = true;
67             }
68         }
69     };
70
71     private class ImsSmsDispatcherTestHandler extends HandlerThread {
72
73         private ImsSmsDispatcherTestHandler(String name) {
74             super(name);
75         }
76
77         @Override
78         public void onLooperPrepared() {
79             mImsSmsDispatcher = new ImsSMSDispatcher(mPhone, mSmsStorageMonitor,
80                     mSmsUsageMonitor);
81             //Initial state of RIL is power on, need to wait util RADIO_ON msg get handled
82             waitForMs(200);
83             setReady(true);
84         }
85     }
86
87     @Before
88     public void setUp() throws Exception {
89         super.setUp(getClass().getSimpleName());
90         setupMockPackagePermissionChecks();
91
92         mImsSmsDispatcherTestHandler = new ImsSmsDispatcherTestHandler(getClass().getSimpleName());
93         mImsSmsDispatcherTestHandler.start();
94         waitUntilReady();
95     }
96
97     @After
98     public void tearDown() throws Exception {
99         mImsSmsDispatcher = null;
100         mImsSmsDispatcherTestHandler.quitSafely();
101         super.tearDown();
102     }
103
104     @Test @SmallTest @FlakyTest @Ignore
105     public void testSmsHandleStateUpdate() throws Exception {
106         assertEquals(SmsConstants.FORMAT_UNKNOWN, mImsSmsDispatcher.getImsSmsFormat());
107         //Mock ImsNetWorkStateChange with GSM phone type
108         switchImsSmsFormat(PhoneConstants.PHONE_TYPE_GSM);
109         assertEquals(SmsConstants.FORMAT_3GPP, mImsSmsDispatcher.getImsSmsFormat());
110         assertTrue(mImsSmsDispatcher.isIms());
111
112         //Mock ImsNetWorkStateChange with Cdma Phone type
113         switchImsSmsFormat(PhoneConstants.PHONE_TYPE_CDMA);
114         assertEquals(SmsConstants.FORMAT_3GPP2, mImsSmsDispatcher.getImsSmsFormat());
115         assertTrue(mImsSmsDispatcher.isIms());
116     }
117
118     @Test @SmallTest @FlakyTest @Ignore
119     public void testSendImsGmsTest() throws Exception {
120         switchImsSmsFormat(PhoneConstants.PHONE_TYPE_GSM);
121         mImsSmsDispatcher.sendText("111"/* desAddr*/, "222" /*scAddr*/, TAG,
122                 null, null, null, null, false);
123         verify(mSimulatedCommandsVerifier).sendImsGsmSms(eq("038122f2"),
124                 eq("0100038111f1000014c9f67cda9c12d37378983e4697e5d4f29c0e"), eq(0), eq(0),
125                 any(Message.class));
126     }
127
128     @Test @SmallTest
129     public void testSendImsGmsTestWithOutDesAddr() throws Exception {
130         switchImsSmsFormat(PhoneConstants.PHONE_TYPE_GSM);
131         mImsSmsDispatcher.sendText(null, "222" /*scAddr*/, TAG,
132                 null, null, null, null, false);
133         verify(mSimulatedCommandsVerifier, times(0)).sendImsGsmSms(anyString(), anyString(),
134                 anyInt(), anyInt(), any(Message.class));
135     }
136
137     @Test @SmallTest
138     public void testSendImsCdmaTest() throws Exception {
139         switchImsSmsFormat(PhoneConstants.PHONE_TYPE_CDMA);
140         mImsSmsDispatcher.sendText("111"/* desAddr*/, "222" /*scAddr*/, TAG,
141                 null, null, null, null, false);
142         verify(mSimulatedCommandsVerifier).sendImsCdmaSms((byte[])any(), eq(0), eq(0),
143                 any(Message.class));
144     }
145
146     @Test @SmallTest
147     public void testSendRetrySmsCdmaTest() throws Exception {
148         // newFormat will be based on voice technology
149         ArgumentCaptor<byte[]> captor = ArgumentCaptor.forClass(byte[].class);
150         switchImsSmsFormat(PhoneConstants.PHONE_TYPE_CDMA);
151         replaceInstance(SMSDispatcher.SmsTracker.class, "mFormat", mTracker,
152                 SmsConstants.FORMAT_3GPP2);
153         doReturn(PhoneConstants.PHONE_TYPE_CDMA).when(mPhone).getPhoneType();
154         mImsSmsDispatcher.sendRetrySms(mTracker);
155         verify(mSimulatedCommandsVerifier).sendImsCdmaSms(captor.capture(), eq(0), eq(0),
156                 any(Message.class));
157         assertEquals(1, captor.getAllValues().size());
158         assertNull(captor.getAllValues().get(0));
159     }
160
161     @Test @SmallTest
162     public void testSendRetrySmsGsmTest() throws Exception {
163         // newFormat will be based on voice technology will be GSM if phone type is not CDMA
164         switchImsSmsFormat(PhoneConstants.PHONE_TYPE_GSM);
165         replaceInstance(SMSDispatcher.SmsTracker.class, "mFormat", mTracker,
166                 SmsConstants.FORMAT_3GPP);
167         mImsSmsDispatcher.sendRetrySms(mTracker);
168         verify(mSimulatedCommandsVerifier).sendImsGsmSms((String)isNull(), (String)isNull(), eq(0),
169                 eq(0), any(Message.class));
170     }
171
172     @Test @SmallTest
173     public void testInjectNullSmsPdu() throws Exception {
174         // unmock ActivityManager to be able to register receiver, create real PendingIntent and
175         // receive TEST_INTENT
176         restoreInstance(Singleton.class, "mInstance", mIActivityManagerSingleton);
177         restoreInstance(ActivityManager.class, "IActivityManagerSingleton", null);
178
179         Context realContext = TestApplication.getAppContext();
180         realContext.registerReceiver(mTestReceiver, new IntentFilter(TEST_INTENT));
181
182         PendingIntent pendingIntent = PendingIntent.getBroadcast(realContext, 0,
183                 new Intent(TEST_INTENT), 0);
184
185         // inject null sms pdu. This should cause intent to be received since pdu is null.
186         mImsSmsDispatcher.injectSmsPdu(null, SmsConstants.FORMAT_3GPP, pendingIntent);
187         waitForMs(100);
188         synchronized (mLock) {
189             assertEquals(true, mReceivedTestIntent);
190         }
191     }
192
193     private void switchImsSmsFormat(int phoneType) {
194         mSimulatedCommands.setImsRegistrationState(new int[]{1, phoneType});
195         mSimulatedCommands.notifyImsNetworkStateChanged();
196         /* wait for async msg get handled */
197         waitForMs(200);
198     }
199 }