{ "specversion": 3, "name": "BuiltIn", "doc": "An always available standard library with often needed keywords.\n\n``BuiltIn`` is Robot Framework's standard library that provides a set\nof generic keywords needed often. It is imported automatically and\nthus always available. The provided keywords can be used, for example,\nfor verifications (e.g. `Should Be Equal`, `Should Contain`),\nconversions (e.g. `Convert To Integer`) and for various other purposes\n(e.g. `Log`, `Sleep`, `Run Keyword If`, `Set Global Variable`).\n\n== Table of contents ==\n\n- `HTML error messages`\n- `Evaluating expressions`\n- `Using variables with keywords creating or accessing variables`\n- `Boolean arguments`\n- `Pattern matching`\n- `Multiline string comparison`\n- `String representations`\n- `Keywords`\n\n= HTML error messages =\n\nMany of the keywords accept an optional error message to use if the keyword\nfails, and it is possible to use HTML in these messages by prefixing them\nwith ``*HTML*``. See `Fail` keyword for a usage example. Notice that using\nHTML in messages is not limited to BuiltIn library but works with any\nerror message.\n\n= Evaluating expressions =\n\nMany keywords, such as `Evaluate`, `Run Keyword If` and `Should Be True`,\naccept an expression that is evaluated in Python.\n\n== Evaluation namespace ==\n\nExpressions are evaluated using Python's\n[http://docs.python.org/library/functions.html#eval|eval] function so\nthat all Python built-ins like ``len()`` and ``int()`` are available.\nIn addition to that, all unrecognized variables are considered to be\nmodules that are automatically imported. It is possible to use all\navailable Python modules, including the standard modules and the installed\nthird party modules.\n\nExamples:\n| `Should Be True` len('${result}') > 3\n| `Run Keyword If` os.sep == '/' Non-Windows Keyword\n| ${version} = `Evaluate` robot.__version__\n\n`Evaluate` also allows configuring the execution namespace with a custom\nnamespace and with custom modules to be imported. The latter functionality\nis useful in special cases where the automatic module import does not work\nsuch as when using nested modules like ``rootmod.submod`` or list\ncomprehensions. See the documentation of the `Evaluate` keyword for mode\ndetails.\n\n== Variables in expressions ==\n\nWhen a variable is used in the expressing using the normal ``${variable}``\nsyntax, its value is replaced before the expression is evaluated. This\nmeans that the value used in the expression will be the string\nrepresentation of the variable value, not the variable value itself.\nThis is not a problem with numbers and other objects that have a string\nrepresentation that can be evaluated directly, but with other objects\nthe behavior depends on the string representation. Most importantly,\nstrings must always be quoted, and if they can contain newlines, they must\nbe triple quoted.\n\nExamples:\n| `Should Be True` ${rc} < 10 Return code greater than 10\n| `Run Keyword If` '${status}' == 'PASS' Log Passed\n| `Run Keyword If` 'FAIL' in '''${output}''' Log Output contains FAIL\n\nActual variables values are also available in the evaluation namespace.\nThey can be accessed using special variable syntax without the curly\nbraces like ``$variable``. These variables should never be quoted.\n\nExamples:\n| `Should Be True` $rc < 10 Return code greater than 10\n| `Run Keyword If` $status == 'PASS' `Log` Passed\n| `Run Keyword If` 'FAIL' in $output `Log` Output contains FAIL\n| `Should Be True` len($result) > 1 and $result[1] == 'OK'\n| `Should Be True` $result is not None\n\nUsing the ``$variable`` syntax slows down expression evaluation a little.\nThis should not typically matter, but should be taken into account if\ncomplex expressions are evaluated often and there are strict time\nconstrains.\n\nNotice that instead of creating complicated expressions, it is often better\nto move the logic into a library. That eases maintenance and can also\nenhance execution speed.\n\n= Using variables with keywords creating or accessing variables =\n\nThis library has special keywords `Set Global Variable`, `Set Suite Variable`,\n`Set Test Variable` and `Set Local Variable` for creating variables in\ndifferent scopes. These keywords take the variable name and its value as\narguments. The name can be given using the normal ``${variable}`` syntax or\nin escaped format either like ``$variable`` or ``\\${variable}``. For example,\nthese are typically equivalent and create new suite level variable\n``${name}`` with value ``value``:\n\n| Set Suite Variable ${name} value\n| Set Suite Variable $name value\n| Set Suite Variable \\${name} value\n\nA problem with using the normal ``${variable}`` syntax is that these\nkeywords cannot easily know is the idea to create a variable with exactly\nthat name or does that variable actually contain the name of the variable\nto create. If the variable does not initially exist, it will always be\ncreated. If it exists and its value is a variable name either in the normal\nor in the escaped syntax, variable with _that_ name is created instead.\nFor example, if ``${name}`` variable would exist and contain value\n``$example``, these examples would create different variables:\n\n| Set Suite Variable ${name} value # Creates ${example}.\n| Set Suite Variable $name value # Creates ${name}.\n| Set Suite Variable \\${name} value # Creates ${name}.\n\nBecause the behavior when using the normal ``${variable}`` syntax depends\non the possible existing value of the variable, it is *highly recommended\nto use the escaped ``$variable`` or ``\\${variable}`` format instead*.\n\nThis same problem occurs also with special keywords for accessing variables\n`Get Variable Value`, `Variable Should Exist` and `Variable Should Not Exist`.\n\n*NOTE:* It is recommended to use the ``VAR`` syntax introduced in Robot\nFramework 7.0 for creating variables in different scopes instead of the\n`Set Global/Suite/Test/Local Variable` keywords. It makes creating variables\nuniform and avoids all the problems discussed above.\n\n= Boolean arguments =\n\nSome keywords accept arguments that are handled as Boolean values true or\nfalse. If such an argument is given as a string, it is considered false if\nit is an empty string or equal to ``FALSE``, ``NONE``, ``NO``, ``OFF`` or\n``0``, case-insensitively. Keywords verifying something that allow dropping\nactual and expected values from the possible error message also consider\nstring ``no values`` to be false. Other strings are considered true unless\nthe keyword documentation explicitly states otherwise, and other argument\ntypes are tested using the same\n[http://docs.python.org/library/stdtypes.html#truth|rules as in Python].\n\nTrue examples:\n| `Should Be Equal` ${x} ${y} Custom error values=True # Strings are generally true.\n| `Should Be Equal` ${x} ${y} Custom error values=yes # Same as the above.\n| `Should Be Equal` ${x} ${y} Custom error values=${TRUE} # Python ``True`` is true.\n| `Should Be Equal` ${x} ${y} Custom error values=${42} # Numbers other than 0 are true.\n\nFalse examples:\n| `Should Be Equal` ${x} ${y} Custom error values=False # String ``false`` is false.\n| `Should Be Equal` ${x} ${y} Custom error values=no # Also string ``no`` is false.\n| `Should Be Equal` ${x} ${y} Custom error values=${EMPTY} # Empty string is false.\n| `Should Be Equal` ${x} ${y} Custom error values=${FALSE} # Python ``False`` is false.\n| `Should Be Equal` ${x} ${y} Custom error values=no values # ``no values`` works with ``values`` argument\n\n= Pattern matching =\n\nMany keywords accept arguments as either glob or regular expression patterns.\n\n== Glob patterns ==\n\nSome keywords, for example `Should Match`, support so called\n[http://en.wikipedia.org/wiki/Glob_(programming)|glob patterns] where:\n\n| ``*`` | matches any string, even an empty string |\n| ``?`` | matches any single character |\n| ``[chars]`` | matches one character in the bracket |\n| ``[!chars]`` | matches one character not in the bracket |\n| ``[a-z]`` | matches one character from the range in the bracket |\n| ``[!a-z]`` | matches one character not from the range in the bracket |\n\nUnlike with glob patterns normally, path separator characters ``/`` and\n``\\`` and the newline character ``\\n`` are matches by the above\nwildcards.\n\n== Regular expressions ==\n\nSome keywords, for example `Should Match Regexp`, support\n[http://en.wikipedia.org/wiki/Regular_expression|regular expressions]\nthat are more powerful but also more complicated that glob patterns.\nThe regular expression support is implemented using Python's\n[http://docs.python.org/library/re.html|re module] and its documentation\nshould be consulted for more information about the syntax.\n\nBecause the backslash character (``\\``) is an escape character in\nRobot Framework test data, possible backslash characters in regular\nexpressions need to be escaped with another backslash like ``\\\\d\\\\w+``.\nStrings that may contain special characters but should be handled\nas literal strings, can be escaped with the `Regexp Escape` keyword.\n\n= Multiline string comparison =\n\n`Should Be Equal` and `Should Be Equal As Strings` report the failures using\n[http://en.wikipedia.org/wiki/Diff_utility#Unified_format|unified diff\nformat] if both strings have more than two lines.\n\nExample:\n| ${first} = `Catenate` SEPARATOR=\\n Not in second Same Differs Same\n| ${second} = `Catenate` SEPARATOR=\\n Same Differs2 Same Not in first\n| `Should Be Equal` ${first} ${second}\n\nResults in the following error message:\n\n| Multiline strings are different:\n| --- first\n| +++ second\n| @@ -1,4 +1,4 @@\n| -Not in second\n| Same\n| -Differs\n| +Differs2\n| Same\n| +Not in first\n\n= String representations =\n\nSeveral keywords log values explicitly (e.g. `Log`) or implicitly (e.g.\n`Should Be Equal` when there are failures). By default, keywords log values\nusing human-readable string representation, which means that strings\nlike ``Hello`` and numbers like ``42`` are logged as-is. Most of the time\nthis is the desired behavior, but there are some problems as well:\n\n- It is not possible to see difference between different objects that\n have the same string representation like string ``42`` and integer ``42``.\n `Should Be Equal` and some other keywords add the type information to\n the error message in these cases, though.\n\n- Non-printable characters such as the null byte are not visible.\n\n- Trailing whitespace is not visible.\n\n- Different newlines (``\\r\\n`` on Windows, ``\\n`` elsewhere) cannot\n be separated from each others.\n\n- There are several Unicode characters that are different but look the\n same. One example is the Latin ``a`` (``\\u0061``) and the Cyrillic\n ``\u0430`` (``\\u0430``). Error messages like ``a != \u0430`` are not very helpful.\n\n- Some Unicode characters can be represented using\n [https://en.wikipedia.org/wiki/Unicode_equivalence|different forms].\n For example, ``\u00e4`` can be represented either as a single code point\n ``\\u00e4`` or using two combined code points ``\\u0061`` and ``\\u0308``.\n Such forms are considered canonically equivalent, but strings\n containing them are not considered equal when compared in Python. Error\n messages like ``\u00e4 != \u00e4`` are not that helpful either.\n\n- Containers such as lists and dictionaries are formatted into a single\n line making it hard to see individual items they contain.\n\nTo overcome the above problems, some keywords such as `Log` and\n`Should Be Equal` have an optional ``formatter`` argument that can be\nused to configure the string representation. The supported values are\n``str`` (default), ``repr``, and ``ascii`` that work similarly as\n[https://docs.python.org/library/functions.html|Python built-in functions]\nwith same names. More detailed semantics are explained below.\n\n== str ==\n\nUse the human-readable string representation. Equivalent to using ``str()``\nin Python. This is the default.\n\n== repr ==\n\nUse the machine-readable string representation. Similar to using ``repr()``\nin Python, which means that strings like ``Hello`` are logged like\n``'Hello'``, newlines and non-printable characters are escaped like ``\\n``\nand ``\\x00``, and so on. Non-ASCII characters are shown as-is like ``\u00e4``.\n\nIn this mode bigger lists, dictionaries and other containers are\npretty-printed so that there is one item per row.\n\n== ascii ==\n\nSame as using ``ascii()`` in Python. Similar to using ``repr`` explained above\nbut with the following differences:\n\n- Non-ASCII characters are escaped like ``\\xe4`` instead of\n showing them as-is like ``\u00e4``. This makes it easier to see differences\n between Unicode characters that look the same but are not equal.\n- Containers are not pretty-printed.", "version": "7.2.dev1", "generated": "2024-10-02T23:00:46+00:00", "type": "LIBRARY", "scope": "GLOBAL", "docFormat": "ROBOT", "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3755, "tags": [], "inits": [], "keywords": [ { "name": "Call Method", "args": [ { "name": "object", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "object" }, { "name": "method_name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "method_name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" }, { "name": "kwargs", "type": null, "defaultValue": null, "kind": "VAR_NAMED", "required": false, "repr": "**kwargs" } ], "returnType": null, "doc": "Calls the named method of the given object with the provided arguments.\n\nThe possible return value from the method is returned and can be\nassigned to a variable. Keyword fails both if the object does not have\na method with the given name or if executing the method raises an\nexception.\n\nPossible equal signs in arguments must be escaped with a backslash\nlike ``\\=``.\n\nExamples:\n| Call Method | ${hashtable} | put | myname | myvalue |\n| ${isempty} = | Call Method | ${hashtable} | isEmpty | |\n| Should Not Be True | ${isempty} | | | |\n| ${value} = | Call Method | ${hashtable} | get | myname |\n| Should Be Equal | ${value} | myvalue | | |\n| Call Method | ${object} | kwargs | name=value | foo=bar |\n| Call Method | ${object} | positional | escaped\\=equals |", "shortdoc": "Calls the named method of the given object with the provided arguments.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3504 }, { "name": "Catenate", "args": [ { "name": "items", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*items" } ], "returnType": null, "doc": "Catenates the given items together and returns the resulted string.\n\nBy default, items are catenated with spaces, but if the first item\ncontains the string ``SEPARATOR=``, the separator ```` is\nused instead. Items are converted into strings when necessary.\n\nExamples:\n| ${str1} = | Catenate | Hello | world | |\n| ${str2} = | Catenate | SEPARATOR=--- | Hello | world |\n| ${str3} = | Catenate | SEPARATOR= | Hello | world |\n=>\n| ${str1} = 'Hello world'\n| ${str2} = 'Hello---world'\n| ${str3} = 'Helloworld'", "shortdoc": "Catenates the given items together and returns the resulted string.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2998 }, { "name": "Comment", "args": [ { "name": "messages", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*messages" } ], "returnType": null, "doc": "Displays the given messages in the log file as keyword arguments.\n\nThis keyword does nothing with the arguments it receives, but as they\nare visible in the log, this keyword can be used to display simple\nmessages. Given arguments are ignored so thoroughly that they can even\ncontain non-existing variables. If you are interested about variable\nvalues, you can use the `Log` or `Log Many` keywords.", "shortdoc": "Displays the given messages in the log file as keyword arguments.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3168 }, { "name": "Continue For Loop", "args": [], "returnType": null, "doc": "Skips the current FOR loop iteration and continues from the next.\n\n---\n\n*NOTE:* Robot Framework 5.0 added support for native ``CONTINUE`` statement that\nis recommended over this keyword. In the examples below, ``Continue For Loop``\ncan simply be replaced with ``CONTINUE``. In addition to that, native ``IF``\nsyntax (new in RF 4.0) or inline ``IF`` syntax (new in RF 5.0) can be used\ninstead of ``Run Keyword If``. For example, the first example below could be\nwritten like this instead:\n\n| IF '${var}' == 'CONTINUE' CONTINUE\n\nThis keyword will eventually be deprecated and removed.\n\n---\n\nSkips the remaining keywords in the current FOR loop iteration and\ncontinues from the next one. Starting from Robot Framework 5.0, this\nkeyword can only be used inside a loop, not in a keyword used in a loop.\n\nExample:\n| FOR | ${var} | IN | @{VALUES} |\n| | Run Keyword If | '${var}' == 'CONTINUE' | Continue For Loop |\n| | Do Something | ${var} |\n| END |\n\nSee `Continue For Loop If` to conditionally continue a FOR loop without\nusing `Run Keyword If` or other wrapper keywords.", "shortdoc": "Skips the current FOR loop iteration and continues from the next.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2601 }, { "name": "Continue For Loop If", "args": [ { "name": "condition", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "condition" } ], "returnType": null, "doc": "Skips the current FOR loop iteration if the ``condition`` is true.\n\n---\n\n*NOTE:* Robot Framework 5.0 added support for native ``CONTINUE`` statement\nand for inline ``IF``, and that combination should be used instead of this\nkeyword. For example, ``Continue For Loop If`` usage in the example below\ncould be replaced with\n\n| IF '${var}' == 'CONTINUE' CONTINUE\n\nThis keyword will eventually be deprecated and removed.\n\n---\n\nA wrapper for `Continue For Loop` to continue a FOR loop based on\nthe given condition. The condition is evaluated using the same\nsemantics as with `Should Be True` keyword.\n\nExample:\n| FOR | ${var} | IN | @{VALUES} |\n| | Continue For Loop If | '${var}' == 'CONTINUE' |\n| | Do Something | ${var} |\n| END |", "shortdoc": "Skips the current FOR loop iteration if the ``condition`` is true.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2637 }, { "name": "Convert To Binary", "args": [ { "name": "item", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "item" }, { "name": "base", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "base=None" }, { "name": "prefix", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "prefix=None" }, { "name": "length", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "length=None" } ], "returnType": null, "doc": "Converts the given item to a binary string.\n\nThe ``item``, with an optional ``base``, is first converted to an\ninteger using `Convert To Integer` internally. After that it\nis converted to a binary number (base 2) represented as a\nstring such as ``1011``.\n\nThe returned value can contain an optional ``prefix`` and can be\nrequired to be of minimum ``length`` (excluding the prefix and a\npossible minus sign). If the value is initially shorter than\nthe required length, it is padded with zeros.\n\nExamples:\n| ${result} = | Convert To Binary | 10 | | | # Result is 1010 |\n| ${result} = | Convert To Binary | F | base=16 | prefix=0b | # Result is 0b1111 |\n| ${result} = | Convert To Binary | -2 | prefix=B | length=4 | # Result is -B0010 |\n\nSee also `Convert To Integer`, `Convert To Octal` and `Convert To Hex`.", "shortdoc": "Converts the given item to a binary string.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 173 }, { "name": "Convert To Boolean", "args": [ { "name": "item", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "item" } ], "returnType": null, "doc": "Converts the given item to Boolean true or false.\n\nHandles strings ``True`` and ``False`` (case-insensitive) as expected,\notherwise returns item's\n[http://docs.python.org/library/stdtypes.html#truth|truth value]\nusing Python's ``bool()`` method.", "shortdoc": "Converts the given item to Boolean true or false.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 320 }, { "name": "Convert To Bytes", "args": [ { "name": "input", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "input" }, { "name": "input_type", "type": null, "defaultValue": "text", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "input_type=text" } ], "returnType": null, "doc": "Converts the given ``input`` to bytes according to the ``input_type``.\n\nValid input types are listed below:\n\n- ``text:`` Converts text to bytes character by character. All\n characters with ordinal below 256 can be used and are converted to\n bytes with same values. Many characters are easiest to represent\n using escapes like ``\\x00`` or ``\\xff``. Supports both Unicode\n strings and bytes.\n\n- ``int:`` Converts integers separated by spaces to bytes. Similarly as\n with `Convert To Integer`, it is possible to use binary, octal, or\n hex values by prefixing the values with ``0b``, ``0o``, or ``0x``,\n respectively.\n\n- ``hex:`` Converts hexadecimal values to bytes. Single byte is always\n two characters long (e.g. ``01`` or ``FF``). Spaces are ignored and\n can be used freely as a visual separator.\n\n- ``bin:`` Converts binary values to bytes. Single byte is always eight\n characters long (e.g. ``00001010``). Spaces are ignored and can be\n used freely as a visual separator.\n\nIn addition to giving the input as a string, it is possible to use\nlists or other iterables containing individual characters or numbers.\nIn that case numbers do not need to be padded to certain length and\nthey cannot contain extra spaces.\n\nExamples (last column shows returned bytes):\n| ${bytes} = | Convert To Bytes | hyv\u00e4 | | # hyv\\xe4 |\n| ${bytes} = | Convert To Bytes | hyv\\xe4 | | # hyv\\xe4 |\n| ${bytes} = | Convert To Bytes | \\xff\\x07 | | # \\xff\\x07 |\n| ${bytes} = | Convert To Bytes | 82 70 | int | # RF |\n| ${bytes} = | Convert To Bytes | 0b10 0x10 | int | # \\x02\\x10 |\n| ${bytes} = | Convert To Bytes | ff 00 07 | hex | # \\xff\\x00\\x07 |\n| ${bytes} = | Convert To Bytes | 52462121 | hex | # RF!! |\n| ${bytes} = | Convert To Bytes | 0000 1000 | bin | # \\x08 |\n| ${input} = | Create List | 1 | 2 | 12 |\n| ${bytes} = | Convert To Bytes | ${input} | int | # \\x01\\x02\\x0c |\n| ${bytes} = | Convert To Bytes | ${input} | hex | # \\x01\\x02\\x12 |\n\nUse `Encode String To Bytes` in ``String`` library if you need to\nconvert text to bytes using a certain encoding.", "shortdoc": "Converts the given ``input`` to bytes according to the ``input_type``.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 336 }, { "name": "Convert To Hex", "args": [ { "name": "item", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "item" }, { "name": "base", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "base=None" }, { "name": "prefix", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "prefix=None" }, { "name": "length", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "length=None" }, { "name": "lowercase", "type": null, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "lowercase=False" } ], "returnType": null, "doc": "Converts the given item to a hexadecimal string.\n\nThe ``item``, with an optional ``base``, is first converted to an\ninteger using `Convert To Integer` internally. After that it\nis converted to a hexadecimal number (base 16) represented as\na string such as ``FF0A``.\n\nThe returned value can contain an optional ``prefix`` and can be\nrequired to be of minimum ``length`` (excluding the prefix and a\npossible minus sign). If the value is initially shorter than\nthe required length, it is padded with zeros.\n\nBy default the value is returned as an upper case string, but the\n``lowercase`` argument a true value (see `Boolean arguments`) turns\nthe value (but not the given prefix) to lower case.\n\nExamples:\n| ${result} = | Convert To Hex | 255 | | | # Result is FF |\n| ${result} = | Convert To Hex | -10 | prefix=0x | length=2 | # Result is -0x0A |\n| ${result} = | Convert To Hex | 255 | prefix=X | lowercase=yes | # Result is Xff |\n\nSee also `Convert To Integer`, `Convert To Binary` and `Convert To Octal`.", "shortdoc": "Converts the given item to a hexadecimal string.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 217 }, { "name": "Convert To Integer", "args": [ { "name": "item", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "item" }, { "name": "base", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "base=None" } ], "returnType": null, "doc": "Converts the given item to an integer number.\n\nIf the given item is a string, it is by default expected to be an\ninteger in base 10. There are two ways to convert from other bases:\n\n- Give base explicitly to the keyword as ``base`` argument.\n\n- Prefix the given string with the base so that ``0b`` means binary\n (base 2), ``0o`` means octal (base 8), and ``0x`` means hex (base 16).\n The prefix is considered only when ``base`` argument is not given and\n may itself be prefixed with a plus or minus sign.\n\nThe syntax is case-insensitive and possible spaces are ignored.\n\nExamples:\n| ${result} = | Convert To Integer | 100 | | # Result is 100 |\n| ${result} = | Convert To Integer | FF AA | 16 | # Result is 65450 |\n| ${result} = | Convert To Integer | 100 | 8 | # Result is 64 |\n| ${result} = | Convert To Integer | -100 | 2 | # Result is -4 |\n| ${result} = | Convert To Integer | 0b100 | | # Result is 4 |\n| ${result} = | Convert To Integer | -0x100 | | # Result is -256 |\n\nSee also `Convert To Number`, `Convert To Binary`, `Convert To Octal`,\n`Convert To Hex`, and `Convert To Bytes`.", "shortdoc": "Converts the given item to an integer number.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 120 }, { "name": "Convert To Number", "args": [ { "name": "item", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "item" }, { "name": "precision", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "precision=None" } ], "returnType": null, "doc": "Converts the given item to a floating point number.\n\nIf the optional ``precision`` is positive or zero, the returned number\nis rounded to that number of decimal digits. Negative precision means\nthat the number is rounded to the closest multiple of 10 to the power\nof the absolute precision. If a number is equally close to a certain\nprecision, it is always rounded away from zero.\n\nExamples:\n| ${result} = | Convert To Number | 42.512 | | # Result is 42.512 |\n| ${result} = | Convert To Number | 42.512 | 1 | # Result is 42.5 |\n| ${result} = | Convert To Number | 42.512 | 0 | # Result is 43.0 |\n| ${result} = | Convert To Number | 42.512 | -1 | # Result is 40.0 |\n\nNotice that machines generally cannot store floating point numbers\naccurately. This may cause surprises with these numbers in general\nand also when they are rounded. For more information see, for example,\nthese resources:\n\n- http://docs.python.org/tutorial/floatingpoint.html\n- http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition\n\nIf you want to avoid possible problems with floating point numbers,\nyou can implement custom keywords using Python's\n[http://docs.python.org/library/decimal.html|decimal] or\n[http://docs.python.org/library/fractions.html|fractions] modules.\n\nIf you need an integer number, use `Convert To Integer` instead.", "shortdoc": "Converts the given item to a floating point number.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 256 }, { "name": "Convert To Octal", "args": [ { "name": "item", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "item" }, { "name": "base", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "base=None" }, { "name": "prefix", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "prefix=None" }, { "name": "length", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "length=None" } ], "returnType": null, "doc": "Converts the given item to an octal string.\n\nThe ``item``, with an optional ``base``, is first converted to an\ninteger using `Convert To Integer` internally. After that it\nis converted to an octal number (base 8) represented as a\nstring such as ``775``.\n\nThe returned value can contain an optional ``prefix`` and can be\nrequired to be of minimum ``length`` (excluding the prefix and a\npossible minus sign). If the value is initially shorter than\nthe required length, it is padded with zeros.\n\nExamples:\n| ${result} = | Convert To Octal | 10 | | | # Result is 12 |\n| ${result} = | Convert To Octal | -F | base=16 | prefix=0 | # Result is -017 |\n| ${result} = | Convert To Octal | 16 | prefix=oct | length=4 | # Result is oct0020 |\n\nSee also `Convert To Integer`, `Convert To Binary` and `Convert To Hex`.", "shortdoc": "Converts the given item to an octal string.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 195 }, { "name": "Convert To String", "args": [ { "name": "item", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "item" } ], "returnType": null, "doc": "Converts the given item to a Unicode string.\n\nStrings are also [https://en.wikipedia.org/wiki/Unicode_equivalence|\nNFC normalized].\n\nUse `Encode String To Bytes` and `Decode Bytes To String` keywords\nin ``String`` library if you need to convert between Unicode and byte\nstrings using different encodings. Use `Convert To Bytes` if you just\nwant to create byte strings.", "shortdoc": "Converts the given item to a Unicode string.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 306 }, { "name": "Create Dictionary", "args": [ { "name": "items", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*items" } ], "returnType": null, "doc": "Creates and returns a dictionary based on the given ``items``.\n\nItems are typically given using the ``key=value`` syntax same way as\n``&{dictionary}`` variables are created in the Variable table. Both\nkeys and values can contain variables, and possible equal sign in key\ncan be escaped with a backslash like ``escaped\\=key=value``. It is\nalso possible to get items from existing dictionaries by simply using\nthem like ``&{dict}``.\n\nAlternatively items can be specified so that keys and values are given\nseparately. This and the ``key=value`` syntax can even be combined,\nbut separately given items must be first. If same key is used multiple\ntimes, the last value has precedence.\n\nThe returned dictionary is ordered, and values with strings as keys\ncan also be accessed using a convenient dot-access syntax like\n``${dict.key}``. Technically the returned dictionary is Robot\nFramework's own ``DotDict`` instance. If there is a need, it can be\nconverted into a regular Python ``dict`` instance by using the\n`Convert To Dictionary` keyword from the Collections library.\n\nExamples:\n| &{dict} = | Create Dictionary | key=value | foo=bar | | | # key=value syntax |\n| Should Be True | ${dict} == {'key': 'value', 'foo': 'bar'} |\n| &{dict2} = | Create Dictionary | key | value | foo | bar | # separate key and value |\n| Should Be Equal | ${dict} | ${dict2} |\n| &{dict} = | Create Dictionary | ${1}=${2} | &{dict} | foo=new | | # using variables |\n| Should Be True | ${dict} == {1: 2, 'key': 'value', 'foo': 'new'} |\n| Should Be Equal | ${dict.key} | value | | | | # dot-access |", "shortdoc": "Creates and returns a dictionary based on the given ``items``.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 441 }, { "name": "Create List", "args": [ { "name": "items", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*items" } ], "returnType": null, "doc": "Returns a list containing given items.\n\nThe returned list can be assigned both to ``${scalar}`` and ``@{list}``\nvariables.\n\nExamples:\n| @{list} = | Create List | a | b | c |\n| ${scalar} = | Create List | a | b | c |\n| ${ints} = | Create List | ${1} | ${2} | ${3} |", "shortdoc": "Returns a list containing given items.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 427 }, { "name": "Evaluate", "args": [ { "name": "expression", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "expression" }, { "name": "modules", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "modules=None" }, { "name": "namespace", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "namespace=None" } ], "returnType": null, "doc": "Evaluates the given expression in Python and returns the result.\n\n``expression`` is evaluated in Python as explained in the\n`Evaluating expressions` section.\n\n``modules`` argument can be used to specify a comma separated\nlist of Python modules to be imported and added to the evaluation\nnamespace.\n\n``namespace`` argument can be used to pass a custom evaluation\nnamespace as a dictionary. Possible ``modules`` are added to this\nnamespace.\n\nVariables used like ``${variable}`` are replaced in the expression\nbefore evaluation. Variables are also available in the evaluation\nnamespace and can be accessed using the special ``$variable`` syntax\nas explained in the `Evaluating expressions` section.\n\nStarting from Robot Framework 3.2, modules used in the expression are\nimported automatically. There are, however, two cases where they need to\nbe explicitly specified using the ``modules`` argument:\n\n- When nested modules like ``rootmod.submod`` are implemented so that\n the root module does not automatically import sub modules. This is\n illustrated by the ``selenium.webdriver`` example below.\n\n- When using a module in the expression part of a list comprehension.\n This is illustrated by the ``json`` example below.\n\nExamples (expecting ``${result}`` is number 3.14):\n| ${status} = | Evaluate | 0 < ${result} < 10 | # Would also work with string '3.14' |\n| ${status} = | Evaluate | 0 < $result < 10 | # Using variable itself, not string representation |\n| ${random} = | Evaluate | random.randint(0, sys.maxsize) |\n| ${options} = | Evaluate | selenium.webdriver.ChromeOptions() | modules=selenium.webdriver |\n| ${items} = | Evaluate | [json.loads(item) for item in ('1', '\"b\"')] | modules=json |\n| ${ns} = | Create Dictionary | x=${4} | y=${2} |\n| ${result} = | Evaluate | x*10 + y | namespace=${ns} |\n=>\n| ${status} = True\n| ${random} = \n| ${options} = ChromeOptions instance\n| ${items} = [1, 'b']\n| ${result} = 42\n\n*NOTE*: Prior to Robot Framework 3.2 using ``modules=rootmod.submod``\nwas not enough to make the root module itself available in the\nevaluation namespace. It needed to be taken into use explicitly like\n``modules=rootmod, rootmod.submod``.", "shortdoc": "Evaluates the given expression in Python and returns the result.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3448 }, { "name": "Exit For Loop", "args": [], "returnType": null, "doc": "Stops executing the enclosing FOR loop.\n\n---\n\n*NOTE:* Robot Framework 5.0 added support for native ``BREAK`` statement that\nis recommended over this keyword. In the examples below, ``Exit For Loop``\ncan simply be replaced with ``BREAK``. In addition to that, native ``IF``\nsyntax (new in RF 4.0) or inline ``IF`` syntax (new in RF 5.0) can be used\ninstead of ``Run Keyword If``. For example, the first example below could be\nwritten like this instead:\n\n| IF '${var}' == 'EXIT' BREAK\n\nThis keyword will eventually be deprecated and removed.\n\n---\n\nExits the enclosing FOR loop and continues execution after it. Starting\nfrom Robot Framework 5.0, this keyword can only be used inside a loop,\nnot in a keyword used in a loop.\n\nExample:\n| FOR | ${var} | IN | @{VALUES} |\n| | Run Keyword If | '${var}' == 'EXIT' | Exit For Loop |\n| | Do Something | ${var} |\n| END |\n\nSee `Exit For Loop If` to conditionally exit a FOR loop without\nusing `Run Keyword If` or other wrapper keywords.", "shortdoc": "Stops executing the enclosing FOR loop.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2668 }, { "name": "Exit For Loop If", "args": [ { "name": "condition", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "condition" } ], "returnType": null, "doc": "Stops executing the enclosing FOR loop if the ``condition`` is true.\n\n---\n\n*NOTE:* Robot Framework 5.0 added support for native ``BREAK`` statement\nand for inline ``IF``, and that combination should be used instead of this\nkeyword. For example, ``Exit For Loop If`` usage in the example below\ncould be replaced with\n\n| IF '${var}' == 'EXIT' BREAK\n\nThis keyword will eventually be deprecated and removed.\n\n---\n\nA wrapper for `Exit For Loop` to exit a FOR loop based on\nthe given condition. The condition is evaluated using the same\nsemantics as with `Should Be True` keyword.\n\nExample:\n| FOR | ${var} | IN | @{VALUES} |\n| | Exit For Loop If | '${var}' == 'EXIT' |\n| | Do Something | ${var} |\n| END |", "shortdoc": "Stops executing the enclosing FOR loop if the ``condition`` is true.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2704 }, { "name": "Fail", "args": [ { "name": "msg", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "msg=None" }, { "name": "tags", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*tags" } ], "returnType": null, "doc": "Fails the test with the given message and optionally alters its tags.\n\nThe error message is specified using the ``msg`` argument.\nIt is possible to use HTML in the given error message, similarly\nas with any other keyword accepting an error message, by prefixing\nthe error with ``*HTML*``.\n\nIt is possible to modify tags of the current test case by passing tags\nafter the message. Tags starting with a hyphen (e.g. ``-regression``)\nare removed and others added. Tags are modified using `Set Tags` and\n`Remove Tags` internally, and the semantics setting and removing them\nare the same as with these keywords.\n\nExamples:\n| Fail | Test not ready | | | # Fails with the given message. |\n| Fail | *HTML*Test not ready | | | # Fails using HTML in the message. |\n| Fail | Test not ready | not-ready | | # Fails and adds 'not-ready' tag. |\n| Fail | OS not supported | -regression | | # Removes tag 'regression'. |\n| Fail | My message | tag | -t* | # Removes all tags starting with 't' except the newly added 'tag'. |\n\nSee `Fatal Error` if you need to stop the whole test execution.", "shortdoc": "Fails the test with the given message and optionally alters its tags.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 505 }, { "name": "Fatal Error", "args": [ { "name": "msg", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "msg=None" } ], "returnType": null, "doc": "Stops the whole test execution.\n\nThe test or suite where this keyword is used fails with the provided\nmessage, and subsequent tests fail with a canned message.\nPossible teardowns will nevertheless be executed.\n\nSee `Fail` if you only want to stop one test case unconditionally.", "shortdoc": "Stops the whole test execution.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 531 }, { "name": "Get Count", "args": [ { "name": "container", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "container" }, { "name": "item", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "item" } ], "returnType": null, "doc": "Returns and logs how many times ``item`` is found from ``container``.\n\nThis keyword works with Python strings and lists and all objects\nthat either have ``count`` method or can be converted to Python lists.\n\nExample:\n| ${count} = | Get Count | ${some item} | interesting value |\n| Should Be True | 5 < ${count} < 10 |", "shortdoc": "Returns and logs how many times ``item`` is found from ``container``.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 1285 }, { "name": "Get Length", "args": [ { "name": "item", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "item" } ], "returnType": null, "doc": "Returns and logs the length of the given item as an integer.\n\nThe item can be anything that has a length, for example, a string,\na list, or a mapping. The keyword first tries to get the length with\nthe Python function ``len``, which calls the item's ``__len__`` method\ninternally. If that fails, the keyword tries to call the item's\npossible ``length`` and ``size`` methods directly. The final attempt is\ntrying to get the value of the item's ``length`` attribute. If all\nthese attempts are unsuccessful, the keyword fails.\n\nExamples:\n| ${length} = | Get Length | Hello, world! | |\n| Should Be Equal As Integers | ${length} | 13 |\n| @{list} = | Create List | Hello, | world! |\n| ${length} = | Get Length | ${list} | |\n| Should Be Equal As Integers | ${length} | 2 |\n\nSee also `Length Should Be`, `Should Be Empty` and `Should Not Be\nEmpty`.", "shortdoc": "Returns and logs the length of the given item as an integer.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 1400 }, { "name": "Get Library Instance", "args": [ { "name": "name", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "name=None" }, { "name": "all", "type": null, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "all=False" } ], "returnType": null, "doc": "Returns the currently active instance of the specified library.\n\nThis keyword makes it easy for libraries to interact with\nother libraries that have state. This is illustrated by\nthe Python example below:\n\n| from robot.libraries.BuiltIn import BuiltIn\n|\n| def title_should_start_with(expected):\n| seleniumlib = BuiltIn().get_library_instance('SeleniumLibrary')\n| title = seleniumlib.get_title()\n| if not title.startswith(expected):\n| raise AssertionError(f\"Title '{title}' did not start with '{expected}'.\")\n\nIt is also possible to use this keyword in the test data and\npass the returned library instance to another keyword. If a\nlibrary is imported with a custom name, the ``name`` used to get\nthe instance must be that name and not the original library name.\n\nIf the optional argument ``all`` is given a true value, then a\ndictionary mapping all library names to instances will be returned.\n\nExample:\n| &{all libs} = | Get library instance | all=True |", "shortdoc": "Returns the currently active instance of the specified library.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3721 }, { "name": "Get Time", "args": [ { "name": "format", "type": null, "defaultValue": "timestamp", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "format=timestamp" }, { "name": "time_", "type": null, "defaultValue": "NOW", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "time_=NOW" } ], "returnType": null, "doc": "Returns the given time in the requested format.\n\n*NOTE:* DateTime library contains much more flexible keywords for\ngetting the current date and time and for date and time handling in\ngeneral.\n\nHow time is returned is determined based on the given ``format``\nstring as follows. Note that all checks are case-insensitive.\n\n1) If ``format`` contains the word ``epoch``, the time is returned\n in seconds after the UNIX epoch (1970-01-01 00:00:00 UTC).\n The return value is always an integer.\n\n2) If ``format`` contains any of the words ``year``, ``month``,\n ``day``, ``hour``, ``min``, or ``sec``, only the selected parts are\n returned. The order of the returned parts is always the one\n in the previous sentence and the order of words in ``format``\n is not significant. The parts are returned as zero-padded\n strings (e.g. May -> ``05``).\n\n3) Otherwise (and by default) the time is returned as a\n timestamp string in the format ``2006-02-24 15:08:31``.\n\nBy default this keyword returns the current local time, but\nthat can be altered using ``time`` argument as explained below.\nNote that all checks involving strings are case-insensitive.\n\n1) If ``time`` is a number, or a string that can be converted to\n a number, it is interpreted as seconds since the UNIX epoch.\n This documentation was originally written about 1177654467\n seconds after the epoch.\n\n2) If ``time`` is a timestamp, that time will be used. Valid\n timestamp formats are ``YYYY-MM-DD hh:mm:ss`` and\n ``YYYYMMDD hhmmss``.\n\n3) If ``time`` is equal to ``NOW`` (default), the current local\n time is used.\n\n4) If ``time`` is equal to ``UTC``, the current time in\n [http://en.wikipedia.org/wiki/Coordinated_Universal_Time|UTC]\n is used.\n\n5) If ``time`` is in the format like ``NOW - 1 day`` or ``UTC + 1 hour\n 30 min``, the current local/UTC time plus/minus the time\n specified with the time string is used. The time string format\n is described in an appendix of Robot Framework User Guide.\n\nExamples (expecting the current local time is 2006-03-29 15:06:21):\n| ${time} = | Get Time | | | |\n| ${secs} = | Get Time | epoch | | |\n| ${year} = | Get Time | return year | | |\n| ${yyyy} | ${mm} | ${dd} = | Get Time | year,month,day |\n| @{time} = | Get Time | year month day hour min sec | | |\n| ${y} | ${s} = | Get Time | seconds and year | |\n=>\n| ${time} = '2006-03-29 15:06:21'\n| ${secs} = 1143637581\n| ${year} = '2006'\n| ${yyyy} = '2006', ${mm} = '03', ${dd} = '29'\n| @{time} = ['2006', '03', '29', '15', '06', '21']\n| ${y} = '2006'\n| ${s} = '21'\n\nExamples (expecting the current local time is 2006-03-29 15:06:21 and\nUTC time is 2006-03-29 12:06:21):\n| ${time} = | Get Time | | 1177654467 | # Time given as epoch seconds |\n| ${secs} = | Get Time | sec | 2007-04-27 09:14:27 | # Time given as a timestamp |\n| ${year} = | Get Time | year | NOW | # The local time of execution |\n| @{time} = | Get Time | hour min sec | NOW + 1h 2min 3s | # 1h 2min 3s added to the local time |\n| @{utc} = | Get Time | hour min sec | UTC | # The UTC time of execution |\n| ${hour} = | Get Time | hour | UTC - 1 hour | # 1h subtracted from the UTC time |\n=>\n| ${time} = '2007-04-27 09:14:27'\n| ${secs} = 27\n| ${year} = '2006'\n| @{time} = ['16', '08', '24']\n| @{utc} = ['12', '06', '21']\n| ${hour} = '11'", "shortdoc": "Returns the given time in the requested format.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3365 }, { "name": "Get Variable Value", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "default", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "default=None" } ], "returnType": null, "doc": "Returns variable value or ``default`` if the variable does not exist.\n\nThe name of the variable can be given either as a normal variable name\nlike ``${name}`` or in escaped format like ``$name`` or ``\\${name}``.\nFor the reasons explained in the `Using variables with keywords creating\nor accessing variables` section, using the escaped format is recommended.\n\nExamples:\n| ${x} = `Get Variable Value` $a default\n| ${y} = `Get Variable Value` $a ${b}\n| ${z} = `Get Variable Value` $z\n=>\n- ``${x}`` gets value of ``${a}`` if ``${a}`` exists and string ``default`` otherwise\n- ``${y}`` gets value of ``${a}`` if ``${a}`` exists and value of ``${b}`` otherwise\n- ``${z}`` is set to Python ``None`` if it does not exist previously", "shortdoc": "Returns variable value or ``default`` if the variable does not exist.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 1522 }, { "name": "Get Variables", "args": [ { "name": "no_decoration", "type": null, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "no_decoration=False" } ], "returnType": null, "doc": "Returns a dictionary containing all variables in the current scope.\n\nVariables are returned as a special dictionary that allows accessing\nvariables in space, case, and underscore insensitive manner similarly\nas accessing variables in the test data. This dictionary supports all\nsame operations as normal Python dictionaries and, for example,\nCollections library can be used to access or modify it. Modifying the\nreturned dictionary has no effect on the variables available in the\ncurrent scope.\n\nBy default variables are returned with ``${}``, ``@{}`` or ``&{}``\ndecoration based on variable types. Giving a true value (see `Boolean\narguments`) to the optional argument ``no_decoration`` will return\nthe variables without the decoration.\n\nExample:\n| ${example_variable} = | Set Variable | example value |\n| ${variables} = | Get Variables | |\n| Dictionary Should Contain Key | ${variables} | \\${example_variable} |\n| Dictionary Should Contain Key | ${variables} | \\${ExampleVariable} |\n| Set To Dictionary | ${variables} | \\${name} | value |\n| Variable Should Not Exist | \\${name} | | |\n| ${no decoration} = | Get Variables | no_decoration=Yes |\n| Dictionary Should Contain Key | ${no decoration} | example_variable |", "shortdoc": "Returns a dictionary containing all variables in the current scope.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 1492 }, { "name": "Import Library", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "Imports a library with the given name and optional arguments.\n\nThis functionality allows dynamic importing of libraries while tests\nare running. That may be necessary, if the library itself is dynamic\nand not yet available when test data is processed. In a normal case,\nlibraries should be imported using the Library setting in the Setting\nsection.\n\nThis keyword supports importing libraries both using library\nnames and physical paths. When paths are used, they must be\ngiven in absolute format or found from\n[http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#module-search-path|\nsearch path]. Forward slashes can be used as path separators in all\noperating systems.\n\nIt is possible to pass arguments to the imported library and also\nnamed argument syntax works if the library supports it. ``AS``\nsyntax can be used to give a custom name to the imported library.\n\nExamples:\n| Import Library | MyLibrary |\n| Import Library | ${CURDIR}/Lib.py | arg1 | named=arg2 | AS | Custom |", "shortdoc": "Imports a library with the given name and optional arguments.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3222 }, { "name": "Import Resource", "args": [ { "name": "path", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "path" } ], "returnType": null, "doc": "Imports a resource file with the given path.\n\nResources imported with this keyword are set into the test suite scope\nsimilarly when importing them in the Setting table using the Resource\nsetting.\n\nThe given path must be absolute or found from\n[http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#module-search-path|search path].\nForward slashes can be used as path separator regardless\nthe operating system.\n\nExamples:\n| Import Resource | ${CURDIR}/resource.txt |\n| Import Resource | ${CURDIR}/../resources/resource.html |\n| Import Resource | found_from_pythonpath.robot |", "shortdoc": "Imports a resource file with the given path.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3283 }, { "name": "Import Variables", "args": [ { "name": "path", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "path" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "Imports a variable file with the given path and optional arguments.\n\nVariables imported with this keyword are set into the test suite scope\nsimilarly when importing them in the Setting table using the Variables\nsetting. These variables override possible existing variables with\nthe same names. This functionality can thus be used to import new\nvariables, for example, for each test in a test suite.\n\nThe given path must be absolute or found from\n[http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html##module-search-path|search path].\nForward slashes can be used as path separator regardless\nthe operating system.\n\nExamples:\n| Import Variables | ${CURDIR}/variables.py | | |\n| Import Variables | ${CURDIR}/../vars/env.py | arg1 | arg2 |\n| Import Variables | file_from_pythonpath.py | | |", "shortdoc": "Imports a variable file with the given path and optional arguments.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3258 }, { "name": "Keyword Should Exist", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "msg", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "msg=None" } ], "returnType": null, "doc": "Fails unless the given keyword exists in the current scope.\n\nFails also if there is more than one keyword with the same name.\nWorks both with the short name (e.g. ``Log``) and the full name\n(e.g. ``BuiltIn.Log``).\n\nThe default error message can be overridden with the ``msg`` argument.\n\nSee also `Variable Should Exist`.", "shortdoc": "Fails unless the given keyword exists in the current scope.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3347 }, { "name": "Length Should Be", "args": [ { "name": "item", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "item" }, { "name": "length", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "length" }, { "name": "msg", "type": null, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "msg=None" } ], "returnType": null, "doc": "Verifies that the length of the given item is correct.\n\nThe length of the item is got using the `Get Length` keyword. The\ndefault error message can be overridden with the ``msg`` argument.", "shortdoc": "Verifies that the length of the given item is correct.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 1448 }, { "name": "Log", "args": [ { "name": "message", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "message" }, { "name": "level", "type": null, "defaultValue": "INFO", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "level=INFO" }, { "name": "html", "type": null, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "html=False" }, { "name": "console", "type": null, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "console=False" }, { "name": "repr", "type": null, "defaultValue": "DEPRECATED", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "repr=DEPRECATED" }, { "name": "formatter", "type": null, "defaultValue": "str", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "formatter=str" } ], "returnType": null, "doc": "Logs the given message with the given level.\n\nValid levels are TRACE, DEBUG, INFO (default), WARN and ERROR.\nIn addition to that, there are pseudo log levels HTML and CONSOLE that\nboth log messages using INFO.\n\nMessages below the current active log\nlevel are ignored. See `Set Log Level` keyword and ``--loglevel``\ncommand line option for more details about setting the level.\n\nMessages logged with the WARN or ERROR levels are automatically\nvisible also in the console and in the Test Execution Errors section\nin the log file.\n\nIf the ``html`` argument is given a true value (see `Boolean\narguments`) or the HTML pseudo log level is used, the message is\nconsidered to be HTML and special characters\nsuch as ``<`` are not escaped. For example, logging\n```` creates an image in this case, but\notherwise the message is that exact string. When using the HTML pseudo\nlevel, the messages is logged using the INFO level.\n\nIf the ``console`` argument is true or the CONSOLE pseudo level is\nused, the message is written both to the console and to the log file.\nWhen using the CONSOLE pseudo level, the message is logged using the\nINFO level. If the message should not be logged to the log file or there\nare special formatting needs, use the `Log To Console` keyword instead.\n\nThe ``formatter`` argument controls how to format the string\nrepresentation of the message. Possible values are ``str`` (default),\n``repr``, ``ascii``, ``len``, and ``type``. They work similarly to\nPython built-in functions with same names. When using ``repr``, bigger\nlists, dictionaries and other containers are also pretty-printed so\nthat there is one item per row. For more details see `String\nrepresentations`.\n\nThe old way to control string representation was using the ``repr``\nargument. This argument has been deprecated and ``formatter=repr``\nshould be used instead.\n\nExamples:\n| Log | Hello, world! | | | # Normal INFO message. |\n| Log | Warning, world! | WARN | | # Warning. |\n| Log | Hello, world! | html=yes | | # INFO message as HTML. |\n| Log | Hello, world! | HTML | | # Same as above. |\n| Log | Hello, world! | DEBUG | html=true | # DEBUG as HTML. |\n| Log | Hello, console! | console=yes | | # Log also to the console. |\n| Log | Hello, console! | CONSOLE | | # Log also to the console. |\n| Log | Null is \\x00 | formatter=repr | | # Log ``'Null is \\x00'``. |\n\nSee `Log Many` if you want to log multiple messages in one go, and\n`Log To Console` if you only want to write to the console.\n\nFormatter options ``type`` and ``len`` are new in Robot Framework 5.0.\nThe CONSOLE level is new in Robot Framework 6.1.", "shortdoc": "Logs the given message with the given level.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3024 }, { "name": "Log Many", "args": [ { "name": "messages", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*messages" } ], "returnType": null, "doc": "Logs the given messages as separate entries using the INFO level.\n\nSupports also logging list and dictionary variable items individually.\n\nExamples:\n| Log Many | Hello | ${var} |\n| Log Many | @{list} | &{dict} |\n\nSee `Log` and `Log To Console` keywords if you want to use alternative\nlog levels, use HTML, or log to the console.", "shortdoc": "Logs the given messages as separate entries using the INFO level.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3106 }, { "name": "Log To Console", "args": [ { "name": "message", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "message" }, { "name": "stream", "type": null, "defaultValue": "STDOUT", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "stream=STDOUT" }, { "name": "no_newline", "type": null, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "no_newline=False" }, { "name": "format", "type": null, "defaultValue": "", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "format=" } ], "returnType": null, "doc": "Logs the given message to the console.\n\nBy default uses the standard output stream. Using the standard error\nstream is possible by giving the ``stream`` argument value ``STDERR``\n(case-insensitive).\n\nBy default appends a newline to the logged message. This can be\ndisabled by giving the ``no_newline`` argument a true value (see\n`Boolean arguments`).\n\nBy default adds no alignment formatting. The ``format`` argument allows,\nfor example, alignment and customized padding of the log message. Please see the\n[https://docs.python.org/3/library/string.html#formatspec|format specification] for\ndetailed alignment possibilities. This argument is new in Robot\nFramework 5.0.\n\nExamples:\n| Log To Console | Hello, console! | |\n| Log To Console | Hello, stderr! | STDERR |\n| Log To Console | Message starts here and is | no_newline=true |\n| Log To Console | continued without newline. | |\n| Log To Console | center message with * pad | format=*^60 |\n| Log To Console | 30 spaces before msg starts | format=>30 |\n\nThis keyword does not log the message to the normal log file. Use\n`Log` keyword, possibly with argument ``console``, if that is desired.", "shortdoc": "Logs the given message to the console.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3134 }, { "name": "Log Variables", "args": [ { "name": "level", "type": null, "defaultValue": "INFO", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "level=INFO" } ], "returnType": null, "doc": "Logs all variables in the current scope with given log level.", "shortdoc": "Logs all variables in the current scope with given log level.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 1545 }, { "name": "No Operation", "args": [], "returnType": null, "doc": "Does absolutely nothing.", "shortdoc": "Does absolutely nothing.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2958 }, { "name": "Pass Execution", "args": [ { "name": "message", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "message" }, { "name": "tags", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*tags" } ], "returnType": null, "doc": "Skips rest of the current test, setup, or teardown with PASS status.\n\nThis keyword can be used anywhere in the test data, but the place where\nused affects the behavior:\n\n- When used in any setup or teardown (suite, test or keyword), passes\n that setup or teardown. Possible keyword teardowns of the started\n keywords are executed. Does not affect execution or statuses\n otherwise.\n- When used in a test outside setup or teardown, passes that particular\n test case. Possible test and keyword teardowns are executed.\n\nPossible continuable failures before this keyword is used, as well as\nfailures in executed teardowns, will fail the execution.\n\nIt is mandatory to give a message explaining why execution was passed.\nBy default the message is considered plain text, but starting it with\n``*HTML*`` allows using HTML formatting.\n\nIt is also possible to modify test tags passing tags after the message\nsimilarly as with `Fail` keyword. Tags starting with a hyphen\n(e.g. ``-regression``) are removed and others added. Tags are modified\nusing `Set Tags` and `Remove Tags` internally, and the semantics\nsetting and removing them are the same as with these keywords.\n\nExamples:\n| Pass Execution | All features available in this version tested. |\n| Pass Execution | Deprecated test. | deprecated | -regression |\n\nThis keyword is typically wrapped to some other keyword, such as\n`Run Keyword If`, to pass based on a condition. The most common case\ncan be handled also with `Pass Execution If`:\n\n| Run Keyword If | ${rc} < 0 | Pass Execution | Negative values are cool. |\n| Pass Execution If | ${rc} < 0 | Negative values are cool. |\n\nPassing execution in the middle of a test, setup or teardown should be\nused with care. In the worst case it leads to tests that skip all the\nparts that could actually uncover problems in the tested application.\nIn cases where execution cannot continue due to external factors,\nit is often safer to fail the test case and make it non-critical.", "shortdoc": "Skips rest of the current test, setup, or teardown with PASS status.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2884 }, { "name": "Pass Execution If", "args": [ { "name": "condition", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "condition" }, { "name": "message", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "message" }, { "name": "tags", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*tags" } ], "returnType": null, "doc": "Conditionally skips rest of the current test, setup, or teardown with PASS status.\n\nA wrapper for `Pass Execution` to skip rest of the current test,\nsetup or teardown based the given ``condition``. The condition is\nevaluated similarly as with `Should Be True` keyword, and ``message``\nand ``*tags`` have same semantics as with `Pass Execution`.\n\nExample:\n| FOR | ${var} | IN | @{VALUES} |\n| | Pass Execution If | '${var}' == 'EXPECTED' | Correct value was found |\n| | Do Something | ${var} |\n| END |", "shortdoc": "Conditionally skips rest of the current test, setup, or teardown with PASS status.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2936 }, { "name": "Regexp Escape", "args": [ { "name": "patterns", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*patterns" } ], "returnType": null, "doc": "Returns each argument string escaped for use as a regular expression.\n\nThis keyword can be used to escape strings to be used with\n`Should Match Regexp` and `Should Not Match Regexp` keywords.\n\nEscaping is done with Python's ``re.escape()`` function.\n\nExamples:\n| ${escaped} = | Regexp Escape | ${original} |\n| @{strings} = | Regexp Escape | @{strings} |", "shortdoc": "Returns each argument string escaped for use as a regular expression.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3535 }, { "name": "Reload Library", "args": [ { "name": "name_or_instance", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name_or_instance" } ], "returnType": null, "doc": "Rechecks what keywords the specified library provides.\n\nCan be called explicitly in the test data or by a library itself\nwhen keywords it provides have changed.\n\nThe library can be specified by its name or as the active instance of\nthe library. The latter is especially useful if the library itself\ncalls this keyword as a method.", "shortdoc": "Rechecks what keywords the specified library provides.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3208 }, { "name": "Remove Tags", "args": [ { "name": "tags", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*tags" } ], "returnType": null, "doc": "Removes given ``tags`` from the current test or all tests in a suite.\n\nTags can be given exactly or using a pattern with ``*``, ``?`` and\n``[chars]`` acting as wildcards. See the `Glob patterns` section\nfor more information.\n\nThis keyword can affect either one test case or all test cases in a\ntest suite similarly as `Set Tags` keyword.\n\nThe current tags are available as a built-in variable ``@{TEST TAGS}``.\n\nExample:\n| Remove Tags | mytag | something-* | ?ython |\n\nSee `Set Tags` if you want to add certain tags and `Fail` if you want\nto fail the test case after setting and/or removing tags.", "shortdoc": "Removes given ``tags`` from the current test or all tests in a suite.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3693 }, { "name": "Repeat Keyword", "args": [ { "name": "repeat", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "repeat" }, { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "Executes the specified keyword multiple times.\n\n``name`` and ``args`` define the keyword that is executed similarly as\nwith `Run Keyword`. ``repeat`` specifies how many times (as a count) or\nhow long time (as a timeout) the keyword should be executed.\n\nIf ``repeat`` is given as count, it specifies how many times the\nkeyword should be executed. ``repeat`` can be given as an integer or\nas a string that can be converted to an integer. If it is a string,\nit can have postfix ``times`` or ``x`` (case and space insensitive)\nto make the expression more explicit.\n\nIf ``repeat`` is given as timeout, it must be in Robot Framework's\ntime format (e.g. ``1 minute``, ``2 min 3 s``). Using a number alone\n(e.g. ``1`` or ``1.5``) does not work in this context.\n\nIf ``repeat`` is zero or negative, the keyword is not executed at\nall. This keyword fails immediately if any of the execution\nrounds fails.\n\nExamples:\n| Repeat Keyword | 5 times | Go to Previous Page |\n| Repeat Keyword | ${var} | Some Keyword | arg1 | arg2 |\n| Repeat Keyword | 2 minutes | Some Keyword | arg1 | arg2 |", "shortdoc": "Executes the specified keyword multiple times.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2275 }, { "name": "Replace Variables", "args": [ { "name": "text", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "text" } ], "returnType": null, "doc": "Replaces variables in the given text with their current values.\n\nIf the text contains undefined variables, this keyword fails.\nIf the given ``text`` contains only a single variable, its value is\nreturned as-is and it can be any object. Otherwise, this keyword\nalways returns a string.\n\nExample:\n\nThe file ``template.txt`` contains ``Hello ${NAME}!`` and variable\n``${NAME}`` has the value ``Robot``.\n\n| ${template} = | Get File | ${CURDIR}/template.txt |\n| ${message} = | Replace Variables | ${template} |\n| Should Be Equal | ${message} | Hello Robot! |", "shortdoc": "Replaces variables in the given text with their current values.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 1611 }, { "name": "Reset Log Level", "args": [], "returnType": null, "doc": "Resets the log level to the original value.\n\nThe original log level is set from the command line with the ``--loglevel``\noption and is INFO by default. The active log level can be changed using\nthe `Set Log Level` keyword.\n\nNew in Robot Framework 7.0.", "shortdoc": "Resets the log level to the original value.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3196 }, { "name": "Return From Keyword", "args": [ { "name": "return_values", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*return_values" } ], "returnType": null, "doc": "Returns from the enclosing user keyword.\n\n---\n\n*NOTE:* Robot Framework 5.0 added support for native ``RETURN`` statement that\nis recommended over this keyword. In the examples below, ``Return From Keyword``\ncan simply be replaced with ``RETURN``. In addition to that, native ``IF``\nsyntax (new in RF 4.0) or inline ``IF`` syntax (new in RF 5.0) can be used\ninstead of ``Run Keyword If``. For example, the first example below could be\nwritten like this instead:\n\n| IF ${rc} < 0 RETURN\n\nThis keyword will eventually be deprecated and removed.\n\n---\n\nThis keyword can be used to return from a user keyword with PASS status\nwithout executing it fully. It is also possible to return values\nsimilarly as with the ``[Return]`` setting. For more detailed information\nabout working with the return values, see the User Guide.\n\nThis keyword is typically wrapped to some other keyword, such as\n`Run Keyword If`, to return based on a condition:\n\n| Run Keyword If ${rc} < 0 Return From Keyword\n\nIt is possible to use this keyword to return from a keyword also inside\na for loop. That, as well as returning values, is demonstrated by the\n`Find Index` keyword in the following somewhat advanced example.\nNotice that it is often a good idea to move this kind of complicated\nlogic into a library.\n\n| ***** Variables *****\n| @{LIST} = foo baz\n|\n| ***** Test Cases *****\n| Example\n| ${index} = Find Index baz @{LIST}\n| Should Be Equal ${index} ${1}\n| ${index} = Find Index non existing @{LIST}\n| Should Be Equal ${index} ${-1}\n|\n| ***** Keywords *****\n| Find Index\n| [Arguments] ${element} @{items}\n| ${index} = Set Variable ${0}\n| FOR ${item} IN @{items}\n| Run Keyword If '${item}' == '${element}' Return From Keyword ${index}\n| ${index} = Set Variable ${index + 1}\n| END\n| Return From Keyword ${-1}\n\nThe most common use case, returning based on an expression, can be\naccomplished directly with `Return From Keyword If`. See also\n`Run Keyword And Return` and `Run Keyword And Return If`.", "shortdoc": "Returns from the enclosing user keyword.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2736 }, { "name": "Return From Keyword If", "args": [ { "name": "condition", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "condition" }, { "name": "return_values", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*return_values" } ], "returnType": null, "doc": "Returns from the enclosing user keyword if ``condition`` is true.\n\n---\n\n*NOTE:* Robot Framework 5.0 added support for native ``RETURN`` statement\nand for inline ``IF``, and that combination should be used instead of this\nkeyword. For example, ``Return From Keyword`` usage in the example below\ncould be replaced with\n\n| IF '${item}' == '${element}' RETURN ${index}\n\nThis keyword will eventually be deprecated and removed.\n\n---\n\nA wrapper for `Return From Keyword` to return based on the given\ncondition. The condition is evaluated using the same semantics as\nwith `Should Be True` keyword.\n\nGiven the same example as in `Return From Keyword`, we can rewrite the\n`Find Index` keyword as follows:\n\n| ***** Keywords *****\n| Find Index\n| [Arguments] ${element} @{items}\n| ${index} = Set Variable ${0}\n| FOR ${item} IN @{items}\n| Return From Keyword If '${item}' == '${element}' ${index}\n| ${index} = Set Variable ${index + 1}\n| END\n| Return From Keyword ${-1}\n\nSee also `Run Keyword And Return` and `Run Keyword And Return If`.", "shortdoc": "Returns from the enclosing user keyword if ``condition`` is true.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2801 }, { "name": "Run Keyword", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "Executes the given keyword with the given arguments.\n\nBecause the name of the keyword to execute is given as an argument, it\ncan be a variable and thus set dynamically, e.g. from a return value of\nanother keyword or from the command line.", "shortdoc": "Executes the given keyword with the given arguments.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 1904 }, { "name": "Run Keyword And Continue On Failure", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "Runs the keyword and continues execution even if a failure occurs.\n\nThe keyword name and arguments work as with `Run Keyword`.\n\nExample:\n| Run Keyword And Continue On Failure | Fail | This is a stupid example |\n| Log | This keyword is executed |\n\nThe execution is not continued if the failure is caused by invalid syntax,\ntimeout, or fatal exception.", "shortdoc": "Runs the keyword and continues execution even if a failure occurs.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2181 }, { "name": "Run Keyword And Expect Error", "args": [ { "name": "expected_error", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "expected_error" }, { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "Runs the keyword and checks that the expected error occurred.\n\nThe keyword to execute and its arguments are specified using ``name``\nand ``*args`` exactly like with `Run Keyword`.\n\nThe expected error must be given in the same format as in Robot Framework\nreports. By default it is interpreted as a glob pattern with ``*``, ``?``\nand ``[chars]`` as wildcards, but that can be changed by using various\nprefixes explained in the table below. Prefixes are case-sensitive and\nthey must be separated from the actual message with a colon and an\noptional space like ``PREFIX: Message`` or ``PREFIX:Message``.\n\n| = Prefix = | = Explanation = |\n| ``EQUALS`` | Exact match. Especially useful if the error contains glob wildcards. |\n| ``STARTS`` | Error must start with the specified error. |\n| ``REGEXP`` | Regular expression match. |\n| ``GLOB`` | Same as the default behavior. |\n\nSee the `Pattern matching` section for more information about glob\npatterns and regular expressions.\n\nIf the expected error occurs, the error message is returned and it can\nbe further processed or tested if needed. If there is no error, or the\nerror does not match the expected error, this keyword fails.\n\nExamples:\n| Run Keyword And Expect Error | My error | Keyword | arg |\n| Run Keyword And Expect Error | ValueError: * | Some Keyword |\n| Run Keyword And Expect Error | STARTS: ValueError: | Some Keyword |\n| Run Keyword And Expect Error | EQUALS:No match for '//input[@type=\"text\"]' |\n| ... | Find Element | //input[@type=\"text\"] |\n| ${msg} = | Run Keyword And Expect Error | * |\n| ... | Keyword | arg1 | arg2 |\n| Log To Console | ${msg} |\n\nErrors caused by invalid syntax, timeouts, or fatal exceptions are not\ncaught by this keyword.\n\n*NOTE:* Regular expression matching used to require only the beginning\nof the error to match the given pattern. That was changed in Robot\nFramework 5.0 and nowadays the pattern must match the error fully.\nTo match only the beginning, add ``.*`` at the end of the pattern like\n``REGEXP: Start.*``.\n\n*NOTE:* Robot Framework 5.0 introduced native TRY/EXCEPT functionality\nthat is generally recommended for error handling. It supports same\npattern matching syntax as this keyword.", "shortdoc": "Runs the keyword and checks that the expected error occurred.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2201 }, { "name": "Run Keyword And Ignore Error", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "Runs the given keyword with the given arguments and ignores possible error.\n\nThis keyword returns two values, so that the first is either string\n``PASS`` or ``FAIL``, depending on the status of the executed keyword.\nThe second value is either the return value of the keyword or the\nreceived error message. See `Run Keyword And Return Status` If you are\nonly interested in the execution status.\n\nThe keyword name and arguments work as in `Run Keyword`. See\n`Run Keyword If` for a usage example.\n\nErrors caused by invalid syntax, timeouts, or fatal exceptions are not\ncaught by this keyword. Otherwise this keyword itself never fails.\n\n*NOTE:* Robot Framework 5.0 introduced native TRY/EXCEPT functionality\nthat is generally recommended for error handling.", "shortdoc": "Runs the given keyword with the given arguments and ignores possible error.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2115 }, { "name": "Run Keyword And Return", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "Runs the specified keyword and returns from the enclosing user keyword.\n\nThe keyword to execute is defined with ``name`` and ``*args`` exactly\nlike with `Run Keyword`. After running the keyword, returns from the\nenclosing user keyword and passes possible return value from the\nexecuted keyword further. Returning from a keyword has exactly same\nsemantics as with `Return From Keyword`.\n\nExample:\n| `Run Keyword And Return` | `My Keyword` | arg1 | arg2 |\n| # Above is equivalent to: |\n| ${result} = | `My Keyword` | arg1 | arg2 |\n| `Return From Keyword` | ${result} | | |\n\nUse `Run Keyword And Return If` if you want to run keyword and return\nbased on a condition.", "shortdoc": "Runs the specified keyword and returns from the enclosing user keyword.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2840 }, { "name": "Run Keyword And Return If", "args": [ { "name": "condition", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "condition" }, { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "Runs the specified keyword and returns from the enclosing user keyword.\n\nA wrapper for `Run Keyword And Return` to run and return based on\nthe given ``condition``. The condition is evaluated using the same\nsemantics as with `Should Be True` keyword.\n\nExample:\n| `Run Keyword And Return If` | ${rc} > 0 | `My Keyword` | arg1 | arg2 |\n| # Above is equivalent to: |\n| `Run Keyword If` | ${rc} > 0 | `Run Keyword And Return` | `My Keyword ` | arg1 | arg2 |\n\nUse `Return From Keyword If` if you want to return a certain value\nbased on a condition.", "shortdoc": "Runs the specified keyword and returns from the enclosing user keyword.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2866 }, { "name": "Run Keyword And Return Status", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "Runs the given keyword with given arguments and returns the status as a Boolean value.\n\nThis keyword returns Boolean ``True`` if the keyword that is executed\nsucceeds and ``False`` if it fails. This is useful, for example, in\ncombination with `Run Keyword If`. If you are interested in the error\nmessage or return value, use `Run Keyword And Ignore Error` instead.\n\nThe keyword name and arguments work as in `Run Keyword`.\n\nExample:\n| ${passed} = | `Run Keyword And Return Status` | Keyword | args |\n| `Run Keyword If` | ${passed} | Another keyword |\n\nErrors caused by invalid syntax, timeouts, or fatal exceptions are not\ncaught by this keyword. Otherwise this keyword itself never fails.", "shortdoc": "Runs the given keyword with given arguments and returns the status as a Boolean value.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2160 }, { "name": "Run Keyword And Warn On Failure", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "Runs the specified keyword logs a warning if the keyword fails.\n\nThis keyword is similar to `Run Keyword And Ignore Error` but if the executed\nkeyword fails, the error message is logged as a warning to make it more\nvisible. Returns status and possible return value or error message exactly\nlike `Run Keyword And Ignore Error` does.\n\nErrors caused by invalid syntax, timeouts, or fatal exceptions are not\ncaught by this keyword. Otherwise this keyword itself never fails.\n\nNew in Robot Framework 4.0.", "shortdoc": "Runs the specified keyword logs a warning if the keyword fails.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2141 }, { "name": "Run Keyword If", "args": [ { "name": "condition", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "condition" }, { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "Runs the given keyword with the given arguments, if ``condition`` is true.\n\n*NOTE:* Robot Framework 4.0 introduced built-in IF/ELSE support and using\nthat is generally recommended over using this keyword.\n\nThe given ``condition`` is evaluated in Python as explained in the\n`Evaluating expressions` section, and ``name`` and ``*args`` have same\nsemantics as with `Run Keyword`.\n\nExample, a simple if/else construct:\n| `Run Keyword If` | '${status}' == 'OK' | Some Action | arg |\n| `Run Keyword If` | '${status}' != 'OK' | Another Action |\n\nIn this example, only either ``Some Action`` or ``Another Action`` is\nexecuted, based on the value of the ``${status}`` variable.\n\nVariables used like ``${variable}``, as in the examples above, are\nreplaced in the expression before evaluation. Variables are also\navailable in the evaluation namespace and can be accessed using special\n``$variable`` syntax as explained in the `Evaluating expressions` section.\n\nExample:\n| `Run Keyword If` | $result is None or $result == 'FAIL' | Keyword |\n\nThis keyword supports also optional ELSE and ELSE IF branches. Both\nof them are defined in ``*args`` and must use exactly format ``ELSE``\nor ``ELSE IF``, respectively. ELSE branches must contain first the\nname of the keyword to execute and then its possible arguments. ELSE\nIF branches must first contain a condition, like the first argument\nto this keyword, and then the keyword to execute and its possible\narguments. It is possible to have ELSE branch after ELSE IF and to\nhave multiple ELSE IF branches. Nested `Run Keyword If` usage is not\nsupported when using ELSE and/or ELSE IF branches.\n\nGiven previous example, if/else construct can also be created like this:\n| `Run Keyword If` | '${status}' == 'PASS' | Some Action | arg | ELSE | Another Action |\n\nThe return value of this keyword is the return value of the actually\nexecuted keyword or Python ``None`` if no keyword was executed (i.e.\nif ``condition`` was false). Hence, it is recommended to use ELSE\nand/or ELSE IF branches to conditionally assign return values from\nkeyword to variables (see `Set Variable If` you need to set fixed\nvalues conditionally). This is illustrated by the example below:\n\n| ${var1} = | `Run Keyword If` | ${rc} == 0 | Some keyword returning a value |\n| ... | ELSE IF | 0 < ${rc} < 42 | Another keyword |\n| ... | ELSE IF | ${rc} < 0 | Another keyword with args | ${rc} | arg2 |\n| ... | ELSE | Final keyword to handle abnormal cases | ${rc} |\n| ${var2} = | `Run Keyword If` | ${condition} | Some keyword |\n\nIn this example, ${var2} will be set to ``None`` if ${condition} is\nfalse.\n\nNotice that ``ELSE`` and ``ELSE IF`` control words must be used\nexplicitly and thus cannot come from variables. If you need to use\nliteral ``ELSE`` and ``ELSE IF`` strings as arguments, you can escape\nthem with a backslash like ``\\ELSE`` and ``\\ELSE IF``.", "shortdoc": "Runs the given keyword with the given arguments, if ``condition`` is true.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2021 }, { "name": "Run Keyword If All Tests Passed", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "Runs the given keyword with the given arguments, if all tests passed.\n\nThis keyword can only be used in a suite teardown. Trying to use it\nanywhere else results in an error.\n\nOtherwise, this keyword works exactly like `Run Keyword`, see its\ndocumentation for more details.", "shortdoc": "Runs the given keyword with the given arguments, if all tests passed.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2546 }, { "name": "Run Keyword If Any Tests Failed", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "Runs the given keyword with the given arguments, if one or more tests failed.\n\nThis keyword can only be used in a suite teardown. Trying to use it\nanywhere else results in an error.\n\nOtherwise, this keyword works exactly like `Run Keyword`, see its\ndocumentation for more details.", "shortdoc": "Runs the given keyword with the given arguments, if one or more tests failed.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2560 }, { "name": "Run Keyword If Test Failed", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "Runs the given keyword with the given arguments, if the test failed.\n\nThis keyword can only be used in a test teardown. Trying to use it\nanywhere else results in an error.\n\nOtherwise, this keyword works exactly like `Run Keyword`, see its\ndocumentation for more details.", "shortdoc": "Runs the given keyword with the given arguments, if the test failed.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2498 }, { "name": "Run Keyword If Test Passed", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "Runs the given keyword with the given arguments, if the test passed.\n\nThis keyword can only be used in a test teardown. Trying to use it\nanywhere else results in an error.\n\nOtherwise, this keyword works exactly like `Run Keyword`, see its\ndocumentation for more details.", "shortdoc": "Runs the given keyword with the given arguments, if the test passed.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2512 }, { "name": "Run Keyword If Timeout Occurred", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "Runs the given keyword if either a test or a keyword timeout has occurred.\n\nThis keyword can only be used in a test teardown. Trying to use it\nanywhere else results in an error.\n\nOtherwise, this keyword works exactly like `Run Keyword`, see its\ndocumentation for more details.", "shortdoc": "Runs the given keyword if either a test or a keyword timeout has occurred.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2526 }, { "name": "Run Keyword Unless", "args": [ { "name": "condition", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "condition" }, { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "args", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*args" } ], "returnType": null, "doc": "*DEPRECATED since RF 5.0. Use Native IF/ELSE or `Run Keyword If` instead.*\n\nRuns the given keyword with the given arguments if ``condition`` is false.\n\nSee `Run Keyword If` for more information and an example. Notice that this\nkeyword does not support ELSE or ELSE IF branches like `Run Keyword If` does.", "shortdoc": "*DEPRECATED since RF 5.0. Use Native IF/ELSE or `Run Keyword If` instead.*", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 2103, "deprecated": true }, { "name": "Run Keywords", "args": [ { "name": "keywords", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*keywords" } ], "returnType": null, "doc": "Executes all the given keywords in a sequence.\n\nThis keyword is mainly useful in setups and teardowns when they need\nto take care of multiple actions and creating a new higher level user\nkeyword would be an overkill.\n\nBy default all arguments are expected to be keywords to be executed.\n\nExamples:\n| `Run Keywords` | `Initialize database` | `Start servers` | `Clear logs` |\n| `Run Keywords` | ${KW 1} | ${KW 2} |\n| `Run Keywords` | @{KEYWORDS} |\n\nKeywords can also be run with arguments using upper case ``AND`` as\na separator between keywords. The keywords are executed so that the\nfirst argument is the first keyword and proceeding arguments until\nthe first ``AND`` are arguments to it. First argument after the first\n``AND`` is the second keyword and proceeding arguments until the next\n``AND`` are its arguments. And so on.\n\nExamples:\n| `Run Keywords` | `Initialize database` | db1 | AND | `Start servers` | server1 | server2 |\n| `Run Keywords` | `Initialize database` | ${DB NAME} | AND | `Start servers` | @{SERVERS} | AND | `Clear logs` |\n| `Run Keywords` | ${KW} | AND | @{KW WITH ARGS} |\n\nNotice that the ``AND`` control argument must be used explicitly and\ncannot itself come from a variable. If you need to use literal ``AND``\nstring as argument, you can either use variables or escape it with\na backslash like ``\\AND``.", "shortdoc": "Executes all the given keywords in a sequence.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 1943 }, { "name": "Set Global Variable", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "values", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*values" } ], "returnType": null, "doc": "Makes a variable available globally in all tests and suites.\n\nVariables set with this keyword are globally available in all\nsubsequent test suites, test cases and user keywords. Also variables\ncreated Variables sections are overridden. Variables assigned locally\nbased on keyword return values or by using `Set Suite Variable`,\n`Set Test Variable` or `Set Local Variable` override these variables\nin that scope, but the global value is not changed in those cases.\n\nIn practice setting variables with this keyword has the same effect\nas using command line options ``--variable`` and ``--variablefile``.\nBecause this keyword can change variables everywhere, it should be\nused with care.\n\nSee `Set Suite Variable` for more information and usage examples. See\nalso the `Using variables with keywords creating or accessing variables`\nsection for information why it is recommended to give the variable name\nin escaped format like ``$name`` or ``\\${name}`` instead of the normal\n``${name}``.\n\n*NOTE:* The ``VAR`` syntax introduced in Robot Framework 7.0 is recommended\nover this keyword.", "shortdoc": "Makes a variable available globally in all tests and suites.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 1815 }, { "name": "Set Library Search Order", "args": [ { "name": "search_order", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*search_order" } ], "returnType": null, "doc": "Sets the resolution order to use when a name matches multiple keywords.\n\nThe library search order is used to resolve conflicts when a keyword name\nthat is used matches multiple keyword implementations. The first library\n(or resource, see below) containing the keyword is selected and that\nkeyword implementation used. If the keyword is not found from any library\n(or resource), execution fails the same way as when the search order is\nnot set.\n\nWhen this keyword is used, there is no need to use the long\n``LibraryName.Keyword Name`` notation. For example, instead of\nhaving\n\n| MyLibrary.Keyword | arg |\n| MyLibrary.Another Keyword |\n| MyLibrary.Keyword | xxx |\n\nyou can have\n\n| Set Library Search Order | MyLibrary |\n| Keyword | arg |\n| Another Keyword |\n| Keyword | xxx |\n\nThis keyword can be used also to set the order of keywords in different\nresource files. In this case resource names must be given without paths\nor extensions like:\n\n| Set Library Search Order | resource | another_resource |\n\n*NOTE:*\n- The search order is valid only in the suite where this keyword is used.\n- Keywords in resources always have higher priority than\n keywords in libraries regardless the search order.\n- The old order is returned and can be used to reset the search order later.\n- Calling this keyword without arguments removes possible search order.\n- Library and resource names in the search order are both case and space\n insensitive.", "shortdoc": "Sets the resolution order to use when a name matches multiple keywords.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3305 }, { "name": "Set Local Variable", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "values", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*values" } ], "returnType": null, "doc": "Makes a variable available everywhere within the local scope.\n\nVariables set with this keyword are available within the\nlocal scope of the currently executed test case or in the local scope\nof the keyword in which they are defined. For example, if you set a\nvariable in a user keyword, it is available only in that keyword. Other\ntest cases or keywords will not see variables set with this keyword.\n\nThis keyword is equivalent to a normal variable assignment based on a\nkeyword return value. For example,\n\n| ${var} = `Set Variable` value\n| @{list} = `Create List` item1 item2 item3\n\nare equivalent with\n\n| `Set Local Variable` @var value\n| `Set Local Variable` @list item1 item2 item3\n\nThe main use case for this keyword is creating local variables in\nlibraries.\n\nSee `Set Suite Variable` for more information and usage examples. See\nalso the `Using variables with keywords creating or accessing variables`\nsection for information why it is recommended to give the variable name\nin escaped format like ``$name`` or ``\\${name}`` instead of the normal\n``${name}``.\n\nSee also `Set Global Variable` and `Set Test Variable`.\n\n*NOTE:* The ``VAR`` syntax introduced in Robot Framework 7.0 is recommended\nover this keyword.", "shortdoc": "Makes a variable available everywhere within the local scope.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 1665 }, { "name": "Set Log Level", "args": [ { "name": "level", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "level" } ], "returnType": null, "doc": "Sets the log threshold to the specified level.\n\nMessages below the level will not logged. The default logging level is\nINFO, but it can be overridden with the ``--loglevel`` command line option.\nThe available levels are TRACE, DEBUG, INFO (default), WARN, ERROR and NONE\n(no logging).\n\nThe old level is returned and can be used for setting the level back\nlater. An alternative way to reset the level is using the dedicated\n`Reset Log Level` keyword.", "shortdoc": "Sets the log threshold to the specified level.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3179 }, { "name": "Set Suite Documentation", "args": [ { "name": "doc", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "doc" }, { "name": "append", "type": null, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "append=False" }, { "name": "top", "type": null, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "top=False" } ], "returnType": null, "doc": "Sets documentation for the current test suite.\n\nBy default, the possible existing documentation is overwritten, but\nthis can be changed using the optional ``append`` argument similarly\nas with `Set Test Message` keyword.\n\nThis keyword sets the documentation of the current suite by default.\nIf the optional ``top`` argument is given a true value (see `Boolean\narguments`), the documentation of the top level suite is altered\ninstead.\n\nThe documentation of the current suite is available as a built-in\nvariable ``${SUITE DOCUMENTATION}``.", "shortdoc": "Sets documentation for the current test suite.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3625 }, { "name": "Set Suite Metadata", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "value", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "value" }, { "name": "append", "type": null, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "append=False" }, { "name": "top", "type": null, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "top=False" } ], "returnType": null, "doc": "Sets metadata for the current test suite.\n\nBy default, possible existing metadata values are overwritten, but\nthis can be changed using the optional ``append`` argument similarly\nas with `Set Test Message` keyword.\n\nThis keyword sets the metadata of the current suite by default.\nIf the optional ``top`` argument is given a true value (see `Boolean\narguments`), the metadata of the top level suite is altered instead.\n\nThe metadata of the current suite is available as a built-in variable\n``${SUITE METADATA}`` in a Python dictionary. Notice that modifying this\nvariable directly has no effect on the actual metadata the suite has.", "shortdoc": "Sets metadata for the current test suite.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/BuiltIn.py", "lineno": 3645 }, { "name": "Set Suite Variable", "args": [ { "name": "name", "type": null, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "name" }, { "name": "values", "type": null, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*values" } ], "returnType": null, "doc": "Makes a variable available everywhere within the scope of the current suite.\n\nVariables set with this keyword are available everywhere within the\nscope of the currently executed test suite. Setting variables with this\nkeyword thus has the same effect as creating them using the Variables\nsection in the data file or importing them from variable files.\n\nPossible child test suites do not see variables set with this keyword\nby default, but that can be controlled by using ``children=