robotframework 7.1rc2__zip → 7.2b1__zip

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/model/body.py

@@ -17,6 +17,7 @@ import re
 from typing import (Any, Callable, cast, Generic, Iterable, Type, TYPE_CHECKING,
                     TypeVar, Union)
 
+from robot.errors import DataError
 from robot.utils import copy_signature, KnownAtRuntime
 
 from .itemlist import ItemList
@@ -24,8 +25,8 @@ from .modelobject import DataDict, full_name, ModelObject
 
 if TYPE_CHECKING:
     from robot.running.model import ResourceFile, UserKeyword
-    from .control import (Break, Continue, Error, For, ForIteration, If, IfBranch,
-                          Return, Try, TryBranch, Var, While, WhileIteration)
+    from .control import (Break, Continue, Error, For, ForIteration, Group, If,
+                          IfBranch, Return, Try, TryBranch, Var, While, WhileIteration)
     from .keyword import Keyword
     from .message import Message
     from .testcase import TestCase
@@ -33,12 +34,14 @@ if TYPE_CHECKING:
 
 
 BodyItemParent = Union['TestSuite', 'TestCase', 'UserKeyword', 'For', 'ForIteration',
-                       'If', 'IfBranch', 'Try', 'TryBranch', 'While', 'WhileIteration',
-                       'Keyword', 'Var', 'Return', 'Continue', 'Break', 'Error', None]
+                       'If', 'IfBranch', 'Try', 'TryBranch', 'While', 'Group',
+                       'WhileIteration', 'Keyword', 'Var', 'Return', 'Continue',
+                       'Break', 'Error', None]
 BI = TypeVar('BI', bound='BodyItem')
 KW = TypeVar('KW', bound='Keyword')
 F = TypeVar('F', bound='For')
 W = TypeVar('W', bound='While')
+G = TypeVar('G', bound='Group')
 I = TypeVar('I', bound='If')
 T = TypeVar('T', bound='Try')
 V = TypeVar('V', bound='Var')
@@ -52,28 +55,7 @@ FW = TypeVar('FW', bound='ForIteration|WhileIteration')
 
 
 class BodyItem(ModelObject):
-    KEYWORD = 'KEYWORD'
-    SETUP = 'SETUP'
-    TEARDOWN = 'TEARDOWN'
-    FOR = 'FOR'
-    ITERATION = 'ITERATION'
-    IF_ELSE_ROOT = 'IF/ELSE ROOT'
-    IF = 'IF'
-    ELSE_IF = 'ELSE IF'
-    ELSE = 'ELSE'
-    TRY_EXCEPT_ROOT = 'TRY/EXCEPT ROOT'
-    TRY = 'TRY'
-    EXCEPT = 'EXCEPT'
-    FINALLY = 'FINALLY'
-    WHILE = 'WHILE'
-    VAR = 'VAR'
-    RETURN = 'RETURN'
-    CONTINUE = 'CONTINUE'
-    BREAK = 'BREAK'
-    ERROR = 'ERROR'
-    MESSAGE = 'MESSAGE'
-    KEYWORD_TYPES = (KEYWORD, SETUP, TEARDOWN)
-    type = None
+    body: 'BaseBody'
     __slots__ = ['parent']
 
     @property
@@ -99,28 +81,27 @@ class BodyItem(ModelObject):
         # or linking to warnings and errors won't work.
         steps = []
         if getattr(parent, 'has_setup', False):
-            steps.append(parent.setup)          # type: ignore - Use Protocol with RF 7.
+            steps.append(parent.setup)
         if hasattr(parent, 'body'):
-            steps.extend(step for step in
-                         parent.body.flatten()  # type: ignore - Use Protocol with RF 7.
-                         if step.type != self.MESSAGE)
+            steps.extend(parent.body.flatten(messages=False))
         if getattr(parent, 'has_teardown', False):
-            steps.append(parent.teardown)       # type: ignore - Use Protocol with RF 7.
+            steps.append(parent.teardown)
         index = steps.index(self) if self in steps else len(steps)
-        parent_id = getattr(parent, 'id', None)
-        return f'{parent_id}-k{index + 1}' if parent_id else f'k{index + 1}'
+        pid = parent.id    # IF/TRY root id is None. Avoid calling property twice.
+        return f'{pid}-k{index + 1}' if pid else f'k{index + 1}'
 
     def to_dict(self) -> DataDict:
         raise NotImplementedError
 
 
-class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, V, R, C, B, M, E]):
+class BaseBody(ItemList[BodyItem], Generic[KW, F, W, G, I, T, V, R, C, B, M, E]):
     """Base class for Body and Branches objects."""
-    __slots__ = []
+    __slots__ = ()
     # Set using 'BaseBody.register' when these classes are created.
     keyword_class: Type[KW] = KnownAtRuntime
     for_class: Type[F] = KnownAtRuntime
     while_class: Type[W] = KnownAtRuntime
+    group_class: Type[G] = KnownAtRuntime
     if_class: Type[I] = KnownAtRuntime
     try_class: Type[T] = KnownAtRuntime
     var_class: Type[V] = KnownAtRuntime
@@ -189,6 +170,10 @@ class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, V, R, C, B, M, E]):
     def create_while(self, *args, **kwargs) -> while_class:
         return self._create(self.while_class, 'create_while', args, kwargs)
 
+    @copy_signature(group_class)
+    def create_group(self, *args, **kwargs) -> group_class:
+        return self._create(self.group_class, 'create_group', args, kwargs)
+
     @copy_signature(var_class)
     def create_var(self, *args, **kwargs) -> var_class:
         return self._create(self.var_class, 'create_var', args, kwargs)
@@ -214,7 +199,7 @@ class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, V, R, C, B, M, E]):
         return self._create(self.error_class, 'create_error', args, kwargs)
 
     def filter(self, keywords: 'bool|None' = None, messages: 'bool|None' = None,
-               predicate: 'Callable[[T], bool]|None' = None):
+               predicate: 'Callable[[T], bool]|None' = None) -> 'list[BodyItem]':
         """Filter body items based on type and/or custom predicate.
 
         To include or exclude items based on types, give matching arguments
@@ -238,9 +223,6 @@ class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, V, R, C, B, M, E]):
         use ``body.filter(keywords=False``, messages=False)``. For more detailed
         filtering it is possible to use ``predicate``.
         """
-        if messages is not None and self.message_class is KnownAtRuntime:
-            raise TypeError(f"'{full_name(self)}' object does not support "
-                            f"filtering by 'messages'.")
         return self._filter([(self.keyword_class, keywords),
                              (self.message_class, messages)], predicate)
 
@@ -258,38 +240,41 @@ class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, V, R, C, B, M, E]):
             items = [item for item in items if predicate(item)]
         return items
 
-    def flatten(self) -> 'list[BodyItem]':
+    def flatten(self, **filter_config) -> 'list[BodyItem]':
         """Return steps so that IF and TRY structures are flattened.
 
         Basically the IF/ELSE and TRY/EXCEPT root elements are replaced
-        with their branches. This is how they are shown in log files.
+        with their branches. This is how they are shown in the log file.
+
+        ``filter_config`` can be used to filter steps using the :meth:`filter`
+        method before flattening. New in Robot Framework 7.2.
         """
         roots = BodyItem.IF_ELSE_ROOT, BodyItem.TRY_EXCEPT_ROOT
-        steps = []
-        for item in self:
+        steps = self if not filter_config else self.filter(**filter_config)
+        flat = []
+        for item in steps:
             if item.type in roots:
-                item = cast('Try|If', item)
-                steps.extend(item.body)
+                flat.extend(item.body)
             else:
-                steps.append(item)
-        return steps
+                flat.append(item)
+        return flat
 
 
-class Body(BaseBody['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return',
-                    'Continue', 'Break', 'Message', 'Error']):
+class Body(BaseBody['Keyword', 'For', 'While', 'Group', 'If', 'Try', 'Var',
+                     'Return', 'Continue', 'Break', 'Message', 'Error']):
     """A list-like object representing a body of a test, keyword, etc.
 
     Body contains the keywords and other structures such as FOR loops.
     """
-    pass
+    __slots__ = ()
 
 
 # BaseBranches cannot extend Generic[IT] directly with BaseBody[...].
 class BranchType(Generic[IT]):
-    pass
+    __slots__ = ()
 
 
-class BaseBranches(BaseBody[KW, F, W, I, T, V, R, C, B, M, E], BranchType[IT]):
+class BaseBranches(BaseBody[KW, F, W, G, I, T, V, R, C, B, M, E], BranchType[IT]):
     """A list-like object representing IF and TRY branches."""
     __slots__ = ['branch_class']
     branch_type: Type[IT] = KnownAtRuntime
@@ -300,8 +285,11 @@ class BaseBranches(BaseBody[KW, F, W, I, T, V, R, C, B, M, E], BranchType[IT]):
         self.branch_class = branch_class
         super().__init__(parent, items)
 
-    def _item_from_dict(self, data: DataDict) -> IT:
-        return self.branch_class.from_dict(data)
+    def _item_from_dict(self, data: DataDict) -> BodyItem:
+        try:
+            return self.branch_class.from_dict(data)
+        except DataError:
+            return super()._item_from_dict(data)
 
     @copy_signature(branch_type)
     def create_branch(self, *args, **kwargs) -> IT:
@@ -310,10 +298,10 @@ class BaseBranches(BaseBody[KW, F, W, I, T, V, R, C, B, M, E], BranchType[IT]):
 
 # BaseIterations cannot extend Generic[IT] directly with BaseBody[...].
 class IterationType(Generic[FW]):
-    pass
+    __slots__ = ()
 
 
-class BaseIterations(BaseBody[KW, F, W, I, T, V, R, C, B, M, E], IterationType[FW]):
+class BaseIterations(BaseBody[KW, F, W, G, I, T, V, R, C, B, M, E], IterationType[FW]):
     __slots__ = ['iteration_class']
     iteration_type: Type[FW] = KnownAtRuntime
 
@@ -323,7 +311,10 @@ class BaseIterations(BaseBody[KW, F, W, I, T, V, R, C, B, M, E], IterationType[F
         self.iteration_class = iteration_class
         super().__init__(parent, items)
 
-    def _item_from_dict(self, data: DataDict) -> FW:
+    def _item_from_dict(self, data: DataDict) -> BodyItem:
+        # Non-iteration data is typically caused by listeners.
+        if data.get('type') != 'ITERATION':
+            return super()._item_from_dict(data)
         return self.iteration_class.from_dict(data)
 
     @copy_signature(iteration_type)

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/model/control.py

@@ -31,13 +31,13 @@ IT = TypeVar('IT', bound='IfBranch|TryBranch')
 FW = TypeVar('FW', bound='ForIteration|WhileIteration')
 
 
-class Branches(BaseBranches['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return',
-                            'Continue', 'Break', 'Message', 'Error', IT]):
+class Branches(BaseBranches['Keyword', 'For', 'While', 'Group', 'If', 'Try', 'Var',
+                            'Return', 'Continue', 'Break', 'Message', 'Error', IT]):
     __slots__ = ()
 
 
-class Iterations(BaseIterations['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return',
-                                'Continue', 'Break', 'Message', 'Error', FW]):
+class Iterations(BaseIterations['Keyword', 'For', 'While', 'Group', 'If', 'Try', 'Var',
+                                'Return', 'Continue', 'Break', 'Message', 'Error', FW]):
     __slots__ = ()
 
 
@@ -229,6 +229,37 @@ class While(BodyItem):
         return '    '.join(parts)
 
 
+@Body.register
+class Group(BodyItem):
+    """Represents ``GROUP``."""
+    type = BodyItem.GROUP
+    body_class = Body
+    repr_args = ('name',)
+    __slots__ = ['name']
+
+    def __init__(self, name: str = '',
+                 parent: BodyItemParent = None):
+        self.name = name
+        self.parent = parent
+        self.body = ()
+
+    @setter
+    def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
+        return self.body_class(self, body)
+
+    def visit(self, visitor: SuiteVisitor):
+        visitor.visit_group(self)
+
+    def to_dict(self) -> DataDict:
+        return {'type': self.type, 'name': self.name, 'body': self.body.to_dicts()}
+
+    def __str__(self) -> str:
+        parts = ['GROUP']
+        if self.name:
+            parts.append(self.name)
+        return '    '.join(parts)
+
+
 class IfBranch(BodyItem):
     """Represents individual ``IF``, ``ELSE IF`` or ``ELSE`` branch."""
     body_class = Body

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/model/message.py

@@ -61,7 +61,10 @@ class Message(BodyItem):
     def id(self):
         if not self.parent:
             return 'm1'
-        messages = self.parent.messages
+        if hasattr(self.parent, 'messages'):
+            messages = self.parent.messages
+        else:
+            messages = self.parent.body.filter(messages=True)
         index = messages.index(self) if self in messages else len(messages)
         return f'{self.parent.id}-m{index + 1}'
 
@@ -69,12 +72,14 @@ class Message(BodyItem):
         """:mod:`Visitor interface <robot.model.visitor>` entry-point."""
         visitor.visit_message(self)
 
+    def to_dict(self):
+        data = {'message': self.message,
+                'level': self.level}
+        if self.html:
+            data['html'] = True
+        if self.timestamp:
+            data['timestamp'] = self.timestamp.isoformat()
+        return data
+
     def __str__(self):
         return self.message
-
-
-class Messages(ItemList):
-    __slots__ = []
-
-    def __init__(self, message_class=Message, parent=None, messages=None):
-        ItemList.__init__(self, message_class, {'parent': parent}, messages)

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/model/modelobject.py

@@ -27,6 +27,32 @@ DataDict = Dict[str, Any]
 
 
 class ModelObject(metaclass=SetterAwareType):
+    SUITE = 'SUITE'
+    TEST = 'TEST'
+    TASK = TEST
+    KEYWORD = 'KEYWORD'
+    SETUP = 'SETUP'
+    TEARDOWN = 'TEARDOWN'
+    FOR = 'FOR'
+    ITERATION = 'ITERATION'
+    IF_ELSE_ROOT = 'IF/ELSE ROOT'
+    IF = 'IF'
+    ELSE_IF = 'ELSE IF'
+    ELSE = 'ELSE'
+    TRY_EXCEPT_ROOT = 'TRY/EXCEPT ROOT'
+    TRY = 'TRY'
+    EXCEPT = 'EXCEPT'
+    FINALLY = 'FINALLY'
+    WHILE = 'WHILE'
+    GROUP = 'GROUP'
+    VAR = 'VAR'
+    RETURN = 'RETURN'
+    CONTINUE = 'CONTINUE'
+    BREAK = 'BREAK'
+    ERROR = 'ERROR'
+    MESSAGE = 'MESSAGE'
+    KEYWORD_TYPES = (KEYWORD, SETUP, TEARDOWN)
+    type: str
     repr_args = ()
     __slots__ = []
 

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/model/statistics.py

@@ -13,9 +13,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from .totalstatistics import TotalStatisticsBuilder
-from .suitestatistics import SuiteStatisticsBuilder
-from .tagstatistics import TagStatisticsBuilder
+from .totalstatistics import TotalStatistics, TotalStatisticsBuilder
+from .suitestatistics import SuiteStatistics, SuiteStatisticsBuilder
+from .tagstatistics import TagStatistics, TagStatisticsBuilder
 from .visitor import SuiteVisitor
 
 
@@ -34,12 +34,16 @@ class Statistics:
                                            tag_stat_exclude, tag_stat_combine,
                                            tag_doc, tag_stat_link)
         suite.visit(StatisticsBuilder(total_builder, suite_builder, tag_builder))
-        #: Instance of :class:`~robot.model.totalstatistics.TotalStatistics`.
-        self.total = total_builder.stats
-        #: Instance of :class:`~robot.model.suitestatistics.SuiteStatistics`.
-        self.suite = suite_builder.stats
-        #: Instance of :class:`~robot.model.tagstatistics.TagStatistics`.
-        self.tags = tag_builder.stats
+        self.total: TotalStatistics = total_builder.stats
+        self.suite: SuiteStatistics = suite_builder.stats
+        self.tags: TagStatistics = tag_builder.stats
+
+    def to_dict(self):
+        return {
+            'total': self.total.stat.get_attributes(include_label=True),
+            'suites': [s.get_attributes(include_label=True) for s in self.suite],
+            'tags': [t.get_attributes(include_label=True) for t in self.tags],
+        }
 
     def visit(self, visitor):
         visitor.visit_statistics(self)

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/model/stats.py

@@ -15,8 +15,7 @@
 
 from datetime import timedelta
 
-from robot.utils import (Sortable, elapsed_time_to_string, html_escape,
-                         is_string, normalize)
+from robot.utils import elapsed_time_to_string, html_escape, normalize, Sortable
 
 from .tags import TagPattern
 
@@ -40,28 +39,27 @@ class Stat(Sortable):
         self._norm_name = normalize(name, ignore='_')
 
     def get_attributes(self, include_label=False, include_elapsed=False,
-                       exclude_empty=True, values_as_strings=False,
-                       html_escape=False):
-        attrs = {'pass': self.passed, 'fail': self.failed, 'skip': self.skipped}
-        attrs.update(self._get_custom_attrs())
-        if include_label:
-            attrs['label'] = self.name
+                       exclude_empty=True, values_as_strings=False, html_escape=False):
+        attrs = {
+            **({'label': self.name} if include_label else {}),
+            **self._get_custom_attrs(),
+            **{'pass': self.passed, 'fail': self.failed, 'skip': self.skipped},
+        }
         if include_elapsed:
             attrs['elapsed'] = elapsed_time_to_string(self.elapsed, include_millis=False)
         if exclude_empty:
-            attrs = dict((k, v) for k, v in attrs.items() if v not in ('', None))
+            attrs = {k: v for k, v in attrs.items() if v not in ('', None)}
         if values_as_strings:
-            attrs = dict((k, str(v) if v is not None else '')
-                         for k, v in attrs.items())
+            attrs = {k: str(v if v is not None else '') for k, v in attrs.items()}
         if html_escape:
-            attrs = dict((k, self._html_escape(v)) for k, v in attrs.items())
+            attrs = {k: self._html_escape(v) for k, v in attrs.items()}
         return attrs
 
     def _get_custom_attrs(self):
         return {}
 
     def _html_escape(self, item):
-        return html_escape(item) if is_string(item) else item
+        return html_escape(item) if isinstance(item, str) else item
 
     @property
     def total(self):
@@ -109,7 +107,7 @@ class SuiteStat(Stat):
         self._name = suite.name
 
     def _get_custom_attrs(self):
-        return {'id': self.id, 'name': self._name}
+        return {'name': self._name, 'id': self.id}
 
     def _update_elapsed(self, test):
         pass

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/model/suitestatistics.py

@@ -13,6 +13,8 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from typing import Iterator
+
 from .stats import SuiteStat
 
 
@@ -20,30 +22,27 @@ class SuiteStatistics:
     """Container for suite statistics."""
 
     def __init__(self, suite):
-        #: Instance of :class:`~robot.model.stats.SuiteStat`.
         self.stat = SuiteStat(suite)
-        #: List of :class:`~robot.model.testsuite.TestSuite` objects.
-        self.suites = []
+        self.suites: list[SuiteStatistics] = []
 
     def visit(self, visitor):
         visitor.visit_suite_statistics(self)
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[SuiteStat]:
         yield self.stat
         for child in self.suites:
-            for stat in child:
-                yield stat
+            yield from child
 
 
 class SuiteStatisticsBuilder:
 
     def __init__(self, suite_stat_level):
         self._suite_stat_level = suite_stat_level
-        self._stats_stack = []
-        self.stats = None
+        self._stats_stack: list[SuiteStatistics] = []
+        self.stats: SuiteStatistics | None = None
 
     @property
-    def current(self):
+    def current(self) -> 'SuiteStatistics|None':
         return self._stats_stack[-1] if self._stats_stack else None
 
     def start_suite(self, suite):

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/model/tags.py

@@ -108,6 +108,10 @@ class TagPatterns(Sequence['TagPattern']):
     def __init__(self, patterns: Iterable[str] = ()):
         self._patterns = tuple(TagPattern.from_string(p) for p in Tags(patterns))
 
+    @property
+    def is_constant(self):
+        return all(p.is_constant for p in self._patterns)
+
     def match(self, tags: Iterable[str]) -> bool:
         if not self._patterns:
             return False
@@ -132,6 +136,7 @@ class TagPatterns(Sequence['TagPattern']):
 
 
 class TagPattern(ABC):
+    is_constant = False
 
     @classmethod
     def from_string(cls, pattern: str) -> 'TagPattern':
@@ -166,6 +171,11 @@ class SingleTagPattern(TagPattern):
         self._matcher = Matcher(normalize(pattern, ignore='_'),
                                 caseless=False, spaceless=False)
 
+    @property
+    def is_constant(self):
+        pattern = self._matcher.pattern
+        return not ('*' in pattern or '?' in pattern or '[' in pattern)
+
     def match(self, tags: Iterable[str]) -> bool:
         tags = normalize_tags(tags)
         return self._matcher.match_any(tags)

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/model/tagstatistics.py

@@ -13,8 +13,8 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from itertools import chain
 import re
+from itertools import chain
 
 from robot.utils import NormalizedDict
 
@@ -26,10 +26,7 @@ class TagStatistics:
     """Container for tag statistics."""
 
     def __init__(self, combined_stats):
-        #: Dictionary, where key is the name of the tag as a string and value
-        #: is an instance of :class:`~robot.model.stats.TagStat`.
         self.tags = NormalizedDict(ignore='_')
-        #: List of :class:`~robot.model.stats.CombinedTagStat` objects.
         self.combined = combined_stats
 
     def visit(self, visitor):
@@ -127,21 +124,23 @@ class TagStatLink:
         return link, title
 
     def _replace_groups(self, link, title, match):
-        for index, group in enumerate(match.groups()):
-            placefolder = '%%%d' % (index+1)
+        for index, group in enumerate(match.groups(), start=1):
+            placefolder = f'%{index}'
             link = link.replace(placefolder, group)
             title = title.replace(placefolder, group)
         return link, title
 
     def _get_match_regexp(self, pattern):
-        pattern = '^%s$' % ''.join(self._yield_match_pattern(pattern))
+        pattern = ''.join(self._yield_match_pattern(pattern))
         return re.compile(pattern, re.IGNORECASE)
 
     def _yield_match_pattern(self, pattern):
+        yield '^'
         for token in self._match_pattern_tokenizer.split(pattern):
             if token.startswith('?'):
-                yield '(%s)' % ('.'*len(token))
+                yield f'({"."*len(token)})'
             elif token == '*':
                 yield '(.*)'
             else:
                 yield re.escape(token)
+        yield '$'

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/model/testcase.py

@@ -40,6 +40,7 @@ class TestCase(ModelObject, Generic[KW]):
     Extended by :class:`robot.running.model.TestCase` and
     :class:`robot.result.model.TestCase`.
     """
+    type = 'TEST'
     body_class = Body
     # See model.TestSuite on removing the type ignore directive
     fixture_class: Type[KW] = Keyword    # type: ignore

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/model/testsuite.py

@@ -42,6 +42,7 @@ class TestSuite(ModelObject, Generic[KW, TC]):
     Extended by :class:`robot.running.model.TestSuite` and
     :class:`robot.result.model.TestSuite`.
     """
+    type = 'SUITE'
     # FIXME: Type Ignore declarations: Typevars only accept subclasses of the bound class
     # assigning `Type[KW]` to `Keyword` results in an error. In RF 7 the class should be
     # made impossible to instantiate directly, and the assignments can be replaced with

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/model/totalstatistics.py

@@ -15,7 +15,7 @@
 
 from collections.abc import Iterator
 
-from robot.utils import test_or_task
+from robot.utils import plural_or_not, test_or_task
 
 from .stats import TotalStat
 from .visitor import SuiteVisitor
@@ -26,33 +26,33 @@ class TotalStatistics:
 
     def __init__(self, rpa: bool = False):
         #: Instance of :class:`~robot.model.stats.TotalStat` for all the tests.
-        self._stat = TotalStat(test_or_task('All {Test}s', rpa))
+        self.stat = TotalStat(test_or_task('All {Test}s', rpa))
         self._rpa = rpa
 
     def visit(self, visitor):
-        visitor.visit_total_statistics(self._stat)
+        visitor.visit_total_statistics(self.stat)
 
     def __iter__(self) -> 'Iterator[TotalStat]':
-        yield self._stat
+        yield self.stat
 
     @property
     def total(self) -> int:
-        return self._stat.total
+        return self.stat.total
 
     @property
     def passed(self) -> int:
-        return self._stat.passed
+        return self.stat.passed
 
     @property
     def skipped(self) -> int:
-        return self._stat.skipped
+        return self.stat.skipped
 
     @property
     def failed(self) -> int:
-        return self._stat.failed
+        return self.stat.failed
 
     def add_test(self, test):
-        self._stat.add_test(test)
+        self.stat.add_test(test)
 
     @property
     def message(self) -> str:
@@ -61,18 +61,11 @@ class TotalStatistics:
         For example::
             2 tests, 1 passed, 1 failed
         """
-        # TODO: should this message be highlighted in console
-        test_or_task = 'test' if not self._rpa else 'task'
-        total, end, passed, failed, skipped = self._get_counts()
-        template = '%d %s%s, %d passed, %d failed'
-        if skipped:
-            return ((template + ', %d skipped')
-                    % (total, test_or_task, end, passed, failed, skipped))
-        return template % (total, test_or_task, end, passed, failed)
-
-    def _get_counts(self):
-        ending = 's' if self.total != 1 else ''
-        return self.total, ending, self.passed, self.failed, self.skipped
+        kind = test_or_task('test', self._rpa) + plural_or_not(self.total)
+        msg = f'{self.total} {kind}, {self.passed} passed, {self.failed} failed'
+        if self.skipped:
+            msg += f', {self.skipped} skipped'
+        return msg
 
 
 class TotalStatisticsBuilder(SuiteVisitor):