• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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     private val resolver: ContentResolver =
61         ApplicationProvider.getApplicationContext<Context>().getContentResolver()
62     @JvmField @Rule val testName = TestName()
63 
64     private val looper: Looper = Looper.getMainLooper()
65 
66     private lateinit var mode: ArrayList<Boolean>
67 
68     @Before
setupnull69     public fun setup() {
70         Log.i("SatelliteModeListener", "\t--> setup of " + testName.getMethodName())
71         mode = ArrayList()
72     }
73 
enableSensitivenull74     private fun enableSensitive() {
75         enableSensitive(resolver, looper, SETTINGS_SATELLITE_MODE_RADIOS)
76     }
77 
disableSensitivenull78     private fun disableSensitive() {
79         disableSensitive(resolver, looper, SETTINGS_SATELLITE_MODE_RADIOS)
80     }
81 
disableModenull82     private fun disableMode() {
83         disableMode(resolver, looper, SETTINGS_SATELLITE_MODE_ENABLED)
84     }
85 
enableModenull86     private fun enableMode() {
87         enableMode(resolver, looper, SETTINGS_SATELLITE_MODE_ENABLED)
88     }
89 
callbacknull90     private fun callback(newMode: Boolean) = mode.add(newMode)
91 
92     @Test
93     fun initialize_whenNullSensitive_isOff() {
94         Settings.Global.putString(resolver, SETTINGS_SATELLITE_MODE_RADIOS, null)
95         enableMode()
96 
97         initialize(looper, resolver, this::callback)
98 
99         assertThat(isOn).isFalse()
100         assertThat(mode).isEmpty()
101     }
102 
103     @Test
initialize_whenNotSensitive_isOffnull104     fun initialize_whenNotSensitive_isOff() {
105         disableSensitive()
106         enableMode()
107 
108         initialize(looper, resolver, this::callback)
109 
110         assertThat(isOn).isFalse()
111         assertThat(mode).isEmpty()
112     }
113 
114     @Test
enable_whenNotSensitive_isOffnull115     fun enable_whenNotSensitive_isOff() {
116         disableSensitive()
117         disableMode()
118 
119         initialize(looper, resolver, this::callback)
120 
121         enableMode()
122 
123         assertThat(isOn).isFalse()
124         assertThat(mode).isEmpty()
125     }
126 
127     @Test
initialize_whenSensitive_isOffnull128     fun initialize_whenSensitive_isOff() {
129         enableSensitive()
130         disableMode()
131 
132         initialize(looper, resolver, this::callback)
133 
134         assertThat(isOn).isFalse()
135         assertThat(mode).isEmpty()
136     }
137 
138     @Test
initialize_whenSensitive_isOnnull139     fun initialize_whenSensitive_isOn() {
140         enableSensitive()
141         enableMode()
142 
143         initialize(looper, resolver, this::callback)
144 
145         assertThat(isOn).isTrue()
146         assertThat(mode).isEmpty()
147     }
148 
149     @Test
toggleSensitive_whenEnabled_isOnOffOnnull150     fun toggleSensitive_whenEnabled_isOnOffOn() {
151         enableSensitive()
152         enableMode()
153 
154         initialize(looper, resolver, this::callback)
155 
156         disableSensitive()
157         enableSensitive()
158 
159         assertThat(isOn).isTrue()
160         assertThat(mode).containsExactly(false, true)
161     }
162 
163     @Test
toggleEnable_whenSensitive_isOffOnOffnull164     fun toggleEnable_whenSensitive_isOffOnOff() {
165         enableSensitive()
166         disableMode()
167 
168         initialize(looper, resolver, this::callback)
169 
170         enableMode()
171         disableMode()
172 
173         assertThat(isOn).isFalse()
174         assertThat(mode).containsExactly(true, false)
175     }
176 
177     @Test
disable_whenDisabled_discardUpdatenull178     fun disable_whenDisabled_discardUpdate() {
179         enableSensitive()
180         disableMode()
181 
182         initialize(looper, resolver, this::callback)
183 
184         disableMode()
185 
186         assertThat(isOn).isFalse()
187         assertThat(mode).isEmpty()
188     }
189 
190     @Test
enabled_whenEnabled_discardOnChangenull191     fun enabled_whenEnabled_discardOnChange() {
192         enableSensitive()
193         enableMode()
194 
195         initialize(looper, resolver, this::callback)
196 
197         enableMode()
198 
199         assertThat(isOn).isTrue()
200         assertThat(mode).isEmpty()
201     }
202 
203     @Test
changeContent_whenDisabled_discardnull204     fun changeContent_whenDisabled_discard() {
205         enableSensitive()
206         disableMode()
207 
208         initialize(looper, resolver, this::callback)
209 
210         disableSensitive()
211         enableMode()
212 
213         assertThat(isOn).isFalse()
214         // As opposed to the bare RadioModeListener, similar consecutive event are discarded
215         assertThat(mode).isEmpty()
216     }
217 }
218