def decorator(method):

RUN_KW_REGISTER.register_run_keyword('BuiltIn', method.__name__,

resolve, deprecation_warning=False)

return method

@property

def _context(self):

return self._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

def _namespace(self):

return self._get_context().namespace

@property

def _variables(self):

return self._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('DEBUG', *args)

def _log_types_at_level(self, level, *args):

msg = ["Argument types are:"] + [self._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'>"

def convert_to_integer(self, item, base=None):

"""Converts the given item to an integer number.

self._log_types(item)

return self._convert_to_integer(item, base)

def _convert_to_integer(self, orig, base=None):

try:

item = self._handle_java_numbers(orig)

item, base = self._get_base(item, base)

if base:

return int(item, self._convert_to_integer(base))

return int(item)

except:

raise RuntimeError("'%s' cannot be converted to an integer: %s"

% (orig, get_error_message()))

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):

"""Converts the given item to a binary string.

return self._convert_to_bin_oct_hex(item, base, prefix, length, 'b')

def convert_to_octal(self, item, base=None, prefix=None, length=None):

"""Converts the given item to an octal string.

return self._convert_to_bin_oct_hex(item, base, prefix, length, 'o')

def convert_to_hex(self, item, base=None, prefix=None, length=None,

lowercase=False):

"""Converts the given item to a hexadecimal string.

spec = 'x' if is_truthy(lowercase) else 'X'

return self._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(item)

ret = format(self._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(length), '0')

return prefix + ret

def convert_to_number(self, item, precision=None):

"""Converts the given item to a floating point number.

self._log_types(item)

return self._convert_to_number(item, precision)

def _convert_to_number(self, item, precision=None):

number = self._convert_to_number_without_precision(item)

if precision is not None:

number = roundup(number, self._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(item)

return float(item)

except:

error = get_error_message()

try:

return float(self._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):

"""Converts the given item to a Unicode string.

self._log_types(item)

return self._convert_to_string(item)

def _convert_to_string(self, item):

return unic(item)

def convert_to_boolean(self, item):

"""Converts the given item to Boolean true or false.

self._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'):

u"""Converts the given ``input`` to bytes according to the ``input_type``.

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(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(integer)

yield self._test_ordinal(ordinal, integer, 'Integer')

def _get_ordinals_from_hex(self, input):

for token in self._input_to_tokens(input, length=2):

ordinal = self._convert_to_integer(token, base=16)

yield self._test_ordinal(ordinal, token, 'Hex value')

def _get_ordinals_from_bin(self, input):

for token in self._input_to_tokens(input, length=8):

ordinal = self._convert_to_integer(token, base=2)

yield self._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):

"""Returns a list containing given items.

return list(items)

@run_keyword_variant(resolve=0)

def create_dictionary(self, *items):

"""Creates and returns a dictionary based on the given ``items``.

separate, combined = self._split_dict_items(items)

result = DotDict(self._format_separate_dict_items(separate))

combined = DictVariableTableValue(combined).resolve(self._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.replace_list(separate)

if len(separate) % 2 != 0:

raise DataError('Expected even number of keys and values, got %d.'

% len(separate))

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):

"""Fails the test with the given message and optionally alters its tags.

self._set_and_remove_tags(tags)

raise AssertionError(msg) if msg else AssertionError()

def fatal_error(self, msg=None):

"""Stops the whole test execution.

error = AssertionError(msg) if msg else AssertionError()

error.ROBOT_EXIT_ON_FAILURE = True

raise error

def should_not_be_true(self, condition, msg=None):

"""Fails if the given condition is true.

if self._is_true(condition):

raise AssertionError(msg or "'%s' should not be true." % condition)

def should_be_true(self, condition, msg=None):

"""Fails if the given condition is not true.

if not self._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'):

"""Fails if the given objects are unequal.

self._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(first, second, msg, values, formatter)

def _should_be_equal(self, first, second, msg, values, formatter='str'):

include_values = self._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(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(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):

"""Fails if the given objects are equal.

self._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(first, second, msg, values)

def _should_not_be_equal(self, first, second, msg, values):

assert_not_equal(first, second, msg, self._include_values(values))

def should_not_be_equal_as_integers(self, first, second, msg=None,

values=True, base=None):

"""Fails if objects are equal after converting them to integers.

self._log_types_at_info_if_different(first, second)

self._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):

"""Fails if objects are unequal after converting them to integers.

self._log_types_at_info_if_different(first, second)

self._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):

"""Fails if objects are equal after converting them to real numbers.

self._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(first, second, msg, values)

def should_be_equal_as_numbers(self, first, second, msg=None, values=True,

precision=6):

"""Fails if objects are unequal after converting them to real numbers.

self._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(first, second, msg, values)

def should_not_be_equal_as_strings(self, first, second, msg=None,

values=True, ignore_case=False):

"""Fails if objects are equal after converting them to strings.

self._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(first, second, msg, values)

def should_be_equal_as_strings(self, first, second, msg=None, values=True,

ignore_case=False, formatter='str'):

"""Fails if objects are unequal after converting them to strings.

self._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(first, second, msg, values, formatter)

def should_not_start_with(self, str1, str2, msg=None, values=True,

ignore_case=False):

"""Fails if the string ``str1`` starts with the string ``str2``.

if is_truthy(ignore_case):

str1 = str1.lower()

str2 = str2.lower()

if str1.startswith(str2):

raise AssertionError(self._get_string_msg(str1, str2, msg, values,

'starts with'))

def should_start_with(self, str1, str2, msg=None, values=True,

ignore_case=False):

"""Fails if the string ``str1`` does not start with the string ``str2``.

if is_truthy(ignore_case):

str1 = str1.lower()

str2 = str2.lower()

if not str1.startswith(str2):

raise AssertionError(self._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):

"""Fails if the string ``str1`` ends with the string ``str2``.

if is_truthy(ignore_case):

str1 = str1.lower()

str2 = str2.lower()

if str1.endswith(str2):

raise AssertionError(self._get_string_msg(str1, str2, msg, values,

'ends with'))

def should_end_with(self, str1, str2, msg=None, values=True,

ignore_case=False):

"""Fails if the string ``str1`` does not end with the string ``str2``.

if is_truthy(ignore_case):

str1 = str1.lower()

str2 = str2.lower()

if not str1.endswith(str2):

raise AssertionError(self._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):

"""Fails if ``container`` contains ``item`` one or more times.

# 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(orig_container, item, msg,

values, 'contains'))

def should_contain(self, container, item, msg=None, values=True,

ignore_case=False):

"""Fails if ``container`` does not contain ``item`` one or more times.

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(orig_container, item, msg,

values, 'does not contain'))

def should_contain_any(self, container, *items, **configuration):

"""Fails if ``container`` does not contain any of the ``*items``.

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(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):