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.
 
import difflib
import re
import time
import token
from tokenize import generate_tokens, untokenize
 
from robotide.lib.robot.api import logger
from robotide.lib.robot.errors import (ContinueForLoop, DataError, ExecutionFailed,
                          ExecutionFailures, ExecutionPassed, ExitForLoop,
                          PassExecution, ReturnFromKeyword)
from robotide.lib.robot.running import Keyword, RUN_KW_REGISTER
from robotide.lib.robot.running.context import EXECUTION_CONTEXTS
from robotide.lib.robot.running.usererrorhandler import UserErrorHandler
from robotide.lib.robot.utils import (DotDict, escape, format_assign_message,
                         get_error_message, get_time, html_escape, is_falsy, is_integer,
                         is_string, is_truthy, is_unicode, IRONPYTHON, JYTHON,
                         Matcher, normalize, NormalizedDict, parse_time, prepr,
                         plural_or_not as s, PY3, RERAISED_EXCEPTIONS, roundup,
                         secs_to_timestr, seq2str, split_from_equals, StringIO,
                         timestr_to_secs, type_name, unic, is_list_like)
from robotide.lib.robot.utils.asserts import assert_equal, assert_not_equal
from robotide.lib.robot.variables import (is_list_var, is_var, DictVariableTableValue,
                             VariableTableValue, VariableSplitter,
                             variable_not_found)
from robotide.lib.robot.version import get_version
 
if JYTHON:
    from java.lang import String, Number
 
 
# TODO: Clean-up registering run keyword variants in RF 3.1.
# https://github.com/robotframework/robotframework/issues/2190
 
def run_keyword_variant(resolve):
    def decorator(method):
        RUN_KW_REGISTER.register_run_keyword('BuiltIn', method.__name__,
                                             resolve, deprecation_warning=False)
        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, modules='os,sys')
        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):
        # In IronPython type(u'x') is str. We want to report unicode anyway.
        if is_unicode(arg):
            return "<type 'unicode'>"
        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 = self._handle_java_numbers_handle_java_numbers(orig)
            item, base = self._get_base_get_base(item, 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 _handle_java_numbers(self, item):
        if not JYTHON:
            return item
        if isinstance(item, String):
            return unic(item)
        if isinstance(item, Number):
            return item.doubleValue()
        return item
 
    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 is_truthy(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 = roundup(number, self._convert_to_integer_convert_to_integer(precision),
                             return_type=float)
        return number
 
    def _convert_to_number_without_precision(self, item):
        try:
            if JYTHON:
                item = self._handle_java_numbers_handle_java_numbers(item)
            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 self._convert_to_string_convert_to_string(item)
 
    def _convert_to_string(self, item):
        return unic(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):
        # https://github.com/IronLanguages/main/issues/1237
        if IRONPYTHON and isinstance(input, bytearray):
            input = bytes(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 VariableSplitter(item).is_dict_variable():
                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'):
        self._log_types_at_info_if_different_log_types_at_info_if_different(first, second)
        if is_truthy(ignore_case) and is_string(first) and is_string(second):
            first = first.lower()
            second = second.lower()
        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, 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, 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:]]
        raise AssertionError('Multiline strings are different:\n' +
                             '\n'.join(diffs))
 
    def _include_values(self, values):
        return is_truthy(values) and str(values).upper() != 'NO VALUES'
 
    
    def should_not_be_equal(self, first, second, msg=None, values=True,
                            ignore_case=False):
        self._log_types_at_info_if_different_log_types_at_info_if_different(first, second)
        if is_truthy(ignore_case) and is_string(first) and is_string(second):
            first = first.lower()
            second = second.lower()
        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):
        self._log_types_at_info_if_different_log_types_at_info_if_different(first, second)
        first = self._convert_to_string(first)
        second = self._convert_to_string(second)
        if is_truthy(ignore_case):
            first = first.lower()
            second = second.lower()
        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, formatter='str'):
        self._log_types_at_info_if_different_log_types_at_info_if_different(first, second)
        first = self._convert_to_string(first)
        second = self._convert_to_string(second)
        if is_truthy(ignore_case):
            first = first.lower()
            second = second.lower()
        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):
        if is_truthy(ignore_case):
            str1 = str1.lower()
            str2 = str2.lower()
        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):
        if is_truthy(ignore_case):
            str1 = str1.lower()
            str2 = str2.lower()
        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):
        if is_truthy(ignore_case):
            str1 = str1.lower()
            str2 = str2.lower()
        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):
        if is_truthy(ignore_case):
            str1 = str1.lower()
            str2 = str2.lower()
        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):
        # 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 is_truthy(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 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):
        orig_container = container
        if is_truthy(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 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 = configuration.pop('ignore_case', 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 is_truthy(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 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 = configuration.pop('ignore_case', 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 is_truthy(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 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, item1, item2, count, msg=None,
                               ignore_case=False):
        # TODO: Rename 'item1' and 'item2' to 'container' and 'item' in RF 3.1.
        # Other 'contain' keywords use these names. And 'Get Count' should too.
        # Cannot be done in minor release due to backwards compatibility.
        # Remember to update it also in the docstring!!
        count = self._convert_to_integer(count)
        orig_item1 = item1
        if is_truthy(ignore_case) and is_string(item2):
            item2 = item2.lower()
            if is_string(item1):
                item1 = item1.lower()
            elif is_list_like(item1):
                item1 = [x.lower() if is_string(x) else x for x in item1]
        x = self.get_countget_count(item1, item2)
        if not msg:
            msg = "'%s' contains '%s' %d time%s, not %d time%s." \
                    % (unic(orig_item1), unic(item2), 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, item1, item2):
        if not hasattr(item1, 'count'):
            try:
                item1 = list(item1)
            except:
                raise RuntimeError("Converting '%s' to list failed: %s"
                                   % (item1, get_error_message()))
        count = item1.count(item2)
        self.log('Item found from the first item %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=is_truthy(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=is_truthy(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):
        res = re.search(pattern, string)
        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):
        if re.search(pattern, string) 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'" % unic(item1) if quote_item1 else unic(item1)
        item2 = "'%s'" % unic(item2) if quote_item2 else unic(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))
 
    @run_keyword_variant(resolve=0)
    
    def get_variable_value(self, name, default=None):
        try:
            return self._variables_variables_variables[self._get_var_name_get_var_name(name)]
        except DataError:
            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()):
            msg = format_assign_message(name, variables[name], cut_long=False)
            self.log(msg, level)
 
    @run_keyword_variant(resolve=0)
    
    def variable_should_exist(self, name, msg=None):
        name = self._get_var_name_get_var_name(name)
        msg = self._variables_variables_variables.replace_string(msg) if msg \
            else "Variable %s does not exist." % name
        try:
            self._variables_variables_variables[name]
        except DataError:
            raise AssertionError(msg)
 
    @run_keyword_variant(resolve=0)
    
    def variable_should_not_exist(self, name, msg=None):
        name = self._get_var_name_get_var_name(name)
        msg = self._variables_variables_variables.replace_string(msg) if msg \
            else "Variable %s exists." % name
        try:
            self._variables_variables_variables[name]
        except DataError:
            pass
        else:
            raise AssertionError(msg)
 
    
    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_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, orig):
        name = self._resolve_possible_variable_resolve_possible_variable(orig)
        try:
            return self._unescape_variable_if_needed_unescape_variable_if_needed(name)
        except ValueError:
            raise RuntimeError("Invalid variable syntax '%s'." % orig)
 
    def _resolve_possible_variable(self, name):
        try:
            resolved = self._variables_variables_variables.replace_string(name)
            return self._unescape_variable_if_needed_unescape_variable_if_needed(resolved)
        except (KeyError, ValueError, DataError):
            return name
 
    def _unescape_variable_if_needed(self, name):
        if name.startswith('\\'):
            name = name[1:]
        if len(name) < 2:
            raise ValueError
        if name[0] in '$@&' and name[1] != '{':
            name = '%s{%s}' % (name[0], name[1:])
        if is_var(name):
            return name
        # Support for possible internal variables (issue 397)
        name = '%s{%s}' % (name[0], self.replace_variablesreplace_variables(name[2:-1]))
        if is_var(name):
            return name
        raise ValueError
 
    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 VariableSplitter(values[0]).is_list_variable():
                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=1)
    
    def run_keyword(self, name, *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)
 
    @run_keyword_variant(resolve=0)
    
    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.in_teardown):
                    break
        if errors:
            raise ExecutionFailures(errors)
 
    def _split_run_keywords(self, keywords):
        if 'AND' not in keywords:
            for name in self._variables_variables_variables.replace_list(keywords):
                yield name, ()
        else:
            for name, args in self._split_run_keywords_from_and_split_run_keywords_from_and(keywords):
                yield name, args
 
    def _split_run_keywords_from_and(self, keywords):
        while 'AND' in keywords:
            index = keywords.index('AND')
            yield self._resolve_run_keywords_name_and_args_resolve_run_keywords_name_and_args(keywords[:index])
            keywords = keywords[index+1:]
        yield self._resolve_run_keywords_name_and_args_resolve_run_keywords_name_and_args(keywords)
 
    def _resolve_run_keywords_name_and_args(self, kw_call):
        kw_call = self._variables_variables_variables.replace_list(kw_call, replace_until=1)
        if not kw_call:
            raise DataError('Incorrect use of AND')
        return kw_call[0], kw_call[1:]
 
    @run_keyword_variant(resolve=2)
    
    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=2)
    
    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=1)
    
    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:
                raise
            return 'FAIL', unic(err)
 
    @run_keyword_variant(resolve=1)
    
    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=1)
    
    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=2)
    
    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:
                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, 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=2)
    
    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=3)
    
    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))
        retry_interval = timestr_to_secs(retry_interval)
        while True:
            try:
                return self.run_keywordrun_keyword(name, *args)
            except ExecutionFailed as err:
                if err.dont_continue:
                    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))
                self._sleep_in_parts(retry_interval)
 
    @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_var(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=1)
    
    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 not test.passed:
            return self.run_keywordrun_keyword(name, *args)
 
    @run_keyword_variant(resolve=1)
    
    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=1)
    
    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("Keyword '%s' can only be used in test teardown."
                           % kwname)
 
    @run_keyword_variant(resolve=1)
    
    def run_keyword_if_all_critical_tests_passed(self, name, *args):
        suite = self._get_suite_in_teardown_get_suite_in_teardown('Run Keyword If '
                                            'All Critical Tests Passed')
        if suite.statistics.critical.failed == 0:
            return self.run_keywordrun_keyword(name, *args)
 
    @run_keyword_variant(resolve=1)
    
    def run_keyword_if_any_critical_tests_failed(self, name, *args):
        suite = self._get_suite_in_teardown_get_suite_in_teardown('Run Keyword If '
                                            'Any Critical Tests Failed')
        if suite.statistics.critical.failed > 0:
            return self.run_keywordrun_keyword(name, *args)
 
    @run_keyword_variant(resolve=1)
    
    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.all.failed == 0:
            return self.run_keywordrun_keyword(name, *args)
 
    @run_keyword_variant(resolve=1)
    
    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.all.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 continue_for_loop(self):
        self.log("Continuing for loop from the next iteration.")
        raise ContinueForLoop()
 
    
    def continue_for_loop_if(self, condition):
        if self._is_true_is_true(condition):
            self.continue_for_loopcontinue_for_loop()
 
    
    def exit_for_loop(self):
        self.log("Exiting for loop altogether.")
        raise ExitForLoop()
 
    
    def exit_for_loop_if(self, condition):
        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=1)
    
    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=2)
    
    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 = [unic(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=False, formatter='str'):
        # TODO: Deprecate `repr` in RF 3.2 or latest in RF 3.3.
        if is_truthy(repr):
            formatter = prepr
        else:
            formatter = self._get_formatter_get_formatter(formatter)
        message = formatter(message)
        logger.write(message, level, is_truthy(html))
        if is_truthy(console):
            logger.console(message)
 
    def _get_formatter(self, formatter):
        try:
            return {'str': unic,
                    'repr': prepr,
                    'ascii': ascii if PY3 else repr}[formatter.lower()]
        except KeyError:
            raise ValueError("Invalid formatter '%s'. Available "
                             "'str', 'repr' and 'ascii'." % 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:
            var = VariableSplitter(msg)
            value = self._variables_variables_variables.replace_scalar(msg)
            if var.is_list_variable():
                for item in value:
                    yield item
            elif var.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):
        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(unic(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):
        try:
            self._namespace_namespace_namespace.import_library(name, list(args))
        except DataError as err:
            raise RuntimeError(unic(err))
 
    @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(unic(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(unic(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)
        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):
        if is_string(expression) and '$' in expression:
            expression, variables = self._handle_variables_in_expression_handle_variables_in_expression(expression)
        else:
            variables = {}
        namespace = self._create_evaluation_namespace_create_evaluation_namespace(namespace, modules)
        try:
            if not is_string(expression):
                raise TypeError("Expression must be string, got %s."
                                % type_name(expression))
            if not expression:
                raise ValueError("Expression cannot be empty.")
            return eval(expression, namespace, variables)
        except:
            raise RuntimeError("Evaluating expression '%s' failed: %s"
                               % (expression, get_error_message()))
 
    def _handle_variables_in_expression(self, expression):
        variables = None
        variable_started = False
        tokens = []
        generated = generate_tokens(StringIO(expression).readline)
        for toknum, tokval, _, _, _ in generated:
            if variable_started:
                if toknum == token.NAME:
                    if variables is None:
                        variables = self._variables_variables_variables.as_dict(decoration=False)
                    if tokval not in variables:
                        variable_not_found('$%s' % tokval, variables,
                                           deco_braces=False)
                    tokval = 'RF_VAR_' + tokval
                else:
                    tokens.append((token.ERRORTOKEN, '$'))
                variable_started = False
            if toknum == token.ERRORTOKEN and tokval == '$':
                variable_started = True
            else:
                tokens.append((toknum, tokval))
        if variables is None:
            return expression, {}
        decorated = [('RF_VAR_' + name, variables[name]) for name in variables]
        return untokenize(tokens).strip(), NormalizedDict(decorated, ignore='_')
 
    def _create_evaluation_namespace(self, namespace, modules):
        namespace = dict(namespace or {})
        modules = modules.replace(' ', '').split(',') if modules else []
        namespace.update((m, __import__(m)) for m in modules if m)
        return namespace
 
    
    def call_method(self, object, method_name, *args, **kwargs):
        try:
            method = getattr(object, method_name)
        except AttributeError:
            raise RuntimeError("Object '%s' does not have method '%s'."
                               % (object, method_name))
        try:
            return method(*args, **kwargs)
        except:
            raise RuntimeError("Calling method '%s' failed: %s"
                               % (method_name, get_error_message()))
 
    
    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_unicode(new):
            new = unic(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):
        top = is_truthy(top)
        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):
        top = is_truthy(top)
        if not is_unicode(name):
            name = unic(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 is_truthy(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(unic(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=None,
                         deprecation_warning=True):
    RUN_KW_REGISTER.register_run_keyword(library, keyword, args_to_process,
                                         deprecation_warning)