def writeline(self, data, crlf="\n"): # pylint: disable=arguments-differ
"""
Write data to process.
:param data: data to write
:param crlf: line end character
:return: Nothing
"""
GenericProcess.writeline(self, data, crlf=crlf)
def __init__(self,
type='process',
name='process',
config=None,
params=None):
Dut.__init__(self, name=name, params=params)
GenericProcess.__init__(self, self.name, logger=self.logger)
self.disable_io_prints() # because those are printed in Dut object
self.proc = False
self.type = type
self.config = config if config else {}
self.dutinformation = DutInformation(
self.type,
self.resource_id if self.resource_id else "",
index=None,
build=None)
self.command = None
def readline(self, timeout=1):
"""
Read a line from the process.
:param timeout: Timeout
:return: read line
"""
return GenericProcess.readline(self, timeout=timeout)
def start_external_services(self):
"""
Start ExtApps required by test case.
:return: Nothing
"""
apps = get(self._config, 'requirements.external.apps', [])
for app in apps:
# Check if we have an environment configuration for this app
conf = app
try:
conf = merge(conf, self._env["extApps"][app["name"]])
except KeyError:
self._logger.warning("Unable to merge configuration for app %s", app,
exc_info=True if not self._args.silent else False)
if 'name' in app:
try:
self.pluginmanager.start_external_service(app['name'], conf=conf)
except PluginException:
self._logger.error("Failed to start requested external services.")
raise EnvironmentError("Failed to start requested external services.")
self._logger.info("done")
else:
conf_path = None
conf_cmd = None
try:
conf_path = conf["path"]
except KeyError:
self._logger.warning("No path defined for app %s", app)
try:
conf_cmd = conf["cmd"]
except KeyError:
self._logger.warning("No command defined for app %s", app)
appname = 'generic'
newapp = GenericProcess(name=appname, path=conf_path, cmd=conf_cmd)
newapp.ignore_return_code = True
newapp.start_process()
def test_usevalgrind(self):
my_process = GenericProcess("test", logger=MockLogger())
with self.assertRaises(AttributeError):
my_process.use_valgrind("test", True, True, True, True)
my_process.use_valgrind("memcheck", 1, 2, 3, 4)
self.assertEqual(my_process.valgrind, "memcheck")
self.assertEqual(my_process.valgrind_xml, 1)
self.assertEqual(my_process.valgrind_console, 2)
self.assertEqual(my_process.valgrind_track_origins, 3)
self.assertEqual(my_process.valgrind_extra_params, 4)
def test_stop_process_errors(self, mocked_os):
mocked_os.killpg = mock.MagicMock(side_effect=OSError)
my_process = GenericProcess("test", logger=MockLogger())
mocked_proc = mock.MagicMock()
pid = 11111111
type(mocked_proc).pid = mock.PropertyMock(return_value=pid)
type(my_process).proc = mock.PropertyMock(return_value=mocked_proc)
my_process.stop_process()
self.assertEqual(mocked_os.killpg.call_count, 3)
mocked_os.killpg.reset_mock()
mocked_os.killpg.side_effect = None
mocked_os.killpg.return_value = 1
mocked_proc.poll = mock.MagicMock()
mocked_proc.poll.side_effect = [1, 1]
with self.assertRaises(TestStepError):
my_process.stop_process()
def test_stop_process(self, mocked_time, mocked_os):
mocked_os.killpg = mock.MagicMock()
mocked_time.sleep = mock.MagicMock(return_value=1)
my_process = GenericProcess("test", logger=MockLogger())
my_process.read_thread = mock.MagicMock()
my_process.read_thread.stop = mock.MagicMock()
my_process.stop_process()
my_process.read_thread.stop.assert_called_once()
mocked_proc = mock.MagicMock()
pid = 11111111
type(mocked_proc).pid = mock.PropertyMock(return_value=pid)
mocked_proc.poll = mock.MagicMock()
mocked_proc.poll.side_effect = [
None, None, None, None, None, None, None, None, None, None, None,
None, None, None, 0, 0, 0, 0, 0
]
type(my_process).proc = mock.PropertyMock(return_value=mocked_proc)
my_process.stop_process()
self.assertEqual(mocked_os.killpg.call_count, 3)
mocked_os.killpg.assert_has_calls([
mock.call(pid, signal.SIGINT),
mock.call(pid, signal.SIGTERM),
mock.call(pid, signal.SIGKILL)
])
my_process = GenericProcess("test", logger=MockLogger())
my_process.read_thread = mock.MagicMock()
my_process.read_thread.stop = mock.MagicMock()
my_process.stop_process()
my_process.read_thread.stop.assert_called_once()
mocked_proc = mock.MagicMock()
pid = 11111111
type(mocked_proc).pid = mock.PropertyMock(return_value=pid)
mocked_proc.poll = mock.MagicMock()
mocked_proc.poll.side_effect = [
None, None, None, None, None, None, None, None, None, 0, 0, 0
]
type(my_process).proc = mock.PropertyMock(return_value=mocked_proc)
mocked_os.killpg.reset_mock()
my_process.stop_process()
self.assertEqual(mocked_os.killpg.call_count, 2)
mocked_os.killpg.assert_has_calls(
[mock.call(pid, signal.SIGINT),
mock.call(pid, signal.SIGTERM)])
def test_getters_and_setters(self):
my_process = GenericProcess("test", logger=MockLogger())
self.assertFalse(my_process.gdb)
my_process.use_gdb()
self.assertTrue(my_process.gdb)
my_process.use_gdb(False)
self.assertFalse(my_process.gdb)
self.assertFalse(my_process.gdbs)
my_process.use_gdbs()
self.assertTrue(my_process.gdbs)
self.assertEqual(my_process.gdbs_port, 2345)
my_process.use_gdbs(False)
self.assertFalse(my_process.gdbs)
my_process.gdbs_port = 1234
self.assertEqual(my_process.gdbs_port, 1234)
self.assertFalse(my_process.vgdb)
my_process.use_vgdb()
self.assertTrue(my_process.vgdb)
my_process.use_vgdb(False)
self.assertFalse(my_process.vgdb)
self.assertFalse(my_process.nobuf)
my_process.no_std_buf()
self.assertTrue(my_process.nobuf)
my_process.no_std_buf(False)
self.assertFalse(my_process.nobuf)
self.assertIsNone(my_process.valgrind_xml)
my_process.valgrind_xml = True
self.assertTrue(my_process.valgrind_xml)
self.assertFalse(my_process.valgrind_console)
my_process.valgrind_console = True
self.assertTrue(my_process.valgrind_console)
self.assertFalse(my_process.valgrind_track_origins)
my_process.valgrind_track_origins = True
self.assertTrue(my_process.valgrind_track_origins)
self.assertFalse(my_process.valgrind_extra_params)
my_process.valgrind_extra_params = True
self.assertTrue(my_process.valgrind_extra_params)
self.assertFalse(my_process.ignore_return_code)
my_process.ignore_return_code = True
self.assertTrue(my_process.ignore_return_code)
my_process.ignore_return_code = False
self.assertFalse(my_process.ignore_return_code)