def _parse_arguments():
"""
Static method for paring arguments
"""
parser = get_base_arguments(get_parser())
parser = get_tc_arguments(parser)
args, unknown = parser.parse_known_args()
return args, unknown
def test_args_from_file_with_file_infinite_recursion(self): # pylint: disable=invalid-name
sys.argv = ["filename.py", "--cfg_file",
os.path.abspath(os.path.join(os.path.dirname(__file__),
"data/conf_file_3.txt"))]
parser = get_parser() # pylint: disable=unused-variable
args, unknown = _parse_arguments() # pylint: disable=unused-variable
for arg in ["tcdir", "baudrate", "suitedir"]:
self.assertTrue(hasattr(args, arg))
self.assertEqual(args.tcdir, "shouldoverwrite")
def test_args_from_file(self):
sys.argv = ["filename.py", "--tc", "test_case_1", "--tcdir", "test_directory",
"--cfg_file",
os.path.abspath(os.path.join(os.path.dirname(__file__),
"data/conf_file.txt")),
"--suitedir",
"shouldoverwrite"]
parser = get_parser() # pylint: disable=unused-variable
args, unknown = _parse_arguments() # pylint: disable=unused-variable
for arg in ["tc", "tcdir", "cfg_file", "baudrate", "suitedir"]:
self.assertTrue(hasattr(args, arg))
self.assertEqual(args.tc, "test_case_1")
self.assertEqual(args.tcdir, "shouldoverwrite")
self.assertEqual(args.baudrate, 9600)
self.assertEqual(args.suitedir, "shouldoverwrite")
def check_args(self):
"""
Validates that a valid number of arguments were received and that all arguments were
recognised.
:return: True or False.
"""
parser = get_base_arguments(get_parser())
parser = get_tc_arguments(parser)
# Disable "Do not use len(SEQ) as condition value"
# pylint: disable=C1801
if len(sys.argv) < 2:
self.logger.error("Icetea called with no arguments! ")
parser.print_help()
return False
elif not self.args.ignore_invalid_params and self.unknown:
self.logger.error(
"Unknown parameters received, exiting. "
"To ignore this add --ignore_invalid_params flag.")
self.logger.error("Following parameters were unknown: {}".format(
self.unknown))
parser.print_help()
return False
return True
def _parse_arguments():
parser = get_base_arguments(get_parser())
parser = get_tc_arguments(parser)
args, unknown = parser.parse_known_args()
return args, unknown
def run(self, forceflash=False):
"""
Runs the testcase associated with this container.
:param forceflash: boolean, True if forceflash should be used
:return: Result
"""
if self.status == TestStatus.FINISHED:
self.logger.debug("Creating new bench instance for repeat.")
self._instance = self._create_new_bench_instance(self._modulename)
self.set_final_config()
self.status = TestStatus.RUNNING
self.logger.debug("Starting test case {}".format(self.tcname))
tc_instance = self.get_instance()
result = self._check_skip(tc_instance)
if result:
self.logger.debug("Skipping test case {}".format(self.tcname))
self._result = result
self.status = TestStatus.FINISHED
return result
# Check if version checking is enabled in cli
# and if the bench has the compatible key in it's config.
result = self._check_version(tc_instance)
if result is not None:
self.logger.debug(
"Version check triggered, skipping test case {}.".format(
self.tcname))
self._result = result
self.status = TestStatus.FINISHED
return result
parser = get_tc_arguments(get_base_arguments(get_parser()))
args, unknown = parser.parse_known_args()
if len(unknown) > 0:
for para in unknown:
self.logger.warning(
"Icetea received unknown parameter {}".format(para))
if not args.ignore_invalid_params:
self.logger.error(
"Unknown parameters received, exiting. To ignore this add --ignore_invalid_params flag."
)
parser.print_help()
result = tc_instance.get_result()
result.set_verdict(verdict="inconclusive",
retcode=-1,
duration=0)
self.status = TestStatus.FINISHED
return result
args.forceflash = forceflash
self.status = TestStatus.RUNNING
tc_instance.set_args(args)
self.logger.info("")
self.logger.info("START TEST CASE EXECUTION: '%s'" %
tc_instance.get_test_name())
self.logger.info("")
a = datetime.datetime.now()
try:
retcode = tc_instance.run()
self.logger.debug(
"Test bench returned return code {}".format(retcode))
except:
traceback.print_exc()
retcode = -9999
b = datetime.datetime.now()
result = tc_instance.get_result(tc_file=self._filepath)
# Force garbage collection
gc.collect()
# cleanup Testcase
tc_instance = None
LogManager.finish_testcase_logging()
self.status = TestStatus.FINISHED
if isinstance(result, ResultList):
self.logger.debug("Received a list of results from test bench.")
return result
if result.retcode == ReturnCodes.RETCODE_FAIL_ABORTED_BY_USER:
print("Press CTRL + C again if you want to abort test run")
try:
time.sleep(5)
except KeyboardInterrupt:
self.status = TestStatus.FINISHED
raise
c = b - a
duration = c.total_seconds()
self.logger.debug("Duration: {} seconds".format(duration))
verdict = None
if retcode == 0:
verdict = "pass"
elif retcode in ReturnCodes.INCONCLUSIVE_RETCODES:
verdict = "inconclusive"
elif retcode == ReturnCodes.RETCODE_SKIP:
verdict = "skip"
else:
verdict = "fail"
result.set_verdict(verdict=verdict, retcode=retcode, duration=duration)
self._result = result
return result
def __init__(self, **kwargs):
super(ArgsHandler, self).__init__(**kwargs)
parser = get_tc_arguments(get_base_arguments(get_parser()))
self.__args, self.__unknown = parser.parse_known_args()
