Makoto Onuki | c9754cf | 2015-08-31 11:58:43 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2015 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.server.devicepolicy; |
| 18 | |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 19 | import com.android.internal.widget.LockPatternUtils; |
| 20 | |
| 21 | import android.app.IActivityManager; |
| 22 | import android.app.NotificationManager; |
Makoto Onuki | b643fb0 | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 23 | import android.app.backup.IBackupManager; |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 24 | import android.content.BroadcastReceiver; |
Makoto Onuki | a52562c | 2015-10-01 16:12:31 -0700 | [diff] [blame] | 25 | import android.content.ContentResolver; |
Makoto Onuki | c9754cf | 2015-08-31 11:58:43 -0700 | [diff] [blame] | 26 | import android.content.Context; |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 27 | import android.content.Intent; |
| 28 | import android.content.IntentFilter; |
Makoto Onuki | f76b06a | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 29 | import android.content.pm.IPackageManager; |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 30 | import android.content.pm.PackageManager; |
Fyodor Kupolov | cb6fd80 | 2015-11-05 14:27:06 -0800 | [diff] [blame] | 31 | import android.content.pm.PackageManagerInternal; |
Makoto Onuki | d932f76 | 2015-09-29 16:53:38 -0700 | [diff] [blame] | 32 | import android.content.pm.UserInfo; |
Makoto Onuki | b643fb0 | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 33 | import android.media.IAudioService; |
Makoto Onuki | a31ebbc | 2015-11-23 17:15:21 -0800 | [diff] [blame] | 34 | import android.net.wifi.WifiManager; |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 35 | import android.os.Bundle; |
| 36 | import android.os.Handler; |
| 37 | import android.os.PowerManager.WakeLock; |
| 38 | import android.os.PowerManagerInternal; |
| 39 | import android.os.UserHandle; |
Makoto Onuki | c9754cf | 2015-08-31 11:58:43 -0700 | [diff] [blame] | 40 | import android.os.UserManager; |
Makoto Onuki | 068c54a | 2015-10-13 14:34:03 -0700 | [diff] [blame] | 41 | import android.os.UserManagerInternal; |
Makoto Onuki | d4c9e54 | 2016-02-25 18:17:30 -0800 | [diff] [blame] | 42 | import android.os.storage.StorageManager; |
Mahaver Chopra | 1216ae5 | 2016-03-11 15:39:48 +0000 | [diff] [blame] | 43 | import android.telephony.TelephonyManager; |
Makoto Onuki | a52562c | 2015-10-01 16:12:31 -0700 | [diff] [blame] | 44 | import android.test.mock.MockContentResolver; |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 45 | import android.test.mock.MockContext; |
| 46 | import android.view.IWindowManager; |
| 47 | |
Makoto Onuki | b643fb0 | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 48 | import org.junit.Assert; |
Makoto Onuki | 2a3c3da | 2016-02-18 14:25:30 -0800 | [diff] [blame] | 49 | import org.mockito.invocation.InvocationOnMock; |
| 50 | import org.mockito.stubbing.Answer; |
Makoto Onuki | b643fb0 | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 51 | |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 52 | import java.io.File; |
| 53 | import java.util.ArrayList; |
| 54 | import java.util.List; |
Makoto Onuki | c9754cf | 2015-08-31 11:58:43 -0700 | [diff] [blame] | 55 | |
Makoto Onuki | 2a3c3da | 2016-02-18 14:25:30 -0800 | [diff] [blame] | 56 | import static org.mockito.Matchers.anyInt; |
Makoto Onuki | d932f76 | 2015-09-29 16:53:38 -0700 | [diff] [blame] | 57 | import static org.mockito.Matchers.eq; |
Makoto Onuki | c9754cf | 2015-08-31 11:58:43 -0700 | [diff] [blame] | 58 | import static org.mockito.Mockito.mock; |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 59 | import static org.mockito.Mockito.spy; |
Makoto Onuki | d932f76 | 2015-09-29 16:53:38 -0700 | [diff] [blame] | 60 | import static org.mockito.Mockito.when; |
Makoto Onuki | c9754cf | 2015-08-31 11:58:43 -0700 | [diff] [blame] | 61 | |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 62 | /** |
| 63 | * Context used throughout DPMS tests. |
| 64 | */ |
| 65 | public class DpmMockContext extends MockContext { |
| 66 | /** |
| 67 | * User-id of a non-system user we use throughout unit tests. |
| 68 | */ |
| 69 | public static final int CALLER_USER_HANDLE = 20; |
Makoto Onuki | c9754cf | 2015-08-31 11:58:43 -0700 | [diff] [blame] | 70 | |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 71 | /** |
Makoto Onuki | b643fb0 | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 72 | * UID corresponding to {@link #CALLER_USER_HANDLE}. |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 73 | */ |
Makoto Onuki | d932f76 | 2015-09-29 16:53:38 -0700 | [diff] [blame] | 74 | public static final int CALLER_UID = UserHandle.getUid(CALLER_USER_HANDLE, 20123); |
Makoto Onuki | c9754cf | 2015-08-31 11:58:43 -0700 | [diff] [blame] | 75 | |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 76 | /** |
Makoto Onuki | b643fb0 | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 77 | * UID used when a caller is on the system user. |
| 78 | */ |
Makoto Onuki | d932f76 | 2015-09-29 16:53:38 -0700 | [diff] [blame] | 79 | public static final int CALLER_SYSTEM_USER_UID = 20321; |
Makoto Onuki | b643fb0 | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 80 | |
| 81 | /** |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 82 | * PID of the caller. |
| 83 | */ |
| 84 | public static final int CALLER_PID = 22222; |
| 85 | |
| 86 | /** |
| 87 | * UID of the system server. |
| 88 | */ |
| 89 | public static final int SYSTEM_UID = android.os.Process.SYSTEM_UID; |
| 90 | |
| 91 | /** |
| 92 | * PID of the system server. |
| 93 | */ |
| 94 | public static final int SYSTEM_PID = 11111; |
| 95 | |
| 96 | public static class MockBinder { |
Makoto Onuki | f76b06a | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 97 | public int callingUid = CALLER_UID; |
| 98 | public int callingPid = CALLER_PID; |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 99 | |
| 100 | public long clearCallingIdentity() { |
Makoto Onuki | f76b06a | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 101 | final long token = (((long) callingUid) << 32) | (callingPid); |
| 102 | callingUid = SYSTEM_UID; |
| 103 | callingPid = SYSTEM_PID; |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 104 | return token; |
| 105 | } |
| 106 | |
| 107 | public void restoreCallingIdentity(long token) { |
Makoto Onuki | f76b06a | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 108 | callingUid = (int) (token >> 32); |
| 109 | callingPid = (int) token; |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 110 | } |
| 111 | |
| 112 | public int getCallingUid() { |
Makoto Onuki | f76b06a | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 113 | return callingUid; |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 114 | } |
| 115 | |
| 116 | public int getCallingPid() { |
Makoto Onuki | f76b06a | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 117 | return callingPid; |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 118 | } |
| 119 | |
| 120 | public UserHandle getCallingUserHandle() { |
| 121 | return new UserHandle(UserHandle.getUserId(getCallingUid())); |
| 122 | } |
| 123 | |
| 124 | public boolean isCallerUidMyUid() { |
Makoto Onuki | f76b06a | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 125 | return callingUid == SYSTEM_UID; |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 126 | } |
Makoto Onuki | c9754cf | 2015-08-31 11:58:43 -0700 | [diff] [blame] | 127 | } |
| 128 | |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 129 | public static class EnvironmentForMock { |
| 130 | public File getUserSystemDirectory(int userId) { |
| 131 | return null; |
| 132 | } |
| 133 | } |
| 134 | |
| 135 | public static class PowerManagerForMock { |
| 136 | public WakeLock newWakeLock(int levelAndFlags, String tag) { |
| 137 | return null; |
| 138 | } |
| 139 | |
| 140 | public void goToSleep(long time, int reason, int flags) { |
| 141 | } |
Mahaver Chopra | f8373b5 | 2015-12-23 14:42:18 +0000 | [diff] [blame] | 142 | |
| 143 | public void reboot(String reason) { |
| 144 | } |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 145 | } |
| 146 | |
Makoto Onuki | f76b06a | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 147 | public static class SystemPropertiesForMock { |
| 148 | public boolean getBoolean(String key, boolean def) { |
| 149 | return false; |
| 150 | } |
| 151 | |
| 152 | public long getLong(String key, long def) { |
| 153 | return 0; |
| 154 | } |
| 155 | |
| 156 | public String get(String key, String def) { |
| 157 | return null; |
| 158 | } |
| 159 | |
| 160 | public String get(String key) { |
| 161 | return null; |
| 162 | } |
| 163 | |
| 164 | public void set(String key, String value) { |
| 165 | } |
| 166 | } |
| 167 | |
Makoto Onuki | b643fb0 | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 168 | public static class UserManagerForMock { |
| 169 | public boolean isSplitSystemUser() { |
| 170 | return false; |
| 171 | } |
| 172 | } |
| 173 | |
Makoto Onuki | a4f1197 | 2015-10-01 13:19:58 -0700 | [diff] [blame] | 174 | public static class SettingsForMock { |
| 175 | int settingsSecureGetIntForUser(String name, int def, int userHandle) { |
| 176 | return 0; |
| 177 | } |
| 178 | |
| 179 | void settingsSecurePutIntForUser(String name, int value, int userHandle) { |
| 180 | } |
| 181 | |
| 182 | void settingsSecurePutStringForUser(String name, String value, int userHandle) { |
| 183 | } |
| 184 | |
| 185 | void settingsGlobalPutStringForUser(String name, String value, int userHandle) { |
| 186 | } |
| 187 | |
| 188 | void settingsSecurePutInt(String name, int value) { |
| 189 | } |
| 190 | |
| 191 | void settingsGlobalPutInt(String name, int value) { |
| 192 | } |
| 193 | |
| 194 | void settingsSecurePutString(String name, String value) { |
| 195 | } |
| 196 | |
| 197 | void settingsGlobalPutString(String name, String value) { |
| 198 | } |
Makoto Onuki | 3f3657a | 2016-01-28 14:44:18 -0800 | [diff] [blame] | 199 | |
| 200 | int settingsGlobalGetInt(String name, int def) { |
| 201 | return 0; |
| 202 | } |
| 203 | |
| 204 | void securityLogSetLoggingEnabledProperty(boolean enabled) { |
| 205 | } |
Rubin Xu | 49caead | 2016-02-02 18:00:28 +0000 | [diff] [blame] | 206 | |
| 207 | public boolean securityLogGetLoggingEnabledProperty() { |
| 208 | return false; |
| 209 | } |
| 210 | |
| 211 | public boolean securityLogIsLoggingEnabled() { |
| 212 | return false; |
| 213 | } |
Makoto Onuki | a4f1197 | 2015-10-01 13:19:58 -0700 | [diff] [blame] | 214 | } |
| 215 | |
Makoto Onuki | d4c9e54 | 2016-02-25 18:17:30 -0800 | [diff] [blame] | 216 | public static class StorageManagerForMock { |
| 217 | public boolean isFileBasedEncryptionEnabled() { |
| 218 | return false; |
| 219 | } |
| 220 | |
| 221 | public boolean isNonDefaultBlockEncrypted() { |
| 222 | return false; |
| 223 | } |
| 224 | |
| 225 | public boolean isEncrypted() { |
| 226 | return false; |
| 227 | } |
| 228 | |
| 229 | public boolean isEncryptable() { |
| 230 | return false; |
| 231 | } |
| 232 | } |
| 233 | |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 234 | public final Context realTestContext; |
| 235 | |
| 236 | /** |
| 237 | * Use this instance to verify unimplemented methods such as {@link #sendBroadcast}. |
| 238 | * (Spying on {@code this} instance will confuse mockito somehow and I got weired "wrong number |
| 239 | * of arguments" exceptions.) |
| 240 | */ |
| 241 | public final Context spiedContext; |
| 242 | |
Makoto Onuki | d932f76 | 2015-09-29 16:53:38 -0700 | [diff] [blame] | 243 | public final File dataDir; |
| 244 | public final File systemUserDataDir; |
| 245 | |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 246 | public final MockBinder binder; |
| 247 | public final EnvironmentForMock environment; |
Makoto Onuki | f76b06a | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 248 | public final SystemPropertiesForMock systemProperties; |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 249 | public final UserManager userManager; |
Makoto Onuki | 068c54a | 2015-10-13 14:34:03 -0700 | [diff] [blame] | 250 | public final UserManagerInternal userManagerInternal; |
Fyodor Kupolov | cb6fd80 | 2015-11-05 14:27:06 -0800 | [diff] [blame] | 251 | public final PackageManagerInternal packageManagerInternal; |
Makoto Onuki | b643fb0 | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 252 | public final UserManagerForMock userManagerForMock; |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 253 | public final PowerManagerForMock powerManager; |
| 254 | public final PowerManagerInternal powerManagerInternal; |
| 255 | public final NotificationManager notificationManager; |
| 256 | public final IWindowManager iwindowManager; |
| 257 | public final IActivityManager iactivityManager; |
Makoto Onuki | f76b06a | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 258 | public final IPackageManager ipackageManager; |
Makoto Onuki | b643fb0 | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 259 | public final IBackupManager ibackupManager; |
| 260 | public final IAudioService iaudioService; |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 261 | public final LockPatternUtils lockPatternUtils; |
Makoto Onuki | d4c9e54 | 2016-02-25 18:17:30 -0800 | [diff] [blame] | 262 | public final StorageManagerForMock storageManager; |
Makoto Onuki | a31ebbc | 2015-11-23 17:15:21 -0800 | [diff] [blame] | 263 | public final WifiManager wifiManager; |
Makoto Onuki | a4f1197 | 2015-10-01 13:19:58 -0700 | [diff] [blame] | 264 | public final SettingsForMock settings; |
Makoto Onuki | a52562c | 2015-10-01 16:12:31 -0700 | [diff] [blame] | 265 | public final MockContentResolver contentResolver; |
Mahaver Chopra | 1216ae5 | 2016-03-11 15:39:48 +0000 | [diff] [blame] | 266 | public final TelephonyManager telephonyManager; |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 267 | |
| 268 | /** Note this is a partial mock, not a real mock. */ |
| 269 | public final PackageManager packageManager; |
| 270 | |
| 271 | public final List<String> callerPermissions = new ArrayList<>(); |
| 272 | |
Makoto Onuki | d932f76 | 2015-09-29 16:53:38 -0700 | [diff] [blame] | 273 | private final ArrayList<UserInfo> mUserInfos = new ArrayList<>(); |
| 274 | |
| 275 | public DpmMockContext(Context context, File dataDir) { |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 276 | realTestContext = context; |
Makoto Onuki | d932f76 | 2015-09-29 16:53:38 -0700 | [diff] [blame] | 277 | |
| 278 | this.dataDir = dataDir; |
| 279 | DpmTestUtils.clearDir(dataDir); |
| 280 | |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 281 | binder = new MockBinder(); |
| 282 | environment = mock(EnvironmentForMock.class); |
Makoto Onuki | f76b06a | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 283 | systemProperties= mock(SystemPropertiesForMock.class); |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 284 | userManager = mock(UserManager.class); |
Makoto Onuki | 068c54a | 2015-10-13 14:34:03 -0700 | [diff] [blame] | 285 | userManagerInternal = mock(UserManagerInternal.class); |
Makoto Onuki | b643fb0 | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 286 | userManagerForMock = mock(UserManagerForMock.class); |
Fyodor Kupolov | cb6fd80 | 2015-11-05 14:27:06 -0800 | [diff] [blame] | 287 | packageManagerInternal = mock(PackageManagerInternal.class); |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 288 | powerManager = mock(PowerManagerForMock.class); |
| 289 | powerManagerInternal = mock(PowerManagerInternal.class); |
| 290 | notificationManager = mock(NotificationManager.class); |
| 291 | iwindowManager = mock(IWindowManager.class); |
| 292 | iactivityManager = mock(IActivityManager.class); |
Makoto Onuki | f76b06a | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 293 | ipackageManager = mock(IPackageManager.class); |
Makoto Onuki | b643fb0 | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 294 | ibackupManager = mock(IBackupManager.class); |
| 295 | iaudioService = mock(IAudioService.class); |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 296 | lockPatternUtils = mock(LockPatternUtils.class); |
Makoto Onuki | d4c9e54 | 2016-02-25 18:17:30 -0800 | [diff] [blame] | 297 | storageManager = mock(StorageManagerForMock.class); |
Makoto Onuki | a31ebbc | 2015-11-23 17:15:21 -0800 | [diff] [blame] | 298 | wifiManager = mock(WifiManager.class); |
Makoto Onuki | a4f1197 | 2015-10-01 13:19:58 -0700 | [diff] [blame] | 299 | settings = mock(SettingsForMock.class); |
Mahaver Chopra | 1216ae5 | 2016-03-11 15:39:48 +0000 | [diff] [blame] | 300 | telephonyManager = mock(TelephonyManager.class); |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 301 | |
| 302 | // Package manager is huge, so we use a partial mock instead. |
| 303 | packageManager = spy(context.getPackageManager()); |
| 304 | |
| 305 | spiedContext = mock(Context.class); |
Makoto Onuki | d932f76 | 2015-09-29 16:53:38 -0700 | [diff] [blame] | 306 | |
Makoto Onuki | a52562c | 2015-10-01 16:12:31 -0700 | [diff] [blame] | 307 | contentResolver = new MockContentResolver(); |
| 308 | |
Makoto Onuki | d932f76 | 2015-09-29 16:53:38 -0700 | [diff] [blame] | 309 | // Add the system user |
| 310 | systemUserDataDir = addUser(UserHandle.USER_SYSTEM, UserInfo.FLAG_PRIMARY); |
| 311 | |
| 312 | // System user is always running. |
Makoto Onuki | a52562c | 2015-10-01 16:12:31 -0700 | [diff] [blame] | 313 | setUserRunning(UserHandle.USER_SYSTEM, true); |
Makoto Onuki | d932f76 | 2015-09-29 16:53:38 -0700 | [diff] [blame] | 314 | } |
| 315 | |
| 316 | public File addUser(int userId, int flags) { |
| 317 | |
| 318 | // Set up (default) UserInfo for CALLER_USER_HANDLE. |
| 319 | final UserInfo uh = new UserInfo(userId, "user" + userId, flags); |
| 320 | when(userManager.getUserInfo(eq(userId))).thenReturn(uh); |
| 321 | |
| 322 | mUserInfos.add(uh); |
| 323 | when(userManager.getUsers()).thenReturn(mUserInfos); |
Makoto Onuki | 2a3c3da | 2016-02-18 14:25:30 -0800 | [diff] [blame] | 324 | when(userManager.getUserInfo(anyInt())).thenAnswer( |
| 325 | new Answer<UserInfo>() { |
| 326 | @Override |
| 327 | public UserInfo answer(InvocationOnMock invocation) throws Throwable { |
| 328 | final int userId = (int) invocation.getArguments()[0]; |
| 329 | for (UserInfo ui : mUserInfos) { |
| 330 | if (ui.id == userId) { |
| 331 | return ui; |
| 332 | } |
| 333 | } |
| 334 | return null; |
| 335 | } |
| 336 | } |
| 337 | ); |
| 338 | when(userManager.getProfiles(anyInt())).thenAnswer( |
| 339 | new Answer<List<UserInfo>>() { |
| 340 | @Override |
| 341 | public List<UserInfo> answer(InvocationOnMock invocation) throws Throwable { |
| 342 | final int userId = (int) invocation.getArguments()[0]; |
| 343 | final ArrayList<UserInfo> ret = new ArrayList<UserInfo>(); |
| 344 | UserInfo parent = null; |
| 345 | for (UserInfo ui : mUserInfos) { |
| 346 | if (ui.id == userId) { |
| 347 | parent = ui; |
| 348 | break; |
| 349 | } |
| 350 | } |
| 351 | if (parent == null) { |
| 352 | return ret; |
| 353 | } |
| 354 | ret.add(parent); |
| 355 | for (UserInfo ui : mUserInfos) { |
| 356 | if (ui.id == userId) { |
| 357 | continue; |
| 358 | } |
| 359 | if (ui.profileGroupId != UserInfo.NO_PROFILE_GROUP_ID |
| 360 | && ui.profileGroupId == parent.profileGroupId) { |
| 361 | ret.add(ui); |
| 362 | } |
| 363 | } |
| 364 | return ret; |
| 365 | } |
| 366 | } |
| 367 | ); |
Makoto Onuki | d932f76 | 2015-09-29 16:53:38 -0700 | [diff] [blame] | 368 | |
| 369 | // Create a data directory. |
| 370 | final File dir = new File(dataDir, "user" + userId); |
| 371 | DpmTestUtils.clearDir(dir); |
| 372 | |
| 373 | when(environment.getUserSystemDirectory(eq(userId))).thenReturn(dir); |
| 374 | return dir; |
| 375 | } |
| 376 | |
| 377 | /** |
| 378 | * Add multiple users at once. They'll all have flag 0. |
| 379 | */ |
| 380 | public void addUsers(int... userIds) { |
| 381 | for (int userId : userIds) { |
| 382 | addUser(userId, 0); |
| 383 | } |
Makoto Onuki | c9754cf | 2015-08-31 11:58:43 -0700 | [diff] [blame] | 384 | } |
| 385 | |
Makoto Onuki | a52562c | 2015-10-01 16:12:31 -0700 | [diff] [blame] | 386 | public void setUserRunning(int userId, boolean isRunning) { |
| 387 | when(userManager.isUserRunning(MockUtils.checkUserHandle(userId))) |
| 388 | .thenReturn(isRunning); |
| 389 | } |
| 390 | |
Makoto Onuki | c9754cf | 2015-08-31 11:58:43 -0700 | [diff] [blame] | 391 | @Override |
| 392 | public Object getSystemService(String name) { |
| 393 | switch (name) { |
| 394 | case Context.USER_SERVICE: |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 395 | return userManager; |
| 396 | case Context.POWER_SERVICE: |
| 397 | return powerManager; |
Makoto Onuki | a31ebbc | 2015-11-23 17:15:21 -0800 | [diff] [blame] | 398 | case Context.WIFI_SERVICE: |
| 399 | return wifiManager; |
Makoto Onuki | c9754cf | 2015-08-31 11:58:43 -0700 | [diff] [blame] | 400 | } |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 401 | throw new UnsupportedOperationException(); |
| 402 | } |
| 403 | |
| 404 | @Override |
Makoto Onuki | 72a3a0c | 2015-09-25 16:01:43 -0700 | [diff] [blame] | 405 | public String getSystemServiceName(Class<?> serviceClass) { |
| 406 | return realTestContext.getSystemServiceName(serviceClass); |
| 407 | } |
| 408 | |
| 409 | @Override |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 410 | public PackageManager getPackageManager() { |
| 411 | return packageManager; |
| 412 | } |
| 413 | |
| 414 | @Override |
| 415 | public void enforceCallingOrSelfPermission(String permission, String message) { |
| 416 | if (binder.getCallingUid() == SYSTEM_UID) { |
| 417 | return; // Assume system has all permissions. |
| 418 | } |
| 419 | if (!callerPermissions.contains(permission)) { |
| 420 | throw new SecurityException("Caller doesn't have " + permission + " : " + message); |
| 421 | } |
| 422 | } |
| 423 | |
| 424 | @Override |
| 425 | public void sendBroadcast(Intent intent) { |
| 426 | spiedContext.sendBroadcast(intent); |
| 427 | } |
| 428 | |
| 429 | @Override |
| 430 | public void sendBroadcast(Intent intent, String receiverPermission) { |
| 431 | spiedContext.sendBroadcast(intent, receiverPermission); |
| 432 | } |
| 433 | |
| 434 | @Override |
| 435 | public void sendBroadcastMultiplePermissions(Intent intent, String[] receiverPermissions) { |
| 436 | spiedContext.sendBroadcastMultiplePermissions(intent, receiverPermissions); |
| 437 | } |
| 438 | |
| 439 | @Override |
| 440 | public void sendBroadcast(Intent intent, String receiverPermission, Bundle options) { |
| 441 | spiedContext.sendBroadcast(intent, receiverPermission, options); |
| 442 | } |
| 443 | |
| 444 | @Override |
| 445 | public void sendBroadcast(Intent intent, String receiverPermission, int appOp) { |
| 446 | spiedContext.sendBroadcast(intent, receiverPermission, appOp); |
| 447 | } |
| 448 | |
| 449 | @Override |
| 450 | public void sendOrderedBroadcast(Intent intent, String receiverPermission) { |
| 451 | spiedContext.sendOrderedBroadcast(intent, receiverPermission); |
| 452 | } |
| 453 | |
| 454 | @Override |
| 455 | public void sendOrderedBroadcast(Intent intent, String receiverPermission, |
| 456 | BroadcastReceiver resultReceiver, Handler scheduler, int initialCode, |
| 457 | String initialData, Bundle initialExtras) { |
| 458 | spiedContext.sendOrderedBroadcast(intent, receiverPermission, resultReceiver, scheduler, |
| 459 | initialCode, initialData, initialExtras); |
| 460 | } |
| 461 | |
| 462 | @Override |
| 463 | public void sendOrderedBroadcast(Intent intent, String receiverPermission, Bundle options, |
| 464 | BroadcastReceiver resultReceiver, Handler scheduler, int initialCode, |
| 465 | String initialData, Bundle initialExtras) { |
| 466 | spiedContext.sendOrderedBroadcast(intent, receiverPermission, options, resultReceiver, |
| 467 | scheduler, |
| 468 | initialCode, initialData, initialExtras); |
| 469 | } |
| 470 | |
| 471 | @Override |
| 472 | public void sendOrderedBroadcast(Intent intent, String receiverPermission, int appOp, |
| 473 | BroadcastReceiver resultReceiver, Handler scheduler, int initialCode, |
| 474 | String initialData, Bundle initialExtras) { |
| 475 | spiedContext.sendOrderedBroadcast(intent, receiverPermission, appOp, resultReceiver, |
| 476 | scheduler, |
| 477 | initialCode, initialData, initialExtras); |
| 478 | } |
| 479 | |
| 480 | @Override |
| 481 | public void sendBroadcastAsUser(Intent intent, UserHandle user) { |
Makoto Onuki | b643fb0 | 2015-09-22 15:03:44 -0700 | [diff] [blame] | 482 | if (binder.callingPid != SYSTEM_PID) { |
| 483 | // Unless called as the system process, can only call if the target user is the |
| 484 | // calling user. |
| 485 | // (The actual check is more complex; we may need to change it later.) |
| 486 | Assert.assertEquals(UserHandle.getUserId(binder.getCallingUid()), user.getIdentifier()); |
| 487 | } |
| 488 | |
Makoto Onuki | cc4bbeb | 2015-09-17 10:28:24 -0700 | [diff] [blame] | 489 | spiedContext.sendBroadcastAsUser(intent, user); |
| 490 | } |
| 491 | |
| 492 | @Override |
| 493 | public void sendBroadcastAsUser(Intent intent, UserHandle user, String receiverPermission) { |
| 494 | spiedContext.sendBroadcastAsUser(intent, user, receiverPermission); |
| 495 | } |
| 496 | |
| 497 | @Override |
| 498 | public void sendBroadcastAsUser(Intent intent, UserHandle user, String receiverPermission, |
| 499 | int appOp) { |
| 500 | spiedContext.sendBroadcastAsUser(intent, user, receiverPermission, appOp); |
| 501 | } |
| 502 | |
| 503 | @Override |
| 504 | public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, |
| 505 | String receiverPermission, BroadcastReceiver resultReceiver, Handler scheduler, |
| 506 | int initialCode, String initialData, Bundle initialExtras) { |
| 507 | spiedContext.sendOrderedBroadcastAsUser(intent, user, receiverPermission, resultReceiver, |
| 508 | scheduler, initialCode, initialData, initialExtras); |
| 509 | } |
| 510 | |
| 511 | @Override |
| 512 | public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, |
| 513 | String receiverPermission, int appOp, BroadcastReceiver resultReceiver, |
| 514 | Handler scheduler, int initialCode, String initialData, Bundle initialExtras) { |
| 515 | spiedContext.sendOrderedBroadcastAsUser(intent, user, receiverPermission, appOp, |
| 516 | resultReceiver, |
| 517 | scheduler, initialCode, initialData, initialExtras); |
| 518 | } |
| 519 | |
| 520 | @Override |
| 521 | public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, |
| 522 | String receiverPermission, int appOp, Bundle options, BroadcastReceiver resultReceiver, |
| 523 | Handler scheduler, int initialCode, String initialData, Bundle initialExtras) { |
| 524 | spiedContext.sendOrderedBroadcastAsUser(intent, user, receiverPermission, appOp, options, |
| 525 | resultReceiver, scheduler, initialCode, initialData, initialExtras); |
| 526 | } |
| 527 | |
| 528 | @Override |
| 529 | public void sendStickyBroadcast(Intent intent) { |
| 530 | spiedContext.sendStickyBroadcast(intent); |
| 531 | } |
| 532 | |
| 533 | @Override |
| 534 | public void sendStickyOrderedBroadcast(Intent intent, BroadcastReceiver resultReceiver, |
| 535 | Handler scheduler, int initialCode, String initialData, Bundle initialExtras) { |
| 536 | spiedContext.sendStickyOrderedBroadcast(intent, resultReceiver, scheduler, initialCode, |
| 537 | initialData, initialExtras); |
| 538 | } |
| 539 | |
| 540 | @Override |
| 541 | public void removeStickyBroadcast(Intent intent) { |
| 542 | spiedContext.removeStickyBroadcast(intent); |
| 543 | } |
| 544 | |
| 545 | @Override |
| 546 | public void sendStickyBroadcastAsUser(Intent intent, UserHandle user) { |
| 547 | spiedContext.sendStickyBroadcastAsUser(intent, user); |
| 548 | } |
| 549 | |
| 550 | @Override |
| 551 | public void sendStickyOrderedBroadcastAsUser(Intent intent, UserHandle user, |
| 552 | BroadcastReceiver resultReceiver, Handler scheduler, int initialCode, |
| 553 | String initialData, Bundle initialExtras) { |
| 554 | spiedContext.sendStickyOrderedBroadcastAsUser(intent, user, resultReceiver, scheduler, initialCode, |
| 555 | initialData, initialExtras); |
| 556 | } |
| 557 | |
| 558 | @Override |
| 559 | public void removeStickyBroadcastAsUser(Intent intent, UserHandle user) { |
| 560 | spiedContext.removeStickyBroadcastAsUser(intent, user); |
| 561 | } |
| 562 | |
| 563 | @Override |
| 564 | public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) { |
| 565 | return spiedContext.registerReceiver(receiver, filter); |
| 566 | } |
| 567 | |
| 568 | @Override |
| 569 | public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter, |
| 570 | String broadcastPermission, Handler scheduler) { |
| 571 | return spiedContext.registerReceiver(receiver, filter, broadcastPermission, scheduler); |
| 572 | } |
| 573 | |
| 574 | @Override |
| 575 | public Intent registerReceiverAsUser(BroadcastReceiver receiver, UserHandle user, |
| 576 | IntentFilter filter, String broadcastPermission, Handler scheduler) { |
| 577 | return spiedContext.registerReceiverAsUser(receiver, user, filter, broadcastPermission, |
| 578 | scheduler); |
| 579 | } |
| 580 | |
| 581 | @Override |
| 582 | public void unregisterReceiver(BroadcastReceiver receiver) { |
| 583 | spiedContext.unregisterReceiver(receiver); |
Makoto Onuki | c9754cf | 2015-08-31 11:58:43 -0700 | [diff] [blame] | 584 | } |
Makoto Onuki | a52562c | 2015-10-01 16:12:31 -0700 | [diff] [blame] | 585 | |
| 586 | @Override |
| 587 | public ContentResolver getContentResolver() { |
| 588 | return contentResolver; |
| 589 | } |
Makoto Onuki | c9754cf | 2015-08-31 11:58:43 -0700 | [diff] [blame] | 590 | } |