Robot Framework 2.9

Robot Framework 2.9 is a new major version with nearly 100 fixed issues. It contains, for example, high priority enhancements related to variables, support for creating keywords with embedded arguments in test libraries, and possibility to tag keywords. The most visible enhancement is the new fresh look in logs and reports. For more details see the full release notes.

Source distribution and Windows installers are available at PyPI and the standalone JAR with Jython 2.7 at Maven central. Pip users can simply run pip install --upgrade robotframework to install or upgrade to the latest release or pip install robotframework==2.9 to install exactly this version.

Robot Framework 2.9 was released on Friday July 31, 2015.

Robot Framework 2.9 release candidate 1

Release notes

Robot Framework 2.9 rc 1 is the sixth and hopefully last preview version of the forthcoming RF 2.9 release. It contains, for example, high priority enhancements related to variables and supports creating keywords with embedded arguments in test libraries. All issues targeted for RF 2.9 can be found from the issue tracker.

This release ought to be very stable, and we hope that it gets as much real life testing as possible. We especially hope that library and tool developers would test how well this new version works with their projects. If no issues are found from the rc 1 release in a week, RF 2.9 final will be be released based on it. If problems arise, rc 2 will be created as soon as possible.

Questions and comments related to this release can be sent to the robotframework-users and possible bugs submitted to the issue tracker.

We have not generated Windows installers for this preview, but the source distribution is available from PyPI and the standalone jar with Jython 2.7 can be found from downloads below these release notes.

If you have pip just run pip install --upgrade --pre robotframework to install or upgrade to the latest version or use pip install robotframework==2.9rc1 to install exactly this version. For more details and other installation approaches see installation instructions.

Robot Framework 2.9 rc 1 was released on Wednesday July 15, 2015.

Compatibility with other projects

Robot Framework 2.9 should, for most parts, be compatible with other projects in the larger Robot Framework ecosystem. It may, however, take some time before tools support new syntax like dictionary variables or keyword tags. Additionally, big internal changes may affect tools that have used internal APIs. Libraries and tools know not to be compatible with Robot Framework 2.9 will be listed here.

• RIDE 1.4 and older is not compatible with new syntax added in Robot Framework 2.9. Updated version is to be released shortly.
• Selenium2Library 1.7 and older use an internal API that was removed in Robot Framework 2.9 beta 1. Selenium2Library 1.7.1 and newer are compatible with Robot Framework 2.9.
• Also RemoteSwingLibrary 2.0.2 and older use a removed internal API. A fixed version is to be released shortly.
• Robot Framework Jenkins plugin 1.6.0 and older can not parse the new output.xml. Jenkins plugin 1.6.1 and newer are compatible with Robot Framework 2.9.

Most important enhancements

Dictionary variable type (#1450)

The most noticeable feature in RF 2.9 is the new syntax to create and use dictionary (a.k.a map or hashtable) variables. Dictionaries can be returned from keywords or created in variable files, but they can also be created in the variable table:

*** Variables ***
&{DICT}    key=value    second=2    third=${3}

The above example will create a dictionary variable &{DICT} with Python dictionary {'key': 'value', 'second': '2', 'third': 3} as the value. If a dictionary variable is used as a scalar variable like ${DICT}, it will be passed forward as a single argument containing the whole dictionary. If it used like &{DICT}, individual items are passed as named arguments. For example, these two examples are equivalent:

*** Test Cases ***
Example 1
    My Keyword    key=value    second=2    third=${3}
Example 2
    My Keyword    &{DICT}

Individual dictionary variable items can be accessed either using special &{DICT}[key] syntax similarly as individual list variable items can be accessed like @{LIST}[0]. As a special feature, dictionary variables are ordered and allow accessing values also using attribute access like ${DICT.key}. For more information about dictionary variables, see Variables section in the User Guide.

NOTE: RIDE 1.4 and older do not support dictionary variables.

Python style **kwargs support with user keywords using &{kwargs} syntax (#1561)

New dictionary variable syntax can be used with user keywords to accept free keyword arguments similarly as Python based keywords can accept **kwargs. This can be accomplished simply by having a dictionary variable like &{kwargs} as the last argument in user keyword argument specification:

*** Keywords ***
Run My Process
    [Arguments]    @{arguments}    &{configuration}
    Run Process    myproc.exe    @{arguments}    &{configuration}

Also this new functionality is explained with further examples in the User Guide.

Embedded arguments in keywords defined in test libraries (#1818)

User keywords have supported embedded arguments since RF 2.1.1 (#370), and finally this functionality is supported also by library keywords. This is accomplished by giving a custom name to a keyword by setting robot_name attribute manually or by using robot.api.deco.keyword' decorator (#1835), and using${args}` in the name similarly as with user keywords. The implementing method or function must also accept same number of arguments as there are embedded argument.

from robot.api.deco import keyword

@keyword(name='User "${user}" selects "${item}" from webshop')
def select_item(user, item):
    # ...

The User Guide is, again, the place where to find more information and examples.

Keyword categorization (i.e. tagging) support

Keywords can now have tags (#925). The tags can be added to user keywords either by new [Tags] setting, or by adding them to the last line of documentation.

*** Keywords ***
My keyword
    [Tags]    tag1    tag2
    No Operation
My other keyword
    [Documentation]    Tags can also be added as last line of documentation.
    ...                Tags: tag1, tag2
    No Operation

Library keywords can also use documentation to specify their tags or they can be added to robot_tagsattribute for each method. The keyword decorator provides a handy shortcut for specifying tags for each method.

from robot.api.deco import keyword

@keyword(tags=['tag1', 'tag2'])
def select_item(user, item):
    # ...

Libdoc will show keywords by tags (#1840) and tags can also be used to specify keywords for --removekeywords and --flattenkeywords commandline options (#1935).

Programmatic modifications of test data and results as part of normal execution

It is now possible to specify modifiers to preprocess the test data before the test run and to modify the results before generation of log and report. The modifiers can be taken into use with --prerunmodifier and --prerebotmodifier. See the issue #1976 for an example and more details.

Lighter and more neutral colors for logs and reports (#1943)

Logs and reports have a new fresh look. Go run some tests and see yourself!

Less verbose and quiet console outputs (#317)

New option --console allows changing the console output type. Possible values are verbose (default), dotted (x-unit like output where each passing test prints only a dot), quiet (no output except warnings and errors) and none (no output whatsoever). Dotted output has a shortcut --dotted or -. as a short option.

Variables are added to evaluation namespace of Evaluate, Run Keyword If, etc. (#2040)

Robot´s variables are now available with a $ prefix as Python variables in evaluation namespace of various BuiltIn library keywords.

The two rows below are now equivalent (assuming value of ${my var} is a string):

*** Keywords ***
My keyword
    Run keyword if    "${my var}" != "Foo"   ...   # old syntax
    Run keyword if     $my_var != "Foo"    ...   # new syntax in 2.9

FOR ... IN ZIP ... and FOR ... IN ENUMERATE (#1952)

New for loop syntax allows use of for-in-zip and for-in-enumarete loops.

*** Keywords ***
For in zip example    # take elements from both lists
    :FOR    ${number}    ${name}    IN ZIP    ${NUMBERS}    ${NAMES}
        \     Number Should Be Named    ${number}    ${name}
For in enumerate example    # take an item and an increasing index number
    :FOR    ${index}    ${item}    IN ENUMERATE    @{LIST}
     \     My Keyword    ${index}    ${item}

See the userguide for more details.

Contribution guidelines (#1805)

We have written guidelines helping to submit issue and contribute code. A link to them appears when submitting and issue or creating a pull request, and they are also directly available. We plan to enhance the guidelines in the future, so all kind of comments and enhancement ideas are highly appreciated.

Other high priority enhancements and fixes

• Scalar and list variables stored in same namespace (#1905)
• Standard libraries do not mask third party Python modules (#1737)
• Fixed sporadic failures with timeouts on IronPython (#1931)
• --ExitOnFailure does not work if test/suite setup/teardown fails (#2004)
• Support YAML files as first class variable files (#1965)
• Run Keyword If Test (Failed / Passed) will detect failure in teardown (#1270)
• DateTime: DST problems when calculating with dates (#2018)

Backwards incompatible changes

Being a major release, RF 2.9 contain...

Robot Framework 2.9 beta 2

Robot Framework 2.9 beta 2

RF 2.9 beta 2 is the fifth preview version of the forthcoming RF 2.9 release. It contains, for example, high priority enhancements related to variables and supports creating keywords with embedded arguments in test libraries. After this release the work continues with the first release candidate. All issues targeted for RF 2.9 can be found from the issue tracker.

Most important new features in beta 2 over beta 1 are the new for-in-zip and for-in-enumerate loops (#1952) and change in syntax to adding variables to evaluation namespace of Evaluate, Run Keyword If, and other built-in keywords (#2040). The issue list at the end of this release note mentions for each feature in which preview it came, but otherwise the notes here describe the changes in 2.9 over 2.8.7, therefore containing also previous preview changes.

Questions and comments related to this release can be sent to the robotframework-users and possible bugs submitted to the issue tracker.

We have not generated windows installers for this preview, but the source distribution is available from PyPI and the standalone jar with Jython 2.7 can be found from downloads below these release notes.

If you have pip just run pip install --upgrade --pre robotframework to install or upgrade to the latest version or use pip install robotframework==2.9b2 to install exactly this version. For more details and other installation approaches see installation instructions.

Robot Framework 2.9 beta 2 was released on Thursday July 2, 2015.

Compatibility with other projects

Robot Framework 2.9 should, for most parts, be compatible with other projects in the larger Robot Framework ecosystem. It may, however, take some time before tools support new syntax like dictionary variables or keyword tags. Additionally, big internal changes may affect tools that have used internal APIs. Libraries and tools know not to be compatible with Robot Framework 2.9 will be listed here.

• RIDE 1.4 and older is not compatible with new syntax added in Robot Framework 2.9.
• Selenium2Library 1.7 and older use an internal API that was removed in Robot Framework 2.9 beta 1. Selenium2Library 1.7.1 is fully compatible with Robot Framework 2.9.
• Robot Framework Jenkins plugin 1.6.0 and older can not parse the new output.xml A new version of Jenkins plugin with fixed output parsing should be released shortly after beta 2 is out.

Most important enhancements

Dictionary variable type (#1450)

The most noticeable feature in RF 2.9 is the new syntax to create and use dictionary (a.k.a map or hashtable) variables. Dictionaries can be returned from keywords or created in variable files, but they can also be created in the variable table:

*** Variables ***
&{DICT}    key=value    second=2    third=${3}

The above example will create a dictionary variable &{DICT} with Python dictionary {'key': 'value', 'second': '2', 'third': 3} as the value. If a dictionary variable is used as a scalar variable like ${DICT}, it will be passed forward as a single argument containing the whole dictionary. If it used like &{DICT}, individual items are passed as named arguments. For example, these two examples are equivalent:

*** Test Cases ***
Example 1
    My Keyword    key=value    second=2    third=${3}
Example 2
    My Keyword    &{DICT}

Individual dictionary variable items can be accessed either using special &{DICT}[key] syntax similarly as individual list variable items can be accessed like @{LIST}[0]. As a special feature, dictionary variables are ordered and allow accessing values also using attribute access like ${DICT.key}. For more information about dictionary variables, see Variables section in the User Guide.

NOTE: RIDE editor does not currently support dictionary variables.

Python style **kwargs support with user keywords using &{kwargs} syntax (#1561)

New dictionary variable syntax can be used with user keywords to accept free keyword arguments similarly as Python based keywords can accept **kwargs. This can be accomplished simply by having a dictionary variable like &{kwargs} as the last argument in user keyword argument specification:

*** Keywords ***
Run My Process
    [Arguments]    @{arguments}    &{configuration}
    Run Process    myproc.exe    @{arguments}    &{configuration}

Also this new functionality is explained with further examples in the User Guide.

Embedded arguments in keywords defined in test libraries (#1818)

User keywords have supported embedded arguments since RF 2.1.1 (#370), and finally this functionality is supported also by library keywords. This is accomplished by giving a custom name to a keyword by setting robot_name attribute manually or by using robot.api.deco.keyword' decorator (#1835), and using${args}` in the name similarly as with user keywords. The implementing method or function must also accept same number of arguments as there are embedded argument.

from robot.api.deco import keyword

@keyword(name='User "${user}" selects "${item}" from webshop')
def select_item(user, item):
    # ...

The User Guide is, again, the place where to find more information and examples.

Keyword categorization (i.e. tagging) support

Keywords can now have tags (#925). The tags can be added to user keywords either by new [Tags] setting, or by adding them to the last line of documentation.

*** Keywords ***
My keyword
    [Tags]    tag1    tag2
    No Operation
My other keyword
    [Documentation]    Tags can also be added as last line of documentation.
    ...                Tags: tag1, tag2
    No Operation

Library keywords can also use documentation to specify their tags or they can be added to robot_tagsattribute for each method. The keyword decorator provides a handy shortcut for specifying tags for each method.

from robot.api.deco import keyword

@keyword(tags=['tag1', 'tag2'])
def select_item(user, item):
    # ...

Libdoc will show keywords by tags (#1840) and tags can also be used to specify keywords for --removekeywords and --flattenkeywords commandline options (#1935).

Programmatic modifications of test data and results as part of normal execution

It is now possible to specify modifiers to preprocess the test data before the test run and to modify the results before generation of log and report. The modifiers can be taken into use with --prerunmodifier and --prerebotmodifier. See the issue #1976 for an example and more details.

Less verbose and quiet console outputs (#317)

New option --console allows changing the console output type. Possible values are verbose (default), dotted (x-unit like output where each passing test prints only a dot), quiet (no output except warnings and errors) and none (no output whatsoever). Dotted output has a shortcut --dotted or -. as a short option.

Variables are added to evaluation namespace of Evaluate, Run Keyword If, ... (#2040)

Robot´s variables are now available with $-prefix as Python variables in evaluation namespace of BuiltIn library keywords.

The two rows below are now equivalent (assuming value of ${my var} is a string):

*** Keywords ***
My keyword
    Run keyword if    "${my var}" != "Foo"   ...   # old syntax
    Run keyword if     $my_var != "Foo"    ...   # new syntax in 2.9

NOTE: The syntax was changed in beta 2 to require the $ prefix.

FOR ... IN ZIP ... and FOR ... IN ENUMERATE (#1952)

New for loop syntax allows use of for-in-zip and for-in-enumarete loops.

*** Keywords ***
For in zip example    # take elements from both lists
    :FOR    ${number}    ${name}    IN ZIP    ${NUMBERS}    ${NAMES}
        \     Number Should Be Named    ${number}    ${name}
For in enumerate example    # take an item and an increasing index number
    :FOR    ${index}    ${item}    IN ENUMERATE    @{LIST}
     \     My Keyword    ${index}    ${item}

See the userguide for more details.

Other high priority enhancements and fixes

• Scalar and list variables stored in same namespace (#1905)
• Standard libraries do not mask third party Python modules (#1737)
• Fixed sporadic failures with timeouts on IronPython (#1931)
• --ExitOnFailure does not work if test/suite setup/teardown fails (#2004)
• Support yaml files as first class variable file (#1965)
• Run Keyword If Test (Failed / Passed) will detect failure in teardown ( #1270)
• DateTime: DST problems when calculating with dates (#2018)
• Use lighter and more neutral colors for report and log html page (#1943)

Backwards incompatible changes

Being a major release, RF 2.9 contains lot of changes and some of them are backwards incompatible.

List and scalar variables stored in same namespace (#1905)

It has been possible to use a list variable @{list} as a scalar variable ${list} since RF 2.0.3 (#117), and scalar variables containing lists have been usable as list variables since RF 2.8 (#483). It has, however, been possible to also create scalar and list variables with same base name, for example, in the variable table:

*** Variabl...

Robot Framework 2.9 beta 1

Robot Framework 2.9 beta 1

RF 2.9 beta 1 is the fourth preview version of the forthcoming RF 2.9 release. It contains, for example, high priority enhancements related to variables and supports creating keywords with embedded arguments in test libraries. After this release the work continues with the first release candidate. All issues targeted for RF 2.9 can be found from the issue tracker.

Most important new features in beta 1 over alpha 3 are lighter and more neutral colors for report and log html page (#1943) and adding variables to evaluation namespace of Evaluate, Run Keyword If, and other built-in keywords (#2040). The issue list at the end of this release note mentions for each feature in which preview it came, but otherwise the notes here describe the changes in 2.9 over 2.8.7, therefore containing also previous preview changes.

Questions and comments related to this release can be sent to the robotframework-users and possible bugs submitted to the issue tracker.

We have not generated windows installers for this preview, but the source distribution is available from PyPI and the standalone jar with Jython 2.7 can be found from downloads below these release notes.

If you have pip just run pip install --upgrade --pre robotframework to install or upgrade to the latest version or use pip install robotframework==2.9b1 to install exactly this version. For more details and other installation approaches see installation instructions.

Robot Framework 2.9 beta 1 was released on Friday June 26, 2015.

Compatibility with other projects

Robot Framework 2.9 should, for most parts, be compatible with other projects in the larger Robot Framework ecosystem. It may, however, take some time before tools support new syntax like dictionary variables or keyword tags. Additionally, big internal changes may affect tools that have used internal APIs. Libraries and tools know not to be compatible with Robot Framework 2.9 will be listed here.

• RIDE 1.4 and older is not compatible with new syntax added in Robot Framework 2.9.
• Selenium2Library 1.7 and older use an internal API that was removed in Robot Framework 2.9 beta 1. Selenium2Library 1.7.1 is fully compatible with Robot Framework 2.9.

Most important enhancements

Dictionary variable type (#1450)

The most noticeable feature in RF 2.9 is the new syntax to create and use dictionary (a.k.a map or hashtable) variables. Dictionaries can be returned from keywords or created in variable files, but they can also be created in the variable table:

*** Variables ***
&{DICT}    key=value    second=2    third=${3}

The above example will create a dictionary variable &{DICT} with Python dictionary {'key': 'value', 'second': '2', 'third': 3} as the value. If a dictionary variable is used as a scalar variable like ${DICT}, it will be passed forward as a single argument containing the whole dictionary. If it used like &{DICT}, individual items are passed as named arguments. For example, these two examples are equivalent:

*** Test Cases ***
Example 1
    My Keyword    key=value    second=2    third=${3}
Example 2
    My Keyword    &{DICT}

Individual dictionary variable items can be accessed either using special &{DICT}[key] syntax similarly as individual list variable items can be accessed like @{LIST}[0]. As a special feature, dictionary variables are ordered and allow accessing values also using attribute access like ${DICT.key}. For more information about dictionary variables, see Variables section in the User Guide.

NOTE: RIDE editor does not currently support dictionary variables.

Python style **kwargs support with user keywords using &{kwargs} syntax (#1561)

New dictionary variable syntax can be used with user keywords to accept free keyword arguments similarly as Python based keywords can accept **kwargs. This can be accomplished simply by having a dictionary variable like &{kwargs} as the last argument in user keyword argument specification:

*** Keywords ***
Run My Process
    [Arguments]    @{arguments}    &{configuration}
    Run Process    myproc.exe    @{arguments}    &{configuration}

Also this new functionality is explained with further examples in the User Guide.

Embedded arguments in keywords defined in test libraries (#1818)

User keywords have supported embedded arguments since RF 2.1.1 (#370), and finally this functionality is supported also by library keywords. This is accomplished by giving a custom name to a keyword by setting robot_name attribute manually or by using robot.api.deco.keyword' decorator (#1835), and using${args}` in the name similarly as with user keywords. The implementing method or function must also accept same number of arguments as there are embedded argument.

from robot.api.deco import keyword

@keyword(name='User "${user}" selects "${item}" from webshop')
def select_item(user, item):
    # ...

The User Guide is, again, the place where to find more information and examples.

Keyword categorization (i.e. tagging) support

Keywords can now have tags (#925). The tags can be added to user keywords either by new [Tags] setting, or by adding them to the last line of documentation.

*** Keywords ***
My keyword
    [Tags]    tag1    tag2
    No Operation
My other keyword
    [Documentation]    Tags can also be added as last line of documentation.
    ...                Tags: tag1, tag2
    No Operation

Library keywords can also use documentation to specify their tags or they can be added to robot_tagsattribute for each method. The keyword decorator provides a handy shortcut for specifying tags for each method.

from robot.api.deco import keyword

@keyword(tags=['tag1', 'tag2'])
def select_item(user, item):
    # ...

Libdoc will show keywords by tags (#1840) and tags can also be used to specify keywords for --removekeywords and --flattenkeywords commandline options (#1935).

Programmatic modifications of test data and results as part of normal execution

It is now possible to specify modifiers to preprocess the test data before the test run and to modify the results before generation of log and report. The modifiers can be taken into use with --prerunmodifier and --prerebotmodifier. See the issue #1976 for an example and more details.

Less verbose and quiet console outputs (#317)

New option --console allows changing the console output type. Possible values are verbose (default), dotted (x-unit like output where each passing test prints only a dot), quiet (no output except warnings and errors) and none (no output whatsoever). Dotted output has a shortcut --dotted or -. as a short option.

Variables are added to evaluation namespace of Evaluate, Run Keyword If, ... (#2040)

Robot´s variables are now available as Python variables in evaluation namespace of BuiltIn library keywords.

The two rows below are now equivalent (assuming value of ${my var} is a string):

*** Keywords ***
My keyword
    Run keyword if    "${my var}" != "Foo"   ...   # old syntax
    Run keyword if     my_var != "Foo"    ...   # new syntax in 2.9

NOTE: The syntax will be changed in beta 2 so that a $ prefix is required like in $my_var.

Other high priority enhancements and fixes

• Scalar and list variables stored in same namespace (#1905)
• Standard libraries do not mask third party Python modules (#1737)
• Fixed sporadic failures with timeouts on IronPython (#1931)
• --ExitOnFailure does not work if test/suite setup/teardown fails (#2004)
• Support yaml files as first class variable file (#1965)
• Run Keyword If Test (Failed / Passed) will detect failure in teardown ( #1270)
• DateTime: DST problems when calculating with dates (#2018)
• Use lighter and more neutral colors for report and log html page (#1943)

Backwards incompatible changes

Being a major release, RF 2.9 contains lot of changes and some of them are backwards incompatible.

List and scalar variables stored in same namespace (#1905)

It has been possible to use a list variable @{list} as a scalar variable ${list} since RF 2.0.3 (#117), and scalar variables containing lists have been usable as list variables since RF 2.8 (#483). It has, however, been possible to also create scalar and list variables with same base name, for example, in the variable table:

*** Variables ***
${VAR}    Scalar variable
@{VAR}    List    variable

This caused a lot of confusion, and the addition of &{dictionary} variables (#1450) would have made situation even more complicated. As a result it was decided to store all variables in the same namespace (#1905) and decide how they are used depending on the format (e.g. ${var} for scalar, @{var} for list, and &{var} for dictionary).

As a result of this change, tests using scalar and list variables with same base name will need to be updated. Unfortunately there is no other good way to detect these problems than running tests with the new version and seeing does anything break.

Variables no longer leak to lower level keywords (#532)

Local variables used to leak from test to keywords and from keywords to lower level keywords. The example below shows variable leaking from test to keyword:

...

Robot Framework 2.9 alpha 3

Robot Framework 2.9 alpha 3

RF 2.9 alpha 3 is the third preview version of the forthcoming RF 2.9 release. It contains, for example, high priority enhancements related to variables and supports creating keywords with embedded arguments in test libraries. After this release the work continues with beta 1. All issues targeted for RF 2.9 can be found from the issue tracker.

Most important new features in alpha 3 over alpha 2 are that the variables no longer leak to lower level keywords (#532) and the new less verbose console output (#317). The issue list at the end of this release note mentions for each feature in which preview it came, but otherwise the notes here describe the changes in 2.9 over 2.8.7, therefore containing also the alpha 1 and 2 changes.

Questions and comments related to this release can be sent to the robotframework-users and possible bugs submitted to the issue tracker.

We have not generated windows installers for this preview, but the source distribution is available from PyPI and the standalone jar with Jython 2.7 can be found from downloads below these release notes.

If you have pip just run pip install --upgrade --pre robotframework to install or upgrade to the latest version or use pip install robotframework==2.9a3 to install exactly this version. For more details and other installation approaches see installation instructions.

Robot Framework 2.9 alpha 3 was released on Thursday June 18, 2015.

Compatibility with other projects

Robot Framework 2.9 should, for most parts, be compatible with other projects in the larger Robot Framework ecosystem. It may, however, take some time before tools support new syntax like dictionary variables or keyword tags. Additionally, big internal changes may affect tools that have used internal APIs. Libraries and tools know not to be compatible with Robot Framework 2.9 will be listed here.

• RIDE 1.4 and older is not compatible with new syntax added in Robot Framework 2.9.
• Selenium2Library 1.7 and older use an internal API that was removed in Robot Framework 2.9 beta 1. Selenium2Library 1.7.1 is fully compatible with Robot Framework 2.9.

Most important enhancements

Dictionary variable type (#1450)

The most noticeable feature in RF 2.9 is the new syntax to create and use dictionary (a.k.a map or hashtable) variables. Dictionaries can be returned from keywords or created in variable files, but they can also be created in the variable table:

*** Variables ***
&{DICT}    key=value    second=2    third=${3}

The above example will create a dictionary variable &{DICT} with Python dictionary {'key': 'value', 'second': '2', 'third': 3} as the value. If a dictionary variable is used as a scalar variable like ${DICT}, it will be passed forward as a single argument containing the whole dictionary. If it used like &{DICT}, individual items are passed as named arguments. For example, these two examples are equivalent:

*** Test Cases ***
Example 1
    My Keyword    key=value    second=2    third=${3}
Example 2
    My Keyword    &{DICT}

Individual dictionary variable items can be accessed either using special &{DICT}[key] syntax similarly as individual list variable items can be accessed like @{LIST}[0]. As a special feature, dictionary variables are ordered and allow accessing values also using attribute access like ${DICT.key}. For more information about dictionary variables, see Variables section in the User Guide.

NOTE: RIDE editor does not currently support dictionary variables.

Python style **kwargs support with user keywords using &{kwargs} syntax (#1561)

New dictionary variable syntax can be used with user keywords to accept free keyword arguments similarly as Python based keywords can accept **kwargs. This can be accomplished simply by having a dictionary variable like &{kwargs} as the last argument in user keyword argument specification:

*** Keywords ***
Run My Process
    [Arguments]    @{arguments}    &{configuration}
    Run Process    myproc.exe    @{arguments}    &{configuration}

Also this new functionality is explained with further examples in the User Guide.

Embedded arguments in keywords defined in test libraries (#1818)

User keywords have supported embedded arguments since RF 2.1.1 (#370), and finally this functionality is supported also by library keywords. This is accomplished by giving a custom name to a keyword by setting robot_name attribute manually or by using robot.api.deco.keyword' decorator (#1835), and using${args}` in the name similarly as with user keywords. The implementing method or function must also accept same number of arguments as there are embedded argument.

from robot.api.deco import keyword

@keyword(name='User "${user}" selects "${item}" from webshop')
def select_item(user, item):
    # ...

The User Guide is, again, the place where to find more information and examples.

Keyword categorization (i.e. tagging) support

Keywords can now have tags (#925). The tags can be added to user keywords either by new [Tags] setting, or by adding them to the last line of documentation.

*** Keywords ***
My keyword
    [Tags]    tag1    tag2
    No Operation
My other keyword
    [Documentation]    Tags can also be added as last line of documentation.
    ...                Tags: tag1, tag2
    No Operation

Library keywords can also use documentation to specify their tags or they can be added to robot_tagsattribute for each method. The keyword decorator provides a handy shortcut for specifying tags for each method.

from robot.api.deco import keyword

@keyword(tags=['tag1', 'tag2'])
def select_item(user, item):
    # ...

Libdoc will show keywords by tags (#1840) and tags can also be used to specify keywords for --removekeywords and --flattenkeywords commandline options (#1935).

Programmatic modifications of test data and results as part of normal execution

It is now possible to specify modifiers to preprocess the test data before the test run and to modify the results before generation of log and report. The modifiers can be taken into use with --prerunmodifier and --prerebotmodifier. See the issue #1976 for an example and more details.

Less verbose and quiet console outputs (#317)

New option --console allows changing the console output type. Possible values are verbose (default), dotted (x-unit like output where each passing test prints only a dot), quiet (no output except warnings and errors) and none (no output whatsoever). Dotted output has a shortcut --dotted or -. as a short option.

Other high priority enhancements and fixes

• Scalar and list variables stored in same namespace (#1905)
• Standard libraries do not mask third party Python modules (#1737)
• Fixed sporadic failures with timeouts on IronPython (#1931)
• --ExitOnFailure does not work if test/suite setup/teardown fails (#2004)
• Support yaml files as first class variable file (#1965)
• Run Keyword If Test (Failed / Passed) will detect failure in teardown ( #1270)
• DateTime: DST problems when calculating with dates (#2018)

Backwards incompatible changes

Being a major release, RF 2.9 contains lot of changes and some of them are backwards incompatible.

List and scalar variables stored in same namespace (#1905)

It has been possible to use a list variable @{list} as a scalar variable ${list} since RF 2.0.3 (#117), and scalar variables containing lists have been usable as list variables since RF 2.8 (#483). It has, however, been possible to also create scalar and list variables with same base name, for example, in the variable table:

*** Variables ***
${VAR}    Scalar variable
@{VAR}    List    variable

This caused a lot of confusion, and the addition of &{dictionary} variables (#1450) would have made situation even more complicated. As a result it was decided to store all variables in the same namespace (#1905) and decide how they are used depending on the format (e.g. ${var} for scalar, @{var} for list, and &{var} for dictionary).

As a result of this change, tests using scalar and list variables with same base name will need to be updated. Unfortunately there is no other good way to detect these problems than running tests with the new version and seeing does anything break.

Variables no longer leak to lower level keywords (#532)

Local variables used to leak from test to keywords and from keywords to lower level keywords. The example below shows variable leaking from test to keyword:

*** Test Case ***
Example
    ${x}=    Set Variable    hello
    My keyword

*** Keywords ***
My keyword
    Should be equal    ${x}    hello

This behaviour was never intended, but fixing the bug can break tests where this was used either intentionally or by accident.

Drop Python/Jython 2.5 support (#1928)

With the official Jython 2.7 version out, we dropped the support for Python and Jython 2.5 series. The standalone jar contains Jython 2.7 from now on.

PYTHONPATH environment variable is not processed with Jython or IronPython anymore (#1983)

Robot Framework used to add PYTHONPATH to JYTHONPATH for Jython and to IRONPYTHONPATH for IronPython. In RF 2.9 Jython and IronPython will ignore PYTHONPATH and you ...

Robot Framework 2.9 alpha 2

Robot Framework 2.9 alpha 2

RF 2.9 alpha 2 is the second preview version of the forthcoming RF 2.9 release. It contains, for example, high priority enhancements related to variables and supports creating keywords with embedded arguments in test libraries. After this release the work continues with alpha 3. All issues targeted for RF 2.9 can be found from the issue tracker.

Most important new feature in alpha 2 over alpha 1 is the keyword tags support (#925). The issue list at the end of this release note mentions for each feature whether it came in alpha 1 or 2, but otherwise the notes here describe the changes in 2.9 over 2.8.7, therefore containing also the alpha 1 changes.

Questions and comments related to this release can be sent to the robotframework-users and possible bugs submitted to the issue tracker.

We have not generated windows installers for this preview, but the source distribution is available from PyPI and the standalone jar with Jython 2.7 can be found from downloads below these release notes.

If you have pip just run pip install --update --pre robotframework to install or upgrade to the latest version or use pip install robotframework==2.9a2 to install exactly this version. For more details and other installation approaches see installation instructions.

Robot Framework 2.9 alpha 2 was released on Friday June 05, 2015.

Most important enhancements

Dictionary variable type (#1450)

The most noticeable feature in RF 2.9 is the new syntax to create and use dictionary (a.k.a map or hashtable) variables. Dictionaries can be returned from keywords or created in variable files, but they can also be created in the variable table:

*** Variables ***
&{DICT}    key=value    second=2    third=${3}

The above example will create a dictionary variable &{DICT} with Python dictionary {'key': 'value', 'second': '2', 'third': 3} as the value. If a dictionary variable is used as a scalar variable like ${DICT}, it will be passed forward as a single argument containing the whole dictionary. If it used like &{DICT}, individual items are passed as named arguments. For example, these two examples are equivalent:

*** Test Cases ***
Example 1
    My Keyword    key=value    second=2    third=${3}
Example 2
    My Keyword    &{DICT}

Individual dictionary variable items can be accessed either using special &{DICT}[key] syntax similarly as individual list variable items can be accessed like @{LIST}[0]. As a special feature, dictionary variables are ordered and allow accessing values also using attribute access like ${DICT.key}. For more information about dictionary variables, see Variables section the User Guide.

NOTE: RIDE editor does not currently support dictionary variables.

Python style **kwargs support with user keywords using &{kwargs} syntax (#1561)

New dictionary variable syntax can be used with user keywords to accept free keyword arguments similarly as Python based keywords can accept **kwargs. This can be accomplished simply by having a dictionary variable like &{kwargs} as the last argument in user keyword argument specification:

*** Keywords ***
Run My Process
    [Arguments]    @{arguments}    &{configuration}
    Run Process    myproc.exe    @{arguments}    &{configuration}

Also this new functionality is explained with further examples in the User Guide.

Embedded arguments in keywords defined in test libraries (#1818)

User keywords have supported embedded arguments since RF 2.1.1 (#370), and finally this functionality is supported also by library keywords. This is accomplished by giving a custom name to a keyword by setting robot_name attribute manually or by using robot.api.deco.keyword' decorator (#1835), and using${args}` in the name similarly as with user keywords. The implementing method or function must also accept same number of arguments as there are embedded argument.

from robot.api.deco import keyword

@keyword(name='User "${user}" selects "${item}" from webshop')
def select_item(user, item):
    # ...

The User Guide is, again, the place where to find more information and examples.

Keyword categorization (i.e. tagging) support

Keywords can now have tags (#925). The tags can be added to user keywords either by new [Tags] setting, or by adding them to the last line of documentation.

*** Keywords ***
My keyword
    [Tags]    tag1    tag2
    No Operation
My other keyword
    [Documentation]    Tags can also be added as last line of documentation.
    ...                Tags: tag1, tag2
    No Operation

Library keywords can also use documentation to specify their tags or they can be added to robot_tagsattribute for each method. The keyword decorator provides a handy shortcut for specifying tags for each method.

from robot.api.deco import keyword

@keyword(tags=['tag1', 'tag2'])
def select_item(user, item):
    # ...

Libdoc will show keywords by tags (#1840) and tags can also be used to specify keywords for --removekeywords and --flattenkeywords commandline options (#1935).

Programmatic modifications of test data and results as part of normal execution

It is now possible to specify modifiers to preprocess the test data before the test run and to modify the results before generation of log and report. The modifiers can be taken into use with --prerunmodifier and --prerebotmodifier. See the issue #1976 for an example and more details.

Other high priority enhancements and fixes

• Scalar and list variables stored in same namespace (#1905)
• Standard libraries do not mask third party Python modules (#1737)
• Fixed sporadic failures with timeouts on IronPython (#1931)
• --ExitOnFailure does not work if test/suite setup/teardown fails (#2004)
• Support yaml files as first class variable file (#1965)

Backwards incompatible changes

Being a major release, RF 2.9 contains lot of changes and some of them are backwards incompatible.

List and scalar variables stored in same namespace (#1905)

It has been possible to use a list variable @{list} as a scalar variable ${list} since RF 2.0.3 (#117), and scalar variables containing lists have been usable as list variables since RF 2.8 (#483). It has, however, been possible to also create scalar and list variables with same base name, for example, in the variable table:

*** Variables ***
${VAR}    Scalar variable
@{VAR}    List    variable

This caused a lot of confusion, and the addition of &{dictionary} variables (#1450) would have made situation even more complicated. As a result it was decided to store all variables in the same namespace (#1905) and decide how they are used depending on the format (e.g. ${var} for scalar, @{var} for list, and &{var} for dictionary).

As a result of this change, tests using scalar and list variables with same base name will need to be updated. Unfortunately there is no other good way to detect these problems than running tests with the new version and seeing does anything break.

PYTHONPATH environment variable is not processed with Jython or IronPython anymore (#1983)

Robot Framework used to add PYTHONPATH to JYTHONPATH for Jython and to IRONPYTHONPATH for IronPython. In RF 2.9 Jython and IronPython will ignore PYTHONPATH and you need to use the correct path environment variable for your executor.

Execution directory not added automatically to module search path (#2019)

The directory where execution is started from is not anymore added to the module search path. If it is needed, PYTHONPATH, JYTHONPATH or IRONPYTHONPATH environment variable can be explicitly set to . before execution.

Standard libraries not importable in Python w/o robot.libraries prefix (#1737)

It used to be possible to import Robot Framework's standard libraries in Python code by just using the library name like import DateTime. This caused problems in with standard libraries having same name as third party Python modules like DateTime.

To avoid these problems, standard libraries are not anymore directly importable in Python code. They are still importable with the robot.libraries prefix like from robot.libraries import DateTime. This has also always been the recommended way and the one used in examples in the User Guide.

Disabling command line options accepting no values by using same option again not supported anymore

Earlier it was possible to disable options accepting no values like --dryrun by giving the option again like --dryrun --other options --dryrun. This was rather confusing, and nowadays it is possible to do that by using the same option with no prefix like --nodryrun instead (#1865). If option is used with and without the no prefix, the last used value has precedence. Having same option multiple times has no special functionality anymore.

Possible equal signs in arguments to BuiltIn.Call Method need to be escaped

Call Method nowadays supports **kwags (#1603) and thus possible equal signs in normal arguments need to be escaped with a backslash like hello\=world.

Unused internal functions, classes, etc. removed

See issue #1924 for a detailed list of changes to internal APIs. These changes should not affect libraries or tools using Robot Framework's public APIs.

Other backwards in...

Robot Framework 2.9 alpha 1

Robot Framework 2.9 alpha 1

RF 2.9 alpha 1 is the first preview version of the forthcoming RF 2.9 release. It contains, for example, high priority enhancements related to variables and supports creating keywords with embedded arguments in test libraries. After this release the work continues with alpha 2 with keyword tagging and other interesting new features. All issues targeted for RF 2.9 can be found from the issue tracker.

Questions and comments related to this release can be sent to the robotframework-users and possible bugs submitted to the issue tracker.

We have not generated windows installers or standalone jar for this preview, but the source distribution is available from PyPI.

If you have pip just run pip install --update --pre robotframework to install or upgrade to the latest version or use pip install robotframework==2.9a1 to install exactly this version. For more details and other installation approaches see installation instructions.

Robot Framework 2.9 alpha 1 was released on Friday April 10, 2015.

Most important enhancements

Dictionary variable type (#1450)

The most noticeable feature in RF 2.9 is the new syntax to create and use dictionary (a.k.a map or hashtable) variables. Dictionaries can be returned from keywords or created in variable files, but they can also be created in the variable table:

*** Variables ***
&{DICT}    key=value    second=2    third=${3}

The above example will create a dictionary variable &{DICT} with Python dictionary {'key': 'value', 'second': '2', 'third': 3} as the value. If a dictionary variable is used as a scalar variable like ${DICT}, it will be passed forward as a single argument containing the whole dictionary. If it used like &{DICT}, individual items are passed as named arguments. For example, these two examples are equivalent:

*** Test Cases ***
Example 1
    My Keyword    key=value    second=2    third=${3}
Example 2
    My Keyword    &{DICT}

Individual dictionary variable items can be accessed either using special &{DICT}[key] syntax similarly as individual list variable items can be accessed like @{LIST}[0]. As a special feature, dictionary variables are ordered and allow accessing values also using attribute access like ${DICT.key}. For more information about dictionary variables, see Variables section the User Guide.

NOTE: RIDE editor does not currently support dictionary variables.

Python style **kwargs support with user keywords using &{kwargs} syntax (#1561)

New dictionary variable syntax can be used with user keywords to accept free keyword arguments similarly as Python based keywords can accept **kwargs. This can be accomplished simply by having a dictionary variable like &{kwargs} as the last argument in user keyword argument specification:

*** Keywords ***
Run My Process
    [Arguments]    @{arguments}    &{configuration}
    Run Process    myproc.exe    @{arguments}    &{configuration}

Also this new functionality is explained with further examples in the User Guide.

Embedded arguments in keywords defined in test libraries (#1818)

User keywords have supported embedded arguments since RF 2.1.1 (#370), and finally this functionality is supported also by library keywords. This is accomplished by giving a custom name to a keyword by setting robot_name attribute manually or by using robot.api.deco.keyword' decorator (#1835), and using${args}` in the name similarly as with user keywords. The implementing method or function must also accept same number of arguments as there are embedded argument.

from robot.api.deco import keyword

@keyword(name='User "${user}" selects "${item}" from webshop')
def select_item(user, item):
    # ...

The User Guide is, again, the place where to find more information and examples.

Other high priority enhancements and fixes

• Scalar and list variables stored in same namespace (#1905)
• Standard libraries do not mask third party Python modules (#1737)
• Fixed sporadic failures with timeouts on IronPython (#1931)

Backwards incompatible changes

Being a major release, RF 2.9 contains lot of changes and some of them are backwards incompatible.

List and scalar variables stored in same namespace (#1905)

It has been possible to use a list variable @{list} as a scalar variable ${list} since RF 2.0.3 (#117), and scalar variables containing lists have been usable as list variables since RF 2.8 (#483). It has, however, been possible to also create scalar and list variables with same base name, for example, in the variable table:

*** Variables ***
${VAR}    Scalar variable
@{VAR}    List    variable

This caused a lot of confusion, and the addition of &{dictionary} variables (#1450) would have made situation even more complicated. As a result it was decided to store all variables in the same namespace (#1905) and decide how they are used depending on the format (e.g. ${var} for scalar, @{var} for list, and &{var} for dictionary).

As a result of this change, tests using scalar and list variables with same base name will need to be updated. Unfortunately there is no other good way to detect these problems than running tests with the new version and seeing does anything break.

Standard libraries not importable in Python w/o robot.libraries prefix (#1737)

It used to be possible to import Robot Framework's standard libraries in Python code by just using the library name like import DateTime. This caused problems in with standard libraries having same name as third party Python modules like DateTime.

To avoid these problems, standard libraries are not anymore directly importable in Python code. They are still importable with the robot.libraries prefix like from robot.libraries import DateTime. This has also always been the recommended way and the one used in examples in the User Guide.

Disabling command line options accepting no values by using same option again not supported anymore

Earlier it was possible to disable options accepting no values like --dryrun by giving the option again like --dryrun --other options --dryrun. This was rather confusing, and nowadays it is possible to do that by using the same option with no prefix like --nodryrun instead (#1865). If option is used with and without the no prefix, the last used value has precedence. Having same option multiple times has no special functionality anymore.

Possible equal signs in arguments to BuiltIn.Call Method need to be escaped

Call Method nowadays supports **kwags (#1603) and thus possible equal signs in normal arguments need to be escaped with a backslash like hello\=world.

Unused internal functions, classes, etc. removed

See issue #1924 for a detailed list of changes to internal APIs. These changes should not affect libraries or tools using Robot Framework's public APIs.

Other backwards incompatible changes

These changes should generally not cause problems in real life. See linked issues for more details if you think you may be affected.

• Not possible to use keyword with embedded arguments as a normal keyword (#1962)
• When assigning keyword return values to multiple scalar variables, an exact number of values is required (#1910)
• Create Dictionary keyword moved from Collections to BuiltIn (#1913)
• Keyword name conflict involving Remote library keyword causes failure and not warning (#1815)
• Possibility to set scalar variables with lists value using Set Test/Suite/Global Variable keyword removed (#1919)
• Deprecated syntax for repeating single keyword removed (#1775)
• Deprecated --runmode option removed (#1923)
• Deprecated --xunitfile option removed in favor of --xunit (#1925)
• Deprecated way to exit for loops using custom exception with ROBOT_EXIT_FOR_LOOP attribute has been removed (#1440)

Deprecated features

Robot Framework 2.9 also deprecates some features that will be removed in the future releases. See linked issues for more details.

• OperatingSystem.Start Process keyword deprecated in favor of much more flexible Process.Start Process (#1773)
• Listener interface version 1.0 deprecated (#1841)
• --runfailed and --rerunmerge options deprecated in favor of --rerunfailed and --merge, respectively (#1642)
• Old Meta: Name syntax for specifying test suite metadata deprecated (#1918)
• DeprecatedBuiltIn and DeprecatedOperatingSystem officially deprecated (#1774)

Acknowledgements

Big thanks for Jared Hellman (@hellmanj) for implementing both support for embedded arguments with library keywords (#1818) and custom library keyword names (#1835) required by it.

Full list of fixes and enhancements

ID	Type	Priority	Summary
#1450	enhancement	critical	Dictionary variable type
#1561	enhancement	critical	Support Python style **kwargs with user keywords using &{kwargs} syntax
#1905	enhancement	critical	Store list and scalar variables in same namespace
#1737	bug	high	Standard libraries should not be importable in Python w/o robot.libraries prefix
#1931	bug	high	Timeouts can cause sporadic failures with IronPython
#1818	enhancement	high	Embedded arguments in keywords defined in test libraries
#1928	enhancement	high	Drop Python/Jython 2...

Robot Framework 2.8.7

Robot Framework 2.8.7

Robot Framework 2.8.7 is a new minor release with lots of enhancements and bug fixes. It was released on Friday January 16, 2015.

Installation packages are on PyPI. If you have pip available, just run pip install --upgrade robotframework to install the latest version. Otherwise see installation instructions.

Questions and comments related to the release can be sent to the robotframework-users and possible bugs submitted to the issue tracker.

Most important bug fixes

• Installation on Jython/Python 2.5 broken (#1842)
• Running Robot on thread failed (#1848)
• Testdoc broken (#1862)
• Failures in suite teardown ignored with --rerunfailed and when generating only report with Rebot (#1873)

Most important enhancements

• Libdoc: Support searching keywords by name, arguments, and keywords (#1872). See latest standard library docs for an example.
• Support floats in FOR IN RANGE loop (#1850)

Acknowledgements

This release has the biggest number of external contributions ever! Many thanks to Michael Walle for contributing Telnet.Read Until Prompt strip_prompt option (#1874), to Tero Kinnnunen for BDD 'But' prefix (#1878), to Heiko Thiery for log level config option for TelnetLibrary (#1879), to Nicolae Chedea for float parameters in FOR IN RANGE (#1850), and Guy Kisel for making tidy split ELSE, ELSE IF, and AND to own rows (#1273).

Also thanks to everyone else who has contributed with bug reports, feature requests, patches, and fixes.

Full list of fixes and enhancements

ID	Type	Priority	Summary
#1842	bug	critical	Installation broken with Jython/Python 2.5
#1848	bug	high	Running Robot Framework on thread fails because signal handlers cannot be registered
#1862	bug	high	Testdoc broken in 2.8.6
#1873	bug	high	Failures in suite teardown ignored with --rerunfailed and when generating only report with Rebot
#1872	enhancement	high	Libdoc: Support searching keywords by name, arguments, and keywords
#1821	bug	medium	TestSuite.run does not remove its log handler from the root logger
#1838	bug	medium	Results get same timestamps if multiple test runs executed programmatically
#1866	bug	medium	Variable file and listener arguments from command line cannot contain colons
#1867	bug	medium	Rebot does not preserve order of keywords and messages in output.xml
#1850	enhancement	medium	Support using floats in FOR IN RANGE loop
#1860	enhancement	medium	Redirect messages logged with robot.api.logger to Python logging when Robot is not running
#1878	enhancement	medium	Ignore also But BDD prefix
#1879	enhancement	medium	Telnet: Support configuring log level of telnetlib debug messages
#1273	enhancement	medium	Tidy should split ELSE, ELSE IF, and AND to own rows
#1859	bug	low	Cannot set __doc__ dynamically for library class
#1870	bug	low	Process w/ Jython 2.7: Terminate Process fails with IOError if standard streams are used
#1883	bug	low	Reloading report settings from hash fails on IE8
#1884	bug	low	Variables and escape sequences in suite doc not resolved in console output
#1845	enhancement	low	Document that when matching tags, AND, OR and NOT in tags themselves must be given as lower case
#1851	enhancement	low	UG: Improve documentation about using resource files with initialization files
#1861	enhancement	low	Process: Enhance documentation related to process arguments
#1864	enhancement	low	Testdoc: Support for creating link targets and opening them
#1874	enhancement	low	Add option to Telnet.Read Until Prompt to remove prompt from return value

Altogether 23 issues. See on issue tracker.

Robot Framework 2.8.6

Robot Framework 2.8.6

Robot Framework 2.8.6 is a new minor release with lots of enhancements and bug fixes. It was released on Tuesday October 7, 2014.

Questions and comments related to the release can be sent to the robotframework-users and possible bugs submitted to the issue tracker.

If you have pip just run pip install --update robotframework. Otherwise see installation instructions.

Most important enhancements

• Support for more general merging results with Rebot (#1687).
• Improved logfiles with collapse all (#1478), new icons (#1808), and elapsed time on header row (#1796).
• Recommendations for not found variables (#1804) and keywords (#888).

Backwards incompatible changes

• We have removed the old external tools from the distribution. Issue #1754 lists where the tools have moved.
• Support for variables in named arguments and kwarg names (#1793) may possibly cause problems in some cases. See the comments here for details.
• install.py script has been removed (#1753).

Acknowledgements

Many thanks to Guy Kisel (@guykisel) for contributing these new features:

• BuiltIn.Log pprint support (#1666).
• New pattern matching keywords in Collections (#1724).
• Keyword/variable not found recommendations (#888 and #1804).

Also thanks to everyone else who has contributed with bug reports, feature requests, patches, and fixes.

Full list of fixes and enhancements

ID	Type	Priority	Summary
#1748	bug	high	XML: Parsing file with comments fails when using lxml
#1759	bug	high	Variable refering to itself crashes the execution
#1687	enhancement	high	Support more general merging results with Rebot
#1768	enhancement	high	Set up CI
#1779	enhancement	high	Add INSTALL.rst to project root
#1741	bug	medium	Documentation of new DateTime library is not included in User Guide package
#1764	bug	medium	DateTime: Default timestamp can contain .1000 milliseconds while it should only use three digit precision
#1784	bug	medium	XML library: Element in no namespace assigned to parent element namespace
#1794	bug	medium	Repeat Keyword does not continue if failure is continuable
#1806	bug	medium	Log: Back button broken when opening test or suite using link
#1816	bug	medium	In plaint text files `
#1478	enhancement	medium	Log: Support Collapse All in addition to Expand All
#1666	enhancement	medium	BuiltIn.Log: Use pprint.pformat to format the message when repr=True
#1724	enhancement	medium	Collections: New keywords for matching list items using glob/regexp patterns optionally case/space sensitively
#1735	enhancement	medium	String: Keywords to convert strings to uppercase and lowercase
#1749	enhancement	medium	XML: New keywords to set/remove text/tag/attribute of several elements in one call
#1754	enhancement	medium	Remove tools distributed with the framework
#1789	enhancement	medium	Better introduction on PyPI
#1793	enhancement	medium	Support variables in named arguments and kwarg names (e.g. ${hello}=world)
#1796	enhancement	medium	Log: Elapsed time to be visible on suite, test and keyword headers
#1799	enhancement	medium	Remote: Support for timeouts to avoid hanging connections
#1802	enhancement	medium	Doc formatting: New inline style code
#1804	enhancement	medium	Variable suggestions when variable matching failed
#1807	enhancement	medium	Support for stopping execution on error (--ExitOnError)
#1810	enhancement	medium	Better packaging infrastructure
#888	enhancement	medium	Keyword suggestions when keyword matching failed
#1738	bug	low	Process: Arguments to Run/Start Process should be converted to strings when necessary
#1739	bug	low	BuiltIn.Convert to Hex/Octal add 'L' suffix when input is bigger than sys.maxint
#1767	bug	low	HTML special characters shown in escaped format in statistic table pop-ups
#1771	bug	low	Using keyword with dot in name using long format (e.g. MyLib.Keyword.with.dot) fails
#1797	bug	low	Libdoc outputs don't handle incoming links where spaces are encodes as +
#1813	bug	low	Warning about custom keyword overriding standard keyword is not linked to executed keyword
#1814	bug	low	Warning about custom keyword overriding standard keyword contains conflicting library names when importing using WITH NAME syntax
#1753	enhancement	low	Remove non-needed install.py script
#1766	enhancement	low	Rename/convert RF's own acceptance tests from .txt and .html to .robot
#1795	enhancement	low	BuiltIn: Bad error message if keyword evaluating expression (e.g. Evaluate, Should Be True) is used with an empty string
#1808	enhancement	low	Log: Consistent icons

Altogether 37 issues. See on issue tracker.