BuiltIn - Documentation

Version: 2.1.2

Introduction

An always available standard library with often needed keywords.

BuiltIn is Robot Framework's standard library that provides a set of generic keywords needed often. It is imported automatically and thus always available. The provided keywords can be used, for example, for verifications (e.g. Should Be Equal, Should Contain), conversions (e.g. Convert To Integer) and for various other purposes (e.g. Log, Sleep, Run Keyword If, Set Global Variable).

Shortcuts

Call Method  Catenate  Comment  Convert To Boolean  Convert To Integer  Convert To Number  Convert To String  Create List  Evaluate  Fail  Get Count  Get Length  Get Time  Grep  Import Library  Import Variables  Length Should Be  Log  Log Many  Log Variables  No Operation  Regexp Escape  Remove Tags  Repeat Keyword  Replace Variables  Run Keyword  Run Keyword And Expect Error  Run Keyword And Ignore Error  Run Keyword If  Run Keyword If All Critical Tests Passed  Run Keyword If All Tests Passed  Run Keyword If Any Critical Tests Failed  Run Keyword If Any Tests Failed  Run Keyword If Test Failed  Run Keyword If Test Passed  Run Keyword Unless  Set Global Variable  Set Library Search Order  Set Log Level  Set Suite Variable  Set Tags  Set Test Variable  Set Variable  Set Variable If  Should Be Empty  Should Be Equal  Should Be Equal As Integers  Should Be Equal As Numbers  Should Be Equal As Strings  Should Be True  Should Contain  Should Contain X Times  Should End With  Should Match  Should Match Regexp  Should Not Be Empty  Should Not Be Equal  Should Not Be Equal As Integers  Should Not Be Equal As Numbers  Should Not Be Equal As Strings  Should Not Be True  Should Not Contain  Should Not End With  Should Not Match  Should Not Match Regexp  Should Not Start With  Should Start With  Sleep  Syslog  Variable Should Exist  Variable Should Not Exist  Wait Until Keyword Succeeds 

Keywords

Keyword Arguments Documentation
Call Method object, method_name, *args Calls the named method of the given object with the provided arguments.

The possible return value from the method is returned and can be assigned to a variable. Keyword fails both if the object does not have a method with the given name or if executing the method raises an exception.

Examples:
Call Method ${hashtable} put myname myvalue
${isempty} = Call Method ${hashtable} isEmpty
Should Not Be True ${isempty}
${value} = Call Method ${hashtable} get myname
Should Be Equal ${value} myvalue
Catenate *items Catenates the given items together and returns the resulted string.

By default, items are catenated with spaces, but if the first item contains the string 'SEPARATOR=<sep>', the separator '<sep>' is used. Items are converted into strings when necessary.

Examples:
${str1} = Catenate Hello world
${str2} = Catenate SEPARATOR=--- Hello world
${str3} = Catenate SEPARATOR= Hello world
=>
- ${str1} = 'Hello world'
- ${str2} = 'Hello---world'
- ${str3} = 'Helloworld'
Comment *messages Displays the given messages in the log file as keyword arguments.

This keyword does nothing with the arguments it receives, but as they are visible in the log, this keyword can be used to display simple messages. Given arguments are ignored so thoroughly that they can even contain non-existing variables. If you are interested about variable values, you can use the Log or Log Many keywords.
Convert To Boolean item Converts the given item to Boolean true or false.

Handles strings 'True' and 'False' (case-insensitive) as expected, otherwise returns item's truth value using Python's 'bool' method. For more information about truth values, see http://docs.python.org/lib/truth.html.
Convert To Integer item Converts the given item to an integer number.
Convert To Number item Converts the given item to a floating point number.
Convert To String item Converts the given item to a Unicode string.

Uses '__unicode__' or '__str__' method with Python objects and 'toString' with Java objects.
Create List *items Returns a list containing given items.

The returned list can be assigned both to ${scalar} and @{list} variables. The earlier can be used e.g. with Java keywords expecting an array as an argument.

Examples:
@{list} = Create List a b c
${scalar} = Create List a b c
${ints} = Create List ${1} ${2} ${3}
Evaluate expression, modules=None Evaluates the given expression in Python and returns the results.

modules argument can be used to specify a comma separated list of Python modules to be imported and added to the namespace of the evaluated expression.

Examples (expecting ${result} is 3.14):
${status} = Evaluate 0 < ${result} < 10
${down}   = Evaluate int(${result})
${up}     = Evaluate math.ceil(${result}) math
${random} = Evaluate random.randint(0, sys.maxint) random,sys
=>
- ${status} = True
- ${down} = 3
- ${up} = 4.0
- ${random} = <random integer>

Notice that instead of creating complicated expressions, it is recommended to move the logic into a test library.
Fail msg=None Fails the test immediately with the given (optional) message.
Get Count item1, item2 Returns and logs how many times item2 is found from item1.

This keyword works with Python strings and lists and all objects that either have 'count' method or can be converted to Python lists.

Example:
${count} = Get Count ${some item} interesting value
Should Be True 5 < ${count} < 10
Get Length item Returns and logs the length of the given item.

The keyword first tries to get the length with the Python function 'len', which calls the item's '__len__' method internally. If that fails, the keyword tries to call the item's 'length' and 'size' methods directly. The final attempt is trying to get the value of the item's 'length' attribute. If all these attempts are unsuccessful, the keyword fails.
Get Time format=timestamp, time=NOW Returns the given time in the requested format.

How time is returned is determined based on the given format string as follows. Note that all checks are case-insensitive.

1) If format contains the word 'epoch', the time is returned in seconds after the UNIX epoch. The return value is always an integer.

2) If format contains any of the words 'year', 'month', 'day', 'hour', 'min', or 'sec', only the selected parts are returned. The order of the returned parts is always the one in the previous sentence and the order of words in format is not significant. The parts are returned as zero-padded strings (e.g. May -> '05').

3) Otherwise (and by default) the time is returned as a timestamp string in the format '2006-02-24 15:08:31'.

By default this keyword returns the current time, but that can be altered using time argument as explained below. Notice that this argument is only available in Robot Framework 2.1.1 and newer.

1) If time is a floating point number, it is interpreted as seconds since epoch (Jan 1, 1970 0:00:00). This documentation is written about 1177654467 seconds since epoch.

2) If time is a valid timestamp, that time will be used. Valid timestamp formats are 'YYYY-MM-DD hh:mm:ss' and 'YYYYMMDD hhmmss'.

3) If time is equal to 'NOW' (case-insensitive), the current time is used.

4) If time is in the format 'NOW - 1 day' or 'NOW + 1 hour 30 min', the current time plus/minus the time specified with the time string is used. The time string format is described in an appendix of Robot Framework User Guide.

Examples (expecting the current time is 2006-03-29 15:06:21):
${time} = Get Time
${secs} = Get Time epoch
${year} = Get Time return year
${yyyy} ${mm} ${dd} = Get Time year,month,day
@{time} = Get Time year month day hour min sec
${y} ${s} = Get Time seconds and year
=>
- ${time} = '2006-03-29 15:06:21'
- ${secs} = 1143637581
- ${year} = '2006'
- ${yyyy} = '2006', ${mm} = '03', ${dd} = '29'
- @{time} = ['2006', '03', '29', '15', '06', '21']
- ${y} = '2006'
- ${s} = '21'

${time} = Get Time 1177654467
${secs} = Get Time sec 2007-04-27 09:14:27
${year} = Get Time year NOW # The time of execution
${day} = Get Time day NOW - 1d # 1 day subtraced from NOW
@{time} = Get Time hour min sec NOW + 1h 2min 3s # 1h 2min 3s added to NOW
=>
- ${time} = '2007-04-27 09:14:27'
- ${secs} = 27
- ${year} = '2006'
- ${day} = '28'
- @{time} = ['16', '08', '24']
Grep text, pattern, pattern_type=literal string DEPRECATED Use Get Lines Matching XXX keywords from String library instead. This keyword will be removed in Robot Framework 2.2.
Import Library name, *args Imports a library with the given name and optional arguments.

This functionality allows dynamic importing of libraries while tests are running. That may be necessary, if the library itself is dynamic and not yet available when test data is processed. In a normal case, libraries should be imported using the Library setting in the Setting table.

This keyword supports importing libraries both using library names and physical paths. When path are used, they must be given in absolute format. Starting from 2.0.2 version, forward slashes can be used as path separators in all operating systems. It is possible to use arguments as well as to give a custom name with 'WITH NAME' syntax. For more information about importing libraries, see Robot Framework User Guide.

Examples:
Import Library MyLibrary
Import Library ${CURDIR}/Library.py some args
Import Library ${CURDIR}/../libs/Lib.java arg WITH NAME JavaLib
Import Variables path, *args Imports a variable file with the given path and optional arguments.

Variables imported with this keyword are set into the test suite scope similarly when importing them in the Setting table using the Variables setting. These variables override possible existing variables with the same names and this functionality can thus be used to import new variables, e.g. for each test in a test suite.

The given path must be absolute. Starting from 2.0.2 version, forward slashes can be used as path separator regardless the operating system, but on earlier versions ${/} variable must be used instead.

Examples:
Import Variables ${CURDIR}/variables.py
Import Variables ${CURDIR}/../vars/env.py arg1 arg2
Length Should Be item, length, msg=None Verifies that the length of the given item is correct.

The length of the item is got using the Get Length keyword. The default error message can be overridden with the msg argument.
Log message, level=INFO Logs the given message with the given level.

Valid levels are TRACE, DEBUG, INFO (default), HTML and WARN.

HTML level is special because it writes the message into the log file without escaping HTML code from it. For example logging a message like '<img src="image.png">' with that level creates an image, but with other levels you see just that string.  Logging HTML messages should be used with care, because invalid messages can corrupt the whole log file.  The actual log level used for HTML messages is INFO.
Log Many *messages Logs the given messages as separate entries with the INFO level.
Log Variables level=INFO Logs all variables in the current scope with given log level.
No Operation Does absolutely nothing.
Regexp Escape *patterns Returns each argument string escaped for use as a regular expression.

This keyword can be used to escape strings to be used with Should Match Regexp and Should Not Match Regexp keywords.

Escaping is done with Python's re.escape() function.

Examples:
${escaped} = Regexp Escape ${original}
@{strings} = Regexp Escape @{strings}
Remove Tags *tags Removes given tags from the current test or all tests in a suite.

Tags can be given exactly or using a pattern where '*' matches anything and '?' matches one character.

This keyword can affect either one test case or all test cases in a test suite similarly as Set Tags keyword.

Example:
Remove Tags mytag something-* ?ython

New in Robot Framework version 2.0.3.
Repeat Keyword times, name, *args Executes the specified keyword multiple times.

name and args define the keyword that is executed similarly as with Run Keyword, and times specifies how many the keyword should be executed. times can be given as an integer or as a string that can be converted to an integer. It can also have postfix 'times' or 'x' (case and space insensitive) to make the expression easier to read.

If times is zero or negative, the keyword is not executed at all. This keyword fails immediately if any of the execution rounds fails.

Examples:
Repeat Keyword 5 times Goto Previous Page
Repeat Keyword ${var} Some Keyword arg1 arg2
Replace Variables text Replaces variables in the given text with their current values.

If the text contains undefined variables, this keyword fails.

Example:

The file 'template.txt' contains 'Hello ${NAME}!' and variable '${NAME}' has the value 'Robot'.

${template} = Get File ${CURDIR}/template.txt
${message} = Replace Variables ${template}
Should Be Equal ${message} Hello Robot!

If the given text contains only a single variable, its value is returned as-is. Otherwise, and always with Robot Framework 2.0.3 and earlier, this keyword returns a string.
Run Keyword name, *args Executes the given keyword with the given arguments.

Because the name of the keyword to execute is given as an argument, it can be a variable and thus set dynamically, e.g. from a return value of another keyword or from the command line.
Run Keyword And Expect Error expected_error, name, *args Runs the keyword and checks that the expected error occurred.

The expected error must be given in the same format as in Robot Framework reports. It can be a pattern containing characters '?', which matches to any single character and '*', which matches to any number of any characters. name and *args have same semantics as with Run Keyword.

If the expected error occurs, the error message is returned and it can be further processed/tested, if needed. If there is no error, or the error does not match the expected error, this keyword fails.

Examples:
Run Keyword And Expect Error My error Some Keyword arg1 arg2
${msg} = Run Keyword And Expect Error * My KW
Should Start With ${msg} Once upon a time in
Run Keyword And Ignore Error name, *args Runs the given keyword with the given arguments and ignores possible error.

This keyword returns two values, so that the first is either 'PASS' or 'FAIL', depending on the status of the executed keyword. The second value is either the return value of the keyword or the received error message.

The keyword name and arguments work as in Run Keyword. See Run Keyword If for a usage example.
Run Keyword If condition, name, *args Runs the given keyword with the given arguments, if condition is true.

The given condition is evaluated similarly as with Should Be True keyword, and name and *args have same semantics as with Run Keyword.

Example, a simple if/else construct:
${status} ${value} = Run Keyword And Ignore Error My Keyword
Run Keyword If '${status}' == 'PASS' Some Action
Run Keyword Unless '${status}' == 'PASS' Another Action

In this example, only either 'Some Action' or 'Another Action' is executed, based on the status of 'My Keyword'.
Run Keyword If All Critical Tests Passed name, *args Runs the given keyword with the given arguments, if all critical tests passed.

This keyword can only be used in suite teardown. Trying to use it in any other place will result in an error.

Otherwise, this keyword works exactly like Run Keyword, see its documentation for more details.
Run Keyword If All Tests Passed name, *args Runs the given keyword with the given arguments, if all tests passed.

This keyword can only be used in a suite teardown. Trying to use it anywhere else results in an error.

Otherwise, this keyword works exactly like Run Keyword, see its documentation for more details.
Run Keyword If Any Critical Tests Failed name, *args Runs the given keyword with the given arguments, if any critical tests failed.

This keyword can only be used in a suite teardown. Trying to use it anywhere else results in an error.

Otherwise, this keyword works exactly like Run Keyword, see its documentation for more details.
Run Keyword If Any Tests Failed name, *args Runs the given keyword with the given arguments, if one or more tests failed.

This keyword can only be used in a suite teardown. Trying to use it anywhere else results in an error.

Otherwise, this keyword works exactly like Run Keyword, see its documentation for more details.
Run Keyword If Test Failed name, *args Runs the given keyword with the given arguments, if the test failed.

This keyword can only be used in a test teardown. Trying to use it anywhere else results in an error.

Otherwise, this keyword works exactly like Run Keyword, see its documentation for more details.
Run Keyword If Test Passed name, *args Runs the given keyword with the given arguments, if the test passed.

This keyword can only be used in a test teardown. Trying to use it anywhere else results in an error.

Otherwise, this keyword works exactly like Run Keyword, see its documentation for more details.
Run Keyword Unless condition, name, *args Runs the given keyword with the given arguments, if condition is false.

See Run Keyword If for more information and an example.
Set Global Variable name, *values Makes a variable available globally in all tests and suites.

Variables set with this keyword are globally available in all test cases and suites executed after setting them. Setting variables with this keyword thus has the same effect as creating from the command line using the options '--variable' or '--variablefile'. Because this keyword can change variables everywhere, it should be used with care.

See Set Suite Variable for more information and examples.
Set Library Search Order *libraries Sets the resolution order to use when a name matches multiple keywords.

The library search order is used to resolve conflicts when a keyword name in the test data matches multiple keywords. The first library containing the keyword is selected and that keyword implementation used. If keyword is not found from any library, or the library search order is not set, executing the specified keyword fails.

When this keyword is used, there is no need to use the long LibraryName.Keyword Name notation.  For example, instead of having

MyLibrary.Keyword arg
MyLibrary.Another Keyword
MyLibrary.Keyword xxx

you can have

Set Library Search Order MyLibrary
Keyword arg
Another Keyword
Keyword xxx

The library search order is valid only in the suite where this keyword is used in. The old order is returned and can be used to reset the search order later.
Set Log Level level Sets the log threshold to the specified level and returns the old level.

Messages below the level will not logged. The default logging level is INFO, but it can be overridden with the command line option '--loglevel'.

The available levels: TRACE, DEBUG, INFO (default), WARN and NONE (no logging).
Set Suite Variable name, *values Makes a variable available everywhere within the scope of the current suite.

Variables set with this keyword are available everywhere within the scope of the currently executed test suite. Setting variables with this keyword thus has the same effect as creating them using the Variable table in the test data file or importing them from variable files. Other test suites, including possible child test suites, will not see variables set with this keyword.

The name of the variable can be given either as a normal variable name (e.g. ${NAME}) or in escaped format (e.g. \${NAME}). Notice that the former works only in Robot Framework 2.1 and newer.

If a variable already exists within the new scope, its value will be overwritten. Otherwise a new variable is created. If a variable already exists within the current scope, the value can be left empty and the variable within the new scope gets the value within the current scope.

Examples:
Set Suite Variable ${GREET} Hello, world!
${ID} = Get ID
Set Suite Variable ${ID}

NOTE: If the variable has value which itself is a variable (escaped or not), you must always use the escaped format like in the example below. This limitation applies to Set Test/Suite/Global Variable and Variable Should (Not) Exist keywords.

Example:
${NAME} = Set Variable \${variable}
Set Suite Variable ${NAME} new value # Does not work
Set Suite Variable \${NAME} new value # This works
Set Tags *tags Adds given tags for the current test or all tests in a suite.

When this keyword is used inside a test case, that test gets the specified tags and other tests are not affected.

If this keyword is used in a suite setup, all test cases in that suite, recursively, gets the given tags. It is a failure to use this keyword in a suite teardown.

See Remove Tags for another keyword to modify tags at test execution time.

New in Robot Framework version 2.0.3.
Set Test Variable name, *values Makes a variable available everywhere within the scope of the current test.

Variables set with this keyword are available everywhere within the scope of the currently executed test case. For example, if you set a variable in a user keyword, it is available both in the test case level and also in all other user keywords used in the current test. Other test cases will not see variables set with this keyword.

See Set Suite Variable for more information and examples.
Set Variable *values Returns the given values which can then be assigned to a variables.

This keyword is mainly used for setting scalar variables. Additionally it can be used for converting a scalar variable containing a list to a list variable or to multiple scalar variables. It is recommended to use `Create List' when creating new lists.

Examples:
${hi} = Set Variable Hello, world!
${hi2} = Set Variable I said: ${hi}
${var1} ${var2} = Set Variable Hello world
@{list} = Set Variable ${list with some items}
${item1} ${item2} = Set Variable ${list with 2 items}

Variables created with this keyword are available only in the scope where they are created. See Set Global Variable, Set Test Variable and Set Suite Variable for information on how to set variables so that they are available also in a larger scope.
Set Variable If condition, *values Sets variable based on the given condition.

The basic usage is giving a condition and two values. The given condition is first evaluated the same way as with the Should Be True keyword. If the condition is true, then the first value is returned, and otherwise the second value is returned. The second value can also be omitted, in which case it has a default value None. This usage is illustrated in the examples below, where ${rc} is assumed to be zero.

${var1} = Set Variable If ${rc} == 0 zero nonzero
${var2} = Set Variable If ${rc} > 0 value1 value2
${var3} = Set Variable If ${rc} > 0 whatever
=>
- ${var1} = 'zero'
- ${var2} = 'value2'
- ${var3} = None

Starting from Robot Framework 2.0.2 it is also possible to have 'Else If' support by replacing the second value with another condition, and having two new values after it. If the first condition is not true, the second is evaluated and one of the values after it is returned based on its truth value. This can be continued by adding more conditions without a limit.

${var} = Set Variable If ${rc} == 0 zero
... ${rc} > 0 greater than zero less then zero
${var} = Set Variable If
... ${rc} == 0 zero
... ${rc} == 1 one
... ${rc} == 2 two
... ${rc} > 2 greater than two
... ${rc} < 0 less than zero
Should Be Empty item, msg=None Verifies that the given item is empty.

The length of the item is got using the Get Length keyword. The default error message can be overridden with the msg argument.
Should Be Equal first, second, msg=None, values=True Fails if the given objects are unequal.

- If msg is not given, the error message is 'first != second'.
- If msg is given and values is either Boolean False or the string 'False' or 'No Values', the error message is simply msg.
- Otherwise the error message is 'msg: first != second'.
Should Be Equal As Integers first, second, msg=None, values=True Fails if objects are unequal after converting them to integers.

See Should Be Equal for an explanation on how to override the default error message with msg and values.
Should Be Equal As Numbers first, second, msg=None, values=True Fails if objects are unequal after converting them to real numbers.

Starting from Robot Framework 2.0.2, the check for equality is done using six decimal places.

See Should Be Equal for an explanation on how to override the default error message with msg and values.
Should Be Equal As Strings first, second, msg=None, values=True Fails if objects are unequal after converting them to strings.

See Should Be Equal for an explanation on how to override the default error message with msg and values.
Should Be True condition, msg=None Fails if the given condition is not true.

If condition is a string (e.g. '${rc} < 10'), it is evaluated as a Python expression using the built-in 'eval' function and the keyword status is decided based on the result. If a non-string item is given, the status is got directly from its truth value as explained at http://docs.python.org/lib/truth.html.

The default error message ('<condition> should be true') is not very informative, but it can be overridden with the msg argument.

Examples:
Should Be True ${rc} < 10
Should Be True '${status}' == 'PASS' # Strings must be quoted
Should Be True ${number} # Passes if ${number} is not zero
Should Be True ${list} # Passes if ${list} is not empty
Should Contain item1, item2, msg=None, values=True Fails if item1 does not contain item2 one or more times.

Works with strings, lists, and anything that supports Python's 'in' keyword. See Should Be Equal for an explanation on how to override the default error message with msg and values.

Examples:
Should Contain ${output} PASS
Should Contain ${some_list} value
Should Contain X Times item1, item2, count, msg=None Fails if item1 does not contain item2 count times.

Works with strings, lists and all objects that Get Count works with. The default error message can be overridden with msg and the actual count is always logged.

Examples:
Should Contain X Times ${output} hello 2
Should Contain X Times ${some list} value 3
Should End With str1, str2, msg=None, values=True Fails if the string str1 does not end with the string str2.

See Should Be Equal for an explanation on how to override the default error message with msg and values.
Should Match string, pattern, msg=None, values=True Fails unless the given string matches the given pattern.

Pattern matching is similar as matching files in a shell, and it is always case-sensitive. In the pattern, '*' matches to anything and '?' matches to any single character.

See Should Be Equal for an explanation on how to override the default error message with msg and values.
Should Match Regexp string, pattern, msg=None, values=True Fails if string does not match pattern as a regular expression.

Regular expression check is done using the Python 're' module, which has a pattern syntax derived from Perl, and thus also very similar to the one in Java. See the following documents for more details about regular expressions in general and Python implementation in particular.

* http://docs.python.org/lib/module-re.html
* http://www.amk.ca/python/howto/regex/

Things to note about the regexp syntax in Robot Framework test data:

1) Backslash is an escape character in the test data, and possible backslashes in the pattern must thus be escaped with another backslash (e.g. '\\d\\w+').

2) Strings that may contain special characters, but should be handled as literal strings, can be escaped with the Regexp Escape keyword.

3) The given pattern does not need to match the whole string. For example, the pattern 'ello' matches the string 'Hello world!'. If a full match is needed, the '^' and '$' characters can be used to denote the beginning and end of the string, respectively. For example, '^ello$' only matches the exact string 'ello'.

4) Possible flags altering how the expression is parsed (e.g. re.IGNORECASE, re.MULTILINE) can be set by prefixing the pattern with the '(?iLmsux)' group (e.g. '(?im)pattern'). The available flags are 'IGNORECASE': 'i', 'MULTILINE': 'm', 'DOTALL': 's', 'VERBOSE': 'x', 'UNICODE': 'u', and 'LOCALE': 'L'.

If this keyword passes, it returns the portion of the string that matched the pattern. Additionally, the possible captured groups are returned.

See the Should Be Equal keyword for an explanation on how to override the default error message with the msg and values arguments.

Examples:
Should Match Regexp ${output} \\d{6} # Output contains six numbers
Should Match Regexp ${output} ^\\d{6}$ # Six numbers and nothing more
${ret} = Should Match Regexp Foo: 42 (?i)foo: \\d+
${match} ${group1} ${group2} =
... Should Match Regexp Bar: 43 (Foo|Bar): (\\d+)
=>
- ${ret} = 'Foo: 42'
- ${match} = 'Bar: 43'
- ${group1} = 'Bar'
- ${group2} = '43'
Should Not Be Empty item, msg=None Verifies that the given item is not empty.

The length of the item is got using the Get Length keyword. The default error message can be overridden with the msg argument.
Should Not Be Equal first, second, msg=None, values=True Fails if the given objects are equal.

See Should Be Equal for an explanation on how to override the default error message with msg and values.
Should Not Be Equal As Integers first, second, msg=None, values=True Fails if objects are equal after converting them to integers.

See Should Be Equal for an explanation on how to override the default error message with msg and values.
Should Not Be Equal As Numbers first, second, msg=None, values=True Fails if objects are equal after converting them to real numbers.

Starting from Robot Framework 2.0.2, the check for equality is done using six decimal places.

See Should Be Equal for an explanation on how to override the default error message with msg and values.
Should Not Be Equal As Strings first, second, msg=None, values=True Fails if objects are equal after converting them to strings.

See Should Be Equal for an explanation on how to override the default error message with msg and values.
Should Not Be True condition, msg=None Fails if the given condition is true.

See Should Be True for details about how condition is evaluated and how msg can be used to override the default error message.
Should Not Contain item1, item2, msg=None, values=True Fails if item1 contains item2 one or more times.

Works with strings, lists, and anything that supports Python's 'in' keyword. See Should Be Equal for an explanation on how to override the default error message with msg and values.

Examples:
Should Not Contain ${output} FAILED
Should Not Contain ${some_list} value
Should Not End With str1, str2, msg=None, values=True Fails if the string str1 ends with the string str2.

See Should Be Equal for an explanation on how to override the default error message with msg and values.
Should Not Match string, pattern, msg=None, values=True Fails if the given string matches the given pattern.

Pattern matching is similar as matching files in a shell, and it is always case-sensitive. In the pattern '*' matches to anything and '?' matches to any single character.

See Should Be Equal for an explanation on how to override the default error message with msg and values.
Should Not Match Regexp string, pattern, msg=None, values=True Fails if string matches pattern as a regular expression.

See Should Match Regexp for more information about arguments.
Should Not Start With str1, str2, msg=None, values=True Fails if the string str1 starts with the string str2.

See Should Be Equal for an explanation on how to override the default error message with msg and values.
Should Start With str1, str2, msg=None, values=True Fails if the string str1 does not start with the string str2.

See Should Be Equal for an explanation on how to override the default error message with msg and values.
Sleep time, reason=None Pauses the test executed for the given time.

time may be either a number or a time string. Time strings are in a format such as '1 day 2 hours 3 minutes 4 seconds 5milliseconds' or '1d 2h 3m 4s 5ms', and they are fully explained in an appendix of Robot Framework User Guide. Optional reason can be used to explain why sleeping is necessary. Both the time slept and the reason are logged.

Examples:
Sleep 42
Sleep 1.5
Sleep 2 minutes 10 seconds
Sleep 10s Wait for a reply
Syslog message, level=INFO DEPRECATED Use Log keyword with WARN level instead. This keyword will be removed in Robot Framework 2.2.
Variable Should Exist name, msg=None Fails unless the given variable exists within the current scope.

The name of the variable can be given either as a normal variable name (e.g. ${NAME}) or in escaped format (e.g. \${NAME}). Notice that the former works only in Robot Framework 2.1 and newer, and it has some limitations explained in Set Suite Variable.

The default error message can be overridden with the msg argument.
Variable Should Not Exist name, msg=None Fails if the given variable exists within the current scope.

The name of the variable can be given either as a normal variable name (e.g. ${NAME}) or in escaped format (e.g. \${NAME}). Notice that the former works only in Robot Framework 2.1 and newer, and it has some limitations explained in Set Suite Variable.

The default error message can be overridden with the msg argument.
Wait Until Keyword Succeeds timeout, retry_interval, name, *args Waits until the specified keyword succeeds or the given timeout expires.

name and args define the keyword that is executed similarly as with Run Keyword. If the specified keyword does not succeed within timeout, this keyword fails. retry_interval is the time to wait before trying to run the keyword again after the previous run has failed.

Both timeout and retry_interval must be given in Robot Framework's time format (e.g. '1 minute', '2 min 3 s', '4.5').

Example:
Wait Until Keyword Succeeds 2 min 5 sec My keyword arg1 arg2

Altogether 72 keywords.
Generated by libdoc.py on 2009-10-23 13:50:26.