1 /* 2 * Copyright (C) 2017 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.settings.datausage; 18 19 import static com.google.common.truth.Truth.assertThat; 20 21 import static org.junit.Assert.assertTrue; 22 import static org.mockito.Mockito.RETURNS_DEEP_STUBS; 23 import static org.mockito.Mockito.any; 24 import static org.mockito.Mockito.anyBoolean; 25 import static org.mockito.Mockito.anyInt; 26 import static org.mockito.Mockito.anyString; 27 import static org.mockito.Mockito.doNothing; 28 import static org.mockito.Mockito.doReturn; 29 import static org.mockito.Mockito.eq; 30 import static org.mockito.Mockito.mock; 31 import static org.mockito.Mockito.spy; 32 import static org.mockito.Mockito.verify; 33 import static org.mockito.Mockito.when; 34 35 import android.content.Context; 36 import android.content.pm.ApplicationInfo; 37 import android.content.pm.PackageManager; 38 import android.content.pm.PackageManager.NameNotFoundException; 39 import android.net.NetworkPolicyManager; 40 import android.net.NetworkTemplate; 41 import android.os.Bundle; 42 import android.os.Process; 43 import android.telephony.SubscriptionManager; 44 import android.text.format.DateUtils; 45 import android.util.ArraySet; 46 47 import androidx.fragment.app.FragmentActivity; 48 import androidx.preference.Preference; 49 import androidx.preference.PreferenceManager; 50 import androidx.preference.PreferenceScreen; 51 import androidx.recyclerview.widget.RecyclerView; 52 53 import com.android.settings.applications.AppInfoBase; 54 import com.android.settings.testutils.FakeFeatureFactory; 55 import com.android.settings.testutils.shadow.ShadowDataUsageUtils; 56 import com.android.settings.testutils.shadow.ShadowEntityHeaderController; 57 import com.android.settings.testutils.shadow.ShadowFragment; 58 import com.android.settings.testutils.shadow.ShadowRestrictedLockUtilsInternal; 59 import com.android.settings.widget.EntityHeaderController; 60 import com.android.settingslib.AppItem; 61 import com.android.settingslib.RestrictedLockUtils.EnforcedAdmin; 62 import com.android.settingslib.RestrictedSwitchPreference; 63 import com.android.settingslib.net.NetworkCycleDataForUid; 64 import com.android.settingslib.net.NetworkCycleDataForUidLoader; 65 import com.android.settingslib.net.UidDetail; 66 import com.android.settingslib.net.UidDetailProvider; 67 68 import org.junit.After; 69 import org.junit.Before; 70 import org.junit.Test; 71 import org.junit.runner.RunWith; 72 import org.mockito.Answers; 73 import org.mockito.Mock; 74 import org.mockito.MockitoAnnotations; 75 import org.robolectric.Robolectric; 76 import org.robolectric.RobolectricTestRunner; 77 import org.robolectric.RuntimeEnvironment; 78 import org.robolectric.annotation.Config; 79 import org.robolectric.shadows.ShadowSubscriptionManager; 80 import org.robolectric.util.ReflectionHelpers; 81 82 import java.util.ArrayList; 83 import java.util.List; 84 85 @RunWith(RobolectricTestRunner.class) 86 @Config(shadows = {ShadowEntityHeaderController.class, ShadowRestrictedLockUtilsInternal.class}) 87 public class AppDataUsageTest { 88 89 @Mock(answer = Answers.RETURNS_DEEP_STUBS) 90 private EntityHeaderController mHeaderController; 91 @Mock 92 private PackageManager mPackageManager; 93 94 private AppDataUsage mFragment; 95 96 @Before setUp()97 public void setUp() { 98 MockitoAnnotations.initMocks(this); 99 100 ShadowEntityHeaderController.setUseMock(mHeaderController); 101 when(mHeaderController.setRecyclerView(any(), any())).thenReturn(mHeaderController); 102 when(mHeaderController.setUid(anyInt())).thenReturn(mHeaderController); 103 } 104 105 @After tearDown()106 public void tearDown() { 107 ShadowEntityHeaderController.reset(); 108 } 109 110 @Test 111 @Config(shadows = ShadowFragment.class) onCreate_appUid_shouldGetAppLabelFromAppInfo()112 public void onCreate_appUid_shouldGetAppLabelFromAppInfo() throws NameNotFoundException { 113 mFragment = spy(new AppDataUsage() { 114 @Override 115 public boolean isSimHardwareVisible(Context context) { return true; } 116 }); 117 final FragmentActivity activity = spy(Robolectric.setupActivity(FragmentActivity.class)); 118 doReturn(mPackageManager).when(activity).getPackageManager(); 119 doReturn(activity).when(mFragment).getActivity(); 120 doReturn(RuntimeEnvironment.application).when(mFragment).getContext(); 121 ReflectionHelpers.setField(mFragment, "mDashboardFeatureProvider", 122 FakeFeatureFactory.setupForTest().dashboardFeatureProvider); 123 final String packageName = "testPackage"; 124 final int uid = (Process.FIRST_APPLICATION_UID + Process.LAST_APPLICATION_UID) / 2; 125 doReturn(new String[]{packageName}).when(mPackageManager).getPackagesForUid(uid); 126 final String label = "testLabel"; 127 final AppItem appItem = new AppItem(uid); 128 appItem.uids.put(uid, true); 129 final ApplicationInfo info = spy(new ApplicationInfo()); 130 doReturn(label).when(info).loadLabel(mPackageManager); 131 when(mPackageManager.getApplicationInfoAsUser( 132 eq(packageName), anyInt() /* flags */, anyInt() /* userId */)).thenReturn(info); 133 final Bundle args = new Bundle(); 134 args.putParcelable(AppDataUsage.ARG_APP_ITEM, appItem); 135 args.putInt(AppInfoBase.ARG_PACKAGE_UID, uid); 136 mFragment.setArguments(args); 137 138 mFragment.onCreate(Bundle.EMPTY); 139 140 assertThat(mFragment.mLabel).isEqualTo(label); 141 } 142 143 @Test 144 @Config(shadows = ShadowFragment.class) onCreate_notAppUid_shouldGetAppLabelFromUidDetailProvider()145 public void onCreate_notAppUid_shouldGetAppLabelFromUidDetailProvider() { 146 mFragment = spy(new AppDataUsage() { 147 @Override 148 public boolean isSimHardwareVisible(Context context) { return true; } 149 }); 150 ReflectionHelpers.setField(mFragment, "mDashboardFeatureProvider", 151 FakeFeatureFactory.setupForTest().dashboardFeatureProvider); 152 doReturn(Robolectric.setupActivity(FragmentActivity.class)).when(mFragment).getActivity(); 153 doReturn(RuntimeEnvironment.application).when(mFragment).getContext(); 154 final UidDetailProvider uidDetailProvider = mock(UidDetailProvider.class); 155 doReturn(uidDetailProvider).when(mFragment).getUidDetailProvider(); 156 final String label = "testLabel"; 157 final int uid = Process.SYSTEM_UID; 158 final UidDetail uidDetail = new UidDetail(); 159 uidDetail.label = label; 160 when(uidDetailProvider.getUidDetail(eq(uid), anyBoolean() /* blocking */)). 161 thenReturn(uidDetail); 162 final AppItem appItem = new AppItem(uid); 163 appItem.uids.put(uid, true); 164 final Bundle args = new Bundle(); 165 args.putParcelable(AppDataUsage.ARG_APP_ITEM, appItem); 166 args.putInt(AppInfoBase.ARG_PACKAGE_UID, uid); 167 mFragment.setArguments(args); 168 169 mFragment.onCreate(Bundle.EMPTY); 170 171 assertThat(mFragment.mLabel).isEqualTo(label); 172 } 173 174 @Test bindAppHeader_allWorkApps_shouldNotShowAppInfoLink()175 public void bindAppHeader_allWorkApps_shouldNotShowAppInfoLink() { 176 mFragment = spy(new AppDataUsage() { 177 @Override 178 public boolean isSimHardwareVisible(Context context) { return true; } 179 }); 180 181 when(mFragment.getPreferenceManager()) 182 .thenReturn(mock(PreferenceManager.class, RETURNS_DEEP_STUBS)); 183 doReturn(mock(PreferenceScreen.class)).when(mFragment).getPreferenceScreen(); 184 ReflectionHelpers.setField(mFragment, "mAppItem", mock(AppItem.class)); 185 186 mFragment.addEntityHeader(); 187 188 verify(mHeaderController).setHasAppInfoLink(false); 189 } 190 191 @Test bindAppHeader_workApp_shouldSetWorkAppUid()192 public void bindAppHeader_workApp_shouldSetWorkAppUid() 193 throws PackageManager.NameNotFoundException { 194 final int fakeUserId = 100; 195 196 mFragment = spy(new AppDataUsage() { 197 @Override 198 public boolean isSimHardwareVisible(Context context) { return true; } 199 }); 200 final ArraySet<String> packages = new ArraySet<>(); 201 packages.add("pkg"); 202 final AppItem appItem = new AppItem(123456789); 203 204 ReflectionHelpers.setField(mFragment, "mPackageManager", mPackageManager); 205 ReflectionHelpers.setField(mFragment, "mAppItem", appItem); 206 ReflectionHelpers.setField(mFragment, "mPackages", packages); 207 208 when(mPackageManager.getPackageUidAsUser(anyString(), anyInt())) 209 .thenReturn(fakeUserId); 210 211 when(mHeaderController.setHasAppInfoLink(anyBoolean())).thenReturn(mHeaderController); 212 213 when(mFragment.getPreferenceManager()) 214 .thenReturn(mock(PreferenceManager.class, RETURNS_DEEP_STUBS)); 215 doReturn(mock(PreferenceScreen.class)).when(mFragment).getPreferenceScreen(); 216 217 mFragment.addEntityHeader(); 218 219 verify(mHeaderController).setHasAppInfoLink(true); 220 verify(mHeaderController).setUid(fakeUserId); 221 } 222 223 @Test changePreference_backgroundData_shouldUpdateUI()224 public void changePreference_backgroundData_shouldUpdateUI() { 225 mFragment = spy(new AppDataUsage() { 226 @Override 227 public boolean isSimHardwareVisible(Context context) { return true; } 228 }); 229 final AppItem appItem = new AppItem(123456789); 230 final RestrictedSwitchPreference pref = mock(RestrictedSwitchPreference.class); 231 final DataSaverBackend dataSaverBackend = mock(DataSaverBackend.class); 232 ReflectionHelpers.setField(mFragment, "mAppItem", appItem); 233 ReflectionHelpers.setField(mFragment, "mRestrictBackground", pref); 234 ReflectionHelpers.setField(mFragment, "mDataSaverBackend", dataSaverBackend); 235 236 doNothing().when(mFragment).updatePrefs(); 237 238 mFragment.onPreferenceChange(pref, true /* value */); 239 240 verify(mFragment).updatePrefs(); 241 } 242 243 @Test updatePrefs_restrictedByAdmin_shouldDisablePreference()244 public void updatePrefs_restrictedByAdmin_shouldDisablePreference() { 245 mFragment = spy(new AppDataUsage() { 246 @Override 247 public boolean isSimHardwareVisible(Context context) { return true; } 248 }); 249 final int testUid = 123123; 250 final AppItem appItem = new AppItem(testUid); 251 final RestrictedSwitchPreference restrictBackgroundPref 252 = mock(RestrictedSwitchPreference.class); 253 final RestrictedSwitchPreference unrestrictedDataPref 254 = mock(RestrictedSwitchPreference.class); 255 final DataSaverBackend dataSaverBackend = mock(DataSaverBackend.class); 256 final NetworkPolicyManager networkPolicyManager = mock(NetworkPolicyManager.class); 257 ReflectionHelpers.setField(mFragment, "mAppItem", appItem); 258 ReflectionHelpers.setField(mFragment, "mRestrictBackground", restrictBackgroundPref); 259 ReflectionHelpers.setField(mFragment, "mUnrestrictedData", unrestrictedDataPref); 260 ReflectionHelpers.setField(mFragment, "mDataSaverBackend", dataSaverBackend); 261 ReflectionHelpers.setField(mFragment.services, "mPolicyManager", networkPolicyManager); 262 when(mFragment.getListView()).thenReturn(mock(RecyclerView.class)); 263 264 ShadowRestrictedLockUtilsInternal.setRestricted(true); 265 doReturn(NetworkPolicyManager.POLICY_NONE).when(networkPolicyManager) 266 .getUidPolicy(testUid); 267 268 mFragment.updatePrefs(); 269 270 verify(restrictBackgroundPref).setDisabledByAdmin(any(EnforcedAdmin.class)); 271 verify(unrestrictedDataPref).setDisabledByAdmin(any(EnforcedAdmin.class)); 272 } 273 274 @Test bindData_noAppUsageData_shouldHideCycleSpinner()275 public void bindData_noAppUsageData_shouldHideCycleSpinner() { 276 mFragment = spy(new AppDataUsage() { 277 @Override 278 public boolean isSimHardwareVisible(Context context) { return true; } 279 }); 280 final SpinnerPreference cycle = mock(SpinnerPreference.class); 281 ReflectionHelpers.setField(mFragment, "mCycle", cycle); 282 final Preference preference = mock(Preference.class); 283 ReflectionHelpers.setField(mFragment, "mBackgroundUsage", preference); 284 ReflectionHelpers.setField(mFragment, "mForegroundUsage", preference); 285 ReflectionHelpers.setField(mFragment, "mTotalUsage", preference); 286 ReflectionHelpers.setField(mFragment, "mContext", RuntimeEnvironment.application); 287 288 mFragment.bindData(0 /* position */); 289 290 verify(cycle).setHasCycles(false); 291 } 292 293 @Test bindData_hasAppUsageData_shouldShowCycleSpinnerAndUpdateUsageSummary()294 public void bindData_hasAppUsageData_shouldShowCycleSpinnerAndUpdateUsageSummary() { 295 mFragment = spy(new AppDataUsage() { 296 @Override 297 public boolean isSimHardwareVisible(Context context) { return true; } 298 }); 299 final Context context = RuntimeEnvironment.application; 300 ReflectionHelpers.setField(mFragment, "mContext", context); 301 final long backgroundBytes = 1234L; 302 final long foregroundBytes = 5678L; 303 final List<NetworkCycleDataForUid> appUsage = new ArrayList<>(); 304 appUsage.add(new NetworkCycleDataForUid.Builder() 305 .setBackgroundUsage(backgroundBytes).setForegroundUsage(foregroundBytes).build()); 306 ReflectionHelpers.setField(mFragment, "mUsageData", appUsage); 307 final Preference backgroundPref = mock(Preference.class); 308 ReflectionHelpers.setField(mFragment, "mBackgroundUsage", backgroundPref); 309 final Preference foregroundPref = mock(Preference.class); 310 ReflectionHelpers.setField(mFragment, "mForegroundUsage", foregroundPref); 311 final Preference totalPref = mock(Preference.class); 312 ReflectionHelpers.setField(mFragment, "mTotalUsage", totalPref); 313 final SpinnerPreference cycle = mock(SpinnerPreference.class); 314 ReflectionHelpers.setField(mFragment, "mCycle", cycle); 315 316 mFragment.bindData(0 /* position */); 317 318 verify(cycle).setHasCycles(true); 319 verify(totalPref).setSummary( 320 DataUsageUtils.formatDataUsage(context, backgroundBytes + foregroundBytes)); 321 verify(backgroundPref).setSummary(DataUsageUtils.formatDataUsage(context, backgroundBytes)); 322 verify(foregroundPref).setSummary(DataUsageUtils.formatDataUsage(context, foregroundBytes)); 323 } 324 325 @Test onCreateLoader_categoryApp_shouldQueryDataUsageUsingAppKey()326 public void onCreateLoader_categoryApp_shouldQueryDataUsageUsingAppKey() { 327 mFragment = new AppDataUsage() { 328 @Override 329 public boolean isSimHardwareVisible(Context context) { return true; } 330 }; 331 final Context context = RuntimeEnvironment.application; 332 final int testUid = 123123; 333 final AppItem appItem = new AppItem(testUid); 334 appItem.addUid(testUid); 335 appItem.category = AppItem.CATEGORY_APP; 336 ReflectionHelpers.setField(mFragment, "mContext", context); 337 ReflectionHelpers.setField(mFragment, "mAppItem", appItem); 338 ReflectionHelpers.setField(mFragment, "mTemplate", 339 new NetworkTemplate.Builder(NetworkTemplate.MATCH_WIFI).build()); 340 final long end = System.currentTimeMillis(); 341 final long start = end - (DateUtils.WEEK_IN_MILLIS * 4); 342 343 final NetworkCycleDataForUidLoader loader = (NetworkCycleDataForUidLoader) 344 mFragment.mUidDataCallbacks.onCreateLoader(0, Bundle.EMPTY); 345 346 final List<Integer> uids = loader.getUids(); 347 assertThat(uids).hasSize(1); 348 assertThat(uids.get(0)).isEqualTo(testUid); 349 } 350 351 @Test onCreateLoader_categoryUser_shouldQueryDataUsageUsingAssociatedUids()352 public void onCreateLoader_categoryUser_shouldQueryDataUsageUsingAssociatedUids() { 353 mFragment = new AppDataUsage() { 354 @Override 355 public boolean isSimHardwareVisible(Context context) { return true; } 356 }; 357 final Context context = RuntimeEnvironment.application; 358 final int testUserId = 11; 359 final AppItem appItem = new AppItem(testUserId); 360 appItem.category = AppItem.CATEGORY_USER; 361 appItem.addUid(123); 362 appItem.addUid(456); 363 appItem.addUid(789); 364 ReflectionHelpers.setField(mFragment, "mContext", context); 365 ReflectionHelpers.setField(mFragment, "mAppItem", appItem); 366 ReflectionHelpers.setField(mFragment, "mTemplate", 367 new NetworkTemplate.Builder(NetworkTemplate.MATCH_WIFI).build()); 368 final long end = System.currentTimeMillis(); 369 final long start = end - (DateUtils.WEEK_IN_MILLIS * 4); 370 371 final NetworkCycleDataForUidLoader loader = (NetworkCycleDataForUidLoader) 372 mFragment.mUidDataCallbacks.onCreateLoader(0, Bundle.EMPTY); 373 374 final List<Integer> uids = loader.getUids(); 375 assertThat(uids).hasSize(3); 376 assertThat(uids.get(0)).isEqualTo(123); 377 assertThat(uids.get(1)).isEqualTo(456); 378 assertThat(uids.get(2)).isEqualTo(789); 379 } 380 381 @Test onCreateLoader_hasCyclesSpecified_shouldQueryDataUsageForSpecifiedCycles()382 public void onCreateLoader_hasCyclesSpecified_shouldQueryDataUsageForSpecifiedCycles() { 383 final long startTime = 1521583200000L; 384 final long endTime = 1521676800000L; 385 ArrayList<Long> testCycles = new ArrayList<>(); 386 testCycles.add(endTime); 387 testCycles.add(startTime); 388 final int uid = 123; 389 final AppItem appItem = new AppItem(uid); 390 appItem.category = AppItem.CATEGORY_APP; 391 appItem.addUid(uid); 392 393 mFragment = new AppDataUsage() { 394 @Override 395 public boolean isSimHardwareVisible(Context context) { return true; } 396 }; 397 ReflectionHelpers.setField(mFragment, "mContext", RuntimeEnvironment.application); 398 ReflectionHelpers.setField(mFragment, "mCycles", testCycles); 399 ReflectionHelpers.setField(mFragment, "mAppItem", appItem); 400 ReflectionHelpers.setField(mFragment, "mTemplate", 401 new NetworkTemplate.Builder(NetworkTemplate.MATCH_WIFI).build()); 402 403 final NetworkCycleDataForUidLoader loader = (NetworkCycleDataForUidLoader) 404 mFragment.mUidDataCallbacks.onCreateLoader(0 /* id */, Bundle.EMPTY /* args */); 405 406 final ArrayList<Long> cycles = loader.getCycles(); 407 assertThat(cycles).hasSize(2); 408 assertThat(cycles.get(0)).isEqualTo(endTime); 409 assertThat(cycles.get(1)).isEqualTo(startTime); 410 } 411 412 @Test onLoadFinished_hasSelectedCycleSpecified_shouldSelectSpecifiedCycle()413 public void onLoadFinished_hasSelectedCycleSpecified_shouldSelectSpecifiedCycle() { 414 final long now = System.currentTimeMillis(); 415 final long tenDaysAgo = now - (DateUtils.DAY_IN_MILLIS * 10); 416 final long twentyDaysAgo = now - (DateUtils.DAY_IN_MILLIS * 20); 417 final long thirtyDaysAgo = now - (DateUtils.DAY_IN_MILLIS * 30); 418 final List<NetworkCycleDataForUid> data = new ArrayList<>(); 419 NetworkCycleDataForUid.Builder builder = new NetworkCycleDataForUid.Builder(); 420 builder.setStartTime(thirtyDaysAgo).setEndTime(twentyDaysAgo).setTotalUsage(9876L); 421 data.add(builder.build()); 422 builder = new NetworkCycleDataForUid.Builder(); 423 builder.setStartTime(twentyDaysAgo).setEndTime(tenDaysAgo).setTotalUsage(5678L); 424 data.add(builder.build()); 425 builder = new NetworkCycleDataForUid.Builder(); 426 builder.setStartTime(tenDaysAgo).setEndTime(now).setTotalUsage(1234L); 427 data.add(builder.build()); 428 429 mFragment = new AppDataUsage() { 430 @Override 431 public boolean isSimHardwareVisible(Context context) { return true; } 432 }; 433 ReflectionHelpers.setField(mFragment, "mContext", RuntimeEnvironment.application); 434 ReflectionHelpers.setField(mFragment, "mCycleAdapter", mock(CycleAdapter.class)); 435 ReflectionHelpers.setField(mFragment, "mSelectedCycle", tenDaysAgo); 436 final Preference backgroundPref = mock(Preference.class); 437 ReflectionHelpers.setField(mFragment, "mBackgroundUsage", backgroundPref); 438 final Preference foregroundPref = mock(Preference.class); 439 ReflectionHelpers.setField(mFragment, "mForegroundUsage", foregroundPref); 440 final Preference totalPref = mock(Preference.class); 441 ReflectionHelpers.setField(mFragment, "mTotalUsage", totalPref); 442 final SpinnerPreference cycle = mock(SpinnerPreference.class); 443 ReflectionHelpers.setField(mFragment, "mCycle", cycle); 444 445 mFragment.mUidDataCallbacks.onLoadFinished(null /* loader */, data); 446 447 verify(cycle).setSelection(1); 448 } 449 450 @Test 451 @Config(shadows = {ShadowDataUsageUtils.class, ShadowSubscriptionManager.class, 452 ShadowFragment.class}) onCreate_noNetworkTemplateAndInvalidDataSubscription_shouldUseWifiTemplate()453 public void onCreate_noNetworkTemplateAndInvalidDataSubscription_shouldUseWifiTemplate() { 454 ShadowDataUsageUtils.IS_MOBILE_DATA_SUPPORTED = true; 455 ShadowDataUsageUtils.IS_WIFI_SUPPORTED = true; 456 ShadowDataUsageUtils.HAS_SIM = false; 457 ShadowSubscriptionManager.setDefaultDataSubscriptionId( 458 SubscriptionManager.INVALID_SUBSCRIPTION_ID); 459 mFragment = spy(new AppDataUsage() { 460 @Override 461 public boolean isSimHardwareVisible(Context context) { return true; } 462 }); 463 doReturn(Robolectric.setupActivity(FragmentActivity.class)).when(mFragment).getActivity(); 464 doReturn(RuntimeEnvironment.application).when(mFragment).getContext(); 465 final UidDetailProvider uidDetailProvider = mock(UidDetailProvider.class); 466 doReturn(uidDetailProvider).when(mFragment).getUidDetailProvider(); 467 doReturn(new UidDetail()).when(uidDetailProvider).getUidDetail(anyInt(), anyBoolean()); 468 469 ReflectionHelpers.setField(mFragment, "mDashboardFeatureProvider", 470 FakeFeatureFactory.setupForTest().dashboardFeatureProvider); 471 final Bundle args = new Bundle(); 472 args.putInt(AppInfoBase.ARG_PACKAGE_UID, 123123); 473 mFragment.setArguments(args); 474 475 mFragment.onCreate(Bundle.EMPTY); 476 477 assertThat(mFragment.mTemplate.getMatchRule()) 478 .isEqualTo(NetworkTemplate.MATCH_WIFI); 479 assertTrue(mFragment.mTemplate.getSubscriberIds().isEmpty()); 480 assertTrue(mFragment.mTemplate.getWifiNetworkKeys().isEmpty()); 481 } 482 } 483