robotframework 7.1.1__zip → 7.2b1__zip

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/running/builder/transformers.py

@@ -19,7 +19,7 @@ from robot.parsing import File, ModelVisitor, Token
 from robot.utils import NormalizedDict
 from robot.variables import VariableMatches
 
-from ..model import For, If, IfBranch, TestSuite, TestCase, Try, TryBranch, While
+from ..model import For, Group, If, IfBranch, TestSuite, TestCase, Try, TryBranch, While
 from ..resourcemodel import ResourceFile, UserKeyword
 from .settings import FileSettings
 
@@ -62,6 +62,15 @@ class SettingsBuilder(ModelVisitor):
         self.settings.default_tags = node.values
 
     def visit_TestTags(self, node):
+        for tag in node.values:
+            if tag.startswith('-'):
+                LOGGER.warn(
+                    f"Error in file '{self.suite.source}' on line {node.lineno}: "
+                    f"Setting tags starting with a hyphen like '{tag}' using the "
+                    f"'Test Tags' setting is deprecated. In Robot Framework 8.0 this "
+                    f"syntax will be used for removing tags. Escape the tag like "
+                    f"'\\{tag}' to use the literal value and to avoid this warning."
+                )
         self.settings.test_tags = node.values
 
     def visit_KeywordTags(self, node):
@@ -167,7 +176,7 @@ class ResourceBuilder(ModelVisitor):
 
 class BodyBuilder(ModelVisitor):
 
-    def __init__(self, model: 'TestCase|UserKeyword|For|If|Try|While|None' = None):
+    def __init__(self, model: 'TestCase|UserKeyword|For|If|Try|While|Group|None' = None):
         self.model = model
 
     def visit_For(self, node):
@@ -176,6 +185,9 @@ class BodyBuilder(ModelVisitor):
     def visit_While(self, node):
         WhileBuilder(self.model).build(node)
 
+    def visit_Group(self, node):
+        GroupBuilder(self.model).build(node)
+
     def visit_If(self, node):
         IfBuilder(self.model).build(node)
 
@@ -240,7 +252,7 @@ class TestCaseBuilder(BodyBuilder):
 
     def _set_template(self, parent, template):
         for item in parent.body:
-            if item.type == item.FOR:
+            if item.type in (item.FOR, item.GROUP):
                 self._set_template(item, template)
             elif item.type == item.IF_ELSE_ROOT:
                 for branch in item.body:
@@ -365,7 +377,7 @@ class KeywordBuilder(BodyBuilder):
 class ForBuilder(BodyBuilder):
     model: For
 
-    def __init__(self, parent: 'TestCase|UserKeyword|For|If|Try|While'):
+    def __init__(self, parent: 'TestCase|UserKeyword|For|If|Try|While|Group'):
         super().__init__(parent.body.create_for())
 
     def build(self, node):
@@ -387,7 +399,7 @@ class ForBuilder(BodyBuilder):
 class IfBuilder(BodyBuilder):
     model: 'IfBranch|None'
 
-    def __init__(self, parent: 'TestCase|UserKeyword|For|If|Try|While'):
+    def __init__(self, parent: 'TestCase|UserKeyword|For|If|Try|While|Group'):
         super().__init__()
         self.root = parent.body.create_if()
 
@@ -427,14 +439,13 @@ class IfBuilder(BodyBuilder):
 class TryBuilder(BodyBuilder):
     model: 'TryBranch|None'
 
-    def __init__(self, parent: 'TestCase|UserKeyword|For|If|Try|While'):
+    def __init__(self, parent: 'TestCase|UserKeyword|For|If|Try|While|Group'):
         super().__init__()
         self.root = parent.body.create_try()
-        self.template_error = None
 
     def build(self, node):
-        self.root.config(lineno=node.lineno)
-        errors = self._get_errors(node)
+        self.root.config(lineno=node.lineno,
+                         error=format_error(self._get_errors(node)))
         while node:
             self.model = self.root.body.create_branch(node.type, node.patterns,
                                                       node.pattern_type, node.assign,
@@ -442,10 +453,6 @@ class TryBuilder(BodyBuilder):
             for step in node.body:
                 self.visit(step)
             node = node.next
-        if self.template_error:
-            errors += (self.template_error,)
-        if errors:
-            self.root.error = format_error(errors)
         return self.root
 
     def _get_errors(self, node):
@@ -456,21 +463,40 @@ class TryBuilder(BodyBuilder):
             errors += node.end.errors
         return errors
 
-    def visit_TemplateArguments(self, node):
-        self.template_error = 'Templates cannot be used with TRY.'
-
 
 class WhileBuilder(BodyBuilder):
     model: While
 
-    def __init__(self, parent: 'TestCase|UserKeyword|For|If|Try|While'):
+    def __init__(self, parent: 'TestCase|UserKeyword|For|If|Try|While|Group'):
         super().__init__(parent.body.create_while())
 
+    def build(self, node):
+        self.model.config(condition=node.condition,
+                          limit=node.limit,
+                          on_limit=node.on_limit,
+                          on_limit_message=node.on_limit_message,
+                          lineno=node.lineno,
+                          error=format_error(self._get_errors(node)))
+        for step in node.body:
+            self.visit(step)
+        return self.model
+
+    def _get_errors(self, node):
+        errors = node.header.errors + node.errors
+        if node.end:
+            errors += node.end.errors
+        return errors
+
+
+class GroupBuilder(BodyBuilder):
+    model: Group
+
+    def __init__(self, parent: 'TestCase|UserKeyword|For|If|Try|While|Group'):
+        super().__init__(parent.body.create_group())
+
     def build(self, node):
         error = format_error(self._get_errors(node))
-        self.model.config(condition=node.condition, limit=node.limit,
-                          on_limit=node.on_limit, on_limit_message=node.on_limit_message,
-                          lineno=node.lineno, error=error)
+        self.model.config(name=node.name, lineno=node.lineno, error=error)
         for step in node.body:
             self.visit(step)
         return self.model

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/running/context.py

@@ -13,8 +13,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import inspect
 import asyncio
+import inspect
+import sys
 from contextlib import contextmanager
 
 from robot.errors import DataError, ExecutionFailed
@@ -95,7 +96,6 @@ EXECUTION_CONTEXTS = ExecutionContexts()
 
 
 class _ExecutionContext:
-    _started_keywords_threshold = 100
 
     def __init__(self, suite, namespace, output, dry_run=False, asynchronous=None):
         self.suite = suite
@@ -180,8 +180,11 @@ class _ExecutionContext:
         return self.namespace.variables
 
     def continue_on_failure(self, default=False):
-        parents = ([self.test] if self.test else []) + self.user_keywords
-        for index, parent in enumerate(reversed(parents)):
+        parents = [result for _, result, implementation in reversed(self.steps)
+                   if implementation and implementation.type == 'USER KEYWORD']
+        if self.test:
+            parents.append(self.test)
+        for index, parent in enumerate(parents):
             robot = parent.tags.robot
             if index == 0 and robot('stop-on-failure'):
                 return False
@@ -195,10 +198,10 @@ class _ExecutionContext:
 
     @property
     def allow_loop_control(self):
-        for _, step in reversed(self.steps):
-            if step.type == 'ITERATION':
+        for _, result, _ in reversed(self.steps):
+            if result.type == 'ITERATION':
                 return True
-            if step.type == 'KEYWORD' and step.owner != 'BuiltIn':
+            if result.type == 'KEYWORD' and result.owner != 'BuiltIn':
                 return False
         return False
 
@@ -249,10 +252,8 @@ class _ExecutionContext:
         self.timeout_occurred = False
 
     def start_body_item(self, data, result, implementation=None):
-        self.steps.append((data, result))
-        if len(self.steps) > self._started_keywords_threshold:
-            raise DataError('Maximum limit of started keywords and control '
-                            'structures exceeded.')
+        self._prevent_execution_close_to_recursion_limit()
+        self.steps.append((data, result, implementation))
         output = self.output
         args = (data, result)
         if implementation:
@@ -274,6 +275,7 @@ class _ExecutionContext:
             method = {
                 result.FOR: output.start_for,
                 result.WHILE: output.start_while,
+                result.GROUP: output.start_group,
                 result.IF_ELSE_ROOT: output.start_if,
                 result.IF: output.start_if_branch,
                 result.ELSE: output.start_if_branch,
@@ -290,6 +292,14 @@ class _ExecutionContext:
             }[result.type]
         method(*args)
 
+    def _prevent_execution_close_to_recursion_limit(self):
+        try:
+            sys._getframe(sys.getrecursionlimit() - 100)
+        except (ValueError, AttributeError):
+            pass
+        else:
+            raise DataError('Recursive execution stopped.')
+
     def end_body_item(self, data, result, implementation=None):
         output = self.output
         args = (data, result)
@@ -312,6 +322,7 @@ class _ExecutionContext:
             method = {
                 result.FOR: output.end_for,
                 result.WHILE: output.end_while,
+                result.GROUP: output.end_group,
                 result.IF_ELSE_ROOT: output.end_if,
                 result.IF: output.end_if_branch,
                 result.ELSE: output.end_if_branch,

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/running/librarykeyword.py

@@ -82,7 +82,7 @@ class LibraryKeyword(KeywordImplementation):
             return EmbeddedArgumentsRunner(self, name)
         if self._resolve_args_until is not None:
             dry_run = RUN_KW_REGISTER.get_dry_run(self.owner.real_name, self.name)
-            return RunKeywordRunner(self, execute_in_dry_run=dry_run)
+            return RunKeywordRunner(self, dry_run_children=dry_run)
         return LibraryKeywordRunner(self, languages=languages)
 
     def resolve_arguments(self, args: 'Sequence[str|Any]',

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/running/librarykeywordrunner.py

@@ -131,23 +131,27 @@ class LibraryKeywordRunner:
         kw = self.keyword.bind(data)
         assignment = VariableAssignment(data.assign)
         self._config_result(result, data, kw, assignment)
-        with StatusReporter(data, result, context, run=False, implementation=kw):
+        with StatusReporter(data, result, context, implementation=kw,
+                            run=self._get_initial_dry_run_status(kw)):
             assignment.validate_assignment()
             if self._executed_in_dry_run(kw):
                 self._run(data, kw, context)
             else:
                 self._resolve_arguments(data, kw)
-            self._end_dry_run(data, kw, result, context)
+                self._dry_run(data, kw, result, context)
 
-    def _end_dry_run(self, data: KeywordData, kw: 'LibraryKeyword',
-                     result: KeywordResult, context):
-        pass
+    def _get_initial_dry_run_status(self, kw):
+        return self._executed_in_dry_run(kw)
 
     def _executed_in_dry_run(self, kw: 'LibraryKeyword'):
         return (kw.owner.name == 'BuiltIn'
                 and kw.name in ('Import Library', 'Set Library Search Order',
                                 'Set Tags', 'Remove Tags', 'Import Resource'))
 
+    def _dry_run(self, data: KeywordData, kw: 'LibraryKeyword', result: KeywordResult,
+                 context):
+        pass
+
 
 class EmbeddedArgumentsRunner(LibraryKeywordRunner):
 
@@ -167,9 +171,9 @@ class EmbeddedArgumentsRunner(LibraryKeywordRunner):
 
 class RunKeywordRunner(LibraryKeywordRunner):
 
-    def __init__(self, keyword: 'LibraryKeyword', execute_in_dry_run=False):
+    def __init__(self, keyword: 'LibraryKeyword', dry_run_children=False):
         super().__init__(keyword)
-        self.execute_in_dry_run = execute_in_dry_run
+        self._dry_run_children = dry_run_children
 
     def _get_timeout(self, context):
         # These keywords are not affected by timeouts. Keywords they execute are.
@@ -183,25 +187,31 @@ class RunKeywordRunner(LibraryKeywordRunner):
         finally:
             STOP_SIGNAL_MONITOR.stop_running_keyword()
 
-    def _end_dry_run(self, data: KeywordData, kw: 'LibraryKeyword',
-                     result: KeywordResult, context):
+    def _get_initial_dry_run_status(self, kw):
+        return self._dry_run_children or super()._get_initial_dry_run_status(kw)
+
+    def _dry_run(self, data: KeywordData, kw: 'LibraryKeyword', result: KeywordResult,
+                 context):
         wrapper = UserKeyword(name=kw.name,
-                              doc="Wraps keywords executed by '{kw.name}' in dry-run.",
+                              doc=f"Wraps keywords executed by '{kw.name}' in dry-run.",
                               parent=kw.parent)
-        wrapper.body = [k for k in self._get_dry_run_keywords(kw, data.args)
-                        if not contains_variable(k.name)]
+        for child in self._get_dry_run_children(kw, data.args):
+            if not contains_variable(child.name):
+                child.lineno = data.lineno
+                wrapper.body.append(child)
         BodyRunner(context).run(wrapper, result)
 
-    def _get_dry_run_keywords(self, kw: 'LibraryKeyword', args):
-        if not self.execute_in_dry_run:
+    def _get_dry_run_children(self, kw: 'LibraryKeyword', args):
+        if not self._dry_run_children:
             return []
         if kw.name == 'Run Keyword If':
-            return self._get_dry_run_keywords_for_run_keyword_if(args)
+            return self._get_dry_run_children_for_run_keyword_if(args)
         if kw.name == 'Run Keywords':
-            return self._get_dry_run_keywords_for_run_keyword(args)
-        return self._get_dry_run_keywords_based_on_name(kw, args)
+            return self._get_dry_run_children_for_run_keyword(args)
+        index = kw.args.positional.index('name')
+        return [KeywordData(name=args[index], args=args[index+1:])]
 
-    def _get_dry_run_keywords_for_run_keyword_if(self, given_args):
+    def _get_dry_run_children_for_run_keyword_if(self, given_args):
         for kw_call in self._get_run_kw_if_calls(given_args):
             if kw_call:
                 yield KeywordData(name=kw_call[0], args=kw_call[1:])
@@ -235,7 +245,7 @@ class RunKeywordRunner(LibraryKeywordRunner):
             return True
         return any(is_list_variable(item) for item in kw_call)
 
-    def _get_dry_run_keywords_for_run_keyword(self, given_args):
+    def _get_dry_run_children_for_run_keyword(self, given_args):
         for kw_call in self._get_run_kws_calls(given_args):
             yield KeywordData(name=kw_call[0], args=kw_call[1:])
 
@@ -250,7 +260,3 @@ class RunKeywordRunner(LibraryKeywordRunner):
                 yield kw_call
             if given_args:
                 yield given_args
-
-    def _get_dry_run_keywords_based_on_name(self, kw: 'LibraryKeyword', given_args):
-        index = kw.args.positional.index('name')
-        return [KeywordData(name=given_args[index], args=given_args[index+1:])]

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/running/model.py

@@ -46,7 +46,7 @@ from robot.output import LOGGER, Output, pyloggingconf
 from robot.utils import format_assign_message, setter
 from robot.variables import VariableResolver
 
-from .bodyrunner import ForRunner, IfRunner, KeywordRunner, TryRunner, WhileRunner
+from .bodyrunner import ForRunner, GroupRunner, IfRunner, KeywordRunner, TryRunner, WhileRunner
 from .randomizer import Randomizer
 from .statusreporter import StatusReporter
 
@@ -58,15 +58,15 @@ if TYPE_CHECKING:
 
 IT = TypeVar('IT', bound='IfBranch|TryBranch')
 BodyItemParent = Union['TestSuite', 'TestCase', 'UserKeyword', 'For', 'If', 'IfBranch',
-                       'Try', 'TryBranch', 'While', None]
+                       'Try', 'TryBranch', 'While', 'Group', None]
 
 
-class Body(model.BaseBody['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return',
+class Body(model.BaseBody['Keyword', 'For', 'While', 'Group', 'If', 'Try', 'Var', 'Return',
                           'Continue', 'Break', 'model.Message', 'Error']):
     __slots__ = ()
 
 
-class Branches(model.BaseBranches['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return',
+class Branches(model.BaseBranches['Keyword', 'For', 'While', 'Group', 'If', 'Try', 'Var', 'Return',
                                   'Continue', 'Break', 'model.Message', 'Error', IT]):
     __slots__ = ()
 
@@ -259,6 +259,33 @@ class While(model.While, WithSource):
         iteration = WhileIteration(self, self.lineno, self.error)
         iteration.body = [item.to_dict() for item in self.body]
         return iteration
+        self.error = error
+
+
+@Body.register
+class Group(model.Group, WithSource):
+    __slots__ = ['lineno', 'error']
+    body_class = Body
+
+    def __init__(self, name: str = '',
+                 parent: BodyItemParent = None,
+                 lineno: 'int|None' = None,
+                 error: 'str|None' = None):
+        super().__init__(name, parent)
+        self.lineno = lineno
+        self.error = error
+
+    def to_dict(self) -> DataDict:
+        data = super().to_dict()
+        if self.lineno:
+            data['lineno'] = self.lineno
+        if self.error:
+            data['error'] = self.error
+        return data
+
+    def run(self, result, context, run=True, templated=False):
+        result = result.body.create_group(self.name)
+        return GroupRunner(context, run, templated).run(self, result)
 
 
 class IfBranch(model.IfBranch, WithSource):

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/running/status.py

@@ -13,9 +13,11 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from abc import ABC
+
 from robot.errors import PassExecution
 from robot.model import TagPatterns
-from robot.utils import html_escape, test_or_task
+from robot.utils import html_escape, plural_or_not as s, seq2str, test_or_task
 
 
 class Failure:
@@ -49,10 +51,10 @@ class Exit:
         self.error = False
         self.fatal = False
 
-    def failure_occurred(self, fatal=False):
+    def failure_occurred(self, fatal=False, suite_setup=False):
         if fatal:
             self.fatal = True
-        if self.failure_mode:
+        if self.failure_mode and not suite_setup:
             self.failure = True
 
     def error_occurred(self):
@@ -67,7 +69,7 @@ class Exit:
         return bool(self.failure or self.error or self.fatal)
 
 
-class _ExecutionStatus:
+class ExecutionStatus(ABC):
 
     def __init__(self, parent, exit=None):
         self.parent = parent
@@ -75,7 +77,6 @@ class _ExecutionStatus:
         self.failure = Failure()
         self.skipped = False
         self._teardown_allowed = False
-        self._rpa = False
 
     @property
     def failed(self):
@@ -96,7 +97,8 @@ class _ExecutionStatus:
                 self.skipped = True
             else:
                 self.failure.setup = msg
-                self.exit.failure_occurred(error.exit)
+                self.exit.failure_occurred(error.exit,
+                                           suite_setup=isinstance(self, SuiteStatus))
         self._teardown_allowed = True
 
     def teardown_executed(self, error=None):
@@ -151,7 +153,7 @@ class _ExecutionStatus:
         return ParentMessage(self.parent).message
 
 
-class SuiteStatus(_ExecutionStatus):
+class SuiteStatus(ExecutionStatus):
 
     def __init__(self, parent=None, exit_on_failure=False, exit_on_error=False,
                  skip_teardown_on_exit=False):
@@ -165,19 +167,19 @@ class SuiteStatus(_ExecutionStatus):
         return SuiteMessage(self).message
 
 
-class TestStatus(_ExecutionStatus):
+class TestStatus(ExecutionStatus):
 
-    def __init__(self, parent, test, skip_on_failure=None, rpa=False):
+    def __init__(self, parent, test, skip_on_failure=(), rpa=False):
         super().__init__(parent)
-        self._test = test
-        self._skip_on_failure_tags = skip_on_failure
-        self._rpa = rpa
+        self.test = test
+        self.skip_on_failure_tags = TagPatterns(skip_on_failure)
+        self.rpa = rpa
 
     def test_failed(self, message=None, error=None):
         if error is not None:
             message = str(error)
             skip = error.skip
-            fatal = error.exit
+            fatal = error.exit or self.test.tags.robot('exit-on-failure')
         else:
             skip = fatal = False
         if skip:
@@ -202,26 +204,32 @@ class TestStatus(_ExecutionStatus):
         return False
 
     def _skip_on_failure(self):
-        return (self._test.tags.robot('skip-on-failure')
-                or self._skip_on_failure_tags
-                and TagPatterns(self._skip_on_failure_tags).match(self._test.tags))
+        return (self.test.tags.robot('skip-on-failure')
+                or self.skip_on_failure_tags.match(self.test.tags))
 
-    def _skip_on_fail_msg(self, msg):
+    def _skip_on_fail_msg(self, fail_msg):
+        if self.test.tags.robot('skip-on-failure'):
+            tags = ['robot:skip-on-failure']
+            kind = 'tag'
+        else:
+            tags = self.skip_on_failure_tags
+            kind = 'tag' if tags.is_constant else 'tag pattern'
         return test_or_task(
-            "{Test} failed but skip-on-failure mode was active and it was marked "
-            "skipped.\n\nOriginal failure:\n%s" % msg, rpa=self._rpa
+            f"Failed {{test}} skipped using {seq2str(tags)} {kind}{s(tags)}.\n\n"
+            f"Original failure:\n{fail_msg}", rpa=self.rpa
         )
 
     def _my_message(self):
         return TestMessage(self).message
 
 
-class _Message:
-    setup_message = NotImplemented
-    setup_skipped_message = NotImplemented
-    teardown_skipped_message = NotImplemented
-    teardown_message = NotImplemented
-    also_teardown_message = NotImplemented
+class Message(ABC):
+    setup_message = ''
+    setup_skipped_message = ''
+    teardown_skipped_message = ''
+    teardown_message = ''
+    also_teardown_message = ''
+    also_teardown_skip_message = ''
 
     def __init__(self, status):
         self.failure = status.failure
@@ -234,11 +242,11 @@ class _Message:
 
     def _get_message_before_teardown(self):
         if self.failure.setup_skipped:
-            return self._format_setup_or_teardown_message(
-                self.setup_skipped_message, self.failure.setup_skipped)
+            return self._format_setup_or_teardown_message(self.setup_skipped_message,
+                                                          self.failure.setup_skipped)
         if self.failure.setup:
-            return self._format_setup_or_teardown_message(
-                self.setup_message, self.failure.setup)
+            return self._format_setup_or_teardown_message(self.setup_message,
+                                                          self.failure.setup)
         return self.failure.test_skipped or self.failure.test or ''
 
     def _format_setup_or_teardown_message(self, prefix, message):
@@ -271,7 +279,7 @@ class _Message:
         return self.also_teardown_skip_message % (teardown, message)
 
 
-class TestMessage(_Message):
+class TestMessage(Message):
     setup_message = 'Setup failed:\n%s'
     teardown_message = 'Teardown failed:\n%s'
     setup_skipped_message = '%s'
@@ -279,12 +287,11 @@ class TestMessage(_Message):
     also_teardown_message = '%s\n\nAlso teardown failed:\n%s'
     also_teardown_skip_message = 'Skipped in teardown:\n%s\n\nEarlier message:\n%s'
     exit_on_fatal_message = 'Test execution stopped due to a fatal error.'
-    exit_on_failure_message = \
-        'Failure occurred and exit-on-failure mode is in use.'
+    exit_on_failure_message = 'Failure occurred and exit-on-failure mode is in use.'
     exit_on_error_message = 'Error occurred and exit-on-error mode is in use.'
 
     def __init__(self, status):
-        _Message.__init__(self, status)
+        super().__init__(status)
         self.exit = status.exit
 
     @property
@@ -301,7 +308,7 @@ class TestMessage(_Message):
         return ''
 
 
-class SuiteMessage(_Message):
+class SuiteMessage(Message):
     setup_message = 'Suite setup failed:\n%s'
     setup_skipped_message = 'Skipped in suite setup:\n%s'
     teardown_skipped_message = 'Skipped in suite teardown:\n%s'
@@ -320,4 +327,4 @@ class ParentMessage(SuiteMessage):
     def __init__(self, status):
         while status.parent and status.parent.failed:
             status = status.parent
-        SuiteMessage.__init__(self, status)
+        super().__init__(status)

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/running/statusreporter.py

@@ -62,7 +62,7 @@ class StatusReporter:
             result.status = failure.status
             if not isinstance(failure, (BreakLoop, ContinueLoop, ReturnFromKeyword)):
                 result.message = failure.message
-        if self.initial_test_status == 'PASS':
+        if self.initial_test_status == 'PASS' and result.status != 'NOT RUN':
             context.test.status = result.status
         result.elapsed_time = datetime.now() - result.start_time
         orig_status = (result.status, result.message)