BuiltIn.py

Go to the documentation of this file.

#  Copyright 2008-2015 Nokia Networks
#  Copyright 2016-     Robot Framework Foundation
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
 
from collections import OrderedDict
import difflib
import re
import time
 
from robot.api import logger, SkipExecution
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.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,
                         normalize_whitespace, parse_re_flags, parse_time, prepr,
                         plural_or_not as s, RERAISED_EXCEPTIONS, safe_str,
                         secs_to_timestr, seq2str, split_from_equals,
                         timestr_to_secs, type_name)
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)
from robot.version import get_version
 
 
# FIXME: Clean-up registering run keyword variants!
# https://github.com/robotframework/robotframework/issues/2190
 
def run_keyword_variant(resolve, dry_run=False):
    def decorator(method):
        RUN_KW_REGISTER.register_run_keyword('BuiltIn', method.__name__,
                                             resolve, deprecation_warning=False,
                                             dry_run=dry_run)
        return method
    return decorator
 
 
class _BuiltInBase:
 
    @property
    _context = property
    
    def _context(self):
        return self._get_context_get_context()
 
    def _get_context(self, top=False):
        ctx = EXECUTION_CONTEXTS.current if not top else EXECUTION_CONTEXTS.top
        if ctx is None:
            raise RobotNotRunningError('Cannot access execution context')
        return ctx
 
    @property
    _namespace = property
    
    def _namespace(self):
        return self._get_context_get_context().namespace
 
    @property
    _variables = property
    
    def _variables(self):
        return self._namespace_namespace_namespace.variables
 
    def _matches(self, string, pattern, caseless=False):
        # Must use this instead of fnmatch when string may contain newlines.
        matcher = Matcher(pattern, caseless=caseless, spaceless=False)
        return matcher.match(string)
 
    def _is_true(self, condition):
        if is_string(condition):
            condition = self.evaluate(condition)
        return bool(condition)
 
    def _log_types(self, *args):
        self._log_types_at_level_log_types_at_level('DEBUG', *args)
 
    def _log_types_at_level(self, level, *args):
        msg = ["Argument types are:"] + [self._get_type_get_type(a) for a in args]
        self.log('\n'.join(msg), level)
 
    def _get_type(self, arg):
        return str(type(arg))
 
 
class _Converter(_BuiltInBase):
 
    
    def convert_to_integer(self, item, base=None):
        self._log_types_log_types(item)
        return self._convert_to_integer_convert_to_integer(item, base)
 
    def _convert_to_integer(self, orig, base=None):
        try:
            item, base = self._get_base_get_base(orig, base)
            if base:
                return int(item, self._convert_to_integer_convert_to_integer(base))
            return int(item)
        except:
            raise RuntimeError("'%s' cannot be converted to an integer: %s"
                               % (orig, get_error_message()))
 
    def _get_base(self, item, base):
        if not is_string(item):
            return item, base
        item = normalize(item)
        if item.startswith(('-', '+')):
            sign = item[0]
            item = item[1:]
        else:
            sign = ''
        bases = {'0b': 2, '0o': 8, '0x': 16}
        if base or not item.startswith(tuple(bases)):
            return sign+item, base
        return sign+item[2:], bases[item[:2]]
 
    
    def convert_to_binary(self, item, base=None, prefix=None, length=None):
        return self._convert_to_bin_oct_hex_convert_to_bin_oct_hex(item, base, prefix, length, 'b')
 
    
    def convert_to_octal(self, item, base=None, prefix=None, length=None):
        return self._convert_to_bin_oct_hex_convert_to_bin_oct_hex(item, base, prefix, length, 'o')
 
    
    def convert_to_hex(self, item, base=None, prefix=None, length=None,
                       lowercase=False):
        spec = 'x' if lowercase else 'X'
        return self._convert_to_bin_oct_hex_convert_to_bin_oct_hex(item, base, prefix, length, spec)
 
    def _convert_to_bin_oct_hex(self, item, base, prefix, length, format_spec):
        self._log_types_log_types(item)
        ret = format(self._convert_to_integer_convert_to_integer(item, base), format_spec)
        prefix = prefix or ''
        if ret[0] == '-':
            prefix = '-' + prefix
            ret = ret[1:]
        if length:
            ret = ret.rjust(self._convert_to_integer_convert_to_integer(length), '0')
        return prefix + ret
 
    
    def convert_to_number(self, item, precision=None):
        self._log_types_log_types(item)
        return self._convert_to_number_convert_to_number(item, precision)
 
    def _convert_to_number(self, item, precision=None):
        number = self._convert_to_number_without_precision_convert_to_number_without_precision(item)
        if precision is not None:
            number = float(round(number, self._convert_to_integer_convert_to_integer(precision)))
        return number
 
    def _convert_to_number_without_precision(self, item):
        try:
            return float(item)
        except:
            error = get_error_message()
            try:
                return float(self._convert_to_integer_convert_to_integer(item))
            except RuntimeError:
                raise RuntimeError("'%s' cannot be converted to a floating "
                                   "point number: %s" % (item, error))
 
    
    def convert_to_string(self, item):
        self._log_types_log_types(item)
        return safe_str(item)
 
    
    def convert_to_boolean(self, item):
        self._log_types_log_types(item)
        if is_string(item):
            if item.upper() == 'TRUE':
                return True
            if item.upper() == 'FALSE':
                return False
        return bool(item)
 
    
    def convert_to_bytes(self, input, input_type='text'):
        try:
            try:
                ordinals = getattr(self, '_get_ordinals_from_%s' % input_type)
            except AttributeError:
                raise RuntimeError("Invalid input type '%s'." % input_type)
            return bytes(bytearray(o for o in ordinals(input)))
        except:
            raise RuntimeError("Creating bytes failed: %s" % get_error_message())
 
    def _get_ordinals_from_text(self, input):
        for char in input:
            ordinal = char if is_integer(char) else ord(char)
            yield self._test_ordinal_test_ordinal(ordinal, char, 'Character')
 
    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))
 
    def _get_ordinals_from_int(self, input):
        if is_string(input):
            input = input.split()
        elif is_integer(input):
            input = [input]
        for integer in input:
            ordinal = self._convert_to_integer_convert_to_integer(integer)
            yield self._test_ordinal_test_ordinal(ordinal, integer, 'Integer')
 
    def _get_ordinals_from_hex(self, input):
        for token in self._input_to_tokens_input_to_tokens(input, length=2):
            ordinal = self._convert_to_integer_convert_to_integer(token, base=16)
            yield self._test_ordinal_test_ordinal(ordinal, token, 'Hex value')
 
    def _get_ordinals_from_bin(self, input):
        for token in self._input_to_tokens_input_to_tokens(input, length=8):
            ordinal = self._convert_to_integer_convert_to_integer(token, base=2)
            yield self._test_ordinal_test_ordinal(ordinal, token, 'Binary value')
 
    def _input_to_tokens(self, input, length):
        if not is_string(input):
            return input
        input = ''.join(input.split())
        if len(input) % length != 0:
            raise RuntimeError('Expected input to be multiple of %d.' % length)
        return (input[i:i+length] for i in range(0, len(input), length))
 
    
    def create_list(self, *items):
        return list(items)
 
    @run_keyword_variant(resolve=0)
    
    def create_dictionary(self, *items):
        separate, combined = self._split_dict_items_split_dict_items(items)
        result = DotDict(self._format_separate_dict_items_format_separate_dict_items(separate))
        combined = DictVariableTableValue(combined).resolve(self._variables_variables_variables)
        result.update(combined)
        return result
 
    def _split_dict_items(self, items):
        separate = []
        for item in items:
            name, value = split_from_equals(item)
            if value is not None or is_dict_variable(item):
                break
            separate.append(item)
        return separate, items[len(separate):]
 
    def _format_separate_dict_items(self, separate):
        separate = self._variables_variables_variables.replace_list(separate)
        if len(separate) % 2 != 0:
            raise DataError('Expected even number of keys and values, got %d.'
                            % len(separate))
        return [separate[i:i+2] for i in range(0, len(separate), 2)]
 
 
class _Verify(_BuiltInBase):
 
    def _set_and_remove_tags(self, tags):
        set_tags = [tag for tag in tags if not tag.startswith('-')]
        remove_tags = [tag[1:] for tag in tags if tag.startswith('-')]
        if remove_tags:
            self.remove_tags(*remove_tags)
        if set_tags:
            self.set_tags(*set_tags)
 
    
    def fail(self, msg=None, *tags):
        self._set_and_remove_tags_set_and_remove_tags(tags)
        raise AssertionError(msg) if msg else AssertionError()
 
    
    def fatal_error(self, msg=None):
        error = AssertionError(msg) if msg else AssertionError()
        error.ROBOT_EXIT_ON_FAILURE = True
        raise error
 
    
    def should_not_be_true(self, condition, msg=None):
        if self._is_true_is_true(condition):
            raise AssertionError(msg or "'%s' should not be true." % condition)
 
    
    def should_be_true(self, condition, msg=None):
        if not self._is_true_is_true(condition):
            raise AssertionError(msg or "'%s' should be true." % condition)
 
    
    def should_be_equal(self, first, second, msg=None, values=True,
                        ignore_case=False, formatter='str', strip_spaces=False,
                        collapse_spaces=False):
        self._log_types_at_info_if_different_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()
            if strip_spaces:
                first = self._strip_spaces_strip_spaces(first, strip_spaces)
                second = self._strip_spaces_strip_spaces(second, strip_spaces)
            if collapse_spaces:
                first = self._collapse_spaces_collapse_spaces(first)
                second = self._collapse_spaces_collapse_spaces(second)
        self._should_be_equal_should_be_equal(first, second, msg, values, formatter)
 
    def _should_be_equal(self, first, second, msg, values, formatter='str'):
        include_values = self._include_values_include_values(values)
        formatter = self._get_formatter(formatter)
        if first == second:
            return
        if include_values and is_string(first) and is_string(second):
            self._raise_multi_diff_raise_multi_diff(first, second, msg, formatter)
        assert_equal(first, second, msg, include_values, formatter)
 
    def _log_types_at_info_if_different(self, first, second):
        level = 'DEBUG' if type(first) == type(second) else 'INFO'
        self._log_types_at_level_log_types_at_level(level, first, second)
 
    def _raise_multi_diff(self, first, second, msg, formatter):
        first_lines = first.splitlines(True)      # keepends
        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()))
        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)
        raise AssertionError('\n'.join([prefix] + diffs))
 
    def _include_values(self, values):
        return is_truthy(values) and str(values).upper() != 'NO VALUES'
 
    def _strip_spaces(self, value, strip_spaces):
        if not is_string(value):
            return value
        if not is_string(strip_spaces):
            return value.strip() if strip_spaces else value
        if strip_spaces.upper() == 'LEADING':
            return value.lstrip()
        if strip_spaces.upper() == 'TRAILING':
            return value.rstrip()
        return value.strip() if is_truthy(strip_spaces) else value
 
    def _collapse_spaces(self, value):
        return re.sub(r'\s+', ' ', value) if is_string(value) else value
 
    
    def should_not_be_equal(self, first, second, msg=None, values=True,
                            ignore_case=False, strip_spaces=False,
                            collapse_spaces=False):
        self._log_types_at_info_if_different_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()
            if strip_spaces:
                first = self._strip_spaces_strip_spaces(first, strip_spaces)
                second = self._strip_spaces_strip_spaces(second, strip_spaces)
            if collapse_spaces:
                first = self._collapse_spaces_collapse_spaces(first)
                second = self._collapse_spaces_collapse_spaces(second)
        self._should_not_be_equal_should_not_be_equal(first, second, msg, values)
 
    def _should_not_be_equal(self, first, second, msg, values):
        assert_not_equal(first, second, msg, self._include_values_include_values(values))
 
    
    def should_not_be_equal_as_integers(self, first, second, msg=None,
                                        values=True, base=None):
        self._log_types_at_info_if_different_log_types_at_info_if_different(first, second)
        self._should_not_be_equal_should_not_be_equal(self._convert_to_integer(first, base),
                                  self._convert_to_integer(second, base),
                                  msg, values)
 
    
    def should_be_equal_as_integers(self, first, second, msg=None, values=True,
                                    base=None):
        self._log_types_at_info_if_different_log_types_at_info_if_different(first, second)
        self._should_be_equal_should_be_equal(self._convert_to_integer(first, base),
                              self._convert_to_integer(second, base),
                              msg, values)
 
    
    def should_not_be_equal_as_numbers(self, first, second, msg=None,
                                       values=True, precision=6):
        self._log_types_at_info_if_different_log_types_at_info_if_different(first, second)
        first = self._convert_to_number(first, precision)
        second = self._convert_to_number(second, precision)
        self._should_not_be_equal_should_not_be_equal(first, second, msg, values)
 
    
    def should_be_equal_as_numbers(self, first, second, msg=None, values=True,
                                   precision=6):
        self._log_types_at_info_if_different_log_types_at_info_if_different(first, second)
        first = self._convert_to_number(first, precision)
        second = self._convert_to_number(second, precision)
        self._should_be_equal_should_be_equal(first, second, msg, values)
 
    
    def should_not_be_equal_as_strings(self, first, second, msg=None, values=True,
                                       ignore_case=False, strip_spaces=False,
                                       collapse_spaces=False):
        self._log_types_at_info_if_different_log_types_at_info_if_different(first, second)
        first = safe_str(first)
        second = safe_str(second)
        if ignore_case:
            first = first.lower()
            second = second.lower()
        if strip_spaces:
            first = self._strip_spaces_strip_spaces(first, strip_spaces)
            second = self._strip_spaces_strip_spaces(second, strip_spaces)
        if collapse_spaces:
            first = self._collapse_spaces_collapse_spaces(first)
            second = self._collapse_spaces_collapse_spaces(second)
        self._should_not_be_equal_should_not_be_equal(first, second, msg, values)
 
    
    def should_be_equal_as_strings(self, first, second, msg=None, values=True,
                                   ignore_case=False, strip_spaces=False,
                                   formatter='str', collapse_spaces=False):
        self._log_types_at_info_if_different_log_types_at_info_if_different(first, second)
        first = safe_str(first)
        second = safe_str(second)
        if ignore_case:
            first = first.lower()
            second = second.lower()
        if strip_spaces:
            first = self._strip_spaces_strip_spaces(first, strip_spaces)
            second = self._strip_spaces_strip_spaces(second, strip_spaces)
        if collapse_spaces:
            first = self._collapse_spaces_collapse_spaces(first)
            second = self._collapse_spaces_collapse_spaces(second)
        self._should_be_equal_should_be_equal(first, second, msg, values, formatter)
 
    
    def should_not_start_with(self, str1, str2, msg=None, values=True,
                              ignore_case=False, strip_spaces=False,
                              collapse_spaces=False):
        if ignore_case:
            str1 = str1.lower()
            str2 = str2.lower()
        if strip_spaces:
            str1 = self._strip_spaces_strip_spaces(str1, strip_spaces)
            str2 = self._strip_spaces_strip_spaces(str2, strip_spaces)
        if collapse_spaces:
            str1 = self._collapse_spaces_collapse_spaces(str1)
            str2 = self._collapse_spaces_collapse_spaces(str2)
        if str1.startswith(str2):
            raise AssertionError(self._get_string_msg_get_string_msg(str1, str2, msg, values,
                                                      'starts with'))
 
    
    def should_start_with(self, str1, str2, msg=None, values=True,
                          ignore_case=False, strip_spaces=False, collapse_spaces=False):
        if ignore_case:
            str1 = str1.lower()
            str2 = str2.lower()
        if strip_spaces:
            str1 = self._strip_spaces_strip_spaces(str1, strip_spaces)
            str2 = self._strip_spaces_strip_spaces(str2, strip_spaces)
        if collapse_spaces:
            str1 = self._collapse_spaces_collapse_spaces(str1)
            str2 = self._collapse_spaces_collapse_spaces(str2)
        if not str1.startswith(str2):
            raise AssertionError(self._get_string_msg_get_string_msg(str1, str2, msg, values,
                                                      'does not start with'))
 
    
    def should_not_end_with(self, str1, str2, msg=None, values=True,
                            ignore_case=False, strip_spaces=False,
                            collapse_spaces=False):
        if ignore_case:
            str1 = str1.lower()
            str2 = str2.lower()
        if strip_spaces:
            str1 = self._strip_spaces_strip_spaces(str1, strip_spaces)
            str2 = self._strip_spaces_strip_spaces(str2, strip_spaces)
        if collapse_spaces:
            str1 = self._collapse_spaces_collapse_spaces(str1)
            str2 = self._collapse_spaces_collapse_spaces(str2)
        if str1.endswith(str2):
            raise AssertionError(self._get_string_msg_get_string_msg(str1, str2, msg, values,
                                                      'ends with'))
 
    
    def should_end_with(self, str1, str2, msg=None, values=True,
                        ignore_case=False, strip_spaces=False, collapse_spaces=False):
        if ignore_case:
            str1 = str1.lower()
            str2 = str2.lower()
        if strip_spaces:
            str1 = self._strip_spaces_strip_spaces(str1, strip_spaces)
            str2 = self._strip_spaces_strip_spaces(str2, strip_spaces)
        if collapse_spaces:
            str1 = self._collapse_spaces_collapse_spaces(str1)
            str2 = self._collapse_spaces_collapse_spaces(str2)
        if not str1.endswith(str2):
            raise AssertionError(self._get_string_msg_get_string_msg(str1, str2, msg, values,
                                                      'does not end with'))
 
    
    def should_not_contain(self, container, item, msg=None, values=True,
                           ignore_case=False, strip_spaces=False,
                           collapse_spaces=False):
        # TODO: It is inconsistent that errors show original case in 'container'
        # 'item' is in lower case. Should rather show original case everywhere
        # and add separate '(case-insensitive)' not to the error message.
        # This same logic should be used with all keywords supporting
        # case-insensitive comparisons.
        orig_container = container
        if ignore_case and is_string(item):
            item = item.lower()
            if is_string(container):
                container = container.lower()
            elif is_list_like(container):
                container = set(x.lower() if is_string(x) else x for x in container)
        if strip_spaces and is_string(item):
            item = self._strip_spaces_strip_spaces(item, strip_spaces)
            if is_string(container):
                container = self._strip_spaces_strip_spaces(container, strip_spaces)
            elif is_list_like(container):
                container = set(self._strip_spaces_strip_spaces(x, strip_spaces) for x in container)
        if collapse_spaces and is_string(item):
            item = self._collapse_spaces_collapse_spaces(item)
            if is_string(container):
                container = self._collapse_spaces_collapse_spaces(container)
            elif is_list_like(container):
                container = set(self._collapse_spaces_collapse_spaces(x) for x in container)
        if item in container:
            raise AssertionError(self._get_string_msg_get_string_msg(orig_container, item, msg,
                                                      values, 'contains'))
 
    
    def should_contain(self, container, item, msg=None, values=True,
                       ignore_case=False, strip_spaces=False, collapse_spaces=False):
        orig_container = container
        if ignore_case and is_string(item):
            item = item.lower()
            if is_string(container):
                container = container.lower()
            elif is_list_like(container):
                container = set(x.lower() if is_string(x) else x for x in container)
        if strip_spaces and is_string(item):
            item = self._strip_spaces_strip_spaces(item, strip_spaces)
            if is_string(container):
                container = self._strip_spaces_strip_spaces(container, strip_spaces)
            elif is_list_like(container):
                container = set(self._strip_spaces_strip_spaces(x, strip_spaces) for x in container)
        if collapse_spaces and is_string(item):
            item = self._collapse_spaces_collapse_spaces(item)
            if is_string(container):
                container = self._collapse_spaces_collapse_spaces(container)
            elif is_list_like(container):
                container = set(self._collapse_spaces_collapse_spaces(x) for x in container)
        if item not in container:
            raise AssertionError(self._get_string_msg_get_string_msg(orig_container, item, msg,
                                                      values, 'does not contain'))
 
    
    def should_contain_any(self, container, *items, **configuration):
        msg = configuration.pop('msg', None)
        values = configuration.pop('values', True)
        ignore_case = is_truthy(configuration.pop('ignore_case', False))
        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))))
        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]
            if is_string(container):
                container = container.lower()
            elif is_list_like(container):
                container = set(x.lower() if is_string(x) else x for x in container)
        if strip_spaces:
            items = [self._strip_spaces_strip_spaces(x, strip_spaces) for x in items]
            if is_string(container):
                container = self._strip_spaces_strip_spaces(container, strip_spaces)
            elif is_list_like(container):
                container = set(self._strip_spaces_strip_spaces(x, strip_spaces) for x in container)
        if collapse_spaces:
            items = [self._collapse_spaces_collapse_spaces(x) for x in items]
            if is_string(container):
                container = self._collapse_spaces_collapse_spaces(container)
            elif is_list_like(container):
                container = set(self._collapse_spaces_collapse_spaces(x) for x in container)
        if not any(item in container for item in items):
            msg = self._get_string_msg_get_string_msg(orig_container,
                                       seq2str(items, lastsep=' or '),
                                       msg, values,
                                       'does not contain any of',
                                       quote_item2=False)
            raise AssertionError(msg)
 
    
    def should_not_contain_any(self, container, *items, **configuration):
        msg = configuration.pop('msg', None)
        values = configuration.pop('values', True)
        ignore_case = is_truthy(configuration.pop('ignore_case', False))
        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))))
        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]
            if is_string(container):
                container = container.lower()
            elif is_list_like(container):
                container = set(x.lower() if is_string(x) else x for x in container)
        if strip_spaces:
            items = [self._strip_spaces_strip_spaces(x, strip_spaces) for x in items]
            if is_string(container):
                container = self._strip_spaces_strip_spaces(container, strip_spaces)
            elif is_list_like(container):
                container = set(self._strip_spaces_strip_spaces(x, strip_spaces) for x in container)
        if collapse_spaces:
            items = [self._collapse_spaces_collapse_spaces(x) for x in items]
            if is_string(container):
                container = self._collapse_spaces_collapse_spaces(container)
            elif is_list_like(container):
                container = set(self._collapse_spaces_collapse_spaces(x) for x in container)
        if any(item in container for item in items):
            msg = self._get_string_msg_get_string_msg(orig_container,
                                       seq2str(items, lastsep=' or '),
                                       msg, values,
                                       'contains one or more of',
                                       quote_item2=False)
            raise AssertionError(msg)
 
    
    def should_contain_x_times(self, container, item, count, msg=None,
                               ignore_case=False, strip_spaces=False,
                               collapse_spaces=False):
        count = self._convert_to_integer(count)
        orig_container = container
        if is_string(item):
            if ignore_case:
                item = item.lower()
                if is_string(container):
                    container = container.lower()
                elif is_list_like(container):
                    container = [x.lower() if is_string(x) else x for x in container]
            if strip_spaces:
                item = self._strip_spaces_strip_spaces(item, strip_spaces)
                if is_string(container):
                    container = self._strip_spaces_strip_spaces(container, strip_spaces)
                elif is_list_like(container):
                    container = [self._strip_spaces_strip_spaces(x, strip_spaces) for x in container]
            if collapse_spaces:
                item = self._collapse_spaces_collapse_spaces(item)
                if is_string(container):
                    container = self._collapse_spaces_collapse_spaces(container)
                elif is_list_like(container):
                    container = [self._collapse_spaces_collapse_spaces(x) for x in container]
        x = self.get_countget_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))
        self.should_be_equal_as_integersshould_be_equal_as_integers(x, count, msg, values=False)
 
    
    def get_count(self, container, item):
        if not hasattr(container, 'count'):
            try:
                container = list(container)
            except:
                raise RuntimeError("Converting '%s' to list failed: %s"
                                   % (container, get_error_message()))
        count = container.count(item)
        self.log('Item found from container %d time%s.' % (count, s(count)))
        return count
 
    
    def should_not_match(self, string, pattern, msg=None, values=True,
                         ignore_case=False):
        if self._matches_matches(string, pattern, caseless=ignore_case):
            raise AssertionError(self._get_string_msg_get_string_msg(string, pattern, msg,
                                                      values, 'matches'))
 
    
    def should_match(self, string, pattern, msg=None, values=True,
                     ignore_case=False):
        if not self._matches_matches(string, pattern, caseless=ignore_case):
            raise AssertionError(self._get_string_msg_get_string_msg(string, pattern, msg,
                                                      values, 'does not match'))
 
    
    def should_match_regexp(self, string, pattern, msg=None, values=True, flags=None):
        res = re.search(pattern, string, flags=parse_re_flags(flags))
        if res is None:
            raise AssertionError(self._get_string_msg_get_string_msg(string, pattern, msg,
                                                      values, 'does not match'))
        match = res.group(0)
        groups = res.groups()
        if groups:
            return [match] + list(groups)
        return match
 
    
    def should_not_match_regexp(self, string, pattern, msg=None, values=True, flags=None):
        if re.search(pattern, string, flags=parse_re_flags(flags)) is not None:
            raise AssertionError(self._get_string_msg_get_string_msg(string, pattern, msg,
                                                      values, 'matches'))
 
    
    def get_length(self, item):
        length = self._get_length_get_length(item)
        self.log('Length is %d' % length)
        return length
 
    def _get_length(self, item):
        try:
            return len(item)
        except RERAISED_EXCEPTIONS:
            raise
        except:
            try:
                return item.length()
            except RERAISED_EXCEPTIONS:
                raise
            except:
                try:
                    return item.size()
                except RERAISED_EXCEPTIONS:
                    raise
                except:
                    try:
                        return item.length
                    except RERAISED_EXCEPTIONS:
                        raise
                    except:
                        raise RuntimeError("Could not get length of '%s'." % item)
 
    
    def length_should_be(self, item, length, msg=None):
        length = self._convert_to_integer(length)
        actual = self.get_lengthget_length(item)
        if actual != length:
            raise AssertionError(msg or "Length of '%s' should be %d but is %d."
                                        % (item, length, actual))
 
    
    def should_be_empty(self, item, msg=None):
        if self.get_lengthget_length(item) > 0:
            raise AssertionError(msg or "'%s' should be empty." % (item,))
 
    
    def should_not_be_empty(self, item, msg=None):
        if self.get_lengthget_length(item) == 0:
            raise AssertionError(msg or "'%s' should not be empty." % (item,))
 
    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(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)
        if not custom_message:
            return default_message
        return '%s: %s' % (custom_message, default_message)
 
 
class _Variables(_BuiltInBase):
 
    
    def get_variables(self, no_decoration=False):
        return self._variables_variables_variables.as_dict(decoration=is_falsy(no_decoration))
 
    @keyword(types=None)
    @run_keyword_variant(resolve=0)
    
    def get_variable_value(self, name, default=None):
        try:
            name = self._get_var_name_get_var_name(name, require_assign=False)
            return self._variables_variables_variables.replace_scalar(name)
        except VariableError:
            return self._variables_variables_variables.replace_scalar(default)
 
    
    def log_variables(self, level='INFO'):
        variables = self.get_variablesget_variables()
        for name in sorted(variables, key=lambda s: s[2:-1].lower()):
            name, value = self._get_logged_variable_get_logged_variable(name, variables)
            msg = format_assign_message(name, value, cut_long=False)
            self.log(msg, level)
 
    def _get_logged_variable(self, name, variables):
        value = variables[name]
        try:
            if name[0] == '@':
                value = list(value)
            if name[0] == '&':
                value = OrderedDict(value)
        except RERAISED_EXCEPTIONS:
            raise
        except:
            name = '$' + name[1:]
        return name, value
 
    @run_keyword_variant(resolve=0)
    
    def variable_should_exist(self, name, msg=None):
        name = self._get_var_name_get_var_name(name)
        try:
            self._variables_variables_variables.replace_scalar(name)
        except VariableError:
            raise AssertionError(self._variables_variables_variables.replace_string(msg)
                                 if msg else "Variable '%s' does not exist." % name)
 
    @run_keyword_variant(resolve=0)
    
    def variable_should_not_exist(self, name, msg=None):
        name = self._get_var_name_get_var_name(name)
        try:
            self._variables_variables_variables.replace_scalar(name)
        except VariableError:
            pass
        else:
            raise AssertionError(self._variables_variables_variables.replace_string(msg)
                                 if msg else "Variable '%s' exists." % name)
 
    
    def replace_variables(self, text):
        return self._variables_variables_variables.replace_scalar(text)
 
    
    def set_variable(self, *values):
        if len(values) == 0:
            return ''
        elif len(values) == 1:
            return values[0]
        else:
            return list(values)
 
    @run_keyword_variant(resolve=0)
    
    def set_local_variable(self, name, *values):
        name = self._get_var_name_get_var_name(name)
        value = self._get_var_value_get_var_value(name, values)
        self._variables_variables_variables.set_local_variable(name, value)
        self._log_set_variable_log_set_variable(name, value)
 
    @run_keyword_variant(resolve=0)
    
    def set_test_variable(self, name, *values):
        name = self._get_var_name_get_var_name(name)
        value = self._get_var_value_get_var_value(name, values)
        self._variables_variables_variables.set_test(name, value)
        self._log_set_variable_log_set_variable(name, value)
 
    @run_keyword_variant(resolve=0)
    
    def set_task_variable(self, name, *values):
        self.set_test_variableset_test_variable(name, *values)
 
    @run_keyword_variant(resolve=0)
    
    def set_suite_variable(self, name, *values):
        name = self._get_var_name_get_var_name(name)
        if values and is_string(values[-1]) and values[-1].startswith('children='):
            children = self._variables_variables_variables.replace_scalar(values[-1][9:])
            children = is_truthy(children)
            values = values[:-1]
        else:
            children = False
        value = self._get_var_value_get_var_value(name, values)
        self._variables_variables_variables.set_suite(name, value, children=children)
        self._log_set_variable_log_set_variable(name, value)
 
    @run_keyword_variant(resolve=0)
    
    def set_global_variable(self, name, *values):
        name = self._get_var_name_get_var_name(name)
        value = self._get_var_value_get_var_value(name, values)
        self._variables_variables_variables.set_global(name, value)
        self._log_set_variable_log_set_variable(name, value)
 
    # Helpers
 
    def _get_var_name(self, original, require_assign=True):
        try:
            replaced = self._variables_variables_variables.replace_string(original)
        except VariableError:
            replaced = original
        try:
            name = self._resolve_var_name_resolve_var_name(replaced)
        except ValueError:
            name = original
        match = search_variable(name, identifiers='$@&')
        match.resolve_base(self._variables_variables_variables)
        valid = match.is_assign() if require_assign else match.is_variable()
        if not valid:
            raise DataError("Invalid variable name '%s'." % name)
        return str(match)
 
    def _resolve_var_name(self, name):
        if name.startswith('\\'):
            name = name[1:]
        if len(name) < 2 or name[0] not in '$@&':
            raise ValueError
        if name[1] != '{':
            name = '%s{%s}' % (name[0], name[1:])
        match = search_variable(name, identifiers='$@&', ignore_errors=True)
        match.resolve_base(self._variables_variables_variables)
        if not match.is_assign():
            raise ValueError
        return str(match)
 
    def _get_var_value(self, name, values):
        if not values:
            return self._variables_variables_variables[name]
        if name[0] == '$':
            # We could consider catenating values similarly as when creating
            # scalar variables in the variable table, but that would require
            # 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:]))
            return self._variables_variables_variables.replace_scalar(values[0])
        return VariableTableValue(values, name).resolve(self._variables_variables_variables)
 
    def _log_set_variable(self, name, value):
        self.log(format_assign_message(name, value))
 
 
class _RunKeyword(_BuiltInBase):
 
    # If you use any of these run keyword variants from another library, you
    # should register those keywords with 'register_run_keyword' method. See
    # the documentation of that method at the end of this file. There are also
    # other run keyword variant keywords in BuiltIn which can also be seen
    # at the end of this file.
 
    @run_keyword_variant(resolve=0, dry_run=True)
    
    def run_keyword(self, name, *args):
        if (is_string(name)
                and not self._context_context_context.dry_run
                and not self._accepts_embedded_arguments_accepts_embedded_arguments(name)):
            name, args = self._replace_variables_in_name_replace_variables_in_name([name] + list(args))
        if not is_string(name):
            raise RuntimeError('Keyword name must be a string.')
        kw = Keyword(name, args=args)
        return kw.run(self._context_context_context)
 
    def _accepts_embedded_arguments(self, name):
        if '{' in name:
            runner = self._context_context_context.get_runner(name)
            if hasattr(runner, 'embedded_args'):
                return True
        return False
 
    def _replace_variables_in_name(self, name_and_args):
        resolved = self._variables_variables_variables.replace_list(name_and_args, replace_until=1,
                                                ignore_errors=self._context_context_context.in_teardown)
        if not resolved:
            raise DataError(f'Keyword name missing: Given arguments {name_and_args} '
                            f'resolved to an empty list.')
        return resolved[0], resolved[1:]
 
    @run_keyword_variant(resolve=0, dry_run=True)
    
    def run_keywords(self, *keywords):
        self._run_keywords_run_keywords(self._split_run_keywords_split_run_keywords(list(keywords)))
 
    def _run_keywords(self, iterable):
        errors = []
        for kw, args in iterable:
            try:
                self.run_keywordrun_keyword(kw, *args)
            except ExecutionPassed as err:
                err.set_earlier_failures(errors)
                raise err
            except ExecutionFailed as err:
                errors.extend(err.get_errors())
                if not err.can_continue(self._context_context_context):
                    break
        if errors:
            raise ExecutionFailures(errors)
 
    def _split_run_keywords(self, keywords):
        if 'AND' not in keywords:
            for name in self._split_run_keywords_without_and_split_run_keywords_without_and(keywords):
                yield name, ()
        else:
            for kw_call in self._split_run_keywords_with_and_split_run_keywords_with_and(keywords):
                if not kw_call:
                    raise DataError('AND must have keyword before and after.')
                yield kw_call[0], kw_call[1:]
 
    def _split_run_keywords_without_and(self, keywords):
        replace_list = self._variables_variables_variables.replace_list
        ignore_errors = self._context_context_context.in_teardown
        # `run_keyword` resolves variables, but list variables must be expanded
        # here to pass it each keyword name separately.
        for name in keywords:
            if is_list_variable(name):
                for n in replace_list([name], ignore_errors=ignore_errors):
                    yield escape(n)
            else:
                yield name
 
    def _split_run_keywords_with_and(self, keywords):
        while 'AND' in keywords:
            index = keywords.index('AND')
            yield keywords[:index]
            keywords = keywords[index+1:]
        yield keywords
 
    @run_keyword_variant(resolve=1, dry_run=True)
    
    def run_keyword_if(self, condition, name, *args):
        args, branch = self._split_elif_or_else_branch_split_elif_or_else_branch(args)
        if self._is_true_is_true(condition):
            return self.run_keywordrun_keyword(name, *args)
        return branch()
 
    def _split_elif_or_else_branch(self, args):
        if 'ELSE IF' in args:
            args, branch = self._split_branch_split_branch(args, 'ELSE IF', 2,
                                              'condition and keyword')
            return args, lambda: self.run_keyword_ifrun_keyword_if(*branch)
        if 'ELSE' in args:
            args, branch = self._split_branch_split_branch(args, 'ELSE', 1, 'keyword')
            return args, lambda: self.run_keywordrun_keyword(*branch)
        return args, lambda: None
 
    def _split_branch(self, args, control_word, required, required_error):
        index = list(args).index(control_word)
        branch = self._variables_variables_variables.replace_list(args[index+1:], required)
        if len(branch) < required:
            raise DataError('%s requires %s.' % (control_word, required_error))
        return args[:index], branch
 
    @run_keyword_variant(resolve=1, dry_run=True)
    
    def run_keyword_unless(self, condition, name, *args):
        if not self._is_true_is_true(condition):
            return self.run_keywordrun_keyword(name, *args)
 
    @run_keyword_variant(resolve=0, dry_run=True)
    
    def run_keyword_and_ignore_error(self, name, *args):
        try:
            return 'PASS', self.run_keywordrun_keyword(name, *args)
        except ExecutionFailed as err:
            if err.dont_continue or err.skip:
                raise
            return 'FAIL', str(err)
 
    @run_keyword_variant(resolve=0, dry_run=True)
    
    def run_keyword_and_warn_on_failure(self, name, *args):
        status, message = self.run_keyword_and_ignore_errorrun_keyword_and_ignore_error(name, *args)
        if status == 'FAIL':
            logger.warn("Executing keyword '%s' failed:\n%s" % (name, message))
        return status, message
 
    @run_keyword_variant(resolve=0, dry_run=True)
    
    def run_keyword_and_return_status(self, name, *args):
        status, _ = self.run_keyword_and_ignore_errorrun_keyword_and_ignore_error(name, *args)
        return status == 'PASS'
 
    @run_keyword_variant(resolve=0, dry_run=True)
    
    def run_keyword_and_continue_on_failure(self, name, *args):
        try:
            return self.run_keywordrun_keyword(name, *args)
        except ExecutionFailed as err:
            if not err.dont_continue:
                err.continue_on_failure = True
            raise err
 
    @run_keyword_variant(resolve=1, dry_run=True)
    
    def run_keyword_and_expect_error(self, expected_error, name, *args):
        try:
            self.run_keywordrun_keyword(name, *args)
        except ExecutionFailed as err:
            if err.dont_continue or err.skip:
                raise
            error = err.message
        else:
            raise AssertionError("Expected error '%s' did not occur."
                                 % expected_error)
        if not self._error_is_expected_error_is_expected(error, expected_error):
            raise AssertionError("Expected error '%s' but got '%s'."
                                 % (expected_error, error))
        return error
 
    def _error_is_expected(self, error, expected_error):
        glob = self._matches_matches
        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}
        prefixes = tuple(prefix + ':' for prefix in matchers)
        if not expected_error.startswith(prefixes):
            return glob(error, expected_error)
        prefix, expected_error = expected_error.split(':', 1)
        return matchers[prefix](error, expected_error.lstrip())
 
    @run_keyword_variant(resolve=1, dry_run=True)
    
    def repeat_keyword(self, repeat, name, *args):
        try:
            count = self._get_repeat_count_get_repeat_count(repeat)
        except RuntimeError as err:
            timeout = self._get_repeat_timeout_get_repeat_timeout(repeat)
            if timeout is None:
                raise err
            keywords = self._keywords_repeated_by_timeout_keywords_repeated_by_timeout(timeout, name, args)
        else:
            keywords = self._keywords_repeated_by_count_keywords_repeated_by_count(count, name, args)
        self._run_keywords_run_keywords(keywords)
 
    def _get_repeat_count(self, times, require_postfix=False):
        times = normalize(str(times))
        if times.endswith('times'):
            times = times[:-5]
        elif times.endswith('x'):
            times = times[:-1]
        elif require_postfix:
            raise ValueError
        return self._convert_to_integer(times)
 
    def _get_repeat_timeout(self, timestr):
        try:
            float(timestr)
        except ValueError:
            pass
        else:
            return None
        try:
            return timestr_to_secs(timestr)
        except ValueError:
            return None
 
    def _keywords_repeated_by_count(self, count, name, args):
        if count <= 0:
            self.log("Keyword '%s' repeated zero times." % name)
        for i in range(count):
            self.log("Repeating keyword, round %d/%d." % (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
        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)))
            yield name, args
 
    @run_keyword_variant(resolve=2, dry_run=True)
    
    def wait_until_keyword_succeeds(self, retry, retry_interval, name, *args):
        maxtime = count = -1
        try:
            count = self._get_repeat_count_get_repeat_count(retry, require_postfix=True)
        except ValueError:
            timeout = timestr_to_secs(retry)
            maxtime = time.time() + timeout
            message = 'for %s' % secs_to_timestr(timeout)
        else:
            if count <= 0:
                raise ValueError('Retry count %d is not positive.' % count)
            message = '%d time%s' % (count, s(count))
        if is_string(retry_interval) and normalize(retry_interval).startswith('strict:'):
            retry_interval = retry_interval.split(':', 1)[1].strip()
            strict_interval = True
        else:
            strict_interval = False
        retry_interval = sleep_time = timestr_to_secs(retry_interval)
        while True:
            start_time = time.time()
            try:
                return self.run_keywordrun_keyword(name, *args)
            except ExecutionFailed as err:
                if err.dont_continue or err.skip:
                    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))
            finally:
                if strict_interval:
                    keyword_runtime = time.time() - start_time
                    sleep_time = retry_interval - keyword_runtime
                    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)))
            self._sleep_in_parts(sleep_time)
 
    @run_keyword_variant(resolve=1)
    
    def set_variable_if(self, condition, *values):
        values = self._verify_values_for_set_variable_if_verify_values_for_set_variable_if(list(values))
        if self._is_true_is_true(condition):
            return self._variables_variables_variables.replace_scalar(values[0])
        values = self._verify_values_for_set_variable_if_verify_values_for_set_variable_if(values[1:], True)
        if len(values) == 1:
            return self._variables_variables_variables.replace_scalar(values[0])
        return self.run_keywordrun_keyword('BuiltIn.Set Variable If', *values[0:])
 
    def _verify_values_for_set_variable_if(self, values, default=False):
        if not values:
            if default:
                return [None]
            raise RuntimeError('At least one value is required')
        if is_list_variable(values[0]):
            values[:1] = [escape(item) for item in self._variables_variables_variables[values[0]]]
            return self._verify_values_for_set_variable_if_verify_values_for_set_variable_if(values)
        return values
 
    @run_keyword_variant(resolve=0, dry_run=True)
    
    def run_keyword_if_test_failed(self, name, *args):
        test = self._get_test_in_teardown_get_test_in_teardown('Run Keyword If Test Failed')
        if test.failed:
            return self.run_keywordrun_keyword(name, *args)
 
    @run_keyword_variant(resolve=0, dry_run=True)
    
    def run_keyword_if_test_passed(self, name, *args):
        test = self._get_test_in_teardown_get_test_in_teardown('Run Keyword If Test Passed')
        if test.passed:
            return self.run_keywordrun_keyword(name, *args)
 
    @run_keyword_variant(resolve=0, dry_run=True)
    
    def run_keyword_if_timeout_occurred(self, name, *args):
        self._get_test_in_teardown_get_test_in_teardown('Run Keyword If Timeout Occurred')
        if self._context_context_context.timeout_occurred:
            return self.run_keywordrun_keyword(name, *args)
 
    def _get_test_in_teardown(self, kwname):
        ctx = self._context_context_context
        if ctx.test and ctx.in_test_teardown:
            return ctx.test
        raise RuntimeError(f"Keyword '{kwname}' can only be used in test teardown.")
 
    @run_keyword_variant(resolve=0, dry_run=True)
    
    def run_keyword_if_all_tests_passed(self, name, *args):
        suite = self._get_suite_in_teardown_get_suite_in_teardown('Run Keyword If All Tests Passed')
        if suite.statistics.failed == 0:
            return self.run_keywordrun_keyword(name, *args)
 
    @run_keyword_variant(resolve=0, dry_run=True)
    
    def run_keyword_if_any_tests_failed(self, name, *args):
        suite = self._get_suite_in_teardown_get_suite_in_teardown('Run Keyword If Any Tests Failed')
        if suite.statistics.failed > 0:
            return self.run_keywordrun_keyword(name, *args)
 
    def _get_suite_in_teardown(self, kwname):
        if not self._context_context_context.in_suite_teardown:
            raise RuntimeError("Keyword '%s' can only be used in suite teardown."
                               % kwname)
        return self._context_context_context.suite
 
 
class _Control(_BuiltInBase):
 
    
    def skip(self, msg='Skipped with Skip keyword.'):
        raise SkipExecution(msg)
 
    
    def skip_if(self, condition, msg=None):
        if self._is_true_is_true(condition):
            raise SkipExecution(msg or condition)
 
    
    def continue_for_loop(self):
        if not self._context_context_context.allow_loop_control:
            raise DataError("'Continue For Loop' can only be used inside a loop.")
        self.log("Continuing for loop from the next iteration.")
        raise ContinueLoop()
 
    
    def continue_for_loop_if(self, condition):
        if not self._context_context_context.allow_loop_control:
            raise DataError("'Continue For Loop If' can only be used inside a loop.")
        if self._is_true_is_true(condition):
            self.continue_for_loopcontinue_for_loop()
 
    
    def exit_for_loop(self):
        if not self._context_context_context.allow_loop_control:
            raise DataError("'Exit For Loop' can only be used inside a loop.")
        self.log("Exiting for loop altogether.")
        raise BreakLoop()
 
    
    def exit_for_loop_if(self, condition):
        if not self._context_context_context.allow_loop_control:
            raise DataError("'Exit For Loop If' can only be used inside a loop.")
        if self._is_true_is_true(condition):
            self.exit_for_loopexit_for_loop()
 
    @run_keyword_variant(resolve=0)
    
    def return_from_keyword(self, *return_values):
        self._return_from_keyword_return_from_keyword(return_values)
 
    def _return_from_keyword(self, return_values=None, failures=None):
        self.log('Returning from the enclosing user keyword.')
        raise ReturnFromKeyword(return_values, failures)
 
    @run_keyword_variant(resolve=1)
    
    def return_from_keyword_if(self, condition, *return_values):
        if self._is_true_is_true(condition):
            self._return_from_keyword_return_from_keyword(return_values)
 
    @run_keyword_variant(resolve=0, dry_run=True)
    
    def run_keyword_and_return(self, name, *args):
        try:
            ret = self.run_keyword(name, *args)
        except ExecutionFailed as err:
            self._return_from_keyword_return_from_keyword(failures=[err])
        else:
            self._return_from_keyword_return_from_keyword(return_values=[escape(ret)])
 
    @run_keyword_variant(resolve=1, dry_run=True)
    
    def run_keyword_and_return_if(self, condition, name, *args):
        if self._is_true_is_true(condition):
            self.run_keyword_and_returnrun_keyword_and_return(name, *args)
 
    
    def pass_execution(self, message, *tags):
        message = message.strip()
        if not message:
            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)
        raise PassExecution(message)
 
    @run_keyword_variant(resolve=1)
    
    def pass_execution_if(self, condition, message, *tags):
        if self._is_true_is_true(condition):
            message = self._variables_variables_variables.replace_string(message)
            tags = self._variables_variables_variables.replace_list(tags)
            self.pass_executionpass_execution(message, *tags)
 
 
class _Misc(_BuiltInBase):
 
    
    def no_operation(self):
 
    
    def sleep(self, time_, reason=None):
        seconds = timestr_to_secs(time_)
        # Python hangs with negative values
        if seconds < 0:
            seconds = 0
        self._sleep_in_parts_sleep_in_parts(seconds)
        self.loglog('Slept %s' % secs_to_timestr(seconds))
        if reason:
            self.loglog(reason)
 
    def _sleep_in_parts(self, seconds):
        # time.sleep can't be stopped in windows
        # to ensure that we can signal stop (with timeout)
        # split sleeping to small pieces
        endtime = time.time() + float(seconds)
        while True:
            remaining = endtime - time.time()
            if remaining <= 0:
                break
            time.sleep(min(remaining, 0.01))
 
    
    def catenate(self, *items):
        if not items:
            return ''
        items = [str(item) for item in items]
        if items[0].startswith('SEPARATOR='):
            sep = items[0][len('SEPARATOR='):]
            items = items[1:]
        else:
            sep = ' '
        return sep.join(items)
 
    
    def log(self, message, level='INFO', html=False, console=False,
            repr='DEPRECATED', formatter='str'):
        # TODO: Remove `repr` altogether in RF 7.0. It was deprecated in RF 5.0.
        if repr == 'DEPRECATED':
            formatter = self._get_formatter_get_formatter(formatter)
        else:
            logger.warn("The 'repr' argument of 'BuiltIn.Log' is deprecated. "
                        "Use 'formatter=repr' instead.")
            formatter = prepr if is_truthy(repr) else self._get_formatter_get_formatter(formatter)
        message = formatter(message)
        logger.write(message, level, html)
        if console:
            logger.console(message)
 
    def _get_formatter(self, formatter):
        try:
            return {'str': safe_str,
                    'repr': prepr,
                    'ascii': ascii,
                    '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)
 
    @run_keyword_variant(resolve=0)
    
    def log_many(self, *messages):
        for msg in self._yield_logged_messages_yield_logged_messages(messages):
            self.loglog(msg)
 
    def _yield_logged_messages(self, messages):
        for msg in messages:
            match = search_variable(msg)
            value = self._variables_variables_variables.replace_scalar(msg)
            if match.is_list_variable():
                for item in value:
                    yield item
            elif match.is_dict_variable():
                for name, value in value.items():
                    yield '%s=%s' % (name, value)
            else:
                yield value
 
    
    def log_to_console(self, message, stream='STDOUT', no_newline=False, format=''):
        if format:
            format = "{:" + format + "}"
            message = format.format(message)
        logger.console(message, newline=is_falsy(no_newline), stream=stream)
 
    @run_keyword_variant(resolve=0)
    
    def comment(self, *messages):
        pass
 
    
    def set_log_level(self, level):
        try:
            old = self._context_context_context.output.set_log_level(level)
        except DataError as err:
            raise RuntimeError(str(err))
        self._namespace_namespace_namespace.variables.set_global('${LOG_LEVEL}', level.upper())
        self.loglog('Log level changed from %s to %s.' % (old, level.upper()))
        return old
 
    
    def reload_library(self, name_or_instance):
        library = self._namespace_namespace_namespace.reload_library(name_or_instance)
        self.loglog('Reloaded library %s with %s keywords.' % (library.name,
                                                            len(library)))
 
    @run_keyword_variant(resolve=0)
    
    def import_library(self, name, *args):
        args, alias = self._split_alias_split_alias(args)
        try:
            self._namespace_namespace_namespace.import_library(name, args, alias)
        except DataError as err:
            raise RuntimeError(str(err))
 
    def _split_alias(self, args):
        if len(args) > 1 and normalize_whitespace(args[-2]) in ('WITH NAME', 'AS'):
            return args[:-2], args[-1]
        return args, None
 
    @run_keyword_variant(resolve=0)
    
    def import_variables(self, path, *args):
        try:
            self._namespace_namespace_namespace.import_variables(path, list(args), overwrite=True)
        except DataError as err:
            raise RuntimeError(str(err))
 
    @run_keyword_variant(resolve=0)
    
    def import_resource(self, path):
        try:
            self._namespace_namespace_namespace.import_resource(path)
        except DataError as err:
            raise RuntimeError(str(err))
 
    
    def set_library_search_order(self, *search_order):
        return self._namespace_namespace_namespace.set_search_order(search_order)
 
    
    def keyword_should_exist(self, name, msg=None):
        try:
            runner = self._namespace_namespace_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)
 
    
    def get_time(self, format='timestamp', time_='NOW'):
        return get_time(format, parse_time(time_))
 
    
    def evaluate(self, expression, modules=None, namespace=None):
        try:
            return evaluate_expression(expression, self._variables_variables_variables.current.store,
                                       modules, namespace)
        except DataError as err:
            raise RuntimeError(err.message)
 
    
    def call_method(self, object, method_name, *args, **kwargs):
        try:
            method = getattr(object, method_name)
        except AttributeError:
            raise RuntimeError(f"{type(object).__name__} object does not have "
                               f"method '{method_name}'.")
        try:
            return method(*args, **kwargs)
        except Exception as err:
            msg = get_error_message()
            raise RuntimeError(f"Calling method '{method_name}' failed: {msg}") from err
 
    
    def regexp_escape(self, *patterns):
        if len(patterns) == 0:
            return ''
        if len(patterns) == 1:
            return re.escape(patterns[0])
        return [re.escape(p) for p in patterns]
 
    
    def set_test_message(self, message, append=False):
        test = self._context_context_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_get_new_text(test.message, message,
                                          append, handle_html=True)
        if self._context_context_context.in_test_teardown:
            self._variables_variables_variables.set_test("${TEST_MESSAGE}", test.message)
        message, level = self._get_logged_test_message_and_level_get_logged_test_message_and_level(test.message)
        self.loglog('Set test message to:\n%s' % message, level)
 
    def _get_new_text(self, old, new, append, handle_html=False):
        if not is_string(new):
            new = str(new)
        if not (is_truthy(append) and old):
            return new
        if handle_html:
            if new.startswith('*HTML*'):
                new = new[6:].lstrip()
                if not old.startswith('*HTML*'):
                    old = '*HTML* %s' % html_escape(old)
            elif old.startswith('*HTML*'):
                new = html_escape(new)
        return '%s %s' % (old, 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):
        test = self._context_context_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_get_new_text(test.doc, doc, append)
        self._variables_variables_variables.set_test('${TEST_DOCUMENTATION}', test.doc)
        self.loglog('Set test documentation to:\n%s' % test.doc)
 
    
    def set_suite_documentation(self, doc, append=False, top=False):
        suite = self._get_context_get_context(top).suite
        suite.doc = self._get_new_text_get_new_text(suite.doc, doc, append)
        self._variables_variables_variables.set_suite('${SUITE_DOCUMENTATION}', suite.doc, top)
        self.loglog('Set suite documentation to:\n%s' % suite.doc)
 
    
    def set_suite_metadata(self, name, value, append=False, top=False):
        if not is_string(name):
            name = str(name)
        metadata = self._get_context_get_context(top).suite.metadata
        original = metadata.get(name, '')
        metadata[name] = self._get_new_text_get_new_text(original, value, append)
        self._variables_variables_variables.set_suite('${SUITE_METADATA}', metadata.copy(), top)
        self.loglog("Set suite metadata '%s' to value '%s'." % (name, metadata[name]))
 
    
    def set_tags(self, *tags):
        ctx = self._context_context_context
        if ctx.test:
            ctx.test.tags.add(tags)
            ctx.variables.set_test('@{TEST_TAGS}', list(ctx.test.tags))
        elif not ctx.in_suite_teardown:
            ctx.suite.set_tags(tags, persist=True)
        else:
            raise RuntimeError("'Set Tags' cannot be used in suite teardown.")
        self.loglog('Set tag%s %s.' % (s(tags), seq2str(tags)))
 
    
    def remove_tags(self, *tags):
        ctx = self._context_context_context
        if ctx.test:
            ctx.test.tags.remove(tags)
            ctx.variables.set_test('@{TEST_TAGS}', list(ctx.test.tags))
        elif not ctx.in_suite_teardown:
            ctx.suite.set_tags(remove=tags, persist=True)
        else:
            raise RuntimeError("'Remove Tags' cannot be used in suite teardown.")
        self.loglog('Removed tag%s %s.' % (s(tags), seq2str(tags)))
 
    
    def get_library_instance(self, name=None, all=False):
        if all:
            return self._namespace_namespace_namespace.get_library_instances()
        try:
            return self._namespace_namespace_namespace.get_library_instance(name)
        except DataError as err:
            raise RuntimeError(str(err))
 
 
 
class BuiltIn(_Verify, _Converter, _Variables, _RunKeyword, _Control, _Misc):
    ROBOT_LIBRARY_SCOPE = 'GLOBAL'
    ROBOT_LIBRARY_VERSION = get_version()
 
 
 
class RobotNotRunningError(AttributeError):
    pass
 
 
 
def register_run_keyword(library, keyword, args_to_process=0, deprecation_warning=True):
    RUN_KW_REGISTER.register_run_keyword(library, keyword, args_to_process,
                                         deprecation_warning)