1 /*
2  * Copyright (C) 2021 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.pm.test.verify.domain
18 
19 import android.content.Context
20 import android.content.Intent
21 import android.content.pm.PackageManager
22 import android.content.pm.PackageUserState
23 import android.content.pm.parsing.component.ParsedActivity
24 import android.content.pm.parsing.component.ParsedIntentInfo
25 import android.content.pm.verify.domain.DomainOwner
26 import android.content.pm.verify.domain.DomainVerificationInfo
27 import android.content.pm.verify.domain.DomainVerificationManager
28 import android.content.pm.verify.domain.DomainVerificationUserState
29 import android.content.pm.verify.domain.IDomainVerificationManager
30 import android.os.Build
31 import android.os.PatternMatcher
32 import android.os.Process
33 import android.util.ArraySet
34 import com.android.server.pm.PackageSetting
35 import com.android.server.pm.parsing.pkg.AndroidPackage
36 import com.android.server.pm.test.verify.domain.DomainVerificationTestUtils.mockPackageSettings
37 import com.android.server.pm.verify.domain.DomainVerificationManagerStub
38 import com.android.server.pm.verify.domain.DomainVerificationService
39 import com.android.server.testutils.mockThrowOnUnmocked
40 import com.android.server.testutils.whenever
41 import com.google.common.truth.Truth.assertThat
42 import org.junit.Test
43 import org.mockito.ArgumentMatchers.any
44 import org.mockito.ArgumentMatchers.anyInt
45 import org.mockito.ArgumentMatchers.anyLong
46 import org.mockito.ArgumentMatchers.anyString
47 import java.util.UUID
48 import java.util.concurrent.atomic.AtomicBoolean
49 import kotlin.test.assertFailsWith
50 
51 class DomainVerificationManagerApiTest {
52 
53     companion object {
54         private const val PKG_ONE = "com.test.one"
55         private const val PKG_TWO = "com.test.two"
56         private const val PKG_THREE = "com.test.three"
57 
58         private val UUID_ONE = UUID.fromString("1b041c96-8d37-4932-a858-561bfac5947c")
59         private val UUID_TWO = UUID.fromString("a3389c16-7f9f-4e86-85e3-500d1249c74c")
60         private val UUID_THREE = UUID.fromString("0b3260ed-07c4-4b45-840b-237f8fb8b433")
61         private val UUID_INVALID = UUID.fromString("ad33babc-490b-4965-9d78-7e91248b00f")
62 
63         private val DOMAIN_BASE = DomainVerificationManagerApiTest::class.java.packageName
64         private val DOMAIN_1 = "one.$DOMAIN_BASE"
65         private val DOMAIN_2 = "two.$DOMAIN_BASE"
66         private val DOMAIN_3 = "three.$DOMAIN_BASE"
67         private val DOMAIN_4 = "four.$DOMAIN_BASE"
68     }
69 
70     @Test
71     fun queryValidVerificationPackageNames() {
72         val pkgWithDomains = mockPkgSetting(PKG_ONE, UUID_ONE, listOf(DOMAIN_1, DOMAIN_2))
73         val pkgWithoutDomains = mockPkgSetting(PKG_TWO, UUID_TWO, emptyList())
74 
75         val service = makeService(pkgWithDomains, pkgWithoutDomains).apply {
76             addPackages(pkgWithDomains, pkgWithoutDomains)
77         }
78 
79         assertThat(service.queryValidVerificationPackageNames())
80                 .containsExactly(pkgWithDomains.getName())
81     }
82 
83     @Test
84     fun getDomainVerificationInfoId() {
85         val pkgWithDomains = mockPkgSetting(PKG_ONE, UUID_ONE, listOf(DOMAIN_1, DOMAIN_2))
86         val pkgWithoutDomains = mockPkgSetting(PKG_TWO, UUID_TWO, emptyList())
87 
88         val service = makeService(pkgWithDomains, pkgWithoutDomains).apply {
89             addPackages(pkgWithDomains, pkgWithoutDomains)
90         }
91 
92         assertThat(service.getDomainVerificationInfoId(PKG_ONE)).isEqualTo(UUID_ONE)
93         assertThat(service.getDomainVerificationInfoId(PKG_TWO)).isEqualTo(UUID_TWO)
94 
95         assertThat(service.getDomainVerificationInfoId("invalid.pkg.name")).isEqualTo(null)
96     }
97 
98     @Test
99     fun getDomainVerificationInfo() {
100         val pkgWithDomains = mockPkgSetting(PKG_ONE, UUID_ONE, listOf(DOMAIN_1, DOMAIN_2))
101         val pkgWithoutDomains = mockPkgSetting(PKG_TWO, UUID_TWO, emptyList())
102 
103         val service = makeService(pkgWithDomains, pkgWithoutDomains).apply {
104             addPackages(pkgWithDomains, pkgWithoutDomains)
105         }
106 
107         val infoOne = service.getDomainVerificationInfo(pkgWithDomains.getName())
108         assertThat(infoOne).isNotNull()
109         assertThat(infoOne!!.identifier).isEqualTo(pkgWithDomains.domainSetId)
110         assertThat(infoOne.packageName).isEqualTo(pkgWithDomains.getName())
111         assertThat(infoOne.hostToStateMap).containsExactlyEntriesIn(mapOf(
112                 DOMAIN_1 to DomainVerificationInfo.STATE_NO_RESPONSE,
113                 DOMAIN_2 to DomainVerificationInfo.STATE_NO_RESPONSE
114         ))
115 
116         assertThat(service.getDomainVerificationInfo(pkgWithoutDomains.getName())).isNull()
117 
118         assertFailsWith(PackageManager.NameNotFoundException::class) {
119             service.getDomainVerificationInfo("invalid.pkg.name")
120         }
121     }
122 
123     @Test
124     fun setStatus() {
125         val pkg1 = mockPkgSetting(PKG_ONE, UUID_ONE, listOf(DOMAIN_1, DOMAIN_2))
126         val pkg2 = mockPkgSetting(PKG_TWO, UUID_TWO, listOf(DOMAIN_3, DOMAIN_4))
127 
128         val map = mutableMapOf(pkg1.getName() to pkg1, pkg2.getName() to pkg2)
129         val service = makeService(map::get).apply { addPackages(pkg1, pkg2) }
130 
131         assertThat(service.setStatus(UUID_ONE, setOf(DOMAIN_2), 1100))
132                 .isEqualTo(DomainVerificationManager.STATUS_OK)
133 
134         assertThat(service.setStatus(UUID_INVALID, setOf(DOMAIN_1), 1100))
135                 .isEqualTo(DomainVerificationManager.ERROR_DOMAIN_SET_ID_INVALID)
136 
137         assertFailsWith(IllegalArgumentException::class) {
138             DomainVerificationJavaUtil.setStatusForceNullable(service, null, setOf(DOMAIN_1), 1100)
139         }
140 
141         assertFailsWith(IllegalArgumentException::class) {
142             DomainVerificationJavaUtil.setStatusForceNullable(service, UUID_ONE, null, 1100)
143         }
144 
145         assertFailsWith(IllegalArgumentException::class) {
146             service.setStatus(UUID_ONE, emptySet(), 1100)
147         }
148 
149         assertThat(service.setStatus(UUID_ONE, setOf(DOMAIN_3), 1100))
150                 .isEqualTo(DomainVerificationManager.ERROR_UNKNOWN_DOMAIN)
151 
152         assertThat(service.setStatus(UUID_ONE, setOf(DOMAIN_1, DOMAIN_2, DOMAIN_3), 1100))
153                 .isEqualTo(DomainVerificationManager.ERROR_UNKNOWN_DOMAIN)
154 
155         assertFailsWith(IllegalArgumentException::class) {
156             service.setStatus(UUID_ONE, setOf(DOMAIN_1), 15)
157         }
158 
159         map.clear()
160         assertFailsWith(PackageManager.NameNotFoundException::class) {
161             service.setStatus(UUID_ONE, setOf(DOMAIN_1), 1100)
162         }
163     }
164 
165     @Test
166     fun setDomainVerificationLinkHandlingAllowed() {
167         val pkg1 = mockPkgSetting(PKG_ONE, UUID_ONE, listOf(DOMAIN_1, DOMAIN_2))
168         val pkg2 = mockPkgSetting(PKG_TWO, UUID_TWO, listOf(DOMAIN_3, DOMAIN_4))
169 
170         val map = mutableMapOf(pkg1.getName() to pkg1, pkg2.getName() to pkg2)
171         val service = makeService(map::get).apply { addPackages(pkg1, pkg2) }
172 
173         service.setDomainVerificationLinkHandlingAllowed(PKG_ONE, false, 0)
174 
175         // Should edit same package, same user
176         assertThat(service.getDomainVerificationUserState(PKG_ONE, 0)
177                 ?.isLinkHandlingAllowed).isEqualTo(false)
178 
179         // Shouldn't edit different user
180         assertThat(service.getDomainVerificationUserState(PKG_ONE, 1)
181                 ?.isLinkHandlingAllowed).isEqualTo(true)
182 
183         // Shouldn't edit different package
184         assertThat(service.getDomainVerificationUserState(PKG_TWO, 0)
185                 ?.isLinkHandlingAllowed).isEqualTo(true)
186 
187         assertFailsWith(PackageManager.NameNotFoundException::class) {
188             service.setDomainVerificationLinkHandlingAllowed("invalid.pkg.name", false, 0)
189         }
190     }
191 
192     @Test
193     fun setUserSelection() {
194         val pkg1 = mockPkgSetting(PKG_ONE, UUID_ONE, listOf(DOMAIN_1, DOMAIN_2))
195         val pkg2 = mockPkgSetting(PKG_TWO, UUID_TWO, listOf(DOMAIN_3, DOMAIN_4))
196         val pkg3 = mockPkgSetting(PKG_THREE, UUID_THREE, listOf(DOMAIN_1, DOMAIN_2))
197 
198         val map = mutableMapOf(
199                 pkg1.getName() to pkg1,
200                 pkg2.getName() to pkg2,
201                 pkg3.getName() to pkg3
202         )
203         val service = makeService(map::get).apply { addPackages(pkg1, pkg2, pkg3) }
204 
205         assertThat(service.setUserSelection(UUID_ONE, setOf(DOMAIN_2), true, 0))
206                 .isEqualTo(DomainVerificationManager.STATUS_OK)
207 
208         assertThat(service.setUserSelection(UUID_INVALID, setOf(DOMAIN_1), true, 0))
209                 .isEqualTo(DomainVerificationManager.ERROR_DOMAIN_SET_ID_INVALID)
210 
211         assertFailsWith(IllegalArgumentException::class) {
212             DomainVerificationJavaUtil.setUserSelectionForceNullable(service, null,
213                 setOf(DOMAIN_1), true, 0)
214         }
215 
216         assertFailsWith(IllegalArgumentException::class) {
217             DomainVerificationJavaUtil.setUserSelectionForceNullable(service, UUID_ONE, null,
218                 true, 0)
219         }
220 
221         assertFailsWith(IllegalArgumentException::class) {
222             service.setUserSelection(UUID_ONE, emptySet(), true, 0)
223         }
224 
225         assertThat(service.setUserSelection(UUID_ONE, setOf(DOMAIN_3), true, 0))
226                 .isEqualTo(DomainVerificationManager.ERROR_UNKNOWN_DOMAIN)
227 
228         assertThat(service.setUserSelection(UUID_ONE, setOf(DOMAIN_1, DOMAIN_2, DOMAIN_3), true, 0))
229                 .isEqualTo(DomainVerificationManager.ERROR_UNKNOWN_DOMAIN)
230 
231         service.setStatus(UUID_ONE, setOf(DOMAIN_2), DomainVerificationInfo.STATE_SUCCESS)
232 
233         assertThat(service.setUserSelection(UUID_THREE, setOf(DOMAIN_2), true, 0))
234             .isEqualTo(DomainVerificationManager.ERROR_UNABLE_TO_APPROVE)
235 
236         map.clear()
237         assertFailsWith(PackageManager.NameNotFoundException::class) {
238             service.setUserSelection(UUID_ONE, setOf(DOMAIN_1), true, 0)
239         }
240     }
241 
242     @Test
243     fun getDomainVerificationUserState() {
244         val pkgWithDomains = mockPkgSetting(PKG_ONE, UUID_ONE, listOf(DOMAIN_1, DOMAIN_2))
245         val pkgWithoutDomains = mockPkgSetting(PKG_TWO, UUID_TWO, emptyList())
246 
247         val service = makeService(pkgWithDomains, pkgWithoutDomains).apply {
248             addPackages(pkgWithDomains, pkgWithoutDomains)
249         }
250 
251         val infoOne = service.getDomainVerificationUserState(pkgWithDomains.getName(), 0)
252         assertThat(infoOne).isNotNull()
253         assertThat(infoOne!!.identifier).isEqualTo(pkgWithDomains.domainSetId)
254         assertThat(infoOne.packageName).isEqualTo(pkgWithDomains.getName())
255         assertThat(infoOne.isLinkHandlingAllowed).isTrue()
256         assertThat(infoOne.hostToStateMap).containsExactlyEntriesIn(mapOf(
257                 DOMAIN_1 to DomainVerificationUserState.DOMAIN_STATE_NONE,
258                 DOMAIN_2 to DomainVerificationUserState.DOMAIN_STATE_NONE
259         ))
260 
261         val infoTwo = service.getDomainVerificationUserState(pkgWithoutDomains.getName(), 0)
262         assertThat(infoTwo).isNotNull()
263         assertThat(infoTwo!!.identifier).isEqualTo(pkgWithoutDomains.domainSetId)
264         assertThat(infoTwo.packageName).isEqualTo(pkgWithoutDomains.getName())
265         assertThat(infoOne.isLinkHandlingAllowed).isTrue()
266         assertThat(infoTwo.hostToStateMap).isEmpty()
267 
268         assertFailsWith(PackageManager.NameNotFoundException::class) {
269             service.getDomainVerificationUserState("invalid.pkg.name", 0)
270         }
271     }
272 
273     @Test
274     fun getOwnersForDomain() {
275         val pkg1User0Enabled = AtomicBoolean(true)
276 
277         val pkg1 = mockPkgSetting(PKG_ONE, UUID_ONE, listOf(DOMAIN_1, DOMAIN_2), pkgUserState0 = {
278             mockThrowOnUnmocked {
279                 whenever(isPackageEnabled(any())) {
280                     pkg1User0Enabled.get()
281                 }
282                 installed = true
283             }
284         })
285         val pkg2 = mockPkgSetting(PKG_TWO, UUID_TWO, listOf(DOMAIN_1, DOMAIN_2))
286 
287         val service = makeService(pkg1, pkg2).apply {
288             addPackages(pkg1, pkg2)
289         }
290 
291         // DomainVerificationManager converts the owner list to a SortedSet, so test that, too
292         val manager0 = makeManager(service, 0)
293         val manager1 = makeManager(service, 1)
294 
295         listOf(DOMAIN_1, "").forEach {
296             assertThat(service.getOwnersForDomain(it, 0)).isEmpty()
297             assertThat(manager0.getOwnersForDomain(it)).isEmpty()
298         }
299 
300         assertFailsWith(NullPointerException::class) {
301             DomainVerificationJavaUtil.getOwnersForDomain(service, null, 0)
302         }
303         assertFailsWith(NullPointerException::class) {
304             DomainVerificationJavaUtil.getOwnersForDomain(manager0, null)
305         }
306 
307         assertThat(
308             service.setStatus(
309                 pkg1.domainSetId,
310                 setOf(DOMAIN_1),
311                 DomainVerificationInfo.STATE_SUCCESS
312             )
313         ).isEqualTo(DomainVerificationManager.STATUS_OK)
314         assertThat(
315             service.setStatus(
316                 pkg2.domainSetId,
317                 setOf(DOMAIN_1),
318                 DomainVerificationInfo.STATE_SUCCESS
319             )
320         ).isEqualTo(DomainVerificationManager.STATUS_OK)
321 
322         service.setUserSelection(pkg1.domainSetId, setOf(DOMAIN_2), true, 0)
323 
324         service.getOwnersForDomain(DOMAIN_1, 0).let {
325             assertThat(it).containsExactly(
326                 DomainOwner(pkg1.getName(), false),
327                 DomainOwner(pkg2.getName(), false)
328             ).inOrder()
329         }
330         manager0.getOwnersForDomain(DOMAIN_1).let {
331             assertThat(it).containsExactly(
332                 DomainOwner(pkg1.getName(), false),
333                 DomainOwner(pkg2.getName(), false)
334             ).inOrder()
335         }
336 
337         service.getOwnersForDomain(DOMAIN_2, 0).let {
338             assertThat(it).containsExactly(DomainOwner(pkg1.getName(), true))
339         }
340         manager0.getOwnersForDomain(DOMAIN_2).let {
341             assertThat(it).containsExactly(DomainOwner(pkg1.getName(), true))
342         }
343 
344         assertThat(service.getOwnersForDomain(DOMAIN_2, 1)).isEmpty()
345         assertThat(manager1.getOwnersForDomain(DOMAIN_2)).isEmpty()
346         service.setUserSelection(pkg1.domainSetId, setOf(DOMAIN_2), true, 1)
347         service.getOwnersForDomain(DOMAIN_2, 1).let {
348             assertThat(it).containsExactly(DomainOwner(pkg1.getName(), true))
349         }
350         manager1.getOwnersForDomain(DOMAIN_2).let {
351             assertThat(it).containsExactly(DomainOwner(pkg1.getName(), true))
352         }
353 
354         // "Uninstall" the package from user 0 and ensure it's stripped from the results
355         pkg1User0Enabled.set(false)
356         service.clearPackageForUser(pkg1.getName(), 0)
357 
358         service.getOwnersForDomain(DOMAIN_1, 0).let {
359             assertThat(it).containsExactly(DomainOwner(pkg2.getName(), false))
360         }
361         manager0.getOwnersForDomain(DOMAIN_1).let {
362             assertThat(it).containsExactly(DomainOwner(pkg2.getName(), false))
363         }
364 
365         // Domain 2 user selection gone for user 0
366         assertThat(service.getOwnersForDomain(DOMAIN_2, 0)).isEmpty()
367 
368         // Domain 2 user selection still around for user 1
369         service.getOwnersForDomain(DOMAIN_2, 1).let {
370             assertThat(it).containsExactly(DomainOwner(pkg1.getName(), true))
371         }
372         manager1.getOwnersForDomain(DOMAIN_2).let {
373             assertThat(it).containsExactly(DomainOwner(pkg1.getName(), true))
374         }
375 
376         // Now assert for user 1 that it was unaffected by the change to user 0
377         service.getOwnersForDomain(DOMAIN_1, 1).let {
378             assertThat(it).containsExactly(
379                 DomainOwner(pkg1.getName(), false),
380                 DomainOwner(pkg2.getName(), false)
381             ).inOrder()
382         }
383         manager1.getOwnersForDomain(DOMAIN_1).let {
384             assertThat(it).containsExactly(
385                 DomainOwner(pkg1.getName(), false),
386                 DomainOwner(pkg2.getName(), false)
387             ).inOrder()
388         }
389 
390         service.setUserSelection(pkg1.domainSetId, setOf(DOMAIN_2), true, 0)
391 
392         service.getOwnersForDomain(DOMAIN_2, 1).let {
393             assertThat(it).containsExactly(DomainOwner(pkg1.getName(), true))
394         }
395         manager1.getOwnersForDomain(DOMAIN_2).let {
396             assertThat(it).containsExactly(DomainOwner(pkg1.getName(), true))
397         }
398 
399         // "Reinstall" the package to user 0
400         pkg1User0Enabled.set(false)
401 
402         // This state should have been cleared when the package was uninstalled
403         assertThat(service.getOwnersForDomain(DOMAIN_2, 0)).isEmpty()
404         assertThat(manager0.getOwnersForDomain(DOMAIN_2)).isEmpty()
405 
406         // Other package unaffected
407         service.setUserSelection(pkg2.domainSetId, setOf(DOMAIN_2), true, 0)
408         service.getOwnersForDomain(DOMAIN_2, 0).let {
409             assertThat(it).containsExactly(DomainOwner(pkg2.getName(), true))
410         }
411         manager0.getOwnersForDomain(DOMAIN_2).let {
412             assertThat(it).containsExactly(DomainOwner(pkg2.getName(), true))
413         }
414     }
415 
416     @Test
417     fun appProcessManager() {
418         // The app side DomainVerificationManager also has to do some argument enforcement since
419         // the input values are transformed before they are sent across Binder. Verify that here.
420 
421         // Mock nothing to ensure no calls are made before failing
422         val context = mockThrowOnUnmocked<Context>()
423         val binderInterface = mockThrowOnUnmocked<IDomainVerificationManager>()
424 
425         val manager = DomainVerificationManager(context, binderInterface)
426 
427         assertFailsWith(IllegalArgumentException::class) {
428             DomainVerificationJavaUtil.setStatusForceNullable(manager, null, setOf(DOMAIN_1), 1100)
429         }
430 
431         assertFailsWith(IllegalArgumentException::class) {
432             DomainVerificationJavaUtil.setStatusForceNullable(manager, UUID_ONE, null, 1100)
433         }
434 
435         assertFailsWith(IllegalArgumentException::class) {
436             manager.setDomainVerificationStatus(UUID_ONE, emptySet(), 1100)
437         }
438 
439         assertFailsWith(IllegalArgumentException::class) {
440             DomainVerificationJavaUtil.setUserSelectionForceNullable(
441                 manager, null,
442                 setOf(DOMAIN_1), true
443             )
444         }
445 
446         assertFailsWith(IllegalArgumentException::class) {
447             DomainVerificationJavaUtil.setUserSelectionForceNullable(
448                 manager, UUID_ONE,
449                 null, true
450             )
451         }
452 
453         assertFailsWith(IllegalArgumentException::class) {
454             manager.setDomainVerificationUserSelection(UUID_ONE, emptySet(), true)
455         }
456     }
457 
458     private fun makeService(vararg pkgSettings: PackageSetting) =
459             makeService { pkgName -> pkgSettings.find { pkgName == it.getName() } }
460 
461     private fun makeService(pkgSettingFunction: (String) -> PackageSetting? = { null }) =
462             DomainVerificationService(mockThrowOnUnmocked {
463                 // Assume the test has every permission necessary
464                 whenever(enforcePermission(anyString(), anyInt(), anyInt(), anyString()))
465                 whenever(checkPermission(anyString(), anyInt(), anyInt())) {
466                     PackageManager.PERMISSION_GRANTED
467                 }
468             }, mockThrowOnUnmocked {
469                 whenever(linkedApps) { ArraySet<String>() }
470             }, mockThrowOnUnmocked {
471                 whenever(isChangeEnabledInternalNoLogging(anyLong(), any())) { true }
472             }).apply {
473                 setConnection(mockThrowOnUnmocked {
474                     whenever(filterAppAccess(anyString(), anyInt(), anyInt())) { false }
475                     whenever(doesUserExist(0)) { true }
476                     whenever(doesUserExist(1)) { true }
477                     whenever(scheduleWriteSettings())
478 
479                     // Need to provide an internal UID so some permission checks are ignored
480                     whenever(callingUid) { Process.ROOT_UID }
481                     whenever(callingUserId) { 0 }
482 
483                     mockPackageSettings {
484                         pkgSettingFunction(it)
485                     }
486                 })
487             }
488 
489     private fun mockPkgSetting(
490         pkgName: String,
491         domainSetId: UUID,
492         domains: List<String> = listOf(DOMAIN_1, DOMAIN_2),
493         pkgUserState0: PackageSetting.() -> PackageUserState = { PackageUserState() },
494         pkgUserState1: PackageSetting.() -> PackageUserState = { PackageUserState() }
495     ) = mockThrowOnUnmocked<PackageSetting> {
496         val pkg = mockThrowOnUnmocked<AndroidPackage> {
497             whenever(packageName) { pkgName }
498             whenever(targetSdkVersion) { Build.VERSION_CODES.S }
499             whenever(isEnabled) { true }
500 
501             val activityList = listOf(
502                     ParsedActivity().apply {
503                         domains.forEach {
504                             addIntent(
505                                     ParsedIntentInfo().apply {
506                                         autoVerify = true
507                                         addAction(Intent.ACTION_VIEW)
508                                         addCategory(Intent.CATEGORY_BROWSABLE)
509                                         addCategory(Intent.CATEGORY_DEFAULT)
510                                         addDataScheme("http")
511                                         addDataScheme("https")
512                                         addDataPath("/sub", PatternMatcher.PATTERN_LITERAL)
513                                         addDataAuthority(it, null)
514                                     }
515                             )
516                         }
517                     }
518             )
519 
520             whenever(activities) { activityList }
521         }
522 
523         whenever(getPkg()) { pkg }
524         whenever(getName()) { pkgName }
525         whenever(this.domainSetId) { domainSetId }
526         whenever(getInstantApp(anyInt())) { false }
527         whenever(firstInstallTime) { 0L }
528         whenever(readUserState(0)) { pkgUserState0() }
529         whenever(readUserState(1)) { pkgUserState1() }
530         whenever(isSystem()) { false }
531     }
532 
533     private fun DomainVerificationService.addPackages(vararg pkgSettings: PackageSetting) =
534             pkgSettings.forEach(::addPackage)
535 
536     private fun makeManager(service: DomainVerificationService, userId: Int) =
537         DomainVerificationManager(mockThrowOnUnmocked { whenever(this.userId) { userId } },
538             DomainVerificationManagerStub(service))
539 }
540