Skip to content

Latest commit

 

History

History
1421 lines (1216 loc) · 54.4 KB

rf-3.2rc1.rst

File metadata and controls

1421 lines (1216 loc) · 54.4 KB
Raw

Robot Framework 3.2 release candidate 1

Robot Framework 3.2 is a new major release with an enhanced test data parser, handy @library and @not_keyword decorators, enhanced Libdoc spec files for external tools, inline Python evaluation support, and many other interesting new features and lot of bug fixes. Robot Framework 3.2 rc 1 contains all changes planned to the final release. Users are highly recommended to test it in their environments and report possible problems.

Questions and comments related to the release can be sent to the robotframework-users mailing list or to Robot Framework Slack, and possible bugs submitted to the issue tracker.

If you have pip installed, just run

pip install --pre --upgrade robotframework

to install the latest available release or use

pip install robotframework==3.2rc1

to install exactly this version.

Alternatively you can download the source distribution from PyPI and install it manually. If you are interested to test the standalone jar distribution, you can find it from the GitHub release page. For more details and other installation approaches, see the installation instructions.

Robot Framework 3.2 release candidate 1 was released on Friday April 3, 2020. It was replaced by release candidate 2 on Tuesday April 21, 2020.

Most important enhancements

New test data parser

The absolutely biggest new feature in Robot Framework 3.2 is the new test data parser (#3076). The parser has been totally rewritten, but for most parts it should work exactly like the earlier one.

The most important reason for the parser rewrite was making it possible to add new syntax to Robot Framework in the future. No new syntax is introduced yet in Robot Framework 3.2, but there are plans to add, for example, IF/ELSE (#3074), TRY/EXCEPT (#3075), and nested control structures (#3079) in Robot Framework 4.0 sometime in 2021.

The new parser also has much better APIs for external tools like editors, linters and code formatters than the old one (#3373). See the API documentation for more information and examples. The drawback of the new APIs is that tools using the old parsing APIs need to be updated.

New parsing APIs are already used by the robotframework-lsp project that exposes parsing (and other) APIs to editors and IDEs via the language server protocol (LSP). This is a new project but definitely worth checking out for anyone interested in developing editor plugins for Robot Framework. The project also has ready-made integration to VSCode.

For the user the biggest direct enhancements provided by the new parser are storing line numbers during parsing (#549) and preserving ellipsis (...) denoting line continuation (#1272). The former means that many error messages nowadays tell on which line the error occurred and the latter means that tools like Tidy do not mess up the original formatting (#2579).

The new parser supports only the plain text format (#3081). This means that the HTML format is not supported at all and the TSV format is supported only when it is fully compatible with the plain text format. Because the new parser only parses *.robot files by default (#3084), users of the *.txt, *.tsv, or *.rst files need to explicitly use the --extension option.

New @library decorator

The new @library decorator can be used to decorate library classes (#3019) and it provides these useful features:

  • It makes it convenient to set library scope, version, documentation format and listener. For example, these two libraries are equivalent:

    from robot.api.deco import library


@library(scope='GLOBAL', version='3.2b1')
class NewWay:
    # actual library code


class OldWay:
    ROBOT_LIBRARY_SCOPE = 'GLOBAL'
    ROBOT_LIBRARY_VERSION = '3.2b1'

    # actual library code

  • It forces using the @keyword decorator by default (#3221). Only methods decorated with the @keyword decorator become keywords:

    from robot.api.deco import library, keyword


@library
class Example:

    @keyword
    def example_keyword(self):
        # ...

    def not_exposed_as_keyword(self):
        # ...

    If this behavior is needed with modules, it can be enabled by setting a module level attribute ROBOT_AUTO_KEYWORDS = False. If this behavior needs to be disabled when using the @library decorator, it is possible to use @library(auto_keywords=True).

New @not_keyword decorator

The @not_keyword decorator is another way to tell Robot Framework that a certain function or methods should not be considered a keyword (#3455):

from robot.api.deco import not_keyword


def example_keyword(self):
    # ...

@not_keyword
def not_exposed_as_keyword(self):
    # ...

This functionality is also used to mark the old @keyword decorator, the new @library decorator, and the @not_keyword decorator itself as not being keywords (#3454).

Enhanced Libdoc spec files

The Libdoc tool is typically used for creating library documentation in HTML for humans to read, but it can also create XML spec files where external tools can easily read all the same information. These spec files have been enhanced heavily in Robot Framework 3.2:

  • Actual library and keyword documentation in spec files can be converted to HTML format by using the new XML:HTML format like --format XML:HTML (#3301).
  • Support for custom *.libspec extension has been added (#3491). When an output file has that extension, Libdoc uses the aforementioned XML:HTML format by default.
  • Spec files have an XSD schema (#3520). It can be used for validation and it also thoroughly documents the spec format. The schema can be found here.
  • Somewhat related to the above, the specversion attribute tells the spec version that has been used (#3523). The current version is 2 and it will incremented if and when changes are made.
  • Library and keyword source information is included (#3507). This includes a relative path to the file where library and each keyword is implemented along with the line number.
  • Deprecated keywords get deprecated="true" attribute automatically (#3498).
  • scope and namedargs elements have been changed to attributes (#3522). scope is nowadays consistently GLOBAL, SUITE or TEST (#3532) and namedargs is a Boolean and not string yes/no. For backwards compatibility reasons the old scope and namedargs elements are still written to the spec files with old values.
  • type attribute values have been changed to upper case LIBRARY and RESOURCE (#3534). Tools using this information need to be updated.
  • generated attribute has been changed from local time in custom format to UTC time represented as xsd:dateTime (#3528). Tools using this value need to be updated.

Inline Python evaluation

Another nice feature is being able to evaluate Python expressions inline using a variation of the variable syntax like ${{expression}} (#3179). The actual expression syntax is basically the same that the Evaluate keyword and some other keywords in the BuiltIn library support. The main difference is that these keywords always evaluate expressions and thus the ${{}} decoration is not needed with them.

Main use cases for this pretty advanced functionality are:

  • Evaluating Python expressions involving Robot Framework's variables (${{len('${var}') > 3}}, ${{$var[0] if $var is not None else None}}).
  • Creating values that are not Python base types (${{decimal.Decimal('0.11')}}, ${{datetime.date(2019, 11, 12)}}).
  • Creating values dynamically (${{random.randint(0, 100)}}, ${{datetime.date.today()}}).
  • Constructing collections, especially nested collections (${{[1, 2, 3, 4]}}, ${{ {'id': 1, 'name': 'Example', children: [7, 9]} }}).
  • Accessing constants and other useful attributes in Python modules (${{math.pi}}, ${{platform.system()}}).

This is somewhat similar functionality than the old extended variable syntax. As the examples above illustrate, this syntax is even more powerful as it provides access to Python built-ins like len() and modules like math. In addition to being able to use variables like ${var} in the expressions (they are replaced before evaluation), variables are also available using the special $var syntax during evaluation.

Related to this change, also Evaluate and other BuiltIn keywords that evaluate expressions import modules automatically (#3349).

Native &{dict} iteration with FOR loops

FOR loops support iterating dictionary items if values are &{dict} variables (#3485):

FOR    ${key}    ${value}    IN    &{dict}
    Log    Key is '${key}' and value is '${value}'.
END

It is possible to use multiple dictionaries and add additional items using the key=value syntax:

FOR    ${key}    ${value}    IN    &{first}    &{second}    one=more
    Log    Key is '${key}' and value is '${value}'.
END

If same keys is used multiple times, the last value is used but the original order of keys is preserved.

In the future this syntax will be generalized so that it works also if all values use the key=value syntax even if none of the values is a &{dict} variable. In Robot Framework 3.1 such usage causes a deprecation warning. Escaping like key\=value is possible to avoid dictionary iteration.

In addition to using separate loop variables for key and value, it is possible to use one variable that then becomes a key-value tuple:

FOR    ${item}    IN    &{dict}
    Length Should Be    ${item}    2
    Log    Key is '${item}[0]' and value is '${item}[1]'.
END

The dictionary iteration works also with the FOR IN ENUMERATE loops:

FOR    ${index}    ${key}    ${value}    IN ENUMERATE    &{dict}
    Log    Key is '${key}' and value is '${value}' at index ${index}.
END
FOR    ${item}    IN ENUMERATE    &{dict}
    Length Should Be    ${item}    3
    Log    Key is '${item}[1]' and value is '${item}[2]' at index ${item}[0].
END

Listeners can add and remove tests

Listeners are a powerful feature of Robot Framework and RF 3.2 makes them a bit more powerful. Earlier listeners using the API v3 could not add or remove new tests in their start/end_test methods (#3251), but this limitation has now been lifted. This makes it easier to implement advanced tooling, for example, for model based testing using Robot Framework in its core.

Signatures of "wrapped" keywords are read correctly

When implementing keywords in libraries, it is sometimes useful to modify them with Python decorators. However, decorators often modify function signatures and can thus confuse Robot Framework's introspection when determining which arguments keywords accept. This includes also argument default values and type hints.

Starting from Robot Framework 3.2 and when using Python 3, it is possible to avoid this problem by decorating the decorator itself using functools.wraps (#3027). In that case Robot Framework will automatically "unwrap" the function or method to see the real signature.

Standalone jar distribution updated to use Jython 2.7.2

The standalone jar distribution was earlier based on Jython 2.7.0 but nowadays it uses Jython 2.7.2 (#3383). This brings all features and fixes in the newer Jython version. If you are interested to test the standalone jar, you can find it from the GitHub release page. Only the final release will be uploaded to the Maven Central.

Continuous integrating

Robot Framework project has not had working continuous integration (CI) since the Nokia days but now we finally have it again (#3420). Our CI system is based on GitHub actions and it runs tests automatically every time code is pushed to the repository or a pull request is opened. You can see all actions at https://github.com/robotframework/robotframework/actions.

Backwards incompatible changes

Although we try to avoid backwards incompatible changes, sometimes adding new features mean that old features need to be changed or even removed. This is never done lightly and we try to limit backwards incompatible changes to major releases. In Robot Framework 3.2 these changes are mainly related to parsing one way or the other.

HTML and TSV formats are not supported anymore

The new test data parser (#3076) supports only the plain text format and as a result neither HTML nor TSV formats are supported anymore (#3081). The TSV format still works if it is fully compatible with the plain text format, but the support for the HTML format has been removed for good.

Only *.robot files are parsed by default

When executing a directory, Robot Framework nowadays only parsers *.robot files by default (#3084). Users of the *.txt, *.tsv, or *.rst file need to explicitly use the --extension option like --extension tsv or --extension robot:tsv. When executing a single file, the file is parsed regardless the extension.

Parsing APIs have been rewritten

One of the nice features of the new test data parser is the new stable parsing API (#3373). Unfortunately this API is stable only going forward, and all tools using the old parsing API need to be updated when migrating to Robot Framework 3.2. To see what has changed, see the old and new API documentation.

Changes to recognizing and evaluating variables

When finding variables, all un-escaped curly braces in the variable body are nowadays expected to be closed, when earlier the first closing curly brace ended the variable (#3288). This means that, for example, ${foo{bar}zap} is a single variable, but it used to be considered a variable ${foo{bar} followed by a literal string zap}. This also applies to variable item access syntax ${var}[item] so that possible unescaped opening square brackets in the item part are expected to be closed.

This change was done to make it possible to implement inline Python evaluation using ${{expression}} syntax (#3179). Another benefit of the change is that embedded arguments containing custom patterns can be specified without escaping like ${date:\d{4}-\d{2}-\d{2}}. Unfortunately it also means that the old ${date:\d{4\}-\d{2\}-\d{2\}} syntax will not work anymore. A workaround that works regardless Robot Framework version is avoiding curly braces like ${date:\d\d\d\d-\d\d-\d\d}.

In addition to the variable parsing logic changing, also variable evaluation changes a little. These changes are limited to handling possible escape characters in variable body (#3295) and thus unlikely to cause bigger problems.

Variables in test case names are resolved

Earlier test case names were always used as-is, without replacing possible variables in them, but this was changed by #2962. If this causes problems, variables need to be escaped like Example \${name}.

Changes to handling non-ASCII spaces

The old parser handled non-ASCII spaces such as the no-break space somewhat inconsistently (#3121). The new parser fixes that and as a result changes the syntax a little. Luckily it is pretty unlikely that these changes affect anyone.

  • Any space character is considered a separator. Earlier only the normal ASCII space and the no-break space were considered separators.
  • Non-ASCII spaces in test data itself (i.e. not in separators) are not converted to normal spaces anymore. You can, for example, have an argument with a no-break space.
  • When using the pipe-separated format, consecutive spaces are not collapsed anymore. This affects also normal spaces, not only non-ASCII spaces.

Old for loop style not supported with pipe-separated format

RF 3.2 deprecates the old-style for loops in general, but when using the pipe-separated format there are even bigger changes. Earlier it was possible to use syntax like

| :FOR | ${x} | IN | 1 | 2
|      | Log  | ${x}

but this is not supported anymore at all. The recommended way to resolve this problem is switching to the new for loop style where :FOR is replaced with FOR and an explicit END marker is added:

| FOR | ${x} | IN | 1 | 2
|     | Log  | ${x}
| END |

For alternatives and more details in general see issue #3108.

Stricter section and setting name syntax

Section names like Test Cases and setting names like Test Setup are nowadays space sensitive (#3082). In practice this means that sections like TestCases or settings like TestSetup are not recognized.

Stricter for loop separator syntax

For loop separators IN, IN RANGE, IN ZIP and IN ENUMERATE are both case and space sensitive (#3083). In other works, separators like in or INZIP are nor recognized. Notice also that the old FOR loop syntax has been deprecated in general.

Libdoc spec files have changed

As discussed earlier, Libdoc spec files have been enhanced heavily. Most of the changes are backwards compatible, but these changes may cause problems for tools using the spec files:

  • type attribute values have been changed to upper case LIBRARY and RESOURCE (#3534).
  • generated attribute has been changed from local time in custom format to UTC time represented as xsd:dateTime (#3528).

Pre-run modifiers are run before selecting tests cases to be executed

Earlier possible --test, --suite, --include, and --exclude were executed before running pre-run modifiers, but that order has now been reversed. The main reason was to allow using the aforementioned command line options to match also tests generated by pre-run modifiers. Possible use cases where the old order was important are obviously affected. If such usages are common, we can consider reverting this change or somehow making it possible to select which order to use.

Other backwards incompatible changes

  • Using variable item access syntax like ${var}[0] works with all sequences including strings and bytes (#3182). With RF 3.1 that caused an error with sequences that were not considered list-like and with earlier versions this syntax was interpreted as variable ${var} followed by a literal string [0].
  • BuiltIn keywords Should Contain X Times and Get Count argument names have been changed from item1, item2 to container, item to be consistent with other similar keywords (#3486). This affects tests only if keywords have been used with the named argument syntax like item2=xxx.
  • String library methods convert_to_uppercase and convert_to_lowercase have been renamed to convert_to_upper_case to convert_to_lower_case, respectively (#3484). This does not affect how keywords can be used in test data (both Convert To Upper Case and Convert To Uppercase variants work with all releases) but if someone uses these methods programmatically those usages need to be changes. There should be no need for such usage, though, as Python strings have built-in upper and lower methods.
  • Support for custom timeout messages has been removed (#2291). This functionality was deprecated already in Robot Framework 3.0.1 and it has now finally been removed.
  • --escape option has been removed (#3085). This option used to allow escaping problematic characters on the command line. Shell escaping or quoting mechanism needs to be used instead.
  • --warnonskippedfiles option has been removed (#3086). This option did not have any effect anymore and has now been removed altogether.
  • Using &{dict} variable with FOR loops initiates dictionary iteration (#3485). If this is not desired, the variable syntax should be changed to ${dict}.

Deprecated features

Whenever we notice a feature that needs to be changed in backwards incompatible manner, we try to first deprecate the feature at least one major release before the removal. There are not that many deprecations in Robot Framework 3.2, but unfortunately especially changes to the for loop syntax are likely to affect many users.

Old FOR loop syntax

Robot Framework 3.1 enhanced FOR loop syntax so that nowadays loops can be written like this:

FOR    ${animal}    IN    cat    dog    cow
    Keyword    ${animal}
    Another keyword
END

This is a big improvement compared to the old syntax that required starting the loop with :FOR and escaping all keywords inside the loop with a backslash:

:FOR    ${animal}    IN    cat    dog    cow
\    Keyword    ${animal}
\    Another keyword

The old format still worked in Robot Framework 3.1, but now using :FOR instead of FOR (#3080) and not closing the loop with an explicit END (#3078) are both deprecated. The old syntax will be removed for good already in Robot Framework 3.3.

This change is likely to cause lot of deprecation warnings and requires users to update their test data. Here are some ideas how to find and updated the data:

  • Run tests and see how many deprecation warnings you get. The warning should tell where the old syntax is used. Even if you use some other way to find these usages, running tests tells you have you caught them all.
  • Use the Tidy tool to update data. It also changes data otherwise, so it is a good idea to check changes and possibly commit only changes relevant to FOR loops. Tidy updates the old FOR loop syntax to new one starting from Robot Framework 3.1.2.
  • Use operating system search functionality to find :FOR (case-insensitively) as well as possible : FOR variant from test data files. Then update loops by hand.

  • Use an external command line tool like ack (Perl) or pss (Python) to find :FOR and : FOR and update data by hand. If using the pss tool, this command works well:

    pss -ai ": ?FOR" path/to/tests

FOR loops when all values are in key=value syntax

The &{dict} iteration syntax with FOR loops (#3485) supports giving additional items using the key=value syntax like:

FOR    ${key}    ${value}    IN    &{dict}    another=item    one=more
    Log    Key is '${key}' and value is '${value}'.
END

In the future this will be generalized so that the same syntax works also if none of the values is a &{dict} variable:

FOR    ${key}    ${value}    IN    key=value    another=item    one=more
    Log    Key is '${key}' and value is '${value}'.
END

With Robot Framework 3.2 the above syntax still works as it did earlier but there is a deprecation warning. Notice that this problem occurs _only if all values are like xxx=yyy. An easy way to avoid is it escaping at least one of the values like xxx\=yyy.

Accessing list and dictionary items using @{var}[item] and &{var}[item]

Robot Framework 3.1 enhanced the syntax for accessing items in nested lists and dictionaries by making it possible to use ${var}[item] and ${var}[nested][item] syntax regardless is ${var} a list or dictionary. The old variable type specific syntax @{list}[item] and &{dict}[item] still worked, but this usage has now been deprecated (#2974).

Also this deprecation is likely to cause quite a lot of warnings and require users to update their data. Exactly like with for loops discussed above, running tests is the easiest way to find out how much work there actually is. The Tidy tool cannot handle this deprecation, but otherwise same approach works to find these usages that was recommended with old for loops. If using the pss tool, these commands help:

pss -ai "@\{.+\}\[" path/to/tests
pss -ai "&\{.+\}\[" path/to/tests

Ignoring space after literal newline is deprecated

Earlier two\n lines has been considered equivalent to two\nlines in Robot Framework data. This syntax helped constructing multiline strings when using the HTML format, but now that the HTML format is not supported this syntax has been deprecated (#3333). It is unlikely that it would have been used widely.

Acknowledgements

Robot Framework 3.2 development has been sponsored by the Robot Framework Foundation. Due to the foundation getting some more members and thus more resources, there has now been two active (but part-time) developers. Pekka Klärck has continued working as the lead developer and Janne Härkönen has been driving the new parser development. Big thanks to all the 30+ member organizations for making that possible and for your support in general! Hopefully the foundation growth continues and we can speed up the development even more in the future.

In addition to the work sponsored by the foundation, we have got several great contributions by the wider open source community:

  • Simandan Andrei-Cristian implemented the @library decorator (#3019), added possibility to force using the @keyword decorator (#3221), created the Set Local Variable keyword (#3091) and added note to the Screenshot library documentation about the more powerful ScreenCapLibrary (#3330)
  • Bollen Nico and JasperCraeghs added support to use variable index access like ${var}[2] with all sequences, including strings and bytes (#3182)
  • Mihai Pârvu added support to read "wrapped" signatures correctly (#3027) and enhanced Libdoc, TestDoc and Tidy tools as well as Robot Framework's syslog files to automatically create output directories (#2767)
  • René made it possible to store documentation in Libdoc XML spec files using HTML regardless the original documentation format (#3301) and helped creating XSD schema for these spec files (#3520)
  • Dirk Richter added support to automatically expand certain keywords in the log file (#2698)
  • Vladimir Vasyaev enhanced the built-in support for environment variables to allow default values like %{EXAMPLE=default} (#3382)
  • Stavros Ntentos made it easier to disable process timeouts when using the Process library (#3366) and fixed equality checking with Tags objects (#3242)
  • Adrian Yorke implemented support to disable stdout and stderr altogether when using the Process library (#3397)
  • Bharat Patel enhanced Lists Should Be Equal keyword to allow ignoring order (#2703) and provided initial implementation to Convert To Title Case keyword (#2706)
  • Richard Turc added support to use variables in test case names (#2962)
  • Theodoros Chatzigiannakis fixed connection problems with the Remote library in some scenarios (#3300)
  • Jarkko Peltonen fixed Dialogs library leaving dialogs minimized at least on Windows Server 2016 (#3492)
  • Hélio Guilherme fixed Screenshot library with wxPython 4.0.7 on Linux (#3403)
  • Jani Mikkonen enhanced Libdoc to allow viewing keywords with a certain tag by using query parameters in the URL (#3440)
  • Mikhail Kulinich enhanced test message when results are merged with rebot --merge (#3319)
  • Lukas Breitstadt fixed using the ExecutionResult API with bytes (#3194)
  • Ossi R. added support for svg image links in documentation (#3464)
  • Teddy Lee enhance documentation syntax to support images with data URIs (#3536)
  • Marcin Koperski enhanced the plural_or_not used also by other tools to consider -1 singular (#3460)
  • Mikhail Kulinich and Juho Saarinen set up CI system for the Robot Framework project (#3420)

During the Robot Framework 3.2 development the total number of contributors to the Robot Framework project has gone over 100. That is a big number and a big milestone for the whole community! Huge thanks to all contributors and to everyone else who has reported problems, tested preview releases, participated discussion on various forums, or otherwise helped to make Robot Framework as well as the ecosystem and community around it better.

Thanks everyone and hopefully Robot Framework 3.2 works great for you!

Pekka Klärck,
Robot Framework Lead Developer

Full list of fixes and enhancements

ID Type Priority Summary Added
#3076 enhancement critical New test data parser alpha 1
#3081 enhancement critical Remove support for HTML and TSV formats alpha 1
#3251 bug high Listeners cannot add/remove tests in their start/end_test methods alpha 1
#1272 enhancement high Parsing modules should preserve ellipsis (...) denoting line continuation alpha 1
#2579 enhancement high Tidy should not merge continued lines alpha 1
#3019 enhancement high @library decorator that supports configuring and forces using @keyword to mark keywords beta 1
#3027 enhancement high Read signature (argument names, defaults, types) from "wrapped" keywords correctly beta 1
#3078 enhancement high Deprecate FOR loops without END alpha 1
#3080 enhancement high Deprecate FOR loops starting with case-insensitive :FOR alpha 1
#3084 enhancement high Remove support to parse other than *.robot files by default alpha 1
#3179 enhancement high Inline Python evaluation support using ${{expression}} syntax alpha 1
#3221 enhancement high Possibility to consider only methods decorated with @keyword keywords beta 1
#3373 enhancement high Stable parsing APIs beta 1
#3383 enhancement high Update standalone jar distribution to use Jython 2.7.2 rc 1
#3420 enhancement high Continuous integrating (CI) beta 1
#3455 enhancement high Add @not_keyword decorator to mark functions "not keywords" beta 2
#3485 enhancement high Native &{dict} iteration with FOR loops rc 1
#3507 enhancement high Include library and keyword source information in Libdoc spec files rc 1
#549 enhancement high Test parser should retain source line numbers beta 2
#3201 bug medium Log List and some other keywords in Collections and BuiltIn fail with tuples alpha 1
#3213 bug medium Using abstract base classes directly from collections causes deprecation warning alpha 1
#3226 bug medium XML library does not work with non-ASCII bytes on Python 2 or any bytes on Python 3 alpha 1
#3229 bug medium Variable in keyword teardown name causes failure in dry-run mode alpha 1
#3259 bug medium Libdoc doesn't handle bytes containing non-ASCII characters in keyword arguments alpha 1
#3263 bug medium Tidy does not preserve data before first section alpha 1
#3264 bug medium Robot output can crash when piping output alpha 1
#3265 bug medium --test/--suite/--include/--exclude don't affect tests added by pre-run modifiers alpha 1
#3268 bug medium Execution crashes if directory is not readable alpha 1
#3295 bug medium Inconsistent handling of escape character inside variable body alpha 1
#3300 bug medium Remote library fails to connect in some scenarios beta 1
#3306 bug medium DateTime: Get Current Date with epoch format and timezone UTC return wrong value alpha 1
#3338 bug medium Problems reporting errors when library import fails on Python 2 and import path contains non-ASCII characters alpha 1
#3355 bug medium `Evaluate`: Using nested modules like modules=rootmodule.submodule does not work alpha 1
#3364 bug medium Non-ASCII paths to test data not handled correctly with Jython 2.7.1+ alpha 1
#3403 bug medium Screenshot library doesn't work with wxPython 4.0.7 on Linux rc 1
#3424 bug medium Windows console encoding set with chcp not detected beta 1
#3454 bug medium @keyword decorator should not be exposed as keyword beta 2
#3483 bug medium Libdoc: Not possible to link to Tags section rc 1
#3500 bug medium Rerun functionality fails if test contains [x] rc 1
#2291 enhancement medium Remove possibility to specify custom timeout message alpha 1
#2698 enhancement medium Possibility to automatically expand certain keywords in log file beta 1
#2703 enhancement medium Lists Should Be Equal keywords in Collections should have an option to ignore order rc 1
#2706 enhancement medium String: Add Convert To Title Case keyword rc 1
#2974 enhancement medium Deprecate accessing list/dict items using syntax @{var}[item] and &{var}[item] alpha 1
#3085 enhancement medium Remove support using --escape to escape characters problematic on console alpha 1
#3091 enhancement medium Add Set Local Variable keyword alpha 1
#3121 enhancement medium Consistent handling of whitespace in test data alpha 1
#3182 enhancement medium Support variable index access like ${var}[2] with all sequences (incl. strings and bytes) rc 1
#3194 enhancement medium ExecutionResult should support input as bytes alpha 1
#3202 enhancement medium Upgrade jQuery used by logs and reports alpha 1
#3261 enhancement medium Add missing list methods to internally used ItemList alpha 1
#3269 enhancement medium Support any file extension when explicitly running file and when using --extension alpha 1
#3280 enhancement medium Libdoc: Support automatic generation of table of contents when using "robot format" rc 1
#3288 enhancement medium Require variables to have matching opening and closing curly braces and square brackets alpha 1
#3301 enhancement medium Libdoc: Support converting docs to HTML with XML outputs alpha 1
#3319 enhancement medium Enhance test message when results are merged with rebot --merge rc 1
#3333 enhancement medium Deprecate ignoring space after literal newline alpha 1
#3349 enhancement medium Automatically import modules that are used with Evaluate, Run Keyword If, and others alpha 1
#3366 enhancement medium `Run Process`: Ignore timeout if it is zero, negative or string None beta 1
#3382 enhancement medium Default values for environment variables beta 1
#3397 enhancement medium `Process`: Add option to disable stdout and stderr beta 1
#3440 enhancement medium Libdoc: Allow showing keywords based on tags using query string in URL beta 2
#3449 enhancement medium Support tokenizing strings with variables rc 1
#3451 enhancement medium Expose test line number via listener API v2 beta 2
#3463 enhancement medium Setting suggestions when using invalid setting beta 2
#3464 enhancement medium Add support for svg image links in documentation beta 2
#3491 enhancement medium Libdoc: Support *.libspec extension when reading library information from spec files rc 1
#3494 enhancement medium FOR IN ZIP and FOR IN ENUMERATE enhancements rc 1
#3498 enhancement medium Libdoc could better handle keywords deprecation info rc 1
#3514 enhancement medium Dynamic API: Support returning real default values from get_keyword_arguments rc 1
#3516 enhancement medium Dynamic API: Add new get_keyword_source method rc 1
#3520 enhancement medium Libdoc: Create xsd schema for spec files rc 1
#3522 enhancement medium Libdoc spec files: Change scope and namedargs to attributes rc 1
#3523 enhancement medium Add spec version to Libdoc spec files rc 1
#3532 enhancement medium Libdoc spec files: Change scope to use values GLOBAL, SUITE and TEST consistently rc 1
#2767 bug low Syslog, Libdoc, Testdoc and Tidy don't create directory for outputs alpha 1
#3231 bug low Log: Automatically formatting URLs does not handle { and } correctly beta 1
#3242 bug low Tags objects do not support equality checking correctly alpha 1
#3260 bug low Document that Tidy with --recursive doesn't process resource files alpha 1
#3339 bug low Libdoc, TestDoc and Tidy crash if output file is invalid alpha 1
#3422 bug low --help text related to disabling output has outdated information beta 1
#3453 bug low Methods implemented in C are not exposed as keywords beta 2
#3456 bug low Libdoc: Shortcuts are messed up on Firefox beta 2
#3460 bug low plural_or_not utility should consider -1 singular beta 2
#3489 bug low Variable containing = in its name should not initiate named argument syntax rc 1
#3524 bug low Rebot's merge message uses term "test" also with --rpa rc 1
#2962 enhancement low Support variables in test case names beta 1
#3082 enhancement low Remove support using section and setting names space-insensitively alpha 1
#3083 enhancement low Remove support using for loops with other separators than exact IN, IN RANGE, IN ZIP and IN ENUMERATE alpha 1
#3086 enhancement low Remove --warnonskippedfiles because it has no effect anymore alpha 1
#3195 enhancement low Support .yml extension in addition to .yaml extension with YAML variable files alpha 1
#3273 enhancement low UG: Handling documentation split to multiple columns will not change alpha 1
#3291 enhancement low Document making .robot files executable beta 1
#3330 enhancement low Add a note about more powerful ScreenCapLibrary to Screenshot library documentation alpha 1
#3365 enhancement low Document that zero and negative test/keyword timeout is ignored alpha 1
#3376 enhancement low UG: Enhance creating start-up scripts section beta 1
#3415 enhancement low Document (and test) that glob pattern wildcards like * can be escaped like [*] beta 1
#3465 enhancement low Better reporting if using valid setting is used in wrong context beta 2
#3484 enhancement low String: Rename convert_to_uppercase to convert_to_upper_case (and same with lower) rc 1
#3486 enhancement low BuiltIn: Consistent argument names to Should Contain X Times and Get Count rc 1
#3492 enhancement low Dialogs library bring to front doesn't work in Windows Server 2016 rc 1
#3528 enhancement low Libdoc specs: Change generation time to be valid xsd:dateTime rc 1
#3531 enhancement low Allow using "SUITE" and "TEST" as library scope values rc 1
#3534 enhancement low Libdoc spec files: Change type to upper case LIBRARY and RESOURCE rc 1
#3536 enhancement low Enhance documentation syntax to support images with data URIs rc 1
#645 enhancement low Empty rows should not be discarded during parsing alpha 1

Altogether 105 issues. View on the issue tracker.