robotframework 6.1rc1__zip → 7.0__zip

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/libraries/BuiltIn.py

@@ -17,6 +17,7 @@ import difflib
 import re
 import time
 from collections import OrderedDict
+from collections.abc import Sequence
 
 from robot.api import logger, SkipExecution
 from robot.api.deco import keyword
@@ -25,7 +26,6 @@ from robot.errors import (BreakLoop, ContinueLoop, DataError, ExecutionFailed,
                           ReturnFromKeyword, VariableError)
 from robot.running import Keyword, RUN_KW_REGISTER
 from robot.running.context import EXECUTION_CONTEXTS
-from robot.running.usererrorhandler import UserErrorHandler
 from robot.utils import (DotDict, escape, format_assign_message, get_error_message,
                          get_time, html_escape, is_falsy, is_integer, is_list_like,
                          is_string, is_truthy, Matcher, normalize,
@@ -36,7 +36,7 @@ from robot.utils import (DotDict, escape, format_assign_message, get_error_messa
 from robot.utils.asserts import assert_equal, assert_not_equal
 from robot.variables import (evaluate_expression, is_dict_variable,
                              is_list_variable, search_variable,
-                             DictVariableTableValue, VariableTableValue)
+                             DictVariableResolver, VariableResolver)
 from robot.version import get_version
 
 
@@ -153,8 +153,8 @@ class _Converter(_BuiltInBase):
                 return int(item, self._convert_to_integer(base))
             return int(item)
         except:
-            raise RuntimeError("'%s' cannot be converted to an integer: %s"
-                               % (orig, get_error_message()))
+            raise RuntimeError(f"'{orig}' cannot be converted to an integer: "
+                               f"{get_error_message()}")
 
     def _get_base(self, item, base):
         if not is_string(item):
@@ -300,8 +300,8 @@ class _Converter(_BuiltInBase):
             try:
                 return float(self._convert_to_integer(item))
             except RuntimeError:
-                raise RuntimeError("'%s' cannot be converted to a floating "
-                                   "point number: %s" % (item, error))
+                raise RuntimeError(f"'{item}' cannot be converted to a floating "
+                                   f"point number: {error}")
 
     def convert_to_string(self, item):
         """Converts the given item to a Unicode string.
@@ -380,12 +380,12 @@ class _Converter(_BuiltInBase):
         """
         try:
             try:
-                ordinals = getattr(self, '_get_ordinals_from_%s' % input_type)
+                ordinals = getattr(self, f'_get_ordinals_from_{input_type}')
             except AttributeError:
-                raise RuntimeError("Invalid input type '%s'." % input_type)
+                raise RuntimeError(f"Invalid input type '{input_type}'.")
             return bytes(bytearray(o for o in ordinals(input)))
         except:
-            raise RuntimeError("Creating bytes failed: %s" % get_error_message())
+            raise RuntimeError("Creating bytes failed: " + get_error_message())
 
     def _get_ordinals_from_text(self, input):
         for char in input:
@@ -395,8 +395,7 @@ class _Converter(_BuiltInBase):
     def _test_ordinal(self, ordinal, original, type):
         if 0 <= ordinal <= 255:
             return ordinal
-        raise RuntimeError("%s '%s' cannot be represented as a byte."
-                           % (type, original))
+        raise RuntimeError(f"{type} '{original}' cannot be represented as a byte.")
 
     def _get_ordinals_from_int(self, input):
         if is_string(input):
@@ -422,7 +421,7 @@ class _Converter(_BuiltInBase):
             return input
         input = ''.join(input.split())
         if len(input) % length != 0:
-            raise RuntimeError('Expected input to be multiple of %d.' % length)
+            raise RuntimeError(f'Expected input to be multiple of {length}.')
         return (input[i:i+length] for i in range(0, len(input), length))
 
     def create_list(self, *items):
@@ -472,7 +471,7 @@ class _Converter(_BuiltInBase):
         """
         separate, combined = self._split_dict_items(items)
         result = DotDict(self._format_separate_dict_items(separate))
-        combined = DictVariableTableValue(combined).resolve(self._variables)
+        combined = DictVariableResolver(combined).resolve(self._variables)
         result.update(combined)
         return result
 
@@ -488,8 +487,8 @@ class _Converter(_BuiltInBase):
     def _format_separate_dict_items(self, separate):
         separate = self._variables.replace_list(separate)
         if len(separate) % 2 != 0:
-            raise DataError('Expected even number of keys and values, got %d.'
-                            % len(separate))
+            raise DataError(f'Expected even number of keys and values, '
+                            f'got {len(separate)}.')
         return [separate[i:i+2] for i in range(0, len(separate), 2)]
 
 
@@ -527,7 +526,7 @@ class _Verify(_BuiltInBase):
         See `Fatal Error` if you need to stop the whole test execution.
         """
         self._set_and_remove_tags(tags)
-        raise AssertionError(msg) if msg else AssertionError()
+        raise AssertionError(msg) if msg is not None else AssertionError()
 
     def fatal_error(self, msg=None):
         """Stops the whole test execution.
@@ -549,7 +548,7 @@ class _Verify(_BuiltInBase):
         and how ``msg`` can be used to override the default error message.
         """
         if self._is_true(condition):
-            raise AssertionError(msg or "'%s' should not be true." % condition)
+            raise AssertionError(msg or f"'{condition}' should not be true.")
 
     def should_be_true(self, condition, msg=None):
         """Fails if the given condition is not true.
@@ -580,7 +579,7 @@ class _Verify(_BuiltInBase):
         | Should Be True | $status == 'PASS' | # Expected string must be quoted |
         """
         if not self._is_true(condition):
-            raise AssertionError(msg or "'%s' should be true." % condition)
+            raise AssertionError(msg or f"'{condition}' should be true.")
 
     def should_be_equal(self, first, second, msg=None, values=True,
                         ignore_case=False, formatter='str', strip_spaces=False,
@@ -627,8 +626,8 @@ class _Verify(_BuiltInBase):
         self._log_types_at_info_if_different(first, second)
         if is_string(first) and is_string(second):
             if ignore_case:
-                first = first.lower()
-                second = second.lower()
+                first = first.casefold()
+                second = second.casefold()
             if strip_spaces:
                 first = self._strip_spaces(first, strip_spaces)
                 second = self._strip_spaces(second, strip_spaces)
@@ -655,14 +654,14 @@ class _Verify(_BuiltInBase):
         second_lines = second.splitlines(True)
         if len(first_lines) < 3 or len(second_lines) < 3:
             return
-        self.log("%s\n\n!=\n\n%s" % (first.rstrip(), second.rstrip()))
+        self.log(f"{first.rstrip()}\n\n!=\n\n{second.rstrip()}")
         diffs = list(difflib.unified_diff(first_lines, second_lines,
                                           fromfile='first', tofile='second',
                                           lineterm=''))
         diffs[3:] = [item[0] + formatter(item[1:]).rstrip() for item in diffs[3:]]
         prefix = 'Multiline strings are different:'
         if msg:
-            prefix = '%s: %s' % (msg, prefix)
+            prefix = f'{msg}: {prefix}'
         raise AssertionError('\n'.join([prefix] + diffs))
 
     def _include_values(self, values):
@@ -709,8 +708,8 @@ class _Verify(_BuiltInBase):
         self._log_types_at_info_if_different(first, second)
         if is_string(first) and is_string(second):
             if ignore_case:
-                first = first.lower()
-                second = second.lower()
+                first = first.casefold()
+                second = second.casefold()
             if strip_spaces:
                 first = self._strip_spaces(first, strip_spaces)
                 second = self._strip_spaces(second, strip_spaces)
@@ -845,8 +844,8 @@ class _Verify(_BuiltInBase):
         first = safe_str(first)
         second = safe_str(second)
         if ignore_case:
-            first = first.lower()
-            second = second.lower()
+            first = first.casefold()
+            second = second.casefold()
         if strip_spaces:
             first = self._strip_spaces(first, strip_spaces)
             second = self._strip_spaces(second, strip_spaces)
@@ -886,8 +885,8 @@ class _Verify(_BuiltInBase):
         first = safe_str(first)
         second = safe_str(second)
         if ignore_case:
-            first = first.lower()
-            second = second.lower()
+            first = first.casefold()
+            second = second.casefold()
         if strip_spaces:
             first = self._strip_spaces(first, strip_spaces)
             second = self._strip_spaces(second, strip_spaces)
@@ -906,8 +905,8 @@ class _Verify(_BuiltInBase):
         of the ``ignore_case``, ``strip_spaces``, and ``collapse_spaces`` options.
         """
         if ignore_case:
-            str1 = str1.lower()
-            str2 = str2.lower()
+            str1 = str1.casefold()
+            str2 = str2.casefold()
         if strip_spaces:
             str1 = self._strip_spaces(str1, strip_spaces)
             str2 = self._strip_spaces(str2, strip_spaces)
@@ -927,8 +926,8 @@ class _Verify(_BuiltInBase):
         of the ``ignore_case``, ``strip_spaces``, and ``collapse_spaces`` options.
         """
         if ignore_case:
-            str1 = str1.lower()
-            str2 = str2.lower()
+            str1 = str1.casefold()
+            str2 = str2.casefold()
         if strip_spaces:
             str1 = self._strip_spaces(str1, strip_spaces)
             str2 = self._strip_spaces(str2, strip_spaces)
@@ -949,8 +948,8 @@ class _Verify(_BuiltInBase):
         of the ``ignore_case``, ``strip_spaces``, and ``collapse_spaces`` options.
         """
         if ignore_case:
-            str1 = str1.lower()
-            str2 = str2.lower()
+            str1 = str1.casefold()
+            str2 = str2.casefold()
         if strip_spaces:
             str1 = self._strip_spaces(str1, strip_spaces)
             str2 = self._strip_spaces(str2, strip_spaces)
@@ -970,8 +969,8 @@ class _Verify(_BuiltInBase):
         of the ``ignore_case``, ``strip_spaces``, and ``collapse_spaces`` options.
         """
         if ignore_case:
-            str1 = str1.lower()
-            str2 = str2.lower()
+            str1 = str1.casefold()
+            str2 = str2.casefold()
         if strip_spaces:
             str1 = self._strip_spaces(str1, strip_spaces)
             str2 = self._strip_spaces(str2, strip_spaces)
@@ -1018,11 +1017,11 @@ class _Verify(_BuiltInBase):
         # case-insensitive comparisons.
         orig_container = container
         if ignore_case and is_string(item):
-            item = item.lower()
+            item = item.casefold()
             if is_string(container):
-                container = container.lower()
+                container = container.casefold()
             elif is_list_like(container):
-                container = set(x.lower() if is_string(x) else x for x in container)
+                container = set(x.casefold() if is_string(x) else x for x in container)
         if strip_spaces and is_string(item):
             item = self._strip_spaces(item, strip_spaces)
             if is_string(container):
@@ -1074,11 +1073,11 @@ class _Verify(_BuiltInBase):
         """
         orig_container = container
         if ignore_case and is_string(item):
-            item = item.lower()
+            item = item.casefold()
             if is_string(container):
-                container = container.lower()
+                container = container.casefold()
             elif is_list_like(container):
-                container = set(x.lower() if is_string(x) else x for x in container)
+                container = set(x.casefold() if is_string(x) else x for x in container)
         if strip_spaces and is_string(item):
             item = self._strip_spaces(item, strip_spaces)
             if is_string(container):
@@ -1123,17 +1122,17 @@ class _Verify(_BuiltInBase):
         strip_spaces = configuration.pop('strip_spaces', False)
         collapse_spaces = is_truthy(configuration.pop('collapse_spaces', False))
         if configuration:
-            raise RuntimeError("Unsupported configuration parameter%s: %s."
-                               % (s(configuration), seq2str(sorted(configuration))))
+            raise RuntimeError(f"Unsupported configuration parameter{s(configuration)}: "
+                               f"{seq2str(sorted(configuration))}.")
         if not items:
             raise RuntimeError('One or more items required.')
         orig_container = container
         if ignore_case:
-            items = [x.lower() if is_string(x) else x for x in items]
+            items = [x.casefold() if is_string(x) else x for x in items]
             if is_string(container):
-                container = container.lower()
+                container = container.casefold()
             elif is_list_like(container):
-                container = set(x.lower() if is_string(x) else x for x in container)
+                container = set(x.casefold() if is_string(x) else x for x in container)
         if strip_spaces:
             items = [self._strip_spaces(x, strip_spaces) for x in items]
             if is_string(container):
@@ -1181,17 +1180,17 @@ class _Verify(_BuiltInBase):
         strip_spaces = configuration.pop('strip_spaces', False)
         collapse_spaces = is_truthy(configuration.pop('collapse_spaces', False))
         if configuration:
-            raise RuntimeError("Unsupported configuration parameter%s: %s."
-                               % (s(configuration), seq2str(sorted(configuration))))
+            raise RuntimeError(f"Unsupported configuration parameter{s(configuration)}: "
+                               f"{seq2str(sorted(configuration))}.")
         if not items:
             raise RuntimeError('One or more items required.')
         orig_container = container
         if ignore_case:
-            items = [x.lower() if is_string(x) else x for x in items]
+            items = [x.casefold() if is_string(x) else x for x in items]
             if is_string(container):
-                container = container.lower()
+                container = container.casefold()
             elif is_list_like(container):
-                container = set(x.lower() if is_string(x) else x for x in container)
+                container = set(x.casefold() if is_string(x) else x for x in container)
         if strip_spaces:
             items = [self._strip_spaces(x, strip_spaces) for x in items]
             if is_string(container):
@@ -1247,11 +1246,11 @@ class _Verify(_BuiltInBase):
         orig_container = container
         if is_string(item):
             if ignore_case:
-                item = item.lower()
+                item = item.casefold()
                 if is_string(container):
-                    container = container.lower()
+                    container = container.casefold()
                 elif is_list_like(container):
-                    container = [x.lower() if is_string(x) else x for x in container]
+                    container = [x.casefold() if is_string(x) else x for x in container]
             if strip_spaces:
                 item = self._strip_spaces(item, strip_spaces)
                 if is_string(container):
@@ -1266,8 +1265,8 @@ class _Verify(_BuiltInBase):
                     container = [self._collapse_spaces(x) for x in container]
         x = self.get_count(container, item)
         if not msg:
-            msg = "%r contains '%s' %d time%s, not %d time%s." \
-                    % (orig_container, item, x, s(x), count, s(count))
+            msg = (f"{orig_container!r} contains '{item}' {x} time{s(x)}, "
+                   f"not {count} time{s(count)}.")
         self.should_be_equal_as_integers(x, count, msg, values=False)
 
     def get_count(self, container, item):
@@ -1284,10 +1283,10 @@ class _Verify(_BuiltInBase):
             try:
                 container = list(container)
             except:
-                raise RuntimeError("Converting '%s' to list failed: %s"
-                                   % (container, get_error_message()))
+                raise RuntimeError(f"Converting '{container}' to list failed: "
+                                   f"{get_error_message()}")
         count = container.count(item)
-        self.log('Item found from container %d time%s.' % (count, s(count)))
+        self.log(f'Item found from container {count} time{s(count)}.')
         return count
 
     def should_not_match(self, string, pattern, msg=None, values=True,
@@ -1407,7 +1406,7 @@ class _Verify(_BuiltInBase):
         Empty`.
         """
         length = self._get_length(item)
-        self.log('Length is %d' % length)
+        self.log(f'Length is {length}.')
         return length
 
     def _get_length(self, item):
@@ -1431,7 +1430,7 @@ class _Verify(_BuiltInBase):
                     except RERAISED_EXCEPTIONS:
                         raise
                     except:
-                        raise RuntimeError("Could not get length of '%s'." % item)
+                        raise RuntimeError(f"Could not get length of '{item}'.")
 
     def length_should_be(self, item, length, msg=None):
         """Verifies that the length of the given item is correct.
@@ -1442,8 +1441,8 @@ class _Verify(_BuiltInBase):
         length = self._convert_to_integer(length)
         actual = self.get_length(item)
         if actual != length:
-            raise AssertionError(msg or "Length of '%s' should be %d but is %d."
-                                        % (item, length, actual))
+            raise AssertionError(msg or f"Length of '{item}' should be {length} "
+                                        f"but is {actual}.")
 
     def should_be_empty(self, item, msg=None):
         """Verifies that the given item is empty.
@@ -1452,7 +1451,7 @@ class _Verify(_BuiltInBase):
         default error message can be overridden with the ``msg`` argument.
         """
         if self.get_length(item) > 0:
-            raise AssertionError(msg or "'%s' should be empty." % (item,))
+            raise AssertionError(msg or f"'{item}' should be empty.")
 
     def should_not_be_empty(self, item, msg=None):
         """Verifies that the given item is not empty.
@@ -1461,18 +1460,18 @@ class _Verify(_BuiltInBase):
         default error message can be overridden with the ``msg`` argument.
         """
         if self.get_length(item) == 0:
-            raise AssertionError(msg or "'%s' should not be empty." % (item,))
+            raise AssertionError(msg or f"'{item}' should not be empty.")
 
     def _get_string_msg(self, item1, item2, custom_message, include_values,
                         delimiter, quote_item1=True, quote_item2=True):
         if custom_message and not self._include_values(include_values):
             return custom_message
-        item1 = "'%s'" % safe_str(item1) if quote_item1 else safe_str(item1)
-        item2 = "'%s'" % safe_str(item2) if quote_item2 else safe_str(item2)
-        default_message = '%s %s %s' % (item1, delimiter, item2)
+        item1 = f"'{safe_str(item1)}'" if quote_item1 else safe_str(item1)
+        item2 = f"'{safe_str(item2)}'" if quote_item2 else safe_str(item2)
+        default_message = f'{item1} {delimiter} {item2}'
         if not custom_message:
             return default_message
-        return '%s: %s' % (custom_message, default_message)
+        return f'{custom_message}: {default_message}'
 
 
 class _Variables(_BuiltInBase):
@@ -1533,7 +1532,7 @@ class _Variables(_BuiltInBase):
     def log_variables(self, level='INFO'):
         """Logs all variables in the current scope with given log level."""
         variables = self.get_variables()
-        for name in sorted(variables, key=lambda s: s[2:-1].lower()):
+        for name in sorted(variables, key=lambda s: s[2:-1].casefold()):
             name, value = self._get_logged_variable(name, variables)
             msg = format_assign_message(name, value, cut_long=False)
             self.log(msg, level)
@@ -1542,12 +1541,15 @@ class _Variables(_BuiltInBase):
         value = variables[name]
         try:
             if name[0] == '@':
-                value = list(value)
+                if isinstance(value, Sequence):
+                    value = list(value)
+                else:    # Don't consume iterables.
+                    name = '$' + name[1:]
             if name[0] == '&':
                 value = OrderedDict(value)
         except RERAISED_EXCEPTIONS:
             raise
-        except:
+        except Exception:
             name = '$' + name[1:]
         return name, value
 
@@ -1569,7 +1571,7 @@ class _Variables(_BuiltInBase):
             self._variables.replace_scalar(name)
         except VariableError:
             raise AssertionError(self._variables.replace_string(msg)
-                                 if msg else "Variable '%s' does not exist." % name)
+                                 if msg else f"Variable '{name}' does not exist.")
 
     @run_keyword_variant(resolve=0)
     def variable_should_not_exist(self, name, msg=None):
@@ -1591,14 +1593,14 @@ class _Variables(_BuiltInBase):
             pass
         else:
             raise AssertionError(self._variables.replace_string(msg)
-                                 if msg else "Variable '%s' exists." % name)
+                                 if msg else f"Variable '{name}' exists.")
 
     def replace_variables(self, text):
         """Replaces variables in the given text with their current values.
 
         If the text contains undefined variables, this keyword fails.
         If the given ``text`` contains only a single variable, its value is
-        returned as-is and it can be any object. Otherwise this keyword
+        returned as-is and it can be any object. Otherwise, this keyword
         always returns a string.
 
         Example:
@@ -1621,16 +1623,23 @@ class _Variables(_BuiltInBase):
         It is recommended to use `Create List` when creating new lists.
 
         Examples:
-        | ${hi} =   | Set Variable | Hello, world! |
-        | ${hi2} =  | Set Variable | I said: ${hi} |
-        | ${var1}   | ${var2} =    | Set Variable | Hello | world |
-        | @{list} = | Set Variable | ${list with some items} |
-        | ${item1}  | ${item2} =   | Set Variable  | ${list with 2 items} |
+        | ${hi} =    Set Variable    Hello, world!
+        | ${hi2} =    Set Variable    I said: ${hi}
+        | ${var1}    ${var2} =    Set Variable    Hello    world
+        | @{list} =    Set Variable    ${list with some items}
+        | ${item1}    ${item2} =    Set Variable    ${list with 2 items}
 
         Variables created with this keyword are available only in the
         scope where they are created. See `Set Global Variable`,
         `Set Test Variable` and `Set Suite Variable` for information on how to
         set variables so that they are available also in a larger scope.
+
+        *NOTE:* The ``VAR`` syntax introduced in Robot Framework 7.0 is generally
+        recommended over this keyword. The basic usage is shown below and the Robot
+        Framework User Guide explains the syntax in detail.
+
+        | VAR    ${hi}     Hello, world!
+        | VAR    ${hi2}    I said: ${hi}
         """
         if len(values) == 0:
             return ''
@@ -1670,10 +1679,13 @@ class _Variables(_BuiltInBase):
         ``${name}``.
 
         See also `Set Global Variable` and `Set Test Variable`.
+
+        *NOTE:* The ``VAR`` syntax introduced in Robot Framework 7.0 is recommended
+        over this keyword.
         """
         name = self._get_var_name(name)
         value = self._get_var_value(name, values)
-        self._variables.set_local_variable(name, value)
+        self._variables.set_local(name, value)
         self._log_set_variable(name, value)
 
     @run_keyword_variant(resolve=0)
@@ -1696,6 +1708,9 @@ class _Variables(_BuiltInBase):
 
         When creating automated tasks, not tests, it is possible to use `Set
         Task Variable`. See also `Set Global Variable` and `Set Local Variable`.
+
+        *NOTE:* The ``VAR`` syntax introduced in Robot Framework 7.0 is recommended
+        over this keyword.
         """
         name = self._get_var_name(name)
         value = self._get_var_value(name, values)
@@ -1708,6 +1723,9 @@ class _Variables(_BuiltInBase):
 
         This is an alias for `Set Test Variable` that is more applicable when
         creating tasks, not tests.
+
+        *NOTE:* The ``VAR`` syntax introduced in Robot Framework 7.0 is recommended
+        over this keyword.
         """
         self.set_test_variable(name, *values)
 
@@ -1760,6 +1778,14 @@ class _Variables(_BuiltInBase):
         | Set Suite Variable    &DICT      &{EMPTY}
 
         See also `Set Global Variable`, `Set Test Variable` and `Set Local Variable`.
+
+        *NOTE:* The ``VAR`` syntax introduced in Robot Framework 7.0 is recommended
+        over this keyword. The basic usage is shown below and the Robot Framework
+        User Guide explains the syntax in detail.
+
+        | VAR    ${SCALAR}    Hello, world!                scope=SUITE
+        | VAR    @{LIST}      First item    Second item    scope=SUITE
+        | VAR    &{DICT}      key=value     foo=bar        scope=SUITE
         """
         name = self._get_var_name(name)
         if values and is_string(values[-1]) and values[-1].startswith('children='):
@@ -1793,6 +1819,9 @@ class _Variables(_BuiltInBase):
         section for information why it is recommended to give the variable name
         in escaped format like ``$name`` or ``\${name}`` instead of the normal
         ``${name}``.
+
+        *NOTE:* The ``VAR`` syntax introduced in Robot Framework 7.0 is recommended
+        over this keyword.
         """
         name = self._get_var_name(name)
         value = self._get_var_value(name, values)
@@ -1814,7 +1843,7 @@ class _Variables(_BuiltInBase):
         match.resolve_base(self._variables)
         valid = match.is_assign() if require_assign else match.is_variable()
         if not valid:
-            raise DataError("Invalid variable name '%s'." % name)
+            raise DataError(f"Invalid variable name '{name}'.")
         return str(match)
 
     def _resolve_var_name(self, name):
@@ -1823,7 +1852,7 @@ class _Variables(_BuiltInBase):
         if len(name) < 2 or name[0] not in '$@&':
             raise ValueError
         if name[1] != '{':
-            name = '%s{%s}' % (name[0], name[1:])
+            name = f'{name[0]}{{{name[1:]}}}'
         match = search_variable(name, identifiers='$@&', ignore_errors=True)
         match.resolve_base(self._variables)
         if not match.is_assign():
@@ -1839,11 +1868,12 @@ class _Variables(_BuiltInBase):
             # handling non-string values somehow. For details see
             # https://github.com/robotframework/robotframework/issues/1919
             if len(values) != 1 or is_list_variable(values[0]):
-                raise DataError("Setting list value to scalar variable '%s' "
-                                "is not supported anymore. Create list "
-                                "variable '@%s' instead." % (name, name[1:]))
+                raise DataError(f"Setting list value to scalar variable '{name}' "
+                                f"is not supported anymore. Create list variable "
+                                f"'@{name[1:]}' instead.")
             return self._variables.replace_scalar(values[0])
-        return VariableTableValue(values, name).resolve(self._variables)
+        resolver = VariableResolver.from_name_and_value(name, values)
+        return resolver.resolve(self._variables)
 
     def _log_set_variable(self, name, value):
         self.log(format_assign_message(name, value))
@@ -1870,14 +1900,19 @@ class _RunKeyword(_BuiltInBase):
         ctx = self._context
         if not (ctx.dry_run or self._accepts_embedded_arguments(name, ctx)):
             name, args = self._replace_variables_in_name([name] + list(args))
-        parent = ctx.steps[-1] if ctx.steps else (ctx.test or ctx.suite)
-        kw = Keyword(name, args=args, parent=parent,
-                     lineno=getattr(parent, 'lineno', None))
-        return kw.run(ctx)
+        if ctx.steps:
+            data, result = ctx.steps[-1]
+            lineno = data.lineno
+        else:    # Called, typically by a listener, when no keyword started.
+            data = lineno = None
+            result = ctx.test or (ctx.suite.setup if not ctx.suite.has_tests
+                                  else ctx.suite.teardown)
+        kw = Keyword(name, args=args, parent=data, lineno=lineno)
+        return kw.run(result, ctx)
 
     def _accepts_embedded_arguments(self, name, ctx):
         if '{' in name:
-            runner = ctx.get_runner(name)
+            runner = ctx.get_runner(name, recommend_on_failure=False)
             return runner and hasattr(runner, 'embedded_args')
         return False
 
@@ -2048,7 +2083,7 @@ class _RunKeyword(_BuiltInBase):
         index = list(args).index(control_word)
         branch = self._variables.replace_list(args[index+1:], required)
         if len(branch) < required:
-            raise DataError('%s requires %s.' % (control_word, required_error))
+            raise DataError(f'{control_word} requires {required_error}.')
         return args[:index], branch
 
     @run_keyword_variant(resolve=1, dry_run=True)
@@ -2105,7 +2140,7 @@ class _RunKeyword(_BuiltInBase):
         """
         status, message = self.run_keyword_and_ignore_error(name, *args)
         if status == 'FAIL':
-            logger.warn("Executing keyword '%s' failed:\n%s" % (name, message))
+            logger.warn(f"Executing keyword '{name}' failed:\n{message}")
         return status, message
 
     @run_keyword_variant(resolve=0, dry_run=True)
@@ -2206,11 +2241,9 @@ class _RunKeyword(_BuiltInBase):
                 raise
             error = err.message
         else:
-            raise AssertionError("Expected error '%s' did not occur."
-                                 % expected_error)
+            raise AssertionError(f"Expected error '{expected_error}' did not occur.")
         if not self._error_is_expected(error, expected_error):
-            raise AssertionError("Expected error '%s' but got '%s'."
-                                 % (expected_error, error))
+            raise AssertionError(f"Expected error '{expected_error}' but got '{error}'.")
         return error
 
     def _error_is_expected(self, error, expected_error):
@@ -2218,7 +2251,7 @@ class _RunKeyword(_BuiltInBase):
         matchers = {'GLOB': glob,
                     'EQUALS': lambda s, p: s == p,
                     'STARTS': lambda s, p: s.startswith(p),
-                    'REGEXP': lambda s, p: re.match(p + r'\Z', s) is not None}
+                    'REGEXP': lambda s, p: re.fullmatch(p, s) is not None}
         prefixes = tuple(prefix + ':' for prefix in matchers)
         if not expected_error.startswith(prefixes):
             return glob(error, expected_error)
@@ -2287,21 +2320,20 @@ class _RunKeyword(_BuiltInBase):
 
     def _keywords_repeated_by_count(self, count, name, args):
         if count <= 0:
-            self.log("Keyword '%s' repeated zero times." % name)
+            self.log(f"Keyword '{name}' repeated zero times.")
         for i in range(count):
-            self.log("Repeating keyword, round %d/%d." % (i + 1, count))
+            self.log(f"Repeating keyword, round {i+1}/{count}.")
             yield name, args
 
     def _keywords_repeated_by_timeout(self, timeout, name, args):
         if timeout <= 0:
-            self.log("Keyword '%s' repeated zero times." % name)
-        repeat_round = 0
+            self.log(f"Keyword '{name}' repeated zero times.")
+        round = 0
         maxtime = time.time() + timeout
         while time.time() < maxtime:
-            repeat_round += 1
-            self.log("Repeating keyword, round %d, %s remaining."
-                     % (repeat_round,
-                        secs_to_timestr(maxtime - time.time(), compact=True)))
+            round += 1
+            remaining = secs_to_timestr(maxtime - time.time(), compact=True)
+            self.log(f"Repeating keyword, round {round}, {remaining} remaining.")
             yield name, args
 
     @run_keyword_variant(resolve=2, dry_run=True)
@@ -2320,7 +2352,7 @@ class _RunKeyword(_BuiltInBase):
         ``5 times``, ``10 x``). ``retry_interval`` must always be given in
         Robot Framework's time format.
 
-        By default ``retry_interval`` is the time to wait _after_ a keyword has
+        By default, ``retry_interval`` is the time to wait _after_ a keyword has
         failed. For example, if the first run takes 2 seconds and the retry
         interval is 3 seconds, the second run starts 5 seconds after the first
         run started. If ``retry_interval`` start with prefix ``strict:``, the
@@ -2344,7 +2376,7 @@ class _RunKeyword(_BuiltInBase):
         Running the same keyword multiple times inside this keyword can create
         lots of output and considerably increase the size of the generated
         output files. It is possible to remove unnecessary keywords from
-        the outputs using ``--RemoveKeywords WUKS`` command line option.
+        the outputs using the ``--remove-keywords WUKS`` command line option.
 
         Support for "strict" retry interval is new in Robot Framework 4.1.
         """
@@ -2354,11 +2386,11 @@ class _RunKeyword(_BuiltInBase):
         except ValueError:
             timeout = timestr_to_secs(retry)
             maxtime = time.time() + timeout
-            message = 'for %s' % secs_to_timestr(timeout)
+            message = f'for {secs_to_timestr(timeout)}'
         else:
             if count <= 0:
-                raise ValueError('Retry count %d is not positive.' % count)
-            message = '%d time%s' % (count, s(count))
+                raise ValueError(f'Retry count {count} is not positive.')
+            message = f'{count} time{s(count)}'
         if is_string(retry_interval) and normalize(retry_interval).startswith('strict:'):
             retry_interval = retry_interval.split(':', 1)[1].strip()
             strict_interval = True
@@ -2374,16 +2406,19 @@ class _RunKeyword(_BuiltInBase):
                     raise
                 count -= 1
                 if time.time() > maxtime > 0 or count == 0:
-                    raise AssertionError("Keyword '%s' failed after retrying %s. "
-                                         "The last error was: %s" % (name, message, err))
+                    name = self._variables.replace_scalar(name)
+                    raise AssertionError(f"Keyword '{name}' failed after retrying "
+                                         f"{message}. The last error was: {err}")
             finally:
                 if strict_interval:
-                    keyword_runtime = time.time() - start_time
-                    sleep_time = retry_interval - keyword_runtime
+                    execution_time = time.time() - start_time
+                    sleep_time = retry_interval - execution_time
                     if sleep_time < 0:
-                        logger.warn("Keyword execution time %s is longer than retry "
-                                    "interval %s." % (secs_to_timestr(keyword_runtime),
-                                                      secs_to_timestr(retry_interval)))
+                        logger.warn(
+                            f"Keyword execution time {secs_to_timestr(execution_time)} "
+                            f"is longer than retry interval "
+                            f"{secs_to_timestr(retry_interval)}."
+                        )
             self._sleep_in_parts(sleep_time)
 
     @run_keyword_variant(resolve=1)
@@ -2426,19 +2461,21 @@ class _RunKeyword(_BuiltInBase):
         Use `Get Variable Value` if you need to set variables
         dynamically based on whether a variable exist or not.
         """
-        values = self._verify_values_for_set_variable_if(list(values))
-        if self._is_true(condition):
-            return self._variables.replace_scalar(values[0])
-        values = self._verify_values_for_set_variable_if(values[1:], True)
-        if len(values) == 1:
-            return self._variables.replace_scalar(values[0])
-        return self.run_keyword('BuiltIn.Set Variable If', *values[0:])
-
-    def _verify_values_for_set_variable_if(self, values, default=False):
+        values = list(values)
+        while True:
+            values = self._verify_values_for_set_variable_if(values)
+            if self._is_true(condition):
+                return self._variables.replace_scalar(values[0])
+            if len(values) == 1:
+                return None
+            if len(values) == 2:
+                return self._variables.replace_scalar(values[1])
+            condition, *values = values[1:]
+            condition = self._variables.replace_scalar(condition)
+
+    def _verify_values_for_set_variable_if(self, values):
         if not values:
-            if default:
-                return [None]
-            raise RuntimeError('At least one value is required')
+            raise RuntimeError('At least one value is required.')
         if is_list_variable(values[0]):
             values[:1] = [escape(item) for item in self._variables[values[0]]]
             return self._verify_values_for_set_variable_if(values)
@@ -2520,10 +2557,9 @@ class _RunKeyword(_BuiltInBase):
         if suite.statistics.failed > 0:
             return self.run_keyword(name, *args)
 
-    def _get_suite_in_teardown(self, kwname):
+    def _get_suite_in_teardown(self, kw):
         if not self._context.in_suite_teardown:
-            raise RuntimeError("Keyword '%s' can only be used in suite teardown."
-                               % kwname)
+            raise RuntimeError(f"Keyword '{kw}' can only be used in suite teardown.")
         return self._context.suite
 
 
@@ -2872,7 +2908,7 @@ class _Control(_BuiltInBase):
         Passing execution in the middle of a test, setup or teardown should be
         used with care. In the worst case it leads to tests that skip all the
         parts that could actually uncover problems in the tested application.
-        In cases where execution cannot continue do to external factors,
+        In cases where execution cannot continue due to external factors,
         it is often safer to fail the test case and make it non-critical.
         """
         message = message.strip()
@@ -2880,7 +2916,7 @@ class _Control(_BuiltInBase):
             raise RuntimeError('Message cannot be empty.')
         self._set_and_remove_tags(tags)
         log_message, level = self._get_logged_test_message_and_level(message)
-        self.log('Execution passed with message:\n%s' % log_message, level)
+        self.log(f'Execution passed with message:\n{log_message}', level)
         raise PassExecution(message)
 
     @run_keyword_variant(resolve=1)
@@ -2931,7 +2967,7 @@ class _Misc(_BuiltInBase):
         if seconds < 0:
             seconds = 0
         self._sleep_in_parts(seconds)
-        self.log('Slept %s' % secs_to_timestr(seconds))
+        self.log(f'Slept {secs_to_timestr(seconds)}.')
         if reason:
             self.log(reason)
 
@@ -3050,8 +3086,8 @@ class _Misc(_BuiltInBase):
                     'len': len,
                     'type': lambda x: type(x).__name__}[formatter.lower()]
         except KeyError:
-            raise ValueError("Invalid formatter '%s'. Available "
-                             "'str', 'repr', 'ascii', 'len', and 'type'." % formatter)
+            raise ValueError(f"Invalid formatter '{formatter}'. Available "
+                             f"'str', 'repr', 'ascii', 'len', and 'type'.")
 
     @run_keyword_variant(resolve=0)
     def log_many(self, *messages):
@@ -3078,7 +3114,7 @@ class _Misc(_BuiltInBase):
                     yield item
             elif match.is_dict_variable():
                 for name, value in value.items():
-                    yield '%s=%s' % (name, value)
+                    yield f'{name}={value}'
             else:
                 yield value
 
@@ -3128,23 +3164,34 @@ class _Misc(_BuiltInBase):
         pass
 
     def set_log_level(self, level):
-        """Sets the log threshold to the specified level and returns the old level.
+        """Sets the log threshold to the specified level.
 
         Messages below the level will not logged. The default logging level is
-        INFO, but it can be overridden with the command line option
-        ``--loglevel``.
+        INFO, but it can be overridden with the ``--loglevel`` command line option.
+        The available levels are TRACE, DEBUG, INFO (default), WARN, ERROR and NONE
+        (no logging).
 
-        The available levels: TRACE, DEBUG, INFO (default), WARN, ERROR and NONE (no
-        logging).
+        The old level is returned and can be used for setting the level back
+        later. An alternative way to reset the level is using the dedicated
+        `Reset Log Level` keyword.
         """
-        try:
-            old = self._context.output.set_log_level(level)
-        except DataError as err:
-            raise RuntimeError(str(err))
+        old = self._context.output.set_log_level(level)
         self._namespace.variables.set_global('${LOG_LEVEL}', level.upper())
-        self.log('Log level changed from %s to %s.' % (old, level.upper()))
+        self.log(f'Log level changed from {old} to {level.upper()}.', level='DEBUG')
         return old
 
+    def reset_log_level(self):
+        """Resets the log level to the original value.
+
+        The original log level is set from the command line with the ``--loglevel``
+        option and is INFO by default. The active log level can be changed using
+        the `Set Log Level` keyword.
+
+        New in Robot Framework 7.0.
+        """
+        level = self._context.output.initial_log_level
+        return self.set_log_level(level)
+
     def reload_library(self, name_or_instance):
         """Rechecks what keywords the specified library provides.
 
@@ -3155,9 +3202,8 @@ class _Misc(_BuiltInBase):
         the library. The latter is especially useful if the library itself
         calls this keyword as a method.
         """
-        library = self._namespace.reload_library(name_or_instance)
-        self.log('Reloaded library %s with %s keywords.' % (library.name,
-                                                            len(library)))
+        lib = self._namespace.reload_library(name_or_instance)
+        self.log(f'Reloaded library {lib.name} with {len(lib.keywords)} keywords.')
 
     @run_keyword_variant(resolve=0)
     def import_library(self, name, *args):
@@ -3297,11 +3343,11 @@ class _Misc(_BuiltInBase):
         See also `Variable Should Exist`.
         """
         try:
-            runner = self._namespace.get_runner(name, recommend_on_failure=False)
-        except DataError as error:
-            raise AssertionError(msg or error.message)
-        if isinstance(runner, UserErrorHandler):
-            raise AssertionError(msg or runner.error.message)
+            kw = self._namespace.get_runner(name, recommend_on_failure=False).keyword
+            if kw.error:
+                raise DataError(kw.error)
+        except DataError as err:
+            raise AssertionError(msg or err.message)
 
     def get_time(self, format='timestamp', time_='NOW'):
         """Returns the given time in the requested format.
@@ -3523,7 +3569,7 @@ class _Misc(_BuiltInBase):
         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('Set test message to:\n%s' % message, level)
+        self.log(f'Set test message to:\n{message}', level)
 
     def _get_new_text(self, old, new, append, handle_html=False):
         if not is_string(new):
@@ -3534,10 +3580,10 @@ class _Misc(_BuiltInBase):
             if new.startswith('*HTML*'):
                 new = new[6:].lstrip()
                 if not old.startswith('*HTML*'):
-                    old = '*HTML* %s' % html_escape(old)
+                    old = f'*HTML* {html_escape(old)}'
             elif old.startswith('*HTML*'):
                 new = html_escape(new)
-        return '%s %s' % (old, new)
+        return f'{old} {new}'
 
     def _get_logged_test_message_and_level(self, message):
         if message.startswith('*HTML*'):
@@ -3561,12 +3607,12 @@ class _Misc(_BuiltInBase):
                                "used in suite setup or teardown.")
         test.doc = self._get_new_text(test.doc, doc, append)
         self._variables.set_test('${TEST_DOCUMENTATION}', test.doc)
-        self.log('Set test documentation to:\n%s' % test.doc)
+        self.log(f'Set test documentation to:\n{test.doc}')
 
     def set_suite_documentation(self, doc, append=False, top=False):
         """Sets documentation for the current test suite.
 
-        By default the possible existing documentation is overwritten, but
+        By default, the possible existing documentation is overwritten, but
         this can be changed using the optional ``append`` argument similarly
         as with `Set Test Message` keyword.
 
@@ -3581,12 +3627,12 @@ class _Misc(_BuiltInBase):
         suite = self._get_context(top).suite
         suite.doc = self._get_new_text(suite.doc, doc, append)
         self._variables.set_suite('${SUITE_DOCUMENTATION}', suite.doc, top)
-        self.log('Set suite documentation to:\n%s' % suite.doc)
+        self.log(f'Set suite documentation to:\n{suite.doc}')
 
     def set_suite_metadata(self, name, value, append=False, top=False):
         """Sets metadata for the current test suite.
 
-        By default possible existing metadata values are overwritten, but
+        By default, possible existing metadata values are overwritten, but
         this can be changed using the optional ``append`` argument similarly
         as with `Set Test Message` keyword.
 
@@ -3604,7 +3650,7 @@ class _Misc(_BuiltInBase):
         original = metadata.get(name, '')
         metadata[name] = self._get_new_text(original, value, append)
         self._variables.set_suite('${SUITE_METADATA}', metadata.copy(), top)
-        self.log("Set suite metadata '%s' to value '%s'." % (name, metadata[name]))
+        self.log(f"Set suite metadata '{name}' to value '{metadata[name]}'.")
 
     def set_tags(self, *tags):
         """Adds given ``tags`` for the current test or all tests in a suite.
@@ -3629,7 +3675,7 @@ class _Misc(_BuiltInBase):
             ctx.suite.set_tags(tags, persist=True)
         else:
             raise RuntimeError("'Set Tags' cannot be used in suite teardown.")
-        self.log('Set tag%s %s.' % (s(tags), seq2str(tags)))
+        self.log(f'Set tag{s(tags)} {seq2str((tags))}.')
 
     def remove_tags(self, *tags):
         """Removes given ``tags`` from the current test or all tests in a suite.
@@ -3657,7 +3703,7 @@ class _Misc(_BuiltInBase):
             ctx.suite.set_tags(remove=tags, persist=True)
         else:
             raise RuntimeError("'Remove Tags' cannot be used in suite teardown.")
-        self.log('Removed tag%s %s.' % (s(tags), seq2str(tags)))
+        self.log(f'Removed tag{s(tags)} {seq2str((tags))}.')
 
     def get_library_instance(self, name=None, all=False):
         """Returns the currently active instance of the specified library.
@@ -3672,8 +3718,7 @@ class _Misc(_BuiltInBase):
         |     seleniumlib = BuiltIn().get_library_instance('SeleniumLibrary')
         |     title = seleniumlib.get_title()
         |     if not title.startswith(expected):
-        |         raise AssertionError("Title '%s' did not start with '%s'"
-        |                              % (title, expected))
+        |         raise AssertionError(f"Title '{title}' did not start with '{expected}'.")
 
         It is also possible to use this keyword in the test data and
         pass the returned library instance to another keyword. If a
@@ -3716,40 +3761,6 @@ class BuiltIn(_Verify, _Converter, _Variables, _RunKeyword, _Control, _Misc):
     HTML in messages is not limited to BuiltIn library but works with any
     error message.
 
-    = Using variables with keywords creating or accessing variables =
-
-    This library has special keywords `Set Global Variable`, `Set Suite Variable`,
-    `Set Test Variable` and `Set Local Variable` for creating variables in
-    different scopes. These keywords take the variable name and its value as
-    arguments. The name can be given using the normal ``${variable}`` syntax or
-    in escaped format either like ``$variable`` or ``\${variable}``. For example,
-    these are typically equivalent and create new suite level variable
-    ``${name}`` with value ``value``:
-
-    | Set Suite Variable    ${name}     value
-    | Set Suite Variable    $name       value
-    | Set Suite Variable    \${name}    value
-
-    A problem with using the normal ``${variable}`` syntax is that these
-    keywords cannot easily know is the idea to create a variable with exactly
-    that name or does that variable actually contain the name of the variable
-    to create. If the variable does not initially exist, it will always be
-    created. If it exists and its value is a variable name either in the normal
-    or in the escaped syntax, variable with _that_ name is created instead.
-    For example, if ``${name}`` variable would exist and contain value
-    ``$example``, these examples would create different variables:
-
-    | Set Suite Variable    ${name}     value    # Creates ${example}.
-    | Set Suite Variable    $name       value    # Creates ${name}.
-    | Set Suite Variable    \${name}    value    # Creates ${name}.
-
-    Because the behavior when using the normal ``${variable}`` syntax depends
-    on the possible existing value of the variable, it is *highly recommended
-    to use the escaped ``$variable`` or ``\${variable}`` format instead*.
-
-    This same problem occurs also with special keywords for accessing variables
-    `Get Variable Value`, `Variable Should Exist` and `Variable Should Not Exist`.
-
     = Evaluating expressions =
 
     Many keywords, such as `Evaluate`, `Run Keyword If` and `Should Be True`,
@@ -3814,6 +3825,45 @@ class BuiltIn(_Verify, _Converter, _Variables, _RunKeyword, _Control, _Misc):
     to move the logic into a library. That eases maintenance and can also
     enhance execution speed.
 
+    = Using variables with keywords creating or accessing variables =
+
+    This library has special keywords `Set Global Variable`, `Set Suite Variable`,
+    `Set Test Variable` and `Set Local Variable` for creating variables in
+    different scopes. These keywords take the variable name and its value as
+    arguments. The name can be given using the normal ``${variable}`` syntax or
+    in escaped format either like ``$variable`` or ``\${variable}``. For example,
+    these are typically equivalent and create new suite level variable
+    ``${name}`` with value ``value``:
+
+    | Set Suite Variable    ${name}     value
+    | Set Suite Variable    $name       value
+    | Set Suite Variable    \${name}    value
+
+    A problem with using the normal ``${variable}`` syntax is that these
+    keywords cannot easily know is the idea to create a variable with exactly
+    that name or does that variable actually contain the name of the variable
+    to create. If the variable does not initially exist, it will always be
+    created. If it exists and its value is a variable name either in the normal
+    or in the escaped syntax, variable with _that_ name is created instead.
+    For example, if ``${name}`` variable would exist and contain value
+    ``$example``, these examples would create different variables:
+
+    | Set Suite Variable    ${name}     value    # Creates ${example}.
+    | Set Suite Variable    $name       value    # Creates ${name}.
+    | Set Suite Variable    \${name}    value    # Creates ${name}.
+
+    Because the behavior when using the normal ``${variable}`` syntax depends
+    on the possible existing value of the variable, it is *highly recommended
+    to use the escaped ``$variable`` or ``\${variable}`` format instead*.
+
+    This same problem occurs also with special keywords for accessing variables
+    `Get Variable Value`, `Variable Should Exist` and `Variable Should Not Exist`.
+
+    *NOTE:* It is recommended to use the ``VAR`` syntax introduced in Robot
+    Framework 7.0 for creating variables in different scopes instead of the
+    `Set Global/Suite/Test/Local Variable` keywords. It makes creating variables
+    uniform and avoids all the problems discussed above.
+
     = Boolean arguments =
 
     Some keywords accept arguments that are handled as Boolean values true or