holado 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

holado_scripting/text/interpreter/text_interpreter.py

@@ -60,12 +60,11 @@ class TextInterpreter(TextInspecter):
         if str_to_interpret is None:
             return None
         
-        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-        
-            logger.trace("Interpreting '{}'...".format(str_to_interpret))
+        if Tools.do_log(logger, logging.TRACE, max_log_level=log_level):  # @UndefinedVariable
+            logger.log(Tools.do_log_level(logging.TRACE, log_level), "Interpreting '{}'...".format(str_to_interpret))  # @UndefinedVariable
         
         # Interpret and get result as object
-        res, _ = self.__interpret(str_to_interpret, eval_params=eval_params)
+        res, _ = self.__interpret(str_to_interpret, eval_params=eval_params, log_level=log_level)
 
         if Tools.do_log_if_objects_are_different(logger, log_level, str_to_interpret, res):
             logger.log(log_level, "Interpreting '{}' -> [{}] (type: {})".format(str_to_interpret, res, type(res)))
@@ -82,18 +81,17 @@ class TextInterpreter(TextInspecter):
         if str_to_interpret is None:
             return None
         
-        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-        
-            logger.trace("Interpreting sections in '{}'...".format(str_to_interpret))
+        if Tools.do_log(logger, logging.TRACE, max_log_level=log_level):  # @UndefinedVariable
+            logger.log(Tools.do_log_level(logging.TRACE, log_level), "Interpreting sections in '{}'...".format(str_to_interpret))  # @UndefinedVariable
         
         # Interpret and get result as object
-        res, locals_ = self.__interpret(str_to_interpret, replace_sections_by_variables=True, eval_params=eval_params)
+        res, locals_ = self.__interpret(str_to_interpret, replace_sections_by_variables=True, eval_params=eval_params, log_level=log_level)
 
         if Tools.do_log_if_objects_are_different(logger, log_level, str_to_interpret, res):
             logger.log(log_level, f"Interpreting sections in '{str_to_interpret}' -> [{res}] (type: {type(res)}, locals: {locals_})")
         return res, locals_
 
-    def __interpret(self, str_to_interpret, replace_sections_by_variables=False, eval_params=EvaluateParameters.default_without_raise()):
+    def __interpret(self, str_to_interpret, replace_sections_by_variables=False, eval_params=EvaluateParameters.default_without_raise(), log_level=logging.DEBUG):
         res = None
         locals_ = {}
         
@@ -103,7 +101,7 @@ class TextInterpreter(TextInspecter):
             r_match = self.__regex_to_be_interpreted.match(str_to_interpret)
             if r_match:
                 str_under_interpret = r_match.group(1).strip()
-                res = self.__interpret_text(str_under_interpret, eval_params=eval_params)
+                res = self.__interpret_text(str_under_interpret, eval_params=eval_params, log_level=log_level)
                 # Text is not interpretable ; expect it will be the case later
                 if res == str_under_interpret:
                     res = str_to_interpret
@@ -112,19 +110,20 @@ class TextInterpreter(TextInspecter):
             else:
                 raise TechnicalException(f"Failed to find interpret section whereas its indexes were found")
         else:
-            res, locals_ = self.__find_and_interpret_sections(str_to_interpret, replace_sections_by_variables=replace_sections_by_variables, eval_params=eval_params)
+            res, locals_ = self.__find_and_interpret_sections(str_to_interpret, replace_sections_by_variables=replace_sections_by_variables, eval_params=eval_params, log_level=log_level)
             
         return res, locals_
     
-    def __interpret_text(self, text, eval_params=EvaluateParameters.default_without_raise()):
+    def __interpret_text(self, text, eval_params=EvaluateParameters.default_without_raise(), log_level=logging.DEBUG):  # @UndefinedVariable
         # Manage functions
         if self._has_function(text, with_interpreted=False):
-            return self.__evaluate_function(text, eval_params=eval_params)
+            return self.__evaluate_function(text, eval_params=eval_params, log_level=log_level)
         
         # Manage evaluation
-        return self._expression_evaluator.evaluate_expression(text, eval_params=eval_params, log_level=logging.TRACE)  # @UndefinedVariable
+        _, res = self._expression_evaluator.evaluate_expression(text, eval_params=eval_params, log_level=Tools.do_log_level(log_level, logging.TRACE))  # @UndefinedVariable
+        return res
     
-    def __find_and_interpret_sections(self, str_to_interpret, replace_sections_by_variables=False, eval_params=EvaluateParameters.default_without_raise()):
+    def __find_and_interpret_sections(self, str_to_interpret, replace_sections_by_variables=False, eval_params=EvaluateParameters.default_without_raise(), log_level=logging.DEBUG):
         res = str_to_interpret
         locals_ = {}
         
@@ -145,7 +144,7 @@ class TextInterpreter(TextInspecter):
             sub_str = res[ind_beg:ind_end]
             
             # Interpret sub-section
-            interpreted_value = self.interpret(sub_str, eval_params=eval_params)
+            interpreted_value = self.interpret(sub_str, eval_params=eval_params, log_level=log_level)
             
             # Manage sections that aren't interpretable
             interpreted_str = f"{interpreted_value}"
@@ -170,7 +169,7 @@ class TextInterpreter(TextInspecter):
                 
         return res, locals_
     
-    def __evaluate_function(self, fct_str, eval_params=EvaluateParameters.default_without_raise()):
+    def __evaluate_function(self, fct_str, eval_params=EvaluateParameters.default_without_raise(), log_level=logging.DEBUG):
         func_name, args_str = self._get_function_and_args_strings(fct_str, with_interpreted=False)
         func = self._get_function(func_name) if func_name is not None else None
         if func is None:
@@ -178,8 +177,8 @@ class TextInterpreter(TextInspecter):
         
         args = self._get_args(args_str)
         
-        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-            logger.trace(f"Evaluating function '{func_name}' with args {args}")
+        if Tools.do_log(logger, logging.TRACE, max_log_level=log_level):  # @UndefinedVariable
+            logger.log(Tools.do_log_level(logging.TRACE, max_log_level=log_level), f"Evaluating function '{func_name}' with args {args}")  # @UndefinedVariable
             # logger.trace(f"Evaluating function '{func_name}' with args {args} (eval_params: {eval_params})", stack_info=True)
         try:
             res = func.apply(args)
@@ -189,8 +188,8 @@ class TextInterpreter(TextInspecter):
             else:
                 res = fct_str
                 
-        if Tools.do_log(logger, logging.DEBUG):
-            logger.debug(f"Evaluate function [{fct_str}] => [{func_name}({', '.join(args)})] => [{res}] (type: {Typing.get_object_class_fullname(res)})")
+        if Tools.do_log(logger, log_level):
+            logger.log(log_level, f"Evaluate function [{fct_str}] => [{func_name}({', '.join(args)})] => [{res}] (type: {Typing.get_object_class_fullname(res)})")
         return res
     
     def __register_default_functions(self, dynamic_text_manager):

holado_test/behave/behave_environment.py

@@ -22,6 +22,8 @@ from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
 from holado_test.scenario.step_tools import StepTools
 from holado_test.test_config import TestConfig
 import time
+from behave.model_core import Status
+from holado.common.handlers.undefined import undefined_value
 
 
 logger = logging.getLogger(__name__)
@@ -107,23 +109,40 @@ def after_step(context, step):
         # Session context
         SessionContext.instance().after_step(step)
         
-        # Log failures
-        if step.status == "failed":
-            step_descr = __step_description(step)
-            var_step_descr = StepTools.evaluate_variable_name(step_descr)
-            interpreted_step_descr = StepTools.evaluate_string_parameter(step_descr)
-            msg = "Step failed:\n    step:\n{}{}{}\n    error:\n{}\n    step attributes:\n{}".format(
-                Tools.indent_string(8, step_descr),
+        # Log step result
+        step_descr = __step_description(step)
+        try:
+            var_step_descr = StepTools.evaluate_variable_name(step_descr, log_level=logging.NOTSET)
+        except:
+            var_step_descr = "[ERROR during evaluation]"
+        try:
+            interpreted_step_descr = StepTools.evaluate_string_parameter(step_descr, log_level=logging.NOTSET)
+        except:
+            interpreted_step_descr = "[ERROR during interpretation]"
+        if step.status in [Status.failed, Status.error] or interpreted_step_descr != step_descr or var_step_descr != interpreted_step_descr:
+            msg = "Step {}:\n    step:\n{}{}{}".format(
+                step.status.name, Tools.indent_string(8, step_descr),
                 "" if interpreted_step_descr == step_descr else "\n    interpreted step:\n{}".format(Tools.indent_string(8, interpreted_step_descr)),
-                "" if var_step_descr == interpreted_step_descr else "\n    partially interpreted step:\n{}".format(Tools.indent_string(8, var_step_descr)),
-                Tools.indent_string(8, __step_error(step)),
-                Tools.indent_string(8, __step_attributes(step)) )
-            if step.hook_failed:
-                msg += "\n    Hook failed"
+                "" if var_step_descr == interpreted_step_descr else "\n    partially interpreted step:\n{}".format(Tools.indent_string(8, var_step_descr)) )
+            
+            if step.status in [Status.failed, Status.error]:
+                msg += "\n    error:\n{}\n    step attributes:\n{}".format(
+                    Tools.indent_string(8, __step_error(step)),
+                    Tools.indent_string(8, __step_attributes(step)) )
+                if step.hook_failed:
+                    msg += "\n    Hook failed"
+        elif '\n' in step_descr:
+            msg = "Step {}:\n{}".format(step.status.name, Tools.indent_string(4, step_descr))
+        else:
+            msg = "Step {}: {}".format(step.status.name, step_descr)
+        
+        if step.status in [Status.failed, Status.error]:
             logger.error(msg)
             
             if TestConfig.wait_on_step_failure_s > 0:
                 time.sleep(TestConfig.wait_on_step_failure_s)
+        else:
+            logger.debug(msg)
     except:
         logger.exception(f"Hook error (step: {step})")
         raise

holado_test/scenario/step_tools.py

@@ -78,7 +78,6 @@ class StepTools(object):
         res = text.encode('latin-1').decode('unicode-escape')
         
         if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-        
             logger.trace("unescaping string [{}] -> [{}]".format(text, res))
         return res
     
@@ -88,8 +87,8 @@ class StepTools(object):
     
     @staticmethod
     def evaluate_string_parameter(text_param, do_interpret=True, log_level=logging.DEBUG):
-        eval_params = EvaluateParameters.default().with_interpret(do_interpret).with_eval(False)
-        res = StepTools._get_expression_evaluator().evaluate_expression(text_param, eval_params=eval_params, log_level=logging.TRACE)  # @UndefinedVariable
+        eval_params = EvaluateParameters.default().with_interpret(do_interpret).with_eval(False).with_result_type(str)
+        _, res = StepTools._get_expression_evaluator().evaluate_expression(text_param, eval_params=eval_params, log_level=Tools.do_log_level(log_level, logging.TRACE))  # @UndefinedVariable
         if Tools.do_log_if_objects_are_different(logger, log_level, text_param, res):
             logger.log(log_level, "evaluate_string_parameter: [{}] -> [{}]".format(text_param, res))
         return res
@@ -99,8 +98,8 @@ class StepTools(object):
         if text_param is None:
             return None
         
-        eval_params = EvaluateParameters.default_without_eval(False)
-        res = StepTools._get_text_interpreter().interpret(text_param, eval_params=eval_params, log_level=logging.TRACE)  # @UndefinedVariable
+        eval_params = EvaluateParameters.default_without_eval(False).with_result_type(str)
+        res = StepTools._get_text_interpreter().interpret(text_param, eval_params=eval_params, log_level=Tools.do_log_level(log_level, logging.TRACE))  # @UndefinedVariable
         if Tools.do_log_if_objects_are_different(logger, log_level, text_param, res):
             logger.log(log_level, f"evaluate_variable_name: [{text_param}] -> [{res}] (type: {Typing.get_object_class_fullname(res)})")
         return res
@@ -111,7 +110,7 @@ class StepTools(object):
             return None
         
         eval_params = EvaluateParameters.default_without_eval(False)
-        res = StepTools._get_expression_evaluator().evaluate_expression(text_param, eval_params=eval_params, log_level=logging.TRACE)  # @UndefinedVariable
+        _, res = StepTools._get_expression_evaluator().evaluate_expression(text_param, eval_params=eval_params, log_level=Tools.do_log_level(log_level, logging.TRACE))  # @UndefinedVariable
         if Tools.do_log_if_objects_are_different(logger, log_level, text_param, res):
             logger.log(log_level, f"evaluate_variable_name: [{text_param}] -> [{res}] (type: {Typing.get_object_class_fullname(res)})")
         return res
@@ -122,14 +121,14 @@ class StepTools(object):
             return None
         
         eval_params = EvaluateParameters.default().with_raise_on_eval_error(False)
-        res = StepTools._get_expression_evaluator().evaluate_expression(text_param, eval_params=eval_params, log_level=logging.TRACE)  # @UndefinedVariable
+        _, res = StepTools._get_expression_evaluator().evaluate_expression(text_param, eval_params=eval_params, log_level=Tools.do_log_level(log_level, logging.TRACE))  # @UndefinedVariable
         if Tools.do_log_if_objects_are_different(logger, log_level, text_param, res):
             logger.log(log_level, f"evaluate_scenario_parameter: [{text_param}] -> [{res}] (type: {Typing.get_object_class_fullname(res)})")
         return res
  
     @staticmethod
     def evaluate_list_scenario_parameter(text_param, param_name, log_level=logging.DEBUG):
-        res = StepTools.evaluate_scenario_parameter(text_param)
+        res = StepTools.evaluate_scenario_parameter(text_param, log_level=log_level)
         if isinstance(res, str):
             regex = re.compile(r"^\s*\[(.*)\]\s*$")
             m = regex.match(res)
@@ -294,8 +293,8 @@ class StepTools(object):
     @classmethod
     def has_table_header(cls, table):
         """
-        Return True if scenario table has a header (for testing solution).
-        For testing solution, table header names are all texts without quotes.
+        Return True if scenario table has a header (for HolAdo framework).
+        For HolAdo framework, table header names are all texts without quotes.
         """
         internal_header = cls._get_table_header(table)
         if internal_header is None:
@@ -303,7 +302,7 @@ class StepTools(object):
         
         for cell in internal_header:
             scell = ValueTableCell(cell)
-            if scell.value_type not in [ValueTypes.Symbol]:
+            if not ( scell.content_type == ValueTypes.Symbol and scell.value_type == ValueTypes.String ):
                 return False
         
         return True
@@ -402,7 +401,7 @@ class StepTools(object):
     def format_steps_with(cls, steps, format_with_list):
         res = steps
         for form in format_with_list:
-            form_eval = cls._get_expression_evaluator().evaluate_expression(form)
+            _, form_eval = cls._get_expression_evaluator().evaluate_expression(form, log_level=logging.TRACE)  # @UndefinedVariable
             if form_eval == form:
                 raise FunctionalException(f"Not able to evaluation expression [{form}]. Is missing its initialization ?")
             res = res.replace(f"${{{form}}}", str(form_eval))

holado_test/scenario/tester_tools.py

@@ -14,6 +14,7 @@
 from holado.common.context.session_context import SessionContext
 import logging
 from holado_core.common.tables.table import Table
+from holado_core.common.tools.tools import Tools
 
 logger = logging.getLogger(__name__)
 
@@ -47,6 +48,7 @@ class TesterTools(object):
         if isinstance(obj, Table):
             res = obj.represent()
         else:
-            res = str(obj)
+            # res = str(obj)
+            res = Tools.represent_object(obj)
         return res
 

holado_value/common/tables/comparators/table_2_value_table_cell_comparator.py

@@ -107,7 +107,8 @@ class Table2ValueTable_CellComparator(TableCellComparator):
         
         cause = None
         try:
-            value_type = cell_2.value_type
+            # value_type = cell_2.value_type
+            value_type = cell_2.content_type
             if value_type == ValueTypes.NotApplicable:
                 res = True
             elif value_type == ValueTypes.Null:
@@ -121,7 +122,7 @@ class Table2ValueTable_CellComparator(TableCellComparator):
                 res = comparator.equals(cell_1_value, cell_2_value, is_obtained_vs_expected=is_obtained_vs_expected, raise_exception=raise_exception)
             elif value_type == ValueTypes.Merged:
                 return super().equals(cell_1, cell_2, is_obtained_vs_expected, raise_exception)
-            elif value_type in [ValueTypes.String, ValueTypes.DynamicString, ValueTypes.ThreadDynamicString, ValueTypes.UniqueString]:
+            elif ValueTypes.is_string(value_type):
                 res = self._equals_string(cell_1, cell_2, is_obtained_vs_expected, raise_exception)
             elif value_type == ValueTypes.Symbol:
                 res = self._equals_symbol(cell_1, cell_2, is_obtained_vs_expected, raise_exception)

holado_value/common/tables/converters/value_table_converter.py

@@ -158,7 +158,7 @@ class ValueTableConverter(TableConverter):
             
             if row.get_cell(1).value_type in [ValueTypes.NotApplicable, ValueTypes.Merged]:
                 pass
-            elif row.get_cell(1).value_type in [ValueTypes.String, ValueTypes.DynamicString, ValueTypes.ThreadDynamicString, ValueTypes.UniqueString]:
+            elif ValueTypes.is_string(row.get_cell(1).value_type):
                 name = row.get_cell(0).value
                 value = row.get_cell(1).value
                 

holado_value/common/tables/value_table_cell.py

@@ -31,7 +31,7 @@ class ValueTableCell(TableCell):
         super().__init__(cell_content)
         
         self.__value = Value(original_value=cell_content, value=cell_value, do_eval_once=do_eval_once)
-        self.content = self.__value.value_original
+        self.content = self.__value.original_value
         
     def __eq__(self, other):
         self._verify_valid_compared_object(other)
@@ -51,6 +51,10 @@ class ValueTableCell(TableCell):
     def string_content(self):
         return self.__value.string_value
     
+    @property
+    def content_type(self):
+        return self.__value.original_value_type
+    
     @property
     def value_type(self):
         return self.__value.value_type

holado_value/common/tools/value.py

@@ -20,7 +20,7 @@ from holado_value.common.tools.value_types import ValueTypes
 from functools import total_ordering
 from holado_scripting.common.tools.evaluate_parameters import EvaluateParameters
 from holado.holado_config import Config
-from holado.common.handlers.undefined import undefined_value
+from holado.common.handlers.undefined import undefined_value, undefined_argument, to_be_defined, not_applicable, is_undefined
 from holado_python.standard_library.typing import Typing
 
 logger = logging.getLogger(__name__)
@@ -29,26 +29,27 @@ logger = logging.getLogger(__name__)
 @total_ordering
 class Value(object):
     
-    def __init__(self, original_value=undefined_value, value=undefined_value, do_eval_once=True, eval_params=undefined_value):
+    def __init__(self, original_value=undefined_argument, value=undefined_argument, do_eval_once=True, eval_params=undefined_argument):
         """
         @summary: Constructor
-        @param original_value: Original value - can be a string or any object
+        @param original_value: Original value (before value expression evaluation) - can be a string or any object
         @param value: Value - can be a string or any object
         """
-        self.__value_original = undefined_value
-        self.__type = None
-        self.__value = undefined_value
+        self.__original_value = to_be_defined
+        self.__value = to_be_defined
+        self.__value_type = None
         
         # Manage value evaluation
-        self.__value_to_eval = undefined_value
-        self.__value_evaluated = undefined_value
+        self.__value_to_eval = to_be_defined
+        self.__evaluated_value = to_be_defined
+        self.__evaluated_value_type = to_be_defined
         # By default, raise on interpret and variable evaluation error, but not on eval error
-        self.__eval_params_default = eval_params if eval_params is not undefined_value else EvaluateParameters.default().with_raise_on_eval_error(False)
+        self.__eval_params_default = eval_params if eval_params is not undefined_argument else EvaluateParameters.default().with_raise_on_eval_error(False)
         self.__do_eval_once = do_eval_once
         
         self.__extract_value_information(original_value, value)
         if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-            logger.trace(f"New Value: value_original=[{self.__value_original}] ; type=[{self.value_type.name}] ; value=[{self.__value}] ; value_to_eval=[{self.__value_to_eval}]")
+            logger.trace(f"New Value: original_value=[{self.__original_value}] ; type=[{self.__value_type.name}] ; value=[{self.__value}] ; value_to_eval=[{self.__value_to_eval}]")
         
     def _verify_valid_compared_object(self, other, raise_exception=True):
         res = isinstance(other, Value)
@@ -73,7 +74,7 @@ class Value(object):
     def string_value(self):
         value = self.get_value()
         
-        if value is undefined_value:
+        if value in [undefined_value, not_applicable]:
             return Config.NOT_APPLICABLE_SYMBOL
         if value is None:
             return Config.NONE_SYMBOL
@@ -81,15 +82,22 @@ class Value(object):
             return str(value)
     
     @property
-    def value_original(self):
+    def original_value(self):
         """
         @summary: Return the original value
         """
-        return self.__value_original
+        return self.__original_value
+    
+    @property
+    def original_value_type(self):
+        """
+        @summary: Return the original value type
+        """
+        return self.__value_type
     
     @property
     def value_type(self):
-        return self.__type
+        return self.get_value_type()
     
     @property
     def value_before_eval(self):
@@ -105,56 +113,71 @@ class Value(object):
         """
         return self.get_value(raise_if_undefined=True)
     
-    def get_value(self, raise_if_undefined=False, eval_params=undefined_value):
+    def get_value(self, raise_if_undefined=False, eval_params=undefined_argument):
         if self.__value_to_eval is not undefined_value:
-            if self.__value_evaluated is undefined_value or not self.__do_eval_once:
-                eval_params = eval_params if eval_params is not undefined_value else self.__eval_params_default
-                self.__value_evaluated = self.__get_expression_evaluator().evaluate_expression_of_information(self.__type, self.__value_to_eval, eval_params=eval_params)
-            res = self.__value_evaluated
+            self.__evaluate_value_if_needed(eval_params=eval_params)
+            res = self.__evaluated_value
         else:
             res = self.__value
         
-        if res is undefined_value and raise_if_undefined:
+        if is_undefined(res) and raise_if_undefined:
             msg = "Value is undefined"
             if self.value_type == ValueTypes.NotApplicable:
                 msg += " (Not Applicable)"
-            raise ValueError(f"Value is undefined (value type: {self.value_type.name} ; original value: [{self.value_original}] (type: {Typing.get_object_class_fullname(self.value_original)}))")
+            raise ValueError(f"Value is undefined (value type: {self.value_type.name} ; original value: [{self.original_value}] (type: {Typing.get_object_class_fullname(self.original_value)}))")
+        return res
+    
+    def get_value_type(self, eval_params=undefined_argument):
+        if self.__value_to_eval is not undefined_value:
+            self.__evaluate_value_if_needed(eval_params=eval_params)
+            res = self.__evaluated_value_type
+        else:
+            res = self.__value_type
         return res
     
+    def __evaluate_value_if_needed(self, eval_params=undefined_argument):
+        if self.__evaluated_value is to_be_defined or not self.__do_eval_once:
+            eval_params = eval_params if eval_params is not undefined_argument else self.__eval_params_default
+            if ValueTypes.is_string(self.__value_type):
+                eval_params = eval_params.with_result_type(str)
+            self.__evaluated_value_type, self.__evaluated_value = self.__get_expression_evaluator().evaluate_expression_of_information(self.__value_type, self.__value_to_eval, eval_params=eval_params)
+        
     def represent(self, indent = 0, do_evaluation = False):
         res_list = []
         
         res_list.append(Tools.get_indent_string(indent))
         
-        if self.__type in [ValueTypes.String, ValueTypes.DynamicString, ValueTypes.ThreadDynamicString, ValueTypes.UniqueString]:
+        if ValueTypes.is_string(self.__value_type):
             if do_evaluation:
                 res_list.append("'")
                 res_list.append(self.string_value)
                 res_list.append("'")
             else:
-                res_list.append(str(self.value_original))
-        elif self.__type in [ValueTypes.Boolean, ValueTypes.Integer, ValueTypes.Float, ValueTypes.Null, ValueTypes.NotApplicable, ValueTypes.Symbol, ValueTypes.Generic]:
+                res_list.append(str(self.original_value))
+        elif self.__value_type in [ValueTypes.Boolean, ValueTypes.Integer, ValueTypes.Float, ValueTypes.Null, ValueTypes.NotApplicable, ValueTypes.Symbol, ValueTypes.Generic]:
             if do_evaluation:
                 res_list.append(self.string_value)
             else:
-                res_list.append(str(self.value_original))
+                res_list.append(str(self.original_value))
         else:
-            raise TechnicalException("Unmanaged value type '{}'".format(self.__type.name))
+            raise TechnicalException("Unmanaged value type '{}'".format(self.__value_type.name))
         
         return "".join(res_list)
         
-    def __extract_value_information(self, value_original, value):
+    def __extract_value_information(self, original_value, value):
         # Define original value
-        if value_original is not undefined_value and not (value_original is None and value not in [undefined_value, None]):
-            self.__value_original = value_original
-        elif value is not undefined_value:
+        if original_value is not undefined_argument and not (original_value in [undefined_value, None] and value not in [undefined_argument, undefined_value, None]):
+            self.__original_value = original_value
+        elif value is not undefined_argument:
             if value is not None and isinstance(value, str):
-                self.__value_original = f"'{value}'"
+                self.__original_value = f"'{value}'"
             else:
-                self.__value_original = value
+                self.__original_value = value
         
         # Define value information from original value
-        self.__type, self.__value, self.__value_to_eval = self.__get_expression_evaluator().extract_expression_information(self.value_original)
+        self.__value_type, self.__value, self.__value_to_eval = self.__get_expression_evaluator().extract_expression_information(self.original_value)
+        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+            logger.trace(f"extracted value info: {self.__value_type=}, {self.__value=}, {self.__value_to_eval=}")
         
     def __get_expression_evaluator(self):
         if SessionContext.instance().has_scenario_context():

holado_value/common/tools/value_types.py

@@ -32,4 +32,10 @@ class ValueTypes(AutoNumber):
     Merged = ()
     Symbol = ()
     Generic = ()
+    
+    @classmethod
+    def is_string(cls, value_type):
+        return value_type in [ValueTypes.String, ValueTypes.DynamicString, ValueTypes.ThreadDynamicString, ValueTypes.UniqueString]
+
+
 

test_holado/features/NonReg/{ipc → holado_binary}/bit_series.feature

@@ -3,6 +3,7 @@
 @go_nogo
 Feature: Test bit_series module
 
+    @to_hexadecimal_string
     Scenario: Create and convert bit-series to hexa
         Given BIT_SERIES = bit series
             | Name    | Bit length | Type | Value |
@@ -24,6 +25,9 @@ Feature: Test bit_series module
         Given RAW_TM = convert bit series BIT_SERIES to hexadecimal string
         Then RAW_TM == '99FFFFAE1B'
 
+    
+    @to_hexadecimal_string
+    @padding
     Scenario: Create and convert to hexa bit-series of bit length out of bytes array length
         Given BIT_SERIES = bit series
             | Name    | Bit length | Type | Value |
@@ -56,6 +60,8 @@ Feature: Test bit_series module
         Given RAW_TM = convert bit series BIT_SERIES to hexadecimal string (right padded)
         Then RAW_TM == '92'
 
+    
+    @from_hexadecimal_string
     Scenario: Create a bit-series from hexa
         Given BIT_SERIES = bit series
             | Name    | Bit length | Type |
@@ -71,6 +77,9 @@ Feature: Test bit_series module
             | 'F3'    | 2          | int  | 0     |
             | 'F4'    | 2          | int  | 2     |
 
+
+    @from_hexadecimal_string
+    @padding
     Scenario: Create from hexa bit-series of bit length out of bytes array length
         Given BIT_SERIES = bit series
             | Name    | Bit length | Type |
@@ -99,6 +108,8 @@ Feature: Test bit_series module
             | 'F2'    | 1          | int  | 1     |
             | 'F3'    | 1          | int  | 1     |
 
+
+    @is_bit_series
     Scenario: Verify hexa string is bit series
         Then hexadecimal string '92' is bit series
             | Name    | Bit length | Type | Value |
@@ -107,6 +118,8 @@ Feature: Test bit_series module
             | 'F3'    | 2          | int  | 0     |
             | 'F4'    | 2          | int  | 2     |
 
+
+    @set_field
     Scenario: Set bit-series field by variable expression
         Given BIT_SERIES = bit series
             | Name    | Bit length | Type | Value |

test_holado/features/NonReg/test_steps/common.feature

@@ -51,7 +51,7 @@ Feature: Steps in common_steps.py
             """
             Given TOTO = 'TITI'
             """
-        When wait until wait 0.5 seconds (timeout: 0.7 s)
+        When wait until wait 0.5 seconds (timeout: 0.75 s)
             """
             Given TOTO = 'TITI'
             """