def test_rfcomm_connection(self): """Test bluetooth RFCOMM connection Test RFCOMM though establishing a basic connection. Steps: 1. Get the mac address of the server device. 2. Establish an RFCOMM connection from the client to the server AD. 3. Verify that the RFCOMM connection is active from both the client and server. Expected Result: RFCOMM connection is established then disconnected succcessfully. Returns: Pass if True Fail if False TAGS: Classic, RFCOMM Priority: 1 """ if not orchestrate_rfcomm_connection(self.client_ad, self.server_ad): return False self.client_ad.droid.bluetoothRfcommStop() self.server_ad.droid.bluetoothRfcommStop() return True
def test_rfcomm_connection_stress(self): """Stress test an RFCOMM connection Test the integrity of RFCOMM. Verify that file descriptors are cleared out properly. Steps: 1. Establish a bonding between two Android devices. 2. Write data to RFCOMM from the client droid. 3. Read data from RFCOMM from the server droid. 4. Stop the RFCOMM connection. 5. Repeat steps 2-4 1000 times. Expected Result: Each iteration should read and write to the RFCOMM connection successfully. Returns: Pass if True Fail if False TAGS: Classic, Stress, RFCOMM Priority: 1 """ iterations = 10000 for n in range(iterations): if not orchestrate_rfcomm_connection(self.client_ad, self.server_ad): return False self.client_ad.droid.bluetoothRfcommStop() self.server_ad.droid.bluetoothRfcommStop() self.log.info("Iteration {} completed".format(n)) return True
def _test_rfcomm_connection_with_uuid(self, uuid): if not orchestrate_rfcomm_connection( self.client_ad, self.server_ad, uuid=uuid): return False self.client_ad.droid.bluetoothRfcommStop() self.server_ad.droid.bluetoothRfcommStop() return True
def test_rfcomm_longev_read_write_small_message(self): """Longevity test an RFCOMM connection's I/O with a small message Test the longevity of RFCOMM with a basic read/write connect/disconnect sequence. The data being transfered is only one character in size. Steps: 1. Establish a bonding between two Android devices. 2. Write data to RFCOMM from the client droid. 3. Read data from RFCOMM from the server droid. 4. Verify data written matches data read. 5. Repeat steps 2-4 5000 times. 6. Disconnect RFCOMM connection. 7. Repeat steps 1-6 1000 times. Expected Result: Each iteration should read and write to the RFCOMM connection successfully. Each connect and disconnect should be successful. Returns: Pass if True Fail if False TAGS: Classic, Longevity, RFCOMM Priority: 2 """ message = "x" for i in range(self.longev_iterations): self.log.info("iteration {} connection".format(i + 1)) if not orchestrate_rfcomm_connection(self.client_ad, self.server_ad): return False for n in range(self.write_iterations): self.log.info("iteration {} data".format( ((n + 1) + (i * self.write_iterations)))) if not write_read_verify_data(self.client_ad, self.server_ad, message, False): return False self.log.info("Iteration {} completed".format(n)) self.client_ad.droid.bluetoothRfcommStop() self.server_ad.droid.bluetoothRfcommStop() return True
def _connect_rfcomm(self): """Establishes an RFCOMM connection between two phones. Connects the client device to the server device given the hardware address of the server device. """ set_location_service(self.client_device, True) set_location_service(self.server_device, True) server_address = self.server_device.droid.bluetoothGetLocalAddress() self.log.info('Pairing and connecting devices') asserts.assert_true( self.client_device.droid.bluetoothDiscoverAndBond(server_address), 'Failed to pair and connect devices') # Create RFCOMM connection asserts.assert_true( orchestrate_rfcomm_connection(self.client_device, self.server_device), 'Failed to establish RFCOMM connection')
def test_rfcomm_write_binary(self): """Test bluetooth RFCOMM writing and reading binary data Test profile though establishing an RFCOMM connection. Steps: 1. Get the mac address of the server device. 2. Establish an RFCOMM connection from the client to the server AD. 3. Verify that the RFCOMM connection is active from both the client and server. 4. Write data from the client and read received data from the server. 5. Verify data matches from client and server 6. Disconnect the RFCOMM connection. Expected Result: RFCOMM connection is established then disconnected succcessfully. Returns: Pass if True Fail if False TAGS: Classic, RFCOMM Priority: 1 """ if not orchestrate_rfcomm_connection(self.client_ad, self.server_ad): return False binary_message = "11010101" if not write_read_verify_data(self.client_ad, self.server_ad, binary_message, True): return False if not verify_server_and_client_connected(self.client_ad, self.server_ad): return False self.client_ad.droid.bluetoothRfcommStop() self.server_ad.droid.bluetoothRfcommStop() return True
def test_rfcomm_longev_data_elasticity(self): """Longevity test an RFCOMM connection's I/O with changing data size Test the longevity of RFCOMM with a basic read/write connect/disconnect sequence. The data being transfered changes in size after each write/read sequence to increase up to 990 chars in size and decrease down to 1 in size. This repeats through the entire test in order to exercise different size values being written. Steps: 1. Establish a bonding between two Android devices. 2. Write data to RFCOMM from the client droid. 3. Read data from RFCOMM from the server droid. 4. Verify data written matches data read. 5. Change data size according to above description. 6. Repeat steps 2-5 5000 times. 7. Disconnect RFCOMM connection. 8. Repeat steps 1-6 1000 times. Expected Result: Each iteration should read and write to the RFCOMM connection successfully. Each connect and disconnect should be successful. Returns: Pass if True Fail if False TAGS: Classic, Longevity, RFCOMM Priority: 2 """ message = "x" resize_toggle = 1 for i in range(self.longev_iterations): try: self.log.info("iteration {} connection".format(i + 1)) if not orchestrate_rfcomm_connection(self.client_ad, self.server_ad): return False for n in range(self.write_iterations): self.log.info("iteration {} data".format( ((n + 1) + (i * self.write_iterations)))) if not write_read_verify_data( self.client_ad, self.server_ad, message, False): return False self.log.info("Iteration {} completed".format(n)) size_of_message = len(message) #max size is 990 due to a bug in sl4a. if size_of_message >= 990: resize_toggle = 0 elif size_of_message <= 1: resize_toggle = 1 if resize_toggle == 0: message = "x" * (size_of_message - 1) else: message = "x" * (size_of_message + 1) self.client_ad.droid.bluetoothRfcommStop() self.server_ad.droid.bluetoothRfcommStop() except Exception as err: self.log.info("Error in longevity test: {}".format(err)) return False return True
def test_rfcomm_longev_connection_interuption(self): """Longevity test an RFCOMM connection's with socket interuptions Test the longevity of RFCOMM with a basic read/write connect/disconnect sequence. Randomly in the sequence of reads and writes the socket on the client side will close. There should be an exception thrown for writing the next set of data and the test should start up a new connection and continue. Steps: 1. Establish a bonding between two Android devices. 2. Write data to RFCOMM from the client droid. 3. Read data from RFCOMM from the server droid. 4. Verify data written matches data read. 5. Repeat steps 2-4 5000 times or until the random interupt occurs. 6. Re-establish an RFCOMM connection. 7. Repeat steps 1-6 1000 times. Expected Result: Each iteration should read and write to the RFCOMM connection successfully. Each connect and disconnect should be successful. Devices should recover a new connection after each interruption. Returns: Pass if True Fail if False TAGS: Classic, Longevity, RFCOMM Priority: 2 """ for i in range(self.longev_iterations): try: self.log.info("iteration {} connection".format(i + 1)) if not orchestrate_rfcomm_connection(self.client_ad, self.server_ad): return False random_interup_iteration = randint(0, self.write_iterations) for n in range(self.write_iterations): self.log.info("iteration {} data".format( ((n + 1) + (i * self.write_iterations)))) if not write_read_verify_data(self.client_ad, self.server_ad, self.generic_message, False): return False self.log.info("Iteration {} completed".format(n)) if n > random_interup_iteration: self.client_ad.droid.bluetoothRfcommCloseSocket() self.client_ad.droid.bluetoothRfcommStop() self.server_ad.droid.bluetoothRfcommStop() except Exception: self.log.info("Exception found as expected. Continuing...") try: self.client_ad.droid.bluetoothRfcommStop() except Exception as err: self.log.error( "Error closing client connection: {}".format(err)) return False try: self.server_ad.droid.bluetoothRfcommStop() except Exception as err: self.log.error( "Error closing server connection: {}".format(err)) return False return True