Robot Framework用戶指南

時間 2020-06-06

標籤 robot framework 用戶指南简体版

原文原文鏈接

Robot Framework用戶指南

版本2.8.6

版權全部©諾基亞解決方案和網絡2008-2014

根據知識共享署名3.0 Unported許可受權

目錄html

1開始

1.1簡介

Robot Framework是一個基於Python的，可擴展的關鍵字驅動的測試自動化框架，用於端到端驗收測試和驗收測試驅動開發（ATDD）。它能夠用於測試分佈式異構應用程序，其中驗證須要涉及多種技術和接口。java

1.1.1爲何使用Robot Framework？

以統一的方式建立易於使用的表格語法來建立測試用例。
提供從現有關鍵字建立可重用的更高級關鍵字的功能。
以HTML格式提供易於閱讀的結果報告和日誌。
平臺和應用程序是獨立的。
提供一個簡單的庫API來建立自定義的測試庫，能夠用Python或Java本地執行。
提供命令行界面和基於XML的輸出文件，用於集成到現有的構建基礎架構（持續集成系統）中。
爲Web測試，Java GUI測試，運行進程，Telnet，SSH等提供對Selenium的支持。
支持建立數據驅動的測試用例。
內置對變量的支持，尤爲適用於在不一樣環境下進行測試。
提供標記來分類和選擇要執行的測試用例。
實現與源代碼控制的輕鬆集成：測試套件只是能夠用生產代碼進行版本化的文件和目錄。
提供測試用例和測試套件的級別設置和拆卸。
模塊化體系結構支持建立測試，即便是具備多種不一樣接口的應用程

1.1.2高級架構

Robot Framework是一個通用的，應用程序和技術獨立的框架。它有一個高度模塊化的架構，以下圖所示。node

SRC / gettingstarted /使用architecture.png

機器人框架結構python

該測試數據是簡單，易於編輯表格格式。當Robot Framework啓動時，它處理測試數據，執行測試用例並生成日誌和報告。核心框架不知道任何關於被測試的目標，與它的交互由測試庫處理。庫能夠直接使用應用程序接口，也能夠使用底層的測試工具做爲驅動程序。linux

1.1.3截圖

如下屏幕截圖顯示了測試數據的示例以及建立的報告和日誌。git

SRC / gettingstarted /使用testdata_screenshots.png

測試用例文件程序員

報告和日誌github

1.1.4獲取更多信息

項目頁面

尋找更多關於Robot Framework及其周圍豐富生態系統信息的第一位是http://robotframework.org。Robot Framework自己託管在GitHub上。web

郵件列表

有幾個機器人框架郵件列表在哪裏要求和搜索更多的信息。郵件列表檔案是爲全部人（包括搜索引擎）開放的，每一個人均可以自由地加入這些列表。可是，只有列表成員才能發送郵件，而且爲了防止垃圾郵件，新用戶將被主持，這意味着您的第一封郵件可能須要一些時間。不要懼怕把問題發送到郵件列表，但記得如何提出問題的智能方式。正則表達式

robotframework用戶: 有關全部Robot Framework相關問題的通常性討論。問題和問題能夠發送到這個列表。也用於全部用戶的信息共享。
robotframework通告: 只有公告人的郵件列表，只有版主能夠發送郵件。全部公告也發送到robotframework-users郵件列表，因此不須要加入這兩個列表。
robotframework-devel的: 關於Robot Framework開發的討論。
robotframework提交: 自動生成關於提交到版本控制系統的郵件，構建結果，新的和編輯的問題等等。能夠用來跟蹤Robot Framework的開發。

1.2版權和許可

版權全部2008-2014諾基亞解決方案和網絡根據Apache許可證2.0版（「許可證」）得到許可;除遵照許可證外，不得使用此文件。您能夠在得到許可證副本    http://www.apache.org/licenses/LICENSE-2.0除非適用法律要求或書面贊成，軟件根據許可證分發的數據按「現狀」分發，沒有任何形式的保證或條件，不管是明示的仍是暗示的。請參閱許可證以獲取有關權限和權限的特定語言根據許可證的限制。

1.3安裝說明

這些說明包括在不一樣的操做系統上安裝和卸載Robot Framework及其先決條件。若是你已經安裝了pip，那麼運行就足夠了：

點安裝robotframework

1.3.1簡介

Robot Framework是用Python實現的，也能夠在Jython（JVM）和 IronPython（.NET）上運行。在安裝框架以前，一個明顯的先決條件是安裝至少一個這樣的解釋器。請注意，Python 3尚不支持，但有一個非官方的Python 3端口可用。

下面列出了安裝Robot Framework自己的不一樣方法，並在隨後的章節中進行更詳細的解釋。

包管理員（如點子）

Python包管理器使安裝變得微不足道。例如，pip用戶只須要執行：

點安裝robotframework

不過，使用包管理器會首先增長一個先決條件來安裝包管理器自己。

從源代碼安裝

不管使用的是操做系統仍是Python解釋器，這種方法均可以工做。您能夠經過從 PyPI下載和提取源代碼或克隆 GitHub存儲庫來獲取源代碼。

使用Windows安裝程序

有32位和64位Windows系統的圖形化安裝程序，均可以在 PyPI上找到。

獨立的JAR分發

若是使用Jython運行測試就足夠了，最簡單的方法是從 Maven central下載獨立的 robotframework- <version> .jar。JAR發行包含Jython和Robot Framework，所以只須要安裝 Java。

手動安裝

若是您有特殊的需求而沒有其餘的工做，您能夠隨時進行自定義手動安裝。

1.3.2先決條件

Robot Framework支持Python，Jython（JVM）和IronPython（.NET），也能夠在PyPy上運行。在安裝框架以前應該安裝你想要使用的解釋器。

通常來講，使用哪一種解釋器取決於所需的測試庫和測試環境。一些庫使用只能用於Python的工具或模塊，而另外一些則可能使用須要Jython或須要.NET的Java工具，所以須要使用IronPython。還有不少工具和庫能夠和全部的解釋器一塊兒運行。

若是您沒有特殊需求或者只是想嘗試框架，建議使用Python。這是最成熟的實現，比Jython或IronPython快得多（特別是啓動時間更快），而且在大多數類UNIX操做系統上也很容易得到。另外一個很好的選擇是使用僅以Java爲前提的獨立JAR發行版。

Python安裝

在大多數類UNIX系統（如Linux和OS X）上，您默認安裝了Python。若是你使用的是Windows，或者須要本身安裝Python，那麼一個好的開始是http://python.org。在那裏，你能夠下載一個合適的安裝程序，並得到有關安裝過程和Python的更多信息。

Robot Framework目前支持Python版本2.5,2.6和2.7。計劃未來也會支持Python 3，同時Python 2.5的支持將會被拋棄。Robot Framework 2.0和2.1支持Python 2.3和2.4。

在Windows上，建議將Python安裝到全部用戶，並以管理員身份運行安裝程序。另外，不能設置環境變量 PYTHONCASEOK。

安裝Python以後，您可能仍然須要配置PATH以使命令提示符下的pybot runner腳本可執行。

Jython安裝

使用用Java實現的測試庫或內部使用Java工具的測試庫須要在Jython上運行Robot Framework，而Jython又須要Java Runtime Environment（JRE）或Java Development Kit（JDK）。安裝這些Java實現中的任何一個都不在這些說明的範圍內，可是若是須要，您能夠從http://java.com找到更多信息。

安裝Jython是一個至關簡單的過程，第一步是從http://jython.org獲取安裝程序。安裝程序是一個可執行的JAR包，能夠像命令行同樣運行java -jar jython_installer-<version>.jar。根據系統配置，也能夠雙擊安裝程序。

支持的最低Jython版本是2.5，須要Java 5（也稱爲Java 1.5）或更新版本。即將到來的Jython 2.7將須要最少的Java 7，並且未來對於Jython 2.5的支持也將是Robot Framework的最低限度。Robot Framework 2.0和2.1支持Jython 2.2。

安裝Jython以後，您可能仍然須要配置PATH以在命令提示符下使jybot runner腳本可執行。

IronPython安裝

IronPython容許在.NET平臺上運行Robot Framework，並與C＃和其餘.NET語言和API進行交互。只支持IronPython 2.7。

當使用IronPython時，額外的依賴項是安裝 elementtree 模塊1.2.7預覽版。這是必需的，由於使用IronPython分發的elementtree模塊已經損壞。您能夠經過下載源代碼發行版，解壓縮並ipy setup.py install在建立的目錄中的命令提示符下運行來安裝該程序包。

安裝IronPython以後，您可能仍然須要配置PATH以使命令提示符下的ipybot runner腳本可執行。

配置`PATH`

該PATH環境變量列出其中在一個系統中執行的命令是從搜索位置。爲了使命令提示符更容易使用Robot Framework，建議將運行器腳本的安裝位置添加到PATH中。跑步者腳本自己須要匹配的解釋器在PATH中，所以解釋器安裝目錄也必須添加到那裏。

在相似UNIX的機器上使用Python時，Python自己和安裝的腳本都應該自動在PATH中，不須要額外的操做。在Windows和其餘解釋器上，PATH必須單獨配置。

什麼目錄添加到`PATH`

須要將哪些目錄添加到PATH取決於解釋器和操做系統。第一個位置是解釋器的安裝目錄（例如C：\ Python27），另外一個位置是解釋器安裝腳本的位置。Python和IronPython都將腳本安裝到Windows安裝目錄下的Scripts目錄（例如C：\ Python27 \ Scripts），Jython使用bin 目錄而無論操做系統（例如C：\ jython2.5.3 \ bin）。

請注意，腳本和bin目錄可能不會做爲解釋器安裝的一部分建立，而只是在稍後安裝Robot Framework或其餘第三方模塊時才建立。

在Windows上設置`PATH`

在Windows上，您能夠按照如下步驟配置PATH。請注意，確切的設置名稱可能在不一樣的Windows版本上有所不一樣，但基本方法應該仍然是相同的。

打開Start > Settings > Control Panel > System > Advanced > Environment Variables。有User variables和System variables，和它們的區別是用戶變量隻影響當前用戶，而系統變量影響全部用戶。
要編輯現有的PATH值，請在值（例如）的末尾選擇Edit並添加。請注意分號（）在分離不一樣的條目時很是重要。要添加一個新的PATH 值，選擇並設置名稱和值，此次沒有前導分號。;<InstallationDir>;<ScriptsDir>;C:\Python27;C:\Python27\Scripts;New
退出對話框Ok以保存更改。
啓動新的命令提示符以使更改生效。

請注意，若是你安裝了多個版本的Python，在執行 pybot腳本老是會使用一個是第一個在PATH 不管在什麼樣的Python版本該腳本安裝。爲了不這種狀況，您能夠隨時使用直接入口點和解釋器C:\Python26\python.exe -m robot.run。

還要注意，你不該該在你添加到PATH中的目錄周圍添加引號（例如"C:\Python27\Scripts"）。引號可能會致使Python程序出現問題，即便目錄路徑包含空格，PATH也不須要它們。

在類UNIX系統上設置`PATH`

在類UNIX系統上，一般須要編輯某個系統範圍或用戶特定的配置文件。要編輯哪一個文件以及如何依賴於系統，而且須要查閱操做系統文檔以獲取更多詳細信息。

設置`https_proxy`

若是您打算使用pip進行安裝並位於代理以後，則須要設置https_proxy環境變量。在安裝pip和使用它來安裝Robot Framework和其餘Python包時都須要它。

如何設置https_proxy取決於操做系統，相似於配置PATH。此變量的值必須是代理的URL，例如http://10.0.0.42:8080。

1.3.3安裝Robot Framework

包管理員（如點子）

最流行的Python軟件包管理器是pip，但也有其餘的選擇，好比Buildout和easy_install。這些說明只包括使用pip，可是其餘軟件包管理者也應該可以安裝Robot Framework，至少若是他們從PyPI搜索軟件包的話。

安裝pip

使用點最難的部分是安裝工具自己，但幸運的是，也不是太複雜。您能夠從pip項目頁面找到最新的安裝說明。只要記住，若是您在代理以後，則須要在安裝和使用pip以前設置https_proxy環境變量。

pip的一個更大的問題是，在編寫本文時，只有Python支持它。即將到來的Jython 2.7應該支持它，甚至捆綁它，但目前還不清楚何時會被IronPython支持。

另外一個小的限制是，只有Robot Framework 2.7和更新版本能夠使用pip來安裝。若是您須要安裝較舊的版本，則必須使用其餘安裝方法。

使用點子

一旦你安裝了pip，在命令行上使用它就很是簡單了。最經常使用的用法以下所示，pip文檔有更多信息和示例。

＃安裝最新版本點安裝robotframework＃升級到最新版本pip安裝 - 升級robotframework＃安裝特定版本的 pip install robotframework == 2.8.5＃ 卸載點卸載robotframework

注意，pip 1.4和更新版本只會默認安裝穩定的版本。若是您想要安裝alpha，beta或release候選版本，則須要明確指定版本或使用--pre選項：

＃安裝2.9 beta 1 點安裝robotframework == 2.9b1＃即便是預發行版，也要安裝最新版本pip install --pre robotframework

若是您仍然使用pip 1.3或更高版本，而且不想在預發行版本中得到最新版本，則須要明確指定要安裝的穩定版本。

從源代碼安裝

此安裝方法能夠在任何支持的解釋器的操做系統上使用。從源代碼安裝聽起來有點可怕，但程序其實是很是簡單的。

獲取源代碼

一般，您能夠經過下載得到源代碼源代碼分發包 的.tar.gz格式。PyPI提供了更新的軟件包，但Robot Framework 2.8.1及更高版本能夠從舊的Google Code下載頁面找到。一旦你下載了軟件包，你須要把它解壓到某個地方，結果你獲得一個名爲的目錄robotframework-<version>。該目錄包含安裝它所需的源代碼和腳本。

獲取源代碼的另外一種方法是直接克隆項目的 GitHub存儲庫。默認狀況下，您將得到最新的代碼，可是您能夠輕鬆切換到不一樣的發佈版本或其餘標籤。

安裝

Robot Framework是使用Python的標準setup.py 腳本從源代碼安裝的。該腳本位於包含源代碼的目錄中，能夠使用任何受支持的解釋器從命令行運行該腳本：

＃用Python進行安裝。建立`pybot`和`rebot`腳本。python setup.py安裝＃使用Jython進行安裝。建立`jybot`和`jyrebot`腳本。jython setup.py安裝＃用IronPython安裝。建立`ipybot`和`ipyrebot`腳本。ipy setup.py安裝

該setup.py腳本接受幾個參數，容許，例如，在安裝到不須要管理員權限的非默認位置。它也用於建立不一樣的分發包。運行 python setup.py --help更多的細節。

使用Windows安裝程序

有32位和64位Windows系統的獨立圖形安裝程序，名稱格式分別爲robotframework- <version> .win32.exe和 robotframework- <version> .win-amd64.exe。較新的安裝程序位於舊版Google代碼下載頁面上的PyPI和Robot Framework 2.8.1及更高版本。運行安裝程序須要雙擊它並遵循簡單的指示。

Windows安裝程序始終在Python上運行，並建立標準的pybot和 rebot runner腳本。與其餘提供的安裝程序不一樣，這些安裝程序還會自動建立jybot和ipybot腳本。爲了可以使用建立的運行腳本，包含它們的腳本目錄和適當的解釋器都須要在PATH中。

安裝Robot Framework可能須要管理員權限。在這種狀況Run as administrator下，在啓動安裝程序時從上下文菜單中選擇。

手動安裝

若是您不想使用任何自動安裝Robot Framework的方式，則能夠按照如下步驟手動安裝它：

獲取源代碼。全部的代碼都在一個名爲robot的目錄（Python中的一個包）中。若是您有一個源代碼發行版或版本控制簽出，您能夠從src目錄中找到它，可是您也能夠從早期的安裝中獲取它。
將源代碼複製到你想要的地方。
建立您須要的跑步者腳本，或使用您選擇的解釋器直接入口點。

驗證安裝

成功安裝後，您應該可以使用--version選項執行已建立的運行腳本，並得到Robot Framework和解釋器版本：

$ pybot --versionRobot Framework 2.8.5 （ linux2上的Python 2.7.3 ）$ rebot --versionRebot 2.8.5 （在linux2上的Python 2.7.3 ）$ jybot --versionRobot Framework 2.8.5 （ java1.7.0_60上的Jython 2.5.3 ）

若是運行runner腳本失敗，並顯示一條消息，指出找不到或識別該命令，那麼首先須要仔細檢查PATH 配置。若是這樣作沒有幫助，在從互聯網尋求幫助以前從新閱讀這些說明中的相關部分，或者在robotframework-users郵件列表或其餘地方尋求幫助。

當使用自動安裝程序時，Robot Framework源代碼被複制到包含外部Python模塊的目錄中。在預裝了Python的類UNIX操做系統上，此目錄的位置各不相同。若是您本身安裝瞭解釋器，它一般位於解釋器安裝目錄下的Lib / site-packages，例如C：\ Python27 \ Lib \ site-packages。實際的Robot Framework代碼位於一個名爲robot的目錄中。

Robot Framework運行器腳本被建立並複製到另外一個特定於平臺的位置。在類UNIX系統上使用Python時，一般使用/ usr / bin或/ usr / local / bin。在Windows和其餘解釋器上，腳本一般位於解釋器安裝目錄下的腳本或bin目錄中。

1.3.4卸載和升級

卸載

如何卸載Robot Framework取決於原始的安裝方法。請注意，若是您已經設置PATH或配置了您的環境，則須要單獨撤消這些更改。

使用pip卸載

若是你有可用的pip，卸載就像安裝同樣簡單：

點卸載robotframework

一個不錯的點子功能是它能夠卸載軟件包，即便安裝已經完成使用其餘方法。

使用Windows安裝程序後卸載

若是已經使用Windows安裝程序，則能夠使用卸載 Control Panel > Add/Remove Programs。Robot Framework列在Python應用程序下。

手動卸載

該框架老是能夠手動卸載。這須要刪除建立的機器人目錄和運行腳本。查看上面安裝文件的部分，以瞭解能夠在哪裏找到它們。

升級

在升級或降級Robot Framework時，在兩個次要版本（例如2.8.4到2.8.5）之間切換時，能夠安全地在現有版本上安裝新版本。這一般也適用於升級到新的主要版本，例如，從2.8.5到2.9，但卸載舊版本老是更安全。

pip軟件包管理器的一個很是好的功能是它在升級時自動卸載舊版本。在更改成特定版本或升級到最新版本時都會發生這種狀況：

pip安裝robotframework == 2.7.1pip安裝 - 升級robotframework

不管版本和安裝方式如何，您都不須要從新安裝前提條件或從新設置PATH環境變量。

1.3.5不一樣的入口點

跑步者腳本

Robot Framework具備不一樣的運行腳本，用於執行測試用例和基於早期測試結果的後處理輸出。除此以外，這些腳本根據所使用的解釋器而不一樣：

不一樣的跑步者腳本
翻譯員	測試執行	後期處理
蟒蛇	`pybot`	`rebot`
Jython的	`jybot`	`jyrebot`
IronPython的	`ipybot`	`ipyrebot`

在類UNIX操做系統（如Linux和OS X）上，運行腳本是使用Python實現的，在Windows上它們是批處理文件。不管操做系統如何，使用這些腳本都須要相應的解釋器在PATH中。

直接入口點

除了上面的runner腳本以外，還能夠經過直接使用選定的解釋器執行框架的入口點來運行測試和後處理輸出。能夠使用Python的-m選項將它們做爲模塊執行，而且若是知道安裝框架的位置，則能夠將它們做爲腳本運行。下面的表格使用Python列出了入口點，下面的例子說明了在其餘解釋器中使用它們的方法。

直接入口點
入口點	做爲模塊運行	以腳本運行
測試執行	`python -m robot.run`	`python path/robot/run.py`
後期處理	`python -m robot.rebot`	`python path/robot/rebot.py`

＃經過執行`robot.run`模塊，用Python運行測試。python -m robot.run＃運行`robot / run.py`腳本運行Jython測試。jython path / to / robot / run.py＃經過執行`robot.rebot`模塊，用IronPython建立報表/日誌。ipy -m robot.rebot＃運行`robot / rebot.py`腳本，用Python建立報告/日誌。python path / to / robot / rebot.py

1.4示範

有幾個演示項目介紹Robot Framework並幫助開始使用它。

快速入門指南: 介紹機器人框架的最重要的功能，並做爲一個可執行的演示。
機器人框架演示: 簡單的示例測試用例。演示還建立自定義測試庫。
網絡測試演示: 演示如何建立測試和更高級別的關鍵字。被測系統是一個簡單的網頁，使用 Selenium2Library進行測試。
SwingLibrary演示: 演示如何使用 SwingLibrary來測試Java GUI應用程序。
ATDD與機器人框架: 演示如何在遵循驗收測試驅動開發（ATDD）過程時使用Robot Framework。

2建立測試數據

2.1測試數據語法

本節介紹Robot Framework的總體測試數據語法。如下部分將解釋如何實際建立測試用例，測試套件等。

2.1.1文件和目錄

安排測試用例的層次結構以下：

測試用例在測試用例文件中建立。
測試用例文件會自動建立一個包含該文件中的測試用例的測試套件。
包含測試用例文件的目錄構成了更高級別的測試套件。這樣的測試套件目錄具備從測試用例文件建立的套件做爲其子測試套件。
測試套件目錄也能夠包含其餘測試套件目錄，而且這個分層結構能夠根據須要深度嵌套。
測試套件目錄能夠有一個特殊的初始化文件。

除此以外，還有：

測試包含最低級關鍵字的庫。
帶有變量和更高級別用戶關鍵字的資源文件。
變量文件提供比資源文件更靈活的建立變量的方法。

2.1.2支持的文件格式

Robot Framework測試數據以表格格式定義，使用超文本標記語言（HTML），製表符分隔值（TSV），純文本或reStructuredText（reST）格式。這些格式的細節，以及它們的主要優勢和問題，將在後面的章節中進行解釋。要使用哪一種格式取決於上下文，但若是沒有特殊須要，則建議使用純文本格式。

Robot Framework根據文件擴展名爲測試數據選擇一個解析器。該擴展名不區分大小寫，HTML的擴展名爲 .html，.htm和.xhtml， TSV的.tsv，.txt和純文本的特殊.robot，以及.resstructuredText的.rst和.rest。

不一樣的測試數據模板可用於HTML和TSV格式，以便開始編寫測試。

注意

從Robot Framework 2.7.6開始，支持純文本文件的特殊.robot擴展。

HTML格式

HTML文件支持表格周圍的格式和自由文本。這樣能夠將附加信息添加到測試用例文件中，並容許建立看起來像正式測試規範的測試用例文件。HTML格式的主要問題是使用普通文本編輯器編輯這些文件並不容易。另外一個問題是，HTML不能和版本控制系統一塊兒工做，由於除了對實際測試數據的更改以外，更改產生的差別包含HTML語法。

在HTML文件中，測試數據是在單獨的表中定義的（請參見下面的示例）。Robot Framework 根據第一個單元格中的文本識別這些測試數據表。承認的表格外的全部內容都被忽

使用HTML格式
設置	值	值	值
圖書館	操做系統

變量	值	值	值
$ {文}	你好，世界！

測試用例	行動	論據	論據
個人測試	[文檔]	示例測試
日誌	$ {文}
個人關鍵字	/ tmp目錄

另外一個測試	應該是平等的	$ {文}	你好，世界！

關鍵詞	行動	論據	論據
個人關鍵字	[參數]	$ {PATH}
目錄應該存在	$ {PATH}

編輯測試數據

HTML文件中的測試數據能夠使用您喜歡的任何編輯器進行編輯，但建議您使用圖形編輯器，在這裏您能夠真正看到表格。RIDE能夠讀取和寫入HTML文件，但不幸的是，它會丟失全部的HTML格式以及測試用例表以外的可能的數據。

編碼和實體引用

HTML實體引用（例如，ä）受支持。另外，能夠使用任何編碼，假設它在數據文件中被指定。正常的HTML文件必須使用META元素，以下例所示：

<meta http-equiv =「Content-Type」content =「text / html; charset = UTF-8」>

在本例中，XHTML文件應該使用XML前導碼：

<？xml version =「1.0」encoding =「Big5」？>

若是沒有指定編碼，Robot Framework默認使用ISO-8859-1。

TSV格式

TSV文件能夠在電子表格程序中進行編輯，由於語法很是簡單，因此很容易以編程方式生成。它們使用普通的文本編輯器也很容易編輯，並且它們在版本控制中運行良好，但純文本格式更適合於這些目的。

TSV格式能夠在Robot Framework的測試數據中用於與HTML相同的目的。在TSV文件中，全部數據都在一個大表中。測試數據表能夠從一個或多個星號（*）中識別出來，而後是一個普通的表名和一個可選的星號。第一個識別表以前的全部內容都被忽略，就像HTML數據中的表外數據同樣。

使用TSV格式
設置	值	值	值
圖書館	操做系統


變量	值	值	值
$ {文}	你好，世界！


測試用例	行動	論據	論據
個人測試	[文檔]	示例測試
日誌	$ {文}
個人關鍵字	/ tmp目錄

另外一個測試	應該是平等的	$ {文}	你好，世界！


關鍵詞	行動	論據	論據
個人關鍵字	[參數]	$ {PATH}
目錄應該存在	$ {PATH}

編輯測試數據

您能夠在任何電子表格程序（如Microsoft Excel）中建立和編輯TSV文件。保存文件時選擇製表符分隔的格式，並記住將文件擴展名設置爲.tsv。關閉全部自動更正並配置工具將文件中的全部值做爲純文本處理也是一個好主意。

使用任何文本編輯器編輯TSV文件都相對容易，尤爲是編輯器支持從空格中可視地分離製表符時。RIDE也支持TSV格式。

Robot Framework首先將全部內容分割成行，而後根據表格字符將行分割成單元格，從而分析TSV數據。電子表格程序有時會用引號括住單元格（例如"my value"），而Robot Framework會刪除它們。數據內部的可能引號加倍（例如 "my ""quoted"" value"），這也是正確處理的。若是您使用電子表格程序來建立TSV數據，則不須要注意這一點，可是若是以編程方式建立數據，則必須遵循與電子表格相同的引用約定。

編碼

TSV文件老是須要使用UTF-8編碼。因爲ASCII是UTF-8的子集，所以天然也支持純ASCII。

純文本格式

純文本格式很是容易使用任何文本編輯器進行編輯，而且在版本控制中也能夠很好地工做。因爲這些好處，它已成爲Robot Framework最經常使用的數據格式。

純文本格式在技術上與TSV格式相似，但單元之間的分隔符不一樣。TSV格式使用製表符，可是在純文本格式中，能夠使用兩個或多個空格或用空格（|）包圍的管道符號。

該測試數據表必須有本身的名字前的一個或多個星號相似於在TSV格式。不然，星號，並在表頭可能的空間被忽略的話，例如，*** Settings ***和*Settings工做方式相同。與TSV格式相似，第一個表格以前的全部內容都將被忽略。

在純文本文件中，選項卡會自動轉換爲兩個空格。這容許與TSV格式相似地使用單個標籤做爲分隔符。可是，請注意，在純文本格式中，多個選項卡被認爲是單個分隔符，而在TSV格式中，每一個選項卡都是分隔符。

空格分隔的格式

用做分隔符的空格的數量能夠變化，只要至少有兩個空格，就能夠很好地對齊數據。這對於在文本編輯器中編輯TSV格式有明顯的好處，由於TSV不能控制對齊。

***設置***庫操做系統       ***變量***$ { MESSAGE }     你好，世界！*** 測試用例 ***個人測試    [ 文檔]     示例測試    記錄    $ { MESSAGE } 個人關鍵字/ tmp        另外一個測試    應該是平等的    $ { MESSAGE }     你好，世界！***關鍵詞***個人關鍵字    [ 參數] $ { path } 目錄應該存在    $ { path }

由於空間被用做分離器，全部空單元必須被轉義與${EMPTY}變量或一個反斜槓。不然，處理空白與其餘測試數據沒有區別，由於前導，尾隨和連續空格必須始終轉義。

小費

建議在關鍵字和參數之間使用四個空格。

管道和空間分隔的格式

空格分隔的格式最大的問題是可視化分隔關鍵字表單參數可能會很是棘手。這是一個問題，特別是若是關鍵字須要大量參數和/或參數包含空格。在這種狀況下，管道和空間分隔變體能夠更好地工做，由於它使單元邊界更加可見。

| *設置*   |     *值*      | | 圖書館    | OperatingSystem || *變量* |     *值*      | | $ { MESSAGE } | 你好，世界！   || *測試案例*   | *行動*         | *參數*    | | 個人測試      | [ 文檔] | 示例測試| | | 日誌             | $ { MESSAGE } | | | 個人關鍵字      | / tmp          | | 另外一個測試| 應該是平等的| $ { MESSAGE } | 你好，世界！| *關鍵字*   | | 個人關鍵字| [ 參數] | $ { path } | | 目錄應該存在| $ { path }

純文本文件能夠包含空格和空格分隔格式的測試數據，可是單行必須使用相同的分隔符。由管道和空間分隔的管線由強制性的管道進行識別，但管線末端的管道是可選的。管道兩側至少有一個空間（開始和結束處除外），但除了使數據更清楚之外，不須要對齊管道。

當使用管道和空間分隔格式時，不須要空白單元格（除了尾部空單元格）。惟一要考慮的是實際測試數據中由空格包圍的可能管道必須使用反斜線進行轉義：

| ***測試案例*** | | | | | 逃跑的管道      | $ { file count } = | 執行命令| ls -1 * .txt \ | wc -l | | | 應該是平等的| $ { file count } | 42                    |

編輯和編碼

純文本格式比HTML和TSV最大的好處之一是使用普通文本編輯器進行編輯很是簡單。許多編輯器和IDE（至少是Eclipse，Emacs，Vim和TextMate）也有支持語法突出顯示Robot Framework測試數據的插件，而且還能夠提供關鍵字完成等其餘功能。RIDE也支持純文本格式。

與TSV測試數據相似，純文本文件始終應使用UTF-8編碼。所以也支持ASCII文件。

承認的擴展

從Robot Framework 2.7.6開始，除了正常的.txt擴展名之外，還能夠使用特殊的.robot擴展名保存純文本測試數據文件。新的擴展使得將測試數據文件與其餘純文本文件區分開來變得更加容易。

reStructuredText格式

reStructuredText（reST）是一個易於閱讀的純文本標記語法，一般用於Python項目的文檔（包括Python自己以及本用戶指南）。reST文檔一般被編譯爲HTML，但也支持其餘輸出格式。

在Robot Framework中使用reST容許您以簡潔的文本格式混合豐富格式的文檔和測試數據，使用簡單的文本編輯器，差別工具和源代碼管理系統能夠輕鬆完成工做。實際上它結合了純文本和HTML格式的許多好處。

在Robot Framework中使用reST文件時，有兩種方法能夠定義測試數據。您能夠使用代碼塊並使用純文本格式在其中定義測試用例，或者您能夠像使用HTML格式同樣使用表格。

注意

在Robot Framework中使用reST文件須要安裝Python docutils模塊。

使用代碼塊

reStructuredText文檔能夠在所謂的代碼塊中包含代碼示例。當這些文檔被編譯成HTML或其餘格式時，代碼塊使用Pygments高亮語法。在標準的代碼塊中，開始使用code指令，但Sphinx使用code-block 或者sourcecode代替。代碼塊中的編程語言的名稱做爲指令的參數給出。例如，如下代碼塊分別包含Python和Robot Framework示例：

..  code ::  python   高清 EXAMPLE_KEYWORD （）：       打印 '你好，世界！'..  code ::  robotframework   *** 測試用例 ***   示例測試       示例關鍵字

當機器人框架解析reStructuredText的文件，可能它首先搜索code，code-block或sourcecode含有機器人框架測試數據塊。若是找到這樣的代碼塊，則它們包含的數據被寫入到內存文件中並被執行。代碼塊以外的全部數據都被忽略。

代碼塊中的測試數據必須使用純文本格式進行定義。以下例所示，支持空間和管道分離變體：

例子-------這個文本在代碼塊以外，所以被忽略。..  code ::  robotframework   ***設置***   庫操做系統          ***變量***   $ { MESSAGE }     你好，世界！   *** 測試用例 ***   個人測試       [ 文檔]     示例測試       記錄    $ { MESSAGE }    個人關鍵字/ tmp           另外一個測試       應該是平等的    $ { MESSAGE }     你好，世界！此外，這個文本是在代碼塊以外，並被忽略。上面的塊使用空格分隔純文本格式和下面的塊使用管道分開的變體。..  code ::  robotframework   | ***關鍵字***   | | |    | 個人關鍵字       | [ 參數] | $ { path } |    | | 目錄應該存在| $ { path } |

注意

使用反斜槓字符轉義一般以這種格式工做。不須要雙重轉義，就像使用從新表格同樣。

注意

支持代碼塊中的測試數據是Robot Framework 2.8.2中的一項新功能。

使用表格

若是reStructuredText文檔不包含具備Robot Framework數據的代碼塊，則但願與表格中的數據相似於HTML格式。在這種狀況下，Robot Framework將文檔編譯爲內存中的HTML，並將其解析爲徹底像分析正常HTML文件同樣。

Robot Framework 根據第一個單元格中的文本識別測試數據表，而且忽略所識別表格類型以外的全部內容。如下使用簡單表格和網格表語法顯示四個測試數據表格中的每個的示例：

例子-------該文本在表格以外，所以被忽略。============ ================ ======= =======  設定值的價值============ ================ ======= =======庫操做系統============ ================ ======= =================== ================ ======= =======  變量值的值============ ================ ======= =======$ {MESSAGE}你好，世界！============ ================ ======= ==================== ================== ============ ======= ======  測試用例操做參數參數============= ================== ============ ======= ======個人測試[文檔]示例測試\ Log $ {MESSAGE}\個人關鍵字/ tmp\另外一個測試應該是相等的$ {MESSAGE}你好，世界！============= ================== ============ ======= ======此外，這個文本是在表以外，並被忽略。上面的表格被建立使用簡單的表格語法和下面的表格使用網格表作法。+ ------------- + ------------------------ + ---------- -  + ------------ +|    關鍵字| 行動| 參數| 參數|+ ------------- + ------------------------ + ---------- -  + ------------ +| 個人關鍵字| [參數] | $ {path} | |+ ------------- + ------------------------ + ---------- -  + ------------ +|              | 目錄應該存在| $ {path} | |+ ------------- + ------------------------ + ---------- -  + ------------ +

注意

第一列簡單表格中的空單元格須要轉義。上面的例子使用\，但..也能夠使用。

注意

因爲反斜線字符是reST中的轉義字符，所以指定一個反斜槓以使Robot Framework能看到它，須要使用另外一個反斜槓來轉義它\\。例如，一個新的行字符必須寫成像\\n。因爲反斜槓也用於在Robot Framework數據中進行轉義，所以在使用reST表時指定文字反斜槓須要進行雙重轉義c:\\\\temp。

每次運行測試時基於reST文件生成HTML文件顯然會增長一些開銷。若是這是一個問題，那麼使用外部工具分別將reST文件轉換爲HTML是一個好主意，並讓Robot Framework只使用生成的文件。

編輯和編碼

reStructuredText文件中的測試數據能夠用任何文本編輯器進行編輯，許多編輯器也爲其提供自動語法高亮顯示。雖然，RIDE不支持reST格式。

Robot Framework要求使用UTF-8編碼保存包含非ASCII字符的reST文件。

reST源文件中的語法錯誤

若是reStructuredText文檔在語法上不正確（例如格式錯誤的表格），則解析該文檔將失敗，而且不能從該文件中找到測試用例。執行單個reST文件時，Robot Framework將在控制檯上顯示錯誤。當執行一個目錄時，這樣的解析錯誤一般會被忽略。

2.1.3測試數據表

測試數據分爲如下四種類型的表格。這些測試數據表由表的第一個單元格標識，下表中的最後一列列出了可用做表名稱的不一樣別名。

不一樣的測試數據表
表名	用於	別名
設置表	1）導入測試庫，資源文件和變量文件 2）爲測試套件和測試用例定義元數據	設置，設置，元數據
變量表	定義能夠在測試數據中的其餘地方使用的變量	變量，變量
測試案例表	從可用關鍵字建立測試用例	測試用例，測試用例
關鍵字表格	從現有的低級關鍵字建立用戶關鍵字	關鍵字，關鍵字，用戶關鍵字，用戶關鍵字

2.1.4解析數據的規則

忽略的數據

Robot Framework解析測試數據時，忽略：

在第一個單元格中沒有以可識別的表名稱開頭的全部表格。
除了第一個單元格外，表格第一行的其餘全部內容。
全部數據在第一個表以前。若是數據格式容許表格之間的數據，也被忽略。
全部空行，這意味着這些行能夠用來使表更具可讀性。
行尾的全部空單元，除非它們被轉義。
全部單反斜槓（\）不用於轉義時。
#當它是單元格的第一個字符時，全部跟在散列字符（）後面的字符。這意味着能夠使用散列標記在測試數據中輸入註釋。
全部格式在HTML / reST測試數據。

當Robot Framework忽略一些數據時，這些數據在任何生成的報告中都不可用，另外，Robot Framework使用的大多數工具也忽略它們。要添加Robot Framework輸出中可見的信息，請將其放置在測試用例或套件的文檔或其餘元數據中，或使用BuiltIn關鍵字「日誌」或「註釋」進行記錄。

處理空白

Robot Framework處理空白的方式與在HTML源代碼中處理空白的方式相同：

換行符，回車符和製表符被轉換爲空格。
全部單元格中的前導空白符將被忽略。
多個連續的空格被摺疊成一個空格。

除此以外，不間斷空間被正常空間所替代。這樣作是爲了不在無心間使用不間斷空間而不是普通空間時出現難以調試的錯誤。

若是須要引導，尾隨或連續空格，則必須將其轉義。換行符，回車，製表符和非換空間能夠使用被建立轉義序列 \n，\r，\t，和\xA0分別。

逃離

Robot Framework測試數據中的轉義字符是反斜線（\）和額外的內置變量 ${EMPTY}，${SPACE} 一般可用於轉義。下面將討論不一樣的轉義機制。

轉義特殊字符

反斜槓字符可用於轉義特殊字符，以便使用它們的字面值。

轉義特殊字符
字符	含義	例子
`\$`	美圓符號永遠不會啓動一個標量變量。	`\${notvar}`
`\@`	在符號上，永遠不會啓動一個列表變量。	`\@{notvar}`
`\%`	百分號，永遠不會啓動一個環境變量。	`\%{notvar}`
`\#`	哈希符號，從不開始評論。	`\# not comment`
`\=`	等號，從不是命名參數語法的一部分。	`not\=named`
`\\|`	管道字符，而不是管道分隔格式中的分隔符。	`\| Run \| ps \\| grep xxx \|`
`\\`	反斜槓字符，永遠不會逃脫任何東西。	`c:\\temp, \\${var}`

造成轉義序列

反斜槓字符還容許建立特殊的轉義序列，這些轉義序列被識別爲不然在測試數據中難以或不可能建立的字符。

逃逸序列
序列	含義	例子
`\n`	換行字符。	`first line\n2nd line`
`\r`	回車符	`text\rmore text`
`\t`	製表符。	`text\tmore text`
`\xhh`	十六進制值的字符`hh`。	`null byte: \x00, ä: \xE4`
`\uhhhh`	十六進制值的字符`hhhh`。	`snowman: \u2603`
`\Uhhhhhhhh`	十六進制值的字符`hhhhhhhh`。	`love hotel: \U0001f3e9`

注意

在測試數據中建立的全部字符串（包括字符 \x02）都是Unicode，必要時必須顯式轉換爲字節字符串。這是能夠作到，例如，使用轉換爲字節或編碼字符串的字節中的關鍵字內建和字符串庫，分別或相似str(value)或value.encode('UTF-8') 在Python代碼。

注意

若是無效的十六進制值與使用\x，\u 或\U逸出，最終的結果是沒有反斜線字符原始值。例如，\xAX（未十六進制）和 \U00110000（過大的值）的結果與xAX 和U00110000分別。可是，這種行爲在將來可能會改變。

注意

${\n}若是須要操做系統相關的行終止符（\r\n在Windows和 \n其餘地方），能夠使用內置變量。

注意

\n被忽略以後可能的未轉義的空白字符。這意味着two lines\nhere而且 two lines\n here是等同的。這樣作的動機是在使用HTML格式時容許包含換行符的長行，可是其餘格式也使用相同的邏輯。此規則的一個例外是在擴展變量語法內不會忽略空白字符。

注意

\x，\u而且\U在Robot Framework 2.8.2中轉義序列是新的。

防止忽略空單元格

若是須要將空值做爲關鍵字的參數或其餘參數，則一般須要將其轉義以防止被忽略。不管測試數據格式如何，清空尾隨的單元格都必須轉義，而且在使用空格分隔格式時，必須轉義全部空值。

空單元格能夠使用反斜線字符或內置變量進行轉義 ${EMPTY}。後者一般是推薦的，由於它更容易理解。此建議的一個例外是在使用空格分隔格式時，使用反斜線轉義 for循環中的縮進單元格。全部這些狀況在如下示例中首先以HTML格式顯示，而後以空格分隔的純文本格式顯示：

測試用例	行動	論據	論據	論據
使用反斜槓	作一點事	第一個arg	\
使用$ {EMPTY}	作一點事	第一個arg	$ {EMPTY}
非尾隨空	作一點事		第二個arg	＃在HTML中不須要轉義
For循環	：對於	$ {VAR}	在	@ {} VALUES
	日誌	$ {VAR}	＃這裏也不須要轉義

*** 測試用例 ***使用反斜槓    先作一些事arg \        使用$ { EMPTY } 先作一些事情arg     $ { EMPTY } 非尾隨空            作些什麼    $ { EMPTY }      second arg ＃空格分隔格式所需的轉義For循環        ：FOR $ { var } IN @ { VALUES }     \     Log     $ { var }                          ＃這裏也須要轉義

防止無視空間

因爲單元格中的前導空格，尾部空格和連續空格被忽略，所以若是須要將它們做爲關鍵字的參數或以其餘方式進行轉義，則須要將其轉義。與防止忽略空單元格同樣，能夠使用反斜線字符或使用內置變量來執行此操做 ${SPACE}。

轉義空格的例子
用反斜槓轉義	逃跑 `${SPACE}`	筆記
領先的空間	`${SPACE}leading space`
尾隨空間\	`trailing space${SPACE}`	反斜槓必須在空格以後。
\ \ \	`${SPACE}`	雙方都須要反斜槓。
連續的\空格	`consecutive${SPACE * 3}spaces`	使用擴展的變量語法。

正如上面的例子所示，使用${SPACE}變量一般會使測試數據更容易理解。當須要多個空間時，與擴展變量語法結合使用尤爲方便。

將測試數據分紅幾行

若是有更多的數據比隨便一行，能夠使用省略號（...）來繼續前一行。在測試用例和用戶關鍵字表中，省略號必須至少有一個空單元格。在設置和變量表中，它能夠直接放置在設置或變量名下。在全部的表中，省略號以前的全部空單元都被忽略。

此外，只有一個值（主要是文檔）的設置值能夠分紅幾列。這些值將在解析測試數據時與空格一塊兒鏈接。從Robot Framework 2.7開始，分割成多行的文檔和測試套件元數據將與換行符一塊兒鏈接。

下面的例子說明了上面討論的全部語法。在前三個表中，測試數據尚未被拆分，接下來的三個數據代表，在將數據分紅幾行以後，須要的列數是多少。

測試還沒有拆分的數據
設置	值	值	值	值	值	值
默認標籤	標籤-1	標籤-2	標籤-3	標籤-4	標籤-5	標籤-6

變量	值	值	值	值	值	值
@ {}清單	這個	名單	具備	至關	許多	項目

測試用例	行動	論據	精氨酸	精氨酸	精氨酸	精氨酸	精氨酸	精氨酸
例	[文檔]	這個測試案例的文檔。\ n這可能會至關長。
	[標籤]	T-1	T-2	T-3	T-4	T-5
	作X	一	二	三	四	五	六
	$ {var} =	獲得X	1	2	3	4	五	6

測試數據分紅幾行
設置	值	值	值
默認標籤	標籤-1	標籤-2	標籤-3
...	標籤-4	標籤-5	標籤-6

變量	值	值	值
@ {}清單	這個	名單	具備
...	至關	許多	項目

測試用例	行動	論據	論據	論據
例	[文檔]	文檔	爲了這	測試用例。
...	這能夠獲得	至關	長...
[標籤]	T-1	T-2	T-3
...	T-4	T-5
作X	一	二	三
...	四	五	六
$ {var} =	獲得X	1	2
	...	3	4
	...	五	6

2.2建立測試用例

本節介紹總體測試用例語法。下一節將討論使用測試用例文件和測試套件目錄將測試用例組織到測試套件中的狀況。

2.2.1測試用例語法

基本的語法

測試用例在可用關鍵字的測試用例表中構建。關鍵字能夠從測試庫或資源文件中導入，也能夠在測試用例文件自己的關鍵字表中建立。

測試用例表中的第一列包含測試用例名稱。測試用例從該列中的某行開始，繼續到下一個測試用例名稱或表結尾。在表頭和第一個測試之間有一些東西是錯誤的。

第二列一般有關鍵字名稱。此規則的一個例外是，當關鍵字返回值設置變量時，第二個和可能的後續列包含變量名稱，而且關鍵字名稱位於後面。不管哪一種狀況，關鍵字名稱後面的列都包含指定關鍵字的可能參數。

示例測試用例
測試用例	行動	論據	論據
有效登陸	打開登陸頁面
輸入名稱	演示
輸入密碼	模式
提交證書
歡迎頁面應該打開

設置變量	作一點事	第一個論點	第二個論據
$ {value} =	得到一些價值
應該是平等的	$ {}值	指望值

測試用例表中的設置

測試用例也能夠有本身的設置。設置名稱始終位於第二列，一般是關鍵字，其值在後續列中。設置名稱周圍有方括號，以區別於關鍵字。下面列出了可用的設置，並在本節稍後進行介紹。

[文檔]: 用於指定測試用例文檔。
[標籤]: 用於標記測試用例。
[設置]，[拆解]: 指定測試設置和拆卸。還分別有同義詞 [Precondition]和[Postcondition]。
[模板]: 指定要使用的模板關鍵字。測試自己將只包含用做該關鍵字參數的數據。
[時間到]: 用於設置測試用例超時。超時在他們本身的部分討論。

示例測試用例設置
測試用例	行動	論據
測試設置	[文檔]	另外一個虛擬測試
[標籤]	假	業主爲johndoe
日誌	你好，世界！

2.2.2使用參數

前面的例子已經說明了不一樣論點的關鍵字，本節更深刻地討論了這個重要的功能。如何真正實現用不一樣參數的用戶關鍵字和庫關鍵字在不一樣的部分討論。

關鍵字能夠接受零個或多個參數，某些參數可能具備默認值。關鍵字接受哪些參數取決於其實現方式，一般搜索此信息的最佳位置是關鍵字的文檔。在本節的示例中，文檔預計將使用libdoc工具生成，可是相同的信息可用於通用文檔工具（如javadoc）生成的文檔。

強制性參數

大多數關鍵字都有必定數量的參數，必須始終給出。在關鍵字文檔中，這是經過指定用逗號分隔的參數名來表示的first, second, third。在這種狀況下，參數名稱實際上並不重要，只是它們應該解釋參數的做用，但具備與文檔中指定的參數徹底相同的參數是很是重要的。使用太少或太多的參數會致使錯誤。

下面的測試使用來自OperatingSystem庫的關鍵字Create Directory和Copy File。他們的論點被指定爲和，這意味着他們分別拿一個和兩個參數。最後一個關鍵字，來自BuiltIn的No Operation，不帶任何參數。pathsource, destination

帶位置參數的關鍵字
測試用例	行動	論據
例	建立目錄	$ {TEMPDIR} /東東
複製文件	$ {} CURDIR /file.txt	$ {TEMPDIR} /東東
沒有操做

默認值

參數一般具備既能夠給定也能夠不給定的默認值。在文檔中，默認值一般與參數名稱用等號分隔name=default value，可是使用Java 實現的關鍵字可能會有多個具備不一樣參數的相同關鍵字的實現。全部參數均可能有默認值，可是在帶有默認值的參數後面不能有任何位置參數。

下面的示例使用默認值說明了使用具備參數的「建立文件」關鍵字path, content=, encoding=UTF-8。試圖使用它沒有任何參數或超過三個參數將沒法正常工做。

具備參數的關鍵字具備默認值
測試用例	行動	論據	論據
例	建立文件	$ {TEMPDIR} /empty.txt
建立文件	$ {TEMPDIR} /utf-8.txt	Hyväesimerkki
建立文件	$ {TEMPDIR} /iso-8859-1.txt	Hyväesimerkki	ISO-8859-1

可變數量的參數

也能夠建立接受任意數量參數的關鍵字。這些參數能夠與強制參數和帶有默認值的參數相結合，但所謂的可變參數老是最後一個參數。在文檔中，它們一般在參數名稱以前有一個星號*varargs，可是與Java庫又有區別。

刪除文件和加入路徑下面的例子中使用的關鍵字分別具備參數*paths和base, *parts。前者能夠與任意數量的參數一塊兒使用，但後者至少須要一個參數。

具備可變數量參數的關鍵字
測試用例	行動	論據	論據	論據
例	刪除文件	$ {TEMPDIR} /f1.txt	$ {TEMPDIR} /f2.txt	$ {TEMPDIR} /f3.txt
@ {paths} =	加入路徑	$ {TEMPDIR}	f1.txt
...	f2.txt	f3.txt	f4.txt

命名的參數

命名的參數語法使得使用具備默認值的參數更加靈活，而且容許明確地標記某個參數值意味着什麼。技術上命名的參數與Python中的關鍵字參數徹底相同。

基本的語法

能夠經過給參數賦予一個參數的名稱前綴值來命名參數arg=value。當多個參數具備默認值時，這是特別有用的，由於能夠僅命名一些參數並讓其餘人使用它們的默認值。例如，若是一個關鍵字接受參數arg1=a, arg2=b, arg3=c，並用一個參數arg3=override，參數調用 arg1並arg2獲取它們的默認值，但arg3 得到值override。若是這聽起來很複雜，下面的命名參數示例有但願使其更清楚。

命名的參數語法既是大小寫又是空格敏感的。前者意味着，若是你有一個論點arg，你必須使用它 arg=value，既不，Arg=value也不ARG=value 工做。後者意味着在= 符號以前不容許有空格，而且以後可能的空格被認爲是給定值的一部分。

當命名參數語法與用戶關鍵字一塊兒使用時，參數名稱必須在沒有${}裝飾的狀況下給出。例如，${arg1}=first, ${arg2}=second必須使用帶有參數的用戶關鍵字arg2=override。

例如，在命名參數以後使用普通的位置參數 | Keyword | arg=value | positional |不起做用。從Robot Framework 2.8開始，這會致使一個明顯的錯誤。命名參數的相對順序可有可無。

注意

在Robot Framework 2.8以前，不能命名沒有默認值的參數。

用變量命名參數

能夠在兩個命名的參數名稱和值中使用變量。若是該值是單個標量變量，則將其按原樣傳遞給關鍵字。這容許在使用命名參數語法時使用任何對象（不只是字符串）做爲值。例如，調用相似的關鍵字arg=${object} 會將變量傳遞${object}給關鍵字，而不會將其轉換爲字符串。

若是在命名參數名稱中使用變量，則在將變量與參數名稱進行匹配以前先解析變量。這是Robot Framework 2.8.6中的一個新功能。

命名的參數語法要求在關鍵字調用中直接寫入等號。這意味着若是一個變量具備相似的值foo=bar，它永遠不會觸發命名的參數語法。當把關鍵字包裝到其餘關鍵字中時，這一點很重要。例如，若是一個關鍵字採用可變數量的參數，@{args} 而且使用相同的@{args}語法將其所有傳遞給另外一個關鍵字，則這些值不會被識別爲named。看下面的例子：

命名參數不能從變量值中識別
測試用例	行動	論據	論據
例	包裝紙	殼=真	＃這不會做爲啓動進程的命名參數

關鍵詞	行動	論據	論據	論據
包裝紙	[參數]	@ {} ARGS
啓動過程	MyProcess	@ {} ARGS	＃命名參數不能從@ {args}中識別

轉義命名參數語法

命名的參數語法僅在等號前的參數部分與關鍵字參數之一匹配時使用。可能有一個相似於字面值的位置參數foo=quux，還有一個與名稱無關的參數foo。在這種狀況下，參數 foo要麼不正確地獲取值，quux要麼更多是語法錯誤。

在偶然匹配的狀況下，能夠使用反斜槓字符來轉義語法foo\=quux。如今參數將會獲得一個字面的值foo=quux。請注意，若是沒有名稱參數，則不須要轉義foo，可是因爲它使狀況更加明確，因此它多是個好主意。

支持命名參數的地方

正如已經解釋的那樣，命名參數語法與關鍵字一塊兒工做除此以外，在使用測試庫時，它也能夠工做。

命名參數由用戶關鍵字和大多數測試庫支持。惟一的例外是使用靜態庫API的基於Java的庫。使用Libdoc生成的庫文檔有一個註釋，庫是否支持命名參數。

注意

在Robot Framework 2.8以前，命名參數語法不適用於使用動態庫API的測試庫。

命名參數的例子

如下示例演示如何使用帶有庫關鍵字，用戶關鍵字和導入Telnet測試庫的命名參數語法。

命名的參數的例子
設置	值	值	值
圖書館	遠程登陸	提示= $	default_log_level = DEBUG

測試用例	行動	論據	論據	論據
例	打開鏈接	10.0.0.42	端口= $（港口）	別名=示例
列出文件	選項= -lh
列出文件	路徑= / TMP	選項= -l

關鍵詞	行動	論據	論據	論據
列出文件	[參數]	$ {PATH} =。	$ {}選項=
執行命令	ls $ {options} $ {path}

免費的關鍵字參數

Robot Framework 2.8增長了對Python風格的免費關鍵字參數（**kwargs）的支持。這意味着關鍵字能夠在使用name=value語法的關鍵字調用結束時接收全部參數，而且不會與任何其餘參數（如kwargs）匹配。

免費的關鍵字參數支持變量相似於命名參數。在實踐中，這意味着變量既能夠在名稱中使用，也能夠在值中使用，可是轉義符必須始終能夠從字面上看到。例如，這兩個foo=${bar}和${foo}=${bar}是有效的，只要所使用的變量存在。一個額外的限制是免費的關鍵字參數名稱必須始終是字符串。對名稱中的變量的支持是Robot Framework 2.8.6中的一個新功能，在此以前，可能的變量未被解決。

最初的free關鍵字參數只適用於基於Python的庫，但Robot Framework 2.8.2擴展了對動態庫API的支持，Robot Framework 2.8.3將其進一步擴展到基於Java的庫和遠程庫接口。換句話說，如今全部的圖書館都支持kwargs。不幸的是用戶關鍵字不支持他們，可是這個支持是爲 Robot Framework 2.9而設計的。

有關使用kwargs的真實案例，咱們來看看 Process Library 中的Run Process關鍵字。它有一個簽名，這意味着它執行該命令，將其參數做爲可變數量的參數，最後是可選的配置參數做爲自由關鍵字參數。command, *arguments, **configuration**configuration

使用免費的關鍵字參數
測試用例	行動	論據	論據	論據	論據
使用Kwargs	運行進程	COMMAND.EXE	ARG1	ARG2	CWD = / home / user的
運行進程	COMMAND.EXE	論據	殼=真	ENV = $ {} ENVIRON

如上例所示，使用帶有free關鍵字參數的變量與使用命名參數語法徹底相同。

有關在自定義測試庫中使用kwargs語法的更多信息，請參閱建立測試庫下的免費關鍵字參數（** kwargs）部分。

嵌入到關鍵字名稱的參數

指定參數的徹底不一樣的方法是將它們嵌入到關鍵字名稱中。至少目前這個語法只支持用戶關鍵字。

2.2.3失敗

當測試用例失敗時

若是任何關鍵字使用失敗，則測試用例將失敗。一般這意味着中止執行該測試用例，執行可能的測試拆卸，而後繼續執行下一個測試用例。若是不但願中止測試執行，也能夠使用特殊的可連續性故障。

錯誤消息

分配給失敗測試用例的錯誤消息直接來自失敗的關鍵字。錯誤信息一般是由關鍵字自己建立的，但有些關鍵字容許配置它們。

在某些狀況下，例如，當使用可連續性故障時，測試用例可能會屢次失敗。在這種狀況下，最終的錯誤信息是經過組合單個錯誤獲得的。很是長的錯誤信息會自動從中間刪除，使報告更易於閱讀。完整的錯誤消息始終在日誌文件中顯示爲關鍵字失敗的消息。

默認狀況下，錯誤消息是普通文本，可是從Robot Framework 2.8開始，它們能夠包含HTML格式。這是經過使用標記字符串啓動錯誤消息來啓用的*HTML*。此標記將從報告和日誌中顯示的最終錯誤消息中刪除。在下面的第二個示例中顯示了在自定義消息中使用HTML。

關鍵字錯誤消息
測試用例	行動	論據	論據	論據
正常錯誤	失敗	這是一個至關無聊的例子
HTML錯誤	$ {數} =	獲取號碼
	應該是平等的	$ {}號	42	* HTML *號碼不是個人<b> MAGIC </ b>號碼。

2.2.4測試用例名稱和文檔

測試用例名直接來自測試用例表：它正是輸入到測試用例列中的內容。一個測試套件中的測試用例應該有惟一的名稱。與此相關，您也能夠使用測試中的自動變量 ${TEST_NAME}來引用測試名稱。不管什麼時候執行測試，包括全部用戶關鍵字，以及測試設置和測試拆卸均可用。

在[文件]設置，能夠設置爲測試條件下自由文檔。該文本顯示在命令行輸出中，以及生成的測試日誌和測試報告。

若是文檔很長，能夠將其分紅幾個與空格鏈接的單元格。能夠使用簡單的 HTML格式，而且能夠使用變量來使文檔動態化。從Robot Framework 2.7開始，若是文檔被分紅多行，那麼這些行自己就是使用換行符來連接的。若是換行符已經以換行符結尾或換行符以反斜槓結尾，則不添加換行符。

測試用例文檔示例
測試用例	行動	論據	論據
簡單	[文檔]	簡單的文檔
	沒有操做
拆分	[文檔]	這個文檔有點長，	它已被分紅幾列。
	沒有操做
不少線路	[文檔]	在這裏，咱們有
	...	一個自動換行符
	沒有操做
格式化	[文檔]	這是大膽的，_這是斜體和	這裏是一個連接：http://robotframework.org
	沒有操做
變量	[文檔]	由$ {USER}在$ {HOST}處執行
	沒有操做

測試用例具備清晰的描述性名稱是很是重要的，在這種狀況下，一般不須要任何文檔。若是測試用例的邏輯須要記錄，那麼測試用例中的關鍵字一般須要更好的名稱，而且須要加強，而不是添加額外的文檔。最後，元數據（如上面最後一個例子中的環境和用戶信息）一般能夠更好地使用標籤來指定。

2.2.5標記測試用例

在Robot Framework中使用標籤是一種簡單而強大的測試用例分類機制。標籤是自由文本，至少能夠用於如下目的：

標籤顯示在測試報告，日誌中，固然還有測試數據中，因此它們爲測試用例提供元數據。
關於測試用例的統計（總計，經過，失敗是根據標籤自動收集的）。
使用標籤，您能夠包含或排除要執行的測試用例。
使用標籤，您能夠指定哪些測試用例被認爲是關鍵的。

在本節中，僅解釋如何爲測試用例設置標籤，下面列出了不一樣的方法。這些方法天然能夠一塊兒使用。

強制設置表中的標籤: 測試用例文件中的全部測試用例老是使用此設置獲取指定的標記。若是 test suite initialization file在子測試套件中使用，則全部的測試用例都會獲得這些標籤。
設置表中的默認標籤: 沒有本身的[標籤]設置的測試用例獲取這些標籤。從Robot Framework版本2.5開始，測試套件初始化文件再也不支持默認標籤。
測試用例表中的[標籤]: 測試用例老是獲取這些標籤。此外，它不會得到使用默認標籤指定的可能標籤，所以能夠使用空值來覆蓋默認標籤。從Robot Framework 2.5.6開始，也能夠使用值 NONE 來覆蓋默認標籤。
--settag命令行選項: 全部執行的測試用例除了他們在其餘地方得到的標籤外，還得到使用此選項設置
設置標籤，移除標籤，失敗和傳遞執行關鍵字: 這些 BuiltIn關鍵字可用於在測試執行期間動態地操做標籤。

標籤是自由文本，但它們被標準化，以便它們被轉換成小寫字母，而且全部的空格都被刪除。若是測試用例屢次獲取相同的標籤，則除第一個之外的其餘事件將被刪除。假設這些變量存在，能夠使用變量建立標籤。

標記示例
設置	值	值	值
強制標籤	REQ-42
默認標籤	主人約翰	抽菸

變量	值	值	值
$ {HOST}	10.0.1.42

測試用例	行動	論據	論據
沒有本身的標籤	[文檔]	這個測試有標籤	老闆約翰，煙，須要-42
	沒有操做

用本身的標籤	[文檔]	這個測試有標籤	不要，已經全部者的MRR，REQ-42
	[標籤]	業主MRX	沒有準備好
	沒有操做

本身的標籤與變量	[文檔]	這個測試有標籤	host-10.0.1.42，req-42
	[標籤]	主機 - $ {HOST}
	沒有操做

清空本身的標籤	[文檔]	這個測試有標籤	REQ-42
	[標籤]
	沒有操做

設置標籤和刪除標籤關鍵字	[文檔]	這個測試有標籤	mytag，老闆約翰
	設置標籤	mytag
	刪除標籤	抽菸	req- *

2.2.6測試設置和拆卸

Robot Framework與許多其餘測試自動化框架具備類似的測試設置和拆卸功能。簡而言之，測試設置是在測試用例以前執行的，在測試用例以後執行測試拆卸。在Robot Framework中，設置和拆卸只是普通的可能參數的關鍵字。

安裝和拆卸老是一個關鍵字。若是他們須要處理多個單獨的任務，則能夠爲此建立更高級別的用戶關鍵字。另外一種解決方案是使用Robot Framework 2.5中添加的BuiltIn關鍵字運行關鍵字來執行多個關鍵字。

測試拆解在兩個方面是特殊的。首先，它也在測試用例失敗時執行，所以能夠用於清理活動，而無論測試用例的狀態如何。從Robot Framework 2.5開始，即便其中一個失敗，也將執行拆解中的全部關鍵字。這繼續失敗功能也能夠使用正常的關鍵字，但內部拆解它默認狀況下。

在測試用例文件中爲測試用例指定設置或拆卸的最簡單方法是使用設置表中的測試設置和測試拆卸設置。個別測試用例也能夠有本身的設置或拆卸。它們經過測試用例表中的[Setup]或[Teardown]設置進行定義，它們覆蓋可能的測試設置和測試拆解設置。在[Setup]或[Teardown]設置後沒有關鍵字意味着沒有設置或拆卸。從Robot Framework 2.5.6開始，還能夠使用value NONE來指示測試沒有設置/拆卸。

測試設置和拆卸示例
設置	值	值	值
測試設置	打開應用程序	應用程序A
測試拆解	關閉應用程序

測試用例	行動	論據	論據
默認值	[文檔]	安裝和拆卸	從設置表
作一點事

重寫的設置	[文檔]	本身的設置，拆解	從設置表
[創建]	打開應用程序	應用程序B
作一點事

沒有拆卸	[文檔]	默認設置，不	完全拆解
作一點事
[拆除]

沒有拆卸2	[文檔]	使用特殊的NONE，	與2.5.6一塊兒工做
作一點事
[拆除]	沒有

使用變量	[文檔]	安裝和拆卸	做爲變量給出
[創建]	$ {設置}
作一點事
[拆除]	$ {} TEARDOWN

一般當建立相似用例的測試用例時，術語先決條件 和後置條件優於術語設置和拆卸。機器人框架也支持這個術語，因此前提條件是設置和拆卸的後置條件的同義詞。

安裝和拆卸同義詞
測試設置	測試前提條件
測試拆解	測試後置條件
[創建]	[前提]
[拆除]	[後置條件]

要做爲設置或拆卸執行的關鍵字的名稱能夠是變量。這有助於在不一樣的環境中經過將命令行中的關鍵字名稱做爲變量來進行不一樣的設置或拆卸。

注意

測試套件能夠有本身的設置和拆卸。套件設置在該測試套件中的任何測試用例或子測試套件以前執行，相似地，套件拆除將在其後執行。

2.2.7測試模板

測試模板將普通的關鍵字驅動的測試用例轉換爲數據驅動的測試。而關鍵字驅動測試用例的主體是由關鍵字及其可能的參數構成的，而帶有模板的測試用例只包含template關鍵字的參數。不是每一個測試和/或文件中的全部測試屢次重複相同的關鍵字，而是能夠僅在每一個測試中使用它，或者每一個文件只使用一次。

模板關鍵字能夠接受正常的位置參數和命名參數，也能夠接受嵌入到關鍵字名稱的參數。與其餘設置不一樣，使用變量定義模板是不可能的。

基本用法

如下示例測試用例說明了如何將可接受正常位置參數的關鍵字用做模板。這兩個測試在功能上徹底相同。

*** 測試用例 **正常的測試用例    關鍵字第一個參數的第二個參數        模板化測試用例    [ Template ]     示例關鍵字    第一個參數第二個參數

如示例所示，能夠使用[模板] 設置爲單個測試用例指定模板。另外一種方法是使用「設置」表中的「測試模板」設置，在這種狀況下，模板將應用於該測試用例文件中的全部測試用例。的[模板] 設置覆蓋可能模板在設定表中設定，併爲一個空值[模板]表示試驗沒有模板即便當測試模板被使用。從Robot Framework 2.5.6開始，也能夠使用value NONE來指示一個測試沒有模板。

若是模板化的測試用例在其正文中有多個數據行，則將逐個應用全部行的模板。這意味着屢次執行相同的關鍵字，每行一次的數據。模板化測試也是很是特殊的，即便其中一個或多個失敗，也執行全部的測試。也能夠使用這種繼續正常測試的失敗模式，而用模板測試模式自動開啓。

***設置***測試模板示例關鍵字    *** 測試用例 ***模板化測試用例    首輪第一輪第一輪2         第二輪1 輪第二輪2        第三輪1 輪第三輪2

使用默認值或可變參數的參數，以及使用命名參數和免費的關鍵字參數，使用模板徹底同樣，不然工做。在參數中使用變量也是正常的。

嵌入參數的模板

從Robot Framework 2.8.2開始，模板支持嵌入式參數語法的變體。使用模板時，此語法的工做原理是，若是template關鍵字的名稱中包含變量，則它們被視爲參數的佔位符，並替換爲與模板一塊兒使用的實際參數。而後使用生成的關鍵字，而不使用位置參數。舉一個例子來講明：

*** 測試用例 ***具備嵌入參數的正常測試用例    1 + 1的結果應該是2    1 + 2的結果應該是3嵌入參數的模板    [ Template ]     $ { calculation } 的結果應該是$ { expected } 1 + 1 2            1 + 2 3    ***關鍵詞***$ { calculation } 的結果應該是$ { expected }     $ { result } =     Calculate     $ { calculation } 應該相等    $ { result } $ { expected }

嵌入式參數與模板一塊兒使用時，模板關鍵字名稱中的參數數量必須與使用的參數數量相匹配。參數名稱不須要匹配原始關鍵字的參數，但也能夠使用不一樣的參數：

*** 測試用例 ***不一樣的參數名稱    [ Template ]     $ { foo } 的結果應該是$ { bar } 1 + 1 2            1 + 2 3    只有一些論據    [ 模板]     $ { calculation } 的結果應該是3    1 + 2    4  -  1新的論點    [ 模板]     的$ { 意思} 的$ { 生命} 應該是42    結果21 * 2

嵌入參數與模板一塊兒使用的主要好處是參數名稱是明確指定的。使用普通參數時，經過命名包含參數的列能夠達到一樣的效果。這由下一節中的數據驅動樣式示例來講明。

帶有for循環的模板

若是模板與for循環一塊兒使用，則模板將應用於循環內的全部步驟。在這種狀況下，繼續失敗模式也被使用，這意味着，即便在失敗的狀況下，全部的步驟也是以全部的循環元素執行的。

在for循環中使用測試模板
測試用例	行動	論據	論據
模板和	[模板]	示例關鍵字
：對於	$ {}項	在	@ {} ITEMS
	$ {}項	第二個arg
：對於	$ {}指數	在範圍內	42
	第一arg	$ {}指數

2.2.8不一樣的測試用例樣式

測試用例能夠有幾種不一樣的寫法。描述某種工做流的測試用例能夠用關鍵字驅動或行爲驅動的風格來編寫。數據驅動風格可用於測試具備不一樣輸入數據的相同工做流程。

關鍵字驅動的風格

工做流程測試（如前面描述的有效登陸測試）是由幾個關鍵字及其可能的參數構成的。他們的正常結構是，首先系統進入初始狀態（在有效登陸示例中打開登陸頁面），而後對系統進行一些操做（輸入名稱，輸入密碼，提交證書），最後驗證系統表現如預期（歡迎頁面應該打開）。

數據驅動的風格

編寫測試用例的另外一種風格是數據驅動的方法，其中測試用例只使用一個更高級別的關鍵字，一般建立爲用戶關鍵字，隱藏實際的測試工做流程。當須要使用不一樣的輸入和/或輸出數據測試相同的場景時，這些測試很是有用。每次測試均可以重複相同的關鍵字，但測試模板功能容許指定關鍵字只使用一次。

數據驅動的測試例子
設置	值	值	值
測試模板	用無效憑證登陸應該失敗

測試用例	用戶名	密碼
無效的用戶名	無效	$ {VALID PASSWORD}
無效的密碼	$ {有效的用戶}	無效
無效的用戶名和密碼	無效	隨你
空的用戶名	$ {EMPTY}	$ {VALID PASSWORD}
空密碼	$ {有效的用戶}	$ {EMPTY}
空的用戶名和密碼	$ {EMPTY}	$ {EMPTY}

上面的例子有六個單獨的測試，每個對於每一個無效的用戶/密碼組合，下面的例子說明了如何只有一個測試與全部的組合。當使用測試模板時，即便出現故障，也會執行測試中的全部回合，因此這兩種樣式之間沒有實際的功能差別。在上面的例子中，單獨的組合被命名，因此更容易看到他們測試什麼，可是可能大量的這些測試可能會弄亂統計數據。使用哪一種風格取決於上下文和我的喜愛。

數據驅動的測試與多個數據的變化
測試用例	用戶名	密碼
無效的密碼	[模板]	用無效憑證登陸應該失敗
	無效	$ {VALID PASSWORD}
	$ {有效的用戶}	無效
	無效	隨你
	$ {EMPTY}	$ {VALID PASSWORD}
	$ {有效的用戶}	$ {EMPTY}
	$ {EMPTY}	$ {EMPTY}

小費

在上面的兩個例子中，列標題已被更改成與數據匹配。這是可能的，由於在第一行，除了第一個單元以外的其餘單元被忽略。

行爲驅動的風格

也能夠編寫測試用例做爲非技術項目利益相關者必須理解的需求。這些可執行要求是一般稱爲驗收測試驅動開發（ATDD）或示例說明的過程的基石。

編寫這些需求/測試的一種方式是由行爲驅動開發（BDD）推廣的Given-When-Then風格。當以這種風格編寫測試用例時，初始狀態一般用一個以Given開始的關鍵字來表示，這些動做被描述爲關鍵字以 When開頭，關鍵字以Then開頭的指望。若是某個步驟有多個操做，則能夠使用以And開頭的關鍵字。

使用行爲驅動樣式的示例測試用例
測試用例	步
有效登陸	鑑於登陸頁面已打開
當有效的用戶名和密碼被插入時
並提交證書
那麼歡迎頁面應該打開

忽略Given / When / Then /和前綴

前綴考慮，當，而後和而被當匹配關鍵字進行搜索，若是沒有與之相匹配的全名被發現丟棄。這適用於用戶關鍵字和庫關鍵字。例如，在上面的例子中，給定的登陸頁面是打開的，能夠使用或不使用單詞Given來實現爲用戶關鍵字。忽略前綴還容許使用具備不一樣前綴的相同關鍵字。例如歡迎頁面應該打開也能夠用做和歡迎頁面應該打開。

將數據嵌入關鍵字

在編寫具體示例時，將實際數據傳遞給關鍵字實現是有用的。用戶關鍵字經過容許將參數嵌入關鍵字名稱來支持這一點。

2.3建立測試套件

Robot Framework測試用例是在測試用例文件中建立的，能夠將其組織到目錄中。這些文件和目錄建立一個分層測試套件結構。

2.3.1測試用例文件

Robot Framework測試用例是使用測試用例文件中的測試用例表建立的。這樣的文件自動從它包含的全部測試用例中建立一個測試套件。有多少測試用例沒有上限，但建議少於十個，除非使用數據驅動的方法，一個測試用例只包含一個高級關鍵字。

設置表中的如下設置可用於自定義測試套件：

文檔: 用於指定測試套件文檔
元數據: 用於將免費測試套件元數據設置爲名稱 - 值對。
套房設置，套房拆解: 指定套件設置和拆卸。還分別具備同義詞 Suite Precondition和Suite Postcondition。

注意

全部設置名稱能夠任選地包括在所述端部的結腸，例如文檔：。這能夠使讀取設置更容易，特別是在使用純文本格式時。這是Robot Framework 2.5.5中的一個新功能。

2.3.2測試套件目錄

測試用例文件能夠組織到目錄中，這些目錄建立更高級別的測試套件。從目錄建立的測試套件不能直接提供任何測試用例，可是它包含其餘測試用例，而不是測試用例。這些目錄而後能夠被放置到其餘目錄建立一個更高層次的套件。結構沒有限制，因此能夠根據須要組織測試用例。

當執行一個測試目錄時，它所包含的文件和目錄將按照以下遞歸的方式處理：

名稱以點（。）或下劃線（_）開頭的文件和目錄將被忽略。
名稱爲CVS的目錄被忽略（區分大小寫）。
沒有識別擴展名（.html， .xhtml，.htm，.tsv，.txt，.rst或.rest）的文件被忽略（不區分大小寫）。
其餘文件和目錄被處理。

若是處理的文件或目錄不包含任何測試用例，則將其忽略（將消息寫入syslog），並繼續處理。

警告無效的文件

一般狀況下，沒有有效的測試用例表的文件會被寫入syslog的消息忽略。從Robot Framework 2.5.5開始，能夠使用命令行選項--warnonskippedfiles，將消息轉變爲測試執行錯誤中顯示的警告。

初始化文件

從目錄建立的測試套件能夠具備與從測試用例文件建立的套件相似的設置。由於單獨的一個目錄不能有這樣的信息，因此它必須放在一個特殊的測試套件初始化文件中。初始化文件與測試用例文件具備相同的結構和語法，只是它們不能包含測試用例表，而且不支持全部的設置。

初始化文件名必須始終爲格式__init __。ext，其中擴展名必須匹配其中一種受支持的文件格式（例如， __init __。html或__init __。txt）。名稱格式是從Python借用的，以這種方式命名的文件表示目錄是一個模塊。

初始化文件的主要用法是指定與測試用例文件相似的測試套件相關設置，但也能夠設置一些測試用例相關的設置。初始化文件中建立或導入的變量和關鍵字在較低級別的測試套件中不可用，可是若是須要共享資源文件，則能夠使用資源文件。

如何在初始化文件中使用不一樣的設置：

文檔，元數據，套件設置，套件拆解: 這些測試套件的具體設置與測試用例文件中的相同。
強制標籤: 指定的標籤無條件地設置爲該目錄直接或遞歸包含的全部測試用例文件中的全部測試用例。
測試設置，測試拆解，測試超時: 將測試設置/拆卸的默認值或測試超時設置爲此目錄包含的全部測試用例。能夠在較低級別上被覆蓋。在Robot Framework 2.7中添加了在初始化文件中定義測試超時的支持。
默認標籤，測試模板: 在初始化文件中不受支持。

示例測試套件初始化文件
設置	值	值
文檔	示例套件
套件設置	作一點事	$ {文}
強制標籤	例
圖書館	SomeLibrary

變量	值	值
$ {文}	你好，世界！

關鍵詞	行動	論據
作一點事	[參數]	$ {} ARG
一些關鍵字	$ {} ARG
另外一個關鍵字

2.3.3測試套件名稱和文檔

測試套件名稱由文件或目錄名稱構成。名稱被建立以便擴展被忽略，可能的下劃線被空格替換，而且名字徹底以小寫字母爲標題。例如，some_tests.html變成了一些測試，而 My_test_directory變成了個人測試目錄。

注意

Robot Framework 2.5中建立測試套件名稱的規則稍有變化。

文件或目錄名稱能夠包含一個前綴來控制套件的執行順序。前綴與基本名稱分開兩個下劃線，在構造實際測試套件名稱時，前綴和下劃線都將被刪除。例如文件 01__some_tests.txt和02__more_tests.txt建立測試套件的一些測試和更多的測試，分別與前者在後者以前執行。

測試套件的文檔使用「設置」表中的「文檔」設置進行設置。它能夠在測試用例文件中使用，或者在更高級別的套件中用在測試套件初始化文件中。測試套件文檔具備與顯示位置徹底相同的特徵以及如何將其做爲測試用例文檔建立。

測試套件文檔示例
設置	值	值	值
文檔	一個示例測試套件	文檔與	一些 _formatting_。
...	見測試文檔	獲取更多文檔	例子。

測試執行中能夠覆蓋頂級測試套件的名稱和文檔。這能夠分別使用命令行選項--name和 - doc來完成，如設置元數據一節中所述。

2.3.4免費測試套件元數據

測試套件也能夠具備除文檔以外的其餘元數據。此元數據是使用「元數據」設置在「設置」表中定義的。以這種方式設置的元數據顯示在測試報告和日誌中。

對元數據的名稱和值位於下面的列元數據。該值的處理方式與文檔類似，也就是說能夠將其分割爲多個單元格（用空格鏈接）或多行（用換行符鏈接在一塊兒），能夠使用簡單的HTML格式化工做，甚至能夠使用變量。

元數據示例
設置	值	值	值	值
元數據	版	2.0
元數據	更多信息	瞭解更多信息	關於* Robot Framework *	請參閱http://robotframework.org
元數據	執行在	$ {HOST}

對於頂級測試套件，也能夠使用--metadata命令行選項設置元數據。這將在「設置元數據」一節中更詳細地討論。

在Robot Framework 2.5以前，免費的元數據是用Meta：<name>這樣的語法指定的，其中<name>是元數據名稱，而且在後續的列中定義了該值。Robot Framework 2.5仍然支持這種舊格式，但未來會被棄用。

2.3.5套件安裝和拆卸

不只測試用例並且測試套件均可以進行設置和拆卸。套件安裝程序在運行套件的任何測試用例或子測試套件以前執行，並在其後執行測試拆卸。全部的測試套件均可以進行設置和拆卸; 從目錄建立的套件必須在測試套件初始化文件中指定。

與測試用例相似，套件設置和拆卸是可能須要參數的關鍵字。它們分別在套件設置和套件拆卸設置的設置表中定義。他們也有相似的同義詞，套件先決條件和套件後置條件，做爲測試案例的設置和拆解。關鍵字名稱和可能的參數位於設置名稱後面的列中。

若是套件設置失敗，則其中的全部測試用例及其子測試套件將當即分配爲失敗狀態，而且不會實際執行。這使得套件設置很是適合檢查在運行測試用例以前必須知足的前提條件。

全部測試用例執行完畢後，一般會使用套件拆卸進行清理。即便同一套件的設置失敗，也會執行該操做。若是套件拆卸失敗，套件中的全部測試用例都被標記爲失敗，不管其原始執行狀態如何。從Robot Framework 2.5開始，全部在teardowns中的關鍵字都會被執行，即便其中一個失敗。

要做爲設置或拆卸執行的關鍵字的名稱能夠是變量。這有助於在不一樣的環境中經過將命令行中的關鍵字名稱做爲變量來進行不一樣的設置或拆卸。

2.4使用測試庫

測試庫包含最低級別的關鍵字，一般稱爲 庫關鍵字，它們實際上與被測系統進行交互。全部的測試用例老是使用某些庫中的關鍵字，一般是經過更高級別的用戶關鍵字。本節介紹如何使用測試庫以及如何使用它們提供的關鍵字。建立測試庫將在一個單獨的章節中介紹。

2.4.1使用測試庫

使用測試庫的說明在下面的小節中給出。

使用庫設置

測試庫一般使用「設置」表中的「庫」設置導入，並在後續列中具備庫名稱。庫名稱區分大小寫（它是實現庫的模塊或類的名稱，必須徹底正確），但其中的任何空格都將被忽略。使用包中的模塊或Java庫中的Python庫時，必須使用包括模塊或包名稱的全名。

在庫須要參數的狀況下，它們在庫名後面的列中列出。能夠在測試庫導入中使用默認值，可變數量的參數和命名參數，與使用關鍵字的參數相似。庫名稱和參數均可以使用變量進行設置。

導入測試庫
設置	值	值	值
圖書館	操做系統
圖書館	com.company.TestLib
圖書館	個人圖書館	ARG1	ARG2
圖書館	$ {}庫

能夠在測試用例文件，資源文件和測試套件初始化文件中導入測試庫。在全部這些狀況下，導入庫中的全部關鍵字均可以在該文件中使用。對於資源文件，這些關鍵字也能夠在其餘使用它們的文件中使用。

使用導入庫關鍵字

採起測試庫投入使用另外一種可能性是使用關鍵字導入庫從內建庫。該關鍵字與庫設置相似，使用庫名稱和可能的參數。導入庫中的關鍵字在使用Import Library關鍵字的測試套件中可用。這種方法在測試執行開始時庫不可用的狀況下很是有用，只有其餘一些關鍵字可用。

使用導入庫關鍵字
測試用例	行動	論據	論據
例	作一點事
導入庫	個人圖書館	ARG1	ARG2
KW從Mylibrary

庫搜索路徑

指定要導入的測試庫最經常使用的方法是使用其名稱，就像本節全部示例中所作的那樣。在這些狀況下，Robot Framework會嘗試從庫搜索路徑中查找實現庫的類或模塊。基本上，這意味着庫代碼及其全部可能的依賴關係必須在PYTHONPATH中，或者在Jython上運行測試時在 CLASSPATH中。設置庫搜索路徑在其本身的一節中進行解釋。庫也能夠自動設置搜索路徑，或者有特別的說明。例如，全部標準庫都自動在庫搜索路徑中。

這種方法的最大好處是，當庫搜索路徑被配置時，一般使用自定義的啓動腳本，普通用戶不須要考慮庫的實際安裝位置。缺點是將本身的，可能很是簡單的庫放到搜索路徑中可能須要一些額外的配置。

使用物理路徑來圖書館

指定要導入的庫的另外一種機制是在文件系統中使用它的路徑。該路徑被認爲是相對於當前測試數據文件所在的目錄類似於到資源和變量文件的路徑。這種方法的主要優勢是不須要配置庫搜索路徑。

若是庫是一個文件，它的路徑必須包含擴展名。對於Python庫，擴展名天然是.py，對於Java庫，擴展名能夠是.class或.java，但類文件必須始終可用。若是Python庫被實現爲目錄，則其路徑必須有一個尾隨正斜槓（/）。如下示例演示了這些不一樣的用法。

使用物理路徑導入測試庫
設置	值	值	值
圖書館	PythonLib.py
圖書館	/absolute/path/JavaLib.java
圖書館	相對/路徑/ PythonDirLib /	可能	參數
圖書館	$ {}資源/Example.class

這種方法的侷限性在於，做爲Python類實現的庫必須位於與類相同名稱的模塊中。此外，使用此機制導入以JAR或ZIP包分發的庫是不可能的。

2.4.2設置自定義名稱爲測試庫

庫名稱顯示在關鍵字名稱以前的測試日誌中，若是多個關鍵字具備相同的名稱，則必須使用它們以使關鍵字名稱以庫名稱做爲前綴。庫名一般是從實現它的模塊或類名獲得的，可是在某些狀況下，更改它是可取的：

須要用不一樣的參數屢次導入同一個庫。不然這是不可能的。
圖書館的名字很不方便。例如，若是Java庫具備很長的包名稱，就可能發生這種狀況。
您但願使用變量在不一樣的環境中導入不一樣的庫，但使用相同的名稱引用它們。
圖書館名稱有誤導性或其餘差。在這種狀況下，更改實際名稱固然是更好的解決方案。

用於指定新名稱的基本語法是WITH NAME在庫名後面加上文本（不區分大小寫），而後在下一個單元格中輸入新名稱。指定的名稱顯示在日誌中，使用關鍵字的全名（LibraryName.Keyword名稱）時，必須在測試數據中使用。

用自定義名稱導入庫
設置	值	值	值
圖書館	com.company.TestLib	與姓名	TESTLIB
圖書館	$ {}庫	與姓名	個人名字

庫的可能參數被放置在原始庫名稱和WITH NAME文本之間的單元格中。如下示例說明了如何使用不一樣的參數屢次導入同一個庫：

用不一樣的名稱導入相同的庫幾回
設置	值	值	值	值	值
圖書館	SomeLibrary	本地主機	1234	與姓名	LocalLib
圖書館	SomeLibrary	server.domain	8080	與姓名	RemoteLib

測試用例	行動	論據	論據
個人測試	LocalLib.Some關鍵字	一些arg	第二個arg
RemoteLib.Some關鍵字	另外一個arg	隨你
LocalLib.Another關鍵字

將自定義名稱設置爲測試庫時，在導入「設置」表中的庫時以及使用「導入庫」關鍵字時都會起做用。

2.4.3標準庫

一些測試庫是經過Robot Framework分發的，這些庫被稱爲標準庫。該內建庫是特殊的，由於它會自動投入使用，所以它的關鍵字老是可用的。其餘標準庫須要以與其餘庫相同的方式導入，可是不須要安裝它們。

正常的標準庫

下面列出了可用的常規標準庫，並連接到他們的文檔：

內建

集合

約會時間

對話框

操做系統

處理

截圖

串

遠程登陸

XML

遠程庫

除上面列出的常規標準庫外，還有與其餘標準庫徹底不一樣的遠程庫。它沒有任何本身的關鍵字，但它做爲Robot Framework和實際測試庫實現之間的代理。這些庫能夠在覈心框架之外的其餘機器上運行，甚至能夠使用Robot Framework自己不支持的語言來實現。

有關此概念的更多信息，請參閱單獨的遠程庫接口部分。

2.4.4外部庫

根據定義，任何不是標準庫之一的測試庫都是外部庫。Robot Framework開源社區已經實現了幾個通用庫，好比Selenium2Library和SwingLibrary，這些庫並沒有與核心框架一塊兒打包。能夠從http://robotframework.org找到公開可用的庫列表。

通用和自定義庫顯然也能夠由使用Robot Framework的團隊來實現。有關該主題的更多信息，請參閱建立測試庫部分。

不一樣的外部庫能夠有徹底不一樣的機制來安裝並使用它們。有時他們可能還須要另外安裝一些依賴項。全部庫應該有清楚的安裝和使用文檔，他們應該最好自動化安裝過程。

2.5變量

2.5.1簡介

變量是Robot Framework的一個完整功能，能夠在測試數據的大部分地方使用。一般，它們用於測試用例表和關鍵字表中關鍵字的參數，並且全部設置都容許其值中的變量。一個正常的關鍵字名稱不能用變量指定，可是能夠使用BuiltIn關鍵字 Run關鍵字來得到相同的效果。

Robot Framework自己有兩種變量，標量和列表，它們分別具備語法${SCALAR}和語法@{LIST}。除此以外，環境變量能夠直接與語法結合使用%{VARIABLE}。

在如下狀況下建議使用變量：

當字符串在測試數據中常常變化時。使用變量只須要在一個地方進行這些更改。
建立獨立於系統和獨立於操做系統的測試數據時。使用變量而不是硬編碼的字符串能夠大大簡化（例如，${RESOURCES}而不是 c:\resources或${HOST}不是 10.0.0.1:8080）。由於變量能夠在開始測試時從命令行設置，因此更改系統特定變量很容易（例如--variable HOST:10.0.0.2:1234 --variable RESOURCES:/opt/resources）。這也有利於本地化測試，這一般涉及使用不一樣的字符串運行相同的測試。
當須要將字符串之外的對象做爲關鍵字的參數時。
當不一樣的關鍵字，即便在不一樣的測試庫中，也須要進行通訊。您能夠將一個關鍵字的返回值分配給一個變量，並將其做爲參數分配給另外一個變量。
當測試數據中的值長或其餘複雜時。好比，${URL}比...更短 http://long.domain.name:8080/path/to/service?foo=1&bar=2&zap=42。

若是在測試數據中使用不存在的變量，則使用它的關鍵字將失敗。若是用於變量相同的語法須要爲文字字符串，則必須用反斜槓轉義爲\${NAME}。

2.5.2變量類型

本節簡要介紹了不一樣的變量類型。變量的建立和使用在下面的小節中有更詳細的描述。

Robot Framework變量與關鍵字相似，不區分大小寫，空格和下劃線也被忽略。可是，建議將全部大寫字母與全局變量（例如${PATH}或${TWO_WORDS}）和小寫字母一塊兒使用，這些變量只在某些測試用例或用戶關鍵字（例如${my_var}或 ${myVar}）中可用。更重要的是，案件應該一向使用。

與使用相似變量語法的某些編程語言不一樣，在Robot Framework測試數據中，花括號（{和}）是強制性的。基本上，變量名能夠在花括號之間有任何字符。可是，建議僅使用從a到z的字母字符，數字，下劃線和空格，甚至須要使用擴展變量語法。

標量變量

在測試數據中使用標量變量時，它們將被分配的值替換。雖然標量變量最經常使用於簡單字符串，但您能夠將任何對象（包括列表）分配給它們。例如${NAME}，標量變量語法對於大多數用戶應該是熟悉的，由於它也被用在例如shell腳本和Perl編程語言中。

下面的例子說明了標量變量的用法。假設變量${GREET}和${NAME}提供與分配給串Hello並world分別，同時例如測試用例是等價的。

具備字符串值的標量變量
測試用例	行動	論據
字符串	日誌	你好
日誌	你好，世界！！
變量	日誌	$ {} GREET
日誌	$ {GREET}，$ {NAME} !!

當一個標量變量被用做測試數據單元中惟一的值時，標量變量將被替換爲它所具備的值。該值能夠是任何對象。當一個標量變量與其餘東西（常量字符串或其餘變量）一塊兒被用在一個測試數據單元格中時，它的值首先被轉換成一個Unicode字符串，而後被連接到該單元格中的任何東西。將值轉換爲字符串意味着對象的方法__unicode__（在Python中，__str__做爲後備）或toString（在Java中）被調用。

注意

當使用命名參數語法將參數傳遞給關鍵字時，變量值按原樣使用argname=${var}。

下面的示例演示了在單獨的單元格中仍是與其餘內容中的變量之間的區別。首先，讓咱們假設咱們有一個變量${STR}設置爲一個字符串，Hello, world!並${OBJ}設置爲如下Java對象的一個實例：

公共 類 MyObj  {    public  String  toString （） {         return  「嗨，tellus！」 ;     } }

經過設置這兩個變量，咱們能夠獲得如下測試數據：

以對象做爲值的標量變量
測試用例	行動	論據
對象	KW 1	$ {} STR
KW 2	$ {} OBJ
KW 3	我說「$ {STR}」
KW 4	你說「$ {OBJ}」

最後，當這個測試數據被執行時，不一樣的關鍵字接收參數以下：

KW 1得到一個字符串Hello, world!
KW 2將一個對象存儲到變量中${OBJ}
KW 3得到一個字符串I said "Hello, world!"
KW 4得到一個字符串You said "Hi, tellus!"

注意

若是變量不能表示爲Unicode，則將變量轉換爲Unicode顯然會失敗。例如，若是您嘗試將字節序列用做關鍵字的參數，則可能發生這種狀況，以便將值連接在一塊兒${byte1}${byte2}。解決方法是建立一個包含整個值的變量，並在單元格中單獨使用它（例如${bytes}），由於該值原樣使用。

列出變量

列表變量是複合變量，能夠有幾個值分配給他們。總之，他們老是列表，能夠包含無限數量的條目（也能夠是空列表）。列表變量的主要好處是，它們容許您爲更大的數據集分配一個名稱。雖然列表變量一般只包含字符串，但其餘內容也是可能的。

在測試數據中使用列表變量時，列表中的元素將做爲新的單元插入到測試數據中。所以，若是列表變量包含兩個元素，則包含列表變量的單元格將變成具備列表變量內容的兩個單元格。請注意，具備列表變量的單元格不該包含其餘內容。列表變量語法@{NAME}是從Perl借用的。

假設列表變量@{USER}設置爲該值 ['robot','secret']，如下兩個測試用例是等效的。

使用列表變量
測試用例	行動	用戶名	密碼
字符串	登陸	機器人	祕密
列表變量	登陸	@{用戶}

訪問單個列表變量項目

也能夠使用語法從列表變量中訪問某個值@{NAME}[i]，其中，i是所選值的索引。索引從零開始，嘗試訪問索引過大的值會致使錯誤。以這種方式訪問的列表項能夠相似地用做標量變量：

訪問列表變量項目
測試用例	行動	論據	論據
字符串	登陸	機器人	祕密
標題應該是	歡迎機器人！
列表變量	登陸	@{用戶}
標題應該是	歡迎@ {USER} [0]！

使用列表變量的設置

列表變量只能用於某些設置。它們能夠用於導入庫和變量文件的參數，可是庫和變量文件名自己不能是列表變量。另外帶有setups和teardowns的列表變量不能做爲關鍵字的名字，可是能夠用在參數中。與標籤相關的設置，他們能夠自由使用。在不支持列表變量的地方使用標量變量是可能的。

使用列表變量的設置
設置	值	值	評論
圖書館	ExampleLibrary	@ {LIB ARGS}	＃這工做
圖書館	$ {}庫	@ {LIB ARGS}	＃這工做
圖書館	@ {姓名和家庭}		＃這不起做用
套件設置	一些關鍵字	@ {KW ARGS}	＃這工做
套件設置	爲$ {keyword}	@ {KW ARGS}	＃這工做
套件設置	@{關鍵詞}		＃這不起做用
默認標籤	@ {}標籤		＃這工做

使用列表變量做爲標量

能夠使用列表變量做爲包含列表的標量變量，只需替換@爲$。這使得能夠使用列表變量與列表相關的關鍵字，例如從BuiltIn和Collections庫。

使用列表變量做爲標量
測試用例	行動	論據	論據	論據
例	@ {list} =	建立列表	第一	第二
長度應該是	$ {}名單	2
附加到列表	$ {}名單	第三
長度應該是	$ {}名單	3
從列表中刪除	$ {}名單	1
長度應該是	$ {}名單	2
記錄許多	@ {}名單

請注意，列表變量值的可能更改不限於當前變量做用域。因爲沒有建立新變量，而是改變現有變量的狀態，全部查看該變量的測試和關鍵字也會看到更改。若是這是一個問題，則能夠使用Collections庫中的Copy List關鍵字來建立變量的本地副本。

使用列表變量做爲標量只有在沒有與列表變量具備相同基本名稱的標量變量時才起做用。在這些狀況下，標量變量有優先權，而是使用其值。

使用標量變量做爲列表

從Robot Framework 2.8開始，也能夠使用標量變量做爲列表變量。若是一個標量變量包含任何列表相似的對象，就能夠經過更換被用做列表變量$與@。例如，對於for循環以及標量列表中的項目須要用做關鍵字的單獨參數時，這是很是有用的。

使用標量變量做爲列表
測試用例	行動	論據	論據	論據
例	$ {list} =	建立列表	第一	第二
記錄許多	@ {}名單
$ {string} =	鏈狀	@ {}名單
應該是平等的	$ {}字符串	第一秒
：對於	$ {}項	在	@ {}名單
	日誌	$ {}項

若是標量變量包含任何非列表對象，例如字符串或整數，則將其用做列表變量將失敗。徹底像使用列表變量做爲標量同樣，使用標量變量做爲列表僅在沒有具備相同基本名稱的列表變量時才起做用。

環境變量

Robot Framework容許使用語法在測試數據中使用環境變量%{ENV_VAR_NAME}。它們僅限於字符串值。

在執行測試以前在操做系統中設置的環境變量是可用的，能夠使用關鍵字Set Environment Variable建立新的環境變量，或者使用關鍵字Delete Environment Variable刪除現有的環境變量，二者均可以在 OperatingSystem庫中找到。由於環境變量是全局的，因此在一個測試用例中設置的環境變量能夠用在其餘的測試用例以後。可是，對環境變量的更改在測試執行後無效。

使用環境變量
測試用例	行動	論據	論據
環境變量	日誌	當前用戶：％{USER}
跑	％{JAVA_HOME} $ {/} javac的

Java系統屬性

使用Jython運行測試時，能夠使用與環境變量相同的語法來訪問Java系統屬性。若是存在同名的環境變量和系統屬性，則使用環境變量。在Robot Framework 2.6中添加了對訪問Java系統屬性的支持。

使用Java系統屬性
測試用例	行動	論據	論據
系統屬性	日誌	％{user.name}在％{os.name}上運行測試

2.5.3建立變量

變量能夠從如下小節中描述的不一樣來源中產生。

變量表

變量最多見的來源是測試用例文件和資源文件中的變量表。變量表很方便，由於它們容許在與測試數據的其他部分相同的位置建立變量，而且所需的語法很是簡單。它們的主要缺點是值始終是字符串，不能動態建立。若是其中任何一個出現問題，則能夠使用變量文件。

建立標量變量

最簡單的變量賦值就是將一個字符串設置爲一個標量變量。這是經過給${}變量表的第一列中的變量名（包括）和第二個中的值來完成的。若是第二列爲空，則將空字符串設置爲值。也能夠在值中使用已經定義的變量。

建立標量變量
變量	值	值
$ {NAME}	機器人框架
$ {VERSION}	2.0
$ {機器人}	$ {NAME} $ {VERSION}

=在變量名以後使用等號也能夠，但不是強制性的，使變量的分配略微更明確。

使用等號建立標量變量
變量	值	值
$ {NAME} =	機器人框架
$ {VERSION} =	2.0

建立列表變量

建立列表變量與建立標量變量同樣簡單。一樣，變量名稱位於變量表格的第一列，以及後續列中的值。一個列表變量能夠有任意數量的值，從零開始，若是須要不少值，它們能夠分紅幾行。

建立列表變量
變量	值	值	值
@ {NAMES}	馬蒂	鐵炮
@ {} NAMES2	@ {NAMES}	雪峯
@{沒有}
@{許多}	一	二	三
...	四	五	六
...	七

變量文件

變量文件是建立不一樣類型的變量的最強大的機制。能夠將變量分配給使用它們的任何對象，而且還能夠動態地建立變量。變量文件的語法和變量文件的使用在資源和變量文件部分進行了解釋。

在命令行中設置變量

變量能夠在命令行中單獨使用--variable（-v）選項設置，或者使用帶有--variablefile（-V）選項的變量文件來設置。從命令行設置的變量全局可用於全部已執行的測試數據文件，還能夠覆蓋變量表中相同名稱和測試數據中導入的變量文件中的可能變量。

設置單個變量的語法是--variable name：value，其中name是沒有${}和的變量的名稱 value。經過屢次使用此選項能夠設置多個變量。只有標量變量能夠使用這個語法來設置，而且只能獲得字符串值。許多特殊字符很難在命令行中表示，但能夠使用--escape 選項來轉義。

 - 變化例：價值- 變量HOST：localhost：7272  - 變量USER：機器人- 變量ESCAPED：Qquotes_and_spacesQ --escape quot：Q  - 轉義空間：_

在上面的例子中，變量是這樣設置的

${EXAMPLE} 得到價值 value
${HOST}並${USER}得到值 localhost:7272和robot
${ESCAPED} 得到價值 "quotes and spaces"

從命令行使用變量文件的基本語法是--variablefile path / to / variables.py，並將變量文件變爲use部分有更多的細節。實際建立的變量取決於引用變量文件中的變量。

若是從命令行給出變量文件和單個變量，則後者具備更高的優先級。

從關鍵字返回值

關鍵字的返回值也能夠設置爲變量。這樣即便在不一樣的測試庫中也能夠實現不一樣關鍵字下面的例子說明了一個簡單案例的語法：

將關鍵字的值分配給變量
測試用例	行動	論據	論據
返回	$ {x} =	獲得X	一個論點
日誌	咱們獲得$ {x}！
設置變量	$ {var} =	設置變量	例
應該是平等的	$ {VAR}	例

在上面的第一個例子中，Get X關鍵字返回的值首先被設置到變量中${x}，而後被Log 關鍵字使用。這個語法適用於全部關鍵字返回的狀況，變量被設置爲關鍵字返回的值。在=變量名以後加上等號不是強制性的，而是推薦的，由於它使得賦值更加明確。

上面的第二個例子展現瞭如何使用BuiltIn Set Variable關鍵字來設置預約義的測試用例做用域變量。一樣的方法顯然也適用於用戶關鍵字範圍中的變量。若是全部測試共享相同的預約義變量，則建議使用變量表。

若是一個關鍵字返回一個列表，或者任何相似列表的對象，也能夠將返回值分配給幾個標量變量和/或一個列表變量。

一次分配多個值
測試用例	行動	論據	論據
返回倍數	$ {scalar} =	獲得3
$ {A}	$ {B}	$ {c} =	獲得3
$ {}第一	@ {rest} =	獲得3
@ {list} =	獲得3

假設關鍵字Get 3返回一個列表 [1, 2, 3]，將建立如下變量：

${scalar} 與價值 [1, 2, 3]
${a}，${b}而且${c}與值1， 2和3分別
${first}與價值1和@{rest}價值 [2, 3]
@{list} 與價值 [1, 2, 3]

以這種方式設置的變量在其餘方面與其餘變量相似，可是它們僅在建立測試用例或關鍵字的範圍內可用。所以，例如，在一個測試用例中設置一個變量並將其用於另外一個測試用例是不可能的。這是由於通常狀況下，自動化測試用例不該相互依賴，而且意外設置其餘地方使用的變量可能會致使難以調試的錯誤。若是真的須要在一個測試用例中設置一個變量並在另外一個測試用例中使用它，能夠使用下一節中介紹的BuiltIn關鍵字。

使用設置測試/套件/全局變量關鍵字

該內建庫有關鍵字設置測試變量，設置套房變量和設置全局變量可用於測試執行過程當中動態地設置變量。若是新範圍內已經存在一個變量，則其值將被覆蓋，不然將建立一個新變量。

使用Set Test Variable關鍵字設置的變量在當前執行的測試用例範圍內的任何地方都是可用的。例如，若是您在用戶關鍵字中設置變量，則在測試用例級別以及當前測試中使用的全部其餘用戶關鍵字中均可以使用該變量。其餘測試用例不會看到用這個關鍵字設置的變量。

使用Set Suite Variable關鍵字設置的變量在當前執行的測試套件的範圍內隨處可見。所以，使用此關鍵字設置變量與使用測試數據文件中的變量表建立變量或從變量文件中導入變量具備相同的效果。其餘測試套件（包括可能的子測試套件）將不會看到使用此關鍵字設置的變量。

設置變量設置全局變量的關鍵字是在設置這些以後執行的全部測試用例和套件全局可用。所以使用這個關鍵字設置變量與使用選項--variable或 --variablefile 從命令行建立的效果相同。由於這個關鍵字能夠在任何地方改變變量，因此應該當心使用。

注意

將測試/套件/全局變量關鍵字直接設置爲測試，套件或全局變量範圍，而且不返回任何內容。另外一方面，另外一個BuiltIn關鍵字 Set Variable使用返回值設置局部變量。

2.5.4內置變量

Robot Framework提供了一些自動可用的內置變量。

操做系統變量

與操做系統相關的內置變量簡化了測試數據的操做系統不可知性。

可用的操做系統相關的內置變量
變量	說明
$ {} CURDIR	測試數據文件所在目錄的絕對路徑。這個變量是區分大小寫的。
$ {TEMPDIR}	系統臨時目錄的絕對路徑。在類UNIX系統中，這一般是/ tmp，而且在Windows c：\ Documents and Settings \ <user> \ Local Settings \ Temp中。
$ {} EXECDIR	執行測試執行的目錄的絕對路徑。
$ {/}	系統目錄路徑分隔符。`/`在類UNIX系統和\ Windows中。
$ {：}	系統路徑元素分隔符。`:`在類UNIX系統和`;`Windows中。
$ {\ n}	系統行分隔符。\ n在類UNIX系統中和 \ r \ n在Windows中。2.7.5版本中的新功能

使用操做系統相關的內置變量
測試用例	行動	論據	論據
例	建立二進制文件	$ {CURDIR} $ {/} input.data	這裏有兩行$ {\ n}
設置環境變量	CLASSPATH	$ {TEMPDIR} $ {：} $ {CURDIR} $ {/} foo.jar中

數字變量

變量語法可用於建立整數和浮點數，以下例所示。當一個關鍵字但願獲得一個實際的數字，而不是一個看起來像一個數字的字符串時，這是很是有用的。

使用數字變量
測試用例	行動	論據	論據	評論
示例1A	連	example.com	80	＃Connect獲取兩個字符串做爲參數
實例1B	連	example.com	$ {} 80	＃鏈接獲取一個字符串和一個整數
例2	作X	$ {} 3.14	$ { - 1E-4}	＃X得到浮點數3.14和-0.0001

從機器人框架2.6開始，有可能也是從二進制，八進制，和十六進制值使用建立的整數0b，0o 和0x前綴分別。語法不區分大小寫。

與基地使用整數變量
測試用例	行動	論據	論據
例	應該是平等的	$ {} 0b1011	$ {11}
應該是平等的	$ {} 0o10	$ {8}
應該是平等的	$ {}爲0xFF	$ {} 255
應該是平等的	$ {} 0B1010	$ {}的0xA

布爾值和無/空變量

也能夠使用相似於數字的變量語法建立布爾值和Python None和Java null。

使用布爾和無/空變量
測試用例	行動	論據	論據	評論
布爾	設置狀態	$ {TRUE}		＃設置狀態獲取布爾值做爲參數
建立Y	某物	$ {}假	＃建立Y獲取一個字符串，布爾值爲false
沒有	作XYZ	$ {}無		＃XYZ是否將Python做爲參數
空值	$ {ret} =	得到價值	ARG	＃檢查Get Value是否返回Java null
應該是平等的	$ {} RET	$ {}空

這些變量是不區分大小寫的，例如${True}和 ${true}等價的。此外，${None}和 ${null}是同義詞，由於Jython解釋運行測試時，Jython的自動轉換None，並 null以正確的格式在必要的時候。

空間和空變量

能夠分別使用變量${SPACE}和空格來建立空格和空字符串 ${EMPTY}。這些變量是有用的，例如，不然須要使用反斜槓轉義空格或空單元格。若是須要一個以上的空間，有可能使用擴展變量語法等 ${SPACE * 5}。在下面的例子中，應該是等於關鍵字得到相同的參數，但使用變量的那些比使用反斜槓更容易理解。

使用 `${SPACE}`和 `${EMPTY}`變量
測試用例	行動	論據	論據
一個空間	應該是平等的	$ {空白}	\ \ \
四個空間	應該是平等的	$ {SPACE * 4}	\ \ \ \ \
十個空間	應該是平等的	$ {SPACE * 10}	\ \ \ \ \ \ \ \ \ \
引用空間	應該是平等的	「$ {空白}」	「」
引用的空間	應該是平等的	「$ {SPACE * 2}」	「\」
空	應該是平等的	$ {EMPTY}	\

從Robot Framework 2.7.4開始，還有一個空的列表變量 @{EMPTY}。由於它沒有內容，因此在測試數據中的某處使用時基本上會消失。例如，當使用template關鍵字而不帶參數或在不一樣範圍內重寫列表變量時，使用測試模板是頗有用的。修改的價值是不可能的。@{EMPTY}

使用 `@{EMPTY}`變量
測試用例	行動	論據	論據
模板	[模板]	一些關鍵字
@ {} EMPTY

覆蓋	設置全局變量	@ {}清單	@ {} EMPTY

自動變量

一些自動變量也能夠用在測試數據中。這些變量在測試執行過程當中可能有不一樣的值，有些甚至一直不可用。更改這些變量的值不會影響原始值，可是能夠使用BuiltIn庫中的關鍵字動態更改一些值。

可用的自動變量
變量	說明	可獲得
$ {TEST NAME}	當前測試用例的名稱。	測試用例
@ {TEST TAGS}	包含當前測試用例的標籤，按字母順序排列。能夠使用「設置標籤」和「移除標籤」關鍵字來動態修改	測試用例
$ {TEST DOCUMENTATION}	當前測試用例的文檔。能夠使用Set Test Documentation 關鍵字動態設置。Robot Framework 2.7新增功能	測試用例
$ {測試狀態}	當前測試用例的狀態，即PASS或FAIL。	測試拆解
$ {TEST MESSAGE}	當前測試用例的消息。	測試拆解
$ {PREV TEST NAME}	前一個測試用例的名稱，若是還沒有執行任何測試，則返回一個空字符串。	處處
$ {PREV TEST STATUS}	之前的測試用例的狀態：PASS，FAIL，或沒有執行測試時的空字符串。	處處
$ {PREV TEST MESSAGE}	前面的測試用例可能的錯誤信息。	處處
$ {SUITE NAME}	當前測試套件的全名。	處處
$ {SUITE SOURCE}	套件文件或目錄的絕對路徑。Robot Framework 2.5中的新功能	處處
$ {SUITE DOCUMENTATION}	當前測試套件的文檔。能夠使用Set Suite Documentation關鍵字動態設置。Robot Framework 2.7新增功能	處處
$ {SUITE METADATA}	當前測試套件的免費元數據。能夠使用Set Suite Metadata關鍵字進行設置。Robot Framework 2.7.4新增功能	處處
$ {SUITE STATUS}	當前測試套件的狀態，經過或失敗。	套房拆解
$ {SUITE MESSAGE}	當前測試套件的完整信息，包括統計信息。	套房拆解
$ {KEYWORD STATUS}	當前關鍵字的狀態，經過或失敗。Robot Framework 2.7新增功能	用戶關鍵字拆解
$ {KEYWORD MESSAGE}	當前關鍵字可能的錯誤信息。Robot Framework 2.7新增功能	用戶關鍵字拆解
$ {LOG LEVEL}	當前日誌級別。Robot Framework 2.8新增功能	處處
$ {OUTPUT FILE}	輸出文件的絕對路徑。	處處
$ {LOG FILE}	當沒有建立日誌文件時，日誌文件或字符串NONE 的絕對路徑。	處處
$ {REPORT FILE}	報告文件的絕對路徑或未建立報告時的字符串NONE。	處處
$ {DEBUG FILE}	調試文件或字符串NONE 的絕對路徑，當沒有調試文件被建立。	處處
$ {OUTPUT DIR}	輸出目錄的絕對路徑。	處處

套房相關的變量${SUITE SOURCE}，${SUITE NAME}， ${SUITE DOCUMENTATION}和${SUITE METADATA}可已經在測試庫和可變文件導入，除了機器人框架2.8和2.8.1，其中該支持被打破。儘管這些自動變量中的可能變量在導入時還沒有解決。

2.5.5變量優先級和範圍

來自不一樣來源的變量具備不一樣的優先級，而且能夠在不一樣的範圍內提供。

變量優先

命令行中的變量

在命令行中設置的變量具備在實際測試執行開始以前能夠設置的全部變量的最高優先級。它們覆蓋在測試用例文件中的變量表中以及在測試數據中導入的資源和變量文件中建立的可能變量。

單獨設置變量（--variable選項）會覆蓋使用變量文件設置的變量（--variablefile選項）。若是屢次指定相同的單個變量，則最後指定的變量將覆蓋較早的變量。這容許在啓動腳本中設置變量的默認值，並從命令行覆蓋它們。不過請注意，若是多個變量文件具備相同的變量，那麼指定的文件中的變量文件將具備最高的優先級。

測試用例文件中的變量表

使用測試用例文件中的變量表建立的變量可用於該文件中的全部測試用例。這些變量會覆蓋導入的資源和變量文件中具備相同名稱的可能變量。

在變量表中建立的變量在建立它們的文件中的全部其餘表中均可用。這意味着它們也能夠在設置表中使用，例如，從資源文件和變量文件中導入更多的變量。

導入的資源和變量文件

從資源和變量文件導入的變量具備在測試數據中建立的全部變量的最低優先級。資源文件和變量文件的變量具備相同的優先級。若是多個資源和/或變量文件具備相同的變量，則首先導入的文件中的那些被使用。

若是資源文件導入資源文件或變量文件，則變量表中的變量比其導入的變量具備更高的優先級。全部這些變量均可用於導入此資源文件的文件。

請注意，從資源文件和變量文件導入的變量在導入文件的變量表中不可用。這是因爲在導入資源文件和變量文件的設置表以前正在處理變量表。

測試執行期間設置的變量

在測試執行期間使用關鍵字的返回值或使用Set Test / Suite / Global Variable關鍵字設置的變量始終會覆蓋可能的現有變量。從某種意義上講，他們所以具備最高的優先權，但另外一方面，他們不會影響他們定義範圍之外的變量。

內置變量

內置變量同樣 ${TEMPDIR}，並 ${TEST_NAME} 擁有全部變量的最高優先級。它們不能被變量表或命令行覆蓋，可是即便在測試執行期間它們也能夠被重置。此規則的一個例外是數字變量，若是沒有發現變量，則動態解析數字變量。他們能夠被覆蓋，但這一般是一個壞主意。此外 ${CURDIR} ，因爲在測試數據處理期間已經被替換，因此是特別的。

變量範圍

根據建立的位置和方式，變量能夠具備全局，測試套件，測試用例或用戶關鍵字範圍。

全球範圍

測試數據中的全局變量都是可用的。這些變量一般在命令行中用 --variable和--variablefile選項設置，可是也能夠在測試數據中的任何位置使用BuiltIn關鍵字設置全局變量來建立新的全局變量或更改現有的變量。另外內置的變量是全局的。

建議對全部全局變量使用大寫字母。

測試套件範圍

測試套件範圍的變量在定義或導入的測試套件的任何地方都是可用的。它們能夠在變量表中建立，從資源和變量文件導入，或者在測試執行過程當中使用BuiltIn關鍵字 Set Suite變量設置。

測試套件範圍不是遞歸的，這意味着更高級別測試套件中可用的變量在低級套件中不可用。若有必要，資源和變量文件可用於共享變量。

因爲這些變量在使用它們的測試套件中能夠被認爲是全局的，所以建議也使用大寫字母。

測試用例範圍

測試用例中的關鍵字返回值中建立的變量具備測試用例範圍，而且僅在該測試用例中可用。建立它們的另外一種可能性是在特定的測試用例的任何地方使用BuiltIn關鍵字 Set Test Variable。測試用例變量是本地的，應該使用小寫字母。

用戶關鍵字範圍

用戶關鍵字從傳遞給它們的參數中獲取本身的變量，並從它們使用的關鍵字返回值。這些變量也是本地的，應該使用小寫字母。

2.5.6高級變量功能

擴展的變量語法

擴展變量語法容許訪問分配給變量（例如${object.attribute}）的對象的屬性，甚至能夠調用其方法（例如，${obj.getName()}）。它與標量和列表變量一塊兒工做，但主要用於前者

擴展變量語法是一個強大的功能，但應該當心使用它。訪問屬性一般不是問題，相反，由於包含具備多個屬性的對象的一個變量一般比具備多個變量更好。另外一方面，調用方法，尤爲是當它們與參數一塊兒使用時，可能會使測試數據變得至關複雜難以理解。若是發生這種狀況，建議將代碼移動到測試庫中。

下面的例子說明了擴展變量語法的最經常使用的用法。首先假定咱們有如下變量文件和測試用例：

類 MyObject ：    def  __init__ （self ， name ）：        self 。name  =  name    高清 吃（自我， 什麼）：        返回 ' ％s的吃％S '  ％ （自我。名稱， 什麼）    def  __str__ （self ）：        返回 自我。名稱OBJECT  =  MyObject （'Robot' ）DICTIONARY  =  { 1 ： 'one' ， 2 ： 'two' ， 3 ： 'three' }

測試用例	行動	論據
例	KW 1	$ {} OBJECT.name
KW 2	$ {OBJECT.eat（ '黃瓜'）}
KW 3	$ {DICTIONARY [2]}

當這個測試數據被執行時，關鍵字獲取參數，以下所示：

KW 1得到字符串Robot
KW 2得到字符串Robot eats Cucumber
KW 3獲取字符串two

擴展變量語法按如下順序進行評估：

該變量使用完整的變量名稱進行搜索。只有在沒有找到匹配變量的狀況下，擴展變量語法纔會被計算。
基本變量的名稱被建立。名稱的主體由開放後的全部字符組成，{直到首次出現不是字母數字字符或空格的字符。例如，基本變量${OBJECT.name} 和${DICTIONARY[2]}）是OBJECT和DICTIONARY分別。
搜索與身體匹配的變量。若是不匹配，則引起異常，測試用例失敗。
大括號內的表達式被評估爲一個Python表達式，以便基本變量名稱被其值替換。若是因爲語法無效而致使評估失敗，或者查詢的屬性不存在，則會引起異常，而且測試失敗。
整個擴展變量被替換爲從評估返回的值。

若是使用的對象是用Java實現的，則擴展變量語法容許您使用所謂的bean屬性來訪問屬性。實質上，這意味着若是你有一個getName 方法設置爲一個變量的對象 ${OBJ}，那麼語法${OBJ.name}至關於但比它更清晰 ${OBJ.getName()}。前面例子中使用的Python對象能夠用下面的Java實現來代替：

公共 類 MyObject ：    私人 字符串 名稱;    public  MyObject （String  name ） {         name  =  name ;     }    public  String  getName （） {         return  name ;     }    public  String  eat （String  what ） {         return  name  +  「吃」  +  what ;     }    public  String  toString （） {         return  name ;     } }

許多標準的Python對象，包括字符串和數字，都有明確或隱含地使用擴展變量語法的方法。有時這多是很是有用的，而且減小了設置臨時變量的需求，可是過分使用它並建立真正的模擬測試數據也是很容易的。下面的例子顯示了一些至關不錯的用法。

使用字符串和數字的方法
測試用例	行動	論據	論據
串	$ {string} =	設置變量	ABC
日誌	$ {string.upper（）}	＃記錄「ABC」
日誌	$ {string * 2}	＃日誌「abcabc」
數	$ {number} =	設置變量	$ { - 2}
日誌	$ {number * 10}	＃日誌-20
日誌	$ {數.__ ABS（）__}	＃日誌2

請注意，儘管在正常的Python代碼中abs(number)被推薦 number.__abs__()，可是使用 ${abs(number)}不起做用。這是由於變量名稱必須在擴展語法的開頭。__xxx__ 在這樣的測試數據中使用方法已經有點使人質疑了，一般將這種邏輯轉移到測試庫中會更好。

當使用標量變量做爲列表時，擴展變量語法也能夠工做。例如，若是分配給變量的對象${EXTENDED}具備attribute包含做爲值的列表的屬性，則能夠將其用做列表變量@{EXTENDED.attribute}。

擴展變量賦值

從Robot Framework 2.7開始，能夠使用關鍵字返回值和擴展變量語法的變體來設置存儲到標量變量的對象的屬性。假設咱們${OBJECT}在前面的例子中有變量，能夠像下面的例子那樣設置屬性。

擴展變量賦值
測試用例	行動	論據	論據
例	$ {OBJECT.name} =	設置變量	新名字
$ {OBJECT.new_attr} =	設置變量	新的屬性

使用如下規則評估擴展變量分配語法：

分配的變量必須是標量變量，而且至少有一個點。不然，不使用擴展分配語法，而且正常分配變量。
若是存在具備全名的變量（例如${OBJECT.name}在上面的示例中），那麼該變量將被分配新的值而且不使用擴展語法。
基本變量的名稱被建立。名稱的主體由開頭${和最後一個點之間的全部字符組成，例如OBJECTin ${OBJECT.name} 和foo.barin ${foo.bar.zap}。如第二個例子所示，基本名稱可能包含正常的擴展變量語法。
經過取最後一個點和結束點之間的全部字符}（例如，namein）來建立要設置的屬性的名稱${OBJECT.name}。若是名稱不是以字母或下劃線開頭，只包含這些字符和數字，則該屬性被認爲是無效的，而且不使用擴展語法。用全名建立一個新的變量。
搜索與基本名稱匹配的變量。若是找不到變量，則不使用擴展語法，而是使用完整變量名稱建立新變量。
若是找到的變量是字符串或數字，則忽略擴展語法，並使用全名建立新變量。這樣作是由於你不能將新的屬性添加到Python字符串或數字，這樣新的語法也不會向後兼容。
若是全部先前的規則匹配，則將該屬性設置爲基本變量。若是設置因任何緣由失敗，則會引起異常，而且測試失敗。

注意

與一般使用關鍵字返回值分配變量不一樣，使用擴展分配語法完成的變量更改不限於當前範圍。因爲沒有建立新變量，而是改變現有變量的狀態，全部查看該變量的測試和關鍵字也會看到更改。

變量內部的變量

變量也能夠在變量內部使用，當使用這個語法時，變量從裏到外被解析。例如，若是你有一個變量${var${x}}，那麼${x}首先解決。若是它有值name，那麼最終值就是變量的值${varname}。能夠有幾個嵌套變量，可是解決最外層的失敗，若是它們中的任何一個不存在的話。

在下面的示例中，Do X獲取值，${JOHN HOME} 或者${JANE HOME}取決於Get Name返回 john或jane。若是它返回別的東西，解決 ${${name} HOME}失敗。

在另外一個變量中使用一個變量
變量	值	值	值
$ {JOHN HOME}	/家/約翰·
$ {JANE HOME}	/家/簡

測試用例	行動	論據	論據
例	$ {name} =	獲取名稱
作X	$ {$ {name} HOME}

2.6建立用戶關鍵字

關鍵字表格用於經過將現有關鍵字組合在一塊兒來建立新的更高級別的關鍵字。這些關鍵字稱爲用戶關鍵字，以區別於在測試庫中實現的最低級庫關鍵字。用於建立用戶關鍵字的語法與建立測試用例的語法很是接近，這使得它易於學習。

2.6.1用戶關鍵字語法

基本的語法

在許多方面，總體用戶關鍵字語法與測試用例語法相同。用戶關鍵字是在關鍵字表格中建立的，這些表格與測試用例表格的區別僅在於用於標識它們的名稱。用戶關鍵字名稱與測試用例名稱相似，位於第一列。用戶關鍵字也能夠從關鍵字中建立，能夠從測試庫中的關鍵字或其餘用戶關鍵字中建立關鍵字名稱一般在第二列，可是當從關鍵字返回值設置變量時，它們位於後續列中。

用戶關鍵字示例
關鍵詞	行動	論據
打開登陸頁面	打開瀏覽器	HTTP：//host/login.html
標題應該是	登陸頁面

標題應該以	[參數]	$ {}預期
$ {title} =	獲取標題
應該開始	$ {}稱號	$ {}預期

大多數用戶關鍵字須要一些參數這個重要的特性已經在上面的第二個例子中使用了，本節稍後會詳細解釋，與用戶關鍵字返回值相似。

用戶關鍵字能夠在測試用例文件，資源文件和測試套件初始化文件中建立。在資源文件中建立的關鍵字可用於使用它們的文件，而其餘關鍵字僅在建立它們的文件中可用。

關鍵字表格中的設置

用戶關鍵字能夠具備與測試用例類似的設置，而且它們具備相同的方括號語法，將它們與關鍵字名稱分開。下面列出了全部可用的設置，並在本節稍後進行介紹。

[文檔]: 用於設置用戶關鍵字文檔。
[參數]: 指定用戶關鍵字參數。
[返回]: 指定用戶關鍵字返回值。
[拆除]: 指定用戶關鍵字拆解。從Robot Framework 2.6開始可用。
[時間到]: 設置可能的用戶關鍵字超時。超時在他們本身的部分中討論。

2.6.2用戶關鍵字名稱和文檔

用戶關鍵字名稱在用戶關鍵字表的第一列中定義。固然，這個名字應該是描述性的，而且有至關長的關鍵字名稱是能夠接受的。實際上，當建立相似用例的測試用例時，最高級別的關鍵字一般被定義爲句子甚至段落。

用戶關鍵字能夠具備與 [文檔]設置一致的文檔，與測試用例文檔徹底同樣。此設置記錄測試數據中的用戶關鍵字。它也顯示在更正式的關鍵字文檔中，libdoc工具能夠從資源文件建立。最後，文檔的第一行顯示爲測試日誌中的關鍵字文檔。

有時須要刪除關鍵字，替換爲新關鍵字，或者因爲其餘緣由而不推薦使用。用戶關鍵字能夠經過啓動文檔來標記爲廢棄*DEPRECATED*，這將在使用keyoword時引起警告。有關更多信息，請參閱棄用關鍵字部分。

2.6.3用戶關鍵字參數

大多數用戶關鍵字須要一些參數。指定它們的語法多是Robot Framework一般須要的最複雜的功能，但即便這樣也相對容易，特別是在大多數狀況下。參數一般與指定的[參數]設定，參數名稱使用相同的語法做爲變量，例如${arg}。

位置參數

指定參數最簡單的方法（除了根本沒有它們）只使用位置參數。在大多數狀況下，這是全部須要的。

語法是這樣的：首先給出[Arguments]設置，而後在隨後的單元格中定義參數名稱。每一個參數都在本身的單元格中，使用與變量相同的語法。關鍵字必須與其簽名中的參數名稱同樣多。實際的參數名稱與框架無關，但從用戶的角度來看，它們應該儘量描述性的。建議在變量名中使用小寫字母，或者as ${my_arg}，${my arg}或者${myArg}。

用戶關鍵字採起不一樣數量的參數
關鍵詞	行動	論據	論據	論據
一個參數	[參數]	$ {} arg_name
日誌	獲得了參數$ {arg_name}

三個參數	[參數]	$ {ARG1}	$ {ARG2}	$ {} ARG3
日誌	第一個參數：$ {arg1}
日誌	第二個參數：$ {arg2}
日誌	第三個參數：$ {arg3}

用戶關鍵字的默認值

在建立用戶關鍵字時，位置參數在大多數狀況下是足夠的。可是，有時關鍵字有一些或所有參數的默認值是有用的。用戶關鍵字也支持默認值，所需的新語法不會增長不少已經討論過的基本語法。

總之，默認值被添加到參數，因此首先有等號（=），而後是值，例如${arg}=default。默認狀況下能夠有不少參數，但都必須在正常的位置參數以後給出。默認值能夠包含在套件或全局範圍上建立的變量。

注意

缺省值的語法是空間敏感的。=符號以前的空格是不容許的，其後面的可能空格被認爲是默認值自己的一部分。

具備參數默認值的用戶關鍵字
關鍵詞	行動	論據	論據
一個帶有默認值的參數	[參數]	$ {arg} =默認值
[文檔]	這個關鍵字須要	0-1的參數
日誌	獲得了參數$ {arg}

兩個帶有默認值的參數	[參數]	$ {arg1} =默認1	$ {ARG2} = $ {}變量
[文檔]	這個關鍵字須要	0-2的參數
日誌	第一個參數$ {arg1}
日誌	第二個參數$ {arg2}

一個須要和一個默認	[參數]	$ {}要求	$ {}可選默認=
[文檔]	這個關鍵字須要	1-2個參數
日誌	必需：$ {required}
日誌	可選：$ {可選}

當一個關鍵字接受幾個具備默認值的參數，而且只有一些參數須要重寫時，使用命名參數語法一般很方便。當這個語法與用戶關鍵字一塊兒使用時，參數被指定而沒有${} 裝飾。例如，上面的第二個關鍵字能夠像下面同樣使用，${arg1}仍然會獲得它的默認值。

用戶關鍵字和命名參數語法
測試用例	行動	論據	論據
例	兩個帶有默認值的參數	arg2 =新值

因爲全部的Pythonistas必須已經注意到，指定默認參數的語法在很大程度上受Python語法對函數默認值的啓發。

帶有用戶關鍵字的可變參數

有時甚至默認值是不夠的，須要一個關鍵字接受可變數量的參數。用戶關鍵字也支持這個功能。全部這一切都須要具備列表變量，如@{varargs}關鍵字簽名中的最後一個參數。這個語法能夠和前面描述的位置參數和默認值相結合，最後list變量得到全部與其餘參數不匹配的剩餘參數。列表變量所以能夠具備任何數量的項目，甚至爲零。

用戶關鍵字接受可變數量的參數
關鍵詞	行動	論據	論據	論據
任何數量的參數	[參數]	@ {}可變參數
記錄許多	@ {}可變參數

一個或多個參數	[參數]	$ {}要求	@{休息}
記錄許多	$ {}要求	@{休息}

必需，默認，可變參數	[參數]	$ {} REQ	$ {選擇} = 42	@{其餘}
日誌	必需：$ {req}
日誌	可選：$ {opt}
日誌	其餘：
：FOR	$ {}項	在	@{其餘}
	日誌	$ {}項

注意，若是上面的最後一個關鍵字與多個參數一塊兒使用，那麼第二個參數${opt}老是獲得給定的值而不是默認值。即便給定值爲空，也會發生這種狀況。最後一個例子還說明了如何在for循環中使用用戶關鍵字接受的可變數量的參數。這兩個至關先進的功能的組合有時是很是有用的。

再一次，Pythonistas可能會注意到，可變數量的參數語法與Python中的很是接近。

2.6.4將參數嵌入到關鍵字名稱中

Robot Framework還提供了另外一種方法來將參數傳遞給用戶關鍵字，而不是像上一節中所述那樣在關鍵字名稱後面的單元格中指定它們。該方法基於將參數直接嵌入到關鍵字名稱中，其主要優勢是使用真實和明確的句子做爲關鍵字更容易。

基本的語法

一直以來，能夠使用相似的關鍵字選擇狗從列表，並選擇從貓名單，但全部這些關鍵字必須一直是單獨實施。將參數嵌入到關鍵字名稱中的想法是，您只須要一個名稱爲「 Select $ {animal}」的關鍵字。

參數嵌入名稱的示例關鍵字
關鍵詞	行動	論據	論據
從列表中選擇$ {動物}	打開頁面	寵物選擇
從列表中選擇項目	animal_list	$ {}動物

關鍵字使用嵌入式參數不能帶任何「正常」參數（用[參數]設置指定），不然就像其餘用戶關鍵字同樣建立。名稱中使用的參數天然能夠在關鍵字中使用，而且根據關鍵字的調用方式而有不一樣的值。例如，若是關鍵字像列表中的Select dog同樣使用${animal}，那麼前面的值dog就是有效的。顯然，在關鍵字中使用全部這些參數並非強制性的，所以能夠用做通配符。

除了空格和下劃線在名稱中不被忽略以外，這些關鍵字的使用方式與其餘關鍵字相同。可是，它們與其餘關鍵字不區分大小寫。例如，上面的例子中的關鍵字能夠用來從列表中選擇x，但不能像Select x fromlist那樣。

嵌入式參數不支持像普通參數那樣的默認值或可變數量的參數。調用這些關鍵字時使用變量是可能的，但這會下降可讀性。還要注意，嵌入的參數只能用於用戶關鍵字。

嵌入的參數匹配太多

使用嵌入式參數的一個棘手的部分是確保調用關鍵字時使用的值匹配正確的參數。這是一個問題，尤爲是若是有多個參數和分隔它們的字符也可能出如今給定的值。例如，關鍵字選擇$ {city} $ {team}若是與包含太多部分的城市一塊兒使用，則沒法正常工做，如Select Los Angeles LAkers。

這個問題的一個簡單的解決方法是引用參數（例如選擇「$ {city}」「$ {team}」）並使用引用格式的關鍵字（例如選擇「洛杉磯」「湖人」）。儘管如此，這種方法還不足以解決全部這類衝突，但仍然強烈建議使用這種方法，由於它使得參數從關鍵字的其他部分中脫穎而出。在定義變量時使用自定義正則表達式是一個更強大但更復雜的解決方案，將在下一節解釋。最後，若是事情變得複雜，那麼使用普通的位置參數可能會更好。

參數匹配太多的問題常常發生在建立關鍵字時忽略given / when / then /和前綴。例如， $ {name}回家比賽鑑於Janne回家，以便${name}得到價值Given Janne。像「$ {name}」這樣的參數引用，能夠很容易地解決這個問題。

使用自定義正則表達式

當調用帶有嵌入參數的關鍵字時，這些值在內部使用正則表達式進行匹配（簡稱爲regexps）。默認的邏輯是這樣的，名稱中的每一個參數都被一個.*?基本上匹配任何字符串的模式替換。這個邏輯一般工做得至關好，但正如上面所討論的，有時候關鍵字比預期的要多。引用或以其餘方式將參數與其餘文本分開可能會有所幫助，可是，例如，如下測試失敗，由於關鍵字 I執行帶有「-lh」的「ls」與兩個定義的關鍵字都匹配。

嵌入的參數匹配太多
測試用例	步
例	我執行「ls」
我用「-lh」執行「ls」

關鍵詞	行動	論據	論據
我執行「$ {cmd}」	跑	$ {cmd}，在
我用「$ {opts}」執行「$ {cmd}」	跑	$ {cmd} $ {opts}

解決這個問題的方法是使用一個自定義的正則表達式來確保關鍵字只匹配它在特定的上下文中的內容。爲了可以使用這個特性，而且要充分理解本節中的例子，至少須要瞭解正則表達式語法的基礎知識。

自定義嵌入式參數正則表達式在參數的基本名稱以後定義，以便參數和正則表達式以冒號分隔。例如，一個只能匹配數字的參數能夠像這樣定義${arg:\d+}。下面的例子說明了使用自定義正則表達式。

使用自定義正則表達式與嵌入式參數
測試用例	步
例	我執行「ls」
我用「-lh」執行「ls」
我輸入1 + 2
我輸入53 - 11
今天是2011-06-27

關鍵詞	行動	論據	論據	論據
我執行「$ {cmd：[^」] +}「	跑	$ {cmd}，在
我用「$ {opts}」執行「$ {cmd}」	跑	$ {cmd} $ {opts}
我輸入$ {a：\ d +} $ {operator：[+ - ]} $ {b：\ d +}	計算	$ {A}	$ {}操做	$ {B}
今天是$ {date：\ d {4 \} - \ d {2 \} - \ d {2 \}}	日誌	$ {}日期

在上面的例子中，我用「-lh」執行「ls」的關鍵字只匹配我用「$ {opts}」執行「$ {cmd}」。這是保證，由於自定義的正則表達式[^"]+在我執行「$ {CMD：[^」]}」指的是匹配的參數不能包含任何引號在這種狀況下，沒有必要定製正則表達式添加到其餘的。我執行的變體。

小費

若是引用參數，則使用正則表達式可[^"]+ 保證參數僅匹配到第一個結束引號。

支持正則表達式語法

用Python實現，Robot Framework天然使用Python的 re模塊，它具備很是標準的正則表達式語法。嵌入參數徹底支持此語法，但(?...)不能使用格式的正則表達式擴展。還要注意匹配嵌入式參數是不區分大小寫的。若是正則表達式語法無效，則建立關鍵字失敗，並在測試執行錯誤中顯示錯誤。

轉義特殊字符

在自定義嵌入參數regexp中使用時，有一些特殊字符須要轉義。首先，}模式中的花括號（）可能須要使用單個反斜槓（\}）進行轉義，不然參數將會在那裏結束。在前面的例子中，關鍵字 Today是$ {date：\ d {4 \} - \ d {2 \} - \ d {2 \}}。

反斜槓（\）是Python正則表達式語法中的一個特殊字符，所以若是您但願具備文字反斜槓字符，則須要將其轉義。在這種狀況下，最安全的轉義序列是四個反斜槓（\\\\），但根據下一個字符，也可能有兩個反斜槓。

還要注意，關鍵字名稱和其中可能的嵌入式參數不應該使用正常的測試數據轉義規則進行轉義。這意味着，例如，表達式中的反斜槓${name:\w+}不該該被轉義。

使用具備自定義嵌入式參數正則表達式

每當使用自定義嵌入式參數正則表達式時，Robot Framework會自動加強指定的正則表達式，以便匹配變量和匹配模式的文本。這意味着始終能夠使用帶有嵌入參數的關鍵字的變量。例如，下面的測試用例會使用前面例子中的關鍵字。

在自定義正則表達式中使用變量
變量	值
$ {DATE}	2011-06-27

測試用例	步
例	我輸入$ {1} + $ {2}
今天是$ {DATE}

自動匹配自定義正則表達式的變量的一個缺點是關鍵字獲取的值可能並不匹配指定的正則表達式。例如，上例中的變量 ${DATE}能夠包含任何值，而今天$ {DATE}仍然會匹配相同的關鍵字。

行爲驅動開發的例子

將參數做爲關鍵字名稱的一部分的最大好處在於，在以行爲驅動樣式編寫測試用例時，能夠更輕鬆地使用更高級的相似句子的關鍵字。下面的例子說明了這一點。還要注意，給定的前綴，時間和而後被排除在關鍵字定義以外。

嵌入式參數由BDD風格測試使用
測試用例	步
添加兩個數字	鑑於我有計算器打開
當我加2和40
那麼結果應該是42

添加負數	鑑於我有計算器打開
當我加1和-2
那麼結果應該是-1

關鍵詞	行動	論據
我有$ {程序}打開	啓動程序	$ {方案}

我添加$ {number 1}和$ {number 2}	輸入號碼	$ {number 1}
按鈕	+
輸入號碼	$ {number 2}
按鈕	=

結果應該是$ {expected}	$ {result} =	得到結果
應該是平等的	$ {}結果	$ {}預期

注意

機器人框架中的嵌入式參數功能受到在流行的BDD工具Cucumber中如何建立步驟定義的啓發。

2.6.5用戶關鍵字返回值

與庫關鍵字相似，用戶關鍵字也能夠返回值。一般，返回值是經過[Return] 設置定義的，但也能夠使用BuiltIn關鍵字返回關鍵字和返回關鍵字If。不管返回值如何，均可以將其分配給測試用例和其餘用戶關鍵字中的變量。

使用[返回]設置

最多見的狀況是用戶關鍵字返回一個值，並將其分配給標量變量。使用[返回]設置時，經過在設置後的下一個單元格中具備返回值來完成此操做。

用戶關鍵字也能夠返回幾個值，而後能夠一次將它們分配給多個標量變量，列表變量或標量變量和列表變量。經過在[返回]設置以後的不一樣單元格中指定這些值，能夠返回多個值。

用戶關鍵字使用[返回]設置返回值
測試用例	行動	論據	論據	論據
一個返回值	$ {ret} =	回報一個價值	論據
一些關鍵字	$ {} RET

多個值	$ {A}	$ {B}	$ {c} =	回報三個價值觀
@ {list} =	回報三個價值觀
$ {}標	@ {rest} =	回報三個價值觀

關鍵詞	行動	論據	論據	論據
回報一個價值	[參數]	$ {} ARG
作一點事	$ {} ARG
$ {value} =	得到一些價值
[返回]	$ {}值

回報三個價值觀	[返回]	FOO	酒吧	ZAP

使用特殊關鍵字返回

內置的關鍵字返回從關鍵字和返回從關鍵字若是容許用戶關鍵詞在關鍵詞中間有條件返回。它們都接受可選的返回值，與上面討論的[返回]設置徹底相同。

下面的第一個例子在功能上與前面的 [Return]設置示例相同。第二個更高級的示例演示了在for循環內有條件地返回。

用戶關鍵字使用特殊關鍵字返回值
測試用例	行動	論據	論據	論據
一個返回值	$ {ret} =	回報一個價值	論據
一些關鍵字	$ {} RET

高級	@ {list} =	建立列表	FOO	巴茲
$ {index} =	查找索引	巴茲	@ {}名單
應該是平等的	$ {}指數	$ {1}
$ {index} =	查找索引	不存在	@ {}名單
應該是平等的	$ {}指數	$ { - 1}

關鍵詞	行動	論據	論據
回報一個價值	[參數]	$ {} ARG
作一點事	$ {} ARG
$ {value} =	得到一些價值
從關鍵字返回	$ {}值
失敗	這不被執行

查找索引	[參數]	$ {}元素	@ {}項目
$ {指數=}	設置變量	$ {0}
：對於	$ {}項	在	@ {}項目
	從關鍵字返回If	'$ {item}'=='$ {element}'	$ {}指數
	$ {指數=}	設置變量	$ {index + 1}
從關鍵字返回	$ { - 1}	＃也能夠用[返回]

注意

不管返回從關鍵字和返回從關鍵字若是是可用的，由於機器人框架2.8。

2.6.6用戶關鍵詞拆解

從Robot Framework 2.6開始，用戶關鍵字也可能會被拆除。它是使用[Teardown]設置定義的。

關鍵詞teardown的工做方式與測試用例拆解相同。最重要的是，拆卸老是一個關鍵字，雖然它能夠是另外一個用戶關鍵字，當用戶關鍵字失敗時也會被執行。另外，即便其中一個失敗，拆解的全部步驟也會執行。可是，關鍵字拆解失敗將會致使測試用例失敗，而且測試中的後續步驟不會運行。做爲拆解而執行的關鍵字的名稱也能夠是變量。

用戶關鍵字	行動	論據	論據
隨着拆解	作一點事
[拆除]	日誌	關鍵字拆解

使用變量	[文檔]	拆除給予	變量
作一點事
[拆除]	$ {} TEARDOWN

2.7資源和變量文件

測試用例文件和測試套件初始化文件中的用戶關鍵字和變量只能在建立它們的文件中使用，但資源文件提供了共享它們的機制。因爲資源文件結構很是接近測試用例文件，因此很容易建立它們。

變量文件提供了建立和共享變量的強大機制。例如，它們容許字符串之外的值動態建立變量。它們的靈活性來源於它們是使用Python代碼建立的，這也使得它們比變量表更復雜一些。

2.7.1資源文件

使用資源文件

資源文件使用「設置」表中的「資源」設置導入。設置名稱後面的單元格中給出了資源文件的路徑。

若是路徑以絕對格式給出，則直接使用。在其餘狀況下，首先相對於導入文件所在的目錄搜索資源文件。若是沒有找到文件，則從PYTHONPATH的目錄中搜索。路徑能夠包含變量，建議使用它們使路徑與系統無關（例如，$ {RESOURCES} /login_resources.html或 $ {RESOURCE_PATH}）。此外，/路徑中的斜槓（）會自動更改成Windows上的反斜槓（\）。

導入資源文件
設置	值	值
資源	myresources.html
資源	../data/resources.html
資源	$ {}資源/common.tsv

資源文件中定義的用戶關鍵字和變量在使用該資源文件的文件中可用。相似地可用的也是來自由所述資源文件導入的庫，資源文件和變量文件的全部關鍵字和變量。

資源文件結構

不然，資源文件的更高級別的結構與測試用例文件的結構相同，可是固然，它們不能包含測試用例表。另外，資源文件中的設置表只能包含導入設置（庫，資源，變量）和文檔。變量表和關鍵字表的使用方式與測試用例文件徹底相同。

若是多個資源文件具備相同名稱的用戶關鍵字，則必須使用它們，以便關鍵字名稱前面帶有不帶擴展名的資源文件名（例如，myresources.Some Keyword和common.Some Keyword）。並且，若是多個資源文件包含相同的變量，則首先導入的文件被使用。

記錄資源文件

在資源文件中建立的關鍵字能夠使用 [文檔]設置進行記錄。從Robot Framework 2.1開始，資源文件自己能夠在設置表中具備與測試套件類似的文檔。

不管libdoc和RIDE使用這些文檔，和他們天然能夠爲任何人打開資源文件。關鍵字文檔的第一行是在運行時記錄的，不然在測試執行過程當中會忽略資源文檔文檔。

示例資源文件

設置	值	值	值
文檔	一個示例資源文件
圖書館	SeleniumLibrary
資源	$ {}資源/common.html

變量	值	值	值
$ {HOST}	本地主機：7272
$ {} LOGIN_URL	HTTP：// $ {HOST} /
$ {} WELCOME_URL	HTTP：// $ {HOST} /welcome.html
$ {} BROWSER	火狐

關鍵詞	行動	論據	論據
打開登陸頁面	[文檔]	打開瀏覽器	登陸頁面
打開瀏覽器	$ {} LOGIN_URL	$ {} BROWSER
標題應該是	登陸頁面

輸入名稱	[參數]	$ {NAME}
輸入文本	username_field	$ {NAME}

輸入密碼	[參數]	$ {}密碼
輸入文本	password_field	$ {}密碼

2.7.2變量文件

變量文件包含能夠在測試數據中使用的變量。變量也能夠使用變量表建立，也能夠經過命令行進行設置，但變量文件容許動態建立變量，變量能夠包含任何對象。

變量文件一般以Python模塊的形式實現，建立變量有兩種不一樣的方法：

直接建立變量: 變量被指定爲模塊屬性。在簡單狀況下，語法很是簡單，不須要真正的編程。例如，用指定的文本做爲值 MY_VAR = 'my value'建立一個變量 ${MY_VAR}。
從特殊功能獲取變量: 變量文件能夠有一個特殊的 get_variables （或 getVariables）方法做爲映射返回變量。由於該方法能夠採起參數，因此這種方法很是靈活。

或者，能夠將變量文件實現爲框架將實例化的Python或Java類。一樣在這種狀況下，能夠建立變量做爲屬性或從一個特殊的方法獲取它們。

把變量文件投入使用

設置表

全部測試數據文件均可以使用「設置」表中的「變量」設置導入變量，與使用「資源」設置導入資源文件的方式相同。與資源文件相似，導入變量文件的路徑被認爲是相對於導入文件所在的目錄，若是沒有找到，則從PYTHONPATH中的目錄中搜索。該路徑也能夠包含變量，並在Windows上將斜槓轉換爲反斜槓。若是參數文件帶有參數，則它們在路徑以後的單元格中指定，而且它們也能夠包含變量。

導入一個變量文件
設置	值	值	值
變量	myvariables.py
變量	../data/variables.py
變量	$ {}資源/common.py
變量	taking_arguments.py	ARG1	$ {ARG2}

來自變量文件的全部變量均可以在導入它的測試數據文件中找到。若是導入了多個變量文件而且它們包含一個名稱相同的變量，則最先導入的文件中的文件將被使用。另外，變量表中建立的變量和從命令行設置的變量會覆蓋變量文件中的變量。

命令行

使變量文件變爲可用的另外一種方法是使用命令行選項 --variablefile。變量文件使用它們的路徑引用，可能的參數用冒號（:）鏈接到路徑：

--variablefile myvariables.py--variablefile path / variables.py--variablefile /absolute/path/common.py--variablefile taking_arguments.py:arg1:arg2

從Robot Framework 2.8.2開始，從命令行使用的變量文件也會從PYTHONPATH中搜索，相似於在設置表中導入的變量文件。

這些變量文件中的變量在所有測試數據文件中是全局可用的，與用--variable選項設置的單個變量相似。若是同時使用了--variablefile和 --variable選項，而且有相同名稱的變量，則使用--variable選項單獨設置的選項優先。

直接建立變量

基本的語法

當變量文件被使用時，它們被導入爲Python模塊，而且全部不如下劃線（_）開頭的全局屬性被認爲是變量。由於變量名是不區分大小寫的，因此大小寫都是可能的，可是通常狀況下，大寫字母被推薦用於全局變量和屬性。

VARIABLE  =  「一個示例字符串」 ANOTHER_VARIABLE  =  「這很簡單！」 INTEGER  =  42 STRINGS  =  [ 「one」 ， 「two」 ， 「kolme」 ， 「four」 ] NUMBERS  =  [ 1 ， INTEGER ， 3.14 ]

在上面的例子中，變量${VARIABLE}， ${ANOTHER VARIABLE}等，被建立。前兩個變量是字符串，第三個是整數，後兩個是列表。全部這些變量都是標量變量，即便是包含列表值的變量。要建立列表變量，變量名稱必須之前綴LIST__（注意兩個下劃線）。

LIST__STRINGS  =  [ 「list」 ， 「of」 ， 「strings」 ] LIST__MIXED  =  [ 「first value」 ， - 1.1 ， None ， True ]

上面兩個例子中的變量均可以使用下面的變量表建立。

變量	值	值	值	值
$ {}變量	一個示例字符串
$ {} ANOTHER_VARIABLE	這很容易！
$ {整數}	$ {42}
$ {} STRINGS	一	二	kolme	四
$ {}號碼	$ {1}	$ {整數}	$ {} 3.14
@ {} STRINGS	名單	的	字符串
@ {}混合	第一價值	$ { - 1.1}	$ {}無	$ {TRUE}

注意

變量不會被變量文件中的字符串替換。例如，不管變量是否存在，VAR = "an ${example}"都將建立${VAR}一個字符串值的 an ${example}變量${example}。

使用對象做爲值

變量文件中的變量並不侷限於像變量表同樣只有字符串或其餘基本類型。相反，他們的變量能夠包含任何對象。在下面的例子中，變量 ${MAPPING}包含一個帶有兩個值的Java Hashtable（這個例子只在Jython上運行測試時才起做用）。

從 java.util  import  HashtableMAPPING  =  Hashtable （）映射。放（「一」 ， 1 ）映射。把（「兩」 ， 2 ）

第二個示例建立${MAPPING}爲Python字典，同時還有兩個由在同一個文件中實現的自定義對象建立的變量。

MAPPING  =  { 'one' ： 1 ， 'two' ： 2 }class  MyObject ：    def  __init__ （self ， name ）：        self 。name  =  nameOBJ1  =  MyObject （'John' ）OBJ2  =  MyObject （'Jane' ）

動態建立變量

因爲變量文件是使用真正的編程語言建立的，所以它們能夠具備用於設置變量的動態邏輯。

導入 os 導入 隨機導入 時間USER  =  os 。getlogin （）                ＃當前登陸名RANDOM_INT  =  random 。randint （0 ， 10 ）  在範圍＃隨機整數[0,10] CURRENT_TIME  =  時間。asctime （）        ＃時間戳像「星期四4月6日12點45分21秒2006年」 若是 時間。localtime （）[ 3 ]  >  12 ：    AFTERNOON  =  True else ：    AFTERNOON  =  False

上面的例子使用標準的Python庫來設置不一樣的變量，可是您能夠使用本身的代碼來構造這些值。下面的例子說明了這個概念，可是相似地，你的代碼能夠從數據庫中讀取數據，從外部文件中讀取數據，甚至能夠從用戶那裏獲取數據。

導入 數學def  get_area （直徑）：    半徑 =  直徑 /  2     面積 =  數學。pi  *  半徑 *  半徑    返回 區域AREA1  =  get_area （1 ）AREA2  =  get_area （2 ）

選擇包含哪些變量

當Robot Framework處理變量文件時，全部不如下劃線開頭的屬性都是變量。這意味着即便在變量文件中建立的或從別處導入的函數或類也被認爲是變量。例如，上例中會包含變量${math} 和${get_area}除了${AREA1}和 ${AREA2}。

一般狀況下，額外的變量不會致使問題，但能夠覆蓋其餘一些變量，致使難以調試的錯誤。忽略其餘屬性的一種可能性是用下劃線做爲前綴：

將 數學 做爲 _math 導入def  _get_area （直徑）：    半徑 =  直徑 /  2.0     面積 =  _math 。pi  *  半徑 *  半徑    返回 區域AREA1  =  _get_area （1 ）AREA2  =  _get_area （2 ）

若是存在大量的其他屬性，而不是將它們所有前綴，那麼使用特殊屬性__all__並給它一個屬性名稱列表以做爲變量進行處理每每更容易。

導入 數學__all__  =  [ 'AREA1' ， 'AREA2' ]def  get_area （直徑）：    半徑 =  直徑 /  2.0     面積 =  數學。pi  *  半徑 *  半徑    返回 區域AREA1  =  get_area （1 ）AREA2  =  get_area （2 ）

注意

該__all__屬性也是最初由Python用來決定在使用語法時要導入哪些屬性from modulename import *。

從特殊功能獲取變量

獲取變量的另外一種方法是在變量文件中使用一個特殊的 get_variables函數（也getVariables多是camelCase語法）。若是存在這樣的函數，Robot Framework會調用它，並指望以Map變量名做爲鍵和變量值做爲值接收變量做爲Python字典或Java 。變量被認爲是標量，除非用前綴LIST__，值能夠包含任何東西。下面的例子在功能上與上面直接建立變量的第一個例子相同。

def  get_variables （）：    variables  =  { 「VARIABLE」 ： 「一個字符串示例」 ，                 「ANOTHER_VARIABLE」 ： 「這很容易！，                 「INTEGER」 ： 42 ，                 「字符串」 ： [ 「一」 ， 「二」 ， 「kolme」 ，「 四」 ]，                  「 數字」 ： [ 1 ， 42 ， 3.14 ]，                 「LIST__STRINGS」 ： [ 「列表」 ， 「的」                  ： [ 「first value」 ， - 1.1 ， None ， True ]}     返回 變量

get_variables也能夠採起參數，這有利於改變實際建立的變量。該函數的參數設置與Python函數的其餘參數同樣。當在測試數據中使用變量文件時，變量文件的路徑以後的單元格中指定了參數，而在命令行中，它們用冒號與路徑分隔。

下面的虛擬示例顯示瞭如何使用變量文件的參數。在更現實的例子中，參數能夠是到外部文本文件或數據庫讀取變量的路徑。

variables1  =  { '的標量' ： '標量變量' ，              'LIST__list' ： [ '列表' ，'可變' ]} variables2  =  { '的標量'  ： '某些其餘值' ，              'LIST__list' ： [ '某些' ，「其它' ，'value' ]，              'extra' ： 'variables1根本就沒有這個' }def  get_variables （arg ）：    若是 arg  ==  'one' ：        return  variables1     else ：        return  variables2

將變量文件實現爲Python或Java類

從Robot Framework 2.7開始，能夠將變量文件實現爲Python或Java類。

履行

由於變量文件老是使用文件系統路徑導入，因此將它們建立爲類有一些限制：

Python類必須與它們所在的模塊具備相同的名稱。

Java類必須存在於默認包中。

Java類的路徑必須以.java或.class結尾。在兩種狀況下都必須存在類文件。

不管實現語言如何，框架都將使用無參數來建立類的實例，變量將從實例中獲取。與模塊相似，變量能夠直接在實例中定義爲屬性，也能夠從特殊get_variables （或getVariables）方法中獲取。

當變量直接在實例中定義時，將忽略包含可調用值的全部屬性，以免實例具備的可能方法建立變量。若是您確實須要可調用變量，則須要使用其餘方法來建立可變文件。

例子

第一個示例使用Python和Java從屬性建立變量。他們都建立變量${VARIABLE}，@{LIST}從類屬性和${ANOTHER VARIABLE}實例屬性。

類 StaticPythonExample （對象）：    變量 =  '值'     LIST__list  =  [ 1 ， 2 ， 3 ]     _not_variable  =  '如下劃線開始'    def  __init__ （self ）：        self 。another_variable  =  '另外一個值'

公共 類 StaticJavaExample  {     公共 靜態 字符串 變量 =  「值」 ;     公共 靜態 字符串[]  LIST__list  =  { 1 ， 2 ， 3 };     private  String  notVariable  =  「is private」 ;     public  String  anotherVariable ;    public  StaticJavaExample （） {         anotherVariable  =  「another value」 ;     } }

第二個例子使用動態方法獲取變量。他們兩個只建立一個變量${DYNAMIC VARIABLE}。

類 DynamicPythonExample （object ）：    def  get_variables （self ， * args ）：        return  { 'dynamic variable' ： '' 。join （args ）}

import  java.util.Map ; import  java.util.HashMap ;公共 類 DynamicJavaExample  {    公共 Map < String ， String >  getVariables （String  arg1 ， String  arg2 ） {         HashMap < String ， String >  variables  =  new  HashMap < String ， String >（）;         變量。put （「dynamic variable」 ， arg1  +  「」  +  arg2 ）;         返回 變量;     } }

2.8高級功能

2.8.1處理同名的關鍵字

Robot Framework使用的關鍵詞是庫關鍵字或用戶關鍵字。前者來自標準庫或外部庫，然後者則使用相同的文件建立，而後從資源文件導入。在使用多個關鍵字的狀況下，一般有一些關鍵字具備相同的名稱，本節將介紹如何處理這些狀況下可能發生的衝突。

關鍵字範圍

若是僅使用關鍵字名稱，而且有多個關鍵字具備該名稱，則Robot Framework將根據其範圍嘗試肯定哪一個關鍵字具備最高優先級。關鍵字的範圍是根據建立關鍵字的方式肯定的：

在使用該文件的同一文件中做爲用戶關鍵字建立。這些關鍵字具備最高的優先級，而且始終使用它們，即便其餘關鍵字具備相同的名稱也是如此。
在資源文件中建立，並直接或間接從另外一個資源文件導入。這是第二高優先級。
在外部測試庫中建立。若是不存在具備相同名稱的用戶關鍵字，則使用這些關鍵字。可是，若是標準庫中有同名的關鍵字，則會顯示警告。
在標準庫中建立。這些關鍵字的優先級最低。

明確指定關鍵字

單獨使用範圍並非一個足夠的解決方案，由於在幾個庫或資源中能夠有相同名稱的關鍵字，所以它們提供了一種機制，只使用最高優先級的關鍵字。在這種狀況下，能夠使用關鍵字的全名，其中關鍵字名稱以資源或庫的名稱做爲前綴，而點是分隔符。

使用庫關鍵字，長格式意味着只使用格式庫名稱。關鍵字名稱。例如，關鍵字運行從OperatingSystem的庫可做爲 OperatingSystem.Run，即便有另外一個運行關鍵字別處。若是庫位於模塊或包中，則必須使用完整的模塊或包名稱（例如 com.company.Library.Some關鍵字）。若是使用WITH NAME語法將自定義名稱賦予庫，則必須在完整的關鍵字名稱中使用指定的名稱。

資源文件在完整的關鍵字名稱中指定，相似於庫名稱。資源的名稱是從沒有文件擴展名的資源文件的基本名稱派生的。例如，資源文件myresources.html中的關鍵字Example能夠用做myresources.Example。請注意，若是多個資源文件具備相同的基本名稱，則此語法不起做用。在這種狀況下，文件或關鍵字必須重命名。關鍵字的全名不區分大小寫，空格和下劃線，與普通關鍵字名稱相似。

指定庫和資源之間的顯式優先級

若是關鍵字之間存在多個衝突，那麼以長格式指定全部關鍵字多是至關多的工做。使用長格式還會致使沒法建立動態測試用例或用戶關鍵字，這些關鍵字的工做方式會有所不一樣，具體取決於可用的庫或資源。一種解決這兩個問題被明確指定使用關鍵字的關鍵字的優先級設置庫搜索順序從內建庫。

注意

儘管關鍵字的名稱中包含單詞庫，但它也適用於從Robot Framework 2.6.2開始的資源文件。如上所述，儘管資源中的關鍵字老是比庫中的關鍵字具備更高的優先級。

該設置庫搜索順序接受一個有序列表或庫和資源做爲參數。當測試數據中的關鍵字名稱與多個關鍵字匹配時，將選擇包含該關鍵字的第一個庫或資源，並使用該關鍵字實現。若是未從任何指定的庫或資源中找到關鍵字，則與未設置搜索順序時相同的方式執行失敗。

有關更多信息和示例，請參閱關鍵字的文檔。

2.8.2超時

在這些狀況下，關鍵字可能會出現問題，由於它們須要特別長時間才能執行或者無休止地運行。Robot Framework容許您爲測試用例和用戶關鍵字設置超時，若是測試或關鍵字在指定的時間內沒有完成，那麼當前正在執行的關鍵字會被強制中止。以這種方式中止關鍵字可能會使庫或系統處於不穩定狀態，只有當沒有可用的安全選項時才建議超時。通常來講，應該實現庫，以便關鍵字不會掛起，或者若是有必要，它們有本身的超時機制。

測試用例超時

測試用例超時能夠經過使用設置表中的測試超時設置或測試用例表中的[超時] 設置來設置。測試超時的設置表定義了全部的測試用例的測試套件默認測試超時值，而[超時]在測試用例表適用超時到一個單獨的測試案例和覆蓋可能的默認值。

使用一個空的[Timeout]意味着即便使用Test Timeout，測試也沒有超時。從Robot Framework 2.5.6開始，也能夠爲此使用值NONE。

不管定義測試超時的位置如何，設置名稱後的第一個單元格都包含超時的持續時間。持續時間必須以「機器人框架」的時間格式給出，也就是直接以秒爲單位或以像1 minute 30 seconds。必須注意的是，框架老是會有一些開銷，所以不推薦超過一秒的超時。

發生測試超時時顯示的默認錯誤消息是 Test timeout <time> exceeded。也能夠使用自定義錯誤消息，並在超時時間後將這些消息寫入單元。該消息能夠拆分紅多個單元格，相似於文檔。超時值和錯誤消息均可能包含變量。

若是發生超時，則在超時到期時中止運行關鍵字，而且測試用例失敗。可是，當測試超時發生時，做爲測試拆卸執行的關鍵字不會被中斷，由於它們一般從事重要的清理活動。若有必要，也能夠用用戶關鍵字超時中斷這些關鍵字。

測試超時的例子
設置	值	值	值
測試超時	2分鐘

測試用例	行動	論據	論據
默認超時	[文檔]	使用設置表中的超時
一些關鍵字	論據

覆蓋	[文檔]	覆蓋默認值，使用10秒超時
[時間到]	10
一些關鍵字	論據

自定義消息	[文檔]	覆蓋默認值並使用自定義消息
[時間到]	1分10秒	這是個人自定義錯誤。	它繼續在這裏。
一些關鍵字	論據

變量	[文檔]	也能夠使用變量
[時間到]	$ {} TIMEOUT
一些關鍵字	論據

沒有超時	[文檔]	空超時意味着即便在沒有超時時	測試超時已被使用
[時間到]
一些關鍵字	論據

沒有超時2	[文檔]	空的超時使用無，使用	2.5.6
[時間到]	沒有
一些關鍵字	論據

用戶關鍵字超時

能夠使用關鍵字表中的[超時]設置爲用戶關鍵字設置超時。包括如何給出超時值和可能的自定義消息的設置語法與測試用例超時使用的語法相同。若是未提供自定義消息，Keyword timeout <time> exceeded則在發生超時時使用默認錯誤消息。

用戶關鍵字超時示例
關鍵詞	行動	論據	論據
計時關鍵字	[文檔]	只設置超時值	而不是自定義消息。
[時間到]	1分42秒
作一點事
作其餘事情

超時包裝	[參數]	@ {} ARGS
[文檔]	這個關鍵字是一個包裝	這會給另外一個關鍵字增長一個超時。
[時間到]	2分鐘	原始關鍵字沒有在2分鐘內完成
原始關鍵字	@ {} ARGS

用戶關鍵字超時在執行該用戶關鍵字時適用。若是整個關鍵字的總時間大於超時值，則中止當前執行的關鍵字。用戶關鍵字超時也適用於測試用例拆解期間，而測試超時則不適用。

若是測試用例和它的一些關鍵字（或者幾個嵌套的關鍵字）都有一個超時，那麼活動超時是剩下最少的時間。

警告

在其餘地方使用Python 2.5時，使用超時可能會減慢測試的執行速度。在Robot Framework 2.7超時以前，全部平臺上的全部Python版本都會減慢執行速度。

2.8.3 For循環

在測試自動化中屢次重複相同的動做是至關常見的需求。使用Robot Framework，測試庫能夠具備任何類型的循環結構，而且大部分時間循環都應該在其中實現。Robot Framework也有它本身的循環語法，例如，當須要重複來自不一樣庫的關鍵字時，它是有用的。

for循環能夠用於測試用例和用戶關鍵字。除了很是簡單的狀況外，用戶關鍵字更好，由於它們隱藏了for循環引入的複雜性。循環語法的基本語法 FOR item IN sequence是從Python派生而來，但在shell腳本或Perl中也可能有相似的語法。

正常循環

在正常循環中，一個變量是從一個值列表中分配的，每一個迭代一個值。語法開始於：FOR，其中須要冒號來將語法從普通關鍵字中分離出來。下一個單元格包含循環變量，後續單元格必須有 IN，最後的單元格包含要迭代的值。這些值能夠包含變量，包括列表變量。

for循環中使用的關鍵字位於下一行，它們必須向右縮進一個單元格。for循環結束時，縮進返回到正常或表結束。直接嵌套for循環不受支持，但能夠在for循環中使用一個用戶關鍵字，並在那裏有另外一個for循環。

簡單的循環
測試用例	行動	論據	論據	論據	參數
例1	：對於	$ {}動物	在	貓	狗
	日誌	$ {}動物
	日誌	第二關鍵字
日誌	外循環

例2	：對於	$ {VAR}	在	一	二
...	$ {3}	四	$ {}最後
	日誌	$ {VAR}

上面例1中的for循環被執行兩次，因此首先循環變量${animal}有值cat，而後 dog。該循環由兩個Log關鍵字組成。在第二個例子中，循環值被分紅兩行，循環共運行五次。

小費

若是以純文本格式文件使用循環，請記住使用反斜槓轉義縮進的單元格：

*** 測試用例 ***例1    ：對於$ { 動物}在     貓的狗        \     Log     $ { animal }     \     Log 第二個關鍵字        記錄外部循環

使用帶有列表變量的循環一般很方便。下面的例子說明了這一點，其中@{ELEMENTS}包含一個任意長的元素列表，而且關鍵字Start Element與它們一一對應。也能夠經過使用列表變量來遍歷包含列表的標量變量的值。

用於列表變量的循環
測試用例	行動	論據	論據	論據	參數
例	：對於	$ {}元素	在	@ {} ELEMENTS
	開始元素	$ {}元素

使用幾個循環變量

也能夠使用幾個循環變量。語法與正常for循環相同，但全部循環變量都列在FOR和IN之間的單元格中。能夠有任意數量的循環變量，可是數值的數量必須可以被變量的數量平分。

若是有不少值要迭代，那麼在循環變量下面組織它們一般是很方便的，以下例的第一個循環所示：

使用多個循環變量
測試用例	行動	論據	論據	論據	參數
例	：對於	$ {}指數	$ {}英語	$ {}芬蘭	在
...	1	貓	kissa
...	2	狗	koira
...	3	馬	hevonen
	作X	$ {}英語
	Y應該是	$ {}芬蘭	$ {}指數
：對於	$ {NAME}	$ {ID}	在	@{僱主}
	建立	$ {NAME}	$ {ID}

在範圍內

早期的for循環老是迭代一個序列，這也是最多見的用例。有時，執行必定次數的for循環仍然很方便，Robot Framework FOR index IN RANGE limit爲此具備特殊的語法。這個語法來源於相似的Python成語。

與其餘for循環相似，for範圍循環以：FOR開頭，循環變量在下一個單元格中。在這種格式中，只能有一個循環變量，它包含當前的循環索引。下一個單元格必須包含IN RANGE和後續的單元格循環限制。

在最簡單的狀況下，只指定循環的上限。在這種狀況下，循環索引從零開始並增長1，直到但不包括限制。也能夠給出開始和結束限制。而後索引從開始限制開始，但與簡單狀況類似地增長。最後，還能夠給出指定要使用的增量的步長值。若是步驟是否認的，則用做遞減。

從Robot Framework 2.5.5開始，能夠使用簡單的算術運算，如範圍限制的加減法。當限制用變量指定時，這是特別有用的。

在範圍的例子
測試用例	行動	論據	論據	精氨酸	精氨酸
只有上限	[文檔]	循環	值	從0開始	到9
：對於	$ {}指數	在範圍內	10
	日誌	$ {}指數

開始和結束	[文檔]	循環	值	從1	到10
：對於	$ {}指數	在範圍內	1	11
	日誌	$ {}指數

也給一步	[文檔]	循環	值	5，15，	和25
：對於	$ {}指數	在範圍內	五	26	10
	日誌	$ {}指數

消極的一步	[文檔]	循環	值	13，3，	和-7
：對於	$ {}指數	在範圍內	13	-13	-10
	日誌	$ {}指數

算術	[文檔]	算術	同	變量
：對於	$ {}指數	在範圍內	$ {VAR} +1
	日誌	$ {}指數

退出循環

一般狀況下，循環會被執行，直到全部的循環值被迭代或循環內使用的關鍵字失敗。若是須要更早地退出循環，則能夠使用BuiltIn關鍵字Exit For Loop和Exit For Loop If來完成此操做。它們break 在Python，Java和許多其餘編程語言中的工做方式相似。

退出For循環和退出For循環若是關鍵字能夠直接在for循環中或循環使用的關鍵字中使用。在這兩種狀況下，循環後測試執行都會繼續。在for循環以外使用這些關鍵字是錯誤的。

退出for循環的例子
測試用例	行動	論據	論據	論據
退出示例	$ {}文本=	設置變量	$ {EMPTY}
：對於	$ {VAR}	在	一	二
	運行關鍵字若是	'$ {var}'=='two'	退出循環
	$ {}文本=	設置變量	$ {文本} $ {VAR}
應該是平等的	$ {}文	一

在上面的例子中，能夠使用Exit For Loop If 而不是使用Exit For Loop和Run關鍵字If來運行。有關這些關鍵字的更多信息（包括更多使用示例），請參閱BuiltIn庫中的文檔。

注意

Exit For Loop關鍵字添加了Robot Framework 2.5.2和 Exit For Loop若是在2.8中。

繼續循環

除了提早退出for循環以外，還能夠在全部關鍵字執行以前繼續執行循環的下一次迭代。這能夠使用BuiltIn關鍵字Continue For Loop 和Continue For Loop來完成。若是continue在許多編程語言中工做得像語句同樣。

繼續For循環並繼續循環若是關鍵字能夠直接在for循環或循環使用的關鍵字中使用。在這兩種狀況下，該迭代中的關鍵字的其他部分都會被跳過，並繼續執行下一次迭代。若是在最後一次迭代中使用這些關鍵字，則在循環以後繼續執行。在for循環以外使用這些關鍵字是錯誤的。

繼續循環的例子
測試用例	行動	論據	論據	論據	論據
繼續例子	$ {}文本=	設置變量	$ {EMPTY}
：對於	$ {VAR}	在	一	二	三
	繼續循環若是	'$ {var}'=='two'
	$ {text} =	設置變量	$ {文本} $ {VAR}
應該是平等的	$ {}文	onethree

有關這些關鍵字的更多信息（包括使用示例），請參閱BuiltIn庫中的文檔。

注意

雙方繼續循環和持續循環若是在機器人框架2.8的溶液。

從輸出中刪除沒必要要的關鍵字

對於具備屢次迭代的循環來講，一般會建立大量的輸出並顯着增長生成的輸出和日誌文件的大小。從Robot Framework 2.7開始，能夠使用--RemoveKeywords FOR命令行選項從輸出中刪除沒必要要的關鍵字。

重複單個關鍵字

對於僅須要重複單個關鍵字的狀況，For循環可能過分。在這些狀況下，使用BuiltIn關鍵字重複關鍵字每每更容易。這個關鍵字須要一個關鍵字和多少次重複做爲參數。重複關鍵字的時間能夠有一個可選的後綴times或x 使語法更易於閱讀。

重複關鍵字示例
測試用例	行動	論據	論據	論據	論據
例	重複關鍵字	五	一些關鍵字	ARG1	ARG2
重複關鍵字	42次	個人關鍵字
重複關鍵字	$ {VAR}	另外一個KW	論據

Robot Framework也有一個特殊的語法來重複一個關鍵字。這個語法在2.0.4版本中已被棄用，而被重複使用，並在2.5版本中被刪除。

2.8.4有條件執行

通常來講，不建議在測試用例中甚至用戶關鍵字中使用條件邏輯，由於這會使得它們難以理解和維護。相反，這種邏輯應該在測試庫中，在那裏它能夠用天然的編程語言結構來實現。然而，有些條件邏輯有時候會頗有用，即便Robot Framework沒有實際的if / else結構，也有幾種方法能夠獲得相同的結果。

能夠使用變量指定用做測試用例和測試套件的設置或拆卸的關鍵字的名稱。這有助於改變它們，例如，從命令行。
該內建關鍵字運行關鍵字取關鍵詞來實際執行做爲參數，所以它能夠是一個變量。例如，變量的值能夠從早期的關鍵字動態得到，或者從命令行得到。
在內置的關鍵字投放關鍵字若是和運行關鍵字除非執行一個名爲關鍵字只有當某個表達式分別是真仍是假。它們很是適合建立簡單的if / else結構。有關示例，請參閱前者的文檔。
另外一個BuiltIn關鍵字Set Variable If能夠用來根據給定的表達式動態地設置變量。
有幾個BuiltIn關鍵字只有在測試用例或測試套件失敗或經過時才容許執行一個named關鍵字。

2.8.5並行執行關鍵字

在2.5版本以前，Robot Framework具備並行執行關鍵字的特殊語法。此功能被刪除，由於它不多使用，它歷來沒有徹底工做。

當須要並行執行時，必須在測試庫級執行，以便庫在後臺執行代碼。一般，這意味着庫須要一個關鍵字，例如Start Something來啓動執行並當即返回，另外一個關鍵字如 Get Results From Something等到結果可用並返回。有關示例，請參閱OperatingSystem庫關鍵字「啓動進程」和「讀取進程輸出」。

3執行測試用例

3.1基本用法

Robot Framework測試用例是從命令行執行的，最終的結果是默認狀況下是XML格式的輸出文件和HTML 報告和日誌。執行完成後，能夠將輸出文件合併在一塊兒，或者使用反彈工具進行後期處理。

3.1.1開始測試執行

概要

pybot | jybot | ipybot [options] data_sourcespython | jython | ipy -m robot.run [options] data_sourcespython | jython | ipy path / to / robot / run.py [options] data_sourcesjava -jar robotframework.jar [options] data_sources

測試執行一般使用pybot，jybot 或ipybot runner腳本啓動。這些腳本在其餘方面是相同的，可是第一個使用Python執行測試，第二個使用Jython，最後一個使用IronPython。或者，能夠使用 robot.run 入口點做爲模塊或使用任何解釋器的腳本，也能夠使用獨立的JAR分發。

不管執行方式如何，要執行的測試數據的路徑（或多個路徑）在命令以後做爲參數給出。此外，能夠使用不一樣的命令行選項以某種方式更改測試執行或生成的輸出。

指定要執行的測試數據

Robot Framework測試用例是在文件和目錄中建立的，而且經過將所討論的文件或目錄的路徑提供給選定的運行器腳原本執行。路徑能夠是絕對的，或者更常見的是相對於執行測試的目錄。給定的文件或目錄建立頂級測試套件，它獲得它的名字，除非與覆蓋--name選項，從文件或目錄名。下面的例子說明了不一樣的執行可能性。請注意，在這些例子中，以及本節中的其餘例子中，只使用了pybot腳本，可是其餘的執行方法也能夠相似地使用。

pybot test_cases.htmlpybot路徑/ to / my_tests /pybot c：\ robot \ tests.txt

也能夠一次給幾個測試用例文件或目錄的路徑，用空格分隔。在這種狀況下，Robot Framework自動建立頂級測試套件，指定的文件和目錄成爲其子測試套件。建立的測試套件的名稱是經過將它們與＆符號（＆）和空格鏈接在一塊兒從子套件名稱得到的。例如，下面第一個示例中的頂級套件的名稱是「個人測試和您的測試」。這些自動建立的名稱一般很是長且複雜。在大多數狀況下，最好使用--name選項來覆蓋它，以下面的第二個例子所示：

pybot my_tests.html your_tests.htmlpybot --name示例路徑/ to / tests / pattern _ *。html

3.1.2使用命令行選項

Robot Framework提供了許多命令行選項，能夠用來控制測試用例如何執行以及生成什麼輸出。本節介紹選項語法，以及實際存在的選項。在本章其餘地方討論它們如何使用。

使用選項

若是使用選項，則必須始終在運行程序腳本和數據源之間提供選項。例如：

pybot -L調試my_tests.txtpybot --include smoke --variable HOST：10.0.0.42 path / to / tests /

短時間和長期的選擇

選項老是有一個很長的名字，好比--name，最經常使用的選項也有一個簡短的名字，好比 -N。除此以外，長期選項只要是惟一的，就能夠縮短。例如，--logle DEBUG做品雖然--lo log.html沒有，由於前者只匹配 --loglevel，但後者匹配了幾個選項。在手動執行測試用例時，縮短和縮短選項是實用的，但在啓動腳本中建議使用較長的選項，由於它們更容易理解。

長選項格式是不區分大小寫的，這便於以易於閱讀的格式書寫選項名稱。例如，--SuiteStatLevel 至關於，但比更易於閱讀--suitestatlevel。

設置選項值

大多數選項都須要在選項名稱後面給出的值。短時間和長期的選項都接受與選項名稱分隔的值，如在--include tag 或中-i tag。若是選項較長，分隔符也能夠是等號，若是--include=tag選項較短，則能夠省略分隔符-itag。

有些選項能夠屢次指定。例如， --variable VAR1:value --variable VAR2:another設置兩個變量。若是屢次使用只有一個值的選項，則最後給出的值是有效的。

簡單的模式

許多命令行選項都將參數做爲簡單模式。這些像glob的圖案按照如下規則進行匹配：

* 是一個匹配任何字符串的通配符，甚至是一個空字符串。
? 是匹配任何單個字符的通配符。
除非另有說明，不然模式匹配是大小寫，空格和下劃線不敏感的。

例子：

--test示例*＃不區分大小寫，匹配名稱以「Example」開始的測試。- 包括f ?? ＃匹配以「f」或「F」開頭且長度爲三個字符的標籤進行測試。

標籤模式

大多數標籤相關選項接受參數做爲標記的圖案。他們都相同的特徵簡單的模式，但他們也支持AND， OR和NOT運營商解釋以下。這些運算符可用於將兩個或更多個別標籤或模式組合在一塊兒。

AND 要麼 &

若是全部個體模式匹配，則整個模式匹配。AND而且 &是等同的。

--include fooANDbar＃匹配包含標籤「foo」和「bar」的測試。--exclude xx＆yy＆zz＃匹配包含標籤'xx'，'yy'和'zz'的測試。

OR

整個模式匹配，若是任何我的模式匹配。

--include fooORbar＃匹配包含標籤「foo」或標籤「bar」的測試。- 排除xxORyyORzz＃匹配包含任何標籤「xx」，「yy」或「zz」的測試。

NOT

若是左側的圖案匹配，可是右側的圖案不匹配，則整個圖案匹配。若是屢次使用，則第一個以後的模式都NOT不能匹配。

--include fooNOTbar＃匹配包含標記「foo」但不標記「bar」的測試。--exclude xxNOTyyNOTzz＃匹配包含標籤'xx'但不包含標籤'yy'或標籤'zz'的測試。

雜

上述運營商也能夠一塊兒使用。運算符優先級，從最高到最低，是AND，OR和NOT。

--include xANDyORz＃匹配包含標籤'x'和'y'或標籤'z'的測試。--include xORyNOTz＃匹配包含標記「x」或「y」但不標記「z」的測試。--include xNOTyANDz＃匹配包含標籤「x」但不包含標籤「y」和「z」的測試。

注意

全部操做員都區分大小寫，而且必須用大寫字母來書寫。

注意

OR 運營商是Robot Framework 2.8.4中的新成員。

`ROBOT_OPTIONS`和`REBOT_OPTIONS`環境變量

環境變量ROBOT_OPTIONS和REBOT_OPTIONS可分別用於指定測試執行和結果後處理的默認選項。選項及其值必須定義爲空格分隔的列表，而且它們放置在命令行上任何顯式選項的前面。這些環境變量的主要用例是爲某些選項設置全局默認值，以免每次運行測試或使用重複使用時都須要重複這些值。

export ROBOT_OPTIONS = 「--critical regression --tagdoc mytag：Example_doc」pybot tests.txt導出REBOT_OPTIONS = 「--reportbackground綠色：黃色：紅色」rebot --name示例output.xml

注意

在Robot Framework 2.8.2中增長了對ROBOT_OPTIONS和REBOT_OPTIONS環境變量的支持。

3.1.3測試結果

命令行輸出

測試執行最顯着的輸出是顯示在命令行中的輸出。全部執行的測試套件和測試用例以及它們的狀態都會實時顯示在那裏。下面的例子顯示了執行一個簡單的測試套件的輸出只有兩個測試用例：

================================================== ============================示例測試套件================================================== ============================第一次測試::可能的測試文檔| PASS |-------------------------------------------------- ----------------------------第二個測試| 失敗|錯誤消息顯示在這裏================================================== ============================示例測試套件| 失敗|2個關鍵測試，1個經過，1個失敗總共2次測試，1次合格，1次失敗================================================== ============================輸出：/path/to/output.xml報告：/path/to/report.html日誌：/path/to/log.html

從Robot Framework 2.7開始，只要測試用例中的頂級關鍵字結束，控制檯上也會有一個通知。若是關鍵字經過，則使用綠點，若是失敗，則使用紅F。這些標記被寫入到行尾，當測試自己結束時，它們被測試狀態覆蓋。若是控制檯輸出重定向到文件，則寫入標記將被禁用。

生成的輸出文件

命令行輸出很是有限，一般須要單獨的輸出文件來檢查測試結果。如上例所示，默認狀況下生成三個輸出文件。第一個是XML格式，包含全部關於測試執行的信息。第二個是更高級的報告，第三個是更詳細的日誌文件。這些文件和其餘可能的輸出文件將在「不一樣的輸出文件」一節中詳細討論。

返回碼

運行腳本將總體測試執行狀態傳遞給使用返回代碼運行的系統。當執行成功啓動而且沒有嚴重測試失敗時，返回碼爲零。下表列出了全部可能的退貨代碼。

可能的返回碼
RC	說明
0	全部關鍵測試都經過了
1-249	返回的關鍵測試數量失敗。
250	250個或更多嚴重故障。
251	幫助或版本信息打印。
252	無效的測試數據或命令行選項。
253	測試執行由用戶中止。
255	意外的內部錯誤。

返回代碼應該在執行後始終易於使用，這樣能夠很容易地自動肯定整體執行狀態。例如，在bash shell中，返回碼是特殊變量$?，在Windows中是%ERRORLEVEL% 變量。若是您使用一些外部工具來運行測試，請參閱其文檔以瞭解如何獲取返回碼。

從Robot Framework 2.5.7開始，即便使用--NoStatusRC命令行選項發生嚴重故障，也能夠將返回碼設置爲0 。例如，在能夠肯定測試執行的整體狀態以前須要後處理結果的持續集成服務器中，這多是有用的。

注意

一樣的返回碼也用於rebot。

執行期間的錯誤和警告

在測試執行過程當中，可能會出現意想不到的問題，例如沒法導入庫或資源文件或不推薦使用的關鍵字。根據嚴重程度的不一樣，這些問題被分類爲錯誤或警告，並寫入控制檯（使用標準錯誤流），在日誌文件中單獨的「 測試執行錯誤」部分中顯示，也寫入Robot Framework本身的系統日誌中。一般這些錯誤是由Robot Framework核心生成的，可是庫能夠使用日誌級別的WARN來編寫警告。下面的例子說明了錯誤和警告在日誌文件中的樣子。

20090322 19：58：42.528	錯誤	第2行元素表中的「設置」文件中的「/home/robot/tests.html」文件錯誤：資源文件「resource.html」不存在
20090322 19：58：43.931	警告	關鍵字「SomeLibrary.Example關鍵字」已被棄用。改成使用關鍵字「其餘關鍵字」。

3.1.4轉義複雜的字符

因爲空格用於將選項彼此分開，因此在選項值中使用它們是有問題的。一些選項，如 --name，自動將下劃線轉換爲空格，可是其餘空格必須轉義。另外，不少特殊字符在命令行上使用起來很複雜。由於用反斜槓或引用這些值來轉義複雜的字符並不老是奏效，Robot Framework有它本身的通用轉義機制。另外一種可能性是使用參數文件，其中能夠用純文本格式指定選項。這兩種機制在執行測試和後處理輸出時都有效，並且一些外部支持工具具備相同或類似的功能。

在Robot Framework的命令行轉義機制中，有問題的字符被自由選擇的文本轉義。要使用的命令行選項是--escape（-E），它採用格式的參數what:with，其中what是要轉義的字符的名稱，是用於轉義 with的字符串。下表列出了能夠轉義的字符：

可用的轉義
字符	名稱使用	字符	名稱使用
＆	功放	（	paren1
「	者	）	paren2
@	在	％	百分
\	bslash	\|	管
：	結腸	？	尋求
，	逗號	「	QUOT
{	curly1	;	SEMIC
}	curly2	/	削減
$	美圓	空間
！	exclam	[	square1
>	GT	]	square2
＃	哈希	*	星
<	LT

如下示例使語法更清晰。在第一個示例中，元數據X獲取值Value with spaces，在第二個示例中，變量${VAR}分配給 "Hello, world!"：

--escape空間：_ --metadata X：Value_with_spaces-E space：SP -E quot：QU -E逗號：CO -E exclam：EX -v VAR：QUHelloCOSPworldEXQU

請注意，全部給定的命令行參數（包括測試數據的路徑）都會被轉義。所以須要仔細選擇轉義字符序列。

3.1.5參數文件

參數文件容許將所有或部分命令行選項和參數放置到外部文件中，以供讀取。這能夠避免在命令行上出現問題的字符問題。若是須要大量選項或參數，則參數文件也會阻止命令行上使用的命令過長。

參數文件與--argumentfile（-A）選項以及可能的其餘命令行選項一塊兒使用。

參數文件語法

參數文件能夠包含命令行選項和測試數據的路徑，每行一個選項或數據源。支持短時間和長期期權，但建議使用後者，由於它們更容易理解。參數文件能夠包含任何字符而不會轉義，但行首和尾部的空格將被忽略。此外，以散列標記（＃）開頭的空行和行將被忽略：

--doc這是一個例子（「特殊字符」能夠！）- 元數據X：帶空格的值- 變量VAR：你好，世界！＃這是一條評論路徑/要/個人/測試

在上面的例子中，選項和它們的值之間的分隔符是單個空格。在Robot Framework 2.7.6及更新版本中，能夠使用等號（=）或任意數量的空格。舉例來講，如下三行是相同的：

 - 一個例子--name =一個例子- 一個例子

若是參數文件包含非ASCII字符，則必須使用UTF-8編碼進行保存。

使用參數文件

參數文件能夠單獨使用，以便它們包含測試數據的全部選項和路徑，或者包含其餘選項和路徑。當一個參數文件和其餘參數一塊兒使用時，它的內容被放置到參數文件選項所在的相同位置的原始參數列表中。這意味着參數文件中的選項能夠覆蓋以前的選項，而選項以後的選項能夠覆蓋它們。能夠屢次使用--argumentfile選項，甚至能夠遞歸使用：

pybot --argumentfile all_arguments.txtpybot --name示例--argumentfile other_options_and_paths.txtpybot --argumentfile default_options.txt --name示例my_tests.htmlpybot -A first.txt -A second.txt -A third.txt tests.txt

從標準輸入讀取參數文件

從Robot Framework 2.5.6開始，STDIN 能夠使用特殊參數文件名從標準輸入流而不是文件讀取參數。這在使用腳本生成參數時很是有用：

generate_arguments.sh | pybot --argumentfile STDINgenerate_arguments.sh | pybot --name示例--argumentfile STDIN tests.txt

3.1.6獲取幫助和版本信息

在執行測試用例和後處理輸出時，能夠經過選項--help（-h）得到命令行幫助。這些幫助文本有一個簡短的概述，並簡要介紹可用的命令行選項。

全部運行腳本也支持使用--version選項獲取版本信息。這些信息還包含Python或Jython版本以及平臺類型：

$ pybot --versionRobot Framework 2.7（linux2上的Python 2.6.6）$ jybot --versionRobot Framework 2.7（java1.6.0_21上的Jython 2.5.2）C：\> rebot --versionRebot 2.7（win32上的Python 2.7.1）

3.1.7建立啓動腳本

測試用例一般由持續集成系統或其餘機制自動執行。在這種狀況下，須要有一個用於啓動測試執行的腳本，而且還可能以某種方式爲後處理輸出。當手動運行測試時，相似的腳本也頗有用，特別是若是須要大量的命令行選項或者設置測試環境很複雜。

在類UNIX環境中，shell腳本爲建立自定義啓動腳本提供了一個簡單而強大的機制。Windows批處理文件也能夠使用，但它們更加有限，一般也更復雜。一個獨立於平臺的替代方案是使用Python或其餘一些高級編程語言。無論語言如何，建議使用長選項名稱，由於它們比短名稱更易於理解。

在第一個示例中，使用不一樣的瀏覽器執行相同的Web測試，而後將結果合併。這對於shell腳原本說很簡單，由於實際上您只須要列出所需的命令：

＃！/斌/慶典pybot  - 變量瀏覽器：Firefox  - 名稱Firefox  - 日誌無 - 報告無 - 輸出/ fx.xml登陸pybot  - 變量瀏覽器：IE  - 名稱IE  - 日誌無 - 報告無 - 輸出/ ie.xml登陸rebot --name登陸--outputdir out --output login.xml out / fx.xml out / ie.xml

用Windows批處理文件實現上面的例子也不是很複雜。最重要的是要記住，由於pybot和rebot是做爲批處理文件實現的，因此在從另外一個批處理文件運行時必須使用call。不然，執行將在第一批文件完成時結束。

@ echo  off call pybot --variable BROWSER：Firefox --name Firefox --log none --report none --output out \ fx.xml login call pybot --variable BROWSER：IE --name IE --log none  -報告沒有 - 輸出\ ie.xml登陸 調用重定向 - 名稱登陸--outputdir出--output login.xml出\ fx.xml出\ ie.xml

在下面的例子中，lib目錄下的jar文件在開始執行測試以前被放入CLASSPATH中。在這些示例中，啓動腳本要求提供執行的測試數據的路徑做爲參數。即便已經在腳本中設置了一些選項，也能夠自由使用命令行選項。全部這些使用bash都是至關直接的：

＃！/斌/慶典cp =。用於 lib / *。jar中的jar; 作cp = $ cp：$ jar done export CLASSPATH = $ cpjybot --ouputdir / tmp / logs --suitestatlevel 2 $ *

使用Windows批處理文件來實現這一點稍微複雜一些。困難的部分是在For循環中設置包含所需JAR的變量，由於某些緣由，若是沒有輔助函數，這是不可能的。

@ 回聲 了設置 CP =。對於 %%罐子中（LIB \ * JAR）就（     叫 ：set_cp  %%罐子）設置 CLASSPATH = ％CP％jybot --ouputdir c：\ temp \ logs --suitestatlevel 2％*goto  ：eof:: Helper在for循環中設置變量：set_cp     set  CP = ％CP％ ; ％1 轉到 ：eof

修改Java啓動參數

有時使用Jython時，須要更改Java啓動參數。最多見的用例是增長JVM最大內存大小，由於當輸出很是大時，默認值可能不足以建立報告和日誌。有幾種方法來配置JVM選項：

直接修改Jython啓動腳本（jython shell腳本或 jython.bat批處理文件）。這是一個永久的配置。
設置JYTHON_OPTS環境變量。這能夠在操做系統級別永久完成，也能夠在自定義啓動腳本中執行。
將所需的Java參數-J選項傳遞給Jython啓動腳本，將其傳遞給Java。使用直接入口點時，這特別容易：
```
jython -J-Xmx1024m -m robot.run some_tests.txt
```

3.1.8調試問題

測試用例可能會失敗，由於被測系統沒法正常工做，在這種狀況下，測試發現了一個錯誤，或者由於測試自己是錯誤的。在命令行輸出和報告文件中顯示瞭解釋失敗的錯誤消息，有時單獨的錯誤消息足以查明問題。可是，更多的狀況是，不須要日誌文件，由於它們還有其餘日誌消息，並顯示哪一個關鍵字實際上失敗了。

當測試的應用程序致使失敗時，錯誤消息和日誌消息應該足以理解是什麼引發的。若是不是這樣，測試庫不能提供足夠的信息，須要增強。在這種狀況下，手動運行相同的測試，若是可能的話，也可能會揭示更多關於這個問題的信息。

測試用例自己或關鍵字引發的故障有時很難調試。例如，若是錯誤消息告訴用關鍵字的參數數量錯誤，修復問題顯然很容易，可是若是關鍵字丟失或以意想不到的方式失敗，找到根本緣由可能會更困難。查找更多信息的第一個地方是日誌文件中的執行錯誤部分。例如，關於失敗的測試庫導入的錯誤能夠很好地解釋爲何因爲缺乏關鍵字而致使測試失敗。

若是日誌文件默認狀況下不提供足夠的信息，則能夠使用較低的日誌級別執行測試。例如，回溯顯示代碼中發生故障的位置是使用DEBUG級別記錄的，而且當問題出如今單個關鍵字中時，這些信息是無價的。

若是日誌文件仍然沒有足夠的信息，啓用系統日誌並查看它提供的信息是一個好主意。也能夠在測試用例中添加一些關鍵字來查看正在發生的事情。特別是BuiltIn關鍵字日誌和日誌變量是有用的。若是沒有其餘的工做，老是能夠從郵件列表或其餘地方搜索幫助。

使用Python調試器（pdb）

也能夠使用Python標準庫中的pdb模塊設置斷點並交互式地調試正在運行的測試。經過插入來調用pdb的典型方法

導入 pdb ;  pdb 。set_trace （）

然而，在想要打入調試器的位置，Robot Framework沒法正常工做，由於標準輸出流在關鍵字執行期間被重定向。相反，您能夠使用如下內容：

import  sys ， pdb ;  pdb 。PDB （標準輸出= SYS 。__stdout__ ）。set_trace （）

3.2測試執行

本節描述如何執行從解析的測試數據建立的測試套件結構，如何在失敗後繼續執行測試用例，以及如何優雅地中止整個測試的執行。

3.2.1執行流程

執行套件和測試

測試用例老是在測試套件中執行。從測試用例文件建立的測試套件直接進行測試，而從目錄建立的套件具備兒童測試套件，該測試套件具備測試或其子套件。默認狀況下，在執行套件中的全部測試運行，但也能夠選擇測試使用的選項--test，--suite，--include和--exclude。不包含測試的套件將被忽略。

執行從頂層測試套件開始。若是套件有測試，它們將逐個執行，若是套件有套件，則按深度優先順序遞歸執行。當一個單獨的測試用例被執行時，它所包含的關鍵字將按順序運行。正常狀況下，當前測試的執行結束，若是任何關鍵字失敗，但它也有可能在失敗後繼續。下面的章節將討論確切的執行順序以及可能的設置和拆卸對執行的影響。

設置和拆解

能夠在測試套件，測試用例和用戶關鍵字級別上使用安裝和拆卸。

套房設置

若是一個測試套件有一個設置，它將在其測試和子套件以前執行。若是套件設置經過，測試執行繼續正常。若是失敗，套件及其子套件包含的全部測試用例都被標記爲失敗。子測試套件中的測試和可能的套件設置和拆卸不會執行。

套件設置一般用於設置測試環境。由於若是套件安裝失敗，測試不運行，因此很容易使用套件設置來驗證環境處於能夠執行測試的狀態。

套房拆解

若是一個測試套件被拆除，它將在全部的測試用例和子套件以後執行。不管測試狀態如何，即便匹配套件設置失敗，套件拆卸也會執行。若是套件拆卸失敗，套件中的全部測試都會在報告和日誌中標記爲失敗。

拆解套件主要用於執行後清理測試環境。爲確保完成全部這些任務，即便其中一些失敗，也會執行拆卸中使用的全部關鍵字。

測試設置

在測試用例的關鍵字以前執行可能的測試設置。若是設置失敗，則不執行關鍵字。測試設置的主要用途是爲特定測試用例設置環境。

測試拆解

在測試用例執行完畢後，可能的測試拆卸被執行。不管測試狀態如何，測試設置失敗都會執行。

相似於套件拆解，拆卸測試主要用於清理活動。即便他們的一些關鍵字失敗，它們也被徹底執行。

關鍵字拆解

用戶關鍵字不能有設置，可是能夠有與其餘拆解同樣的拆解。關鍵字teardowns在關鍵字被執行後運行，不然，無論狀態如何，而且即便他們的一些關鍵字失敗，它們也會被徹底執行。

執行順序

測試套件中的測試用例按照在測試用例文件中定義的順序執行。更高級別的測試套件中的測試套件將根據文件或目錄名以不區分大小寫的字母順序執行。若是從命令行給出多個文件和/或目錄，則按照給定的順序執行它們。

若是須要在目錄中使用特定的測試套件執行順序，則能夠將01和 02等前綴添加到文件和目錄名稱中。若是生成的測試套件名稱與套件的基本名稱用兩個下劃線分隔，則這些前綴不包括在生成的測試套件名稱中：

01__my_suite.html  - >個人套房02__another_suite.html  - >另外一套房

若是套件內測試套件的字母順序有問題，一個很好的解決方法是按要求的順序分別給出它們。這很容易致使過長的啓動命令，但參數文件容許很好地列出每行一個文件的文件。

也能夠使用--randomize選項隨機化執行順序。

經過執行

一般狀況下，若是全部包含的關鍵字都被執行而且沒有失敗，則認爲測試用例，設置和拆卸被認爲經過。從Robot Framework 2.8開始，還能夠使用BuiltIn關鍵字 Pass Execution和Pass Execution若是以PASS狀態中止執行並跳過剩餘的關鍵字。

如何經過執行和經過執行若是在不一樣的狀況下行爲以下：

當用於任何設置或拆卸（套件，測試或關鍵字）時，這些關鍵字將經過該設置或拆卸。已啓動的關鍵字可能被拆除。測試執行或狀態不受影響。
當在設置或拆卸以外的測試用例中使用時，關鍵字將經過特定的測試用例。可能的測試和關鍵字teardowns被執行。
使用這些關鍵字以前發生的可能的繼續性故障以及以後執行的拆解失敗將會使執行失敗。
必須給出一個解釋消息，說明執行被中斷的緣由，還能夠修改測試用例標籤。有關更多詳細信息和用法示例，請參閱這些關鍵字的文檔。

在測試過程當中經過執行，安裝或拆卸應謹慎使用。在最糟糕的狀況下，會致使測試跳過全部可能在測試應用程序中發現問題的部分。在執行不能繼續執行外部因素的狀況下，經過測試用例並使其不關鍵一般更安全。

3.2.2繼續失敗

一般狀況下，當任何關鍵字失敗時，測試用例會當即中止。此行爲縮短了測試執行時間，並防止後續關鍵字掛起或以其餘方式致使被測系統處於不穩定狀態時出現問題。這有一個缺點，就是後面的關鍵字每每會給出關於系統狀態的更多信息。

在Robot Framework 2.5以前，處理故障的惟一方法是不要當即終止測試執行，而是使用BuiltIn關鍵字運行關鍵字和忽略錯誤以及運行關鍵字和指望錯誤。爲此目的使用這些關鍵字每每會增長測試用例的複雜性，並且在Robot Framework 2.5中添加了如下功能，以便在故障發生後繼續執行。

關鍵字的特殊失敗

庫關鍵字使用異常報告失敗，而且能夠使用特殊異常來告訴核心框架，不管失敗如何，執行均可以繼續。測試庫API章節解釋瞭如何建立這些異常。

當測試結束而且出現一個或多個可持續的故障時，測試將被標記爲失敗。若是有多個失敗，則會在最終錯誤消息中枚舉全部錯誤：

發生了幾個故障：1）第一個錯誤信息。2）第二個錯誤消息...

若是繼續失敗後發生正常故障，測試執行也會結束。一樣在這種狀況下，全部的失敗將被列在最終的錯誤信息中。

可能分配給變量的失敗關鍵字的返回值始終是Python None。

運行關鍵字並繼續失敗關鍵字

BuiltIn關鍵字運行關鍵字並繼續失敗容許將任何故障轉換爲可繼續的故障。這些失敗是由框架徹底相同的方式處理源於圖書館關鍵字的可持續失敗。

執行繼續在teardowns自動

爲確保全部的清理活動都獲得了保證，在測試和套件拆卸過程中將自動啓用繼續失敗模式。實際上這意味着在拆解中，全部級別的關鍵字老是被執行。

全部頂級關鍵字都在測試有模板時執行

使用測試模板時，老是執行全部的數據行，以確保測試全部不一樣的組合。在這種使用方式中，繼續限於頂級關鍵字，而且在其內部，若是存在不可持續的故障，則執行正常結束。

3.2.3優雅地中止測試執行

有時須要在全部測試完成以前中止測試執行，可是要建立日誌和報告。下面將解釋如何完成這一點的不一樣方法。在全部這些狀況下，其他的測試用例都被標記爲失敗。

注意

這些功能大部分都是Robot Framework 2.5中的新功能。

緊迫 `Ctrl-C`

Ctrl-C在運行測試的控制檯中按下時中止執行。在Python上運行測試時，當即中止執行，可是使用Jython只會在當前執行的關鍵字結束後才結束。

若是Ctrl-C再次按下，則執行當即結束，不會建立報告和日誌。

使用信號

在相似Unix的機器上，能夠使用信號INT和終止測試執行TERM。這些信號能夠使用kill命令從命令行發送，發送信號也能夠很容易地自動化。

對於Jython，信號與按下有相同的限制Ctrl-C。一樣，第二個信號強制中止執行。

使用關鍵字

執行也能夠經過執行的關鍵字來中止。爲此，有一個單獨的致命錯誤 BuiltIn關鍵字，而且自定義關鍵字在失敗時能夠使用致命異常。

當第一個測試用例失敗時中止

若是使用選項--exitonfailure，若是任何關鍵測試失敗，測試執行當即中止。其他的測試也被標記爲失敗。

注意

在Robot Framework 2.8以前，這個行爲是經過使用--runmode exitonfailure來實現的。選項--runmode 已在2.8中被棄用，未來將被刪除。

中止解析或執行錯誤

Robot Framework能夠將失敗的關鍵字致使的失敗與例如無效設置致使的錯誤或測試庫導入失敗分開。默認狀況下，這些錯誤被報告爲測試執行錯誤，但錯誤自己不會使測試失敗，不然會影響執行。可是，若是使用 --exitonerror選項，則全部此類錯誤都將被視爲致命錯誤，並中止執行，所以剩餘的測試將被標記爲失敗。在執行甚至開始以前遇到的解析錯誤，這意味着沒有測試實際運行。

注意

--Exitonerror是Robot Framework 2.8.6中的新功能。

拆卸拆卸

默認狀況下，即便使用上述方法之一中止測試執行，也會執行已啓動的測試和套件的拆除。這容許清理活動運行，無論執行結束如何。

當使用--skipteardownonexit選項中止執行時也能夠跳過拆卸。例如，若是清理任務須要很長時間，這可能頗有用。

注意

在Robot Framework 2.8以前，這個行爲是經過使用--runmode skipteardownonexit來實現的。選項--runmode 已在2.8中被棄用，未來會被刪除。

3.3後處理輸出

在測試執行過程當中生成的XML輸出文件能夠在以後由做爲Robot Framework必不可少的一部分的rebot工具進行後期處理。它在測試執行期間生成測試報告和日誌時自動使用，而且單獨使用它能夠建立自定義報告和日誌以及合併和合並結果。

3.3.1使用`rebot`工具

概要

rebot | jyrebot | ipyrebot [options] robot_outputspython | jython | ipy -m robot.rebot [options] robot_outputspython | jython | ipy path / to / robot / rebot.py [options] robot_outputsjava -jar robotframework.jar rebot [options] robot_outputs

rebot runner腳本運行在Python上，但也有分別運行在Jython和IronPython上的jyrebot 和ipyrebot runner腳本。推薦使用rebot，由於它比替代品快得多。除了使用這些腳本以外，能夠使用 robot.rebot 入口點做爲模塊或使用任何解釋器的腳本，也能夠使用獨立的JAR分發。

指定選項和參數

使用rebot的基本語法與開始測試執行時的基本語法徹底相同，並且大多數命令行選項也是相同的。主要的區別是rebot的參數是 XML輸出文件而不是測試數據文件或目錄。

返回代碼與`rebot`

來自rebot的返回代碼與運行測試時的返回代碼徹底相同。

3.3.2建立不一樣的報告和日誌

您能夠使用rebot來建立在測試執行期間自動建立的相同報告和日誌。固然，建立徹底相同的文件是不明智的，可是，例如，一個報告包含全部測試用例，而另外一個報告只包含一些測試子集多是有用的：

rebot output.xmlrebot path / to / output_file.xmlrebot --include smoke --name Smoke_Tests c：\ results \ output.xml

另外一個常見用法是在運行測試時建立輸出文件（能夠禁用日誌和報告生成 --log NONE --report NONE），以及稍後生成日誌和報告。例如，測試能夠在不一樣的環境中執行，輸出到中心位置的文件以及在那裏建立的報告和日誌。若是在Jython上運行測試時生成報告和日誌花費了大量時間，這種方法也能夠很好地工做。禁用日誌和報告生成並稍後使用從新生成能夠節省大量時間並使用更少的內存。

3.3.3組合輸出

rebot的一個重要特色是可以結合不一樣測試執行輪次的輸出。例如，此功能能夠在不一樣的環境下運行相同的測試用例，並從全部輸出生成整體報告。合併輸出很是簡單，只須要輸出幾個輸出文件便可：

rebot output1.xml output2.xmlrebot輸出/ *。xml

當輸出結合時，會建立一個新的頂級測試套件，以便給定輸出文件中的測試套件是其子套件。當多個測試數據文件或目錄被執行時，這種方式也是相同的，在這種狀況下，頂級測試套件的名稱是經過用＆符號（＆）和空格鏈接子代名稱來建立的。這些自動生成的名稱並非那麼好，使用--name來提供更有意義的名稱一般是個好主意：

rebot --name Browser_Compatibility firefox.xml opera.xml safari.xml ie.xmlrebot --include smoke --name Smoke_Tests c：\ results \ *。xml

3.3.4合併輸出

若是相同的測試被從新執行或單個測試套件被分段執行，則結合上面討論的結果建立了沒必要要的頂層測試套件。在這些狀況下，最好是合併結果。合併是經過使用--merge選項來完成的，它改變了rebot如何組合兩個或多個輸出文件。這個選項自己沒有參數，全部其餘的命令行選項也能夠正常使用：

rebot --merge --name示例 - 關鍵迴歸original.xml merged.xml

下面討論兩個主要的用例，說明實際中的合併工做。

合併從新執行的測試

一般須要從新執行一個測試子集，例如，在被測系統或測試自己中修復一個bug後。這能夠經過如下方式實現選擇測試用例的名稱（--test和 --suite選項），標籤（--include和--exclude），或由先前的狀態（--rerunfailed）。

將從新執行結果與使用默認組合輸出方法的原始結果結合起來效果不佳。主要的問題是你獲得單獨的測試套件，並可能已經固定的故障也顯示出來。在這種狀況下，最好使用--merge（-R）選項來告訴rebot合併結果。實際上這意味着來自後面的測試運行的測試替換原來的測試。這個用法最好用一個實際的例子來講明 - 使用 --rerunfailed和 - 合併在一塊兒：

pybot  - 輸出original.xml測試＃首先執行全部的測試pybot --rununfailed original.xml --output rerun.xml tests＃而後從新執行失敗rebot --merge original.xml rerun.xml＃最後合併結果

合併測試的消息包含結果已被替換的註釋。該消息還顯示測試的舊狀態和消息。

合併結果必須始終具備相同的頂級測試套件。在原始輸出中找不到的合併輸出中的測試和套件被添加到結果輸出中。下一節將討論實際操做。

注意

合併從新執行的結果是Robot Framework 2.8.4中的一個新特性。在Robot Framework 2.8.6以前，跳過合併輸出中的新測試或套件，並使用現今不推薦使用的--rerunmerge選項進行合併。

合併套件執行的部分

--merge選項的另外一個重要用例是合併運行測試套件時獲得的結果，例如使用--include 和--exclude選項：

pybot --include smoke --output smoke.xml測試＃首先運行一些測試pybot  - 排除smoke  - 輸出others.xml測試＃而後運行其餘rebot --merge smoke.xml others.xml＃最後合併結果

合併這樣的輸出時，結果輸出包含從全部給定的輸出文件中找到的全部測試和套件。若是從多個輸出中發現一些測試，則最新的結果將取代以前部分中介紹的較早的結果。此外，這種合併策略要求頂級測試套件在全部輸出中都是相同的。

3.4配置執行

本節介紹可用於配置測試執行或後處理輸出的不一樣命令行選項。下一節將討論與生成的輸出文件相關的選項。

3.4.1選擇測試用例

Robot Framework提供了幾個命令行選項來選擇要執行的測試用例。使用反彈工具後處理輸出時，也能夠使用相同的選項。

經過測試套件和測試用例名稱

能夠使用命令行選項--suite（-s）和--test（-t）分別選擇測試套件和測試用例。這兩個選項均可以屢次使用來選擇幾個測試套件或案例。這些選項的參數是不區分大小寫和空間的，也能夠有簡單的匹配多個名字的模式。若是同時使用--suite和 --test選項，則僅選擇具備匹配名稱的匹配套件中的測試用例。

 - 測試例子- 測試mytest  - 測試你最喜歡的- 測試例子*- 測試mysuite.mytest--test * .suite.mytest- 例子 -  ??--suite mysuite  - 測試mytest  - 測試你的*

注意

使用長名稱（例如mysuite.mytest）選擇測試用例與Robot Framework 2.5.6及更新版本一塊兒使用。

使用--suite選項或多或少與只執行適當的測試用例文件或目錄相同。一個主要的好處是能夠根據其父套件選擇套件。這個語法是指定用點分隔的父和子套件名稱。在這種狀況下，能夠執行父組件的設置和拆卸。

 - 父母親--suite myhouse.myhousemusic --test jack *

使用--test選項選擇單個測試用例在建立測試用例時很是實用，但在自動運行測試時很是有限。該--suite選項能夠在這種狀況下是有用的，但在通常狀況下，經過標籤名稱選擇測試用例更加靈活。

按標籤名稱

能夠使用--include（-i）和--exclude（-e）選項分別包含和排除測試用例的標籤名稱。若是使用--include選項，則只有具備匹配標記的測試用例被選中，而具備匹配標記的--exclude選項測試用例則不是。若是二者都使用，則只選擇與前一個選項匹配的標籤，而不選擇與後者匹配的標籤。

 - 包括例子- 排除not_ready- 包括迴歸 - 排除long_lasting

不管--include和--exclude能夠屢次使用，以匹配多個標籤。在這種狀況下，若是測試的標籤與任何包含的標籤匹配，而且沒有與任何排除的標籤匹配的標籤，則選擇一個測試。

除了指定標籤的徹底匹配，則有可能使用標記的模式，其中*和?是通配符和 AND，OR和NOT運營商能夠被用於單個標籤或圖案組合在一塊兒：

 - 包括功能4？- 排除錯誤*- 包括fooandbar- 排除xxORyyORzz- 包括fooNOTbar

經過標籤選擇測試案例是一個很是靈活的機制，並容許許多有趣的可能性

在其餘測試以前執行的測試子集（一般稱爲煙霧測試）能夠被標記smoke並執行--include smoke。
未完成的測試能夠被委託給使用標籤的版本控制，例如 not_ready和從測試執行中排除 --exclude not_ready。
sprint-<num>在 <num>指定當前sprint的編號的狀況下，能夠使用標記測試，而且在執行全部測試用例以後，能夠生成一個單獨的報告，僅包含某個特定sprint的測試（例如rebot --include sprint-42 output.xml）。

從新執行失敗的測試用例

命令行選項--rerunfailed（-R）能夠用來從早期的輸出文件中選擇全部失敗的測試以從新執行。例如，若是運行全部測試須要花費大量時間，而且想要反覆修復失敗的測試用例，則此選項很是有用。

pybot測試＃首先執行全部測試pybot --rerunfailed output.xml測試＃而後從新執行失敗

在這個選項後面，這個選項會選擇失敗的測試，由於它們是用--test選項單獨選擇的。它能夠經過進一步微調所選測試的名單--test，--suite， --include和--exclude選項。

使用不是源自執行如今運行的相同測試的輸出會致使未定義的結果。另外，若是輸出不包含失敗的測試，則是錯誤的。使用特殊值NONE做爲輸出與徹底不指定此選項相同。

小費

從新執行結果和原始結果能夠使用--merge命令行選項合併在一塊兒。

注意

從新執行失敗的測試是Robot Framework 2.8中的一項新功能。之前的機器人框架2.8.4該選項被命名爲 - 運行失敗。舊的名字仍然有效，但未來會被刪除。

當沒有測試匹配選擇

默認狀況下，當沒有測試符合選擇標準時，測試執行失敗，出現以下錯誤：

[錯誤]包含「xxx」的套件「示例」不包含測試用例。

因爲沒有生成輸出，若是執行測試並自動處理結果，則此行爲可能會有問題。幸運的是，在這種狀況下，還能夠使用命令行選項--RunEmptySuite來強制執行套件。結果正常輸出被建立，但顯示零執行測試。當一個空目錄或不包含測試的測試用例文件被執行時，一樣的選項也能夠用來改變行爲。

處理帶有rebot的輸出文件時也會出現相似的狀況。可能沒有測試與使用的過濾標準匹配，或者輸出文件不包含任何開始的測試。默認狀況下，在這些狀況下執行 rebot失敗，可是它有一個單獨的 --ProcessEmptySuite選項，能夠用來改變行爲。實際上，在運行測試時，此選項與--RunEmptySuite的工做方式相同。

注意

--RunEmptySuite選項被添加到2.7.2的Robot Framework 2.6和--ProcessEmptySuite中。

3.4.2設置臨界點

測試執行的最終結果是基於關鍵測試肯定的。若是單個關鍵測試失敗，整個測試運行被認爲是失敗的。另外一方面，非關鍵測試用例可能會失敗，總體狀態仍然被認爲是合格的。

全部的測試用例在默認狀況下都被認爲是關鍵的，可是這能夠經過--critical（-c）和--noncritical（-n）選項來改變。這些選項指定哪些測試關鍵的基礎上的標籤，相似於--include和 --exclude用於選擇由標籤測試。若是隻使用 - 關鍵字，那麼具備匹配標籤的測試用例就很是重要。若是隻有--noncritical使用，不匹配的標籤測試是相當重要的。最後，若是二者都被使用，那麼僅使用關鍵標籤進行測試，可是沒有非關鍵標籤是相當重要的。

不管--critical和--noncritical也支持一樣的標記圖案爲--include和--exclude。這意味着，模式匹配的狀況下，空間和下劃線不敏感的，*而且? 被支撐爲通配符，和AND，OR而且NOT 運營商能夠被用於建立組合花樣。

 - 臨界迴歸- 非重要的not_ready- 關鍵的iter- *  - 關鍵要求 -  *  - 非關鍵要求-6

設置關鍵性的最多見用例是在測試執行中沒有準備好測試用例或測試功能仍在開發中。這些測試也能夠使用--exclude選項徹底排除在測試執行以外，但將它們包括在非關鍵測試中可讓您看到什麼時候開始經過測試。

執行測試時設置的嚴重性不存儲在任何地方。若是你想保持相同的臨界時，處理後的輸出與rebot，你須要使用--critical和/或--noncritical也與它：

＃使用rebot從執行期間建立的輸出中建立新的日誌和報告pybot  - 臨界迴歸--outputdir全部my_tests.htmlrebot --name煙霧 - 包括煙霧 - 臨界迴歸--outputdir smoke all / output.xml＃不須要使用 - 關鍵/  - 在沒有建立日誌或報告時不重要jybot --log NONE --report NONE my_tests.htmlrebot --critical feature1 output.xml

3.4.3設置元數據

設置名稱

當Robot Framework分析測試數據時，測試套件名稱是從文件和目錄名稱建立的。可是，頂級測試套件的名稱能夠經過命令行選項--name（-N）覆蓋。給定名稱中的下劃線將自動轉換爲空格，而且名稱中的單詞大寫。

設置文檔

除了在測試數據中定義文檔以外，頂層套件的文檔還能夠經過命令行提供--doc（-D）選項。給定文檔中的下劃線被轉換爲空格，而且可能包含簡單的HTML格式。

設置免費元數據

免費的測試套件元數據也能夠經過命令行--metadata（-M）給出。參數必須是格式 name:value，其中name要設置的元數據的名稱 value是其值。名稱和值中的下劃線將轉換爲空格，然後者可能包含簡單的HTML格式。此選項可能會屢次使用來設置多個元數據。

設置標籤

命令行選項--settag（-G）可用於將給定標記設置爲全部已執行的測試用例。此選項可能會屢次使用來設置多個標籤。

3.4.4調整庫搜索路徑

當測試庫被使用時，Robot Framework使用Python或Jython解釋器從系統導入實現庫的模塊。搜索這些模塊的位置稱爲 PYTHONPATH，在Jython上運行測試或使用jar分發時，也使用Java CLASSPATH。

調整庫搜索路徑以便找到庫是成功執行測試的必要條件。除了查找測試庫以外，搜索路徑還用於查找在命令行上設置的監聽器。有各類方法能夠改變 PYTHONPATH和CLASSPATH，但無論選擇的方法如何，建議使用自定義的啓動腳本。

自動在`PYTHONPATH中的`位置

Python和Jython安裝將本身的庫目錄自動放入 PYTHONPATH中。這意味着使用Python本身的打包系統打包的測試庫會自動安裝到庫搜索路徑中的一個位置。Robot Framework也把包含標準庫的目錄和執行測試的目錄放到PYTHONPATH中。

設置`PYTHONPATH`

有幾種方法能夠在系統中修改PYTHONPATH，但最多見的方法是在測試執行以前設置一個名稱相同的環境變量。Jython實際上並不正常使用PYTHONPATH 環境變量，可是Robot Framework能夠確保在其中列出的位置被添加到庫搜索路徑中，而無論解釋器如何。

設置`CLASSPATH`

CLASSSPATH與Jython一塊兒使用或使用獨立的jar時使用。

使用Jython時，最經常使用的方法是改變CLASSPATH，就像設置PYTHONPATH同樣設置一個環境變量。請注意，不是使用 CLASSPATH，即便使用Java實現庫和偵聽器，始終能夠使用Jython中的PYTHONPATH。

在使用獨立jar分發時，因爲命令不讀取CLASSPATH環境變量，CLASSPATH必須設置稍微不一樣。在這種狀況下，有兩種不一樣的方法來配置CLASSPATH，以下所示：java -jar

java -cp lib / testlibrary.jar：lib / app.jar：robotframework-2.7.1.jar org.robotframework.RobotFramework example.txtjava -Xbootclasspath / a：lib / testlibrary.jar：lib / app.jar -jar robotframework-2.7.1.jar example.txt

使用--pythonpath選項

Robot Framework還有一個單獨的命令行選項 --pythonpath（-P），用於將目錄或存檔添加到 PYTHONPATH中。多個路徑能夠用冒號（:)或屢次使用這個選項來分隔。給定的路徑也能夠是匹配多個路徑的全局模式，但一般必須轉義。

例子：

--pythonpath libs /--pythonpath /opt/testlibs:mylibs.zip:yourlibs--pythonpath mylib.jar --pythonpath lib / STAR.jar --escape star：STAR

3.4.5設置變量

變量能夠在命令行中單獨使用--variable（-v）選項或經過變量文件使用--variablefile（-V）選項來設置。變量和變量文件在單獨的章節中進行了解釋，但如下示例說明了如何使用這些選項：

 - 變量名稱：值- 可變操做系統：Linux  - 變量IP：10.0.0.42--variablefile path / to / variables.py--variablefile myvars.py：possible：arguments：這裏- 變量環境：Windows  - 變量文件c：\ resources \ windows.py

3.4.6空運

Robot Framework支持所謂的空運行模式，不然測試運行正常，可是來自測試庫的關鍵字根本不會被執行。幹運行模式可用於驗證測試數據; 若是幹運行經過，數據應該在語法上是正確的。該模式使用選項--dryrun觸發。

空運行執行可能因爲如下緣由而失敗：

使用未找到的關鍵字。

使用錯誤數量的參數的關鍵字。

使用具備無效語法的用戶關鍵字。

除了這些故障以外，還會顯示正常執行錯誤，例如，沒法解析測試庫或資源文件導入時。

注意

空運行模式不驗證變量。將來版本中可能會取消此限制。

注意

在Robot Framework 2.8以前，使用選項--runmode dryrun激活幹運行模式。選項--runmode已在2.8中被棄用，未來將被刪除。

3.4.7隨機化執行順序

測試執行順序能夠使用選項--randomize <what> [：<seed>]進行隨機化，其中<what>是如下之一：

tests: 每一個測試套件內的測試用例都是以隨機順序執行的。
suites: 全部測試套件都是以隨機順序執行的，但套件內的測試用例按照定義的順序運行。
all: 測試用例和測試套件都是以隨機順序執行的。
none: 測試和套件的執行順序都不是隨機的。該值可用於覆蓋使用 --randomize設置的較早值。

從Robot Framework 2.8.5開始，能夠給定一個自定義種子來初始化隨機生成器。若是要使用與先前相同的順序從新運行測試，這頗有用。種子是做爲--randomize格式的值的一部分給出的 <what>:<seed>，它必須是一個整數。若是沒有給出種子，它是隨機產生的。執行的頂級測試套件自動獲取名爲隨機化的元數據，該元數據告訴隨機化的內容和使用的種子。

例子：

pybot  - 隨機測試my_test.txtpybot  - 隨機大小：12345路徑/到/測試

注意

以前機器人框架2.8，隨機化是使用選項觸發 --runmode <模式>，其中<mode>或者是Random:Test， Random:Suite或Random:All。這些值的工做方式與爲--randomize匹配值的方式相同。選項--runmode已在2.8中被棄用，未來將被刪除。

3.4.8控制檯輸出

控制檯寬度

控制檯中測試執行輸出的寬度能夠使用選項--monitorwidth（-W）來設置。默認寬度是78個字符。

小費

在不少像UNIX同樣的機器上，你能夠使用$COLUMNS 像--monitorwidth $COLUMNS。

控制檯顏色

所述--monitorcolors（-C）選項用於控制是否顏色應在控制檯輸出被使用。顏色是使用ANSI顏色實現的，除了在默認狀況下使用Windows API的Windows。從Jython訪問這些API是不可能的，所以顏色不能在Windows上使用Jython。

該選項支持如下不區分大小寫的值：

auto: 將輸出寫入控制檯時啓用顏色，但在將輸出重定向到文件或其餘位置時啓用顏色。這是默認的。
on: 輸出重定向時也使用顏色。在Windows上不起做用。
ansi: 相同 on但使用在Windows ANSI色也。例如，將輸出重定向到了解ANSI顏色的程序時頗有用。Robot Framework 2.7.5中的新功能
off: 顏色被禁用。
force: 向後兼容Robot Framework 2.5.5及更早版本。不該該使用。

注意

auto在Robot Framework 2.5.6中添加了對Windows和模式的顏色支持。

控制檯標記

從Robot Framework 2.7開始，當測試用例中的頂級關鍵字結束時，控制檯上會顯示特殊標記.（成功）和 F（失敗）。這些標記容許在高級別的測試執行以後，當測試用例結束時它們被擦除。

從Robot Framework 2.7.4開始，能夠使用--monitormarkers（-K）選項配置標記的使用時間。它支持如下不區分大小寫的值：

auto: 將標準輸出寫入控制檯時啓用標記，但不將其重定向到文件或其餘位置。這是默認的。
on: 標記老是被使用。
off: 標記被禁用。

3.4.9設置監聽器

所謂的監聽器能夠用來監視測試執行。它們經過命令行選項--listener被使用，而且指定的監聽器必須與測試庫相似地位於模塊搜索路徑中。

3.5建立輸出

執行測試時會建立多個輸出文件，而且全部文件都與測試結果有關。本節討論建立了哪些輸出，如何配置它們的建立位置以及如何微調其內容。

3.5.1不一樣的輸出文件

本節介紹能夠建立哪些不一樣的輸出文件以及如何配置它們的建立位置。輸出文件是使用命令行選項進行配置的，它們將輸出文件的路徑做爲參數。能夠使用特殊的值NONE （不區分大小寫）來禁止建立特定的輸出文件。

輸出目錄

全部輸出文件均可以使用絕對路徑來設置，在這種狀況下，它們被建立到指定的位置，可是在其餘狀況下，路徑被視爲相對於輸出目錄。默認輸出目錄是從哪裏開始執行的目錄，但能夠使用--outputdir（-d）選項來更改。用這個選項設置的路徑也是相對於執行目錄而言的，固然也能夠做爲絕對路徑給出。不管如何獲取單個輸出文件的路徑，它的父目錄都是自動建立的，若是它不存在的話。

輸出文件

輸出文件包含機器可讀XML格式的全部測試執行結果。日誌，報告和xUnit文件一般是基於它們生成的，也能夠將它們組合在一塊兒，或者用Rebot進行後處理。

小費

從Robot Framework 2.8開始，生成報告和xUnit 文件做爲測試執行的一部分再也不須要處理輸出文件。運行測試時禁用日誌生成能夠節省內存。

命令行選項--output（-o）肯定相對於輸出目錄建立輸出文件的路徑。當運行測試時，輸出文件的默認名稱是output.xml。

當使用Rebot後處理輸出時，除非顯式使用--output選項，不然不會建立新的輸出文件。

從Robot Framework 2.6開始，能夠在運行具備特殊值的測試時禁止建立輸出文件NONE。在Robot Framework 2.6和2.7版本中，這個自動禁用也會建立日誌和報告文件，可是從2.8版本開始，這個再也不作了。若是不須要輸出，則應所有禁用--output NONE --report NONE --log NONE。

日誌文件

日誌文件包含有關以HTML格式執行的測試用例的詳細信息。它們具備顯示測試套件，測試用例和關鍵字詳細信息的分層結構。幾乎每次當測試結果要被詳細研究時都須要日誌文件。即便日誌文件也有統計信息，報告更適合獲取更高級別的概述。

命令行選項--log（-l）肯定建立日誌文件的位置。除非使用特殊值NONE，不然始終建立日誌文件，其默認名稱爲 log.html。

SRC / ExecutingTestCases / log_passed.png

日誌文件開始的一個例子

SRC / ExecutingTestCases / log_failed.png

一個關鍵字詳細信息可見的日誌文件示例

報告文件

報告文件包含HTML格式的測試執行結果的概述。他們有基於標籤和執行測試套件的統計數據，以及全部執行的測試用例列表。當生成報告和日誌時，報告都會連接到日誌文件，以便輕鬆導航到更詳細的信息。若是全部關鍵測試都經過，則背景色爲綠色，不然爲亮紅色，所以從報告中很容易看到總體測試執行狀態。

命令行選項--report（-r）肯定報告文件的建立位置。與日誌文件相似，除非NONE用做值，不然始終建立報告，其默認名稱爲report.html。

SRC / ExecutingTestCases / report_passed.png

成功執行測試的示例報告文件

SRC / ExecutingTestCases / report_failed.png

測試執行失敗的示例報告文件

XUnit兼容的結果文件

XUnit結果文件包含xUnit兼容XML格式的測試執行摘要。這些文件能夠用做理解xUnit報告的外部工具的輸入。例如，Jenkins持續集成服務器支持基於xUnit兼容結果生成統計信息。

小費

詹金斯還有一個獨立的機器人框架插件。

除非明確使用命令行選項--xunit（-x），不然不會建立XUnit輸出文件。這個選項須要一個到生成的xUnit文件（相對於輸出目錄）的路徑做爲一個值。

由於xUnit報告沒有非關鍵測試的概念，因此xUnit報告中的全部測試都將被標記爲合格或不合格，在關鍵測試和非關鍵測試之間沒有區別。若是這是一個問題，能夠使用--xunitskipnoncritical選項將非關鍵測試標記爲跳過。跳過的測試會以相似的格式獲得包含測試用例的實際狀態和可能的消息的消息FAIL: Error message。

注意

--xunitskipnoncritical是Robot Framework 2.8中的一個新選項。

調試文件

調試文件是在測試執行過程當中寫入的純文本文件。全部來自測試庫的消息都被寫入，以及關於開始和結束測試套件，測試用例和關鍵字的信息。調試文件可用於監視測試執行。例如，能夠使用單獨的 fileviewer.py 工具，或者在類UNIX系統中使用tail -f命令。

除非明確使用命令行選項--debugfile（-b），不然不會建立調試文件。

時間戳輸出文件

本節列出的全部輸出文件能夠使用選項--timestampoutputs（-T）自動加蓋時間戳。使用此選項時，格式中的時間戳YYYYMMDD-hhmmss會放在擴展名和每一個文件的基本名稱之間。例如，下面的示例將建立輸出文件，如 output-20080604-163225.xml和mylog-20080604-163225.html：

pybot --timestampoutputs --log mylog.html --report NONE tests.html

設置標題

日誌和報告的默認標題是經過在測試日誌或測試報告前添加頂級測試套件的名稱來生成的。能夠使用選項--logtitle和--reporttitle分別從命令行給出自定義標題。給定標題中的下劃線將自動轉換爲空格。

例：

pybot --logtitle Smoke_Test_Log --reporttitle Smoke_Test_Report --include smoke my_tests /

設置背景顏色

默認狀況下，報告文件在全部重要測試經過時都具備綠色背景，不然爲紅色背景。這些顏色能夠經過使用--reportbackground命令行選項進行自定義，該選項以冒號做爲參數分隔兩個或三個顏色：

--reportbackground藍色：紅色--reportbackground綠色：黃色：紅色--reportbackground＃00E：＃E00

若是您指定了兩種顏色，則將使用第一種顏色，而不使用默認的綠色，而使用第二種顏色而不使用默認的紅色。例如，這容許使用藍色而不是綠色來爲色盲人士更容易地分離背景。

若是您指定了三種顏色，則第一個將在全部測試成功時使用，第二個僅在非關鍵測試失敗時使用，而第二個在出現嚴重故障時使用。所以，這個功能容許在非關鍵測試失敗時使用單獨的背景顏色，例如黃色。

指定的顏色用做body 元素backgroundCSS屬性的值。該值按原樣使用，能夠是HTML顏色名稱（例如red），十六進制值（例如#F00或#FF0000）或RGB值（例如rgb(255,0,0)）。默認的綠色和紅色分別使用十六進制值#9F6和#F33。

3.5.2日誌級別

可用的日誌級別

日誌文件中的消息能夠具備不一樣的日誌級別。一些消息是由Robot Framework自己編寫的，並且執行的關鍵字能夠使用不一樣的級別記錄信息。可用的日誌級別是：

FAIL: 當關鍵字失敗時使用。只能由Robot Framework本身使用。
WARN: 用於顯示警告。它們也顯示在控制檯和日誌文件中的「測試執行錯誤」部分，但不會影響測試用例狀態。
INFO: 正常消息的默認級別。默認狀況下，該級別如下的消息不會顯示在日誌文件中。
DEBUG: 用於調試目的。例如，用於記錄庫在內部進行的操做是有用的。當關鍵字失敗時，會自動使用此級別記錄代碼中發生故障的位置。
TRACE: 更詳細的調試級別。關鍵字參數和返回值是使用這個級別自動記錄的。

設置日誌級別

默認狀況下，INFO不在日誌級別的日誌消息被記錄下來，可是能夠使用--loglevel（-L）選項從命令行更改該閾值。該選項將任何可用的日誌級別做爲參數，而且該級別成爲新的閾值級別。一個特殊的值NONE也能夠用來徹底禁用日誌記錄。

從機器人框架2.5.2開始，也能夠使用 --loglevel選項也當處理後的輸出與 rebot。例如，這容許最初使用該TRACE級別運行測試，並隨後生成較小的日誌文件以供普通查看INFO。默認狀況下，執行過程當中包含的全部消息也將包含在rebot中。執行期間忽略的消息沒法恢復。

另外一種更改日誌級別的方法是在測試數據中使用BuiltIn 關鍵字Set Log Level。它採用與--loglevel選項相同的參數，而且還返回舊的級別，以便稍後能夠恢復，例如在測試拆卸中。

可見的日誌級別

從Robot Framework 2.7.2開始，若是日誌文件包含位於DEBUG或TRACE級別的消息，則右上角會顯示可見的日誌級別下拉列表。這容許用戶從視圖中刪除選定級別如下的消息。這在運行測試時尤爲有用 TRACE。

SRC / ExecutingTestCases / visible_log_level.png

顯示可見日誌級別的示例日誌下拉菜單

默認狀況下，下拉列表將被設置爲日誌文件中的最低級別，以便顯示全部消息。使用--loglevel選項能夠更改默認的可見日誌級別，方法是在用冒號分隔的正常日誌級別以後給定默認級別：

--loglevel DEBUG：INFO

在上面的示例中，測試是使用級別運行的DEBUG，可是日誌文件中的默承認見級別是INFO。

3.5.3分割日誌

一般狀況下，日誌文件只是一個HTML文件。當他的測試用例數量增長時，文件的大小會變得很大，打開瀏覽器是不方便的，甚至是不可能的。從Robot Framework 2.6開始，能夠使用--splitlog選項將日誌的各個部分拆分紅外部文件，並在須要時透明地加載到瀏覽器中。

分割日誌的主要好處是單個日誌部分很是小，即便測試數據量很是大，也能夠打開和瀏覽日誌文件。一個小缺點是日誌文件佔用的總體大小增長。

從技術上講，與每一個測試用例相關的測試數據都保存在與主日誌文件相同的文件夾中的JavaScript文件中。這些文件具備諸如log-42.js之類的名稱，其中log是主日誌文件的基本名稱，而且42是遞增的索引。

注意

當複製日誌文件時，您還須要複製全部日誌 - *。js文件或者某些信息將會丟失。

3.5.4配置統計信息

有跡象代表，可用於配置和調整的內容幾個命令行選項由標籤統計，經過統計套房，並經過標籤測試詳細信息在不一樣的輸出文件表。全部這些選項在執行測試用例和後處理輸出時都有效。

配置顯示的套件統計

當執行更深層次的套件結構時，在Statistics by Suite表中顯示全部測試套件級別可能會使表格難以閱讀。Bt默認顯示全部套件，可是您能夠使用命令行選項--suitestatlevel來控制此套件，該套件將套件級別顯示爲參數：

--suitestatlevel 3

包括和排除標籤統計

當使用多個標籤時，標籤統計表可能變得至關擁擠。若是發生這種狀況，該命令行選項 --tagstatinclude和--tagstatexclude可用於選擇哪些標籤顯示，相似於 --include和--exclude用於選擇測試案例：

--tagstatinclude some-tag --tagstatinclude another-tag--tagstatexclude全部者 -  *--tagstatinclude prefix- * --tagstatexclude prefix-13

生成組合標籤統計信息

命令行選項--tagstatcombine可用於生成彙總來自多個標記的統計信息的彙總標記。組合的標籤是使用標籤模式指定的， *而且?做爲通配符被支持AND， OR而且NOT運算符能夠用於將各個標籤或模式組合在一塊兒。

如下示例說明了使用不一樣的模式建立組合標記統計信息，下圖顯示了由Tag生成的統計信息表片斷：

--tagstatcombine全部者 -  *--tagstatcombine smokeANDmytag--tagstatcombine smokeNOTowner-janne *

SRC / ExecutingTestCases / tagstatcombine.png

組合標籤統計的例子

如上例所示，添加的組合統計量的名稱默認狀況下只是給定的模式。若是這樣作不夠好，能夠在模式以後用冒號（:）分隔它們來給定一個自定義名稱。名字中可能的下劃線被轉換爲空格：

--tagstatcombine prio1ORprio2：High_priority_tests

從標籤名稱建立連接

您能夠使用命令行選項--tagstatlink將外部連接添加到「標記統計信息」表。此選項的參數以格式給出，其中指定要分配連接的標籤是要建立的連接，而且是要提供給連接的名稱。tag:link:nametaglinkname

tag多是一個單一的標籤，但更常見的是一個簡單的模式，*匹配任何東西，並?匹配任何單個字符。當tag是這樣一種模式，以通配符匹配能夠在使用link和title的語法%N，其中「N」是從1開始的匹配的索引。

如下示例說明了此選項的用法，下圖顯示了使用這些選項執行示例測試數據時，由Tag生成的統計信息摘要表的片斷：

--tagstatlink mytag：http：//www.google.com：Google--tagstatlink jython-bug- *：http：//bugs.jython.org/issue_%1：Jython-bugs--tagstatlink全部者 -  *：mailto：％1@domain.com？subject = Acceptance_Tests：Send_Mail

SRC / ExecutingTestCases / tagstatlink.png

來自標籤名稱的連接示例

添加文檔到標籤

能夠經過命令行選項--tagdoc給標記賦予一個文檔，該選項採用格式參數 tag:doc。tag是分配文檔的標籤的名稱，也能夠是匹配多個標籤的簡單模式。doc是指定的文件。文檔中的下劃線會自動轉換爲空格，而且也能夠包含HTML格式。

給出的文檔在「按標籤測試詳細信息」表中顯示有匹配的標籤，並在「按標籤統計」表中顯示爲這些標籤的工具提示。若是一個標籤得到多個文檔，則它們被組合在一塊兒並用＆符號分隔。

例子：

--tagdoc mytag：My_documentation--tagdoc迴歸：*見* _http：//info.html--tagdoc全部者 -  *：Original_author

3.5.5刪除和展開關鍵字

輸出文件的大部份內容來自關鍵字及其日誌消息。在建立更高級別的報告時，根本不須要日誌文件，在這種狀況下，關鍵字及其消息只是佔用了沒必要要的空間。日誌文件自己也可能會變得過大，特別是若是它們包含for循環或其餘構造重複某些關鍵字屢次。

在這些狀況下，能夠使用命令行選項--removekeywords和 --flattenkeywords來處理或拼合沒必要要的關鍵字。它們能夠在執行測試用例和後處理輸出時使用。在執行期間使用時，它們隻影響日誌文件，而不影響XML輸出文件。與rebot他們同時影響日誌，並可能產生新的輸出XML文件。

刪除關鍵字

該--removekeywords選項徹底刪除關鍵字和他們的消息。它具備如下操做模式，能夠屢次使用以啓用多種模式。除非使用模式，不然包含警告的關鍵字不會被刪除ALL。

ALL: 無條件地刪除全部關鍵字的數據。
PASSED: 從經過的測試用例中刪除關鍵字數據在大多數狀況下，使用此選項建立的日誌文件包含足夠的信息來調查可能的故障。
FOR: 從最後一個循環中除去 for循環的全部迭代。
WUKS: 刪除 BuiltIn關鍵字中的全部失敗的關鍵字等到關鍵字成功，除了最後一個關鍵字。
NAME:<pattern>: 從關鍵字狀態中刪除與給定模式匹配的全部關鍵字的數據。該模式與關鍵字的全名相匹配，前綴爲可能的庫或資源文件名。該模式是大小寫，空格和下劃線不敏感，它支持與通配符和簡單模式。 * ?

例子：

rebot --removekeywords all --output removed.xml output.xmlpybot --removekeywords傳遞--removekeywords爲tests.txtpybot --removekeywords名稱：HugeKeyword --removekeywords名稱：resource。* tests.txt

在解析輸出文件並基於它生成內部模型以後，刪除關鍵字。所以，它不會像拼合關鍵字那樣減小內存使用量。

注意

對於使用支持--removekeywords執行測試，以及時FOR和WUKS在機器人框架2.7添加模式。

注意

NAME:<pattern> 模式被添加到機器人框架2.8.2。

拼合關鍵字

該--flattenkeywords選項變平匹配的關鍵字。實際上，這意味着匹配的關鍵字將遞歸地從其子關鍵字中獲取全部日誌消息，不然將丟棄子關鍵字。展平支持如下模式：

FOR: 徹底展平循環。
FORITEM: 逐個展開循環迭代。
NAME:<pattern>: 拼合與給定模式匹配的關鍵字。模式匹配規則與刪除關鍵字使用 NAME:<pattern>模式相同。

例子：

pybot --flattenkeywords名稱：HugeKeyword --flattenkeywords名稱：resource。* tests.txtrebot --flattenkeywords foritem --output flattened.xml original.xml

當最初解析輸出文件時，已經完成了拼合關鍵字。這能夠節省大量的內存，特別是深度嵌套的關鍵字結構。

注意

扁平化的關鍵詞是機器人框架2.8.2中的新功能，並 FOR和FORITEM模式在機器人框架2.8.5添加。

3.5.6設置執行的開始和結束時間

當組合輸出使用rebot，能夠設置使用選項組合的測試套件的開始和結束時間--starttime 和--endtime分別。這很方便，由於默認狀況下，組合套件沒有這些值。當給定開始時間和結束時間時，也會根據它們計算通過時間。不然，通過的時間是經過將兒童測試套件的通過時間加在一塊兒而獲得的。

從Robot Framework 2.5.6開始，也能夠使用上述選項來設置單個套件在使用rebot時的開始和結束時間。對單個輸出使用這些選項老是會影響套件的已用時間。

時間必須以格式的時間戳給出YYYY-MM-DD hh:mm:ss.mil，其中全部分隔符都是可選的，毫秒到小時之間的部分能夠省略。例如，2008-06-11 17:59:20.495至關於既20080611-175920.495和 20080611175920495，也僅僅20080611會工做。

例子：

rebot --starttime 20080611-17：59：20.495 output1.xml output2.xmlrebot --starttime 20080611-175920 --endtime 20080611-180242 * .xmlrebot --starttime 20110302-1317 --endtime 20110302-11418 myoutput.xml

3.5.7系統日誌

機器人框架有它本身的純文本系統日誌寫信息

處理和跳過的測試數據文件

導入測試庫，資源文件和變量文件

執行測試套件和測試用例

建立輸出

一般用戶從不須要這些信息，但在調查測試庫或Robot Framework自己的問題時，它可能很是有用。系統日誌不是默認建立的，可是能夠經過設置環境變量ROBOT_SYSLOG_FILE來啓用它，使其包含所選文件的路徑。

系統日誌與普通日誌文件具備相同的日誌級別，但不一樣的是FAIL它具備ERROR 級別。要使用的閾值級別能夠使用ROBOT_SYSLOG_LEVEL環境變量進行更改，以下例所示。除了控制檯和正常的日誌文件以外，可能的意外錯誤和警告也會寫入系統日誌中。

＃！/斌/慶典導出ROBOT_SYSLOG_FILE = /tmp/syslog.txt 導出ROBOT_SYSLOG_LEVEL = DEBUGpybot --name Syslog_example路徑/ to / tests

4擴展機器人框架

4.1建立測試庫

Robot Framework的實際測試功能由測試庫提供。現有的庫有不少，其中一些甚至與核心框架捆綁在一塊兒，但仍然常常須要建立新的庫。這個任務不是太複雜，由於正如本章所示，Robot Framework的庫API很是簡單直接。

4.1.1簡介

支持的編程語言

Robot Framework自己是用Python編寫的，天然擴展的測試庫能夠使用相同的語言來實現。在Jython上運行框架時，也能夠使用Java實現庫。純Python代碼同時適用於Python和Jython，假定它不使用Jython上沒有的語法或模塊。當使用Python時，也能夠使用Python C API來實現帶有C的庫，儘管使用ctypes模塊與Python庫中的C代碼交互一般更容易。

使用這些本機支持的語言實現的庫也能夠充當使用其餘編程語言實現的功能的包裝。這種方法的一個很好的例子是遠程庫，而另一種普遍使用的方法是將外部腳本或工具做爲單獨的進程運行。

小費

Robot Framework測試庫的Python教程開發人員涵蓋了足夠的Python語言，以便開始使用它來編寫測試庫。它還包含一個簡單的示例庫和測試用例，能夠在您的機器上執行和調查。

不一樣的測試庫API

Robot Framework有三個不一樣的測試庫API。

靜態API

最簡單的方法是使用直接映射到關鍵字名稱的模塊（使用Python）或類（使用Python或Java）。關鍵字也採起與實施它們的方法相同的論據。關鍵字報告具備異常的失敗，經過寫入標準輸出進行日誌記錄，並能夠使用該語句返回值 return。

動態API

動態庫是實現一個方法來獲取他們實現的關鍵字名稱的類，另外一個方法是用給定的參數執行一個named關鍵字。能夠在運行時動態肯定要實現的關鍵字的名稱以及它們的執行方式，但報告狀態，記錄和返回值與靜態API中的相似。

混合API

這是靜態和動態API之間的混合。圖書館是類的方法告訴他們實現的關鍵字，但這些關鍵字必須直接可用。除了發現什麼關鍵字被實現以外，其餘的一切都和靜態API相似。

全部這些API都在本章中描述。一切都基於靜態API的工做原理，因此首先討論它的功能。而後，動態庫API和混合庫API如何與它們不一樣，而後分別討論它們。

本章中的例子主要是關於使用Python，可是對於僅限於Java的開發人員也應該很容易理解。在API差異很小的狀況下，這兩種用法都用適當的例子來解釋。

4.1.2建立測試庫類或模塊

測試庫能夠做爲Python模塊和Python或Java類來實現。

測試庫名稱

導入庫時使用的測試庫的名稱與實現它的模塊或類的名稱相同。例如，若是您有一個Python模塊MyLibrary（即文件MyLibrary.py），它將建立一個名爲MyLibrary的庫。一樣，一個Java類YourLibrary，當它不在任何包中時，就會建立一個具備這個名稱的庫。

Python類老是在模塊內。若是實現庫的類的名稱與模塊的名稱相同，Robot Framework容許在導入庫時刪除類名。例如，類MyLib在MyLib.py 文件能夠被用做與僅舉庫MyLib中。這也適用於子模塊，例如，若是parent.MyLib模塊有類MyLib，只需使用parent.MyLib就能夠導入它。若是模塊名稱和類名稱不一樣，則必須使用模塊和類名稱來使用庫，例如 mymodule.MyLibrary或parent.submodule.MyLib。

非默認包中的Java類必須與全名一塊兒使用。例如，類MyLib在com.mycompany.myproject 包必須用名稱導入com.mycompany.myproject.MyLib。

注意

使用子模塊刪除類名僅適用於Robot Framework 2.8.4及更高版本。在早期版本中，您還須要包含像parent.MyLib.MyLib這樣的類名稱。

小費

若是庫名稱很長，例如Java包名稱很長，則建議使用WITH NAME語法爲庫提供一個更簡單的別名。

提供參數來測試庫

全部做爲類實現的測試庫均可以使用參數。這些參數是在庫名後面的Setting表中指定的，當Robot Framework建立一個導入庫的實例時，它將它們傳遞給它的構造函數。做爲模塊實現的庫不能採起任何參數，因此試圖使用這些結果的錯誤。

庫須要的參數個數與庫構造函數接受的參數個數相同。參數的缺省值和變量的數目與關鍵字參數的工做方式相似，只是沒有Java庫的可變參數支持。傳遞給庫的參數以及庫名稱自己均可以使用變量來指定，因此能夠經過變量來修改它們，例如從命令行。

用參數導入一個測試庫
設置	值	值	值
圖書館	個人圖書館	10.0.0.1	8080
圖書館	AnotherLib	$ {VAR}

上例中使用的庫的示例實現，第一個是Python，第二個是Java：

從 示例 導入 鏈接class  MyLibrary ：    def  __init__ （self ， host ， port = 80 ）：        self 。_conn  =  鏈接（主機， int （端口））    def  send_message （self ， message ）：        self 。_conn 。發送（消息）

公共 類 AnotherLib  {    private  String  setting  =  null ;    public  AnotherLib （字符串 設置） {         設置 =  設置;     }    公共 無效 doSomething （） {         若是 設置。等於（「42」 ） {             //作某事...         }     } }

測試庫範圍

做爲類實現的庫能夠具備內部狀態，能夠經過關鍵字和參數來改變庫的構造函數。由於狀態能夠影響關鍵字的實際行爲，因此確保在一個測試用例中的更改不會意外地影響其餘測試用例是很是重要的。這些依賴關係可能會產生難以調試的問題，例如，當添加新的測試用例而且不一致地使用庫時。

Robot Framework試圖保持測試用例彼此獨立：默認狀況下，它爲每一個測試用例建立新的測試用例實例。可是，這種行爲並不老是可取的，由於有時測試用例應該可以共享一個共同的狀態。另外，全部的庫都沒有狀態，建立它們的新實例根本就不須要。

測試庫能夠控制什麼時候用類屬性建立新的庫ROBOT_LIBRARY_SCOPE。這個屬性必須是一個字符串，它能夠有如下三個值：

TEST CASE: 每一個測試用例都會建立一個新的實例。一個可能的套件設置和套件拆卸共享另外一個實例。這是默認的。
TEST SUITE: 爲每一個測試套件建立一個新的實例。從測試用例文件建立幷包含測試用例的最低級測試套件具備本身的實例，而更高級別的套件均可覺得其可能的設置和拆卸獲取本身的實例。
GLOBAL: 在整個測試執行過程當中只有一個實例被建立，它被全部的測試用例和測試套件共享。從模塊建立的庫始終是全局的。

注意

若是使用不一樣的參數屢次導入庫，則無論範圍如何，都會建立一個新實例。

當TEST SUITE或GLOBAL範圍與有狀態測試庫使用，建議圖書館有清理國家一些特殊的關鍵字。而後能夠使用該關鍵字，例如，在套件設置或拆卸中，以確保下一個測試套件中的測試用例能夠從已知狀態開始。例如， SeleniumLibrary使用GLOBAL範圍來在不一樣的測試用例中使用相同的瀏覽器，而沒必要從新打開它，而且它還具備關閉全部瀏覽器關鍵字，用於輕鬆關閉全部打開的瀏覽器。

使用TEST SUITE範圍的示例Python庫：

class  ExampleLibrary ：    ROBOT_LIBRARY_SCOPE  =  '測試套件'    def  __init__ （self ）：        self 。_counter  =  0    def  count （self ）：        自我。_counter  + =  1         打印 本身。_計數器    def  clear_counter （self ）：        self 。_counter  =  0

使用GLOBAL範圍的示例Java庫：

公共 類 ExampleLibrary  {    public  static  final  String  ROBOT_LIBRARY_SCOPE  =  「GLOBAL」 ;    私人 詮釋 計數器 =  0 ;    public  void  count （） {         counter  + =  1 ;         系統。出去。println （counter ）;     }    public  void  clearCounter （） {         counter  =  0 ;     } }

指定庫版本

當一個測試庫被使用時，Robot Framework會嘗試肯定它的版本。而後將這些信息寫入系統日誌以提供調試信息。庫文檔工具 Libdoc也將這些信息寫入到它生成的關鍵字文檔中。

版本信息是從屬性看 ROBOT_LIBRARY_VERSION，相似於測試庫範圍是從讀ROBOT_LIBRARY_SCOPE。若是 ROBOT_LIBRARY_VERSION不存在，則嘗試從__version__屬性中讀取信息。這些屬性必須是類或模塊屬性，具體取決於庫是做爲類仍是模塊實現的。對於Java庫，版本屬性必須聲明爲static final。

一個示例Python模塊使用__version__：

__version__  =  '0.1'def  關鍵字（）：    經過

一個Java類使用ROBOT_LIBRARY_VERSION：

公共 類 VersionExample  {    public  static  final  String  ROBOT_LIBRARY_VERSION  =  「1.0.2」 ;    public  void  keyword （） {     } }

指定文檔格式

從Robot Framework 2.7.5開始，庫文檔工具Libdoc 支持多種格式的文檔。若是您想使用Robot Framework本身的文檔格式之外的其餘功能，能夠使用ROBOT_LIBRARY_DOC_FORMAT屬性指定源代碼中的格式，範圍和版本均使用本身的ROBOT_LIBRARY_*屬性進行設置。

文檔格式可能不區分大小寫的值是 ROBOT（默認）HTML，TEXT（純文本）和reST（reStructuredText）。使用該reST格式須要在生成文檔時安裝docutils模塊。

設置文檔格式由如下分別使用reStructuredText和HTML格式的Python和Java示例說明。有關記錄測試庫的更多信息，請參見記錄庫部分和Libdoc章節。

「」一個用於*文檔格式*演示目的的庫。這個文檔是使用reStructuredText__建立的。這是一個惟一\ Keyword 的連接。__ http://docutils.sourceforge.net 「」「ROBOT_LIBRARY_DOC_FORMAT  =  'reST'def  關鍵字（）：    「」「**沒有**看到這裏。甚至沒有在下面的表。    ======= ===== =====     這裏的表    沒有什麼可看的。    ======= ===== =====     「」「     通行證

/ ** *用於<i>文檔格式</ i>演示目的的庫。* *本文檔使用<a href="http://www.w3.org/html"> HTML </a>建立。*這是一個連接到惟一`關鍵字`。* / public  class  DocFormatExample  {    public  static  final  String  ROBOT_LIBRARY_DOC_FORMAT  =  「HTML」 ;    / ** <b>沒有</ b>在這裏看到。甚至不在下面的表格中。     *      * <TABLE>      * <TR> <TD>表</ TD> <TD>這裏</ TD> <TD>具備</ TD> </ TR>      * <TR> <TD>沒有</ TD> < td> to </ td> <td> see。</ td> </ tr>      * </ table>      * /     public  void  keyword （） {     } }

圖書館充當監聽者

偵聽器接口容許外部偵聽器得到有關測試執行的通知。例如，當套件，測試和關鍵字開始和結束時，就會調用它們。有時，獲取這樣的通知對於測試庫也是有用的，而且能夠經過使用ROBOT_LIBRARY_LISTENER屬性來註冊自定義的監聽器。該屬性的值應該是要使用的偵聽器的實例，多是庫自己。有關更多信息和示例，請參閱將庫做爲偵聽器部分。

4.1.3建立靜態關鍵字

什麼方法被認爲是關鍵字

當使用靜態庫API時，Robot Framework使用反射來查找庫類或模塊實現的公共方法。它將排除如下劃線開頭的全部方法，而且在Java庫中也會java.lang.Object忽略僅在其中實現的方法。全部不被忽略的方法都被認爲是關鍵字。例如，下面的Python和Java庫實現了單個關鍵字My Keyword。

class  MyLibrary ：    def  my_keyword （self ， arg ）：        返回 自我。_helper_method （arg ）    def  _helper_method （self ， arg ）：        return  arg 。upper （）

公共 類 MyLibrary  {    public  String  myKeyword （String  arg ） {         return  helperMethod （arg ）;     }    private  String  helperMethod （String  arg ） {         return  arg 。toUpperCase （）;     } }

當庫被實現爲Python模塊時，也能夠經過使用Python的__all__屬性限制關鍵字的方法。若是__all__使用，只有在其中列出的方法能夠是關鍵字。例如，下面的庫實現關鍵字示例關鍵字和第二個示例。沒有__all__，它也會實現關鍵字不顯示爲關鍵字和當前線程。最重要的用法__all__是確保導入的幫助程序方法（current_thread例以下面的示例）不會意外暴露爲關鍵字。

從 線程 導入 current_thread__all__  =  [ 'example_keyword' ， 'second_example' ]def  example_keyword （）：    if  current_thread （）。名 ==  「MainThread」 ：        打印 「在主線程中運行」def  second_example （）：    passdef  not_exposed_as_keyword （）：    傳遞

注意

__all__從Robot Framework 2.5.5開始支持該屬性。

關鍵字名稱

將測試數據中使用的關鍵字名稱與方法名稱進行比較，以查找實現這些關鍵字的方法。名稱比較不區分大小寫，空格和下劃線也被忽略。例如，該方法hello映射到關鍵字名稱 Hello，hello甚至hello。一樣兩個 do_nothing和doNothing方法能夠用來做爲不做爲測試數據關鍵字。

示例Python庫在MyLibrary.py文件中做爲模塊實現：

def  hello （name ）：    print  「Hello，％s ！」  ％ 姓名def  do_nothing （）：    經過

示例Java庫在MyLibrary.java文件中做爲類實現：

公共 類 MyLibrary  {    public  void  hello （String  name ） {         System 。出去。println （「Hello，」  +  name  +  「！」 ）;     }    public  void  doNothing （） {     }}

下面的例子說明了如何使用上面的示例庫。若是您想親自嘗試，請確保該庫位於庫搜索路徑中。

使用簡單的示例庫
設置	值	值	值
圖書館	個人圖書館

測試用例	行動	論據	論據
個人測試	沒作什麼
你好	世界

關鍵字參數

使用靜態和混合API，關鍵字須要多少個參數的信息直接來自實現它的方法。使用動態庫API的庫有其餘方法來共享這些信息，因此這一部分與它們無關。

最多見也是最簡單的狀況是關鍵字須要確切數量的參數。在這種狀況下，Python和Java方法都只是簡單地使用這些參數。例如，實現一個沒有參數的關鍵字的方法也沒有參數，一個實現一個參數的關鍵字的方法也須要一個參數，依此類推。

使用不一樣數量參數的Python關鍵字示例：

def  no_arguments （）：    print  「關鍵字沒有參數」。def  one_argument （arg ）：    print  「關鍵字有一個參數」 ％s 「。 ％ argdef  three_arguments （a1 ， a2 ， a3 ）：    print  「關鍵字有三個參數」 ％s 「，」 ％s 「和」 ％s 「。 ％ （a1 ， a2 ， a3 ）

注意

Java庫使用靜態庫API的主要限制是它們不支持命名的參數語法。若是這是一個阻止程序，能夠使用Python或切換到動態庫API。

默認值爲關鍵字

關鍵字使用的某些參數具備默認值一般頗有用。Python和Java有不一樣的方法處理默認值的語法，在爲Robot Framework建立測試庫時，能夠使用這些語言的天然語法。

Python的默認值

在Python中，一個方法老是隻有一個實現，而且在方法簽名中指定了可能的默認值。全部Python程序員都熟悉的語法以下所示：

def  one_default （arg = 'default' ）：    print  「參數具備值％s 」  ％ argdef  multiple_defaults （arg1 ， arg2 = 'default 1' ， arg3 = 'default 2' ）：    print  「得到參數％s ，％s 和％s 」  ％ （arg1 ， arg2 ， arg3 ）

上面的第一個示例關鍵字能夠用於零個或一個參數。若是沒有給出任何參數，則arg獲取該值 default。若是隻有一個參數，則arg獲取該值，而且使用多個參數調用關鍵字將失敗。在第二個示例中，老是須要一個參數，但第二個和第三個參數具備默認值，所以能夠使用具備一到三個參數的關鍵字。

使用可變數量的參數的關鍵字
測試用例	行動	論據	論據
默認	一個默認
一個默認	論據
多個默認值	要求arg
多個默認值	要求arg	可選的
多個默認值	要求arg	可選1	可選2

Java的默認值

在Java中，一個方法能夠有不一樣簽名的幾個實現。Robot Framework將全部這些實現視爲一個關鍵字，能夠使用不一樣的參數。這個語法能夠用來提供對默認值的支持。下面的例子說明了這一點，它與前面的Python例子在功能上是一致的：

public  void  oneDefault （String  arg ） {     System 。出去。println （「Argument has value」  +  arg ）; }public  void  oneDefault （） {     oneDefault （「default」 ）; }public  void  multipleDefaults （String  arg1 ， String  arg2 ， String  arg3 ） {     System 。出去。println （「有參數」  +  arg1  +  「，」  +  arg2  +  「和」  +  arg3 ）; }public  void  multipleDefaults （String  arg1 ， String  arg2 ） {     multipleDefaults （arg1 ， arg2 ， 「default 2」 ）; }public  void  multipleDefaults （String  arg1 ） {     multipleDefaults （arg1 ， 「default 1」 ）; }

可變數量的參數（`*varargs`）

Robot Framework還支持帶有任意數量參數的關鍵字。與默認值相似，在Python和Java中，測試庫中使用的實際語法也是不一樣的。

Python的變量數量是可變的

Python支持接受任意數量參數的方法。在庫中也使用相同的語法，正以下面的示例所示，它也能夠與其餘指定參數的方法結合使用：

高清 any_arguments （* ARGS ）：    打印 「獲得了論據：」     對 ARG  在 ARGS ：        打印 ARG高清 one_required （所需， * 等）：    打印 「要求：％S \ n 其餘：」  ％ 須要    用於 ARG  在 別人：        打印 ARGdef  also_defaults （req ， def1 = 「default 1」 ， def2 = 「default 2」 ， * rest ）：    print  req ， def1 ， def2 ， rest

使用具備可變數量參數的關鍵字
測試用例	行動	論據	論據
可變參數	任何參數
任何參數	論據
任何參數	arg 1	arg 2	arg 2
...	arg 4	arg 5
一個必需	要求arg
一個必需	要求arg	另外一個arg	完後還有
還默認	須要
還默認	須要	這兩個	有默認值
還默認	1	2	3
...	4	五	6

Java的變量數量可變

Robot Framework支持用於定義可變數量的參數的Java可變參數語法。例如，如下兩個關鍵字在功能上與以上具備相同名稱的Python示例相同：

public  void  anyArguments （String ...  varargs ） {     System 。出去。println （「有參數：」 ）;     for  （String  arg： varargs ） {         System 。出去。println （arg ）;     } }public  void  oneRequired （String  required ， String ...  others ） {     System 。出去。println （「Required：」  +  required  +  「\ n其餘：」 ）;     for  （String  arg： others ） {         System 。出去。println （arg ）;     } }

java.util.List若是使用自由關鍵字參數（** kwargs），也能夠使用可變數量的參數，或者從Robot Framework 2.8.3開始，做爲最後一個參數，或者倒數第二個參數。如下示例說明了這一點，它們在功能上與之前的示例相同：

public  void  anyArguments （String []  varargs ） {     System 。出去。println （「有參數：」 ）;     for  （String  arg： varargs ） {         System 。出去。println （arg ）;     } }public  void  oneRequired （String  required ， List < String >  others ） {     System 。出去。println （「Required：」  +  required  +  「\ n其餘：」 ）;     for  （String  arg： others ） {         System 。出去。println （arg ）;     } }

注意

只java.util.List支持可變參數，不支持其任何子類型。

使用Java關鍵字來支持可變數量的參數有一個限制：只有當方法有一個簽名時纔有效。所以，使用默認值和可變參數的Java關鍵字是不可能的。除此以外，只有Robot Framework 2.8和更新的支持使用帶庫構造函數的可變參數。

免費的關鍵字參數（`**kwargs`）

Robot Framework 2.8使用Python的**kwargs語法添加了對free關鍵字參數的支持。建立測試用例下的 Free關鍵字參數部分討論瞭如何使用測試數據中的語法。在本節中，咱們看看如何在自定義測試庫中實際使用它。

用Python免費提供關鍵字參數

若是您已經很熟悉kwargs是如何與Python一塊兒工做的，那麼瞭解它們如何與Robot Framework測試庫一塊兒工做是至關簡單的。下面的例子顯示了基本功能：

def  example_keyword （** stuff ）：    用於 名稱， 值 的 東西。items （）：        打印 名稱， 值

使用關鍵字 `**kwargs`
測試用例	行動	論據	論據	論據
關鍵字參數	示例關鍵字	你好=世界		＃記錄「hello world」。
示例關鍵字	富= 1	條= 42	＃記錄'foo 1'和'bar 42'。

基本上，關鍵字調用結束時的全部使用命名參數語法的 name=value參數，不匹配任何其餘參數，都會以kwargs的形式傳遞給關鍵字。爲了不使用相似文字值foo=quux做爲一個自由關鍵字參數，它必須被轉義像foo\=quux。

如下示例說明了普通參數，可變參數和kwargs如何協同工做：

高清 various_args （阿根廷， * 可變參數， ** kwargs ）：    打印 'ARG：' ， ARG     的 值 在 可變參數：        打印 '可變參數：' ， 值    的 名稱， 值 中的 排序（kwargs 。項目（））：        打印 「kwarg： ' ， 名字， 價值

使用正常的參數，可變參數和kwargs在一塊兒
測試用例	行動	論據	論據	論據	論據
位置	各類各樣的參議院	你好	世界		＃記錄「arg：hello」和「vararg：world」。
命名	各類各樣的參議院	ARG =值			＃記錄「參數：值」。
Kwargs	各類各樣的參議院	a = 1時	B = 2	C = 3	＃記錄「kwarg：1」，「kwarg：b 2」和「kwarg：c 3」。
各類各樣的參議院	C = 3	a = 1時	B = 2	＃同上。順序可有可無。
位置和kwargs	各類各樣的參議院	1	2	千瓦= 3	＃Logs'arg：1'，'vararg：2'和'kwarg：kw 3'。
命名和kwargs	各類各樣的參議院	ARG =值	你好=世界		＃記錄「arg：value」和「kwarg：hello world」。
各類各樣的參議院	你好=世界	ARG =值		＃同上。順序可有可無。

對於上例中使用簽名的真實世界示例，請參閱Process Library 中的Run Process和Start Keyword關鍵字。

與Java免費的關鍵字參數

從Robot Framework 2.8.3開始，Java庫也支持免費的關鍵字參數語法。Java自己沒有kwargs語法，可是關鍵字能夠有java.util.Map最後一個參數來指定它們接受kwargs。

若是一個Java關鍵字接受kwargs，Robot Framework會自動name=value將關鍵字調用結尾處的全部參數打包爲一個關鍵字Map並將其傳遞給關鍵字。例如，下面的示例關鍵字能夠像之前的Python示例同樣使用：

公共 無效 exampleKeyword （地圖< 字符串， 字符串>  的東西）：    對 （字符串 鍵： 東西。中的keySet （））        系統。出去。的println （鍵 +  「」  +  的東西。得到（鍵））;public  void  variousArgs （String  arg ， List < String >  varargs ， Map < String ， Object >  kwargs ）：    System 。出去。println （「arg：」  +  arg ）;     for  （String  varg： varargs ）        系統。出去。println （「vararg：」  +  varg ）;     for  （字符串 鍵： 克瓦格斯。keySet （））        系統。出去。的println （「kwarg：」  +  鍵 +  「」  +  kwargs 。得到（鍵））;

注意

kwargs參數的類型必須是正確的java.util.Map，而不是它的任何子類型。

注意

與varargs支持相似，支持kwargs的關鍵字不能有多個簽名。

參數類型

一般，關鍵字參數以字符串形式出如今Robot Framework中。若是關鍵字須要其餘類型，則能夠使用變量或將字符串轉換爲關鍵字中所需的類型。使用 Java關鍵字時，基本類型也會自動被強制轉換。

使用Python的參數類型

因爲Python中的參數沒有任何類型信息，所以在使用Python庫時不可能自動將字符串轉換爲其餘類型。調用實現具備正確數量參數的關鍵字的Python方法老是成功的，但若是參數不兼容，則執行失敗。幸運的是，將關鍵字中的參數轉換爲合適的類型很是簡單：

def  connect_to_host （address ， port = 25 ）：    port  =  int （port ）    ＃...

使用Java的參數類型

Java方法的參數有類型，全部的基類都是自動處理的。這意味着測試數據中的正常字符串參數在運行時被強制糾正類型。能夠被強制的類型是：

整數類型（byte，short，int，long）
浮點類型（float和double）
該boolean類型
上述類型的對象版本，例如 java.lang.Integer

對關鍵字方法的全部簽名中具備相同或兼容類型的參數進行強制轉換。在下面的例子中，轉換能夠作到的關鍵字doubleArgument 和compatibleTypes，但不適合conflictingTypes。

public  void  doubleArgument （double  arg ） {}public  void  compatibleTypes （String  arg1 ， Integer  arg2 ） {} public  void  compatibleTypes （String  arg2 ， Integer  arg2 ， Boolean  arg3 ） {}public  void  conflictingTypes （String  arg1 ， int  arg2 ） {} public  void  conflictingTypes （int  arg1 ， String  arg2 ） {}

若是測試數據有一個包含數字的字符串，則強制與數字類型一塊兒工做，而布爾型數據必須包含字符串true或false。只有當原始值是來自測試數據的字符串時纔會進行強制轉換，但固然仍然能夠使用包含這些關鍵字的正確類型的變量。若是關鍵字有衝突的簽名，使用變量是惟一的選擇。

使用自動類型強制
測試用例	行動	論據	論據
強迫	雙重論據	3.14
雙重論據	2E16		＃科學計數法
兼容的類型	你好，世界！	1234
兼容的類型	你好，咱們又見面了！	-10	真正

沒有強制	雙重論據	$ {} 3.14
衝突類型	1	$ {2}	＃必須使用變量
衝突類型	$ {1}	2

從Robot Framework 2.8開始，參數類型強制也適用於 Java庫構造函數。

使用裝飾器

編寫靜態關鍵字時，使用Python的修飾器修改它們有時是有用的。然而，裝飾器修改函數簽名，並能夠混淆機器人框架的內省，當肯定哪些參數關鍵字接受。使用Libdoc建立庫文檔時以及使用 RIDE時，這是特別有問題的。爲了不這個問題，要麼不要使用裝飾器，要麼使用方便的裝飾器模塊來建立保留簽名的裝飾器。

4.1.4與Robot Framework通訊

在調用實現關鍵字的方法後，能夠使用任何機制與被測系統進行通訊。而後，它能夠發送消息到Robot Framework的日誌文件，返回能夠保存到變量的信息，最重要的是，報告關鍵字是否經過。

報告關鍵字狀態

報告關鍵字狀態只需使用例外便可完成。若是執行的方法引起異常，則關鍵字狀態爲FAIL，若是正常返回，則狀態爲PASS。

日誌，報告和控制檯中顯示的錯誤消息是從異常類型及其消息中建立的。與通用的異常（例如，AssertionError，Exception，和 RuntimeError），僅使用異常消息，並與其餘人，在格式被建立的消息ExceptionType: Actual message。

從Robot Framework 2.8.2開始，能夠避免將異常類型做爲前綴添加到失敗消息中，也能夠使用非泛型異常。這是經過添加一個特殊的ROBOT_SUPPRESS_NAME屬性值爲True你的例外。

蟒蛇：

class  MyError （RuntimeError ）：    ROBOT_SUPPRESS_NAME  =  True

Java的：

公共 類 MyError  擴展 RuntimeException  {     公共 靜態 最終 布爾 ROBOT_SUPPRESS_NAME  =  true ; }

在全部狀況下，對於用戶而言，異常消息儘量是信息性的，這一點很重要。

錯誤消息中的HTML

從Robot Framework 2.8開始，也能夠經過用文本開始消息來得到HTML格式的錯誤消息*HTML*：

引起 AssertionError （「* HTML * <a href='robotframework.org'> Robot Framework </a> rulez !!」 ）

當在庫中引起異常時（例如上面的示例）以及用戶在測試數據中提供錯誤消息時，能夠使用此方法。

自動切割長信息

若是錯誤信息超過40行，則會自動從中間刪除，防止報告過長，難以閱讀。完整的錯誤消息老是顯示在關鍵字失敗的日誌消息中。

回溯

異常的回溯也使用DEBUG 日誌級別進行記錄。這些消息默認狀況下在日誌文件中不可見，由於它們對於普通用戶來講不多有意思。開發庫時，一般使用運行測試是一個好主意--loglevel DEBUG。

中止測試執行

從Robot Framework 2.5開始，有可能使測試用例失敗，從而中止整個測試的執行。這是經過在關鍵字引起的異常上設置一個特殊的 ROBOT_EXIT_ON_FAILURE屬性True來完成的。這在下面的例子中說明。

蟒蛇：

class  MyFatalError （RuntimeError ）：    ROBOT_EXIT_ON_FAILURE  =  True

Java的：

公共 類 MyFatalError  延伸 的RuntimeException  {     公共 靜態 最終 布爾 ROBOT_EXIT_ON_FAILURE  =  真; }

儘管失敗，繼續測試執行

從Robot Framework 2.5開始，即便出現故障，也能夠繼續執行測試。從測試庫發出信號的方式是添加一個特殊的ROBOT_CONTINUE_ON_FAILURE 屬性，True用來傳遞失敗的異常。下面的例子說明了這一點。

蟒蛇：

類 MyContinuableError （RuntimeError ）：    ROBOT_CONTINUE_ON_FAILURE  =  真

Java的：

公共 類 MyContinuableError  延伸 RuntimeException  {     公共 靜態 最終 布爾 ROBOT_CONTINUE_ON_FAILURE  =  true ; }

記錄信息

異常消息不是向用戶提供信息的惟一方式。除此以外，方法還能夠簡單地經過寫入標準輸出流（stdout）或標準錯誤流（stderr）來將消息發送到日誌文件，甚至能夠使用不一樣的日誌級別。另一種更好的記錄方式是使用編程式日誌記錄API。

默認狀況下，由方法寫入標準輸出的全部內容都將做爲具備日誌級別的單個條目寫入日誌文件 INFO。寫入標準錯誤的消息的處理方式與此相似，可是在關鍵字執行完成以後，它們會回傳到原始標準錯誤。所以，若是須要在執行測試的控制檯上顯示一些消息，則能夠使用stderr。

使用日誌級別

要使用其它日誌級別高於INFO或建立多個郵件，明確地經過嵌入水平進入格式郵件指定的日誌級別*LEVEL* Actual log message，其中 *LEVEL*必須在一行的開頭，LEVEL是可用的日誌記錄級別之一TRACE，DEBUG， INFO，WARN，FAIL和HTML。

警告

具備WARN級別的消息會自動寫入控制檯，並記入日誌文件中單獨的「測試執行錯誤」部分。這使得警告比其餘消息更加明顯，並容許使用它們向用戶報告重要但非關鍵的問題。

記錄HTML

一般由庫所記錄的全部內容都將被轉換成能夠安全地表示爲HTML的格式。例如， <b>foo</b>將顯示在日誌徹底同樣，而不是foo。若是圖書館想要使用格式化，連接，顯示圖像等，他們能夠使用一個特殊的僞日誌級別 HTML。Robot Framework會將這些消息直接寫入日誌中INFO，這樣他們能夠使用任何他們想要的HTML語法。請注意，這個功能須要謹慎使用，由於，例如，一個放置很差的</table>標籤可能會毀壞日誌文件。

使用公共日誌記錄API時，各類日誌記錄方法都具備可選的html屬性，可將其設置True 爲啓用HTML格式的日誌記錄。

時間戳

默認狀況下，當執行的關鍵字結束時，經過標準輸出或錯誤流記錄的消息會獲得它們的時間戳。這意味着時間戳不許確，調試問題尤爲是長時間運行的關鍵字可能會產生問題。

從Robot Framework 2.6開始，若是有須要的話，關鍵字能夠爲他們記錄的消息添加一個準確的時間戳。自Unix時代起，時間戳必須以毫秒爲單位給出，而且它必須放置在用冒號分隔的日誌級別以後：

*信息：1308435758660 *帶時間戳的信息* HTML：1308435758661 *帶有時間戳的<b> HTML </ b>消息

以下面的例子所示，添加時間戳很容易使用Python和Java。若是您使用的是Python，那麼使用編程式日誌記錄API來獲取準確的時間戳就更容易了。明確添加時間戳的一大好處是，這種方法也適用於遠程庫接口。

蟒蛇：

進口 時間DEF  EXAMPLE_KEYWORD （）：    打印 '* INFO：％d 時間戳*消息'  ％ （時間。時間（）* 1000 ）

Java的：

public  void  exampleKeyword （） {     System 。出去。的println （「* INFO：」  +  系統。的currentTimeMillis （） +  「*消息具備時間戳」 ）; }

記錄到控制檯

若是圖書館須要寫一些東西給控制檯，他們有幾個選擇。如前所述，寫入標準錯誤流的警告和全部消息都寫入日誌文件和控制檯。這兩個選項都有一個侷限性，只有在當前執行的關鍵字結束以後，這些消息纔會終止到控制檯。一個好處是，這些方法與基於Python和Java的庫一塊兒工做。

另外一個選項，只能用於Python，正在寫郵件到sys.__stdout__或sys.__stderr__。使用這種方法時，消息當即寫入控制檯，根本不寫入日誌文件：

導入 系統def  my_keyword （arg ）：   sys 。__stdout__ 。寫（'有arg ％s \ n '  ％ arg ）

最後的選擇是使用公共日誌API：

從 robot.api  導入 記錄器def  log_to_console （arg ）：   記錄器。控制檯（'有arg ％s '  ％ arg ）def  log_to_console_and_log_file （arg ）   記錄器。info （' got arg ％s '  ％ arg ， also_console = True ）

記錄示例

在大多數狀況下，這個INFO級別是足夠的。低於它的級別， DEBUG而且TRACE，是用來寫字的調試信息很是有用。這些消息一般不會顯示，但它們能夠方便地調試庫中的可能的問題。該WARN級別能夠用來使消息更加可見，而且HTML若是須要任何種類的格式化是有用的。

如下示例闡明瞭如何使用不一樣級別的日誌進行工做。Java程序員應該把代碼print 'message' 看做僞代碼的意思System.out.println("message");。

打印 「圖書館的你好」 打印 '*警告*來自圖書館的警告。打印 '*信息*再次您好！打印 「這將成爲以前的消息的一部分。打印 '*信息*這是一個新的消息。打印 '*信息*這是<b>普通文字</ b>。print  '* HTML *這是<b>粗體</ b>。打印 '* HTML * <a href="http://robotframework.org">機器人框架</a>'

16：18：42.123	信息	你好，從圖書館。
16：18：42.123	警告	來自圖書館的警告。
16：18：42.123	信息	再一次問好！這將是之前的消息的一部分。
16：18：42.123	信息	這是一個新的消息。
16：18：42.123	信息	這是<b>普通文字</ b>。
16：18：42.123	信息	這是大膽的。
16：18：42.123	信息	機器人框架

程序化日誌API

與使用標準輸出和錯誤流相比，程序化API提供了更清晰的信息記錄方式。目前這些接口僅適用於Python基礎測試庫。

公共日誌記錄API

Robot Framework 2.6有一個新的基於Python的日誌記錄API，用於將消息寫入日誌文件和控制檯。測試庫能夠使用這個API，logger.info('My message')而不是像標準輸出同樣記錄print '*INFO* My message'。除了使用更加清潔的編程接口以外，此API還具備日誌消息具備準確時間戳的優勢。一個明顯的限制是使用這個日誌API的測試庫對Robot Framework有依賴性。

公共日誌API 在https://robot-framework.readthedocs.org中做爲API文檔的一部分進行了詳細記錄。如下是一個簡單的用法示例：

從 robot.api  導入 記錄器def  my_keyword （arg ）：    記錄器。調試（'有參數％s '  ％ arg ）    do_something （）    記錄器。info （'<i>這個</ i>是一個無聊的例子' ， html = True ）    記錄器。控制檯（'Hello，console！' ）

使用Python的標準`logging`模塊

除了新的公共日誌API外，Robot Framework 2.6還爲Python的標準日誌記錄模塊添加了一個內置的支持。這能夠使模塊的根記錄器接收的全部消息自動傳播到Robot Framework的日誌文件。此API 也會生成具備準確時間戳的日誌消息，但不支持記錄HTML消息或將消息寫入控制檯。下面這個簡單的例子也說明了一個很大的好處，就是使用這個日誌API不會對Robot Framework產生任何依賴。

導入 日誌def  my_keyword （arg ）：    日誌記錄。調試（'有參數％s '  ％ arg ）    do_something （）    日誌記錄。info （'這是一個無聊的例子' ）

該logging模塊的日誌級別與Robot Framework略有不一樣。它的級別DEBUG，INFO並直接映射到匹配的機器人框架日誌級別和WARNING 以上的一切都映射到WARN。自定義級別低於 DEBUG被映射到DEBUG之間的一切， DEBUG而且WARNING被映射到INFO。

在庫初始化期間記錄

在測試庫導入和初始化期間，庫也能夠記錄。這些消息不像正常的日誌消息那樣出如今日誌文件中，而是寫入系統日誌。這容許記錄關於庫初始化的任何有用的調試信息。使用該WARN級別記錄的消息也能夠在日誌文件的測試執行錯誤部分中看到。

在導入和初始化期間進行記錄能夠使用標準輸出和錯誤流以及編程式日誌記錄API。這兩個都在下面演示。

Java庫在初始化期間經過stdout進行日誌記錄：

公共 類 LoggingDuringInitialization  {    公共 LoggingDuringInitialization （） {         系統。出去。println （「* INFO *初始化庫」 ）;     }    public  void  keyword （） {         // ...     } }

導入期間使用日誌記錄API的Python庫日誌記錄：

從 robot.api  導入 記錄器記錄器。調試（「導入庫」 ）def  關鍵字（）：    ＃...

注意

若是你在初始化過程當中記錄了一些東西，例如在Python __init__或Java構造函數中，根據測試庫的做用域，這些消息可能被記錄屢次。

注意

在Robot初始化期間對日誌消息寫入syslog的支持是Robot Framework 2.6中的一個新特性。

返回值

關鍵字返回到核心框架的最後一種方式是返回從測試系統中檢索或經過其餘方式生成的信息。返回的值能夠分配給測試數據中的變量，而後用做其餘關鍵字的輸入，即便是來自不一樣的測試庫。

使用returnPython和Java方法中的語句返回值。一般，將一個值分配到一個標量變量中，以下例所示。這個例子還說明能夠返回任何對象並使用擴展變量語法來訪問對象屬性。

從 mymodule  導入 MyObjectdef  return_string （）：    return  「Hello，world！」def  return_object（name ）：    return  MyObject （name ）

從關鍵字返回一個值
$ {string} =	返回字符串
應該是平等的	$ {}字符串	你好，世界！
$ {object} =	返回對象	機器人
應該是平等的	$ {} object.name	機器人

關鍵字還能夠返回值，以即可以將它們分配到幾個標量變量中，列表變量或標量變量和列表變量中。全部這些用法都要求返回的值是Python列表或元組，或者Java數組，列表或迭代器。

def  return_two_values （）：    返回 '第一個值' ，  '第二個值'def  return_multiple_values （）：    return  [ 'a' ， 'list' ， 'of' ， 'strings' ]

返回多個值
$ {VAR1}	$ {var2} =	返回兩個值
應該是平等的	$ {VAR1}	第一價值
應該是平等的	$ {} VAR2	第二值
@ {list} =	返回兩個值
應該是平等的	@ {列表} [0]	第一價值
應該是平等的	@ {列表} [1]	第二值
$ {} S1	$ {} S2	@ {li} =	返回多個值
應該是平等的	$ {s1} $ {s2}	一個列表
應該是平等的	@ {li} [0] @ {li} [1]	的字符串

使用線程時的通訊

若是庫使用線程，它一般應該只從主線程與框架進行通訊。例如，若是一個工做者線程有報告失敗或某些事情要記錄，它應該首先將信息傳遞給主線程，而後主線程能夠使用本節中介紹的異常或其餘機制來與框架進行通訊。

當線程在其餘關鍵字運行時在後臺運行時，這一點尤其重要。在這種狀況下與框架進行通訊的結果是未定義的，而且能夠在最壞的狀況下致使崩潰或損壞的輸出文件。若是關鍵字在後臺啓動，則應該有另外一個關鍵字來檢查工做線程的狀態並相應地收集收集的信息。

注意

從Robot Framework 2.6.2開始，非主線程使用編程式日誌記錄API記錄的信息被忽略。

4.1.5分發測試庫

記錄庫

沒有關於它包含什麼關鍵字的文檔的測試庫以及這些關鍵字所作的事情是沒用的。爲了便於維護，強烈建議將圖書館文檔包含在源代碼中並由其生成。基本上，這意味着在Python中使用docstrings，在Java中使用Javadoc，以下面的示例所示。

class  MyLibrary ：    「」「這是一個帶有一些文檔的示例庫。」「」    def  keyword_with_short_documentation （self ， argument ）：        「」「這個關鍵字只有一個簡短的文檔」「」         pass    def  keyword_with_longer_documentation （self ）：        「」「文檔的第一行就在這裏。        更長的文檔繼續在這裏，它能夠包含        多行或段落。        「」         經過

/ ** *這是一個包含一些文檔的示例庫。* / public  class  MyLibrary  {    / **      *這個關鍵字只有一個簡短的文檔     * /     public  void  keywordWithShortDocumentation （String  argument ） {     }    / **      *文檔的第一行是在這裏。     *      *更長的文檔繼續在這裏，它能夠包含     *多行或段落。     * /     public  void  keywordWithLongerDocumentation （） {     }}

Python和Java都有建立如上所述的庫的API文檔的工具。可是，這些工具的輸出對於某些用戶來講多是稍微技術性的。另外一種選擇是使用Robot Framework本身的文檔工具Libdoc。此工具能夠使用靜態庫API（如上面的庫）從Python和Java庫建立庫文檔，但也能夠使用動態庫API和混合庫API處理庫。

關鍵字文檔的第一行用於特殊用途，並應包含對關鍵字的簡短描述。它被用做一個簡短的文檔，好比做爲Libdoc的一個工具提示，也顯示在測試日誌中。可是，後者不能與使用靜態API的Java庫一塊兒工做，由於它們的文檔在編譯時會丟失，在運行時不可用。

默認狀況下，文檔被認爲是遵循Robot Framework的文檔格式規則。這個簡單的格式容許常用的樣式，好比*bold*和_italic_，表格，列表，連接等從機器人框架2.7.5開始，能夠使用HTML也，純文本和新結構化格式。有關如何設置庫源代碼和Libdoc章節中的格式的更多信息，請參閱指定文檔格式部分。

注意

若是要在Python庫的文檔中使用非ASCII字符，則必須使用UTF-8做爲源代碼編碼，或者將Unicode文檔建立爲Unicode。

測試庫

任何非平凡的測試庫都須要進行完全的測試，以防止其中的錯誤。固然，這個測試應該是自動化的，以便在庫改變時從新運行測試。

Python和Java都有出色的單元測試工具，並且它們很是適合測試庫。與使用它們進行一些其餘測試相比，使用它們沒有什麼重大差異。熟悉這些工具的開發人員不須要學習任何新東西，不熟悉這些工具的開發人員也應該學習它們。

使用Robot Framework自己也能夠很方便地測試庫，這樣就能夠對它們進行實際的端到端驗收測試。爲此，在BuiltIn庫中有許多有用的關鍵字。值得一提的是運行關鍵字和指望錯誤，這對於測試關鍵字報告錯誤是很是有用的。

是否使用單元級或接受級測試方法取決於上下文。若是須要模擬被測試的實際系統，則在單元級別上一般更容易。另外一方面，驗收測試確保關鍵字經過Robot Framework工做。若是你不能決定，固然能夠使用這兩種方法。

打包庫

庫實現，記錄和測試後，仍然須要分發給用戶。對於由單個文件組成的簡單庫，一般要求用戶將該文件複製到某處並相應地設置庫搜索路徑。應該打包更復雜的庫以使安裝更容易。

因爲庫是正常的編程代碼，所以能夠使用普通的打包工具進行打包。使用Python，很好的選擇包括Python標準庫包含的 distutils和更新的 setuptools。這些工具的好處是，庫模塊安裝到庫搜索路徑中自動的位置。

使用Java時，將庫打包到JAR歸檔中是很天然的。在運行測試以前，必須將JAR包放入庫搜索路徑中，但建立一個可自動執行的啓動腳本很容易。

棄用關鍵字

有時須要用新的關鍵字替換現有的關鍵字，或者將其所有刪除。只是通知用戶有關更改可能並不老是足夠的，而且在運行時獲得警告更有效。爲了支持這一點，Robot Framework有能力標記不同意使用的關鍵字。這樣能夠更輕鬆地從測試數據中找到舊關鍵字並刪除或替換它們。

關鍵字經過使用文檔開始被棄用 *DEPRECATED*。執行這些關鍵字時，將包含其他短文檔的警告寫入控制檯，並寫入日誌文件中單獨的「測試執行錯誤」部分。例如，若是執行如下關鍵字，則會在日誌文件中顯示以下所示的警告。

def  example_keyword （argument ）：    「」「* DEPRECATED *改用關鍵字`Other Keyword`。    這個關鍵字作了一些給定的參數，並返回結果。    「」「     return  do_something （argument ）

20080911 16：00：22.650

警告

關鍵字「SomeLibrary.Example關鍵字」已被棄用。改成使用關鍵字「其餘關鍵字」。

這個棄用系統適用於大多數測試庫以及用戶關鍵字。惟一的例外是在使用靜態庫接口的Java測試庫中實現的關鍵字，由於它們的文檔在運行時不可用。使用這樣的關鍵字，能夠使用用戶關鍵字做爲包裝，並將其棄用。

有一個計劃，實施一個工具，能夠使用棄用信息自動替換棄用的關鍵字。該工具極可能會從文檔中獲取新關鍵字的名稱，以便在反引號內搜索單詞（`）。所以，它會從前面的例子中找到其餘關鍵字。請注意，Libdoc也使用相同的語法自動建立內部連接。

4.1.6動態庫API

動態API在很大程度上相似於靜態API。例如，報告關鍵字狀態，日誌記錄和返回值的工做方式徹底相同。最重要的是，與其餘庫相比，導入動態庫和使用關鍵字沒有區別。換句話說，用戶不須要知道他們的庫使用什麼API。

靜態庫和動態庫之間的區別僅在於Robot Framework如何發現庫實現的關鍵字，這些關鍵字具備哪些參數和文檔，以及關鍵字是如何實際執行的。使用靜態API，全部這些都是使用反射（Java庫的文檔除外）完成的，可是動態庫具備用於這些目的的特殊方法。

動態API的好處之一是，您能夠更靈活地組織庫。使用靜態API，您必須在一個類或模塊中包含全部關鍵字，而使用動態API，則能夠將每一個關鍵字做爲單獨的類來實現。可是，這個用例對於Python來講並非那麼重要，由於它的動態能力和多重繼承已經給了很大的靈活性，而且還有可能使用混合庫API。

動態API的另外一個主要用例是實現一個庫，以便它能夠做爲可能在其餘進程或甚至另外一臺機器上運行的實際庫的代理。這種代理庫可能很是薄，並且因爲關鍵字名稱和全部其餘信息是動態獲取的，因此當新的關鍵字添加到實際庫時，不須要更新代理。

本節介紹動態API如何在Robot Framework和動態庫之間起做用。Robot Framework如何實現這些庫並不重要（例如，如何將調用run_keyword方法映射到正確的關鍵字實現），而且可能有許多不一樣的方法。可是，若是您使用Java，則可能須要在實現本身的系統以前檢查 JavalibCore。這個可重複使用的工具集合支持多種建立關鍵字的方式，並且它極可能已經有了一個知足您需求的機制。

獲取關鍵字名稱

動態庫告訴他們用這個get_keyword_names方法實現了什麼關鍵字。該方法還具備getKeywordNames使用Java時推薦的別名。此方法不能接受任何參數，它必須返回包含庫實現的關鍵字名稱的字符串列表或數組。

若是返回的關鍵字名稱包含多個單詞，則能夠用空格或下劃線或camelCase格式將它們返回。例如['first keyword', 'second keyword']， ['first_keyword', 'second_keyword']和 ['firstKeyword', 'secondKeyword']都會被映射到關鍵字的第一關鍵字和第二關鍵字。

動態庫必須老是有這個方法。若是缺失，或者因爲某種緣由調用失敗，則該庫被認爲是一個靜態庫。

運行關鍵字

動態庫有一個特殊的run_keyword（別名 runKeyword）方法來執行他們的關鍵字。當測試數據中使用動態庫中的關鍵字時，Robot Framework使用庫的run_keyword方法來執行它。這個方法有兩個或三個參數。第一個參數是一個字符串，其中包含要以與返回的格式相同的格式執行的關鍵字的名稱get_keyword_names。第二個參數是給測試數據中關鍵字的參數列表或數組。

可選的第三個參數是一個字典（Java中的地圖），它能夠得到傳遞給關鍵字的可能的關鍵字參數（**kwargs）。有關在動態庫中使用kwargs的更多詳細信息，請參見動態庫的免費關鍵字參數。

得到關鍵字名稱和參數後，庫能夠自由執行關鍵字，但必須使用相同的機制做爲靜態庫與框架進行通訊。這意味着使用異常來報告關鍵字狀態，經過寫入標準輸出或使用提供的日誌API進行日誌記錄，並使用return語句run_keyword返回某些內容。

每一個動態庫必須同時擁有get_keyword_names和 run_keyword方法，但動態API中的其他方法是可選的。下面的例子展現了一個在Python中實現的工做，雖然很簡單，動態的庫。

類 DynamicExample ：    def  get_keyword_names （self ）：        return  [ 'first keyword' ， 'second keyword' ]    def  run_keyword （self ， name ， args ）：        print  「運行帶參數％s的關鍵字' ％s ' 。％（名稱，參數）

獲取關鍵字參數

若是一個動態庫只實現了get_keyword_names和 run_keyword方法，Robot Framework沒有關於實現的關鍵字須要的參數的任何信息。例如，上面例子中的First Keyword和Second Keyword均可以和任意數量的參數一塊兒使用。這是有問題的，由於大多數真正的關鍵字須要必定數量的關鍵字，在這種狀況下，他們須要檢查參數計數自己。

動態庫能夠經過使用get_keyword_arguments （別名getKeywordArguments）方法告訴Robot Framework它實現的關鍵字是什麼參數。此方法將關鍵字的名稱做爲參數，並返回包含由該關鍵字接受的參數的字符串列表或數組。

與靜態關鍵字相似，動態關鍵字能夠要求任意數量的參數，具備默認值，並接受可變數量的參數和可用的關鍵字參數。下表說明了如何表示全部這些不一樣變量的語法。請注意，這些示例對列表使用Python語法，但Java開發人員應該使用Java列表或字符串數組。

表明不一樣的論點 `get_keyword_arguments`
預期的論點	如何表示	例子	限制（最小/最大）
沒有參數	空的清單。	`[]`	0/0
一個或多個論點	包含參數名稱的字符串列表。	`['one_argument']` `['a1', 'a2', 'a3']`	1/1 3/3
參數的默認值	默認值與名稱分開`=`。默認值始終被認爲是字符串。	`['arg=default value']` `['a', 'b=1', 'c=2']`	0/1 1/3
可變數量的參數（可變參數）	最後（或者倒數第二個用kwargs）的參數`*` 在它的名字前面。	`['varargs']` `['a', 'b=42', 'rest']`	0 /任何 1 /任何
免費的關鍵字參數（kwargs）	最後的參數 `**`在它的名字以前。	`['kwargs']` `['a', 'b=42', 'kws']` `['varargs', '*kwargs']`	0/0 1/2 0 /任何

當get_keyword_arguments使用時，機器人框架自動計算關鍵字多少位置參數須要和它支持自由關鍵字參數或沒有。若是關鍵字與無效參數一塊兒使用，則會發生錯誤，run_keyword甚至不會被調用。

返回的實際參數名稱和默認值也很重要。他們都須要命名參數的支持和Libdoc 工具須要他們可以創造一個有意義的庫文件。

若是get_keyword_arguments缺乏或返回None或 null某個關鍵字，該關鍵字將得到一個接受全部參數的參數說明。這個自動參數規範是 [*varargs, **kwargs]或者[*varargs]，依賴有三個參數或不 run_keyword 支持kwargs。

獲取關鍵字文檔

動態庫能夠實現的最後一個特殊方法是 get_keyword_documentation（別名 getKeywordDocumentation）。它將一個關鍵字名稱做爲參數，而且如方法名稱所示，將其文檔做爲字符串返回。

返回的文檔與關鍵字文檔字符串的用法相似，用Python實現靜態庫。主要的用例是將關鍵字的文檔寫入由Libdoc生成的庫文檔中。此外，文檔的第一行（直到第一行\n）顯示在測試日誌中。

得到通用庫文檔

該get_keyword_documentation方法也可用於指定整個庫文檔。在執行測試時不會使用這個文檔，但它能夠使Libdoc生成的文檔好得多。

動態庫能夠提供通用庫文檔和與使用庫相關的文檔。前者是經過get_keyword_documentation具備特殊價值的召喚而得到的__intro__，然後者是經過價值得到的 __init__。如何使用Libdoc最好地測試文檔。

基於Python的動態庫也能夠直接在代碼中指定通用庫文檔做爲庫類及其__init__方法的文檔字符串。若是直接從代碼和get_keyword_documentation方法中得到非空文檔，則後者具備優先權。

注意

Robot Framework 2.6.2及更新版本支持獲取通用庫文檔。

用動態庫命名參數語法

從Robot Framework 2.8開始，動態庫API也支持命名的參數語法。使用語法工做基於參數名稱和使用該方法從庫中得到的默認值get_keyword_arguments。

對於大多數部分來講，命名參數語法與動態關鍵字徹底同樣，就像它支持它的任何其餘關鍵字同樣。惟一的特例是一個關鍵字有多個參數的狀況，其中只有一些是默認值。在這種狀況下，框架會根據get_keyword_arguments方法返回的缺省值填充跳過的可選參數。

如下示例說明了在動態庫中使用命名的參數語法。全部的例子都使用一個關鍵字Dynamic 來指定參數指定 [arg1, arg2=xxx, arg3=yyy]。最後一列顯示關鍵字實際被調用的參數。

使用具備動態關鍵字的命名參數語法
測試用例	行動	論據	論據	論據	跟隨
只有位置	動態	一個			＃ [一個]
動態	一個	b		＃[a，b]
動態	一個	b	C	＃[a，b，c]
命名	動態	一個	ARG2 = B		＃[a，b]
動態	一個	b	ARG3 = C	＃[a，b，c]
動態	一個	ARG2 = B	ARG3 = C	＃[a，b，c]
動態	ARG1 =一	ARG2 = B	ARG3 = C	＃[a，b，c]
填寫跳過	動態	一個	ARG3 = C		＃[a，xxx，c]

免費關鍵字參數與動態庫

從Robot Framework 2.8.2開始，動態庫也能夠支持免費的關鍵字參數（**kwargs）。這種支持的強制性前提是該run_keyword方法有三個參數：第三個參數在使用時會獲得kwargs。Kwargs做爲字典（Python）或Map（Java）傳遞給關鍵字。

關鍵字接受什麼參數取決於get_keyword_arguments 返回值。若是最後一個參數開始**，該關鍵字被識別爲接受kwargs。

如下示例說明了如何在動態庫中使用免費關鍵字參數語法。全部的例子都使用一個關鍵字Dynamic 來指定參數指定 [arg1=xxx, arg2=yyy, **kwargs]。最後一列顯示關鍵字實際被調用的參數。

使用免費關鍵字參數與動態關鍵字
測試用例	行動	論據	論據	論據	跟隨
沒有參數	動態				＃[]，{}
只有位置	動態	一個			＃ [一個]， {}
動態	一個	b		＃[a，b]，{}
只有kwargs	動態	a = 1時			＃[]，{a：1}
動態	a = 1時	B = 2	C = 3	＃[]，{a：1，b：2，c：3}
位置和kwargs	動態	一個	B = 2		＃[a]，{b：2}
動態	一個	B = 2	C = 3	＃[a]，{b：2，c：3}
命名和kwargs	動態	ARG1 =一	B = 2		＃[a]，{b：2}
動態	ARG2 =一	B = 2	C = 3	＃[xxx，a]，{b：2，c：3}

概要

下表列出了動態API中的全部特殊方法。方法名稱如下劃線格式列出，但其camelCase別名的工做方式徹底相同。

動態API中的全部特殊方法
名稱	參數	目的
`get_keyword_names`		返回實施的關鍵字的名稱。
`run_keyword`	`name, arguments, kwargs`	用給定的參數執行指定的關鍵字。`kwargs`是可選的。
`get_keyword_arguments`	`name`	返回關鍵字的參數說明。可選方法。
`get_keyword_documentation`	`name`	返回關鍵字「和庫的文檔。可選方法。

用Java編寫一個正式的接口規範是可能的，以下所示。可是，請記住，圖書館不須要實現任何顯式的接口，由於機器人框架直接與反射檢查，若是庫具備所需get_keyword_names和 run_keyword方法或者其駝峯的別名。此外， get_keyword_arguments和get_keyword_documentation 徹底是可選的。

公共 接口 RobotFrameworkDynamicAPI  {    List < String >  getKeywordNames （）;    對象 runKeyword （字符串 名稱， 列表 參數）;    Object  runKeyword （String  name ， List  arguments ， Map  kwargs ）;    List < String >  getKeywordArguments （String  name ）;    String  getKeywordDocumentation （String  name ）;}

注意

除了使用List，還能夠使用像Object[]或者數組String[]。

使用動態API的一個很好的例子是Robot Framework本身的遠程庫。

4.1.7混合庫API

顧名思義，混合庫API就是靜態API和動態API的混合體。就像使用動態API同樣，使用混合API只能做爲一個類來實現庫。

獲取關鍵字名稱

關鍵字名稱的獲取方式與動態API徹底相同。在實踐中，庫須要讓 get_keyword_namesor getKeywordNames方法返回庫實現的關鍵字名稱列表。

運行關鍵字

在混合API中，沒有run_keyword執行關鍵字的方法。相反，Robot Framework使用反射來查找實現關鍵字的方法，相似於靜態API。使用混合API的庫能夠直接實現這些方法，更重要的是，它能夠動態地處理它們。

在Python中，用這個方法動態地處理缺失的方法是很容易的 __getattr__。大多數Python程序員可能都熟悉這種特殊的方法，他們能夠當即理解下面的例子。其餘人可能會首先查閱Python參考手冊更容易。

從 某處 導入 external_keyword類 HybridExample ：    def  get_keyword_names （self ）：        return  [ 'my_keyword' ， 'external_keyword' ]    def  my_keyword （self ， arg ）：        print  「個人關鍵字用％s 調用」  ％ arg    def  __getattr__ （self ， name ）：        if  name  ==  'external_keyword' ：            return  external_keyword         raise  AttributeError （「不存在的屬性' ％s '」  ％ name ）

請注意，__getattr__不像run_keyword動態API 那樣執行實際的關鍵字。相反，它只返回一個由Robot Framework執行的可調用對象。

還有一點須要注意的是，Robot Framework使用相同的名稱get_keyword_names來查找實現它們的方法。所以，在類中實現的方法的名稱必須以與定義的格式相同的格式返回。例如，上面的庫不能正常工做，若是 get_keyword_names返回My Keyword而不是my_keyword。

混合API對於Java來講並非很是有用，由於不可能用它來處理丟失的方法。固然，也能夠在庫類中實現全部的方法，可是與靜態API相比，這並無什麼好處。

獲取關鍵字參數和文檔

當使用這個API時，Robot Framework使用反射來查找實現關鍵字的方法，相似於靜態API。在得到對該方法的引用後，它將以與使用靜態API相同的方式從其中搜索參數和文檔。所以，不須要像動態API那樣獲取參數和文檔的特殊方法。

概要

在Python中實現測試庫時，混合API具備與實際動態API相同的動態功能。一個很大的好處是，沒有必要有特殊的方法來獲取關鍵字參數和文檔。只有真正的動態關鍵字須要處理，__getattr__而其餘的則能夠直接在主庫類中實現。

因爲明確的優點和相同的功能，在使用Python時，混合API在大多數狀況下是比動態API更好的選擇。一個值得注意的例外是將庫實現爲其餘地方實際庫實現的代理，由於那麼實際的關鍵字必須在別處執行，而且代理只能傳遞關鍵字名稱和參數。

使用混合API的一個很好的例子是Robot Framework本身的 Telnet庫。

4.1.8使用Robot Framework的內部模塊

使用Python實現的測試庫能夠使用Robot Framework的內部模塊，例如獲取有關執行的測試和使用的設置的信息。可是，這個與框架進行通訊的強大機制應該謹慎使用，由於全部Robot Framework的API並非用於外部的，它們可能會在不一樣的框架版本之間發生根本性的變化。

可用的API

從Robot Framework 2.7開始，API文檔單獨存在於Read the Docs服務中。若是您不肯定如何使用某些API或正在使用它們向前兼容，請發送問題到郵件列表。

使用BuiltIn庫

要使用的最安全的API是在BuiltIn庫中實現關鍵字的方法。對關鍵字的更改不多見，並且始終是這樣作的，由於舊的用法首先被棄用。最有用的方法之一是replace_variables容許訪問當前可用的變量。下面的例子演示瞭如何得到 ${OUTPUT_DIR}這是許多方便的自動變量之一。它也能夠使用圖書館設置新的變量set_test_variable，set_suite_variable和 set_global_variable。

進口 os.path中從 robot.libraries.BuiltIn  進口 內建DEF  do_something （參數）：    輸出 =  do_something_that_creates_a_lot_of_output （參數）    outputdir  =  內建（） 。replace_variables （'$ {OUTPUTDIR}' ）    path  =  os 。路徑。join （outputdir ， 'results.txt' ）    f  =  open （path ， 'w' ）    f 。寫（輸出）    f 。關（）    打印 '* HTML *輸出寫入<a href="results.txt"> results.txt </a>

使用方法的惟一方法BuiltIn就是全部 run_keyword方法變體都必須專門處理。使用run_keyword方法的方法必須使用模塊中的方法本身註冊爲運行關鍵字。這個方法的文檔解釋了爲何須要這樣作，顯然也是如何作到這一點。register_run_keywordBuiltIn

4.1.9擴展示有的測試庫

本節介紹瞭如何向現有測試庫添加新功能以及如何在本身的庫中使用它們的不一樣方法。

修改原始源代碼

若是您有權訪問要擴展的庫的源代碼，則能夠直接修改源代碼。這種方法的最大問題是，你可能很難更新原始庫而不影響你的改變。對於用戶來講，使用具備與原始功能不一樣的功能的庫也可能會引發混淆。從新包裝圖書館也多是一個很大的額外任務。

若是加強功能是通用的，而且您計劃將其提交給原始開發人員，則此方法很是有效。若是您的更改應用於原始庫，則會將其包含在未來的版本中，並緩解上面討論的全部問題。若是更改是非通用的，或者因爲某些其餘緣由您沒法將其提交回來，那麼後面部分中解釋的方法可能會更好。

使用繼承

擴展示有庫的另外一個直接方法是使用繼承。下面的例子說明了這一點，即將SeleniumLibrary中的關鍵字添加到新的標題。這個例子使用Python，可是顯然能夠用Java代碼以相同的方式擴展示有的Java庫。

從 SeleniumLibrary  導入 SeleniumLibrary類 ExtendedSeleniumLibrary （SeleniumLibrary ）：    def  title_should_start_with （self ， expected ）：        title  =  self 。get_title （）        若是 不是 標題。startswith （預期）：            raise  AssertionError （「標題' ％s '沒有以' ％s '開始」                                  ％ （title ， expected ））

與修改原始庫相比，這種方法有一個很大的不一樣之處在於新庫的名稱與原始庫不一樣。一個好處是，你能夠很容易地告訴你正在使用一個自定義的庫，但一個大問題是，你不能輕易地使用原來的新庫。首先，你的新圖書館將有相同的關鍵字，原來的意思，老是有衝突。另外一個問題是，圖書館不分享他們的狀態。

當您開始使用新的庫並但願從頭開始添加自定義加強功能時，此方法能夠很好地工做。不然本節中解釋的其餘機制可能會更好。

直接使用其餘庫

由於測試庫在技術上只是類或模塊，因此使用另外一個庫的簡單方法是導入它並使用它的方法。當方法是靜態的而且不依賴於庫狀態時，這種方法效果很好。前面使用Robot Framework的BuiltIn庫的例子說明了這一點。

若是圖書館有國家，然而，事情可能不會像你所但願的那樣工做。您在庫中使用的庫實例不會與框架使用的相同，所以執行的關鍵字所作的更改對您的庫不可見。下一節將介紹如何訪問框架使用的同一個庫實例。

從Robot Framework獲取活動的庫實例

Robot Framework 2.5.2添加了新的BuiltIn關鍵字Get Library Instance，它能夠用來從框架自己獲取當前活動的庫實例。這個關鍵字返回的庫實例與框架自己使用的相同，所以看到正確的庫狀態沒有問題。儘管此功能可用做關鍵字，但它一般經過導入BuiltIn庫類來直接在測試庫中使用，如前所述。下面的例子說明了如何使用繼承來實現相同的標題應該從關鍵字開始。

從 robot.libraries.BuiltIn  導入 BuiltIndef  title_should_start_with （預期）：    seleniumlib  =  BuiltIn （）。get_library_instance （'SeleniumLibrary' ）    title  =  seleniumlib 。get_title （）    若是 不是 標題。startswith （預期）：        raise  AssertionError （「標題' ％s '沒有以' ％s '開始」                              ％ （title ， expected ））

這種方法顯然比直接導入庫並在庫有狀態時使用它更好。繼承的最大好處是能夠正常使用原始庫，並在須要時使用新庫。這在下面的例子中獲得了證實，在這個例子中，來自前面例子的代碼能夠在新的庫SeLibExtensions中使用。

使用庫和擴展它的另外一個庫
設置	值	值	值
圖書館	SeleniumLibrary
圖書館	SeLibExtensions

測試用例	行動	論據	論據
例	打開瀏覽器	HTTP：//例子	＃SeleniumLibrary
標題應該以	例	＃SeLibExtensions

使用動態或混合API的庫

使用動態或混合庫API的測試庫一般有本身的系統如何擴展它們。有了這些庫，您須要向圖書館開發人員詢問指導，或查閱圖書館文檔或源代碼。

4.2遠程庫接口

遠程庫接口提供了在不一樣於機器人框架自己運行的機器上安裝測試庫的方法，也能夠使用除本機支持的Python和Java以外的其餘語言來實現庫。對於測試庫用戶而言，遠程庫看起來與其餘測試庫幾乎相同，使用遠程庫接口開發測試庫也很是接近建立常規測試庫。

4.2.1簡介

使用遠程庫API有兩個主要緣由：

在不一樣機器上運行Robot Framework的地方可能有實際的庫。這爲分佈式測試提供了有趣的可能。
測試庫能夠使用任何支持XML-RPC協議的語言來實現。在寫這篇文章的時候，已經有針對Python，Java，Ruby，.NET，Clojure，Perl和node.js的現成的遠程服務器。

遠程庫接口由做爲標準庫之一的遠程庫提供。這個庫沒有本身的關鍵字，但它做爲核心框架和其餘地方實現的關鍵字之間的代理。遠程庫經過遠程服務器與實際庫實現進行交互，遠程庫和服務器使用XML-RPC通道上的簡單遠程協議進行通訊。全部這些的高層架構以下圖所示：

SRC / ExtendingRobotFramework / remote.png

帶有遠程庫的Robot Framework體系結構

注意

遠程客戶端使用Python的標準xmlrpclib模塊。它不支持由某些XML-RPC服務器實現的自定義XML-RPC擴展。

4.2.2使用遠程庫

導入遠程庫

遠程庫須要知道遠程服務器的地址，不然導入並使用它提供的關鍵字與其餘庫的使用方式沒有什麼不一樣。若是您須要在測試套件中屢次使用遠程庫，或者只是想給它一個更具描述性的名稱，則能夠使用WITH NAME語法將其導入。

導入遠程庫
設置	值	值	值	值	值
圖書館	遠程	http://127.0.0.1:8270	與姓名	例1
圖書館	遠程	http://example.com:8080/	與姓名	例題
圖書館	遠程	http://10.0.0.2/example	1分鐘	與姓名	示例3

上面第一個示例使用的URL也是遠程庫在未給出地址的狀況下使用的默認地址。一樣，端口 8270是遠程服務器默認使用的端口。（82和70分別是字母R和ASCII碼F）。

注意

鏈接本地機器時，建議使用地址127.0.0.1代替localhost。這避免了至少在Windows上的地址解析速度很是慢。在Robot Framework 2.8.4以前，遠程庫自己localhost默認使用的速度可能很慢。

注意

請注意，若是URI在服務器地址以後不包含路徑，則遠程庫使用的xmlrpclib模塊將/RPC2默認使用路徑。實際上使用 http://127.0.0.1:8270與使用相同 http://127.0.0.1:8270/RPC2。根據遠程服務器的不一樣，這多是也可能不是問題。即便路徑是正確的，若是地址有路徑，也不會追加額外的路徑/。例如，既http://127.0.0.1:8270/不會也 http://127.0.0.1:8270/my/path不會被修改。

上面的最後一個例子展現瞭如何給遠程庫提供一個自定義超時做爲可選的第二個參數。最初鏈接到服務器時以及鏈接意外關閉時使用超時。超時能夠在機器人的框架來給出的時間格式像60s或2 minutes 10 seconds。

默認超時時間一般是幾分鐘，但取決於操做系統及其配置。請注意，設置比關鍵字執行時間短的超時將會中斷關鍵字。

注意

支持超時是Robot Framework 2.8.6中的一項新功能。超時不適用於Python / Jython 2.5或IronPython。

啓動和中止遠程服務器

在導入遠程庫以前，必須啓動提供實際關鍵字的遠程服務器。若是在啓動測試執行以前啓動服務器，則能夠使用上例中的常規庫設置。或者，其餘關鍵字（例如OperatingSystem或SSH庫）能夠啓動服務器，可是您可能須要使用Import Library關鍵字，由於在測試執行開始時庫不可用。

如何遠程服務器能夠中止取決於如何實現。一般服務器支持如下方法：

不管使用哪一個庫，遠程服務器都應該提供Stop Remote Server關鍵字，這個關鍵字能夠被執行的測試輕鬆使用。
遠程服務器應該stop_remote_server在其XML-RPC接口中有方法。
擊中Ctrl-C在服務器運行應中止服務器控制檯上。
服務器進程能夠使用操做系統提供的工具來終止（例如kill）。

注意

能夠配置服務器，以便用戶不能使用Stop Remote Server關鍵字或stop_remote_server 方法中止它。

4.2.3支持的參數和返回值類型

因爲XML-RPC協議不支持全部可能的對象類型，所以在遠程庫和遠程服務器之間傳輸的值必須轉換爲兼容類型。這適用於遠程庫傳遞給遠程服務器和返回值服務器返回到遠程庫的關鍵字參數。

遠程庫和Python遠程服務器都按照如下規則處理Python值。其餘遠程服務器的行爲應該相似。

字符串，數字和布爾值傳遞沒有修改。
Python None被轉換爲空字符串。
全部列表，元組和其餘可迭代對象（字符串和字典除外）都以列表形式傳遞，以便遞歸地轉換其內容。
字典和其餘映射做爲字符傳遞，以便將它們的鍵轉換爲字符串並將值轉換爲支持的類型。
包含沒法用XML表示的ASCII範圍字節的字符串（例如空字節）做爲內部使用XML-RPC base64數據類型的二進制對象發送。接收到的二進制對象會自動轉換爲字節字符串。
其餘類型轉換爲字符串。

注意

在Robot Framework 2.8.3以前，根據上述規則只處理列表，元組和字典。通用的迭代和映射不被支持。

二進制支持在Robot Framework 2.8.4中是新的。

4.2.4遠程協議

本節介紹在遠程庫和遠程服務器之間使用的協議。這些信息主要針對想要建立新的遠程服務器的人員。提供的Python和Ruby服務器也能夠用做示例。

遠程協議是在XML-RPC之上實現的，XML-RPC是一個使用XML over HTTP的簡單遠程過程調用協議。大多數主流語言（Python，Java，C，Ruby，Perl，Javascript，PHP等）都支持XML-RPC，不管是內置的仍是擴展的。

必需的方法

遠程服務器是一個XML-RPC服務器，其動態庫API必須在其公共接口中具備相同的方法。只有 get_keyword_names和run_keyword實際須要，但get_keyword_arguments並 get_keyword_documentation還建議。請注意，在方法名稱中使用camelCase格式目前是不可能的。如何實現實際的關鍵字與遠程庫無關。遠程服務器既能夠做爲真正的測試庫的包裝，就像提供的Python和Ruby服務器同樣，也能夠本身實現關鍵字。

遠程服務器還應該stop_remote_server 在其公共接口中使用方法來緩解這些問題。他們還應該自動將此方法公開爲Stop Remote Server 關鍵字，以容許在測試數據中使用它，而無論測試庫如何。容許用戶中止服務器並不老是可取的，服務器可能支持以某種方式禁用該功能。該方法，也暴露的關鍵字，應該返回True 或False取決於中止容許與否。這使外部工具知道中止服務器是否成功。

提供的Python遠程服務器能夠用做參考實現。

獲取遠程關鍵字名稱和其餘信息

遠程庫獲取遠程服務器使用get_keyword_names方法提供的關鍵字列表。此方法必須將關鍵字名稱做爲字符串列表返回。

遠程服務器能夠也應該實現 get_keyword_arguments和get_keyword_documentation 提供關於關鍵字的更多信息的方法。這兩個關鍵字都將關鍵字的名稱做爲參數。參數必須以與動態庫相同的格式返回爲字符串列表，而且文檔必須以字符串形式返回。

從Robot Framework 2.6.2開始，遠程服務器還能夠提供通用庫文檔，以在使用libdoc工具生成文檔時使用。

執行遠程關鍵字

當遠程庫但願服務器執行某個關鍵字時，它會調用遠程服務器的run_keyword方法，並將關鍵字名稱，參數列表以及可能的免費關鍵字參數字典傳遞給它。基本類型能夠直接用做參數，可是更復雜的類型能夠轉換爲支持的類型。

服務器必須在包含下表中解釋的項目的結果字典（或映射，取決於術語）中返回執行結果。請注意，只有status條目是強制性的，其餘條目若是不適用，則能夠省略。

遠程結果字典中的條目
名稱	說明
狀態	強制執行狀態。經過或失敗。
產量	可能的輸出寫入日誌文件。必須以單個字符串形式給出，但能夠包含多個消息和格式不一樣的日誌級別`INFO First message\nHTML <b>2nd</b>\nWARN Another message`。也能夠將時間戳嵌入到日誌消息中`INFO:1308435758660 Message with timestamp`。
返回	可能的返回值。必須是受支持的類型之一。
錯誤	可能的錯誤消息。僅在執行失敗時使用。
追溯	當執行失敗時，可能的堆棧跟蹤使用DEBUG級別寫入日誌文件。
可持續	當設置爲`True`或`True`Python中考慮的任何值時，發生的故障被認爲是能夠繼續的。Robot Framework 2.8.4中的新功能
致命	像`continuable`，但表示發生的故障是致命的。在Robot Framework 2.8.4中也是新的。

不一樣的參數語法

遠程庫是一個動態庫，一般它根據與任何其餘動態庫相同的規則處理不一樣的參數語法。這包括強制參數，默認值，可變參數，以及命名參數語法。

另外，免費的關鍵字參數（**kwargs）與其餘動態庫的工做方式大體相同。首先， get_keyword_arguments必須返回一個**kwargs與其餘動態庫徹底相同的參數說明。主要區別在於遠程服務器的run_keyword方法必須有可選的第三個參數來獲取用戶指定的kwargs。第三個參數必須是可選的，由於出於向後兼容的緣由，run_keyword只有在測試數據中使用了kwargs時，遠程庫纔會將kwargs傳遞給方法。

在實踐中run_keyword應該看起來像下面的Python和Java示例，這取決於語言如何處理可選參數。

def  run_keyword （name ， args ， kwargs = None ）：    ＃...

public  Map  run_keyword （String  name ， List  args ） {     // ... }public  Map  run_keyword （String  name ， List  args ， Map  kwargs ） {     // ... }

注意

遠程庫支持**kwargs從Robot Framework 2.8.3開始。

4.3使用監聽器接口

Robot Framework有一個監聽器接口，能夠用來接收有關測試執行的通知。監聽器是具備特定方法的類或模塊，能夠用Python和Java實現。偵聽器接口的使用示例包括外部測試監視器，測試失敗時發送郵件消息以及與其餘系統通訊。

4.3.1聽取使用者的意見

監聽器從--listener 選項的命令行中被使用，因此監聽器的名字被做爲參數賦予它。偵聽器名稱是從實現偵聽器接口的類或模塊的名稱得到的，相似於從實現它們的類得到測試庫名稱。指定的偵聽器必須位於同一個模塊搜索路徑中，在這些路徑中搜索測試庫的時間。其餘選項與給測試庫相似地給出監聽器文件的絕對路徑或相對路徑。經過屢次使用此選項能夠使多個偵聽器可用。

也能夠從命令行給偵聽器類提供參數。在偵聽器名稱（或路徑）以後使用冒號做爲分隔符指定參數。這種方法只提供字符串類型的參數和參數，顯然不能包含冒號。可是，聽衆應該很容易去解決這些限制。

例子：

pybot --listener MyListener tests.htmljybot --listener com.company.package.Listener tests.htmlpybot --listener path / to / MyListener.py tests.htmlpybot --listener module.Listener --listener AnotherListener tests.htmlpybot --listener ListenerWithArgs：arg1：arg2pybot --listener path / to / MyListener.java：參數tests.html

4.3.2可用的監聽器接口方法

Robot Framework在測試執行開始時用給定的參數建立一個監聽器類的實例。在測試執行期間，當測試套件，測試用例和關鍵字開始和結束時，Robot Framework調用監聽器的方法。當輸出文件準備就緒時，它也調用適當的方法，最後調用close方法。監聽器不須要實現任何官方接口，只須要實際須要的方法便可。

監聽器接口版本

Robot Framework 2.1中更改了與測試執行進度有關的方法簽名。這個改變是爲了使新的信息能夠添加到監聽器接口而不會破壞現有的監聽器。舊的簽名將繼續工做，但在將來版本中將被棄用，因此全部新的收聽者都應該使用下表中描述的簽名來實現。舊監聽器接口的最新詳細描述能夠在Robot Framework 2.0.4的用戶指南中找到。

注意

偵聽器必須ROBOT_LISTENER_API_VERSION 定義屬性才能被識別爲新的樣式偵聽器。ROBOT_LISTENER_API_VERSION屬性的值必須是2，能夠是字符串，也能夠是整數。下面的例子被實現爲新的樣式監聽器。

偵聽器接口方法簽名

與測試執行進度相關的全部偵聽器方法都具備相同的簽名method(name, attributes)，其中attributes 是包含事件詳細信息的字典。下表列出了偵聽器接口中的全部可用方法以及attributes字典的內容（若是適用）。字典的鍵是字符串。全部這些方法也有camelCase別名。所以，例如，startSuite是一個同義詞start_suite。

監聽器接口中的可用方法
方法	參數	屬性/說明
start_suite	名稱，屬性	屬性字典中的鍵： ID：套房ID。頂層套件的「s1」，第一個子套件的「s1-s1」，第二個子套件的「s1-s2」等等。（2.8.5新增）長名稱：套件名稱，包括父級套件 doc：測試套件文檔元數據：包含免費測試套件元數據的字典/地圖（2.5中新增） source：文件/目錄測試套件的絕對路徑是從2.7中的new建立的，套房：直接在套房中的套房名稱做爲字符串列表（2.5中新增）測試：直接在這個套件中的測試名稱做爲字符串列表（2.5中的新增內容） totaltests：此套件及其全部子套件中的測試總數（以2.5爲單位）開始時間：執行開始時間
end_suite	名稱，屬性	屬性字典中的鍵： ID：套房ID。頂層套件的「s1」，第一個子套件的「s1-s1」，第二個子套件的「s1-s2」等等。（2.8.5新增）長名稱：測試套件名稱，包括父母 doc：測試套件文檔元數據：包含免費測試套件元數據的字典/地圖（2.6中的新增功能） source：文件/目錄測試套件的絕對路徑是從2.7中的new建立的，開始時間：執行開始時間 endtime：執行結束時間 elapsedtime：執行時間，以毫秒爲單位狀態：`PASS`或者`FAIL` 統計信息：套件統計信息（套件中傳遞和失敗的測試的數量）做爲字符串消息：若是套件設置或拆卸失敗，則爲錯誤消息，不然爲空
start_test	名稱，屬性	屬性字典中的鍵： id：以's1-s2-t2'格式測試id，其中begin是父套件id，最後一部分顯示該套件中的測試索引（2.8.5中新增）長名稱：測試名稱，包括父級套件 doc：測試用例文檔標籤：測試用例標籤做爲字符串列表關鍵：`yes`或`no`依賴於測試是否被認爲是關鍵性的（2.6中新增）模板：包含用於測試的模板的名稱。若是測試不是模板化的，它將是一個空字符串（2.6中的新增功能）開始時間：執行開始時間
end_test	名稱，屬性	屬性字典中的鍵： id：以's1-s2-t2'格式測試id，其中begin是父套件id，最後一部分顯示該套件中的測試索引（2.8.5中新增）長名稱：測試名稱，包括父級套件 doc：測試用例文檔標籤：測試用例標籤做爲字符串列表關鍵：`yes`或`no`依賴於測試是否被認爲是關鍵性的（2.6中新增）模板：包含用於測試的模板的名稱。若是測試不是模板化的，它將是一個空字符串（2.6中的新增功能）開始時間：執行開始時間 endtime：執行結束時間 elapsedtime：執行時間，以毫秒爲單位狀態：`PASS`或者`FAIL` 消息：狀態消息，一般是錯誤消息或空字符串
start_keyword	名稱，屬性	屬性字典中的鍵：類型：字符串`Keyword`正常關鍵字和`Test Setup`，`Test Teardown`，`Suite Setup`或`Suite Teardown`在套房/測試設置/拆卸使用的關鍵字（在2.6新） doc：關鍵字文檔 args：關鍵字的參數做爲字符串列表開始時間：執行開始時間
end_keyword	名稱，屬性	屬性字典中的鍵：類型：與 `start_keyword` doc：關鍵字文檔 args：關鍵字的參數做爲字符串列表開始時間：執行開始時間 endtime：執行結束時間 elapsedtime：執行時間，以毫秒爲單位狀態：`PASS`或者`FAIL`
log_message	信息	當執行關鍵字寫入日誌消息時調用。`message`是一個帶有如下鍵的字典：消息：消息的內容級別：用於記錄消息的日誌級別時間戳：消息建立時間，格式是 `YYYY-MM-DD hh:mm:ss.mil` html：string `yes`或者`no`表示消息是否應該被解釋爲HTML
信息	信息	當框架自己寫入系統日誌消息時調用。`message`是一個與`log_message`方法具備相同鍵的字典。
輸出文件	路徑	寫入輸出文件時調用完成。該路徑是文件的絕對路徑。
LOG_FILE	路徑	寫入日誌文件完成後調用。該路徑是文件的絕對路徑。
報告文件	路徑	寫入報告文件完成後調用。該路徑是文件的絕對路徑。
DEBUG_FILE	路徑	寫入調試文件完成後調用。該路徑是文件的絕對路徑。
關		在全部的測試套件以及測試用例中被調用，都被執行。

下面的正式Java接口規範中還顯示了可用的方法及其參數。的內容java.util.Map attributes如上述的表中。應該記住，一個監聽器不須要實現任何明確的接口或者具備全部這些方法。

公共 接口 RobotListenerInterface  {     public  static  final  int  ROBOT_LISTENER_API_VERSION  =  2 ;     無效 startSuite （字符串 名稱， Java的。UTIL 。地圖 屬性）;     無效 endSuite （字符串 名稱， Java的。UTIL 。地圖 屬性）;     無效 startTest （字符串 名稱， Java的。UTIL。地圖 屬性）;     無效 endTest （字符串 名稱， Java的。UTIL 。地圖 屬性）;     無效 startKeyword （字符串 名稱， Java的。UTIL 。地圖 屬性）;     無效 endKeyword （字符串 名稱， Java的。UTIL 。地圖 屬性）;     無效 的LogMessage （java的。UTIL 。地圖 消息）;     空隙 消息（的java 。util的。地圖 信息）;     void  outputFile （String  path ）;     void  logFile （String  path ）;     void  reportFile （String  path ）;     void  debugFile （String  path ）;     void  close （）; }

4.3.3聽衆記錄

Robot Framework 2.6引入了新的程序化日誌API，也是偵聽器能夠利用的。可是，有一些限制，下面的表格解釋了不一樣的監聽器方法如何記錄消息。

監聽器方法如何記錄
方法	說明
start_keyword，end_keyword，log_message	消息被記錄到執行關鍵字下的普通日誌文件中。
start_suite，end_suite，start_test，end_test	消息被記錄到系統日誌。正常日誌文件的執行錯誤部分也顯示警告。
信息	消息一般記錄到系統日誌中。若是在執行關鍵字時使用此方法，則會將消息記錄到正常的日誌文件中。
其餘方法	消息只記錄到系統日誌。

注意

爲避免遞歸，偵聽器記錄的消息不會發送到偵聽器方法log_message和message。

警告

聽衆在Robot Framework 2.6.2以前有嚴重的問題。所以不建議在早期版本中使用此功能。

4.3.4聽衆示例

第一個簡單的例子是在Python模塊中實現的。主要說明使用監聽器接口不是很複雜。

ROBOT_LISTENER_API_VERSION  =  2def  start_test （name ， attrs ）：    print  '執行測試％s '  ％ nameDEF  start_keyword （名稱， ATTRS ）：    打印 '執行關鍵字％s的帶有參數的％S '  ％ （名， ATTRS [ 'ARGS' ]）def  log_file （path ）：    打印 '測試日誌可用在％s '  ％ 路徑def  close （）：    print'All  tests executed'

第二個仍然使用Python的例子稍微複雜一些。它將全部的信息寫入一個臨時目錄中的文本文件，而不須要太多格式化。文件名可能來自命令行，但也有一個默認值。請注意，在實際使用中，經過命令行選項--debugfile可用的調試文件功能可能比此示例更有用。

導入 os.path 導入 tempfile類 PythonListener ：    ROBOT_LISTENER_API_VERSION  =  2    def  __init__ （self ， filename = 'listen.txt' ）：        outpath  =  os 。路徑。加入（臨時文件。gettempdir （）， 文件名）        自我。outfile  =  open （outpath ， 'w' ）    def  start_suite （self ， name ， attrs ）：        self 。outfile 。寫（「 ％s ' ％s ' \ n 」  ％ （name ， attrs [ 'doc' ]））    def  start_test （self ， name ， attrs ）：        tags  =  '' 。加入（attrs [ 'tags' ]）        自我。outfile 。write （「 - ％s ' ％s '[ ％s ] ::」  ％ （name ， attrs [ 'doc' ]， tags ））    def  end_test （self ， name ， attrs ）：        if  attrs [ 'status' ]  ==  'PASS' ：            self 。outfile 。寫（'PASS \ n ' ）        不然：            自我。outfile 。寫（'FAIL：％s \ n '  ％ attrs [ 'message' ]）     def  end_suite （self ， name ， attrs ）：         self 。outfile 。寫（' ％s \ n ％s \ n '  ％ （attrs [ 'status' ]， attrs [ 'message' ]））     def  close （self ）：         self 。outfile 。close （）

第三個例子實現了與前一個例子相同的功能，但使用Java而不是Python。

import  java.io. * ; import  java.util.Map ; import  java.util.List ;公共 類 JavaListener  {    public  static  final  int  ROBOT_LISTENER_API_VERSION  =  2 ;     public  static  final  String  DEFAULT_FILENAME  =  「listen_java.txt」 ;     私人 BufferedWriter  outfile  =  null ;    public  JavaListener （） 拋出 IOException  {         this （DEFAULT_FILENAME ）;     }    公共 JavaListener （字符串 文件名） 拋出 IOException  {         字符串 tmpdir  =  系統。getProperty （「java.io.tmpdir」 ）;         字符串 sep  =  系統。getProperty （「file.separator」 ）;         字符串 outpath  =  tmpdir  +  sep  +  文件名;         outfile  =  new  BufferedWriter （new  FileWriter （outpath ））;     }    public  void  startSuite （String  name ， Map  attrs ） throws  IOException  {         outfile 。寫（名稱 +  「 '」  +  ATTRS 。得到（「DOC」 ） +  「' \ n」 ）;     }    public  void  startTest （String  name ， Map  attrs ） throws  IOException  {         outfile 。寫（「 - 」  +  名字 +  「 '」  +  ATTRS 。得到（「DOC」 ） +  「'[」 ）;         列表 標籤 =  （列表）attrs 。get （「tags」 ）;         for  （int  i = 0 ;  i  < 標籤。size （）;  我++） {            outfile 。寫（標籤。得到（我） +  「」 ）;         }         outfile 。寫（「] ::」 ）;     }    public  void  endTest （String  name ， Map  attrs ） throws  IOException  {         String  status  =  attrs 。得到（「狀態」 ）。toString （）;         若是 （狀態。等號（「PASS」 ）） {             OUTFILE 。寫（「PASS \ n」 ）;         }         其餘 {             OUTFILE 。寫（「FAIL：」  +  ATTRS 。獲得（「message」 ） +  「\ n」 ）;         }     }    public  void  endSuite （String  name ， Map  attrs ） throws  IOException  {         outfile 。寫（ATTRS 。得到（「狀態」 ） +  「\ n」個 +  ATTRS 。得到（「消息」 ） +  「\ n」個）;     }    public  void  close （） throws  IOException  {         outfile 。close （）;     }}

4.3.5測試庫做爲監聽器

有時，測試庫也能夠獲取有關測試執行的通知。這容許他們在測試套件或整個測試執行結束時自動執行某些清理活動。

注意

這個功能是Robot Framework 2.8.5中的新功能。

註冊偵聽器

一個測試庫能夠經過使用ROBOT_LIBRARY_LISTENER 屬性註冊一個監聽器。此屬性的值應該是要使用的偵聽器的實例。它多是一個徹底獨立的聽衆，或者圖書館自己能夠做爲一個聽衆。爲避免在後一種狀況下將偵聽器方法暴露爲關鍵字，能夠用下劃線做爲前綴。例如，而不是使用end_suite或endSuite，有可能使用_end_suite或_endSuite。

如下示例說明如何使用外部偵聽器以及庫做爲偵聽器自己：

導入 my.project.Listener ;public  class  JavaLibraryWithExternalListener  {     public  static  final  Listener  ROBOT_LIBRARY_LISTENER  =  new  Listener （）;     public  static  final  String  ROBOT_LIBRARY_SCOPE  =  「GLOBAL」 ;    //實際的庫代碼在這裏... }

類 PythonLibraryAsListener自己（object ）：    ROBOT_LIBRARY_SCOPE  =  'TEST     SUITE'ROBOT_LISTENER_API_VERSION  =  2    def  __init__ （self ）：        self 。ROBOT_LIBRARY_LISTENER  =  自我    高清 _end_suite （自我， 名稱， ATTRS ）：        打印 '套件％S （％S ）結束。'  ％ （name ， attrs [ 'id' ]）    ＃實際庫代碼在這裏...

正如上面已經演示的秒示例，庫監聽器能夠像使用任何其餘監聽器同樣使用屬性來指定監聽器接口版本ROBOT_LISTENER_API_VERSION。

調用監聽器方法

庫的偵聽器將得到有關導入庫的套件中的全部事件的通知。在實踐中，這意味着start_suite， end_suite，start_test，end_test，start_keyword， end_keyword，log_message，和message方法被調用的套房內。

若是庫每次建立一個新的偵聽器實例，那麼實際使用的偵聽器實例將根據測試庫範圍而改變。除了以前列出的偵聽器方法外，close 當庫超出範圍時，方法被調用。

有關全部這些方法的更多信息，請參閱上面的Listener接口方法簽名部分。

4.4擴展機器人框架Jar

使用包含在標準JDK安裝中的jar命令，將額外的測試庫或支持代碼添加到Robot Framework jar很是簡單。Python代碼必須放在jar目錄下的lib目錄下，Java代碼能夠直接放到jar的根目錄，根據包結構。

例如，要將Python包添加mytestlib到jar中，首先將mytestlib目錄複製到名爲Lib的目錄下，而後在包含Lib的目錄中運行如下命令：

jar uf /path/to/robotframework-2.7.1.jar Lib

要將編譯的java類添加到jar中，您必須具備與Java包結構相對應的目錄結構，並將其遞歸添加到zip中。

例如，要添加類MyLib.class，在包中org.test，該文件必須位於org / test / MyLib.class中，您能夠執行：

jar uf /path/to/robotframework-2.7.1.jar org

5個支持工具

5.1庫文檔工具（`libdoc`）

Libdoc是一種爲HTML和XML格式的測試庫和資源文件生成關鍵字文檔的工具。前者格式適用於人類，後者適用於RIDE和其餘工具。Libdoc也沒有特別的命令來顯示控制檯上的庫或資源信息。

文檔能夠建立爲：

用Python或Java使用普通靜態庫API 實現的測試庫，
使用動態API測試庫，包括遠程庫和
資源文件。

此外，能夠使用Libdoc早期建立的XML規範做爲輸入。

Libdoc內置於Robot Framework中，並自2.7版本開始自動包含在安裝中。使用較早的版本，您須要單獨下載libdoc.py腳本。這些版本之間的命令行使用稍有變化，但文檔語法仍然相同。

5.1.1通常用法

概要

python -m robot.libdoc [options] library_or_resource output_filepython -m robot.libdoc [options] library_or_resource list | show | version [names]

選項

-f, --format <html|xml>

指定是否生成HTML或XML輸出。若是不使用此選項，則格式將從輸出文件的擴展名得到。

-F, --docformat <robot|html|text|rest>

指定源文檔格式。可能的值是Robot Framework的文檔格式，HTML，純文本和reStructuredText。默認值能夠在測試庫源代碼中指定，初始默認值是robot。Robot Framework 2.7.5中的新功能

-N, --name <newname>

設置記錄的庫或資源的名稱。

-V, --version <newversion>

設置記錄的庫或資源的版本。測試庫的默認值是從源代碼中得到的。

-P, --pythonpath <path>

與運行測試時相似的搜索庫和資源的其餘位置。

-E, --escape <what:with>

轉義控制檯中有問題的字符。 what是要轉義的字符的名稱，是用來轉義with的字符串。可用的轉義符在--help 輸出中列出。

-h, --help 打印此幫助。

另類執行

雖然在上面的簡介中，Libdoc僅用於Python，但它也適用於Jython和IronPython。在記錄Java庫時，實際上須要Jython。

在大綱中，Libdoc做爲已安裝的模塊（python -m robot.libdoc）執行。除此以外，它也能夠做爲腳本運行：

python path / robot / libdoc.py [options]參數

若是您已經完成手動安裝，那麼做爲腳本執行可能很是有用，不然只需將機器人目錄與源代碼放在系統中的某處便可。

指定庫或資源文件

Python庫和具備名稱或路徑的動態庫

當記錄用Python實現的庫或使用動態庫API時，能夠經過僅使用庫名稱或庫源代碼的路徑來指定庫。在前一種狀況下，使用庫搜索路徑搜索庫，而且其名稱必須與Robot Framework測試數據中的格式相同。

若是這些庫在導入時須要參數，則參數必須與庫名或使用兩個冒號的路徑鏈接 MyLibrary::arg1::arg2。若是參數改變了庫提供的關鍵字，或者改變了它的文檔，那麼使用 --name選項也能夠相應地改變庫的名字。

帶有路徑的Java庫

使用靜態庫API實現的Java測試庫能夠經過給包含庫實現的源代碼文件的路徑指定。此外，在執行Libdoc時，必須從CLASSPATH中找到做爲Java JDK發行版的一部分的tools.jar。請注意，爲Java庫生成文檔僅適用於Jython。

具備路徑的資源文件

資源文件必須始終使用路徑指定。若是路徑不存在，那麼資源文件也會像在執行測試用例時那樣從PYTHONPATH中的全部目錄中搜索。

生成文檔

在生成HTML或XML格式的文檔時，必須將輸出文件指定爲庫/資源名稱或路徑以後的第二個參數。輸出格式是從擴展名自動得到，但也能夠使用--format選項設置。

例子：

python -m robot.libdoc OperatingSystem OperatingSystem.htmlpython -m robot.libdoc  - 名稱MyLibrary Remote :: http：//10.0.0.42：8270 MyLibrary.xmlpython -m robot.libdoc test / resource.html doc / resource_doc.htmljython -m robot.libdoc --version 1.0 MyJavaLibrary.java MyJavaLibrary.htmljython -m robot.libdoc my.organization.DynamicJavaLibrary my.organization.DynamicJavaLibrary.xml

在控制檯上查看信息

Libdoc有三個特殊的命令在控制檯上顯示信息。使用這些命令而不是輸出文件的名稱，而且還能夠使用其餘參數。

list: 列出庫/資源包含的關鍵字的名稱。能夠經過傳遞可選模式做爲參數來限制顯示特定關鍵字。若是其名稱包含給定模式，則列出關鍵字。
show: 顯示庫/資源文檔。能夠經過傳遞名稱做爲參數來限制顯示某些關鍵字。若是其名稱與任何給定名稱匹配，則顯示關鍵字。特別的論據 intro將只顯示圖書館介紹和進口部分。
version: 顯示庫版本

給予的可選模式list，show對大小寫和空間不敏感。二者都接受*和?做爲通配符。

例子：

python -m robot.libdoc對話框列表python -m robot.libdoc Selenium2Library列表瀏覽器python -m robot.libdoc Remote :: 10.0.0.42：8270顯示python -m robot.libdoc對話框顯示PauseExecution執行*python -m robot.libdoc Selenium2Library顯示介紹python -m robot.libdoc Selenium2Library版本

5.1.2編寫文件

本節討論爲使用靜態庫API以及動態庫和資源文件的基於Python和Java的測試庫編寫文檔。建立測試庫和資源文件在用戶指南的其餘地方有更詳細的描述。

Python庫

使用靜態庫API的 Python庫的文檔簡單地寫爲庫類或模塊的文檔字符串以及實現關鍵字的方法。方法文檔的第一行被認爲是關鍵字的簡短文檔（例如，在生成的HTML文檔中用做連接中的工具提示），所以它應該儘量描述，但不能太長。

下面這個簡單的例子說明了如何編寫文檔，本章最後還有一個比較長的例子，它也包含了生成文檔的一個例子。

類 ExampleLib ：    「」「庫用於演示目的。    這個庫只用在一個例子中，它沒有作任何有用的事情。    「」」    def  my_keyword （self ）：        「」「什麼都沒有。」「」         傳遞    def  your_keyword （self ， arg ）：        「」「帶一個參數，*不作任何事情*。        例如：        | 您的關鍵字| xxx |         | 您的關鍵字| yyy |         「」         經過

小費

若是要在Python庫文檔中使用非ASCII字符，則必須使用UTF-8做爲源代碼編碼，或者將Unicode文檔建立爲docstrings。

有關Python文檔字符串的更多信息，請參閱PEP-257。

Java庫

使用靜態庫API的 Java庫的文檔被編寫爲庫類和方法的普通Javadoc註釋。在這種狀況下，Libdoc實際上在內部使用Javadoc工具，所以包含它的tools.jar必須位於CLASSPATH中。這個jar文件是普通Java SDK發行版的一部分，應該在Java SDK安裝的bin目錄中找到。

下面這個簡單的例子與以前的Python例子具備徹底相同的文檔（和功能）。

/ ** *用於演示目的的庫。* *這個庫只用於一個例子，它沒有作任何有用的事情。* / public  class  ExampleLib  {    / **      *什麼都不作。     * /     public  void  myKeyword （） {     }    / **      *採起一個論據，而且*什麼也不作。     *      *例子：     * | 您的關鍵字| xxx |      * | 您的關鍵字| yyy |      * /     public  void  yourKeyword （String  arg ） {     } }

動態庫

爲了可以生成動態庫文件有意義，圖書館必須返回關鍵字參數名稱和使用文檔 get_keyword_arguments和get_keyword_documentation 方法（或使用他們的駝峯變種getKeywordArguments 和getKeywordDocumentation）。圖書館還能夠經過該方法的特殊__intro__和__init__價值來支持通用圖書館文獻get_keyword_documentation。

有關如何建立這些方法的更多信息，請參閱動態庫API部分。

導入部分

有關如何導入庫的單獨部分是基於其初始化方法建立的。對於Python庫，若是它有一個__init__ 除了參數以外的方法，self則會顯示它的文檔和參數。對於Java庫，若是它具備接受參數的公共構造函數，則顯示其全部公共構造函數。

class  TestLibrary ：    def  __init__ （self ， mode = 'default' ）        「」「建立新的TestLibrary。`mode`參數用於肯定模式。」「」         self 。mode  =  mode    def  some_keyword （self ， arg ）：        「」「根據給定的`arg`作一些事情。        所作的事情取決於`庫'導入時指定的'模式'。        「」」         若是 自我。模式 ==  '祕密' ：             ＃...

資源文件的文件

資源文件中的關鍵詞能夠使用 [Documentation]設置文檔，Libdoc也使用這個文檔。文檔的第一行（直到第一個隱含的換行符或顯式\n）被認爲是與測試庫相似的簡短文檔。

此外，資源文件自己能夠在設置表中具備文檔來記錄整個資源文件。

資源文件中可能的變量沒有記錄。

一個示例資源文件
設置	值	值
文檔	資源文件用於演示目的。
...	此資源僅用於一個示例	並無作任何有用的事情。

關鍵詞	行動	論據	論據
個人關鍵字	[文檔]	什麼也沒作
	沒有操做

您的關鍵字	[參數]	$ {} ARG
	[文檔]	採起一個論點，什麼都不作	例如：\ n \| 您的關鍵字\| xxx \| \ n \| 您的關鍵字\| yyy \| \ n
	沒有操做

5.1.3文檔語法

Libdoc支持Robot Framework本身的文檔語法，HTML，純文本和reStructuredText中的文檔。能夠使用屬性在測試庫源代碼中指定使用的格式，也能夠ROBOT_LIBRARY_DOC_FORMAT使用--docformat（-F）選項在命令行中給出使用的格式。在這兩種狀況下，可能的不區分大小寫的值都是ROBOT（默認） HTML，TEXT和reST。

Robot Framework本身的文檔格式是默認的，通常推薦的格式。其餘格式在使用測試庫中現有文檔的現有代碼時特別有用。在Robot Framework 2.7.5中添加了對其餘格式的支持。

Robot Framework文檔語法

Robot Framework 文檔語法中最重要的特性是使用*bold*和_italic_自定義連接和自動將URL轉換爲連接的格式，以及使用管道字符建立表格和預格式化文本塊（可用於示例）的可能性。若是文檔變得更長，那麼對部分標題（Robot Framework 2.7.5中的新增功能）的支持也能夠很方便。

下面的例子說明了一些最重要的格式化功能。請注意，因爲這是默認格式，所以不須要使用ROBOT_LIBRARY_DOC_FORMAT屬性，也不須要從命令行提供格式。

「」「Robot Framework格式的示例庫」 - 使用* bold *和_italic_格式化。 - 像http://example.com這樣的網址被轉到連接。 - 支持像[http：//robotframework.org | Robot Framework]這樣的自定義連接。 - 連接到「個人關鍵字」的做品。「」」def  my_keyword （）：    「」「沒有更多的在這裏看到。」「」

HTML文檔語法

使用HTML格式時，能夠使用任何語法很是自由地建立文檔。主要缺點是HTML標記不是人性化的，並且能夠使源代碼中的文檔難以維護和閱讀。HTML格式的文檔被Libdoc直接使用，沒有任何轉換或轉義。然而，支持使用像My Keyword這樣的語法來連接到關鍵字的特殊語法。

下面的示例包含與前面的示例相同的格式示例。如今ROBOT_LIBRARY_DOC_FORMAT屬性必須使用或命令行上給出的格式--docformat HTML。

「」「HTML格式的示例庫。<ul>   <li>使用<b>粗體</ b>和<i>斜體</ i>格式化。  <li>網址未自動轉爲連接。  <li>支持<a href="http://www.w3.org/html"> HTML </a>等自定義連接。  <li>連接到「個人關鍵字」的做品。</ ul> 「」「 ROBOT_LIBRARY_DOC_FORMAT  =  'HTML'def  my_keyword （）：    「」「沒有更多的在這裏看到。」「」

純文本文檔語法

當使用純文本格式時，Libdoc按原樣使用文檔。除了縮進外，換行符和其餘空白符被保留，而且HTML特殊字符（<>&）被轉義。惟一的格式是把網址變成可點擊的連接，並支持像「個人關鍵字」這樣的內部連接。

「」「純文本格式的示例庫。 - 格式不被支持。 - 像http://example.com這樣的網址被轉到連接。 - 不支持自定義連接。 - 連接到「個人關鍵字」的做品。「」「 ROBOT_LIBRARY_DOC_FORMAT  =  '文字'def  my_keyword （）：    「」「沒有更多的在這裏看到」「」

reStructuredText文檔語法

reStructuredText是Python項目（包括本用戶指南）和其餘地方普遍使用的簡單而強大的標記語法。主要限制是您須要安裝docutils模塊才能使用它生成文檔。因爲反向字符在reStructuredText中有特殊含義，連接到關鍵字須要像「個人關鍵字」那樣轉義。

「」「reStructuredText格式的示例庫。 - 用** bold **和* italic *格式化。 - 像http://example.com這樣的網址被轉到連接。 - 支持像reStructuredText__這樣的自定義連接。 - 連接到「個人關鍵字」的做品，但須要逃避。__ http://docutils.sourceforge.net 「」「 ROBOT_LIBRARY_DOC_FORMAT  =  'reST'def  my_keyword （）：    「」「沒有更多的在這裏看到」「」

5.1.4內部連接

Libdoc支持內部連接到關鍵字和文檔中的不一樣部分。連接是經過圍繞目標名稱反向字符，如「目標」。目標名稱不區分大小寫，可能的目標在後面的章節中解釋。

若是找不到連接目標，則沒有錯誤或警告，而是Libdoc只是將文本格式化爲斜體。早些時候，這種格式建議在引用關鍵字參數時使用，但這是有問題的，由於它可能會意外地建立內部連接。如今，建議使用內聯代碼樣式，而不是像``argument``這樣的雙反引號。舊的單向反引號格式化甚至可能在未來被刪除，以便在未找到連接目標時提供錯誤。

除了如下部分中的示例以外，本章末尾的較長示例中也會顯示內部連接和參數格式。

連接到關鍵字

全部的關鍵字庫自動建立連接目標，他們能夠使用語法關鍵字名稱連接。下面的例子說明了這兩個關鍵字之間的連接。

def  關鍵字（log_level = 「INFO」 ）：    「」「執行某些操做並使用給定級別記錄輸出。    日誌級別的有效值是「INFO」（默認）「DEBUG」和「TRACE」。    另請參閱另外一個關鍵字。    「」「     ＃...def  another_keyword （argument ， log_level = 「INFO」 ）：    「」「對給定的參數else作某些事情並記錄輸出。    有關有效日誌級別的信息，請參閱`關鍵字`。    「」「     ＃...

注意

當使用reStructuredText文檔語法時，反引號必須像「關鍵字名稱」同樣被轉義。

連接到自動部分

Libdoc生成的文檔老是包含整個庫引入的部分，關鍵字的快捷鍵以及實際的關鍵字。若是一個庫自己須要參數，那麼也有單獨的導入部分。

全部這些部分充當能夠連接的目標，可能的目標名稱列在下表中。在下一節的例子中顯示了使用這些目標。

自動區段連接目標
部分	目標
介紹	`介紹`和`庫介紹`
輸入	「導入」和「庫導入」
快捷鍵	`快捷方式`（Robot Framework 2.7.5中的新功能）
關鍵詞	`關鍵字`（Robot Framework 2.7.5中的新增內容）

連接到自定義部分

從2.7.5版開始，Robot Framework的文檔語法支持自定義節標題，庫或資源文件引入中使用的標題自動建立連接目標。下面的例子說明了鏈接到自動和自定義部分：

「」「libdoc演示目的的庫。這個庫不會作任何有用的事情。=個人部分=不過，咱們在文檔中有一個自定義部分。「」」def  關鍵字（）：    「」「什麼都不作。    請參閱`介紹`獲取更多信息和'個人部分'來測試如何    連接到自定義部分的做品。    「」     經過

注意

連接到自定義部分僅在使用Robot Framework文檔語法時才起做用。

注意

在Robot Framework 2.8以前，只有一級標題是可連接的。

5.1.5表明論點

Libdoc會自動處理關鍵字的參數，以便爲資源文件中的方法或資源文件中的用戶關鍵字指定的參數列在單獨的列中。用戶關鍵字參數顯示爲不帶${}或@{}使參數看起來相同，不管關鍵字來自哪裏。

不管實際如何實現關鍵字，Libdoc顯示的參數與在Python中建立關鍵字時類似。下表更詳細地解釋了這種格式。

Libdoc如何表明論點
參數	如今表明	例子
沒有參數	空的專欄。
一個或多個論點	包含參數名稱的字符串列表。	`one_argument` `a1, a2, a3`
參數的默認值	默認值與名稱分開`=`。	`arg=default value` `a, b=1, c=2`
可變數量的參數（可變參數）	最後（或者倒數第二個用kwargs）的參數`*` 在它的名字前面。	`varargs` `a, b=42, rest`
免費的關鍵字參數（kwargs）	最後的參數 `**`在它的名字以前。	`kwargs` `a, b=42, kws` `varargs, *kwargs`

在引用關鍵字文檔中的參數時，建議使用像「`argument」這樣的內聯代碼風格。

5.1.6 Libdoc示例

如下示例說明如何使用最重要的文檔格式化可能性，內部連接等。點擊這裏查看生成的文檔是怎樣的。

類 LoggingLibrary ：    「」「用於記錄消息的庫。    =目錄=    - 使用狀況    - 有效的日誌級別    - 例子    - 導入    - 快捷方式    - 關鍵字    =用法=    這個庫有幾個關鍵字，例如`Log Message`，用於記錄    消息。實際上，該庫僅用於_Libdoc_演示    目的。    =有效的日誌級別=    有效的日誌級別是「INFO」，「DEBUG」和「TRACE」。默認的日誌    級別能夠在`imported`中設置。    =例子=    注意關鍵字如何與示例連接。    | `Log Message` | 個人留言| | |     | 記錄兩條消息| 個人留言| 第二條消息| level = DEBUG |     | 「日誌消息」 第一條消息| 第二條消息| 第三條消息|     「」「     ROBOT_LIBRARY_VERSION  =  '0.1'    def  __init__ （self ， default_level = 'INFO' ）：        「」「默認的日誌級別能夠在庫導入時給出。        有關可用日誌        級別的信息，請參閱「有效日誌級別」部分。        例子：        | =設置= | =值= | =值= | =評論= |         | 圖書館| LoggingLibrary | | ＃使用默認級別（INFO）|         | 圖書館| LoggingLibrary | DEBUG | ＃使用給定的水平|         「」」         自我。default_level  =  自我。_verify_level （default_level ）    def  _verify_level （self ， level ）：        level  =  level 。上（）        若是 水平 未 在 [ 'INFO' ， 'DEBUG' ， 'TRACE' ]：            提升 RuntimeError （「無效日誌級別' ％s的'有效水平。」                                「 'INFO'， 'DEBUG'和'TRACE' 「 ）        返回 級別    def  log_message （self ， message ， level = None ）：        「」「使用指定的日誌級別將給定的消息寫入日誌文件。        要記錄的消息和要使用的日誌級別分別使用        「message」和「level」參數來定義。        若是沒有給出日誌級別，        則使用在「庫導入」期間給出的默認級別。        「」」         電平 =  自我。_verify_level （電平） ，若是 電平 別的 自我。default_level         打印 「* ％S * ％S 」  ％ （級別， 消息）    DEF  log_two_messages （自， MESSAGE1 ， 消息2 ， 級別= 無）：        「」「，寫給出使用指定的日誌級別信息到日誌文件中。        有關更多信息，請參閱「日誌消息」關鍵字。        「」」         自我。log_message （MESSAGE1 ， 電平）        自我。log_message （消息2 ， 電平）    def  log_messages （self ， * messages ）：        「」「使用在」導入「期間設置的日誌級別來記錄給定的消息。        另見「日誌消息」和「記錄兩條消息」。        「」」         對 味精 的 消息：            自我。log_message （MSG ）

全部的標準庫都有Libdoc生成的文檔，它們的文檔（和源代碼）是一個更現實的例子。

5.2測試數據文檔工具（`testdoc`）

testdoc是基於Robot Framework測試用例生成高級文檔的工具。所建立的文檔採用HTML格式，包括每一個測試套件和測試用例的名稱，文檔和其餘元數據，以及頂級關鍵字及其參數。

testdoc內置於Robot Framework中，並從版本2.7開始自動包含在安裝中。使用較早的版本，您須要單獨下載testdoc.py腳本。這些版本之間的命令行使用稍有變化。

5.2.1通常用法

概要

python -m robot.testdoc [options] data_sources output_file

選項

-T, --title <title>

設置生成的文檔的標題。標題中的下劃線被轉換爲空格。默認標題是頂級套件的名稱。

-N, --name <name>

覆蓋頂級測試套件的名稱。

-D, --doc <doc>

覆蓋頂級測試套件的文檔。

-M, --metadata <name:value>

設置/覆蓋頂級測試套件的免費元數據。

-G, --settag <tag>

將給定的標籤設置爲全部測試用例。

-t, --test <name>

按名稱包含測試。

-s, --suite <name>

按名稱包括套件。

-i, --include <tag>

包含標籤測試。

-e, --exclude <tag>

排除標籤測試。

-h, --help 在控制檯中打印這個幫助。

除了--title以外的全部選項都與執行測試用例時的選項具備徹底相同的語義。

5.2.2生成文檔

數據能夠以單個文件，目錄或多個文件和目錄的形式給出。在全部這些狀況下，最後一個參數必須是寫入輸出的文件。

Testdoc適用於Robot Framework支持的全部解釋器（Python，Jython和IronPython）。它能夠像安裝的模塊那樣執行， python -m robot.testdoc或者像腳本同樣執行python path/robot/testdoc.py。

例子：

python -m robot.testdoc my_test.html testdoc.htmljython -m robot.testdoc --name smoke_tests --include smoke path / to / my_tests smoke.htmlipy path / to / robot / testdoc.py first_suite.txt second_suite.txt output.html

5.3測試數據清理工具（`整潔`）

tidy是清理和更改Robot Framework測試數據文件格式的工具。它內置於Robot Framework中，並從版本2.7開始自動包含在安裝中。

默認狀況下，輸出寫入標準輸出流，可是能夠從Robot Framework 2.7.5開始輸出一個可選的輸出文件。文件也能夠使用--inplace或 --recursive選項就地修改。

5.3.1通常用法

概要

python -m robot.tidy [options] inputfilepython -m robot.tidy [選項]輸入文件[輸出文件]python -m robot.tidy --inplace [選項]輸入文件[更多輸入文件]python -m robot.tidy --recursive [options]目錄

選項

-i, --inplace
整理給定的文件，以便原始文件被覆蓋（或刪除，若是格式改變）。使用此選項時，能夠輸入多個輸入文件。例子：
python -m robot.tidy --inplace tests.htmlpython -m robot.tidy --inplace --format txt * .html
-r, --recursive

遞歸地處理給定的目錄。目錄中的文件與使用--inplace選項時的處理方式類似。

-f, --format <txt|html|tsv>

輸出文件格式。若是顯式給出輸出文件，則從其擴展名得到默認值。不然，格式不會改變。

-p, --use-pipes

使用管道字符（|）做爲txt格式的單元格分隔符。

-s, --spacecount <number>

txt格式的單元格之間的空格數。Robot Framework 2.7.3新增功能

-l, --lineseparator <native|windows|unix>

用於輸出的行分隔符。默認是「本機」。

native：使用操做系統的本地行分隔符

Windows：使用Windows行分隔符（CRLF）

unix：使用Unix行分隔符（LF）

Robot Framework 2.7.6中的新功能

-h, --help 顯示此幫助。

另類執行

儘管上面的簡介中整潔僅用於Python，但它也適用於Jython和IronPython。在簡介整潔是做爲一個已安裝的模塊（python -m robot.tidy）執行，但它也能夠做爲腳本運行：

python path / robot / tidy.py [options]參數

若是您已經完成手動安裝，那麼做爲腳本執行可能很是有用，不然只需將機器人目錄與源代碼放在系統中的某處便可。

輸出編碼

全部輸出文件都使用UTF-8編碼寫入。寫入控制檯的輸出使用當前的控制檯編碼。

5.3.2清理測試數據

用HTML編輯器建立或用手寫的測試用例文件能夠使用整齊的標準化。整潔老是寫出一致的標題，一致的設置順序以及單元格和表格之間一致的空白。

例子：

python -m robot.tidy messed_up_tests.html cleared_tests.htmlpython -m robot.tidy --inplace tests.txt

5.3.3改變測試數據格式

機器人框架支持HTML，TSV和TXT格式的測試數據，整潔 使得格式之間的轉換變得微不足道。輸入格式老是基於輸入文件的擴展名來肯定的。輸出格式能夠使用--format選項來設置，默認值是從可能的輸出文件的擴展名中得到的。

例子：

python -m robot.tidy tests.html tests.txtpython -m robot.tidy --format txt --inplace tests.htmlpython -m robot.tidy --format tsv  - 遞歸的mytests

5.4外部工具

有不少能夠用於Robot Framework的外部工具。這些工具包括測試數據編輯器RIDE，各類IDE和文本編輯器的擴展，連續集成系統的插件和構建工具等等。

這些工具是獨立於機器人框架自己而獨立開發的。有關可用工具的列表，請參閱 http://robotframework.org/#tools。

注意

過去一些支持工具是經過Robot Framework自行分發的。如今，全部這些工具均可以單獨使用，而且從Robot Framework 2.8.6的版本庫和源代碼發行版中刪除。

6附錄

6.1測試數據中的全部可用設置

6.1.1設置表格

設置表用於導入測試庫，資源文件和變量文件，併爲測試套件和測試用例定義元數據。它能夠包含在測試用例文件和資源文件中。請注意，在資源文件中，設置表只能包含導入庫，資源和變量的設置。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。

`-f, --format <html\|xml>`
	指定是否生成HTML或XML輸出。若是不使用此選項，則格式將從輸出文件的擴展名得到。
`-F, --docformat <robot\|html\|text\|rest>`
	指定源文檔格式。可能的值是Robot Framework的文檔格式，HTML，純文本和reStructuredText。默認值能夠在測試庫源代碼中指定，初始默認值是`robot`。Robot Framework 2.7.5中的新功能
`-N, --name <newname>`
	設置記錄的庫或資源的名稱。
`-V, --version <newversion>`
	設置記錄的庫或資源的版本。測試庫的默認值是從源代碼中得到的。
`-P, --pythonpath <path>`
	與運行測試時相似的搜索庫和資源的其餘位置。
`-E, --escape <what:with>`
	轉義控制檯中有問題的字符。 `what`是要轉義的字符的名稱，是用來轉義`with`的字符串。可用的轉義符在--help 輸出中列出。
`-h, --help`	打印此幫助。

`-T, --title <title>`
	設置生成的文檔的標題。標題中的下劃線被轉換爲空格。默認標題是頂級套件的名稱。
`-N, --name <name>`
	覆蓋頂級測試套件的名稱。
`-D, --doc <doc>`
	覆蓋頂級測試套件的文檔。
`-M, --metadata <name:value>`
	設置/覆蓋頂級測試套件的免費元數據。
`-G, --settag <tag>`
	將給定的標籤設置爲全部測試用例。
`-t, --test <name>`
	按名稱包含測試。
`-s, --suite <name>`
	按名稱包括套件。
`-i, --include <tag>`
	包含標籤測試。
`-e, --exclude <tag>`
	排除標籤測試。
`-h, --help`	在控制檯中打印這個幫助。

`-i, --inplace`	整理給定的文件，以便原始文件被覆蓋（或刪除，若是格式改變）。使用此選項時，能夠輸入多個輸入文件。例子： python -m robot.tidy --inplace tests.htmlpython -m robot.tidy --inplace --format txt * .html
`-r, --recursive`
	遞歸地處理給定的目錄。目錄中的文件與使用--inplace選項時的處理方式類似。
`-f, --format <txt\|html\|tsv>`
	輸出文件格式。若是顯式給出輸出文件，則從其擴展名得到默認值。不然，格式不會改變。
`-p, --use-pipes`
	使用管道字符（\|）做爲txt格式的單元格分隔符。
`-s, --spacecount <number>`
	txt格式的單元格之間的空格數。Robot Framework 2.7.3新增功能
`-l, --lineseparator <native\|windows\|unix>`
	用於輸出的行分隔符。默認是「本機」。 native：使用操做系統的本地行分隔符 Windows：使用Windows行分隔符（CRLF） unix：使用Unix行分隔符（LF） Robot Framework 2.7.6中的新功能
`-h, --help`	顯示此幫助。

Robot Framework用戶指南

Robot Framework用戶指南

版本2.8.6

什麼目錄添加到PATH

在Windows上設置PATH

在類UNIX系統上設置PATH

安裝pip

使用點子

獲取源代碼

安裝

使用pip卸載

使用Windows安裝程序後卸載

手動卸載

編輯測試數據

編碼和實體引用

編輯測試數據

編碼

空格分隔的格式

管道和空間分隔的格式

編輯和編碼

承認的擴展

使用代碼塊

使用表格

編輯和編碼

reST源文件中的語法錯誤

轉義特殊字符

造成轉義序列

防止忽略空單元格

防止無視空間

基本的語法

用變量命名參數

轉義命名參數語法

支持命名參數的地方

命名參數的例子

忽略Given / When / Then /和前綴

將數據嵌入關鍵字

訪問單個列表變量項目

使用列表變量的設置

建立標量變量

建立列表變量

什麼目錄添加到`PATH`

在Windows上設置`PATH`

在類UNIX系統上設置`PATH`