Glossary¶

Validation that a system satisfies agreed business requirements and is ready for deployment or release.

Value supplied to a keyword call as positional, named, or embedded input to configure its behavior.

File containing command-line options and data sources that Robot Framework reads as arguments through the --argumentfile option.

Argument Interface

Ordered specification of a keyword’s arguments, including kinds (for example positional-or-named, named-only, variable positional, free named, embedded), names, default values, and optional type hints.

Atomic Element

Execution element without child steps whose status depends solely on its own execution result.

Automatic Variable

Built-in variable whose value Robot Framework sets from the current execution context and whose availability can depend on the execution phase.

Behavior-Driven Development

Development approach that describes system behavior in business-readable language, often using Given/When/Then phrasing.

Aliases: BDD

Behavior-Driven Specification

Declarative Robot Framework style in which tests|tasks describe system behavior from the user's perspective using natural-language-like steps with embedded arguments and optional Given/When/Then/And/But prefixes.

Boolean Argument

Keyword argument whose value Robot Framework interprets as true or false according to its Boolean conversion rules.

Built-In Variables

Variables provided by Robot Framework that expose execution-related information such as paths, timestamps, and status without explicit definition.

Command Line Interface

Interface used to run Robot Framework from the command line (for example with the robot command), configure execution options, and pass arguments or variables.

Aliases: CLI, Robot Framework CLI

Command-Line Option

Named option passed to the robot or rebot command to configure execution or result post-processing.

Aliases: CLI option

Composite Element

Execution element composed of child elements (for example suites with tests|tasks, tests|tasks with keywords, or user keywords with child steps) whose status is derived from its children.

Continuable Failure

Keyword failure that marks the test or task as failed but allows execution to continue.

Aliases: continue-on-failure

Control Structure

Statement such as IF, FOR, WHILE, BREAK, or CONTINUE that controls execution flow inside a test|task, or keyword.

Data-Driven Specification

Specification style where the same logic or test flow is executed multiple times with varying input or expected output data, often implemented with test|task templates.

Debug File

Optional plain-text result file written during execution that records library messages and the start and end of suites, tests or tasks, and keywords.

Aliases: debug.txt

Dictionary Variable

Robot Framework variable of dictionary type created with the &{} syntax that holds key-value pairs and can be accessed by keys.

Aliases: &{}

Documentation

Descriptive text attached to a suite, test or task, user keyword, library, or resource file to explain its purpose, behaviour, or use.

Dry Run

Execution mode that validates test data without running keywords provided by test libraries.

Dynamic Library API

Test library API in which special methods provide keyword names, arguments, documentation, and execution at runtime.

Aliases: Dynamic API

Embedded Argument

Argument kind defined directly in a keyword name using ${} syntax whose value must appear in that position in calls, often used in behavior-driven steps.

Environment Variable

Operating-system variable available in Robot Framework data through %{NAME} syntax, optionally with a default value.

Aliases: operating-system variable

Execution Artifacts

Files generated by a Robot Framework execution (e.g. output.xml, log.html, and report.html) that document the execution process and its results.

Execution Flow

Order and conditions under which Robot Framework executes suites, tests or tasks, setups, teardowns, keywords, and control structures.

Execution Model

Internal representation created after parsing suites, tests, tasks, and keywords that the execution engine uses to perform automation.

Aliases: data model, running model

External Library

Test library that is distributed separately from Robot Framework rather than included as a standard library.

Fail Status

Execution status indicating that an element (e.g. keyword, test|task, or suite) did not meet its expected outcome or raised an error during execution.

FOR Loop

Control structure used to iterate over items in a list or other iterable and execute a body of keywords for each item.

Free Named Argument

Catch-all named argument kind in a keyword specification, marked with **, that gathers all named values not explicitly defined elsewhere into a dictionary.

Aliases: **kwargs

Given / When / Then / And / But

Conventional prefixes in behavior-driven specification style that Robot Framework can ignore when matching keywords if the remaining part of the name matches a keyword.

Global Variable

Variable with global scope that can be accessed from all suites and keywords in a Robot Framework execution.

GROUP Structure

Control structure that groups related keywords and control structures under a name without creating a separate keyword or variable scope.

Aliases: GROUP

Hybrid Library API

Test library API that lists keyword names with get_keyword_names but otherwise exposes and executes keywords through the static library API.

Aliases: hybrid library

IF Statement

Control structure in Robot Framework used to execute one block of statements when a condition is true and optionally alternative blocks with ELSE IF or ELSE when it is not.

Aliases: IF, IF/ELSE

Initialization File

Suite file located in a directory that configures that directory as a suite and defines suite-level settings, variables, setups, and teardowns for contained suites.

Aliases: __init__.robot, Suite Initialization File

Inline Comment

Comment at the beginning or end of a line in a Robot Framework file, separated by at least two spaces and starting with # so that it is ignored by the interpreter.

Inline IF

Compact single-line IF statement (IF <condition> <keyword> [args]) used to execute one keyword conditionally without an END.

JSON Model

JSON representation of an execution or result model that can be serialized and reconstructed through Robot Framework's model APIs.

Aliases: JSON data model

JSON Output Format

Machine-readable JSON representation of execution results used in output files with the .json extension.

Aliases: JSON output file

Keyword

Named reusable action or sequence of actions in Robot Framework callable from tests, tasks, or other keywords that may accept arguments and return values.

Keyword Interface

Documented information about a keyword, including its name, arguments with kinds and types, return values, documentation, and examples, as exposed by HTML documentation or IDEs.

Keyword Library

Collection of library keywords implemented typically in Python (or other languages) that Robot Framework imports to interact with external systems, perform computations, or provide utility functions.

Aliases: Library, Test Library

Keyword Scope

Priority category based on where a keyword is defined that Robot Framework uses to resolve calls when multiple keywords have the same name.

Keyword-Driven Specification

Imperative Robot Framework style where tests|tasks are written as sequences of keyword calls with arguments, focusing on executed actions and their order.

Keyword-Only Argument

Python function argument defined after *args or a bare * that Robot Framework exposes as a named-only keyword argument.

Library API

Interface through which Robot Framework discovers and executes keywords provided by a test library, using either the static or dynamic API.

Aliases: test library API

Library Keyword

Lowest-level keyword implemented by a test library, often used to interact with a system or perform utility operations.

Library Scope

Setting that controls how long a class-based test library instance is retained and whether it is shared between tests or suites.

Library Specification File

Machine-readable XML or JSON file generated by Libdoc that describes a library or resource file and the keywords it provides.

Aliases: libspec, Libdoc spec file

List Variable

Robot Framework variable of list type created with the @{} syntax that holds an ordered collection of values and can be unpacked when passed to keywords.

Aliases: @{}

Listener Interface

Extension interface that notifies listeners about execution events and allows them to inspect or modify execution data and results.

Aliases: listener API

Local Variable

Variable whose scope is limited to a single keyword, test, or task execution and is not visible outside that body.

Log File

Detailed HTML execution log (log.html) generated by Robot Framework that shows keyword-level execution steps, arguments, messages, and statuses.

Aliases: log.html

Log Level

Classification that indicates the severity or detail of a log message and determines whether the message is recorded or shown.

Mandatory Argument

Argument kind in a keyword specification without a default value that must be provided in calls and that precedes optional arguments.

Metadata

Key–value information attached to a suite, test, or task to document attributes such as owner, environment, version, or related requirements.

Aliases: free metadata

Named Argument

Argument value provided in a keyword call using an explicit name=value pair.

Named-Only Argument

Argument kind in a keyword specification that must be provided by name (never positionally), typically defined after a Variable Number of Positional Arguments or explicitly marked, and that can be mandatory or optional.

Optional Argument

Argument kind in a keyword specification that may be omitted because it has a default value or is a catch-all (e.g. Variable Number of Positional Arguments marked with * or Free Named Arguments marked with **).

Output Directory

Base directory used for result files whose paths are not absolute, configured with the --outputdir option.

Output File

Primary machine-readable execution result file (e.g. output.xml) produced by Robot Framework that stores the full execution tree, messages, and statistics and serves as the source for generating log and report files.

Aliases: output.xml

Parser Interface

Extension interface for parsing custom test data formats or replacing Robot Framework's standard parser for selected file extensions.

Aliases: parser API

Pass Status

Execution status indicating that an element (e.g. keyword, test|task, or suite) executed successfully and met its expectations.

Positional Argument

Argument value provided in a keyword call solely by its position in the argument list without naming it explicitly.

Positional or Named Argument

Argument kind in a keyword specification that can be set either by position or by name (but not both for the same value) and that may be mandatory or optional.

Positional-Only Argument

Python function argument defined before / that Robot Framework accepts only by position.

Pre-Run Modifier

Visitor-based extension that can inspect or modify the executable suite structure before test or task selection and execution.

Private User Keyword

User keyword tagged with robot:private that is intended for use only in the file where it is defined; use elsewhere causes a warning.

Rebot

Command-line tool for generating, combining, merging, and otherwise post-processing Robot Framework output files.

Remote Library Interface

Interface that makes keywords running in another process or machine, including implementations in other languages, available through the standard Remote library.

Aliases: Remote library

Remote Protocol

XML-RPC-based protocol used between the standard Remote library and a remote server to discover and execute keywords.

Report File

High-level HTML summary (report.html) of a Robot Framework execution that focuses on statistics and the overall pass/fail status of suites and tests|tasks.

Aliases: report.html

Reserved Tag

Tag with the robot: prefix whose meaning and behaviour are defined by Robot Framework.

Resource File

File (commonly with extension .resource or .robot) that contains user keywords and variables and is imported by suites to share and reuse these artifacts.

Result File

Execution artifact that stores or presents Robot Framework execution results, such as an output, log, report, xUnit-compatible, or debug file.

Aliases: result files

Result Model

Programmatic object model of Robot Framework execution results used to inspect, modify, and generate result files.

Result Visitor

Visitor interface that traverses a result model and calls handlers for suites, tests or tasks, keywords, messages, statistics, and errors.

Aliases: visitor interface

RETURN Statement

Statement used in user keywords to return one or more values that can be assigned to variables in the calling context.

Aliases: RETURN

Return Type Hint

Documented indication of the type of value a keyword returns, helping users understand how to use the returned data.

Robot Framework Foundation

Non-profit association (Robot Framework ry) that stewards the development, ecosystem, governance, and promotion of Robot Framework and its community.

Robotic Process Automation

Automation of business processes or tasks normally performed by humans, often across multiple systems, without necessarily focusing on testing.

Aliases: RPA

Root Suite

Top-level suite in a Robot Framework execution determined by the initial directory or file path passed to the robot command.

Scalar Access Syntax

Standard variable access form ${} in Robot Framework used to read values regardless of whether the underlying variable was defined as scalar, list-like, or dictionary-like.

Aliases: ${}

Scalar Variable

Robot Framework variable accessed with the ${} syntax that holds a single value of any supported data type.

Secret Variable

Variable whose value Robot Framework avoids logging when it is passed as an argument or return value, without hiding or encrypting the value from code.

Aliases: secret

Section

Structural part of a Robot Framework data file identified by a header, such as Setting, Variable, Test Case, Task, Keyword, or Comment, with available types depending on whether the file is a suite or resource file.

Aliases: test data section, test data sections, table, tables

Section Header

Header row such as *** Settings *** that identifies the type of a section.

Setting

Named instruction that imports data or configures behaviour for a file, suite, test or task, or user keyword.

Setup

Keyword executed before the content of a suite, test or task, or user keyword to prepare the state needed by that scope.

Simple Pattern

Glob-like pattern that uses *, ?, and bracket expressions for matching and is normally case-, space-, and underscore-insensitive.

Aliases: glob-like pattern

Skip Status

Execution status indicating that an element (e.g. a test|task) was intentionally not executed, for example due to selection options or an explicit skip.

Standard Library

Library shipped with Robot Framework itself providing generic functionality such as operating system interaction, string manipulation, or process handling.

Static Library API

Default test library API in which Robot Framework uses reflection to map functions or methods directly to keywords.

Aliases: Static API

Suite

Collection of tests|tasks (optionally with local keywords and variables) defined in a .robot file or directory that is executed as a unit by Robot Framework.

Aliases: Test Suite, Task Suite

Suite Directory

Directory treated as a suite because it directly or indirectly contains at least one suite file, grouping lower-level suites into a suite tree.

Aliases: Higher-Level Suite

Suite File

.robot file that contains at least one test case or task and is therefore treated by Robot Framework as an executable suite.

Suite Status

PASS, FAIL, or SKIP status of a suite, derived from the statuses of the tests or tasks it contains.

Suite Variable

Variable whose scope covers all tests|tasks and keywords within a specific suite but is not visible outside that suite.

System Log

Optional plain-text diagnostic log containing information about Robot Framework's internal parsing, imports, execution, and output creation.

Aliases: syslog

Tag

Label assigned to a test, task, or keyword to categorize it, support filtering or reporting, or activate reserved Robot Framework behaviour.

Tag Pattern

Pattern used to select tags with simple wildcards and the Boolean operators AND, OR, and NOT.

Task

Executable entity in Robot Framework similar to a test case but used for non-testing automation such as RPA workflows, defined in a *** Tasks *** section.

Teardown

Keyword executed after the content of a suite, test or task, or user keyword to clean up resources, including when earlier execution fails.

Test Case

Executable specification in Robot Framework that verifies some aspect of system behavior and is defined in a *** Test Cases *** section.

Aliases: Test

Test Data

Collection of suites, tests, tasks, resource files, keywords, and variables that define what Robot Framework executes.

Test Template

Setting that defines a keyword used as a template for multiple tests|tasks, where each row of data calls the template keyword with different arguments.

Aliases: Task Template

Timeout

Maximum execution time configured for a test, task, or user keyword, after which Robot Framework stops the affected execution and marks it as failed.

TRY/EXCEPT Structure

Control structure that handles keyword failures by matching error messages in one or more EXCEPT branches, with optional ELSE and FINALLY branches.

Aliases: TRY/EXCEPT

User Keyword

Keyword defined in Robot Framework syntax (typically in suites or resource files) composed of calls to other keywords and statements, often describing higher-level or business-oriented actions.

Aliases: Composite Keyword

Variable

Named reference to a value or collection of values in Robot Framework used to store data and pass it between keywords, tests, and tasks.

Variable File

File (often a Python module or other supported format) that provides variables which can be imported into suites using the Variables setting.

Variable Number of Positional Arguments

Optional argument kind in a keyword specification, marked with a single *, that collects all remaining positional values; once present, any subsequent parameters must be provided as named arguments.

Aliases: *varargs, *args

Variable Priority

Order that determines which value Robot Framework uses when variables with the same name come from different sources.

Variable Scope

Visibility and lifetime of a variable (e.g. global, suite, test|task, or local) during a Robot Framework execution.

Variable Type Conversion

Automatic conversion of a value to a specified type when a variable is created using typed variable syntax.

WHILE Loop

Control structure in Robot Framework that repeatedly executes a block of keywords as long as a given condition evaluates to true.

XML Output Format

Machine-readable XML representation of execution results used by default for output files.

XUnit-Compatible Result File

Optional XML file containing an execution summary in a format understood by xUnit-compatible tools.

Aliases: xUnit file