robotframework 7.1rc2__zip → 7.2b1__zip

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/htmldata/rebot/log.html

@@ -131,7 +131,7 @@ function addExecutionLog(main) {
 
 <script type="text/x-jquery-tmpl" id="tagStatisticsRowTemplate">
   <tr class="row-${$item.index}">
-    <td class="stats-col-name" title="{{html doc}}">
+    <td class="stats-col-name" title="${doc}">
       <div class="stat-name">
         <span>{{html label}}</span>
         {{if info}}(${info}){{/if}}

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/htmldata/rebot/report.html

@@ -467,7 +467,7 @@ function hideHiddenDetailsColumns(elem) {
 
 <script type="text/x-jquery-tmpl" id="tagStatisticsRowTemplate">
   <tr onclick="tagDetailSelected('${label}')" class="row-${$item.index}">
-    <td class="stats-col-name" title="{{html doc}}">
+    <td class="stats-col-name" title="${doc}">
       <div class="stat-name">
         <a href="#tags?${label}">{{html label}}</a>
         {{if info}}(${info}){{/if}}

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/htmldata/rebot/testdata.js

@@ -7,7 +7,7 @@ window.testdata = function () {
     var STATUSES = ['FAIL', 'PASS', 'SKIP', 'NOT RUN'];
     var KEYWORD_TYPES = ['KEYWORD', 'SETUP', 'TEARDOWN', 'FOR', 'ITERATION', 'IF',
                          'ELSE IF', 'ELSE', 'RETURN', 'VAR', 'TRY', 'EXCEPT', 'FINALLY',
-                         'WHILE', 'CONTINUE', 'BREAK', 'ERROR'];
+                         'WHILE', 'GROUP', 'CONTINUE', 'BREAK', 'ERROR'];
 
     function addElement(elem) {
         if (!elem.id)

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/htmldata/template.py

@@ -20,8 +20,6 @@ from pathlib import Path
 
 
 if sys.version_info < (3, 9) and not Path(__file__).exists():    # zipsafe
-    # `importlib.resources.files` is new in Python 3.9, but that version does
-    # not seem to be compatible with zipapp.
     try:
         from importlib_resources import files
     except ImportError:

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

@@ -67,9 +67,6 @@ the normal installation. Alternatively it is possible to execute the
 can be replaced with any supported Python interpreter. Yet another alternative
 is running the module as a script like `python path/to/robot/libdoc.py`.
 
-The separate `libdoc` command and the support for JSON spec files are new in
-Robot Framework 4.0.
-
 Options
 =======
 
@@ -85,7 +82,7 @@ Options
                           documentation format and HTML means converting
                           documentation to HTML. The default is RAW with XML
                           spec files and HTML with JSON specs and when using
-                          the special LIBSPEC format. New in RF 4.0.
+                          the special LIBSPEC format.
  -F --docformat ROBOT|HTML|TEXT|REST
                           Specifies the source documentation format. Possible
                           values are Robot Framework's documentation format,
@@ -96,11 +93,14 @@ Options
                           Use dark or light HTML theme. If this option is not
                           used, or the value is NONE, the theme is selected
                           based on the browser color scheme. New in RF 6.0.
+    --language lang       Set the default language in documentation. `lang`
+                          must be a code of a built-in language, which are
+                          `en` and `fi`. New in RF 7.2.
  -n --name name           Sets the name of the documented library or resource.
  -v --version version     Sets the version of the documented library or
                           resource.
     --quiet               Do not print the path of the generated output file
-                          to the console. New in RF 4.0.
+                          to the console.
  -P --pythonpath path *   Additional locations where to search for libraries
                           and resources.
  -h -? --help             Print this help.
@@ -179,7 +179,7 @@ class LibDoc(Application):
         return options, arguments
 
     def main(self, args, name='', version='', format=None, docformat=None,
-             specdocformat=None, theme=None, pythonpath=None, quiet=False):
+             specdocformat=None, theme=None, language=None, pythonpath=None, quiet=False):
         if pythonpath:
             sys.path = pythonpath + sys.path
         lib_or_res, output = args[:2]
@@ -194,7 +194,8 @@ class LibDoc(Application):
                 or specdocformat == 'HTML'
                 or format in ('JSON', 'LIBSPEC') and specdocformat != 'RAW'):
             libdoc.convert_docs_to_html()
-        libdoc.save(output, format, self._validate_theme(theme, format))
+        libdoc.save(output, format, self._validate_theme(theme, format),
+                    self._validate_lang(language, format))
         if not quiet:
             self.console(Path(output).absolute())
 
@@ -229,13 +230,21 @@ class LibDoc(Application):
             raise DataError("The --theme option is only applicable with HTML outputs.")
         return theme
 
+    def _validate_lang(self, lang, format):
+        theme = self._validate('Language', lang, 'FI', 'EN', 'NONE')
+        if not theme or theme == 'NONE':
+            return None
+        if format != 'HTML':
+            raise DataError("The --theme option is only applicable with HTML outputs.")
+        return theme
+
 
 def libdoc_cli(arguments=None, exit=True):
     """Executes Libdoc similarly as from the command line.
 
     :param arguments: Command line options and arguments as a list of strings.
-        Starting from RF 4.0, defaults to ``sys.argv[1:]`` if not given.
-    :param exit: If ``True``, call ``sys.exit`` automatically. New in RF 4.0.
+        Defaults to ``sys.argv[1:]`` if not given.
+    :param exit: If ``True``, call ``sys.exit`` automatically.
 
     The :func:`libdoc` function may work better in programmatic usage.
 
@@ -271,9 +280,8 @@ def libdoc(library_or_resource, outfile, name='', version='', format=None,
         files is converted to HTML regardless of the original documentation
         format. Possible values are ``'HTML'`` (convert to HTML) and ``'RAW'``
         (use original format). The default depends on the output format.
-        New in Robot Framework 4.0.
     :param quiet: When true, the path of the generated output file is not
-        printed the console. New in Robot Framework 4.0.
+        printed the console.
 
     Arguments have same semantics as Libdoc command line options with same names.
     Run ``libdoc --help`` or consult the Libdoc section in the Robot Framework

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/libdocpkg/htmlwriter.py

@@ -18,23 +18,26 @@ from robot.htmldata import HtmlFileWriter, ModelWriter, LIBDOC
 
 class LibdocHtmlWriter:
 
-    def __init__(self, theme=None):
+    def __init__(self, theme=None, lang=None):
         self.theme = theme
+        self.lang = lang
 
     def write(self, libdoc, output):
-        model_writer = LibdocModelWriter(output, libdoc, self.theme)
+        model_writer = LibdocModelWriter(output, libdoc, self.theme, self.lang)
         HtmlFileWriter(output, model_writer).write(LIBDOC)
 
 
 class LibdocModelWriter(ModelWriter):
 
-    def __init__(self, output, libdoc, theme=None):
+    def __init__(self, output, libdoc, theme=None, lang=None):
         self.output = output
         self.libdoc = libdoc
         self.theme = theme
+        self.lang = lang
 
     def write(self, line):
-        data = self.libdoc.to_json(include_private=False, theme=self.theme)
+        data = self.libdoc.to_json(include_private=False, theme=self.theme,
+                                   lang=self.lang)
         self.output.write(f'<script type="text/javascript">\n'
                           f'libdoc = {data}\n'
                           f'</script>\n')

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

@@ -89,9 +89,9 @@ class LibraryDoc:
     def all_tags(self):
         return Tags(chain.from_iterable(kw.tags for kw in self.keywords))
 
-    def save(self, output=None, format='HTML', theme=None):
+    def save(self, output=None, format='HTML', theme=None, lang=None):
         with LibdocOutput(output, format) as outfile:
-            LibdocWriter(format, theme).write(self, outfile)
+            LibdocWriter(format, theme, lang).write(self, outfile)
 
     def convert_docs_to_html(self):
         formatter = DocFormatter(self.keywords, self.type_docs, self.doc, self.doc_format)
@@ -111,7 +111,7 @@ class LibraryDoc:
                 type_doc.doc = formatter.html(type_doc.doc)
         self.doc_format = 'HTML'
 
-    def to_dictionary(self, include_private=False, theme=None):
+    def to_dictionary(self, include_private=False, theme=None, lang=None):
         data = {
             'specversion': 3,
             'name': self.name,
@@ -131,10 +131,12 @@ class LibraryDoc:
         }
         if theme:
             data['theme'] = theme.lower()
+        if lang:
+            data['lang'] = lang.lower()
         return data
 
-    def to_json(self, indent=None, include_private=True, theme=None):
-        data = self.to_dictionary(include_private, theme)
+    def to_json(self, indent=None, include_private=True, theme=None, lang=None):
+        data = self.to_dictionary(include_private, theme, lang)
         return json.dumps(data, indent=indent)
 
 

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/libdocpkg/writer.py

@@ -20,10 +20,10 @@ from .xmlwriter import LibdocXmlWriter
 from .jsonwriter import LibdocJsonWriter
 
 
-def LibdocWriter(format=None, theme=None):
+def LibdocWriter(format=None, theme=None, lang=None):
     format = (format or 'HTML')
     if format == 'HTML':
-        return LibdocHtmlWriter(theme)
+        return LibdocHtmlWriter(theme, lang)
     if format == 'XML':
         return LibdocXmlWriter()
     if format == 'LIBSPEC':

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/libraries/BuiltIn.py

@@ -24,7 +24,7 @@ from robot.api.deco import keyword
 from robot.errors import (BreakLoop, ContinueLoop, DataError, ExecutionFailed,
                           ExecutionFailures, ExecutionPassed, PassExecution,
                           ReturnFromKeyword, VariableError)
-from robot.running import Keyword, RUN_KW_REGISTER
+from robot.running import Keyword, RUN_KW_REGISTER, TypeInfo
 from robot.running.context import EXECUTION_CONTEXTS
 from robot.utils import (DotDict, escape, format_assign_message, get_error_message,
                          get_time, html_escape, is_falsy, is_integer, is_list_like,
@@ -341,8 +341,8 @@ class _Converter(_BuiltInBase):
         - ``text:`` Converts text to bytes character by character. All
           characters with ordinal below 256 can be used and are converted to
           bytes with same values. Many characters are easiest to represent
-          using escapes like ``\x00`` or ``\xff``. Supports both Unicode
-          strings and bytes.
+          using escapes like ``\x00`` or ``\xff``. In practice this is the same
+          as Latin-1 encoding.
 
         - ``int:`` Converts integers separated by spaces to bytes. Similarly as
           with `Convert To Integer`, it is possible to use binary, octal, or
@@ -380,10 +380,10 @@ class _Converter(_BuiltInBase):
         """
         try:
             try:
-                ordinals = getattr(self, f'_get_ordinals_from_{input_type}')
+                get_ordinals = getattr(self, f'_get_ordinals_from_{input_type}')
             except AttributeError:
                 raise RuntimeError(f"Invalid input type '{input_type}'.")
-            return bytes(bytearray(o for o in ordinals(input)))
+            return bytes(o for o in get_ordinals(input))
         except:
             raise RuntimeError("Creating bytes failed: " + get_error_message())
 
@@ -583,8 +583,8 @@ class _Verify(_BuiltInBase):
 
     def should_be_equal(self, first, second, msg=None, values=True,
                         ignore_case=False, formatter='str', strip_spaces=False,
-                        collapse_spaces=False):
-        """Fails if the given objects are unequal.
+                        collapse_spaces=False, type=None, types=None):
+        r"""Fails if the given objects are unequal.
 
         Optional ``msg``, ``values`` and ``formatter`` arguments specify how
         to construct the error message if this keyword fails:
@@ -614,15 +614,33 @@ class _Verify(_BuiltInBase):
         arguments are strings, the comparison is done with all white spaces replaced by
         a single space character.
 
+        The ``type`` and ``types`` arguments control optional type conversion:
+        - If ``type`` is used, the argument ``second`` is converted to that type.
+          In addition to that, the argument ``first`` is validated to match the type.
+        - If ``types`` is used, both ``first`` and ``second`` are converted.
+        - Supported types are the same as supported by
+          [https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#supported-conversions|
+          automatic argument conversion] such as ``int``, ``bytes`` and ``list``.
+          Also parameterized types like ``list[int]`` and unions like ``int | float``
+          are supported.
+        - When using ``type``, a special value ``auto`` can be used to convert
+          ``second`` to the same type that ``first`` has.
+        - Using both ``type`` and ``types`` at the same time is an error.
+
         Examples:
         | Should Be Equal | ${x} | expected |
         | Should Be Equal | ${x} | expected | Custom error message |
         | Should Be Equal | ${x} | expected | Custom message | values=False |
         | Should Be Equal | ${x} | expected | ignore_case=True | formatter=repr |
+        | Should Be Equal | ${x} | \x00\x01 | type=bytes |
+        | Should Be Equal | ${x} | ${y}     | types=int|float |
 
         ``strip_spaces`` is new in Robot Framework 4.0 and
         ``collapse_spaces`` is new in Robot Framework 4.1.
+        ``type`` and ``types`` are new in Robot Framework 7.2.
         """
+        if type or types:
+            first, second = self._type_convert(first, second, type, types)
         self._log_types_at_info_if_different(first, second)
         if is_string(first) and is_string(second):
             if ignore_case:
@@ -636,6 +654,21 @@ class _Verify(_BuiltInBase):
                 second = self._collapse_spaces(second)
         self._should_be_equal(first, second, msg, values, formatter)
 
+    def _type_convert(self, first, second, type, types, type_builtin=type):
+        if type and types:
+            raise TypeError("Cannot use both 'type' and 'types' arguments.")
+        elif types:
+            type = types
+        elif isinstance(type, str) and type.upper() == 'AUTO':
+            type = type_builtin(first)
+        converter = TypeInfo.from_type_hint(type).get_converter()
+        if types:
+            first = converter.convert(first, 'first')
+        elif not converter.no_conversion_needed(first):
+            raise ValueError(f"Argument 'first' got value {first!r} that "
+                             f"does not match type {type!r}.")
+        return first, converter.convert(second, 'second')
+
     def _should_be_equal(self, first, second, msg, values, formatter='str'):
         include_values = self._include_values(values)
         formatter = self._get_formatter(formatter)
@@ -1527,8 +1560,12 @@ class _Variables(_BuiltInBase):
         For the reasons explained in the `Using variables with keywords creating
         or accessing variables` section, using the escaped format is recommended.
 
+        Notice that ``default`` must be given positionally like ``example`` and
+        not using the named-argument syntax like ``default=example``. We hope to
+        be able to remove this limitation in the future.
+
         Examples:
-        | ${x} =    `Get Variable Value`    $a    default
+        | ${x} =    `Get Variable Value`    $a    example
         | ${y} =    `Get Variable Value`    $a    ${b}
         | ${z} =    `Get Variable Value`    $z
         =>
@@ -1567,7 +1604,7 @@ class _Variables(_BuiltInBase):
         return name, value
 
     @run_keyword_variant(resolve=0)
-    def variable_should_exist(self, name, msg=None):
+    def variable_should_exist(self, name, message=None):
         r"""Fails unless the given variable exists within the current scope.
 
         The name of the variable can be given either as a normal variable name
@@ -1575,7 +1612,10 @@ class _Variables(_BuiltInBase):
         For the reasons explained in the `Using variables with keywords creating
         or accessing variables` section, using the escaped format is recommended.
 
-        The default error message can be overridden with the ``msg`` argument.
+        The default error message can be overridden with the ``message`` argument.
+        Notice that it must be given positionally like ``A message`` and not
+        using the named-argument syntax like ``message=A message``. We hope to
+        be able to remove this limitation in the future.
 
         See also `Variable Should Not Exist` and `Keyword Should Exist`.
         """
@@ -1583,11 +1623,11 @@ class _Variables(_BuiltInBase):
         try:
             self._variables.replace_scalar(name)
         except VariableError:
-            raise AssertionError(self._variables.replace_string(msg)
-                                 if msg else f"Variable '{name}' does not exist.")
+            raise AssertionError(self._variables.replace_string(message)
+                                 if message else f"Variable '{name}' does not exist.")
 
     @run_keyword_variant(resolve=0)
-    def variable_should_not_exist(self, name, msg=None):
+    def variable_should_not_exist(self, name, message=None):
         r"""Fails if the given variable exists within the current scope.
 
         The name of the variable can be given either as a normal variable name
@@ -1595,7 +1635,10 @@ class _Variables(_BuiltInBase):
         For the reasons explained in the `Using variables with keywords creating
         or accessing variables` section, using the escaped format is recommended.
 
-        The default error message can be overridden with the ``msg`` argument.
+        The default error message can be overridden with the ``message`` argument.
+        Notice that it must be given positionally like ``A message`` and not
+        using the named-argument syntax like ``message=A message``. We hope to
+        be able to remove this limitation in the future.
 
         See also `Variable Should Exist` and `Keyword Should Exist`.
         """
@@ -1605,8 +1648,8 @@ class _Variables(_BuiltInBase):
         except VariableError:
             pass
         else:
-            raise AssertionError(self._variables.replace_string(msg)
-                                 if msg else f"Variable '{name}' exists.")
+            raise AssertionError(self._variables.replace_string(message)
+                                 if message else f"Variable '{name}' exists.")
 
     def replace_variables(self, text):
         """Replaces variables in the given text with their current values.
@@ -1710,8 +1753,12 @@ class _Variables(_BuiltInBase):
         variable in a user keyword, it is available both in the test case level
         and also in all other user keywords used in the current test. Other
         test cases will not see variables set with this keyword.
-        It is an error to call `Set Test Variable` outside the
-        scope of a test (e.g. in a Suite Setup or Teardown).
+
+        If `Set Test Variable` is used in suite setup, the variable is available
+        everywhere within that suite setup as well as in the corresponding suite
+        teardown, but it is not seen by tests or possible child suites. If the
+        keyword is used in a suite teardown, the variable is available only in that
+        teardown.
 
         See `Set Suite Variable` for more information and usage examples. See
         also the `Using variables with keywords creating or accessing variables`
@@ -1724,6 +1771,9 @@ class _Variables(_BuiltInBase):
 
         *NOTE:* The ``VAR`` syntax introduced in Robot Framework 7.0 is recommended
         over this keyword.
+
+        *NOTE:* Prior to Robot Framework 7.2, using `Set Test Variable` in a suite
+        setup or teardown was an error.
         """
         name = self._get_var_name(name)
         value = self._get_var_value(name, values)
@@ -1914,7 +1964,7 @@ class _RunKeyword(_BuiltInBase):
         if not (ctx.dry_run or self._accepts_embedded_arguments(name, ctx)):
             name, args = self._replace_variables_in_name([name] + list(args))
         if ctx.steps:
-            data, result = ctx.steps[-1]
+            data, result, _ = ctx.steps[-1]
             lineno = data.lineno
         else:    # Called, typically by a listener, when no keyword started.
             data = lineno = None
@@ -2415,6 +2465,7 @@ class _RunKeyword(_BuiltInBase):
             try:
                 return self.run_keyword(name, *args)
             except ExecutionFailed as err:
+                self._reset_keyword_timeout_in_teardown(err, self._context)
                 if err.dont_continue or err.skip:
                     raise
                 count -= 1
@@ -2434,6 +2485,17 @@ class _RunKeyword(_BuiltInBase):
                         )
             self._sleep_in_parts(sleep_time)
 
+    def _reset_keyword_timeout_in_teardown(self, err, context):
+        # Keyword timeouts in teardowns have been converted to normal failures
+        # to allow execution to continue on higher level:
+        # https://github.com/robotframework/robotframework/issues/3398
+        # We need to reset it here to not continue unnecessarily:
+        # https://github.com/robotframework/robotframework/issues/5237
+        if context.in_teardown:
+            timeouts = [t for t in context.timeouts if t.type == 'Keyword']
+            if timeouts and min(timeouts).timed_out():
+                err.keyword_timeout = True
+
     @run_keyword_variant(resolve=1)
     def set_variable_if(self, condition, *values):
         """Sets variable based on the given condition.
@@ -3550,12 +3612,16 @@ class _Misc(_BuiltInBase):
             return re.escape(patterns[0])
         return [re.escape(p) for p in patterns]
 
-    def set_test_message(self, message, append=False):
+    def set_test_message(self, message, append=False, separator=' '):
         """Sets message for the current test case.
 
         If the optional ``append`` argument is given a true value (see `Boolean
         arguments`), the given ``message`` is added after the possible earlier
-        message by joining the messages with a space.
+        message.
+
+        An optional ``separator`` argument can be used to provide custom separator
+        string when appending to the old text. A single space is used as separator
+        by default.
 
         In test teardown this keyword can alter the possible failure message,
         but otherwise failures override messages set by this keyword. Notice
@@ -3572,19 +3638,21 @@ class _Misc(_BuiltInBase):
         | Set Test Message | `*`HTML`*` <b>Hello!</b> |                      |
 
         This keyword can not be used in suite setup or suite teardown.
+
+        The ``separator`` argument is new in Robot Framework 7.2.
         """
         test = self._context.test
         if not test:
             raise RuntimeError("'Set Test Message' keyword cannot be used in "
                                "suite setup or teardown.")
-        test.message = self._get_new_text(test.message, message,
-                                          append, handle_html=True)
+        test.message = self._get_new_text(
+            test.message, message, append, handle_html=True, separator=separator)
         if self._context.in_test_teardown:
             self._variables.set_test("${TEST_MESSAGE}", test.message)
         message, level = self._get_logged_test_message_and_level(test.message)
         self.log(f'Set test message to:\n{message}', level)
 
-    def _get_new_text(self, old, new, append, handle_html=False):
+    def _get_new_text(self, old, new, append, handle_html=False, separator=' '):
         if not is_string(new):
             new = str(new)
         if not (is_truthy(append) and old):
@@ -3594,35 +3662,43 @@ class _Misc(_BuiltInBase):
                 new = new[6:].lstrip()
                 if not old.startswith('*HTML*'):
                     old = f'*HTML* {html_escape(old)}'
+                separator = html_escape(separator)
             elif old.startswith('*HTML*'):
                 new = html_escape(new)
-        return f'{old} {new}'
+                separator = html_escape(separator)
+        return f'{old}{separator}{new}'
 
     def _get_logged_test_message_and_level(self, message):
         if message.startswith('*HTML*'):
             return message[6:].lstrip(), 'HTML'
         return message, 'INFO'
 
-    def set_test_documentation(self, doc, append=False):
+    def set_test_documentation(self, doc, append=False, separator=' '):
         """Sets documentation for the current test case.
 
-        By default the possible existing documentation is overwritten, but
+        The possible existing documentation is overwritten by default, but
         this can be changed using the optional ``append`` argument similarly
         as with `Set Test Message` keyword.
 
+        An optional ``separator`` argument can be used to provide custom separator
+        string when appending to the old text. A single space is used as separator
+        by default.
+
         The current test documentation is available as a built-in variable
         ``${TEST DOCUMENTATION}``. This keyword can not be used in suite
         setup or suite teardown.
+
+        The ``separator`` argument is new in Robot Framework 7.2.
         """
         test = self._context.test
         if not test:
             raise RuntimeError("'Set Test Documentation' keyword cannot be "
                                "used in suite setup or teardown.")
-        test.doc = self._get_new_text(test.doc, doc, append)
+        test.doc = self._get_new_text(test.doc, doc, append, separator=separator)
         self._variables.set_test('${TEST_DOCUMENTATION}', test.doc)
         self.log(f'Set test documentation to:\n{test.doc}')
 
-    def set_suite_documentation(self, doc, append=False, top=False):
+    def set_suite_documentation(self, doc, append=False, top=False, separator=' '):
         """Sets documentation for the current test suite.
 
         By default, the possible existing documentation is overwritten, but
@@ -3634,15 +3710,21 @@ class _Misc(_BuiltInBase):
         arguments`), the documentation of the top level suite is altered
         instead.
 
+        An optional ``separator`` argument can be used to provide custom separator
+        string when appending to the old text. A single space is used as separator
+        by default.
+
         The documentation of the current suite is available as a built-in
         variable ``${SUITE DOCUMENTATION}``.
+
+        The ``separator`` argument is new in Robot Framework 7.2.
         """
         suite = self._get_context(top).suite
-        suite.doc = self._get_new_text(suite.doc, doc, append)
+        suite.doc = self._get_new_text(suite.doc, doc, append, separator=separator)
         self._variables.set_suite('${SUITE_DOCUMENTATION}', suite.doc, top)
         self.log(f'Set suite documentation to:\n{suite.doc}')
 
-    def set_suite_metadata(self, name, value, append=False, top=False):
+    def set_suite_metadata(self, name, value, append=False, top=False, separator=' '):
         """Sets metadata for the current test suite.
 
         By default, possible existing metadata values are overwritten, but
@@ -3653,15 +3735,22 @@ class _Misc(_BuiltInBase):
         If the optional ``top`` argument is given a true value (see `Boolean
         arguments`), the metadata of the top level suite is altered instead.
 
+        An optional ``separator`` argument can be used to provide custom separator
+        string when appending to the old text. A single space is used as separator
+        by default.
+
         The metadata of the current suite is available as a built-in variable
         ``${SUITE METADATA}`` in a Python dictionary. Notice that modifying this
         variable directly has no effect on the actual metadata the suite has.
+
+        The ``separator`` argument is new in Robot Framework 7.2.
         """
         if not is_string(name):
             name = str(name)
         metadata = self._get_context(top).suite.metadata
         original = metadata.get(name, '')
-        metadata[name] = self._get_new_text(original, value, append)
+        metadata[name] = self._get_new_text(original, value, append,
+                                            separator=separator)
         self._variables.set_suite('${SUITE_METADATA}', metadata.copy(), top)
         self.log(f"Set suite metadata '{name}' to value '{metadata[name]}'.")
 

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/libraries/Collections.py

@@ -455,9 +455,8 @@ class _List:
         normalize = Normalizer(ignore_case).normalize
         list1 = normalize(list1)
         list2 = normalize(list2)
-        diffs = ', '.join(str(item) for item in list2 if item not in list1)
-        _verify_condition(not diffs,
-                          f'Following values were not found from first list: {diffs}',
+        diffs = [item for item in list2 if item not in list1]
+        _verify_condition(not diffs, f'Following values are missing: {seq2str(diffs)}',
                           msg, values)
 
     def log_list(self, list_, level='INFO'):
@@ -784,7 +783,8 @@ class _Dictionary:
         )
 
     def dictionaries_should_be_equal(self, dict1, dict2, msg=None, values=True,
-                                     ignore_keys=None, ignore_case=False):
+                                     ignore_keys=None, ignore_case=False,
+                                     ignore_value_order=False):
         """Fails if the given dictionaries are not equal.
 
         First the equality of dictionaries' keys is checked and after that all
@@ -808,9 +808,15 @@ class _Dictionary:
         The ``ignore_case`` argument can be used to make comparison case-insensitive.
         See the `Ignore case` section for more details. This option is new in
         Robot Framework 7.0.
+
+        The ``ignore_value_order`` argument can be used to make comparison in case of
+        list-like values to ignore the order of the elements in the lists.
+        Using it requires items to be sortable.
+        This option is new in Robot Framework 7.2.
         """
         self._validate_dictionary(dict1, dict2)
-        normalizer = Normalizer(ignore_case, ignore_keys=ignore_keys)
+        normalizer = Normalizer(ignore_case=ignore_case, ignore_keys=ignore_keys,
+                                ignore_order=ignore_value_order)
         dict1 = normalizer.normalize(dict1)
         dict2 = normalizer.normalize(dict2)
         self._should_have_same_keys(dict1, dict2, msg, values)
@@ -840,7 +846,8 @@ class _Dictionary:
             _report_error(error, message, values)
 
     def dictionary_should_contain_sub_dictionary(self, dict1, dict2, msg=None,
-                                                 values=True, ignore_case=False):
+                                                 values=True, ignore_case=False,
+                                                 ignore_value_order=False):
         """Fails unless all items in ``dict2`` are found from ``dict1``.
 
         See `Lists Should Be Equal` for more information about configuring
@@ -849,9 +856,15 @@ class _Dictionary:
         The ``ignore_case`` argument can be used to make comparison case-insensitive.
         See the `Ignore case` section for more details. This option is new in
         Robot Framework 7.0.
+
+        The ``ignore_value_order`` argument can be used to make comparison in case of
+        list-like values to ignore the order of the elements in the lists.
+        Using it requires items to be sortable.
+        This option is new in Robot Framework 7.2.
         """
         self._validate_dictionary(dict1, dict2)
-        normalizer = Normalizer(ignore_case)
+        normalizer = Normalizer(ignore_case=ignore_case,
+                                ignore_order=ignore_value_order)
         dict1 = normalizer.normalize(dict1)
         dict2 = normalizer.normalize(dict2)
         self._should_have_same_keys(dict1, dict2, msg, values, validate_both=False)

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

@@ -27,12 +27,12 @@ This package is considered stable.
 
 from .body import BaseBody, Body, BodyItem, BaseBranches, BaseIterations
 from .configurer import SuiteConfigurer
-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 .fixture import create_fixture
 from .itemlist import ItemList
 from .keyword import Keyword
-from .message import Message, MessageLevel, Messages
+from .message import Message, MessageLevel
 from .modelobject import DataDict, ModelObject
 from .modifier import ModelModifier
 from .statistics import Statistics