Project pages 项目页面

The number one place to find more information about Robot Framework and the rich ecosystem around it is http://robotframework.org. Robot Framework itself is hosted on GitHub.
要了解有关Robot Framework及其丰富生态系统的更多信息，请访问http://robotframework.org。Robot Framework本身托管在GitHub上。

Mailing lists 邮件列表

There are several Robot Framework mailing lists where to ask and search for more information. The mailing list archives are open for everyone (including the search engines) and everyone can also join these lists freely. Only list members can send mails, though, and to prevent spam new users are moderated which means that it might take a little time before your first message goes through. Do not be afraid to send question to mailing lists but remember How To Ask Questions The Smart Way.
有几个Robot Framework邮件列表，可以在其中询问和搜索更多信息。邮件列表档案对所有人开放（包括搜索引擎），每个人都可以自由加入这些列表。只有列表成员可以发送邮件，但是，为了防止垃圾邮件，新用户会受到审核，这意味着在您的第一封邮件通过之前可能需要一点时间。不要害怕把问题发送到邮件列表，但要记住如何以聪明的方式提问。

robotframework-users

General discussion about all Robot Framework related issues. Questions and problems can be sent to this list. Used also for information sharing for all users.
关于所有Robot Framework相关问题的一般讨论。问题和疑问可以发送到这个列表。也用于所有用户的信息共享。

robotframework-announce

An announcements-only mailing list where only moderators can send messages. All announcements are sent also to the robotframework-users mailing list so there is no need to join both lists.
一个只有公告的邮件列表，只有版主可以发送消息。所有公告也会发送到robotframework-users邮件列表，因此无需加入两个列表。

robotframework-devel 机器人框架开发公司

Discussion about Robot Framework development.
讨论机器人框架的开发。

Installing Python on Linux
在Linux上安装Python

On Linux you should have suitable Python installation with pip available by default. If not, you need to consult your distributions documentation to learn how to install them. This is also true if you want to use some other Python version than the one provided by your distribution by default.
在Linux上，你应该有合适的Python安装，默认情况下pip可用。如果没有，您需要查阅发行版文档以了解如何安装它们。如果您想使用其他Python版本而不是您的发行版默认提供的版本，也是如此。

To check what Python version you have installed, you can run python --version command in a terminal:
要检查您安装的Python版本，您可以在终端中运行python --version命令：

$ python --version
Python 3.10.13

Notice that if your distribution provides also older Python 2, running python may use that. To use Python 3, you can use python3 command or even more version specific command like python3.8. You need to use these version specific variants also if you have multiple Python 3 versions installed and need to pinpoint which one to use:
请注意，如果您的发行版还提供较旧的Python 2，则运行python可能会使用它。要使用Python 3，您可以使用python3命令或更多版本特定的命令，如python3.8。如果您安装了多个Python 3版本，并且需要确定使用哪个版本，则也需要使用这些特定于版本的变体：用途：

$ python3.11 --version
Python 3.11.7
$ python3.12 --version
Python 3.12.1

Installing Robot Framework directly under the system provided Python has a risk that possible problems can affect the whole Python installation used also by the operating system itself. Nowadays Linux distributions typically use user installs by default to avoid such problems, but users can also themselves decide to use virtual environments.
直接在提供Python的系统下安装Robot Framework存在风险，可能的问题可能会影响操作系统本身使用的整个Python安装。如今，Linux发行版通常默认使用用户安装来避免此类问题，但用户也可以自己决定使用虚拟环境。

Installing Python on Windows
在Windows上安装Python

On Windows Python is not available by default, but it is easy to install. The recommended way to install it is using the official Windows installers available at http://python.org. For other alternatives, such as installing from the Microsoft Store, see the official Python documentation.
在Windows上，Python默认不可用，但它很容易安装。推荐的安装方法是使用官方的Windows安装程序，网址是http://python.org。有关其他替代方案，如从Microsoft Store安装，请参阅官方Python文档。

When installing Python on Windows, it is recommended to add Python to PATH to make it and tools like pip and Robot Framework easier to execute from the command line. When using the official installer, you just need to select the Add Python 3.x to PATH checkbox on the first dialog.
在Windows上安装Python时，建议将Python添加到PATH中，以使其以及pip和Robot Framework等工具更容易从命令行执行。当使用官方安装程序时，你只需要在第一个对话框中选择Add Python 3.x to PATH复选框。

To make sure Python installation has been successful and Python has been added to PATH, you can open the command prompt and execute python --version:
要确保Python安装成功，并且Python已添加到PATH中，您可以打开命令提示符并执行python --version：

C:\>python --version
Python 3.10.9

If you install multiple Python versions on Windows, the version that is used when you execute python is the one first in PATH. If you need to use others, the easiest way is using the py launcher:
如果你在Windows上安装了多个Python版本，那么当你执行Python时，使用的版本是PATH中的第一个版本。如果你需要使用其他的，最简单的方法是使用py启动器：

C:\>py --version
Python 3.10.9
C:\>py -3.12 --version
Python 3.12.1

Installing Python on macOS
在macOS上安装Python

MacOS does not provide Python 3 compatible Python version by default, so it needs to be installed separately. The recommended approach is using the official macOS installers available at http://python.org. If you are using a package manager like Homebrew, installing Python via it is possible as well.
MacOS默认情况下不提供Python 3兼容的Python版本，因此需要单独安装。推荐的方法是使用官方macOS安装程序，可从http://python.org获得。如果你使用的是像Homebrew这样的包管理器，也可以通过它安装Python。

You can validate Python installation on macOS using python --version like on other operating systems.
您可以在macOS上使用python --版本验证Python安装，就像在其他操作系统上一样。

PyPy installation PyPy安装

PyPy is an alternative Python implementation. Its main advantage over the standard Python implementation is that it can be faster and use less memory, but this depends on the context where and how it is used. If execution speed is important, at least testing PyPy is probably a good idea.
PyPy是一个替代的Python实现。与标准Python实现相比，它的主要优点是速度更快，占用的内存更少，但这取决于使用它的上下文以及使用方式。如果执行速度很重要，至少测试PyPy可能是个好主意。

Installing PyPy is a straightforward procedure and you can find both installers and installation instructions at http://pypy.org. To validate that PyPy installation was successful, run pypy --version or pypy3 --version.
安装PyPy是一个简单的过程，您可以在http://pypy.org上找到安装程序和安装说明。要验证PyPy安装是否成功，请运行pypy --version或pypy 3--version。

Configuring PATH
配置PATH

The PATH environment variable lists directories where commands executed in a system are searched from. To make using Python, pip and Robot Framework easier from the command line, it is recommended to add the Python installation directory as well as the directory where commands like pip and robot are installed into PATH.
PATH环境变量列出了在系统中执行的命令的搜索目录。为了使从命令行使用Python，pip和Robot Framework更容易，建议将Python安装目录以及pip和robot等命令的安装目录添加到PATH中。

When using Python on Linux or macOS, Python and tools installed with it should be automatically in PATH. If you nevertheless need to update PATH, you typically need to edit some system wide or user specific configuration file. Which file to edit and how depends on the operating system and you need to consult its documentation for more details.
在Linux或macOS上使用Python时，Python和随其安装的工具应自动位于PATH中。如果您仍然需要更新PATH，您通常需要编辑一些系统范围或用户特定的配置文件。编辑哪个文件以及如何编辑取决于操作系统，您需要查阅其文档以了解更多详细信息。

On Windows the easiest way to make sure PATH is configured correctly is setting the Add Python 3.x to PATH checkbox when running the installer. To manually modify PATH on Windows, follow these steps:
在Windows上，确保PATH配置正确的最简单方法是在运行安装程序时设置Add Python 3.x to PATH复选框。要在Windows上手动修改PATH，请执行以下步骤：

1. Find Environment Variables under Settings. There are variables affecting the whole system and variables affecting only the current user. Modifying the former will require admin rights, but modifying the latter is typically enough.
   在设置下找到环境变量。有影响整个系统的变量，也有只影响当前用户的变量。修改前者需要管理员权限，但修改后者通常就足够了。
2. Select PATH (often written like Path) and click Edit. If you are editing user variables and PATH does not exist, click New instead.
   选择PATH（通常写为Path），然后单击Edit。如果正在编辑用户变量，但PATH不存在，请单击“新建”。
3. Add both the Python installation directory and the Scripts directory under the installation directory into PATH.
   将Python安装目录和安装目录下的Python目录都添加到PATH。
4. Exit the dialog with Ok to save the changes.
   单击“OK”退出对话框以保存更改。
5. Start a new command prompt for the changes to take effect.
   启动新的命令提示符以使更改生效。

Running pip command
运行pip命令

Typically you use pip by running the pip command, but on Linux you may need to use pip3 or even more Python version specific variant like pip3.8 instead. When running pip or any of its variants, the pip version that is found first in PATH will be used. If you have multiple Python versions installed, you may need to pinpoint which exact version you want to use. This is typically easiest done by running python -m pip and substituting python with the Python version you want to use.
通常，您可以通过运行pip命令来使用pip，但在Linux上，您可能需要使用pip 3或更多Python版本特定的变体，如pip3.8。当运行pip或其任何变体时，将使用在PATH中首先找到的pip版本。如果您安装了多个Python版本，则可能需要确定要使用的确切版本。这通常是最简单的，通过运行python -m pip并将python替换为您想要使用的Python版本。

To make sure you have pip available, you can run pip --version or equivalent.
为了确保pip可用，您可以运行pip --版本或等效版本。

Examples on Linux: Linux上的示例：

$ pip --version
pip 23.2.1 from ... (python 3.10)
$ python3.12 -m pip --version
pip 23.3.1 from ... (python 3.12)

Examples on Windows: Windows上的示例：

C:\> pip --version
pip 23.2.1 from ... (python 3.10)
C:\> py -m 3.12 -m pip --version
pip 23.3.2 from ... (python 3.12)

In the subsequent sections pip is always run using the pip command. You may need to use some of the other approaches explained above in your environment.
在后续章节中，pip始终使用pip命令运行。您可能需要在您的环境中使用上面解释的其他一些方法。

Installing and uninstalling Robot Framework
安装和卸载Robot Framework

The easiest way to use pip is by letting it find and download packages it installs from the Python Package Index (PyPI), but it can also install packages downloaded from the PyPI separately. The most common usages are shown below and pip documentation has more information and examples.
使用pip最简单的方法是让它从Python包索引（PyPI）中找到并下载它安装的包，但它也可以单独安装从PyPI下载的包。最常见的用法如下所示，pip文档有更多的信息和示例。

# Install the latest version (does not upgrade)
pip install robotframework

# Upgrade to the latest stable version
pip install --upgrade robotframework

# Upgrade to the latest version even if it is a pre-release
pip install --upgrade --pre robotframework

# Install a specific version
pip install robotframework==7.0

# Install separately downloaded package (no network connection needed)
pip install robotframework-7.0-py3-none-any.whl

# Install latest (possibly unreleased) code directly from GitHub
pip install https://github.com/robotframework/robotframework/archive/master.zip

# Uninstall
pip uninstall robotframework

Space separated format 空格分隔格式

When Robot Framework parses data, it first splits the data to lines and then lines to tokens such as keywords and arguments. When using the space separated format, the separator between tokens is two or more spaces or alternatively one or more tab characters. In addition to the normal ASCII space, any Unicode character considered to be a space (e.g. no-break space) works as a separator. The number of spaces used as separator can vary, as long as there are at least two, making it possible to align the data nicely in settings and elsewhere when it makes the data easier to understand.
当Robot Framework解析数据时，它首先将数据拆分为行，然后将行拆分为关键字和参数等标记。当使用空格分隔格式时，标记之间的分隔符是两个或多个空格，或者一个或多个制表符。除了正常的ASCII空格之外，任何被认为是空格的Unicode字符（例如，无中断空格）都可以用作分隔符。用作分隔符的空格数量可以变化，只要至少有两个，就可以在设置和其他地方很好地对齐数据，使数据更容易理解。

*** Settings ***
Documentation     Example using the space separated format.
Library           OperatingSystem

*** Variables ***
${MESSAGE}        Hello, world!

*** Test Cases ***
My Test
    [Documentation]    Example test.
    Log    ${MESSAGE}
    My Keyword    ${CURDIR}

Another Test
    Should Be Equal    ${MESSAGE}    Hello, world!

*** Keywords ***
My Keyword
    [Arguments]    ${path}
    Directory Should Exist    ${path}

Because tabs and consecutive spaces are considered separators, they must be escaped if they are needed in keyword arguments or elsewhere in the actual data. It is possible to use special escape syntax like \t for tab and \xA0 for no-break space as well as built-in variables ${SPACE} and ${EMPTY}. See the Escaping section for details.
由于制表符和连续空格被视为分隔符，因此如果关键字参数或实际数据中的其他地方需要它们，则必须对其进行转义。可以使用特殊的转义语法，如\t表示制表符，\xA0表示不间断空格，以及内置变量${SPACE}和${EMPTY}。详情请参见“逃逸”部分。

Pipe separated format 管道分隔格式

The biggest problem of the space delimited format is that visually separating keywords from arguments can be tricky. This is a problem especially if keywords take a lot of arguments and/or arguments contain spaces. In such cases the pipe delimited variant can work better because it makes the separator more visible.
空格分隔格式的最大问题是，在视觉上将关键字与参数分开可能很棘手。这是一个问题，特别是如果关键字需要很多参数和/或参数包含空格。在这种情况下，管道分隔变量可以更好地工作，因为它使分隔符更加可见。

One file can contain both space separated and pipe separated lines. Pipe separated lines are recognized by the mandatory leading pipe character, but the pipe at the end of the line is optional. There must always be at least one space or tab on both sides of the pipe except at the beginning and at the end of the line. There is no need to align the pipes, but that often makes the data easier to read.
一个文件可以同时包含空格分隔行和竖线分隔行。用竖线分隔的线由强制性的前导竖线字符识别，但行尾的竖线是可选的。管道的两侧必须始终至少有一个空格或制表符，但行的开头和结尾除外。不需要对齐管道，但这通常会使数据更容易读取。

| *** Settings ***   |
| Documentation      | Example using the pipe separated format.
| Library            | OperatingSystem

| *** Variables ***  |
| ${MESSAGE}         | Hello, world!

| *** Test Cases *** |                 |               |
| My Test            | [Documentation] | Example test. |
|                    | Log             | ${MESSAGE}    |
|                    | My Keyword      | ${CURDIR}     |
| Another Test       | Should Be Equal | ${MESSAGE}    | Hello, world!

| *** Keywords ***   |                        |         |
| My Keyword         | [Arguments]            | ${path} |
|                    | Directory Should Exist | ${path} |

When using the pipe separated format, consecutive spaces or tabs inside arguments do not need to be escaped. Similarly empty columns do not need to be escaped except if they are at the end. Possible pipes surrounded by spaces in the actual test data must be escaped with a backslash, though:
当使用管道分隔格式时，参数中的连续空格或制表符不需要转义。同样，空列也不需要转义，除非它们位于末尾。但是，在实际测试数据中，可能被空格包围的管道必须用反斜杠进行转义：

| *** Test Cases *** |                 |                 |                      |
| Escaping Pipe      | ${file count} = | Execute Command | ls -1 *.txt \| wc -l |
|                    | Should Be Equal | ${file count}   | 42                   |

reStructuredText format reStructuredText格式

reStructuredText (reST) is an easy-to-read plain text markup syntax that is commonly used for documentation of Python projects, including Python itself as well as this User Guide. reST documents are most often compiled to HTML, but also other output formats are supported. Using reST with Robot Framework allows you to mix richly formatted documents and test data in a concise text format that is easy to work with using simple text editors, diff tools, and source control systems.
reStructuredText（reST）是一种易于阅读的纯文本标记语法，通常用于Python项目的文档，包括Python本身以及本用户指南。reST文档通常编译为HTML，但也支持其他输出格式。将reST与Robot Framework结合使用，可以将格式丰富的文档和测试数据以简洁的文本格式混合在一起，使用简单的文本编辑器、diff工具和源代码控制系统就可以轻松使用。

When using Robot Framework with reStructuredText files, normal Robot Framework data is embedded to so called code blocks. In standard reST code blocks are marked using the code directive, but Robot Framework supports also code-block or sourcecode directives used by the Sphinx tool.
当使用带有reStructuredText文件的Robot Framework时，正常的Robot Framework数据被嵌入到所谓的代码块中。在标准的reST中，代码块使用code指令标记，但Robot Framework也支持Sphinx工具使用的代码块或源代码

reStructuredText example
------------------------

This text is outside code blocks and thus ignored.

.. code:: robotframework

   *** Settings ***
   Documentation    Example using the reStructuredText format.
   Library          OperatingSystem

   *** Variables ***
   ${MESSAGE}       Hello, world!

   *** Test Cases ***
   My Test
       [Documentation]    Example test.
       Log    ${MESSAGE}
       My Keyword    ${CURDIR}

   Another Test
       Should Be Equal    ${MESSAGE}    Hello, world!

Also this text is outside code blocks and ignored. Code blocks not
containing Robot Framework data are ignored as well.

.. code:: robotframework

   # Both space and pipe separated formats are supported.

   | *** Keywords ***  |                        |         |
   | My Keyword        | [Arguments]            | ${path} |
   |                   | Directory Should Exist | ${path} |

.. code:: python

   # This code block is ignored.
   def example():
       print('Hello, world!')

Robot Framework supports reStructuredText files using .robot.rst, .rst and .rest extensions. To avoid parsing unrelated reStructuredText files, only files with the .robot.rst extension are parsed by default when executing a directory. Parsing files with other extensions can be enabled by using either --parseinclude or --extension option.
Robot Framework支持使用.robot.rst、.rst和.rest扩展名的reStructuredText文件。为了避免解析不相关的reStructuredText文件，在执行目录时，默认情况下只解析扩展名为.robot.rst的文件。可以使用--parseinclude或--extension选项启用解析具有其他扩展名的文件。

When Robot Framework parses reStructuredText files, errors below level SEVERE are ignored to avoid noise about possible non-standard directives and other such markup. This may hide also real errors, but they can be seen when processing files using reStructuredText tooling normally.
当Robot Framework解析reStructuredText文件时，将忽略SEVERE级别以下的错误，以避免可能的非标准指令和其他此类标记的干扰。这可能也会隐藏真实的错误，但在正常使用reStructuredText工具处理文件时，可以看到这些错误。

JSON format JSON格式

Robot Framework supports data also in the JSON format. This format is designed more for tool developers than for regular Robot Framework users and it is not meant to be edited manually. Its most important use cases are:
Robot Framework也支持JSON格式的数据。此格式更多地是为工具开发人员而不是常规Robot Framework用户设计的，并且不意味着手动编辑。它最重要的用例是：

• Transferring data between processes and machines. A suite can be converted to JSON in one machine and recreated somewhere else.
  在过程和机器之间传输数据。一个套件可以在一台机器上转换为JSON，然后在其他地方重新创建。
• Saving a suite, possibly a nested suite, constructed from normal Robot Framework data into a single JSON file that is faster to parse.
  将从普通Robot Framework数据构建的套件（可能是嵌套套件）保存到单个JSON文件中，这样可以更快地解析。
• Alternative data format for external tools generating tests or tasks.
  用于生成测试或任务的外部工具的替代数据格式。

from robot.running import TestSuite


# Create suite based on data on the file system.
suite = TestSuite.from_file_system('/path/to/data')

# Get JSON data as a string.
data = suite.to_json()

# Save JSON data to a file with custom indentation.
suite.to_json('data.rbt', indent=2)

from robot.running import TestSuite


# Create suite from JSON data in a file.
suite = TestSuite.from_json('data.rbt')

# Create suite from a JSON string.
suite = TestSuite.from_json('{"name": "Suite", "tests": [{"name": "Test"}]}')

# Execute suite. Notice that log and report needs to be created separately.
suite.run(output='example.xml')

from robot.running import TestSuite


# Create a suite, adjust source and convert to JSON.
suite = TestSuite.from_file_system('/path/to/data')
suite.adjust_source(relative_to='/path/to')
suite.to_json('data.rbt')

# Recreate suite elsewhere and adjust source accordingly.
suite = TestSuite.from_json('data.rbt')
suite.adjust_source(root='/new/path/to')

Ignored data 忽略的数据

When Robot Framework parses the test data files, it ignores:
当Robot Framework解析测试数据文件时，它会忽略：

• All data before the first test data section.
  第一个测试数据部分之前的所有数据。
• Data in the Comments section.
  评论部分中的数据。
• All empty rows. 全部为空行。
• All empty cells at the end of rows when using the pipe separated format.
  使用竖线分隔格式时，行末尾的所有单元格为空。
• All single backslashes (\) when not used for escaping.
  不用于转义时，所有单反斜杠（\）。
• All characters following the hash character (#), when it is the first character of a cell. This means that hash marks can be used to enter comments in the test data.
  当哈希字符（#）是单元格的第一个字符时，它后面的所有字符。这意味着可以使用哈希标记在测试数据中输入注释。

When Robot Framework ignores some data, this data is not available in any resulting reports and, additionally, most tools used with Robot Framework also ignore them. To add information that is visible in Robot Framework outputs, place it to the documentation or other metadata of test cases or suites, or log it with the BuiltIn keywords Log or Comment.
当Robot Framework忽略某些数据时，这些数据在任何生成的报告中都不可用，此外，与Robot Framework一起使用的大多数工具也会忽略它们。要添加在Robot Framework输出中可见的信息，请将其放置到测试用例或套件的文档或其他元数据中，或者使用内置关键字Log或Comment将其记录下来。

Escaping 逸出

The escape character in Robot Framework test data is the backslash (\) and additionally built-in variables ${EMPTY} and ${SPACE} can often be used for escaping. Different escaping mechanisms are discussed in the sections below.
Robot Framework测试数据中的转义字符是反斜杠（\），此外，内置变量${EMPTY}和${SPACE}通常可用于转义。不同的逃逸机制将在下面的章节中讨论。

*** Test Cases ***
Using backslash
    Do Something    first arg    \
    Do Something    \            second arg

Using ${EMPTY}
    Do Something    first arg    ${EMPTY}
    Do Something    ${EMPTY}     second arg

| *** Test Cases *** |              |           |            |
| Using backslash    | Do Something | first arg | \          |
|                    | Do Something |           | second arg |
|                    |              |           |            |
| Using ${EMPTY}     | Do Something | first arg | ${EMPTY}   |
|                    | Do Something |           | second arg |

Dividing data to several rows
将数据划分为多行

If there is more data than readily fits a row, it is possible to split it and start continuing rows with ellipsis (...). Ellipses can be indented to match the indentation of the starting row and they must always be followed by the normal test data separator.
如果有更多的数据比容易适合一行，它是可能的分裂它，并开始与省略号（.. ).椭圆可以缩进以匹配起始行的缩进，并且后面必须始终跟有正常的测试数据分隔符。

In most places split lines have exact same semantics as lines that are not split. Exceptions to this rule are suite, test and keyword documentation as well suite metadata. With them split values are automatically joined together with the newline character to ease creating multiline values.
在大多数情况下，分割线与未分割的线具有完全相同的语义。遵循这一规则的是套件、测试和关键字文档以及套件元数据。使用它们，分割值会自动与换行符连接在一起，以轻松创建多行值。

The ... syntax allows also splitting variables in the Variable section. When long scalar variables (e.g. ${STRING}) are split to multiple rows, the final value is got by concatenating the rows together. The separator is a space by default, but that can be changed by starting the value with SEPARATOR=<sep>.
那个... 语法还允许在Variable部分中拆分变量。当长标量变量（例如${STRING}）被拆分为多行时，最终值是通过将行连接在一起获得的。默认情况下，分隔符是一个空格，但可以通过以SEPARATOR=<sep>开头的值来更改。

Splitting lines is illustrated in the following two examples containing exactly same data without and with splitting.
在以下两个示例中说明了分割行，这两个示例包含完全相同的数据（不进行分割和进行分割）。

*** Settings ***
Documentation      Here we have documentation for this suite.\nDocumentation is often quite long.\n\nIt can also contain multiple paragraphs.
Default Tags       default tag 1    default tag 2    default tag 3    default tag 4    default tag 5

*** Variables ***
${STRING}          This is a long string. It has multiple sentences. It does not have newlines.
${MULTILINE}       This is a long multiline string.\nThis is the second line.\nThis is the third and the last line.
@{LIST}            this     list     is    quite    long     and    items in it can also be long
&{DICT}            first=This value is pretty long.    second=This value is even longer. It has two sentences.

*** Test Cases ***
Example
    [Tags]    you    probably    do    not    have    this    many    tags    in    real    life
    Do X    first argument    second argument    third argument    fourth argument    fifth argument    sixth argument
    ${var} =    Get X    first argument passed to this keyword is pretty long    second argument passed to this keyword is long too

*** Settings ***
Documentation      Here we have documentation for this suite.
...                Documentation is often quite long.
...
...                It can also contain multiple paragraphs.
Default Tags       default tag 1    default tag 2    default tag 3
...                default tag 4    default tag 5

*** Variables ***
${STRING}          This is a long string.
...                It has multiple sentences.
...                It does not have newlines.
${MULTILINE}       SEPARATOR=\n
...                This is a long multiline string.
...                This is the second line.
...                This is the third and the last line.
@{LIST}            this     list     is      quite    long     and
...                items in it can also be long
&{DICT}            first=This value is pretty long.
...                second=This value is even longer. It has two sentences.

*** Test Cases ***
Example
    [Tags]    you    probably    do    not    have    this    many
    ...       tags    in    real    life
    Do X    first argument    second argument    third argument
    ...    fourth argument    fifth argument    sixth argument
    ${var} =    Get X
    ...    first argument passed to this keyword is pretty long
    ...    second argument passed to this keyword is long too

Enabling languages 使能语言

robot --language Finnish testit.robot
robot --language pt --language ptbr testes.robot

robot --language Custom.py tests.robot
robot --language MyLang tests.robot

Language: Finnish

*** Asetukset ***
Dokumentaatio        Example using Finnish.

Built-in languages 内置语言

The following languages are supported out-of-the-box. Click the language name to see the actual translations:
开箱即用支持以下语言。点击语言名称查看实际翻译：

• Bulgarian (bg) 保加利亚语（bg）
• Bosnian (bs) 波斯尼亚语（bs）
• Czech (cs) 捷克语（cs）
• German (de) 德语（de）
• Spanish (es) 西班牙语（es）
• Finnish (fi) 芬兰语（fi）
• French (fr) 法语（fr）
• Hindi (hi) 印地语（hi）
• Italian (it) 意大利语（it）
• Japanese (ja) 日语（ja）
• Dutch (nl) 荷兰语（nl）
• Polish (pl) 波兰语（pl）
• Portuguese (pt) 葡萄牙语（pt）
• Brazilian Portuguese (pt-BR)
  巴西葡萄牙语（pt-BR）
• Romanian (ro) 罗马尼亚语（ro）
• Russian (ru) 俄语（ru）
• Swedish (sv) 瑞典语（sv）
• Thai (th) 泰文（th）
• Turkish (tr) 土耳其语（tr）
• Ukrainian (uk) 乌克兰语（英国）
• Vietnamese (vi) 越南语（vi）
• Chinese Simplified (zh-CN)
  简体中文（zh-CN）
• Chinese Traditional (zh-TW)
  繁体中文（zh-TW）

All these translations have been provided by the awesome Robot Framework community. If a language you are interested in is not included, you can consider contributing it!
所有这些翻译都是由令人敬畏的机器人框架社区提供的。如果您感兴趣的语言没有包含在内，您可以考虑贡献它！

Custom language files 自定义语言文件

If a language you would need is not available as a built-in language, or you want to create a totally custom language for some specific need, you can easily create a custom language file. Language files are Python files that contain one or more language definitions that are all loaded when the language file is taken into use. Language definitions are created by extending the robot.api.Language base class and overriding class attributes as needed:
如果您需要的语言无法作为内置语言提供，或者您想要为某些特定需求创建完全自定义的语言，则可以轻松创建自定义语言文件。语言文件是包含一个或多个语言定义的Python文件，这些语言定义在使用语言文件时全部加载。通过扩展robot.API.Language基类并根据需要重写类属性来创建语言定义：

from robot.api import Language


class Example(Language):
    test_cases_header = 'Validations'
    tags_setting = 'Labels'
    given_prefixes = ['Assuming']
    true_strings = ['OK', '\N{THUMBS UP SIGN}']

Assuming the above code would be in file example.py, a path to that file or just the module name example could be used when the language file is activated.
假设上述代码位于文件example.py中，则在激活语言文件时可以使用该文件的路径或仅使用模块名称示例。

The above example adds only some of the possible translations. That is fine because English is automatically enabled anyway. Most values must be specified as strings, but BDD prefixes and true/false strings allow more than one value and must be given as lists. For more examples, see Robot Framework's internal languages module that contains the Language class as well as all built-in language definitions.
上面的例子只添加了一些可能的翻译。这很好，因为无论如何都会自动启用英语。大多数值必须指定为字符串，但是BDD前缀和true/false字符串允许多个值，并且必须以列表的形式给出。有关更多示例，请参见Robot Framework的内部语言模块，该模块包含Language类以及所有内置语言定义。

Contributing translations
贡献翻译

If you want to add translation for a new language or enhance existing, head to Crowdin that we use for collaboration. For more details, see the separate Localization project, and for questions and free discussion join the #localization channel on our Slack.
如果您想添加新语言的翻译或增强现有的翻译，请前往我们用于协作的Crowdin。有关更多详细信息，请参阅单独的本地化项目，如有疑问和免费讨论，请加入我们Slack上的#localization频道。

Basic syntax 基本语法

Test cases are constructed in test case sections from the available keywords. Keywords can be imported from test libraries or resource files, or created in the keyword section of the test case file itself.
测试用例在测试用例部分中从可用的关键字中构造。关键字可以从测试库或资源文件中导入，或者在测试用例文件本身的关键字部分中创建。

The first column in the test case section contains test case names. A test case starts from the row with something in this column and continues to the next test case name or to the end of the section. It is an error to have something between the section headers and the first test.
测试用例部分的第一列包含测试用例名称。测试用例从该列中包含内容的行开始，并继续到下一个测试用例名称或部分的末尾。在节头和第一个测试之间存在某些内容是错误的。

The second column normally has keyword names. An exception to this rule is setting variables from keyword return values, when the second and possibly also the subsequent columns contain variable names and a keyword name is located after them. In either case, columns after the keyword name contain possible arguments to the specified keyword.
第二列通常包含关键字名称。此规则的一个例外是从关键字返回值设置变量，当第二列以及可能的后续列包含变量名称并且关键字名称位于它们之后时。在这两种情况下，关键字名称之后的列都包含指定关键字的可能参数。

*** Test Cases ***
Valid Login
    Open Login Page
    Input Username    demo
    Input Password    mode
    Submit Credentials
    Welcome Page Should Be Open

Setting Variables
    Do Something    first argument    second argument
    ${value} =    Get Some Value
    Should Be Equal    ${value}    Expected value

Settings in the Test Case section
测试用例部分中的设置

Test cases can also have their own settings. Setting names are always in the second column, where keywords normally are, and their values are in the subsequent columns. Setting names have square brackets around them to distinguish them from keywords. The available settings are listed below and explained later in this section.
测试用例也可以有自己的设置。设置名称始终位于第二列中，关键字通常位于第二列中，其值位于后续列中。设置名称周围有方括号，以将其与关键字区分开来。下面列出了可用的设置，并在本节后面进行了说明。

[Documentation] [文件]

Used for specifying a test case documentation.
用于指定测试用例文档。

[Setup], [Teardown]
[设置]、[拆除]

Specify test setup and teardown.
指定测试设置和拆卸。

[Tags] [标签]

Used for tagging test cases.
用于标记测试用例。

[Template] [模板]

Specifies the template keyword to use. The test itself will contain only data to use as arguments to that keyword.
指定要使用的模板关键字。测试本身将只包含用作该关键字的参数的数据。

[Timeout] [超时]

Used for setting a test case timeout. Timeouts are discussed in their own section.
用于设置测试用例超时。超时将在各自的部分中讨论。

Example test case with settings:
带有设置的测试用例示例：

*** Test Cases ***
Test With Settings
    [Documentation]    Another dummy test
    [Tags]    dummy    owner-johndoe
    Log    Hello, world!

Test case related settings in the Setting section
设置部分中的测试用例相关设置

The Setting section can have the following test case related settings. These settings are mainly default values for the test case specific settings listed earlier.
设置部分可以有以下测试用例相关的设置。这些设置主要是前面列出的测试用例特定设置的默认值。

Test Setup, Test Teardown
测试设置、测试拆卸

The default values for test setup and teardown.
测试设置和拆卸的默认值。

Test Tags 测试标签

Tags all tests in the suite will get in addition to their possible own tags.
套件中的所有测试除了可能拥有自己的标记外，还将获得标记。

Test Template 测试模板

The default template keyword to use.
要使用的默认模板关键字。

Test Timeout 测试超时

The default value for test case timeout. Timeouts are discussed in their own section.
测试用例超时的默认值。超时将在各自的部分中讨论。

Positional arguments 位置参数

Most keywords have a certain number of arguments that must always be given. In the keyword documentation this is denoted by specifying the argument names separated with a comma like first, second, third. The argument names actually do not matter in this case, except that they should explain what the argument does, but it is important to have exactly the same number of arguments as specified in the documentation. Using too few or too many arguments will result in an error.
大多数关键字都有一定数量的参数，必须始终给出。在关键字documentation中，这是通过指定参数名来表示的，参数名之间用逗号分隔，如first，second，third。在这种情况下，参数名称实际上并不重要，除了它们应该解释参数的作用，但是重要的是要有与文档中指定的参数数量完全相同的参数。使用太少或太多的参数将导致错误。

The test below uses keywords Create Directory and Copy File from the OperatingSystem library. Their arguments are specified as path and source, destination, which means that they take one and two arguments, respectively. The last keyword, No Operation from BuiltIn, takes no arguments.
下面的测试使用OperatingSystem库中的关键字Create Directory和Copy File。它们的参数被指定为path和source、destination，这意味着它们分别接受一个和两个参数。最后一个关键字NoOperation fromBuiltIn不带参数。

*** Test Cases ***
Example
    Create Directory    ${TEMPDIR}/stuff
    Copy File    ${CURDIR}/file.txt    ${TEMPDIR}/stuff
    No Operation

Default values 默认值

Arguments often have default values which can either be given or not. In the documentation the default value is typically separated from the argument name with an equal sign like name=default value. It is possible that all the arguments have default values, but there cannot be any positional arguments after arguments with default values.
参数通常有默认值，可以给定也可以不给定。在文档中，默认值通常与参数名用等号分隔，如name=default value。可能所有参数都有默认值，但在具有默认值的参数之后不能有任何位置参数。

Using default values is illustrated by the example below that uses Create File keyword which has arguments path, content=, encoding=UTF-8. Trying to use it without any arguments or more than three arguments would not work.
下面的示例说明了如何使用默认值，该示例使用Create File关键字，其参数为path，content=，encoding=UTF-8。尝试在没有任何参数或超过三个参数的情况下使用它将不起作用。

*** Test Cases ***
Example
    Create File    ${TEMPDIR}/empty.txt
    Create File    ${TEMPDIR}/utf-8.txt         Hyvä esimerkki
    Create File    ${TEMPDIR}/iso-8859-1.txt    Hyvä esimerkki    ISO-8859-1

Variable number of arguments
数目可变的参数

It is also possible that a keyword accepts any number of arguments. These so called varargs can be combined with mandatory arguments and arguments with default values, but they are always given after them. In the documentation they have an asterisk before the argument name like *varargs.
关键字也可以接受任意数量的参数。这些所谓的varargs可以与强制参数和具有默认值的参数组合，但它们总是在它们之后给出。在文档中，它们在参数名之前有一个星号，如*varargs。

For example, Remove Files and Join Paths keywords from the OperatingSystem library have arguments *paths and base, *parts, respectively. The former can be used with any number of arguments, but the latter requires at least one argument.
例如，OperatingSystem库中的Remove Files和Join Paths关键字分别具有参数*paths和base，*parts。前者可以与任意数量的参数一起使用，但后者需要至少一个参数。

*** Test Cases ***
Example
    Remove Files    ${TEMPDIR}/f1.txt    ${TEMPDIR}/f2.txt    ${TEMPDIR}/f3.txt
    @{paths} =    Join Paths    ${TEMPDIR}    f1.txt    f2.txt    f3.txt    f4.txt

Named arguments 命名参数

The named argument syntax makes using arguments with default values more flexible, and allows explicitly labeling what a certain argument value means. Technically named arguments work exactly like keyword arguments in Python.
命名参数语法使得使用带有默认值的参数更加灵活，并允许显式地标记某个参数值的含义。从技术上讲，命名参数的工作方式与Python中的关键字参数完全相同。

*** Test Cases ***
Example
    Run Program    shell=True    # This will not come as a named argument to Run Process

*** Keywords ***
Run Program
    [Arguments]    @{args}
    Run Process    program.py    @{args}    # Named arguments are not recognized from inside @{args}

*** Settings ***
Library    Telnet    prompt=$    default_log_level=DEBUG

*** Test Cases ***
Example
    Open connection    10.0.0.42    port=${PORT}    alias=example
    List files    options=-lh
    List files    path=/tmp    options=-l

*** Keywords ***
List files
    [Arguments]    ${path}=.    ${options}=
    Execute command    ls ${options} ${path}

Free named arguments 自由命名参数

Robot Framework supports free named arguments, often also called free keyword arguments or kwargs, similarly as Python supports **kwargs. What this means is that a keyword can receive all arguments that use the named argument syntax (name=value) and do not match any arguments specified in the signature of the keyword.
Robot框架支持自由命名参数，通常也称为自由关键字参数或Kwargs，类似于Python支持 **Kwargs。这意味着关键字可以接收所有使用命名参数语法（name=value）的参数，并且不匹配关键字签名中指定的任何参数。

Free named arguments are supported by same keyword types than normal named arguments. How keywords specify that they accept free named arguments depends on the keyword type. For example, Python based keywords simply use **kwargs and user keywords use &{kwargs}.
自由命名参数受与普通命名参数相同的关键字类型支持。关键字如何指定它们接受自由命名参数取决于关键字类型。例如，基于Python的关键字使用**kwargs，用户关键字使用&{kwargs}。

Free named arguments support variables similarly as named arguments. In practice that means that variables can be used both in names and values, but the escape sign must always be visible literally. For example, both foo=${bar} and ${foo}=${bar} are valid, as long as the variables that are used exist. An extra limitation is that free argument names must always be strings.
自由命名参数支持与命名参数类似的变量。在实践中，这意味着变量可以在名称和值中使用，但转义符号必须始终可见。例如，foo=${bar}和${foo}=${bar}都是有效的，只要使用的变量存在。一个额外的限制是自由参数名称必须总是字符串。

*** Test Cases ***
Free Named Arguments
    Run Process    program.py    arg1    arg2    cwd=/home/user
    Run Process    program.py    argument    shell=True    env=${ENVIRON}

*** Test Cases ***
Free Named Arguments
    Run Program    arg1    arg2    cwd=/home/user
    Run Program    argument    shell=True    env=${ENVIRON}

*** Keywords ***
Run Program
    [Arguments]    @{args}    &{config}
    Run Process    program.py    @{args}    &{config}

Named-only arguments 仅命名参数

Starting from Robot Framework 3.1, keywords can accept argument that must always be named using the named argument syntax. If, for example, a keyword would accept a single named-only argument example, it would always need to be used like example=value and using just value would not work. This syntax is inspired by the keyword-only arguments syntax supported by Python 3.
从Robot Framework 3.1开始，关键字可以接受必须始终使用命名参数语法命名的参数。例如，如果一个关键字接受一个仅命名的参数example，它总是需要像example=value那样使用，而只使用value是行不通的。这种语法受到Python 3支持的仅关键字参数语法的启发。

For most parts named-only arguments work the same way as named arguments. The main difference is that libraries implemented with Python 2 using the static library API do not support this syntax.
在大多数情况下，仅命名参数的工作方式与命名参数相同。主要区别是使用静态库API用Python 2实现的库不支持此语法。

As an example of using the named-only arguments with user keywords, here is a variation of the Run Program in the above free named argument examples that only supports configuring shell:
作为使用带有用户关键字的仅命名参数的示例，下面是上述自由命名参数示例中的Run Program的变体，仅支持配置shell：

*** Test Cases ***
Named-only Arguments
    Run Program    arg1    arg2              # 'shell' is False (default)
    Run Program    argument    shell=True    # 'shell' is True

*** Keywords ***
Run Program
    [Arguments]    @{args}    ${shell}=False
    Run Process    program.py    @{args}    shell=${shell}

Arguments embedded to keyword names
嵌入到关键字名称的参数

A totally different approach to specify arguments is embedding them into keyword names. This syntax is supported by both test library keywords and user keywords.
一种完全不同的指定参数的方法是将它们嵌入到关键字名称中。测试库关键字和用户关键字都支持此语法。

When test case fails 测试用例失败时

A test case fails if any of the keyword it uses fails. Normally this means that execution of that test case is stopped, possible test teardown is executed, and then execution continues from the next test case. It is also possible to use special continuable failures if stopping test execution is not desired.
如果测试用例使用的任何关键字失败，则测试用例失败。通常这意味着停止执行该测试用例，执行可能的测试拆卸，然后从下一个测试用例继续执行。如果不希望停止测试执行，也可以使用特殊的可持续故障。

Error messages 错误消息

The error message assigned to a failed test case is got directly from the failed keyword. Often the error message is created by the keyword itself, but some keywords allow configuring them.
分配给失败测试用例的错误消息直接从failed关键字获得。错误消息通常由关键字本身创建，但有些关键字允许配置它们。

In some circumstances, for example when continuable failures are used, a test case can fail multiple times. In that case the final error message is got by combining the individual errors. Very long error messages are automatically cut from the middle to keep reports easier to read, but full error messages are always visible in log files as messages of the failed keywords.
在某些情况下，例如当使用可持续的失败时，测试用例可能会失败多次。在这种情况下，最终的错误信息是通过合并各个错误得到的。很长的错误消息会自动从中间剪切，以使报告更易于阅读，但完整的错误消息在日志文件中始终可见，作为失败关键字的消息。

By default error messages are normal text, but they can contain HTML formatting. This is enabled by starting the error message with marker string *HTML*. This marker will be removed from the final error message shown in reports and logs. Using HTML in a custom message is shown in the second example below.
默认情况下，错误消息是普通文本，但它们可以包含HTML格式。这是通过以标记字符串*HTML*开始错误消息来启用的。此标记将从报告和日志中显示的最终错误消息中删除。在自定义消息中使用HTML如下面的第二个示例所示。

*** Test Cases ***
Normal Error
    Fail    This is a rather boring example...

HTML Error
    ${number} =    Get Number
    Should Be Equal    ${number}    42    *HTML* Number is not my <b>MAGIC</b> number.

Deprecation of Force Tags and Default Tags
强制标签和默认标签的弃用

Prior to Robot Framework 6.0, tags could be specified to tests in the Setting section using two different settings:
在Robot Framework 6.0之前，可以使用两种不同的设置为设置部分中的测试指定标记：

Force Tags 力标签

All tests unconditionally get these tags. This is exactly the same as Test Tags nowadays.
所有测试都无条件获得这些标签。这与今天的测试标签完全相同。

Default Tags 默认货签

All tests get these tags by default. If a test has [Tags], it will not get these tags.
默认情况下，所有测试都获得这些标记。如果一个测试有[Tags]，它将不会得到这些标签。

Both of these settings still work, but they are considered deprecated. A visible deprecation warning will be added in the future, most likely in Robot Framework 8.0, and eventually these settings will be removed. Tools like Tidy can be used to ease transition.
这两种设置仍然有效，但已被弃用。未来将添加可见的弃用警告，最有可能是在Robot Framework 8.0中，最终这些设置将被删除。像Tidy这样的工具可以用来简化过渡。

Updating Force Tags requires only renaming it to Test Tags. The Default Tags setting will be removed altogether, but the -tag functionality introduced in Robot Framework 7.0 provides same underlying functionality. The following examples demonstrate the needed changes.
更新力标记只需要将其重命名为测试标记。默认标签设置将被完全删除，但Robot Framework 7.0中引入的-tag功能提供了相同的底层功能。以下示例说明了所需的更改。

Old syntax: 旧语法：

*** Settings ***
Force Tags      all
Default Tags    default

*** Test Cases ***
Common only
    [Documentation]    Test has tags 'all' and 'default'.
    No Operation

No default
    [Documentation]    Test has only tag 'all'.
    [Tags]
    No Operation

Own and no default
    [Documentation]    Test has tags 'all' and 'own'.
    [Tags]    own
    No Operation

New syntax: 新语法：

*** Settings ***
Test Tags      all    default

*** Test Cases ***
Common only
    [Documentation]    Test has tags 'all' and 'default'.
    No Operation

No default
    [Documentation]    Test has only tag 'all'.
    [Tags]    -default
    No Operation

Own and no default
    [Documentation]    Test has tags 'all' and 'own'.
    [Tags]    own    -default
    No Operation

Reserved tags 保留标签

Users are generally free to use whatever tags that work in their context. There are, however, certain tags that have a predefined meaning for Robot Framework itself, and using them for other purposes can have unexpected results. All special tags Robot Framework has and will have in the future have the robot: prefix. To avoid problems, users should thus not use any tag with this prefixes unless actually activating the special functionality. The current reserved tags are listed below, but more such tags are likely to be added in the future.
用户通常可以自由使用在其上下文中工作的任何标签。然而，某些标签对Robot框架本身具有预定义的含义，将它们用于其他目的可能会产生意想不到的结果。Robot Framework拥有的所有特殊标签以及将来将会拥有的所有特殊标签都有robot：前缀。为了避免出现问题，用户不应该使用任何带有此前缀的标签，除非实际激活特殊功能。下面列出了当前保留的标签，但将来可能会添加更多这样的标签。

robot:continue-on-failure and robot:recursive-continue-on-failure
robot：continue-on-failure和robot：recursive-continue-on-failure

Used for enabling the continue-on-failure mode.
用于启用故障时继续模式。

robot:stop-on-failure and robot:recursive-stop-on-failure
robot：stop-on-failure和robot：recursive-stop-on-failure

Used for disabling the continue-on-failure mode.
用于禁用故障时继续模式。

robot:skip-on-failure

Mark test to be skipped if it fails.
如果测试失败，则标记跳过测试。

robot:skip

Mark test to be unconditionally skipped.
无条件跳过标记测试。

robot:exclude

Mark test to be unconditionally excluded.
无条件排除标记测试。

robot:private

Mark keyword to be private.
将关键字标记为私有。

robot:no-dry-run

Mark keyword not to be executed in the dry run mode.
将关键字标记为在空运行模式下不执行。

robot:exit

Added to tests automatically when execution is stopped gracefully.
在正常停止执行时自动添加到测试中。

robot:flatten

Enable flattening keyword during execution time.
在执行期间启用扁平化关键字。

As of RobotFramework 4.1, reserved tags are suppressed by default in tag statistics. They will be shown when they are explicitly included via the --tagstatinclude robot:* command line option.
从RobotFramework 4.1开始，默认情况下保留标记在标记统计中被抑制。当它们通过--tagstatinclude robot：*命令行选项显式包含时，将显示它们。

Basic usage 基本用法

How a keyword accepting normal positional arguments can be used as a template is illustrated by the following example test cases. These two tests are functionally fully identical.
下面的示例测试用例说明了如何将接受正常位置参数的关键字用作模板。这两个测试在功能上完全相同。

*** Test Cases ***
Normal test case
    Example keyword    first argument    second argument

Templated test case
    [Template]    Example keyword
    first argument    second argument

As the example illustrates, it is possible to specify the template for an individual test case using the [Template] setting. An alternative approach is using the Test Template setting in the Setting section, in which case the template is applied for all test cases in that test case file. The [Template] setting overrides the possible template set in the Setting section, and an empty value for [Template] means that the test has no template even when Test Template is used. It is also possible to use value NONE to indicate that a test has no template.
如示例所示，可以使用[Template]设置为单个测试用例指定模板。另一种方法是使用设置部分中的测试模板设置，在这种情况下，模板将应用于该测试用例文件中的所有测试用例。[Template]设置会覆盖设置部分中设置的可能模板，[Template]的空值表示即使使用了测试模板，测试也没有模板。也可以使用值NONE来指示测试没有模板。

If a templated test case has multiple data rows in its body, the template is applied for all the rows one by one. This means that the same keyword is executed multiple times, once with data on each row. Templated tests are also special so that all the rounds are executed even if one or more of them fails. It is possible to use this kind of continue on failure mode with normal tests too, but with the templated tests the mode is on automatically.
如果模板化的测试用例在其主体中有多个数据行，则模板将逐个应用于所有行。这意味着同一个关键字会被执行多次，每一行上都有数据。模板化测试也很特殊，即使其中一个或多个失败，也会执行所有轮次。在正常测试中也可以使用这种继续失败模式，但是在模板化测试中，模式是自动打开的。

*** Settings ***
Test Template    Example keyword

*** Test Cases ***
Templated test case
    first round 1     first round 2
    second round 1    second round 2
    third round 1     third round 2

Using keywords with default values or accepting variable number of arguments, as well as using named arguments and free named arguments, work with templates exactly like they work otherwise. Using variables in arguments is also supported normally.
使用带有默认值的关键字或接受可变数量的参数，以及使用命名参数和自由命名参数，与模板的工作方式完全相同。通常也支持在参数中使用变量。

Templates with embedded arguments
带有嵌入参数的模板

Templates support a variation of the embedded argument syntax. With templates this syntax works so that if the template keyword has variables in its name, they are considered placeholders for arguments and replaced with the actual arguments used with the template. The resulting keyword is then used without positional arguments. This is best illustrated with an example:
模板支持嵌入参数语法的变体。对于模板，这种语法的工作原理是，如果模板关键字在其名称中包含变量，则它们被视为参数的占位符，并被模板使用的实际参数替换。然后使用结果关键字而不使用位置参数。最好用一个例子来说明这一点：

*** Test Cases ***
Normal test case with embedded arguments
    The result of 1 + 1 should be 2
    The result of 1 + 2 should be 3

Template with embedded arguments
    [Template]    The result of ${calculation} should be ${expected}
    1 + 1    2
    1 + 2    3

*** Keywords ***
The result of ${calculation} should be ${expected}
    ${result} =    Calculate    ${calculation}
    Should Be Equal    ${result}     ${expected}

When embedded arguments are used with templates, the number of arguments in the template keyword name must match the number of arguments it is used with. The argument names do not need to match the arguments of the original keyword, though, and it is also possible to use different arguments altogether:
当嵌入参数与模板一起使用时，模板关键字名称中的参数数量必须与它一起使用的参数数量相匹配。参数名称不需要与原始关键字的参数匹配，也可以使用不同的参数：

*** Test Cases ***
Different argument names
    [Template]    The result of ${foo} should be ${bar}
    1 + 1    2
    1 + 2    3

Only some arguments
    [Template]    The result of ${calculation} should be 3
    1 + 2
    4 - 1

New arguments
    [Template]    The ${meaning} of ${life} should be 42
    result    21 * 2

The main benefit of using embedded arguments with templates is that argument names are specified explicitly. When using normal arguments, the same effect can be achieved by naming the columns that contain arguments. This is illustrated by the data-driven style example in the next section.
在模板中使用嵌入式参数的主要好处是参数名被显式指定。当使用普通参数时，通过命名包含参数的列可以达到相同的效果。下一节中的数据驱动样式示例对此进行了说明。

Templates with FOR loops
带有FOR循环的模板

If templates are used with FOR loops, the template is applied for all the steps inside the loop. The continue on failure mode is in use also in this case, which means that all the steps are executed with all the looped elements even if there are failures.
如果模板与FOR循环一起使用，则模板将应用于循环内的所有步骤。在这种情况下，也使用继续故障模式，这意味着即使存在故障，也使用所有循环元件执行所有步骤。

*** Test Cases ***
Template with FOR loop
    [Template]    Example keyword
    FOR    ${item}    IN    @{ITEMS}
        ${item}    2nd arg
    END
    FOR    ${index}    IN RANGE    42
        1st arg    ${index}
    END

Templates with IF/ELSE structures
IF/ELSE结构模板

IF/ELSE structures can be also used together with templates. This can be useful, for example, when used together with FOR loops to filter executed arguments.
IF/ELSE结构也可以与模板一起使用。例如，当与FOR循环一起使用以过滤执行的参数时，这可能很有用。

*** Test Cases ***
Template with FOR and IF
    [Template]    Example keyword
    FOR    ${item}    IN    @{ITEMS}
        IF  ${item} < 5
            ${item}    2nd arg
        END
    END

Keyword-driven style 关键字驱动风格

Workflow tests, such as the Valid Login test described earlier, are constructed from several keywords and their possible arguments. Their normal structure is that first the system is taken into the initial state (Open Login Page in the Valid Login example), then something is done to the system (Input Name, Input Password, Submit Credentials), and finally it is verified that the system behaved as expected (Welcome Page Should Be Open).
工作流测试（如前面描述的Valid Login测试）是由几个关键字及其可能的参数构造的。它们的正常结构是，首先系统进入初始状态（在有效登录示例中打开登录页面），然后对系统进行操作（输入名称，输入密码，提交凭据），最后验证系统是否按预期运行（欢迎页面应该打开）。

Data-driven style 数据驱动风格

Another style to write test cases is the data-driven approach where test cases use only one higher-level keyword, often created as a user keyword, that hides the actual test workflow. These tests are very useful when there is a need to test the same scenario with different input and/or output data. It would be possible to repeat the same keyword with every test, but the test template functionality allows specifying the keyword to use only once.
编写测试用例的另一种风格是数据驱动方法，其中测试用例仅使用一个更高级别的关键字，通常作为用户关键字创建，隐藏实际的测试工作流。当需要使用不同的输入和/或输出数据测试相同的场景时，这些测试非常有用。可以在每个测试中重复使用相同的关键字，但是测试模板功能允许指定关键字仅使用一次。

*** Settings ***
Test Template    Login with invalid credentials should fail

*** Test Cases ***                USERNAME         PASSWORD
Invalid User Name                 invalid          ${VALID PASSWORD}
Invalid Password                  ${VALID USER}    invalid
Invalid User Name and Password    invalid          invalid
Empty User Name                   ${EMPTY}         ${VALID PASSWORD}
Empty Password                    ${VALID USER}    ${EMPTY}
Empty User Name and Password      ${EMPTY}         ${EMPTY}

The above example has six separate tests, one for each invalid user/password combination, and the example below illustrates how to have only one test with all the combinations. When using test templates, all the rounds in a test are executed even if there are failures, so there is no real functional difference between these two styles. In the above example separate combinations are named so it is easier to see what they test, but having potentially large number of these tests may mess-up statistics. Which style to use depends on the context and personal preferences.
上面的示例有六个独立的测试，每个测试对应一个无效的用户/密码组合，下面的示例说明了如何对所有组合只进行一个测试。当使用测试模板时，即使有失败，测试中的所有回合也会执行，因此这两种风格之间没有真实的功能差异。在上面的示例中，单独的组合被命名，因此更容易看到它们测试的内容，但是潜在的大量这些测试可能会混淆统计数据。使用哪种风格取决于上下文和个人喜好。

*** Test Cases ***
Invalid Password
    [Template]    Login with invalid credentials should fail
    invalid          ${VALID PASSWORD}
    ${VALID USER}    invalid
    invalid          whatever
    ${EMPTY}         ${VALID PASSWORD}
    ${VALID USER}    ${EMPTY}
    ${EMPTY}         ${EMPTY}

Behavior-driven style 行为驱动风格

It is also possible to write test cases as requirements that also non-technical project stakeholders must understand. These executable requirements are a corner stone of a process commonly called Acceptance Test Driven Development (ATDD) or Specification by Example.
也可以编写测试用例作为非技术项目涉众必须理解的需求。这些可执行的需求是一个过程的基石，通常称为验收测试驱动开发（ATDD）或规范的例子。

One way to write these requirements/tests is Given-When-Then style popularized by Behavior Driven Development (BDD). When writing test cases in this style, the initial state is usually expressed with a keyword starting with word Given, the actions are described with keyword starting with When and the expectations with a keyword starting with Then. Keyword starting with And or But may be used if a step has more than one action.
编写这些需求/测试的一种方法是由行为驱动开发（BDD）推广的Given-When-Then风格。当以这种风格编写测试用例时，初始状态通常用以Given开头的关键字表示，动作用以When开头的关键字描述，期望用以Then开头的关键字描述。如果步骤具有多个操作，则可以使用以And或But开头的关键字。

*** Test Cases ***
Valid Login
    Given login page is open
    When valid username and password are inserted
    and credentials are submitted
    Then welcome page should be open

Suite initialization files
套件初始化文件

A test suite created from a directory can have similar settings as a suite created from a test case file. Because a directory alone cannot have that kind of information, it must be placed into a special test suite initialization file. An initialization file name must always be of the format __init__.ext, where the extension must be one of the supported file formats (typically __init__.robot). The name format is borrowed from Python, where files named in this manner denote that a directory is a module.
从目录创建的测试套件可以具有与从测试用例文件创建的套件类似的设置。由于单独的目录无法包含此类信息，因此必须将其放入特殊的测试套件初始化文件中。初始化文件名必须始终为__init__. ext格式，其中扩展名必须是支持的文件格式之一（通常为__init__.robot）。名称格式借用自Python，其中以这种方式命名的文件表示目录是一个模块。

Starting from Robot Framework 6.1, it is also possible to define a suite initialization file for automatically created suite when starting the test execution by giving multiple paths.
从Robot Framework 6.1开始，还可以通过给定多个路径，在开始执行测试时为自动创建的套件定义套件初始化文件。

Initialization files have the same structure and syntax as test case files, except that they cannot have test case sections and not all settings are supported. Variables and keywords created or imported in initialization files are not available in the lower level test suites. If you need to share variables or keywords, you can put them into resource files that can be imported both by initialization and test case files.
测试用例文件具有与测试用例文件相同的结构和语法，只是它们不能具有测试用例节，并且不支持所有设置。在初始化文件中创建或导入的变量和关键字在较低级别的测试套件中不可用。如果您需要共享变量或关键字，您可以将它们放入可以由初始化和测试用例文件导入的资源文件中。

The main usage for initialization files is specifying test suite related settings similarly as in suite files, but setting some test case related settings is also possible. How to use different settings in the initialization files is explained below.
初始化文件的主要用途是指定测试套件相关的设置，类似于套件文件，但也可以设置一些测试用例相关的设置。下面将解释如何在初始化文件中使用不同的设置。

Name, Documentation, Metadata, Suite Setup, Suite Teardown
名称、文档、元数据、套件设置、套件拆卸

These suite specific settings work the same way in suite initialization files as in suite files.
这些套件特定设置在套件初始化文件中的工作方式与套件文件中的工作方式相同。

Test Tags 测试标签

Specified tags are unconditionally set to all tests in all suite files this directory contains, recursively. New in Robot Framework 6.1. The deprecated Force Tags needs to be used with older versions.
指定的标记被无条件地递归地设置到该目录包含的所有套件文件中的所有测试。机器人框架6.1中的新功能。弃用的Force Tags需要与旧版本一起使用。

Test Setup, Test Teardown, Test Timeout
测试设置、测试拆除、测试超时

Set the default value for test setup/teardown or test timeout to all test cases this directory contains. Can be overridden on lower level. Notice that keywords used as setups and teardowns must be available in test case files where tests using them are. Defining keywords in the initialization file itself is not enough.
将测试设置/拆除或测试超时的默认值设置为此目录包含的所有测试用例。可以在较低级别上被覆盖。请注意，用作设置和拆卸的关键字必须在使用它们的测试所在的测试用例文件中可用。在初始化文件本身中定义关键字是不够的。

Task Setup, Task Teardown, Task Tags, Task Timeout
任务设置、任务分解、任务标记、任务分解

Aliases for Test Setup, Test Teardown, Test Tags and Test Timeout, respectively, that can be used when creating tasks, not tests.
分别用于测试设置、测试拆卸、测试标记和测试任务的别名，可在创建任务（而非测试）时使用。

Default Tags, Test Template
默认标签，测试模板

Not supported in initialization files.
初始化文件中不支持。

*** Settings ***
Documentation    Example suite
Suite Setup      Do Something    ${MESSAGE}
Test Tags        example
Library          SomeLibrary

*** Variables ***
${MESSAGE}       Hello, world!

*** Keywords ***
Do Something
    [Arguments]    ${args}
    Some Keyword    ${arg}
    Another Keyword