1 /*
2  * Copyright 2023 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 package com.android.server.bluetooth.satellite.test
17 
18 import android.content.ContentResolver
19 import android.content.Context
20 import android.os.Looper
21 import android.provider.Settings
22 import androidx.test.core.app.ApplicationProvider
23 import com.android.server.bluetooth.Log
24 import com.android.server.bluetooth.satellite.SETTINGS_SATELLITE_MODE_ENABLED
25 import com.android.server.bluetooth.satellite.SETTINGS_SATELLITE_MODE_RADIOS
26 import com.android.server.bluetooth.satellite.initialize
27 import com.android.server.bluetooth.satellite.isOn
28 import com.android.server.bluetooth.test.disableMode
29 import com.android.server.bluetooth.test.disableSensitive
30 import com.android.server.bluetooth.test.enableMode
31 import com.android.server.bluetooth.test.enableSensitive
32 import com.google.common.truth.Truth.assertThat
33 import org.junit.Before
34 import org.junit.Rule
35 import org.junit.Test
36 import org.junit.rules.TestName
37 import org.junit.runner.RunWith
38 import org.robolectric.RobolectricTestRunner
39 
40 @RunWith(RobolectricTestRunner::class)
41 class ModeListenerTest {
42     companion object {
setupSatelliteModeToOnnull43         internal fun setupSatelliteModeToOn(
44             resolver: ContentResolver,
45             looper: Looper,
46             callback: (m: Boolean) -> Unit
47         ) {
48             enableSensitive(resolver, looper, SETTINGS_SATELLITE_MODE_RADIOS)
49             enableMode(resolver, looper, SETTINGS_SATELLITE_MODE_ENABLED)
50 
51             initialize(looper, resolver, callback)
52         }
53 
setupSatelliteModeToOffnull54         internal fun setupSatelliteModeToOff(resolver: ContentResolver, looper: Looper) {
55             disableSensitive(resolver, looper, SETTINGS_SATELLITE_MODE_RADIOS)
56             disableMode(resolver, looper, SETTINGS_SATELLITE_MODE_ENABLED)
57         }
58     }
59 
60     @get:Rule val testName = TestName()
61 
62     private val resolver: ContentResolver =
63         ApplicationProvider.getApplicationContext<Context>().getContentResolver()
64 
65     private val looper: Looper = Looper.getMainLooper()
66 
67     private lateinit var mode: ArrayList<Boolean>
68 
69     @Before
setupnull70     public fun setup() {
71         Log.i("SatelliteModeListener", "\t--> setup of " + testName.getMethodName())
72         mode = ArrayList()
73     }
74 
enableSensitivenull75     private fun enableSensitive() {
76         enableSensitive(resolver, looper, SETTINGS_SATELLITE_MODE_RADIOS)
77     }
78 
disableSensitivenull79     private fun disableSensitive() {
80         disableSensitive(resolver, looper, SETTINGS_SATELLITE_MODE_RADIOS)
81     }
82 
disableModenull83     private fun disableMode() {
84         disableMode(resolver, looper, SETTINGS_SATELLITE_MODE_ENABLED)
85     }
86 
enableModenull87     private fun enableMode() {
88         enableMode(resolver, looper, SETTINGS_SATELLITE_MODE_ENABLED)
89     }
90 
callbacknull91     private fun callback(newMode: Boolean) = mode.add(newMode)
92 
93     @Test
94     fun initialize_whenNullSensitive_isOff() {
95         Settings.Global.putString(resolver, SETTINGS_SATELLITE_MODE_RADIOS, null)
96         enableMode()
97 
98         initialize(looper, resolver, this::callback)
99 
100         assertThat(isOn).isFalse()
101         assertThat(mode).isEmpty()
102     }
103 
104     @Test
initialize_whenNotSensitive_isOffnull105     fun initialize_whenNotSensitive_isOff() {
106         disableSensitive()
107         enableMode()
108 
109         initialize(looper, resolver, this::callback)
110 
111         assertThat(isOn).isFalse()
112         assertThat(mode).isEmpty()
113     }
114 
115     @Test
enable_whenNotSensitive_isOffnull116     fun enable_whenNotSensitive_isOff() {
117         disableSensitive()
118         disableMode()
119 
120         initialize(looper, resolver, this::callback)
121 
122         enableMode()
123 
124         assertThat(isOn).isFalse()
125         assertThat(mode).isEmpty()
126     }
127 
128     @Test
initialize_whenSensitive_isOffnull129     fun initialize_whenSensitive_isOff() {
130         enableSensitive()
131         disableMode()
132 
133         initialize(looper, resolver, this::callback)
134 
135         assertThat(isOn).isFalse()
136         assertThat(mode).isEmpty()
137     }
138 
139     @Test
initialize_whenSensitive_isOnnull140     fun initialize_whenSensitive_isOn() {
141         enableSensitive()
142         enableMode()
143 
144         initialize(looper, resolver, this::callback)
145 
146         assertThat(isOn).isTrue()
147         assertThat(mode).isEmpty()
148     }
149 
150     @Test
toggleSensitive_whenEnabled_isOnOffOnnull151     fun toggleSensitive_whenEnabled_isOnOffOn() {
152         enableSensitive()
153         enableMode()
154 
155         initialize(looper, resolver, this::callback)
156 
157         disableSensitive()
158         enableSensitive()
159 
160         assertThat(isOn).isTrue()
161         assertThat(mode).containsExactly(false, true)
162     }
163 
164     @Test
toggleEnable_whenSensitive_isOffOnOffnull165     fun toggleEnable_whenSensitive_isOffOnOff() {
166         enableSensitive()
167         disableMode()
168 
169         initialize(looper, resolver, this::callback)
170 
171         enableMode()
172         disableMode()
173 
174         assertThat(isOn).isFalse()
175         assertThat(mode).containsExactly(true, false)
176     }
177 
178     @Test
disable_whenDisabled_discardUpdatenull179     fun disable_whenDisabled_discardUpdate() {
180         enableSensitive()
181         disableMode()
182 
183         initialize(looper, resolver, this::callback)
184 
185         disableMode()
186 
187         assertThat(isOn).isFalse()
188         assertThat(mode).isEmpty()
189     }
190 
191     @Test
enabled_whenEnabled_discardOnChangenull192     fun enabled_whenEnabled_discardOnChange() {
193         enableSensitive()
194         enableMode()
195 
196         initialize(looper, resolver, this::callback)
197 
198         enableMode()
199 
200         assertThat(isOn).isTrue()
201         assertThat(mode).isEmpty()
202     }
203 
204     @Test
changeContent_whenDisabled_discardnull205     fun changeContent_whenDisabled_discard() {
206         enableSensitive()
207         disableMode()
208 
209         initialize(looper, resolver, this::callback)
210 
211         disableSensitive()
212         enableMode()
213 
214         assertThat(isOn).isFalse()
215         // As opposed to the bare RadioModeListener, similar consecutive event are discarded
216         assertThat(mode).isEmpty()
217     }
218 }
219