def test___init___all_params(self, mock_create_empty):
mock_adb = MagicMock()
mock_logger = MagicMock()
battery_file = "mybattery"
memory_file = "mymemory"
cpu_file = "mycpu"
num_samples = 5
collection_time_secs = 10
sample_interval_ms = 25
adb_control = adb_monitor.AdbControl(
mock_adb,
logger=mock_logger,
battery_file=battery_file,
memory_file=memory_file,
cpu_file=cpu_file,
append_file=True,
num_samples=num_samples,
collection_time_secs=10,
sample_interval_ms=sample_interval_ms)
self.assertEqual(adb_control.adb, mock_adb)
self.assertEqual(adb_control.battery_file, battery_file)
self.assertEqual(adb_control.memory_file, memory_file)
self.assertEqual(adb_control.cpu_file, cpu_file)
self.assertEqual(adb_control.num_samples, 0)
self.assertEqual(adb_control.collection_time_secs,
collection_time_secs)
self.assertEqual(adb_control.sample_interval_ms, sample_interval_ms)
mock_create_empty.assert_not_called()
def test_wait_thread_exception(self, mock_sample_monitor,
mock_continuous_monitor):
mock_adb = MagicMock()
mock_logger = MagicMock()
battery_file = "mybattery"
memory_file = "mymemory"
cpu_file = "mycpu"
num_samples = 5
collection_time_secs = 10
sample_interval_ms = 25
adb_control = adb_monitor.AdbControl(
mock_adb,
logger=mock_logger,
battery_file=battery_file,
memory_file=memory_file,
cpu_file=cpu_file,
append_file=True,
num_samples=num_samples,
collection_time_secs=10,
sample_interval_ms=sample_interval_ms)
mock_sample_monitor().exception = RuntimeError("my run time exception")
mock_continuous_monitor().exception = None
adb_control._should_stop = MagicMock()
adb_control.start()
with self.assertRaises(RuntimeError):
adb_control.wait()
adb_control._should_stop.wait.assert_called_once_with(
collection_time_secs)
adb_control._should_stop.set.assert_called_once()
mock_continuous_monitor().join.assert_called_once_with(
adb_control._JOIN_TIMEOUT)
self.assertEqual(mock_sample_monitor().join.call_count, 2)
mock_sample_monitor().join.assert_called_with(
adb_control._JOIN_TIMEOUT)
def test___init___battery_file(self, mock_create_empty):
mock_adb = MagicMock()
battery_file = "mybattery"
adb_control = adb_monitor.AdbControl(mock_adb,
battery_file=battery_file)
self.assertEqual(adb_control.adb, mock_adb)
self.assertEqual(adb_control.battery_file, battery_file)
self.assertIsNone(adb_control.memory_file)
self.assertIsNone(adb_control.cpu_file)
self.assertEqual(adb_control.num_samples, 0)
self.assertIsNone(adb_control.collection_time_secs)
self.assertEqual(adb_control.sample_interval_ms,
adb_monitor.DEFAULT_SAMPLE_INTERVAL_MS)
mock_create_empty.assert_called_once_with(battery_file)
def test___init___num_samples(self, mock_create_empty):
# pylint: disable=unused-argument
mock_adb = MagicMock()
battery_file = "mybattery"
num_samples = 5
adb_control = adb_monitor.AdbControl(mock_adb,
battery_file=battery_file,
num_samples=num_samples)
self.assertEqual(adb_control.adb, mock_adb)
self.assertEqual(adb_control.battery_file, battery_file)
self.assertIsNone(adb_control.memory_file)
self.assertIsNone(adb_control.cpu_file)
self.assertEqual(adb_control.num_samples, num_samples)
self.assertIsNone(adb_control.collection_time_secs)
self.assertEqual(adb_control.sample_interval_ms,
adb_monitor.DEFAULT_SAMPLE_INTERVAL_MS)
def _test_files(self, num_samples=1, collection_time_secs=0, sample_interval_ms=500,
arg_list=None):
args = {}
arg_file_list = []
for arg_name in arg_list:
arg_test_file = tempfile.NamedTemporaryFile(delete=False).name
args[arg_name] = arg_test_file
arg_file_list.append(arg_test_file)
adb_control = adb_monitor.AdbControl(self.adb, collection_time_secs=collection_time_secs,
num_samples=num_samples,
sample_interval_ms=sample_interval_ms, **args)
adb_control.start()
adb_control.wait()
for arg_file in arg_file_list:
self.assertGreater(os.stat(arg_file).st_size, 0)
os.remove(arg_file)
def before_test(self, test, test_report):
"""Start ADB monitoring."""
if self.adb:
battery_file = self._report_path(test, "battery.csv")
cpu_file = self._report_path(test, "cpu.json")
memory_file = self._report_path(test, "memory.csv")
self.adb_control = adb_monitor.AdbControl(
self.adb,
logger=self.hook_logger,
battery_file=battery_file,
cpu_file=cpu_file,
memory_file=memory_file,
sample_interval_ms=self.sample_interval_ms)
self.hook_logger.info("Starting ADB monitoring for test %s",
test.short_name())
self.hook_logger.info("ADB resource files: %s %s %s", battery_file,
cpu_file, memory_file)
self.adb_control.start()
def test_stop(self):
mock_adb = MagicMock()
mock_logger = MagicMock()
battery_file = "mybattery"
num_samples = 5
sample_interval_ms = 25
adb_control = adb_monitor.AdbControl(
mock_adb,
logger=mock_logger,
battery_file=battery_file,
append_file=True,
num_samples=num_samples,
sample_interval_ms=sample_interval_ms)
adb_control._should_stop = MagicMock()
adb_control.wait = MagicMock()
adb_control.stop()
adb_control._should_stop.set.assert_called_once()
adb_control.wait.assert_called_once()
def test_start_cpu(self, mock_sample_monitor, mock_continuous_monitor):
mock_adb = MagicMock()
mock_logger = MagicMock()
cpu_file = "mycpu"
collection_time_secs = 10
adb_control = adb_monitor.AdbControl(
mock_adb,
logger=mock_logger,
cpu_file=cpu_file,
append_file=True,
collection_time_secs=collection_time_secs)
adb_control.start()
self.assertEqual(len(adb_control._all_threads), 1)
self.assertEqual(len(adb_control._sample_based_threads), 0)
mock_continuous_monitor.assert_called_once_with(
cpu_file, adb_control._should_stop, mock_adb.systrace_start,
mock_adb.systrace_stop)
mock_continuous_monitor().start.assert_called_once()
mock_sample_monitor.assert_not_called()
def test___init___all_files(self, mock_create_empty):
mock_adb = MagicMock()
battery_file = "mybattery"
memory_file = "mymemory"
cpu_file = "mycpu"
adb_control = adb_monitor.AdbControl(mock_adb,
battery_file=battery_file,
memory_file=memory_file,
cpu_file=cpu_file)
self.assertEqual(adb_control.adb, mock_adb)
self.assertEqual(adb_control.battery_file, battery_file)
self.assertEqual(adb_control.memory_file, memory_file)
self.assertEqual(adb_control.cpu_file, cpu_file)
self.assertEqual(adb_control.num_samples, 0)
self.assertIsNone(adb_control.collection_time_secs)
self.assertEqual(adb_control.sample_interval_ms,
adb_monitor.DEFAULT_SAMPLE_INTERVAL_MS)
self.assertEqual(mock_create_empty.call_count, 3)
mock_create_empty.assert_any_call(battery_file)
mock_create_empty.assert_any_call(memory_file)
mock_create_empty.assert_any_call(cpu_file)
def test_start_battery(self, mock_sample_monitor, mock_continuous_monitor):
mock_adb = MagicMock()
mock_logger = MagicMock()
battery_file = "mybattery"
num_samples = 5
sample_interval_ms = 25
adb_control = adb_monitor.AdbControl(
mock_adb,
logger=mock_logger,
battery_file=battery_file,
append_file=True,
num_samples=num_samples,
sample_interval_ms=sample_interval_ms)
adb_control.start()
self.assertEqual(len(adb_control._all_threads), 1)
self.assertEqual(len(adb_control._sample_based_threads), 1)
mock_continuous_monitor.assert_not_called()
mock_sample_monitor.assert_called_once_with(battery_file,
adb_control._should_stop,
mock_adb.battery,
num_samples,
sample_interval_ms)
mock_sample_monitor().start.assert_called_once()
def test_wait_no_collection_time(self, mock_sample_monitor):
mock_adb = MagicMock()
mock_logger = MagicMock()
battery_file = "mybattery"
memory_file = "mymemory"
num_samples = 5
sample_interval_ms = 25
adb_control = adb_monitor.AdbControl(
mock_adb,
logger=mock_logger,
battery_file=battery_file,
memory_file=memory_file,
append_file=True,
num_samples=num_samples,
sample_interval_ms=sample_interval_ms)
mock_sample_monitor().exception = None
adb_control._should_stop = MagicMock()
adb_control.start()
adb_control.wait()
adb_control._should_stop.wait.assert_not_called()
adb_control._should_stop.set.assert_called_once()
self.assertEqual(mock_sample_monitor().join.call_count, 4)
mock_sample_monitor().join.assert_called_with(
adb_control._JOIN_TIMEOUT)
def test_start_all(self, mock_sample_monitor, mock_continuous_monitor):
mock_adb = MagicMock()
mock_logger = MagicMock()
battery_file = "mybattery"
memory_file = "mymemory"
cpu_file = "mycpu"
num_samples = 5
collection_time_secs = 10
sample_interval_ms = 25
adb_control = adb_monitor.AdbControl(
mock_adb,
logger=mock_logger,
battery_file=battery_file,
memory_file=memory_file,
cpu_file=cpu_file,
append_file=True,
num_samples=num_samples,
collection_time_secs=collection_time_secs,
sample_interval_ms=sample_interval_ms)
adb_control.start()
self.assertEqual(len(adb_control._all_threads), 3)
self.assertEqual(len(adb_control._sample_based_threads), 2)
mock_continuous_monitor.assert_called_once_with(
cpu_file, adb_control._should_stop, mock_adb.systrace_start,
mock_adb.systrace_stop)
mock_continuous_monitor().start.assert_called_once()
self.assertEqual(mock_sample_monitor.call_count, 2)
mock_sample_monitor.assert_any_call(battery_file,
adb_control._should_stop,
mock_adb.battery, 0,
sample_interval_ms)
mock_sample_monitor.assert_any_call(memory_file,
adb_control._should_stop,
mock_adb.memory, 0,
sample_interval_ms)
self.assertEqual(mock_sample_monitor().start.call_count, 2)
def test___init___no_files(self):
mock_adb = MagicMock()
with self.assertRaises(ValueError):
adb_monitor.AdbControl(mock_adb)
def test_no_file_arg(self):
self.assertRaises(ValueError, lambda: adb_monitor.AdbControl(self.adb))
