Package: robotframework-datadriver
DataDriver is a Data-Driven extension for Robot Framework®.
This document explains how to use the DataDriver library listener. For
information about installation, support, and more, please visit theproject pageFor more information about Robot Framework®, seehttps://robotframework.org.DataDriver is used/imported as Library but does not provide keywords
which can be used in a test. DataDriver uses the Listener Interface
Version 3 to manipulate the test cases and creates new test cases based
on a Data-File that contains the data for Data-Driven Testing. These
data file may be .csv , .xls or .xlsx files.Data Driver is also able to cooperate with Microsoft PICT. An Open
Source Windows tool for data combination testing. Pict is able to
generate data combinations based on textual model definitions.https://github.com/Microsoft/pictIt is also possible to implement own DataReaders in Python to read
your test data from some other sources, like databases or json files.InstallationIf you already have Python >= 3.6 with pip installed, you can simply
run:pip install--upgraderobotframework-datadriverExcel SupportFor file support ofxlsorxlsxfile you need to install the extra XLS or the dependencies.
It contains the dependencies of pandas, numpy and xlrd. Just add [XLS] to your installation.
New since version 3.6.pip install--upgraderobotframework-datadriver[XLS]Python 2or if you have Python 2 and 3 installed in parallel you may usepip3 install--upgraderobotframework-datadriverDataDriver is compatible with Python 2.7 only in Version 0.2.7.pip install--upgraderobotframework-datadriver==0.2.7Because Python 2.7 is deprecated, there are no new feature to python 2.7 compatible version.Table of contentsWhat DataDriver DoesHow DataDriver WorksUsageStructure of Test SuiteStructure of data fileAccessing Test Data From Robot VariablesData SourcesFile Encoding and CSV DialectCustom DataReader ClassesSelection of Test Cases to ExecuteConfigure DataDriver by Pre-Run KeywordPabot and DataDriverWhat DataDriver DoesDataDriver is an alternative approach to create Data-Driven Tests with
Robot Framework®. DataDriver creates multiple test cases based on a test
template and data content of a csv or Excel file. All created tests
share the same test sequence (keywords) and differ in the test data.
Because these tests are created on runtime only the template has to be
specified within the robot test specification and the used data are
specified in an external data file.RoboCon 2020 TalkBrief overview what DataDriver is and how it works at the RoboCon 2020 in Helsiki.Alternative approachDataDriver gives an alternative to the build in data driven approach
like:*** Settings ***Resourcelogin_resources.robotSuite SetupOpen my BrowserSuite TeardownClose BrowsersTest SetupOpen Login PageTest TemplateInvalid login*** Test Cases ***UserPasswortRight user empty passdemo${EMPTY}Right user wrong passdemoFooBarEmpty user right pass${EMPTY}modeEmpty user empty pass${EMPTY}    ${EMPTY}Empty user wrong pass${EMPTY}FooBarWrong user right passFooBarmodeWrong user empty passFooBar${EMPTY}Wrong user wrong passFooBarFooBar*** Keywords ***Invalid login[Arguments]    ${username}    ${password}Input username${username}Input pwd${password}click login buttonError page should be visibleThis inbuilt approach is fine for a hand full of data and a hand full of
test cases. If you have generated or calculated data and specially if
you have a variable amount of test case / combinations these robot files
become quite a pain. With DataDriver you may write the same test case
syntax but only once and deliver the data from en external data file.One of the rare reasons when Microsoft® Excel or LibreOffice Calc may be
used in testing… ;-)See example test suiteSee example csv tableHow DataDriver WorksWhen the DataDriver is used in a test suite it will be activated before
the test suite starts. It uses the Listener Interface Version 3 of Robot
Framework® to read and modify the test specification objects. After
activation it searches for theTest Template-Keyword to analyze the[Arguments]it has. As a second step, it loads the data from the
specified data source. Based on theTest Template-Keyword, DataDriver
creates as much test cases as data sets are in the data source.In the case that data source is csv (Default)
As values for the arguments of theTest Template-Keyword, DataDriver
reads values from the column of the CSV file with the matching name of the[Arguments].
For each line of the CSV data table, one test case will be created. It
is also possible to specify test case names, tags and documentation for
each test case in the specific test suite related CSV file.UsageData Driver is a “Library Listener” but does not provide keywords.
Because Data Driver is a listener and a library at the same time it
sets itself as a listener when this library is imported into a test suite.To use it, just use it as Library in your suite. You may use the first
argument (option) which may set the file name or path to the data file.Without any options set, it loads a .csv file which has the same name
and path like the test suite .robot .Example:*** Settings ***LibraryDataDriverTest TemplateInvalid Logins*** Keywords ***Invalid Logins...Structure of Test SuiteRequirementsIn the Moment there are some requirements how a test
suite must be structured so that the DataDriver can get all the
information it needs.only the first test case will be used as a template. All other test
cases will be deleted.Test cases have to be defined with aTest Templatein Settings secion. Reason for this is,
that the DataDriver needs to know the names of the test case arguments.
Test cases do not have named arguments. Keywords do.The keyword which is used asTest Templatemust be defined within the test suite (in the same
*.robot file). If the keyword which is used asTest Templateis
defined in aResourcethe DataDriver has no access to its
arguments names.Example Test Suite***Settings***LibraryDataDriverResourcelogin_resources.robotSuite SetupOpen my BrowserSuite TeardownClose BrowsersTest SetupOpen Login PageTest TemplateInvalid Login*** Test Case ***Login with user${username}and password${password}DefaultUserData***** *Keywords* *****Invalid login[Arguments]    ${username}    ${password}Input username${username}Input pwd${password}click login buttonError page should be visibleIn this example, the DataDriver is activated by using it as a Library.
It is used with default settings.
AsTest Templatethe keywordInvalid Loginis used. This
keyword has two arguments. Argument names are${username}and${password}. These names have to be in the CSV file as column
header. The test case has two variable names included in its name,
which does not have any functionality in Robot Framework®. However, the
Data Driver will use the test case name as a template name and
replaces the variables with the specific value of the single generated
test case.
This template test will only be used as a template. The specified dataDefaultandUserDatawould only be used if no CSV file has
been found.Structure of data filemin. required columns*** Test Cases ***column has to be the first one.Argument columns:For each argument of theTest Templatekeyword one column must be existing in the data file as data source.
The name of this column must match the variable name and syntax.optional columns[Tags]column may be used to add specific tags to a test case. Tags
may be comma separated.[Documentation]column may be used to add specific test case
documentation.Example Data file*** Test
Cases ***${username}${password}[Tags][Documentation]Right user
empty passdemo${EMPTY}1This is a test
case
documentation of
the first one.Right user
wrong passdemoFooBar2,3,fooThis test
case has
the Tags
2,3 and foo
assigned.${EMPTY}mode1,2,3,4This test
case has a
generated
name based
on template
name.${EMPTY}${EMPTY}${EMPTY}FooBarFooBarmodeFooBar${EMPTY}FooBarFooBarIn this data file, eight test cases are defined. Each line specifies one
test case. The first two test cases have specific names. The other six
test cases will generate names based on template test cases name with
the replacement of variables in this name. The order of columns is
irrelevant except the first column,*** Test Cases ***Supported Data TypesIn general DataDriver supports any Object that is handed over from the DataReader.
However the text based readers for csv, excel and so do support different types as well.
DataDriver supports Robot Framework® Scalar variables as well as Dictionaries and Lists.
It also support python literal evaluations.Scalar VariablesThe Prefix$defines that the value in the cell is taken as in Robot Framework® Syntax.Stringisstr,${1}isintand${None}is NoneType.
The Prefix only defines the value typ. It can also be used to assign a scalar to a dictionary key.
See example table:${user}[id]Dictionary VariablesDictionaries can be created in different ways.One option is, to use the prefix&.
If a variable is defined that was (i.e.&{dict}) the cell value is interpreted the same way,
the BuiltIn keywordCreate Dictionarywould do.
The arguments here are comma (,) separated.
See example table:&{dict}The other option is to define scalar variables in dictionary syntax like${user}[name]or${user.name}That can be also nested dictionaries. DataDriver will create Robot Framework® (DotDict) Dictionaries, that can be accessed with${user.name.first}See example table:${user}[name][first]List VariablesLists can be created with the prefix@as comma (,) separated list.
See example table:@{list}Be aware that a list with an empty string has to be the cell content${Empty}.Python LiteralsDataDriver can evaluate Literals.
It uses the prefixefor that. (i.e.e{list_eval})
For that it usesBuiltIn EvaluateSee example table:e{user.chk}*** Test Cases ***${scalar}@{list}e{list_eval}&{dict}e{dict_eval}e{eval}${exp_eval}${user}[id]${user}[name][first]${user.name.last}e{user.chk}OneSum List1,2,3,4["1","2","3","4"]key=value{'key': 'value'}[1,2,3,4]101PekkaKlärck{'id': '1', 'name': {'first': 'Pekka', 'last':'Klärck'}}TwoShould be Equala,b,c,d["a","b","c","d"]key,value{'key': 'value'}True${true}2EdManlove{'id': '2', 'name': {'first': 'Ed', 'last':'Manlove'}}ThreeWhos your Daddy!,",',$["!",'"',"'","$"]z,value,a,value2{'a': 'value2', 'z': 'value'}{'Daddy' : 'René'}René3TatuAalto{'id': '3', 'name': {'first': 'Tatu', 'last':'Aalto'}}4Should be Equal1["1"]key=value{'key': 'value'}1${1}4JaniMikkonen{'id': '4', 'name': {'first': 'Jani', 'last':'Mikkonen'}}5Should be Equal[]a=${2}{'a':2}"string"string5MikkoKorpela{'id': '5', 'name': {'first': 'Mikko', 'last':'Korpela'}}6Should be Equal[1,2]["[1","2]"]key=value,key2=value2{'key': 'value', 'key2': 'value2'}None${none}6IsmoAro{'id': '6', 'name': {'first': 'Ismo', 'last':'Aro'}}Accessing Test Data From Robot VariablesIf neccesary it is possible to access the fetched data tables directly from a Robot Framework® variable.
This could be helpfull in Test Setup or in Suite Setup.There are three variables available within the Data-Driven Suite:@{DataDriver_DATA_LIST}A list as suite variable containing a robot dictionary for each test case that is selected for execution.[{"test_case_name":"Right user empty pass","arguments":{"${username}":"demo","${password}":"${EMPTY}"},"tags":["1"],"documentation":"This is a test case documentation of the first one."},{"test_case_name":"Right user wrong pass","arguments":{"${username}":"demo","${password}":"FooBar"},"tags":["2","3","foo"],"documentation":"This test case has the Tags 2,3 and foo"},{"test_case_name":"Login with user '${EMPTY}' and password 'mode'","arguments":{"${username}":"${EMPTY}","${password}":"mode"},"tags":["1","2","3","4"],"documentation":"This test case has a generated name based on template name."},{"test_case_name":"Login with user '${EMPTY}' and password '${EMPTY}'","arguments":{"${username}":"${EMPTY}","${password}":"${EMPTY}"},"tags":[""],"documentation":""},{"test_case_name":"Login with user '${EMPTY}' and password 'FooBar'","arguments":{"${username}":"${EMPTY}","${password}":"FooBar"},"tags":[""],"documentation":""},{"test_case_name":"Login with user 'FooBar' and password 'mode'","arguments":{"${username}":"FooBar","${password}":"mode"},"tags":["foo","1"],"documentation":""},{"test_case_name":"Login with user 'FooBar' and password '${EMPTY}'","arguments":{"${username}":"FooBar","${password}":"${EMPTY}"},"tags":["foo"],"documentation":""},{"test_case_name":"Login with user 'FooBar' and password 'FooBar'","arguments":{"${username}":"FooBar","${password}":"FooBar"},"tags":["foo","2"],"documentation":""}]This can be accessed as usual in Robot Framework®.${DataDriver_DATA_LIST}[2][arguments][\\${password}]would result inmode.&{DataDriver_DATA_DICT}A dictionary as suite variable that contains the same data as the list, with the test names as keys.{"Right user empty pass":{"test_case_name":"Right user empty pass","arguments":{"${username}":"demo","${password}":"${EMPTY}"},"tags":["1"],"documentation":"This is a test case documentation of the first one."},"Right user wrong pass":{"test_case_name":"Right user wrong pass","arguments":{"${username}":"demo","${password}":"FooBar"},"tags":["2","3","foo"],"documentation":"This test case has the Tags 2,3 and foo"},"Login with user '${EMPTY}' and password 'mode'":{"test_case_name":"Login with user '${EMPTY}' and password 'mode'","arguments":{"${username}":"${EMPTY}","${password}":"mode"},"tags":["1","2","3","4"],"documentation":"This test case has a generated name based on template name."},"Login with user '${EMPTY}' and password '${EMPTY}'":{"test_case_name":"Login with user '${EMPTY}' and password '${EMPTY}'","arguments":{"${username}":"${EMPTY}","${password}":"${EMPTY}"},"tags":[""],"documentation":""},"Login with user '${EMPTY}' and password 'FooBar'":{"test_case_name":"Login with user '${EMPTY}' and password 'FooBar'","arguments":{"${username}":"${EMPTY}","${password}":"FooBar"},"tags":[""],"documentation":""},"Login with user 'FooBar' and password 'mode'":{"test_case_name":"Login with user 'FooBar' and password 'mode'","arguments":{"${username}":"FooBar","${password}":"mode"},"tags":["foo","1"],"documentation":""},"Login with user 'FooBar' and password '${EMPTY}'":{"test_case_name":"Login with user 'FooBar' and password '${EMPTY}'","arguments":{"${username}":"FooBar","${password}":"${EMPTY}"},"tags":["foo"],"documentation":""},"Login with user 'FooBar' and password 'FooBar'":{"test_case_name":"Login with user 'FooBar' and password 'FooBar'","arguments":{"${username}":"FooBar","${password}":"FooBar"},"tags":["foo","2"],"documentation":""}}&{DataDriver_TEST_DATA}A dictionary as test variable that contains the test data of the current test case.
This dictionary does also contain arguments that are not used in theTest Templatekeyword.
This can be used in Test Setup and within a test case.{"test_case_name":"Right user wrong pass","arguments":{"${username}":"demo","${password}":"FooBar"},"tags":["2","3","foo"],"documentation":"This test case has the Tags 2,3 and foo"}Data SourcesCSV / TSV (Character-separated values)By default DataDriver reads csv files. With theEncoding and CSV
Dialectsettings you may configure which
structure your data source has.XLS / XLSX FilesTo use Excel file types, you have to install DataDriver with the Extra XLS.If you want to use Excel based data sources, you may just set the file
to the extention or you may point to the correct file. If the extention
is “.xls” or “.xlsx” DataDriver will interpret it as Excel file.
You may select the sheet which will be read by the optionsheet_name.
By default it is set to 0 which will be the first table sheet.
You may use sheet index (0 is first sheet) or sheet name(case sensitive).
XLS interpreter will ignore all other options like encoding, delimiters etc.*** Settings ***LibraryDataDriver.xlsxor:*** Settings ***LibraryDataDriverfile=my_data_source.xlsxsheet_name=2nd SheetMS Excel and typed cellsMicrosoft Excel xls or xlsx file have the possibility to type thair data
cells. Numbers are typically of the type float. If these data are not
explicitly defined as text in Excel, pandas will read it as the type
that is has in excel. Because we have to work with strings in Robot
Framework® these data are converted to string. This leads to the
situation that a European time value like “04.02.2019” (4th January
2019) is handed over to Robot Framework® in Iso time “2019-01-04
00:00:00”. This may cause unwanted behavior. To mitigate this risk you
should define Excel based files explicitly as text within Excel.Alternatively you may deactivate that string conversion.
To do so, you have to add the optionpreserve_xls_typestoTrue.
In that case, you will get str, float, boolean, int, datetime.time,
datetime.datetime and some others.*** Settings ***LibraryDataDriverfile=my_data_source.xlsxpreserve_xls_types=TruePICT (Pairwise Independent Combinatorial Testing)Pict is able to generate data files based on a model file.https://github.com/Microsoft/pictDocumentation:https://github.com/Microsoft/pict/blob/master/doc/pict.mdRequirements of PICTPath to pict.exe must be set in the %PATH% environment variable.Data model file has the file extention “.pict”Pict model file must be encoded in UTF-8How it worksIf the file option is set to a file with the extention pict, DataDriver
will hand over this file to pict.exe and let it automatically generates
a file with the extention “.pictout”. This file will the be used as data
source for the test generation. (It is tab seperated and UTF-8 encoded)
Except the file option all other options of the library will be ignored.*** Settings ***LibraryDataDrivermy_model_file.pictIt is possible to give options to pict with the import argumentpict_options=.*** Settings ***LibraryDataDriverpict_arg.pictpict_options=/o:3 /rGlob File PatternThis module implements a reader class that creates a test case for each file or folder that matches the given glob pattern.With an optional argument “arg_name” you can modify the argument that will be set. See folder example.Example with json files:*** Settings ***LibraryDataDriverfile=${CURDIR}/DataFiles/*_File.jsonreader_class=glob_readerLibraryOperatingSystemTest TemplateTest all Files*** Test Cases ***Glob_Reader_TestWrong_File.NoJson*** Keywords ***Test all Files[Arguments]    ${file_name}
    ${file_content}=Get File${file_name}
    ${content}=Evaluatejson.loads($file_content)["test_case"]Should Be Equal${TEST_NAME}    ${content}Example with folders:*** Settings ***LibraryDataDriverfile=${CURDIR}/FoldersToFind/*/reader_class=glob_readerarg_name=\\${folder_name}LibraryOperatingSystemTest TemplateTest all Files*** Test Cases ***Glob_Reader_TestWrong_File.NoJson*** Keywords ***Test all Files[Arguments]    ${folder_name}
    ${content}=Get File${folder_name}/verify.txtShould Be Equal${TEST_NAME}    ${content}File Encoding and CSV DialectWhile there are various specifications and implementations for the CSV format
(seeRFC 4180),
there is no formal specification in existence, which allows for a wide variety of interpretations of CSV files.
Therefore it is possible to define your own dialect or use
predefined. The default is Excel-EU which is a semicolon separated
file.
These Settings are changeable as options of the Data Driver Library.file=*** Settings ***LibraryDataDriverfile=../data/my_data_source.csvNone(default): Data Driver will search in the test suites folder if a
*.csv file with the same name than the test suite *.robot file existsonly file extention: if you just set a file extentions like “.xls” or
“.xlsx” DataDriver will searchabsolute path: If an absolute path to a file is set, DataDriver tries
to find and open the given data file.relative path: If the option does not point to a data file as an
absolute path, Data Driver tries to find a data file relative to the
folder where the test suite is located.encoding=encoding=must be set if it shall not be cp1252.Examples:cp1252, ascii,iso-8859-1,latin-1,utf_8, utf_16, utf_16_be, utf_16_lecp1252is:Code Page 1252Windows-1252Windows Western EuropeanMost characters are same between ISO-8859-1 (Latin-1) except for the code points 128-159 (0x80-0x9F).
These Characters are available in cp1252 which are not present in Latin-1.€ ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ Ž ‘ ’ “ ” • – — ˜ ™ š › œ ž ŸSeePython Standard Encodingfor more encodingsdialect=You may change the CSV Dialect here.
The dialect option can be one of the following:
- Excel-EU
- excel
- excel-tab
- unix
- UserDefinedsupported Dialects are:"Excel-EU"delimiter=';',quotechar='"',escapechar='\\',doublequote=True,skipinitialspace=False,lineterminator="\\r\\n",quoting=csv.QUOTE_ALL"excel"delimiter=','quotechar='"'doublequote=Trueskipinitialspace=Falselineterminator='\\r\\n'quoting=QUOTE_MINIMAL"excel-tab"delimiter='\\t'quotechar='"'doublequote=Trueskipinitialspace=Falselineterminator='\\r\\n'quoting=QUOTE_MINIMAL"unix"delimiter=','quotechar='"'doublequote=Trueskipinitialspace=Falselineterminator='\\n'quoting=QUOTE_ALLUsage in Robot Framework®*** Settings ***LibraryDataDrivermy_data_file.csvdialect=excel*** Settings ***LibraryDataDrivermy_data_file.csvdialect=excel_tab*** Settings ***LibraryDataDrivermy_data_file.csvdialect=unix_dialectExample User DefinedUser may define the format completely free.
If an option is not set, the default values are used.
To register a userdefined format user have to set the
optiondialecttoUserDefinedUsage in Robot Framework®*** Settings ***LibraryDataDrivermy_data_file.csv...dialect=UserDefined...delimiter=....lineterminator=\\nDefaults:file=None,encoding='cp1252',dialect='Excel-EU',delimiter=';',quotechar='"',escapechar='\\\\',doublequote=True,skipinitialspace=False,lineterminator='\\r\\n',sheet_name=0Custom DataReader ClassesIt is possible to write your own DataReader Class as a plugin for DataDriver.
DataReader Classes are called from DataDriver to return a list of TestCaseData.Using Custom DataReaderDataReader classes are loaded dynamically into DataDriver while runtime.
DataDriver identifies the DataReader to load by the file extantion of the data file or by the optionreader_class.Select Reader by File Extension:*** Settings ***LibraryDataDriverfile=mydata.csvThis will load the classcsv_readerfromcsv_reader.pyfrom the same folder.Select Reader by Option:*** Settings ***LibraryDataDriverfile=mydata.csvreader_class=generic_csv_readerdialect=userdefineddelimiter=\\tencoding=UTF-8This will load the classgeneric_csv_readerfromgeneric_csv_reader.pyfrom same folder.Create Custom ReaderRecommendation:Have a look to the Source Code of existing DataReader likecsv_reader.pyorgeneric_csv_reader.py.To write your own reader, create a class inherited fromAbstractReaderClass.Your class will get all available configs from DataDriver as an object ofReaderConfigon__init__.DataDriver will call the methodget_data_from_sourceThis method should then load your data from your custom source and stores them into list of object ofTestCaseData.
This List ofTestCaseDatawill be returned to DataDriver.AbstractReaderClasshas also some optional helper methods that may be useful.You can either place the custom reader with the others in DataDriver folder or anywhere on the disk.
In the first case or if your custom reader is in python path just use it like the others by name:*** Settings ***LibraryDataDriverreader_class=my_readerIn case it is somewhere on the disk, it is possible to use an absolute or relative path to a custom Reader.
Imports of custom readers follow the same rules like importing Robot Framework® libraries.
Path can be relative to ${EXECDIR} or to DataDriver/__init__.py:*** Settings ***LibraryDataDriverreader_class=C:/data/my_reader.py# set custom reader...file_search_strategy=None# set DataDriver to not check file...min=0# kwargs arguments for custom reader...max=62Thismy_reader.pyshould implement a class inherited from AbstractReaderClass that is namedmy_reader.fromDataDriver.AbstractReaderClassimportAbstractReaderClass# inherit class from AbstractReaderClassfromDataDriver.ReaderConfigimportTestCaseData# return list of TestCaseData to DataDriverclassmy_reader(AbstractReaderClass):defget_data_from_source(self):# This method will be called from DataDriver to get the TestCaseData list.test_data=[]foriinrange(int(self.kwargs['min']),int(self.kwargs['max'])):# Dummy code to just generate some dataargs={'${var_1}':str(i),'${var_2}':str(i)}# args is a dictionary. Variable name is the key, value is value.test_data.append(TestCaseData(f'test{i}',args,['tag']))# add a TestCaseData object to the list of tests.returntest_data# return the list of TestCaseData to DataDriverSee other readers as example.Selection of Test Cases to ExecuteBecause test cases that are created by DataDriver after parsing while execution,
it is not possible to use some Robot Framework® methods to select test cases.Examples for options that have to be used differently:robot optionDescription--testSelects the test cases by name.--taskAlias for –test that can be used when executing tasks.--rerunfailedSelects failed tests from an earlier output file to be re-executed.--includeSelects the test cases by tag.--excludeSelects the test cases by tag.Selection of test cases by nameSelect a single test case:To execute just a single test case by its exact name it is possible to execute the test suite
and set the global variable ${DYNAMICTEST} with the name of the test case to execute as value.
Pattern must besuitename.testcasename.Example:robot --variable "DYNAMICTEST:my suite name.test case to be executed" my_suite_name.robotPabot uses this feature to execute a single test case when using--testlevelsplitSelect a list of test cases:It is possible to set a list of test case names by using the variable ${DYNAMICTESTS} (plural).
This variable must be a string and the list of names must be pipe-seperated (|).Example:robot --variable DYNAMICTESTS:firstsuitename.testcase1|firstsuitename.testcase3|anothersuitename.othertestcase foldernameIt is also possible to set the variable @{DYNAMICTESTS} as a list variable from i.e. python code.Re-run failed test cases:Because it is not possible to use the command line argument--rerunfailedfrom robot directly,
DataDriver brings a Pre-Run-Modifier that handles this issue.Normally reexecution of failed testcases has three steps.original executionre-execution the failed ones based on original execution outputmerging original execution output with re-execution outputThe DataDriver.rerunfailed Pre-Run-Modifier removes all passed test cases based on a former output.xml.Example:robot --output original.xml tests                                                    # first execute all tests
robot --prerunmodifier DataDriver.rerunfailed:original.xml --output rerun.xml tests  # then re-execute failing
rebot --merge original.xml rerun.xml                                                 # finally merge resultsBe aware, that in this case it is not allowed to use “:” as character in the original output file path.
If you want to set a full path on windows likee:\\myrobottest\\output.xmlyou have to use “;”
as argument seperator.Example:robot --prerunmodifier DataDriver.rerunfailed;e:\\myrobottest\\output.xml --output e:\\myrobottest\\rerun.xml testsFiltering with tags.New in0.3.1It is possible to use tags to filter the data source.
To use this, tags must be assigned to the test cases in data source.Robot Framework® Command Line ArgumentsTo filter the source, the normal command line arguments of Robot Framework® can be used.
See Robot Framework®Userguidefor more information
Be aware that the filtering of Robot Framework® itself is done before DataDriver is called.
This means if the Template test is already filtered out by Robot Framework®, DataDriver can never be called.
If you want to use--includethe DataDriver TestSuite should have aDefaultTagorForceTagthat
fulfills these requirements.Example:robot--include1OR2--excludefoo DataDriven.robotFilter based on Library OptionsIt is also possible to filter the data source by an init option of DataDriver.
If these Options are set, Robot Framework® Filtering will be ignored.Example:*** Settings ***LibraryDataDriverinclude=1OR2exclude=fooConfigure DataDriver by Pre-Run KeywordWithconfig_keyword=it’s possible to name a keyword that will be called from Data Driver before it starts the actual processing of thedata file.
One possible usage is if thedata fileitself shall be created by another keyword dynamically during the execution of the Data Driver test suite.
Theconfig_keyword=can be used to call that keyword and return the updated arguments (e.g.file) back to the Data Driver Library.Theconfig keywordMay be defined globally or inside each testsuite individuallyGets all the arguments, that Data Driver gets from Library import, as a Robot DictionaryShall return the (updated) Data Driver arguments as a Robot DictionaryUsage in Robot Framework®*** Settings ***LibraryOperatingSystemLibraryDataDriverdialect=excelencoding=utf_8config_keyword=ConfigTest TemplateThe Keyword*** Test Cases ***Testaaa*** Keywords ***The Keyword[Arguments]    ${var}Log To Console${var}Config[Arguments]    ${original_config}Log To Console${original_config.dialect}# just a log of the originalCreate File${CURDIR}/test321.csv...*** Test Cases ***,\\${var},\\n123,111,\\n321,222,# generating file${new_config}=Create Dictionaryfile=test321.csv# set file attribute in a dictionary[Return]    ${new_config}# returns {'file': 'test321.csv'}Pabot and DataDriverYou should use Pabot version 1.10.0 or newer.DataDriver supports--testlevelsplitfrom pabot only if the PabotLib is in use.
Use--pabotlibto enable that.When using pabot like this, DataDriver automatically splits the amount of test cases into nearly same sized groups.
Is uses the processes count from pabot to calculate the groups.
When using 8 processes with 100 test cases you will get 8 groups of tests with the size of 12 to 13 tests.
These 8 groups are then executed as one block with 8 processes.
This reduces a lot of overhead with Suite Setup and Teardown.You can switch between three modes:Equal: means it creates equal sizes groupsBinary: is more complex. it created a decreasing size of containers to support better balancing.Atomic: it does not group tests at all and runs really each test case in a separate thread.This can be set byoptimize_pabotin Library import.Example:*** Settings ***LibraryDataDriveroptimize_pabot=BinaryBinary creates with 40 test cases and 8 threads something like that:P01: 01,02,03,04,05
P02: 06,07,08,09,10
P03: 11,12,13,14,15
P04: 16,17,18,19,20
P05: 21,22,23
P06: 24,25,26
P07: 27,28,29
P08: 30,31,32
P09: 33
P10: 34
P11: 35
P12: 36
P13: 37
P14: 38
P15: 39
P16: 40