| """Tests for blueberry.map.bluetooth_map.""" |
| from __future__ import absolute_import |
| from __future__ import division |
| from __future__ import print_function |
| |
| import queue |
| import time |
| |
| from mobly import test_runner |
| from mobly import signals |
| from mobly import utils |
| |
| from blueberry.controllers import android_bt_target_device |
| from blueberry.utils import blueberry_base_test |
| |
| _SMS_MSG_EVENT = 'SmsReceived' |
| _MAP_MSG_EVENT = 'MapMessageReceived' |
| |
| _EVENT_TIMEOUT_SEC = 180 |
| _TEXT_LENGTH = 10 |
| _TEXT_COUNT = 5 |
| |
| |
| class BluetoothMapTest(blueberry_base_test.BlueberryBaseTest): |
| """Test Class for Bluetooth MAP Test.""" |
| |
| def setup_class(self): |
| """Standard Mobly setup class.""" |
| super().setup_class() |
| for device in self.android_devices: |
| device.init_setup() |
| device.sl4a_setup() |
| |
| # Primary phone which role is Message Server Equipment (MSE). |
| self.pri_phone = self.android_devices[0] |
| self.pri_phone.sl4a.smsStartTrackingIncomingSmsMessage() |
| self.pri_number = self.pri_phone.dimensions['phone_number'] |
| |
| # Secondary phone which is used to send SMS messages to primary phone. |
| self.sec_phone = self.android_devices[1] |
| |
| # Bluetooth carkit which role is Message Client Equipment (MCE). |
| self.derived_bt_device = self.derived_bt_devices[0] |
| |
| mac_address = self.derived_bt_device.get_bluetooth_mac_address() |
| self.derived_bt_device.activate_pairing_mode() |
| self.pri_phone.pair_and_connect_bluetooth(mac_address) |
| # Sleep to make the connection to be steady. |
| time.sleep(5) |
| |
| if isinstance( |
| self.derived_bt_device, android_bt_target_device.AndroidBtTargetDevice): |
| # Allow sl4a to receive the intent with ACTION_MESSAGE_RECEIVED. |
| self.derived_bt_device.adb.shell( |
| 'pm grant com.googlecode.android_scripting ' |
| 'android.permission.RECEIVE_SMS') |
| # Connect derived bt device to primary phone via MAP MCE profile. |
| self.derived_bt_device.add_sec_ad_device(self.pri_phone) |
| |
| def teardown_test(self): |
| """Standard Mobly teardown test. |
| |
| Disconnects the MAP connection after a test completes. |
| """ |
| super().teardown_test() |
| self.derived_bt_device.map_disconnect() |
| |
| def _wait_for_message_on_mce(self, text): |
| """Waits for that MCE gets an event with specific message. |
| |
| Args: |
| text: String, Text of the message. |
| |
| Raises: |
| TestFailure: Raised if timed out. |
| """ |
| try: |
| self.derived_bt_device.ed.wait_for_event( |
| _MAP_MSG_EVENT, lambda e: e['data'] == text, _EVENT_TIMEOUT_SEC) |
| self.derived_bt_device.log.info( |
| 'Successfully got the unread message: %s' % text) |
| except queue.Empty: |
| raise signals.TestFailure( |
| 'Timed out after %ds waiting for "%s" event with the message: %s' % |
| (_EVENT_TIMEOUT_SEC, _MAP_MSG_EVENT, text)) |
| |
| def _wait_for_message_on_mse(self, text): |
| """Waits for that MSE gets an event with specific message. |
| |
| This method is used to make sure that MSE has received the test message. |
| |
| Args: |
| text: String, Text of the message. |
| |
| Raises: |
| TestError: Raised if timed out. |
| """ |
| try: |
| self.pri_phone.ed.wait_for_event( |
| _SMS_MSG_EVENT, lambda e: e['data']['Text'] == text, |
| _EVENT_TIMEOUT_SEC) |
| self.pri_phone.log.info( |
| 'Successfully received the incoming message: %s' % text) |
| except queue.Empty: |
| raise signals.TestError( |
| 'Timed out after %ds waiting for "%s" event with the message: %s' % |
| (_EVENT_TIMEOUT_SEC, _SMS_MSG_EVENT, text)) |
| |
| def _create_message_on_mse(self, text): |
| """Creates a new incoming message on MSE. |
| |
| Args: |
| text: String, Text of the message. |
| """ |
| self.sec_phone.sl4a.smsSendTextMessage(self.pri_number, text, False) |
| self._wait_for_message_on_mse(text) |
| |
| def test_get_existing_unread_messages(self): |
| """Test for the feature of getting existing unread messages on MCE. |
| |
| Tests MCE can list existing messages of MSE. |
| """ |
| text_list = [] |
| # Creates 5 SMS messages on MSE before establishing connection. |
| for _ in range(_TEXT_COUNT): |
| text = utils.rand_ascii_str(_TEXT_LENGTH) |
| self._create_message_on_mse(text) |
| text_list.append(text) |
| self.derived_bt_device.map_connect() |
| # Gets the unread messages of MSE and checks if they are downloaded |
| # successfully on MCE. |
| self.derived_bt_device.get_unread_messages() |
| for text in text_list: |
| self._wait_for_message_on_mce(text) |
| |
| def test_receive_unread_message(self): |
| """Test for the feature of receiving unread message on MCE. |
| |
| Tests MCE can get an unread message when MSE receives an incoming message. |
| """ |
| self.derived_bt_device.map_connect() |
| text = utils.rand_ascii_str(_TEXT_LENGTH) |
| self._create_message_on_mse(text) |
| self._wait_for_message_on_mce(text) |
| |
| |
| if __name__ == '__main__': |
| test_runner.main() |