Skip to content

robot.libraries.OperatingSystem

OperatingSystem

A library providing keywords for operating system related tasks.

OperatingSystem is Robot Framework's standard library that enables various operating system related tasks to be performed in the system where Robot Framework is running. It can, among other things, execute commands (e.g. Run), create and remove files and directories (e.g. Create File, Remove Directory), check whether files or directories exists or contain something (e.g. File Should Exist, Directory Should Be Empty) and manipulate environment variables (e.g. Set Environment Variable).

== Table of contents ==

%TOC%

= Path separators =

Because Robot Framework uses the backslash (\) as an escape character in its data, using a literal backslash requires duplicating it like in c:\\path\\file.txt. That can be inconvenient especially with longer Windows paths, and thus all keywords expecting paths as arguments convert forward slashes to backslashes automatically on Windows. This also means that paths like ${CURDIR}/path/file.txt are operating system independent.

Notice that the automatic path separator conversion does not work if the path is only a part of an argument like with the Run keyword. In these cases the built-in variable ${/} that contains \ or /, depending on the operating system, can be used instead.

= Pattern matching =

Many keywords accept arguments as either glob or regular expression patterns.

== Glob patterns ==

Some keywords, for example List Directory, support so called [http://en.wikipedia.org/wiki/Glob_(programming)|glob patterns] where:

| * | matches any string, even an empty string | | ? | matches any single character | | [chars] | matches one character in the bracket | | [!chars] | matches one character not in the bracket | | [a-z] | matches one character from the range in the bracket | | [!a-z] | matches one character not from the range in the bracket |

Unless otherwise noted, matching is case-insensitive on case-insensitive operating systems such as Windows.

== Regular expressions ==

Some keywords, for example Grep File, support [http://en.wikipedia.org/wiki/Regular_expression|regular expressions] that are more powerful but also more complicated that glob patterns. The regular expression support is implemented using Python's [http://docs.python.org/library/re.html|re module] and its documentation should be consulted for more information about the syntax.

Because the backslash character (\) is an escape character in Robot Framework data, possible backslash characters in regular expressions need to be escaped with another backslash like \\d\\w+. Strings that may contain special characters but should be handled as literal strings, can be escaped with the Regexp Escape keyword from the BuiltIn library.

= Tilde expansion =

Paths beginning with ~ or ~username are expanded to the current or specified user's home directory, respectively. The resulting path is operating system dependent, but typically e.g. ~/robot is expanded to C:\Users\<user>\robot on Windows and /home/<user>/robot on Unixes.

= pathlib.Path support =

Starting from Robot Framework 6.0, arguments representing paths can be given as [https://docs.python.org/3/library/pathlib.html|pathlib.Path] instances in addition to strings.

All keywords returning paths return them as strings. This may change in the future so that the return value type matches the argument type.

= Boolean arguments =

Some keywords accept arguments that are handled as Boolean values true or false. If such an argument is given as a string, it is considered false if it is an empty string or equal to FALSE, NONE, NO, OFF or 0, case-insensitively. Other strings are considered true regardless their value, and other argument types are tested using the same [http://docs.python.org/library/stdtypes.html#truth|rules as in Python].

True examples: | Remove Directory | ${path} | recursive=True | # Strings are generally true. | | Remove Directory | ${path} | recursive=yes | # Same as the above. | | Remove Directory | ${path} | recursive=${TRUE} | # Python True is true. | | Remove Directory | ${path} | recursive=${42} | # Numbers other than 0 are true. |

False examples: | Remove Directory | ${path} | recursive=False | # String false is false. | | Remove Directory | ${path} | recursive=no | # Also string no is false. | | Remove Directory | ${path} | recursive=${EMPTY} | # Empty string is false. | | Remove Directory | ${path} | recursive=${FALSE} | # Python False is false. |

= Example =

| * Settings | Library OperatingSystem | | Variables | ${PATH} ${CURDIR}/example.txt | | Test Cases *** | Example | Create File ${PATH} Some text | File Should Exist ${PATH} | Copy File ${PATH} ~/file.txt

run 

1
run(command)

Runs the given command in the system and returns the output.

The execution status of the command is not checked by this keyword, and it must be done separately based on the returned output. If the execution return code is needed, either Run And Return RC or Run And Return RC And Output can be used.

The standard error stream is automatically redirected to the standard output stream by adding 2>&1 after the executed command. This automatic redirection is done only when the executed command does not contain additional output redirections. You can thus freely forward the standard error somewhere else, for example, like my_command 2>stderr.txt.

The returned output contains everything written into the standard output or error streams by the command (unless either of them is redirected explicitly). Many commands add an extra newline (\n) after the output to make it easier to read in the console. To ease processing the returned output, this possible trailing newline is stripped by this keyword.

Examples: | ${output} = | Run | ls -lhF /tmp | | Log | ${output} | | ${result} = | Run | ${CURDIR}${/}tester.py arg1 arg2 | | Should Not Contain | ${result} | FAIL | | ${stdout} = | Run | /opt/script.sh 2>/tmp/stderr.txt | | Should Be Equal | ${stdout} | TEST PASSED | | File Should Be Empty | /tmp/stderr.txt |

TIP: Run Process keyword provided by the [http://robotframework.org/robotframework/latest/libraries/Process.html| Process library] supports better process configuration and is generally recommended as a replacement for this keyword.

Source code in src/robot/libraries/OperatingSystem.py 
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
def run(self, command):
    """Runs the given command in the system and returns the output.

    The execution status of the command *is not checked* by this
    keyword, and it must be done separately based on the returned
    output. If the execution return code is needed, either `Run
    And Return RC` or `Run And Return RC And Output` can be used.

    The standard error stream is automatically redirected to the standard
    output stream by adding ``2>&1`` after the executed command. This
    automatic redirection is done only when the executed command does not
    contain additional output redirections. You can thus freely forward
    the standard error somewhere else, for example, like
    ``my_command 2>stderr.txt``.

    The returned output contains everything written into the standard
    output or error streams by the command (unless either of them
    is redirected explicitly). Many commands add an extra newline
    (``\\n``) after the output to make it easier to read in the
    console. To ease processing the returned output, this possible
    trailing newline is stripped by this keyword.

    Examples:
    | ${output} =        | Run       | ls -lhF /tmp |
    | Log                | ${output} |
    | ${result} =        | Run       | ${CURDIR}${/}tester.py arg1 arg2 |
    | Should Not Contain | ${result} | FAIL |
    | ${stdout} =        | Run       | /opt/script.sh 2>/tmp/stderr.txt |
    | Should Be Equal    | ${stdout} | TEST PASSED |
    | File Should Be Empty | /tmp/stderr.txt |

    *TIP:* `Run Process` keyword provided by the
    [http://robotframework.org/robotframework/latest/libraries/Process.html|
    Process library] supports better process configuration and is generally
    recommended as a replacement for this keyword.
    """
    return self._run(command)[1]

run_and_return_rc 

1
run_and_return_rc(command)

Runs the given command in the system and returns the return code.

The return code (RC) is returned as a positive integer in range from 0 to 255 as returned by the executed command. On some operating systems (notable Windows) original return codes can be something else, but this keyword always maps them to the 0-255 range. Since the RC is an integer, it must be checked e.g. with the keyword Should Be Equal As Integers instead of Should Be Equal (both are built-in keywords).

Examples: | ${rc} = | Run and Return RC | ${CURDIR}${/}script.py arg | | Should Be Equal As Integers | ${rc} | 0 | | ${rc} = | Run and Return RC | /path/to/example.rb arg1 arg2 | | Should Be True | 0 < ${rc} < 42 |

See Run and Run And Return RC And Output if you need to get the output of the executed command.

TIP: Run Process keyword provided by the [http://robotframework.org/robotframework/latest/libraries/Process.html| Process library] supports better process configuration and is generally recommended as a replacement for this keyword.

Source code in src/robot/libraries/OperatingSystem.py 
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
def run_and_return_rc(self, command):
    """Runs the given command in the system and returns the return code.

    The return code (RC) is returned as a positive integer in
    range from 0 to 255 as returned by the executed command. On
    some operating systems (notable Windows) original return codes
    can be something else, but this keyword always maps them to
    the 0-255 range. Since the RC is an integer, it must be
    checked e.g. with the keyword `Should Be Equal As Integers`
    instead of `Should Be Equal` (both are built-in keywords).

    Examples:
    | ${rc} = | Run and Return RC | ${CURDIR}${/}script.py arg |
    | Should Be Equal As Integers | ${rc} | 0 |
    | ${rc} = | Run and Return RC | /path/to/example.rb arg1 arg2 |
    | Should Be True | 0 < ${rc} < 42 |

    See `Run` and `Run And Return RC And Output` if you need to get the
    output of the executed command.

    *TIP:* `Run Process` keyword provided by the
    [http://robotframework.org/robotframework/latest/libraries/Process.html|
    Process library] supports better process configuration and is generally
    recommended as a replacement for this keyword.
    """
    return self._run(command)[0]

run_and_return_rc_and_output 

1
run_and_return_rc_and_output(command)

Runs the given command in the system and returns the RC and output.

The return code (RC) is returned similarly as with Run And Return RC and the output similarly as with Run.

Examples: | ${rc} | ${output} = | Run and Return RC and Output | ${CURDIR}${/}mytool | | Should Be Equal As Integers | ${rc} | 0 | | Should Not Contain | ${output} | FAIL | | ${rc} | ${stdout} = | Run and Return RC and Output | /opt/script.sh 2>/tmp/stderr.txt | | Should Be True | ${rc} > 42 | | Should Be Equal | ${stdout} | TEST PASSED | | File Should Be Empty | /tmp/stderr.txt |

TIP: Run Process keyword provided by the [http://robotframework.org/robotframework/latest/libraries/Process.html| Process library] supports better process configuration and is generally recommended as a replacement for this keyword.

Source code in src/robot/libraries/OperatingSystem.py 
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
def run_and_return_rc_and_output(self, command):
    """Runs the given command in the system and returns the RC and output.

    The return code (RC) is returned similarly as with `Run And Return RC`
    and the output similarly as with `Run`.

    Examples:
    | ${rc} | ${output} =  | Run and Return RC and Output | ${CURDIR}${/}mytool |
    | Should Be Equal As Integers | ${rc}    | 0    |
    | Should Not Contain   | ${output}       | FAIL |
    | ${rc} | ${stdout} =  | Run and Return RC and Output | /opt/script.sh 2>/tmp/stderr.txt |
    | Should Be True       | ${rc} > 42      |
    | Should Be Equal      | ${stdout}       | TEST PASSED |
    | File Should Be Empty | /tmp/stderr.txt |

    *TIP:* `Run Process` keyword provided by the
    [http://robotframework.org/robotframework/latest/libraries/Process.html|
    Process library] supports better process configuration and is generally
    recommended as a replacement for this keyword.
    """
    return self._run(command)

get_file 

1
get_file(path, encoding='UTF-8', encoding_errors='strict')

Returns the contents of a specified file.

This keyword reads the specified file and returns the contents. Line breaks in content are converted to platform independent form. See also Get Binary File.

encoding defines the encoding of the file. The default value is UTF-8, which means that UTF-8 and ASCII encoded files are read correctly. In addition to the encodings supported by the underlying Python implementation, the following special encoding values can be used:

  • SYSTEM: Use the default system encoding.
  • CONSOLE: Use the console encoding. Outside Windows this is same as the system encoding.

encoding_errors argument controls what to do if decoding some bytes fails. All values accepted by decode method in Python are valid, but in practice the following values are most useful:

  • strict: Fail if characters cannot be decoded (default).
  • ignore: Ignore characters that cannot be decoded.
  • replace: Replace characters that cannot be decoded with a replacement character.
Source code in src/robot/libraries/OperatingSystem.py 
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
def get_file(self, path, encoding='UTF-8', encoding_errors='strict'):
    """Returns the contents of a specified file.

    This keyword reads the specified file and returns the contents.
    Line breaks in content are converted to platform independent form.
    See also `Get Binary File`.

    ``encoding`` defines the encoding of the file. The default value is
    ``UTF-8``, which means that UTF-8 and ASCII encoded files are read
    correctly. In addition to the encodings supported by the underlying
    Python implementation, the following special encoding values can be
    used:

    - ``SYSTEM``: Use the default system encoding.
    - ``CONSOLE``: Use the console encoding. Outside Windows this is same
      as the system encoding.

    ``encoding_errors`` argument controls what to do if decoding some bytes
    fails. All values accepted by ``decode`` method in Python are valid, but
    in practice the following values are most useful:

    - ``strict``: Fail if characters cannot be decoded (default).
    - ``ignore``: Ignore characters that cannot be decoded.
    - ``replace``: Replace characters that cannot be decoded with
      a replacement character.
    """
    path = self._absnorm(path)
    self._link("Getting file '%s'.", path)
    encoding = self._map_encoding(encoding)
    # Using `newline=None` (default) and not converting `\r\n` -> `\n`
    # ourselves would be better but some of our own acceptance tests
    # depend on these semantics. Best solution would probably be making
    # `newline` configurable.
    # FIXME: Make `newline` configurable or at least submit an issue about that.
    with open(path, encoding=encoding, errors=encoding_errors, newline='') as f:
        return f.read().replace('\r\n', '\n')

get_binary_file 

1
get_binary_file(path)

Returns the contents of a specified file.

This keyword reads the specified file and returns the contents as is. See also Get File.

Source code in src/robot/libraries/OperatingSystem.py 
294
295
296
297
298
299
300
301
302
303
def get_binary_file(self, path):
    """Returns the contents of a specified file.

    This keyword reads the specified file and returns the contents as is.
    See also `Get File`.
    """
    path = self._absnorm(path)
    self._link("Getting file '%s'.", path)
    with open(path, 'rb') as f:
        return f.read()

grep_file 

1
2
3
4
5
6
7
grep_file(
    path,
    pattern,
    encoding="UTF-8",
    encoding_errors="strict",
    regexp=False,
)

Returns the lines of the specified file that match the pattern.

This keyword reads a file from the file system using the defined path, encoding and encoding_errors similarly as Get File. A difference is that only the lines that match the given pattern are returned. Lines are returned as a single string concatenated back together with newlines and the number of matched lines is automatically logged. Possible trailing newline is never returned.

A line matches if it contains the pattern anywhere in it i.e. it does not need to match the pattern fully. There are two supported pattern types:

  • By default the pattern is considered a glob pattern where, for example, * and ? can be used as wildcards.
  • If the regexp argument is given a true value, the pattern is considered to be a regular expression. These patterns are more powerful but also more complicated than glob patterns. They often use the backslash character and it needs to be escaped in Robot Framework date like \\.

For more information about glob and regular expression syntax, see the Pattern matching section. With this keyword matching is always case-sensitive.

Examples: | ${errors} = | Grep File | /var/log/myapp.log | ERROR | | ${ret} = | Grep File | ${CURDIR}/file.txt | [Ww]ildc??d exple | | ${ret} = | Grep File | ${CURDIR}/file.txt | [Ww]ildc\w+d ex.ple | regexp=True |

Special encoding values SYSTEM and CONSOLE that Get File supports are supported by this keyword only with Robot Framework 4.0 and newer.

Support for regular expressions is new in Robot Framework 5.0.

Source code in src/robot/libraries/OperatingSystem.py 
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
def grep_file(self, path, pattern, encoding='UTF-8', encoding_errors='strict',
              regexp=False):
    r"""Returns the lines of the specified file that match the ``pattern``.

    This keyword reads a file from the file system using the defined
    ``path``, ``encoding`` and ``encoding_errors`` similarly as `Get File`.
    A difference is that only the lines that match the given ``pattern`` are
    returned. Lines are returned as a single string concatenated back together
    with newlines and the number of matched lines is automatically logged.
    Possible trailing newline is never returned.

    A line matches if it contains the ``pattern`` anywhere in it i.e. it does
    not need to match the pattern fully. There are two supported pattern types:

    - By default the pattern is considered a _glob_ pattern where, for example,
      ``*`` and ``?`` can be used as wildcards.
    - If the ``regexp`` argument is given a true value, the pattern is
      considered to be a _regular expression_. These patterns are more
      powerful but also more complicated than glob patterns. They often use
      the backslash character and it needs to be escaped in Robot Framework
      date like `\\`.

    For more information about glob and regular expression syntax, see
    the `Pattern matching` section. With this keyword matching is always
    case-sensitive.

    Examples:
    | ${errors} = | Grep File | /var/log/myapp.log | ERROR |
    | ${ret} = | Grep File | ${CURDIR}/file.txt | [Ww]ildc??d ex*ple |
    | ${ret} = | Grep File | ${CURDIR}/file.txt | [Ww]ildc\\w+d ex.*ple | regexp=True |

    Special encoding values ``SYSTEM`` and ``CONSOLE`` that `Get File` supports
    are supported by this keyword only with Robot Framework 4.0 and newer.

    Support for regular expressions is new in Robot Framework 5.0.
    """
    path = self._absnorm(path)
    if not regexp:
        pattern = fnmatch.translate(f'{pattern}*')
    reobj = re.compile(pattern)
    encoding = self._map_encoding(encoding)
    lines = []
    total_lines = 0
    self._link("Reading file '%s'.", path)
    with open(path, encoding=encoding, errors=encoding_errors) as file:
        for line in file:
            total_lines += 1
            line = line.rstrip('\r\n')
            if reobj.search(line):
                lines.append(line)
        self._info('%d out of %d lines matched' % (len(lines), total_lines))
        return '\n'.join(lines)

log_file 

1
log_file(path, encoding='UTF-8', encoding_errors='strict')

Wrapper for Get File that also logs the returned file.

The file is logged with the INFO level. If you want something else, just use Get File and the built-in keyword Log with the desired level.

See Get File for more information about encoding and encoding_errors arguments.

Source code in src/robot/libraries/OperatingSystem.py 
358
359
360
361
362
363
364
365
366
367
368
369
370
def log_file(self, path, encoding='UTF-8', encoding_errors='strict'):
    """Wrapper for `Get File` that also logs the returned file.

    The file is logged with the INFO level. If you want something else,
    just use `Get File` and the built-in keyword `Log` with the desired
    level.

    See `Get File` for more information about ``encoding`` and
    ``encoding_errors`` arguments.
    """
    content = self.get_file(path, encoding, encoding_errors)
    self._info(content)
    return content

should_exist 

1
should_exist(path, msg=None)

Fails unless the given path (file or directory) exists.

The path can be given as an exact path or as a glob pattern. See the Glob patterns section for details about the supported syntax.

The default error message can be overridden with the msg argument.

Source code in src/robot/libraries/OperatingSystem.py 
374
375
376
377
378
379
380
381
382
383
384
385
def should_exist(self, path, msg=None):
    """Fails unless the given path (file or directory) exists.

    The path can be given as an exact path or as a glob pattern.
    See the `Glob patterns` section for details about the supported syntax.

    The default error message can be overridden with the ``msg`` argument.
    """
    path = self._absnorm(path)
    if not self._glob(path):
        self._fail(msg, "Path '%s' does not exist." % path)
    self._link("Path '%s' exists.", path)

should_not_exist 

1
should_not_exist(path, msg=None)

Fails if the given path (file or directory) exists.

The path can be given as an exact path or as a glob pattern. See the Glob patterns section for details about the supported syntax.

The default error message can be overridden with the msg argument.

Source code in src/robot/libraries/OperatingSystem.py 
387
388
389
390
391
392
393
394
395
396
397
398
399
def should_not_exist(self, path, msg=None):
    """Fails if the given path (file or directory) exists.

    The path can be given as an exact path or as a glob pattern.
    See the `Glob patterns` section for details about the supported syntax.

    The default error message can be overridden with the ``msg`` argument.
    """
    path = self._absnorm(path)
    matches = self._glob(path)
    if matches:
        self._fail(msg, self._get_matches_error('Path', path, matches))
    self._link("Path '%s' does not exist.", path)

file_should_exist 

1
file_should_exist(path, msg=None)

Fails unless the given path points to an existing file.

The path can be given as an exact path or as a glob pattern. See the Glob patterns section for details about the supported syntax.

The default error message can be overridden with the msg argument.

Source code in src/robot/libraries/OperatingSystem.py 
412
413
414
415
416
417
418
419
420
421
422
423
424
def file_should_exist(self, path, msg=None):
    """Fails unless the given ``path`` points to an existing file.

    The path can be given as an exact path or as a glob pattern.
    See the `Glob patterns` section for details about the supported syntax.

    The default error message can be overridden with the ``msg`` argument.
    """
    path = self._absnorm(path)
    matches = [p for p in self._glob(path) if os.path.isfile(p)]
    if not matches:
        self._fail(msg, "File '%s' does not exist." % path)
    self._link("File '%s' exists.", path)

file_should_not_exist 

1
file_should_not_exist(path, msg=None)

Fails if the given path points to an existing file.

The path can be given as an exact path or as a glob pattern. See the Glob patterns section for details about the supported syntax.

The default error message can be overridden with the msg argument.

Source code in src/robot/libraries/OperatingSystem.py 
426
427
428
429
430
431
432
433
434
435
436
437
438
def file_should_not_exist(self, path, msg=None):
    """Fails if the given path points to an existing file.

    The path can be given as an exact path or as a glob pattern.
    See the `Glob patterns` section for details about the supported syntax.

    The default error message can be overridden with the ``msg`` argument.
    """
    path = self._absnorm(path)
    matches = [p for p in self._glob(path) if os.path.isfile(p)]
    if matches:
        self._fail(msg, self._get_matches_error('File', path, matches))
    self._link("File '%s' does not exist.", path)

directory_should_exist 

1
directory_should_exist(path, msg=None)

Fails unless the given path points to an existing directory.

The path can be given as an exact path or as a glob pattern. See the Glob patterns section for details about the supported syntax.

The default error message can be overridden with the msg argument.

Source code in src/robot/libraries/OperatingSystem.py 
440
441
442
443
444
445
446
447
448
449
450
451
452
def directory_should_exist(self, path, msg=None):
    """Fails unless the given path points to an existing directory.

    The path can be given as an exact path or as a glob pattern.
    See the `Glob patterns` section for details about the supported syntax.

    The default error message can be overridden with the ``msg`` argument.
    """
    path = self._absnorm(path)
    matches = [p for p in self._glob(path) if os.path.isdir(p)]
    if not matches:
        self._fail(msg, "Directory '%s' does not exist." % path)
    self._link("Directory '%s' exists.", path)

directory_should_not_exist 

1
directory_should_not_exist(path, msg=None)

Fails if the given path points to an existing file.

The path can be given as an exact path or as a glob pattern. See the Glob patterns section for details about the supported syntax.

The default error message can be overridden with the msg argument.

Source code in src/robot/libraries/OperatingSystem.py 
454
455
456
457
458
459
460
461
462
463
464
465
466
def directory_should_not_exist(self, path, msg=None):
    """Fails if the given path points to an existing file.

    The path can be given as an exact path or as a glob pattern.
    See the `Glob patterns` section for details about the supported syntax.

    The default error message can be overridden with the ``msg`` argument.
    """
    path = self._absnorm(path)
    matches = [p for p in self._glob(path) if os.path.isdir(p)]
    if matches:
        self._fail(msg, self._get_matches_error('Directory', path, matches))
    self._link("Directory '%s' does not exist.", path)

wait_until_removed 

1
wait_until_removed(path, timeout='1 minute')

Waits until the given file or directory is removed.

The path can be given as an exact path or as a glob pattern. See the Glob patterns section for details about the supported syntax. If the path is a pattern, the keyword waits until all matching items are removed.

The optional timeout can be used to control the maximum time of waiting. The timeout is given as a timeout string, e.g. in a format 15 seconds, 1min 10s or just 10. The time string format is described in an appendix of Robot Framework User Guide.

If the timeout is negative, the keyword is never timed-out. The keyword returns immediately, if the path does not exist in the first place.

Source code in src/robot/libraries/OperatingSystem.py 
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
def wait_until_removed(self, path, timeout='1 minute'):
    """Waits until the given file or directory is removed.

    The path can be given as an exact path or as a glob pattern.
    See the `Glob patterns` section for details about the supported syntax.
    If the path is a pattern, the keyword waits until all matching
    items are removed.

    The optional ``timeout`` can be used to control the maximum time of
    waiting. The timeout is given as a timeout string, e.g. in a format
    ``15 seconds``, ``1min 10s`` or just ``10``. The time string format is
    described in an appendix of Robot Framework User Guide.

    If the timeout is negative, the keyword is never timed-out. The keyword
    returns immediately, if the path does not exist in the first place.
    """
    path = self._absnorm(path)
    timeout = timestr_to_secs(timeout)
    maxtime = time.time() + timeout
    while self._glob(path):
        if timeout >= 0 and time.time() > maxtime:
            self._fail("'%s' was not removed in %s."
                       % (path, secs_to_timestr(timeout)))
        time.sleep(0.1)
    self._link("'%s' was removed.", path)

wait_until_created 

1
wait_until_created(path, timeout='1 minute')

Waits until the given file or directory is created.

The path can be given as an exact path or as a glob pattern. See the Glob patterns section for details about the supported syntax. If the path is a pattern, the keyword returns when an item matching it is created.

The optional timeout can be used to control the maximum time of waiting. The timeout is given as a timeout string, e.g. in a format 15 seconds, 1min 10s or just 10. The time string format is described in an appendix of Robot Framework User Guide.

If the timeout is negative, the keyword is never timed-out. The keyword returns immediately, if the path already exists.

Source code in src/robot/libraries/OperatingSystem.py 
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
def wait_until_created(self, path, timeout='1 minute'):
    """Waits until the given file or directory is created.

    The path can be given as an exact path or as a glob pattern.
    See the `Glob patterns` section for details about the supported syntax.
    If the path is a pattern, the keyword returns when an item matching
    it is created.

    The optional ``timeout`` can be used to control the maximum time of
    waiting. The timeout is given as a timeout string, e.g. in a format
    ``15 seconds``, ``1min 10s`` or just ``10``. The time string format is
    described in an appendix of Robot Framework User Guide.

    If the timeout is negative, the keyword is never timed-out. The keyword
    returns immediately, if the path already exists.
    """
    path = self._absnorm(path)
    timeout = timestr_to_secs(timeout)
    maxtime = time.time() + timeout
    while not self._glob(path):
        if timeout >= 0 and time.time() > maxtime:
            self._fail("'%s' was not created in %s."
                       % (path, secs_to_timestr(timeout)))
        time.sleep(0.1)
    self._link("'%s' was created.", path)

directory_should_be_empty 

1
directory_should_be_empty(path, msg=None)

Fails unless the specified directory is empty.

The default error message can be overridden with the msg argument.

Source code in src/robot/libraries/OperatingSystem.py 
524
525
526
527
528
529
530
531
532
533
534
def directory_should_be_empty(self, path, msg=None):
    """Fails unless the specified directory is empty.

    The default error message can be overridden with the ``msg`` argument.
    """
    path = self._absnorm(path)
    items = self._list_dir(path)
    if items:
        self._fail(msg, "Directory '%s' is not empty. Contents: %s."
                        % (path, seq2str(items, lastsep=', ')))
    self._link("Directory '%s' is empty.", path)

directory_should_not_be_empty 

1
directory_should_not_be_empty(path, msg=None)

Fails if the specified directory is empty.

The default error message can be overridden with the msg argument.

Source code in src/robot/libraries/OperatingSystem.py 
536
537
538
539
540
541
542
543
544
545
546
def directory_should_not_be_empty(self, path, msg=None):
    """Fails if the specified directory is empty.

    The default error message can be overridden with the ``msg`` argument.
    """
    path = self._absnorm(path)
    items = self._list_dir(path)
    if not items:
        self._fail(msg, "Directory '%s' is empty." % path)
    self._link("Directory '%%s' contains %d item%s."
               % (len(items), plural_or_not(items)), path)

file_should_be_empty 

1
file_should_be_empty(path, msg=None)

Fails unless the specified file is empty.

The default error message can be overridden with the msg argument.

Source code in src/robot/libraries/OperatingSystem.py 
548
549
550
551
552
553
554
555
556
557
558
559
560
def file_should_be_empty(self, path, msg=None):
    """Fails unless the specified file is empty.

    The default error message can be overridden with the ``msg`` argument.
    """
    path = self._absnorm(path)
    if not os.path.isfile(path):
        self._error("File '%s' does not exist." % path)
    size = os.stat(path).st_size
    if size > 0:
        self._fail(msg,
                   "File '%s' is not empty. Size: %d bytes." % (path, size))
    self._link("File '%s' is empty.", path)

file_should_not_be_empty 

1
file_should_not_be_empty(path, msg=None)

Fails if the specified file is empty.

The default error message can be overridden with the msg argument.

Source code in src/robot/libraries/OperatingSystem.py 
562
563
564
565
566
567
568
569
570
571
572
573
def file_should_not_be_empty(self, path, msg=None):
    """Fails if the specified file is empty.

    The default error message can be overridden with the ``msg`` argument.
    """
    path = self._absnorm(path)
    if not os.path.isfile(path):
        self._error("File '%s' does not exist." % path)
    size = os.stat(path).st_size
    if size == 0:
        self._fail(msg, "File '%s' is empty." % path)
    self._link("File '%%s' contains %d bytes." % size, path)

create_file 

1
create_file(path, content='', encoding='UTF-8')

Creates a file with the given content and encoding.

If the directory where the file is created does not exist, it is automatically created along with possible missing intermediate directories. Possible existing file is overwritten.

On Windows newline characters (\n) in content are automatically converted to Windows native newline sequence (\r\n).

See Get File for more information about possible encoding values, including special values SYSTEM and CONSOLE.

Examples: | Create File | ${dir}/example.txt | Hello, world! | | | Create File | ${path} | Hyv\xe4 esimerkki | Latin-1 | | Create File | /tmp/foo.txt | 3\nlines\nhere\n | SYSTEM |

Use Append To File if you want to append to an existing file and Create Binary File if you need to write bytes without encoding. File Should Not Exist can be used to avoid overwriting existing files.

Source code in src/robot/libraries/OperatingSystem.py 
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
def create_file(self, path, content='', encoding='UTF-8'):
    """Creates a file with the given content and encoding.

    If the directory where the file is created does not exist, it is
    automatically created along with possible missing intermediate
    directories. Possible existing file is overwritten.

    On Windows newline characters (``\\n``) in content are automatically
    converted to Windows native newline sequence (``\\r\\n``).

    See `Get File` for more information about possible ``encoding`` values,
    including special values ``SYSTEM`` and ``CONSOLE``.

    Examples:
    | Create File | ${dir}/example.txt | Hello, world!       |         |
    | Create File | ${path}            | Hyv\\xe4 esimerkki  | Latin-1 |
    | Create File | /tmp/foo.txt       | 3\\nlines\\nhere\\n | SYSTEM  |

    Use `Append To File` if you want to append to an existing file
    and `Create Binary File` if you need to write bytes without encoding.
    `File Should Not Exist` can be used to avoid overwriting existing
    files.
    """
    path = self._write_to_file(path, content, encoding)
    self._link("Created file '%s'.", path)

create_binary_file 

1
create_binary_file(path, content)

Creates a binary file with the given content.

If content is given as a Unicode string, it is first converted to bytes character by character. All characters with ordinal below 256 can be used and are converted to bytes with same values. Using characters with higher ordinal is an error.

Byte strings, and possible other types, are written to the file as is.

If the directory for the file does not exist, it is created, along with missing intermediate directories.

Examples: | Create Binary File | ${dir}/example.png | ${image content} | | Create Binary File | ${path} | \x01\x00\xe4\x00 |

Use Create File if you want to create a text file using a certain encoding. File Should Not Exist can be used to avoid overwriting existing files.

Source code in src/robot/libraries/OperatingSystem.py 
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
def create_binary_file(self, path, content):
    r"""Creates a binary file with the given content.

    If content is given as a Unicode string, it is first converted to bytes
    character by character. All characters with ordinal below 256 can be
    used and are converted to bytes with same values. Using characters
    with higher ordinal is an error.

    Byte strings, and possible other types, are written to the file as is.

    If the directory for the file does not exist, it is created, along
    with missing intermediate directories.

    Examples:
    | Create Binary File | ${dir}/example.png | ${image content} |
    | Create Binary File | ${path}            | \x01\x00\xe4\x00 |

    Use `Create File` if you want to create a text file using a certain
    encoding. `File Should Not Exist` can be used to avoid overwriting
    existing files.
    """
    if is_string(content):
        content = bytes(ord(c) for c in content)
    path = self._write_to_file(path, content, mode='wb')
    self._link("Created binary file '%s'.", path)

append_to_file 

1
append_to_file(path, content, encoding='UTF-8')

Appends the given content to the specified file.

If the file exists, the given text is written to its end. If the file does not exist, it is created.

Other than not overwriting possible existing files, this keyword works exactly like Create File. See its documentation for more details about the usage.

Source code in src/robot/libraries/OperatingSystem.py 
640
641
642
643
644
645
646
647
648
649
650
651
def append_to_file(self, path, content, encoding='UTF-8'):
    """Appends the given content to the specified file.

    If the file exists, the given text is written to its end. If the file
    does not exist, it is created.

    Other than not overwriting possible existing files, this keyword works
    exactly like `Create File`. See its documentation for more details
    about the usage.
    """
    path = self._write_to_file(path, content, encoding, mode='a')
    self._link("Appended to file '%s'.", path)

remove_file 

1
remove_file(path)

Removes a file with the given path.

Passes if the file does not exist, but fails if the path does not point to a regular file (e.g. it points to a directory).

The path can be given as an exact path or as a glob pattern. See the Glob patterns section for details about the supported syntax. If the path is a pattern, all files matching it are removed.

Source code in src/robot/libraries/OperatingSystem.py 
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
def remove_file(self, path):
    """Removes a file with the given path.

    Passes if the file does not exist, but fails if the path does
    not point to a regular file (e.g. it points to a directory).

    The path can be given as an exact path or as a glob pattern.
    See the `Glob patterns` section for details about the supported syntax.
    If the path is a pattern, all files matching it are removed.
    """
    path = self._absnorm(path)
    matches = self._glob(path)
    if not matches:
        self._link("File '%s' does not exist.", path)
    for match in matches:
        if not os.path.isfile(match):
            self._error("Path '%s' is not a file." % match)
        os.remove(match)
        self._link("Removed file '%s'.", match)

remove_files 

1
remove_files(*paths)

Uses Remove File to remove multiple files one-by-one.

Example: | Remove Files | ${TEMPDIR}${/}foo.txt | ${TEMPDIR}${/}bar.txt | ${TEMPDIR}${/}zap.txt |

Source code in src/robot/libraries/OperatingSystem.py 
673
674
675
676
677
678
679
680
def remove_files(self, *paths):
    """Uses `Remove File` to remove multiple files one-by-one.

    Example:
    | Remove Files | ${TEMPDIR}${/}foo.txt | ${TEMPDIR}${/}bar.txt | ${TEMPDIR}${/}zap.txt |
    """
    for path in paths:
        self.remove_file(path)

empty_directory 

1
empty_directory(path)

Deletes all the content from the given directory.

Deletes both files and sub-directories, but the specified directory itself if not removed. Use Remove Directory if you want to remove the whole directory.

Source code in src/robot/libraries/OperatingSystem.py 
682
683
684
685
686
687
688
689
690
691
692
693
694
695
def empty_directory(self, path):
    """Deletes all the content from the given directory.

    Deletes both files and sub-directories, but the specified directory
    itself if not removed. Use `Remove Directory` if you want to remove
    the whole directory.
    """
    path = self._absnorm(path)
    for item in self._list_dir(path, absolute=True):
        if os.path.isdir(item):
            shutil.rmtree(item)
        else:
            os.remove(item)
    self._link("Emptied directory '%s'.", path)

create_directory 

1
create_directory(path)

Creates the specified directory.

Also possible intermediate directories are created. Passes if the directory already exists, but fails if the path exists and is not a directory.

Source code in src/robot/libraries/OperatingSystem.py 
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
def create_directory(self, path):
    """Creates the specified directory.

    Also possible intermediate directories are created. Passes if the
    directory already exists, but fails if the path exists and is not
    a directory.
    """
    path = self._absnorm(path)
    if os.path.isdir(path):
        self._link("Directory '%s' already exists.", path )
    elif os.path.exists(path):
        self._error("Path '%s' is not a directory." % path)
    else:
        os.makedirs(path)
        self._link("Created directory '%s'.", path)

remove_directory 

1
remove_directory(path, recursive=False)

Removes the directory pointed to by the given path.

If the second argument recursive is given a true value (see Boolean arguments), the directory is removed recursively. Otherwise removing fails if the directory is not empty.

If the directory pointed to by the path does not exist, the keyword passes, but it fails, if the path points to a file.

Source code in src/robot/libraries/OperatingSystem.py 
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
def remove_directory(self, path, recursive=False):
    """Removes the directory pointed to by the given ``path``.

    If the second argument ``recursive`` is given a true value (see
    `Boolean arguments`), the directory is removed recursively. Otherwise
    removing fails if the directory is not empty.

    If the directory pointed to by the ``path`` does not exist, the keyword
    passes, but it fails, if the ``path`` points to a file.
    """
    path = self._absnorm(path)
    if not os.path.exists(path):
        self._link("Directory '%s' does not exist.", path)
    elif not os.path.isdir(path):
        self._error("Path '%s' is not a directory." % path)
    else:
        if is_truthy(recursive):
            shutil.rmtree(path)
        else:
            self.directory_should_be_empty(
                path, "Directory '%s' is not empty." % path)
            os.rmdir(path)
        self._link("Removed directory '%s'.", path)

copy_file 

1
copy_file(source, destination)

Copies the source file into the destination.

Source must be a path to an existing file or a glob pattern (see Glob patterns) that matches exactly one file. How the destination is interpreted is explained below.

1) If the destination is an existing file, the source file is copied over it.

2) If the destination is an existing directory, the source file is copied into it. A possible file with the same name as the source is overwritten.

3) If the destination does not exist and it ends with a path separator (/ or \), it is considered a directory. That directory is created and a source file copied into it. Possible missing intermediate directories are also created.

4) If the destination does not exist and it does not end with a path separator, it is considered a file. If the path to the file does not exist, it is created.

The resulting destination path is returned.

See also Copy Files, Move File, and Move Files.

Source code in src/robot/libraries/OperatingSystem.py 
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
def copy_file(self, source, destination):
    r"""Copies the source file into the destination.

    Source must be a path to an existing file or a glob pattern (see
    `Glob patterns`) that matches exactly one file. How the
    destination is interpreted is explained below.

    1) If the destination is an existing file, the source file is copied
    over it.

    2) If the destination is an existing directory, the source file is
    copied into it. A possible file with the same name as the source is
    overwritten.

    3) If the destination does not exist and it ends with a path
    separator (``/`` or ``\``), it is considered a directory. That
    directory is created and a source file copied into it.
    Possible missing intermediate directories are also created.

    4) If the destination does not exist and it does not end with a path
    separator, it is considered a file. If the path to the file does not
    exist, it is created.

    The resulting destination path is returned.

    See also `Copy Files`, `Move File`, and `Move Files`.
    """
    source, destination = \
        self._prepare_copy_and_move_file(source, destination)
    if not self._are_source_and_destination_same_file(source, destination):
        source, destination = self._atomic_copy(source, destination)
        self._link("Copied file from '%s' to '%s'.", source, destination)
    return destination

move_file 

1
move_file(source, destination)

Moves the source file into the destination.

Arguments have exactly same semantics as with Copy File keyword. Destination file path is returned.

If the source and destination are on the same filesystem, rename operation is used. Otherwise file is copied to the destination filesystem and then removed from the original filesystem.

See also Move Files, Copy File, and Copy Files.

Source code in src/robot/libraries/OperatingSystem.py 
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
def move_file(self, source, destination):
    """Moves the source file into the destination.

    Arguments have exactly same semantics as with `Copy File` keyword.
    Destination file path is returned.

    If the source and destination are on the same filesystem, rename
    operation is used. Otherwise file is copied to the destination
    filesystem and then removed from the original filesystem.

    See also `Move Files`, `Copy File`, and `Copy Files`.
    """
    source, destination = \
        self._prepare_copy_and_move_file(source, destination)
    if not self._are_source_and_destination_same_file(destination, source):
        shutil.move(source, destination)
        self._link("Moved file from '%s' to '%s'.", source, destination)
    return destination

copy_files 

1
copy_files(*sources_and_destination)

Copies specified files to the target directory.

Source files can be given as exact paths and as glob patterns (see Glob patterns). At least one source must be given, but it is not an error if it is a pattern that does not match anything.

Last argument must be the destination directory. If the destination does not exist, it will be created.

Examples: | Copy Files | ${dir}/file1.txt | ${dir}/file2.txt | ${dir2} | | Copy Files | ${dir}/file-*.txt | ${dir2} | |

See also Copy File, Move File, and Move Files.

Source code in src/robot/libraries/OperatingSystem.py 
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
def copy_files(self, *sources_and_destination):
    """Copies specified files to the target directory.

    Source files can be given as exact paths and as glob patterns (see
    `Glob patterns`). At least one source must be given, but it is
    not an error if it is a pattern that does not match anything.

    Last argument must be the destination directory. If the destination
    does not exist, it will be created.

    Examples:
    | Copy Files | ${dir}/file1.txt  | ${dir}/file2.txt | ${dir2} |
    | Copy Files | ${dir}/file-*.txt | ${dir2}          |         |

    See also `Copy File`, `Move File`, and `Move Files`.
    """
    sources, destination \
        = self._prepare_copy_and_move_files(sources_and_destination)
    for source in sources:
        self.copy_file(source, destination)

move_files 

1
move_files(*sources_and_destination)

Moves specified files to the target directory.

Arguments have exactly same semantics as with Copy Files keyword.

See also Move File, Copy File, and Copy Files.

Source code in src/robot/libraries/OperatingSystem.py 
900
901
902
903
904
905
906
907
908
909
910
def move_files(self, *sources_and_destination):
    """Moves specified files to the target directory.

    Arguments have exactly same semantics as with `Copy Files` keyword.

    See also `Move File`, `Copy File`, and `Copy Files`.
    """
    sources, destination \
        = self._prepare_copy_and_move_files(sources_and_destination)
    for source in sources:
        self.move_file(source, destination)

copy_directory 

1
copy_directory(source, destination)

Copies the source directory into the destination.

If the destination exists, the source is copied under it. Otherwise the destination directory and the possible missing intermediate directories are created.

Source code in src/robot/libraries/OperatingSystem.py 
912
913
914
915
916
917
918
919
920
921
def copy_directory(self, source, destination):
    """Copies the source directory into the destination.

    If the destination exists, the source is copied under it. Otherwise
    the destination directory and the possible missing intermediate
    directories are created.
    """
    source, destination = self._prepare_copy_and_move_directory(source, destination)
    shutil.copytree(source, destination)
    self._link("Copied directory from '%s' to '%s'.", source, destination)

move_directory 

1
move_directory(source, destination)

Moves the source directory into a destination.

Uses Copy Directory keyword internally, and source and destination arguments have exactly same semantics as with that keyword.

Source code in src/robot/libraries/OperatingSystem.py 
941
942
943
944
945
946
947
948
949
950
951
def move_directory(self, source, destination):
    """Moves the source directory into a destination.

    Uses `Copy Directory` keyword internally, and ``source`` and
    ``destination`` arguments have exactly same semantics as with
    that keyword.
    """
    source, destination \
        = self._prepare_copy_and_move_directory(source, destination)
    shutil.move(source, destination)
    self._link("Moved directory from '%s' to '%s'.", source, destination)

get_environment_variable 

1
get_environment_variable(name, default=None)

Returns the value of an environment variable with the given name.

If no environment variable is found, returns possible default value. If no default value is given, the keyword fails.

Returned variables are automatically decoded to Unicode using the system encoding.

Note that you can also access environment variables directly using the variable syntax %{ENV_VAR_NAME}.

Source code in src/robot/libraries/OperatingSystem.py 
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
@keyword(types=None)
def get_environment_variable(self, name, default=None):
    """Returns the value of an environment variable with the given name.

    If no environment variable is found, returns possible default value.
    If no default value is given, the keyword fails.

    Returned variables are automatically decoded to Unicode using
    the system encoding.

    Note that you can also access environment variables directly using
    the variable syntax ``%{ENV_VAR_NAME}``.
    """
    value = get_env_var(name, default)
    if value is None:
        self._error("Environment variable '%s' does not exist." % name)
    return value

set_environment_variable 

1
set_environment_variable(name, value)

Sets an environment variable to a specified value.

Values are converted to strings automatically. Set variables are automatically encoded using the system encoding.

Source code in src/robot/libraries/OperatingSystem.py 
973
974
975
976
977
978
979
980
981
def set_environment_variable(self, name, value):
    """Sets an environment variable to a specified value.

    Values are converted to strings automatically. Set variables are
    automatically encoded using the system encoding.
    """
    set_env_var(name, value)
    self._info("Environment variable '%s' set to value '%s'."
               % (name, value))

append_to_environment_variable 

1
append_to_environment_variable(name, *values, **config)

Appends given values to environment variable name.

If the environment variable already exists, values are added after it, and otherwise a new environment variable is created.

Values are, by default, joined together using the operating system path separator (; on Windows, : elsewhere). This can be changed by giving a separator after the values like separator=value. No other configuration parameters are accepted.

Examples (assuming NAME and NAME2 do not exist initially): | Append To Environment Variable | NAME | first | | | Should Be Equal | %{NAME} | first | | | Append To Environment Variable | NAME | second | third | | Should Be Equal | %{NAME} | first${:}second${:}third | | Append To Environment Variable | NAME2 | first | separator=- | | Should Be Equal | %{NAME2} | first | | | Append To Environment Variable | NAME2 | second | separator=- | | Should Be Equal | %{NAME2} | first-second |

Source code in src/robot/libraries/OperatingSystem.py 
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
def append_to_environment_variable(self, name, *values, **config):
    """Appends given ``values`` to environment variable ``name``.

    If the environment variable already exists, values are added after it,
    and otherwise a new environment variable is created.

    Values are, by default, joined together using the operating system
    path separator (``;`` on Windows, ``:`` elsewhere). This can be changed
    by giving a separator after the values like ``separator=value``. No
    other configuration parameters are accepted.

    Examples (assuming ``NAME`` and ``NAME2`` do not exist initially):
    | Append To Environment Variable | NAME     | first  |       |
    | Should Be Equal                | %{NAME}  | first  |       |
    | Append To Environment Variable | NAME     | second | third |
    | Should Be Equal                | %{NAME}  | first${:}second${:}third |
    | Append To Environment Variable | NAME2    | first  | separator=-     |
    | Should Be Equal                | %{NAME2} | first  |                 |
    | Append To Environment Variable | NAME2    | second | separator=-     |
    | Should Be Equal                | %{NAME2} | first-second             |
    """
    sentinel = object()
    initial = self.get_environment_variable(name, sentinel)
    if initial is not sentinel:
        values = (initial,) + values
    separator = config.pop('separator', os.pathsep)
    if config:
        config = ['='.join(i) for i in sorted(config.items())]
        self._error('Configuration %s not accepted.'
                    % seq2str(config, lastsep=' or '))
    self.set_environment_variable(name, separator.join(values))

remove_environment_variable 

1
remove_environment_variable(*names)

Deletes the specified environment variable.

Does nothing if the environment variable is not set.

It is possible to remove multiple variables by passing them to this keyword as separate arguments.

Source code in src/robot/libraries/OperatingSystem.py 
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
def remove_environment_variable(self, *names):
    """Deletes the specified environment variable.

    Does nothing if the environment variable is not set.

    It is possible to remove multiple variables by passing them to this
    keyword as separate arguments.
    """
    for name in names:
        value = del_env_var(name)
        if value:
            self._info("Environment variable '%s' deleted." % name)
        else:
            self._info("Environment variable '%s' does not exist." % name)

environment_variable_should_be_set 

1
environment_variable_should_be_set(name, msg=None)

Fails if the specified environment variable is not set.

The default error message can be overridden with the msg argument.

Source code in src/robot/libraries/OperatingSystem.py 
1030
1031
1032
1033
1034
1035
1036
1037
1038
def environment_variable_should_be_set(self, name, msg=None):
    """Fails if the specified environment variable is not set.

    The default error message can be overridden with the ``msg`` argument.
    """
    value = get_env_var(name)
    if not value:
        self._fail(msg, "Environment variable '%s' is not set." % name)
    self._info("Environment variable '%s' is set to '%s'." % (name, value))

environment_variable_should_not_be_set 

1
environment_variable_should_not_be_set(name, msg=None)

Fails if the specified environment variable is set.

The default error message can be overridden with the msg argument.

Source code in src/robot/libraries/OperatingSystem.py 
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
def environment_variable_should_not_be_set(self, name, msg=None):
    """Fails if the specified environment variable is set.

    The default error message can be overridden with the ``msg`` argument.
    """
    value = get_env_var(name)
    if value:
        self._fail(msg, "Environment variable '%s' is set to '%s'."
                        % (name, value))
    self._info("Environment variable '%s' is not set." % name)

get_environment_variables 

1
get_environment_variables()

Returns currently available environment variables as a dictionary.

Both keys and values are decoded to Unicode using the system encoding. Altering the returned dictionary has no effect on the actual environment variables.

Source code in src/robot/libraries/OperatingSystem.py 
1051
1052
1053
1054
1055
1056
1057
1058
def get_environment_variables(self):
    """Returns currently available environment variables as a dictionary.

    Both keys and values are decoded to Unicode using the system encoding.
    Altering the returned dictionary has no effect on the actual environment
    variables.
    """
    return get_env_vars()

log_environment_variables 

1
log_environment_variables(level='INFO')

Logs all environment variables using the given log level.

Environment variables are also returned the same way as with Get Environment Variables keyword.

Source code in src/robot/libraries/OperatingSystem.py 
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
def log_environment_variables(self, level='INFO'):
    """Logs all environment variables using the given log level.

    Environment variables are also returned the same way as with
    `Get Environment Variables` keyword.
    """
    variables = get_env_vars()
    for name in sorted(variables, key=lambda item: item.lower()):
        self._log('%s = %s' % (name, variables[name]), level)
    return variables

join_path 

1
join_path(base, *parts)

Joins the given path part(s) to the given base path.

The path separator (/ or \) is inserted when needed and the possible absolute paths handled as expected. The resulted path is also normalized.

Examples: | ${path} = | Join Path | my | path | | ${p2} = | Join Path | my/ | path/ | | ${p3} = | Join Path | my | path | my | file.txt | | ${p4} = | Join Path | my | /path | | ${p5} = | Join Path | /my/path/ | .. | path2 | => - ${path} = 'my/path' - ${p2} = 'my/path' - ${p3} = 'my/path/my/file.txt' - ${p4} = '/path' - ${p5} = '/my/path2'

Source code in src/robot/libraries/OperatingSystem.py 
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
def join_path(self, base, *parts):
    """Joins the given path part(s) to the given base path.

    The path separator (``/`` or ``\\``) is inserted when needed and
    the possible absolute paths handled as expected. The resulted
    path is also normalized.

    Examples:
    | ${path} = | Join Path | my        | path  |
    | ${p2} =   | Join Path | my/       | path/ |
    | ${p3} =   | Join Path | my        | path  | my | file.txt |
    | ${p4} =   | Join Path | my        | /path |
    | ${p5} =   | Join Path | /my/path/ | ..    | path2 |
    =>
    - ${path} = 'my/path'
    - ${p2} = 'my/path'
    - ${p3} = 'my/path/my/file.txt'
    - ${p4} = '/path'
    - ${p5} = '/my/path2'
    """
    parts = [str(p) if isinstance(p, pathlib.Path) else p.replace('/', os.sep)
             for p in (base,) + parts]
    return self.normalize_path(os.path.join(*parts))

join_paths 

1
join_paths(base, *paths)

Joins given paths with base and returns resulted paths.

See Join Path for more information.

Examples: | @{p1} = | Join Paths | base | example | other | | | @{p2} = | Join Paths | /my/base | /example | other | | | @{p3} = | Join Paths | my/base | example/path/ | other | one/more | => - @{p1} = ['base/example', 'base/other'] - @{p2} = ['/example', '/my/base/other'] - @{p3} = ['my/base/example/path', 'my/base/other', 'my/base/one/more']

Source code in src/robot/libraries/OperatingSystem.py 
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
def join_paths(self, base, *paths):
    """Joins given paths with base and returns resulted paths.

    See `Join Path` for more information.

    Examples:
    | @{p1} = | Join Paths | base     | example       | other |          |
    | @{p2} = | Join Paths | /my/base | /example      | other |          |
    | @{p3} = | Join Paths | my/base  | example/path/ | other | one/more |
    =>
    - @{p1} = ['base/example', 'base/other']
    - @{p2} = ['/example', '/my/base/other']
    - @{p3} = ['my/base/example/path', 'my/base/other', 'my/base/one/more']
    """
    return [self.join_path(base, path) for path in paths]

normalize_path 

1
normalize_path(path, case_normalize=False)

Normalizes the given path.

  • Collapses redundant separators and up-level references.
  • Converts / to \ on Windows.
  • Replaces initial ~ or ~user by that user's home directory.
  • If case_normalize is given a true value (see Boolean arguments) on Windows, converts the path to all lowercase.
  • Converts pathlib.Path instances to str.

Examples: | ${path1} = | Normalize Path | abc/ | | ${path2} = | Normalize Path | abc/../def | | ${path3} = | Normalize Path | abc/./def//ghi | | ${path4} = | Normalize Path | ~robot/stuff | => - ${path1} = 'abc' - ${path2} = 'def' - ${path3} = 'abc/def/ghi' - ${path4} = '/home/robot/stuff'

On Windows result would use \ instead of / and home directory would be different.

Source code in src/robot/libraries/OperatingSystem.py 
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
def normalize_path(self, path, case_normalize=False):
    """Normalizes the given path.

    - Collapses redundant separators and up-level references.
    - Converts ``/`` to ``\\`` on Windows.
    - Replaces initial ``~`` or ``~user`` by that user's home directory.
    - If ``case_normalize`` is given a true value (see `Boolean arguments`)
      on Windows, converts the path to all lowercase.
    - Converts ``pathlib.Path`` instances to ``str``.

    Examples:
    | ${path1} = | Normalize Path | abc/           |
    | ${path2} = | Normalize Path | abc/../def     |
    | ${path3} = | Normalize Path | abc/./def//ghi |
    | ${path4} = | Normalize Path | ~robot/stuff   |
    =>
    - ${path1} = 'abc'
    - ${path2} = 'def'
    - ${path3} = 'abc/def/ghi'
    - ${path4} = '/home/robot/stuff'

    On Windows result would use ``\\`` instead of ``/`` and home directory
    would be different.
    """
    if isinstance(path, pathlib.Path):
        path = str(path)
    else:
        path = path.replace('/', os.sep)
    path = os.path.normpath(os.path.expanduser(path))
    # os.path.normcase doesn't normalize on OSX which also, by default,
    # has case-insensitive file system. Our robot.utils.normpath would
    # do that, but it's not certain would that, or other things that the
    # utility do, desirable.
    if case_normalize:
        path = os.path.normcase(path)
    return path or '.'

split_path 

1
split_path(path)

Splits the given path from the last path separator (/ or \).

The given path is first normalized (e.g. a possible trailing path separator is removed, special directories .. and . removed). The parts that are split are returned as separate components.

Examples: | ${path1} | ${dir} = | Split Path | abc/def | | ${path2} | ${file} = | Split Path | abc/def/ghi.txt | | ${path3} | ${d2} = | Split Path | abc/../def/ghi/ | => - ${path1} = 'abc' & ${dir} = 'def' - ${path2} = 'abc/def' & ${file} = 'ghi.txt' - ${path3} = 'def' & ${d2} = 'ghi'

Source code in src/robot/libraries/OperatingSystem.py 
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
def split_path(self, path):
    """Splits the given path from the last path separator (``/`` or ``\\``).

    The given path is first normalized (e.g. a possible trailing
    path separator is removed, special directories ``..`` and ``.``
    removed). The parts that are split are returned as separate
    components.

    Examples:
    | ${path1} | ${dir} =  | Split Path | abc/def         |
    | ${path2} | ${file} = | Split Path | abc/def/ghi.txt |
    | ${path3} | ${d2}  =  | Split Path | abc/../def/ghi/ |
    =>
    - ${path1} = 'abc' & ${dir} = 'def'
    - ${path2} = 'abc/def' & ${file} = 'ghi.txt'
    - ${path3} = 'def' & ${d2} = 'ghi'
    """
    return os.path.split(self.normalize_path(path))

split_extension 

1
split_extension(path)

Splits the extension from the given path.

The given path is first normalized (e.g. possible trailing path separators removed, special directories .. and . removed). The base path and extension are returned as separate components so that the dot used as an extension separator is removed. If the path contains no extension, an empty string is returned for it. Possible leading and trailing dots in the file name are never considered to be extension separators.

Examples: | ${path} | ${ext} = | Split Extension | file.extension | | ${p2} | ${e2} = | Split Extension | path/file.ext | | ${p3} | ${e3} = | Split Extension | path/file | | ${p4} | ${e4} = | Split Extension | p1/../p2/file.ext | | ${p5} | ${e5} = | Split Extension | path/.file.ext | | ${p6} | ${e6} = | Split Extension | path/.file | => - ${path} = 'file' & ${ext} = 'extension' - ${p2} = 'path/file' & ${e2} = 'ext' - ${p3} = 'path/file' & ${e3} = '' - ${p4} = 'p2/file' & ${e4} = 'ext' - ${p5} = 'path/.file' & ${e5} = 'ext' - ${p6} = 'path/.file' & ${e6} = ''

Source code in src/robot/libraries/OperatingSystem.py 
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
def split_extension(self, path):
    """Splits the extension from the given path.

    The given path is first normalized (e.g. possible trailing
    path separators removed, special directories ``..`` and ``.``
    removed). The base path and extension are returned as separate
    components so that the dot used as an extension separator is
    removed. If the path contains no extension, an empty string is
    returned for it. Possible leading and trailing dots in the file
    name are never considered to be extension separators.

    Examples:
    | ${path} | ${ext} = | Split Extension | file.extension    |
    | ${p2}   | ${e2} =  | Split Extension | path/file.ext     |
    | ${p3}   | ${e3} =  | Split Extension | path/file         |
    | ${p4}   | ${e4} =  | Split Extension | p1/../p2/file.ext |
    | ${p5}   | ${e5} =  | Split Extension | path/.file.ext    |
    | ${p6}   | ${e6} =  | Split Extension | path/.file        |
    =>
    - ${path} = 'file' & ${ext} = 'extension'
    - ${p2} = 'path/file' & ${e2} = 'ext'
    - ${p3} = 'path/file' & ${e3} = ''
    - ${p4} = 'p2/file' & ${e4} = 'ext'
    - ${p5} = 'path/.file' & ${e5} = 'ext'
    - ${p6} = 'path/.file' & ${e6} = ''
    """
    path = self.normalize_path(path)
    basename = os.path.basename(path)
    if basename.startswith('.' * basename.count('.')):
        return path, ''
    if path.endswith('.'):
        path2 = path.rstrip('.')
        trailing_dots = '.' * (len(path) - len(path2))
        path = path2
    else:
        trailing_dots = ''
    basepath, extension = os.path.splitext(path)
    if extension.startswith('.'):
        extension = extension[1:]
    if extension:
        extension += trailing_dots
    else:
        basepath += trailing_dots
    return basepath, extension

get_modified_time 

1
get_modified_time(path, format='timestamp')

Returns the last modification time of a file or directory.

How time is returned is determined based on the given format string as follows. Note that all checks are case-insensitive. Returned time is also automatically logged.

1) If format contains the word epoch, the time is returned in seconds after the UNIX epoch. The return value is always an integer.

2) If format contains any of the words year, month, day, hour, min or sec, only the selected parts are returned. The order of the returned parts is always the one in the previous sentence and the order of the words in format is not significant. The parts are returned as zero-padded strings (e.g. May -> 05).

3) Otherwise, and by default, the time is returned as a timestamp string in the format 2006-02-24 15:08:31.

Examples (when the modified time of ${CURDIR} is 2006-03-29 15:06:21): | ${time} = | Get Modified Time | ${CURDIR} | | ${secs} = | Get Modified Time | ${CURDIR} | epoch | | ${year} = | Get Modified Time | ${CURDIR} | return year | | ${y} | ${d} = | Get Modified Time | ${CURDIR} | year,day | | @{time} = | Get Modified Time | ${CURDIR} | year,month,day,hour,min,sec | => - ${time} = '2006-03-29 15:06:21' - ${secs} = 1143637581 - ${year} = '2006' - ${y} = '2006' & ${d} = '29' - @{time} = ['2006', '03', '29', '15', '06', '21']

Source code in src/robot/libraries/OperatingSystem.py 
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
def get_modified_time(self, path, format='timestamp'):
    """Returns the last modification time of a file or directory.

    How time is returned is determined based on the given ``format``
    string as follows. Note that all checks are case-insensitive.
    Returned time is also automatically logged.

    1) If ``format`` contains the word ``epoch``, the time is returned
       in seconds after the UNIX epoch. The return value is always
       an integer.

    2) If ``format`` contains any of the words ``year``, ``month``,
       ``day``, ``hour``, ``min`` or ``sec``, only the selected parts are
       returned. The order of the returned parts is always the one
       in the previous sentence and the order of the words in
       ``format`` is not significant. The parts are returned as
       zero-padded strings (e.g. May -> ``05``).

    3) Otherwise, and by default, the time is returned as a
       timestamp string in the format ``2006-02-24 15:08:31``.

    Examples (when the modified time of ``${CURDIR}`` is
    2006-03-29 15:06:21):
    | ${time} = | Get Modified Time | ${CURDIR} |
    | ${secs} = | Get Modified Time | ${CURDIR} | epoch |
    | ${year} = | Get Modified Time | ${CURDIR} | return year |
    | ${y} | ${d} = | Get Modified Time | ${CURDIR} | year,day |
    | @{time} = | Get Modified Time | ${CURDIR} | year,month,day,hour,min,sec |
    =>
    - ${time} = '2006-03-29 15:06:21'
    - ${secs} = 1143637581
    - ${year} = '2006'
    - ${y} = '2006' & ${d} = '29'
    - @{time} = ['2006', '03', '29', '15', '06', '21']
    """
    path = self._absnorm(path)
    if not os.path.exists(path):
        self._error("Path '%s' does not exist." % path)
    mtime = get_time(format, os.stat(path).st_mtime)
    self._link("Last modified time of '%%s' is %s." % mtime, path)
    return mtime

set_modified_time 

1
set_modified_time(path, mtime)

Sets the file modification and access times.

Changes the modification and access times of the given file to the value determined by mtime. The time can be given in different formats described below. Note that all checks involving strings are case-insensitive. Modified time can only be set to regular files.

1) If mtime is a number, or a string that can be converted to a number, it is interpreted as seconds since the UNIX epoch (1970-01-01 00:00:00 UTC). This documentation was originally written about 1177654467 seconds after the epoch.

2) If mtime is a timestamp, that time will be used. Valid timestamp formats are YYYY-MM-DD hh:mm:ss and YYYYMMDD hhmmss.

3) If mtime is equal to NOW, the current local time is used.

4) If mtime is equal to UTC, the current time in [http://en.wikipedia.org/wiki/Coordinated_Universal_Time|UTC] is used.

5) If mtime is in the format like NOW - 1 day or UTC + 1 hour 30 min, the current local/UTC time plus/minus the time specified with the time string is used. The time string format is described in an appendix of Robot Framework User Guide.

Examples: | Set Modified Time | /path/file | 1177654467 | # Time given as epoch seconds | | Set Modified Time | /path/file | 2007-04-27 9:14:27 | # Time given as a timestamp | | Set Modified Time | /path/file | NOW | # The local time of execution | | Set Modified Time | /path/file | NOW - 1 day | # 1 day subtracted from the local time | | Set Modified Time | /path/file | UTC + 1h 2min 3s | # 1h 2min 3s added to the UTC time |

Source code in src/robot/libraries/OperatingSystem.py 
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
def set_modified_time(self, path, mtime):
    """Sets the file modification and access times.

    Changes the modification and access times of the given file to
    the value determined by ``mtime``. The time can be given in
    different formats described below. Note that all checks
    involving strings are case-insensitive. Modified time can only
    be set to regular files.

    1) If ``mtime`` is a number, or a string that can be converted
       to a number, it is interpreted as seconds since the UNIX
       epoch (1970-01-01 00:00:00 UTC). This documentation was
       originally written about 1177654467 seconds after the epoch.

    2) If ``mtime`` is a timestamp, that time will be used. Valid
       timestamp formats are ``YYYY-MM-DD hh:mm:ss`` and
       ``YYYYMMDD hhmmss``.

    3) If ``mtime`` is equal to ``NOW``, the current local time is used.

    4) If ``mtime`` is equal to ``UTC``, the current time in
       [http://en.wikipedia.org/wiki/Coordinated_Universal_Time|UTC]
       is used.

    5) If ``mtime`` is in the format like ``NOW - 1 day`` or ``UTC + 1
       hour 30 min``, the current local/UTC time plus/minus the time
       specified with the time string is used. The time string format
       is described in an appendix of Robot Framework User Guide.

    Examples:
    | Set Modified Time | /path/file | 1177654467         | # Time given as epoch seconds |
    | Set Modified Time | /path/file | 2007-04-27 9:14:27 | # Time given as a timestamp   |
    | Set Modified Time | /path/file | NOW                | # The local time of execution |
    | Set Modified Time | /path/file | NOW - 1 day        | # 1 day subtracted from the local time |
    | Set Modified Time | /path/file | UTC + 1h 2min 3s   | # 1h 2min 3s added to the UTC time |
    """
    mtime = parse_time(mtime)
    path = self._absnorm(path)
    if not os.path.exists(path):
        self._error("File '%s' does not exist." % path)
    if not os.path.isfile(path):
        self._error("Path '%s' is not a regular file." % path)
    os.utime(path, (mtime, mtime))
    time.sleep(0.1)    # Give OS some time to really set these times.
    tstamp = datetime.fromtimestamp(mtime).isoformat(' ', timespec='seconds')
    self._link("Set modified time of '%%s' to %s." % tstamp, path)

get_file_size 

1
get_file_size(path)

Returns and logs file size as an integer in bytes.

Source code in src/robot/libraries/OperatingSystem.py 
1305
1306
1307
1308
1309
1310
1311
1312
1313
def get_file_size(self, path):
    """Returns and logs file size as an integer in bytes."""
    path = self._absnorm(path)
    if not os.path.isfile(path):
        self._error("File '%s' does not exist." % path)
    size = os.stat(path).st_size
    plural = plural_or_not(size)
    self._link("Size of file '%%s' is %d byte%s." % (size, plural), path)
    return size

list_directory 

1
list_directory(path, pattern=None, absolute=False)

Returns and logs items in a directory, optionally filtered with pattern.

File and directory names are returned in case-sensitive alphabetical order, e.g. ['A Name', 'Second', 'a lower case name', 'one more']. Implicit directories . and .. are not returned. The returned items are automatically logged.

File and directory names are returned relative to the given path (e.g. 'file.txt') by default. If you want them be returned in absolute format (e.g. '/home/robot/file.txt'), give the absolute argument a true value (see Boolean arguments).

If pattern is given, only items matching it are returned. The pattern is considered to be a glob pattern and the full syntax is explained in the Glob patterns section. With this keyword matching is always case-sensitive.

Examples (using also other List Directory variants): | @{items} = | List Directory | ${TEMPDIR} | | @{files} = | List Files In Directory | /tmp | *.txt | absolute | | ${count} = | Count Files In Directory | ${CURDIR} | ??? |

Source code in src/robot/libraries/OperatingSystem.py 
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
def list_directory(self, path, pattern=None, absolute=False):
    """Returns and logs items in a directory, optionally filtered with ``pattern``.

    File and directory names are returned in case-sensitive alphabetical
    order, e.g. ``['A Name', 'Second', 'a lower case name', 'one more']``.
    Implicit directories ``.`` and ``..`` are not returned. The returned
    items are automatically logged.

    File and directory names are returned relative to the given path
    (e.g. ``'file.txt'``) by default. If you want them be returned in
    absolute format (e.g. ``'/home/robot/file.txt'``), give the ``absolute``
    argument a true value (see `Boolean arguments`).

    If ``pattern`` is given, only items matching it are returned. The pattern
    is considered to be a _glob pattern_ and the full syntax is explained in
    the `Glob patterns` section. With this keyword matching is always
    case-sensitive.

    Examples (using also other `List Directory` variants):
    | @{items} = | List Directory           | ${TEMPDIR} |
    | @{files} = | List Files In Directory  | /tmp | *.txt | absolute |
    | ${count} = | Count Files In Directory | ${CURDIR} | ??? |
    """
    items = self._list_dir(path, pattern, absolute)
    self._info('%d item%s:\n%s' % (len(items), plural_or_not(items),
                                   '\n'.join(items)))
    return items

list_files_in_directory 

1
list_files_in_directory(path, pattern=None, absolute=False)

Wrapper for List Directory that returns only files.

Source code in src/robot/libraries/OperatingSystem.py 
1343
1344
1345
1346
1347
1348
def list_files_in_directory(self, path, pattern=None, absolute=False):
    """Wrapper for `List Directory` that returns only files."""
    files = self._list_files_in_dir(path, pattern, absolute)
    self._info('%d file%s:\n%s' % (len(files), plural_or_not(files),
                                   '\n'.join(files)))
    return files

list_directories_in_directory 

1
2
3
list_directories_in_directory(
    path, pattern=None, absolute=False
)

Wrapper for List Directory that returns only directories.

Source code in src/robot/libraries/OperatingSystem.py 
1350
1351
1352
1353
1354
1355
1356
def list_directories_in_directory(self, path, pattern=None, absolute=False):
    """Wrapper for `List Directory` that returns only directories."""
    dirs = self._list_dirs_in_dir(path, pattern, absolute)
    self._info('%d director%s:\n%s' % (len(dirs),
                                       'y' if len(dirs) == 1 else 'ies',
                                       '\n'.join(dirs)))
    return dirs

count_items_in_directory 

1
count_items_in_directory(path, pattern=None)

Returns and logs the number of all items in the given directory.

The argument pattern has the same semantics as with List Directory keyword. The count is returned as an integer, so it must be checked e.g. with the built-in keyword Should Be Equal As Integers.

Source code in src/robot/libraries/OperatingSystem.py 
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
def count_items_in_directory(self, path, pattern=None):
    """Returns and logs the number of all items in the given directory.

    The argument ``pattern`` has the same semantics as with `List Directory`
    keyword. The count is returned as an integer, so it must be checked e.g.
    with the built-in keyword `Should Be Equal As Integers`.
    """
    count = len(self._list_dir(path, pattern))
    self._info("%s item%s." % (count, plural_or_not(count)))
    return count

count_files_in_directory 

1
count_files_in_directory(path, pattern=None)

Wrapper for Count Items In Directory returning only file count.

Source code in src/robot/libraries/OperatingSystem.py 
1369
1370
1371
1372
1373
def count_files_in_directory(self, path, pattern=None):
    """Wrapper for `Count Items In Directory` returning only file count."""
    count = len(self._list_files_in_dir(path, pattern))
    self._info("%s file%s." % (count, plural_or_not(count)))
    return count

count_directories_in_directory 

1
count_directories_in_directory(path, pattern=None)

Wrapper for Count Items In Directory returning only directory count.

Source code in src/robot/libraries/OperatingSystem.py 
1375
1376
1377
1378
1379
def count_directories_in_directory(self, path, pattern=None):
    """Wrapper for `Count Items In Directory` returning only directory count."""
    count = len(self._list_dirs_in_dir(path, pattern))
    self._info("%s director%s." % (count, 'y' if count == 1 else 'ies'))
    return count

touch 

1
touch(path)

Emulates the UNIX touch command.

Creates a file, if it does not exist. Otherwise changes its access and modification times to the current time.

Fails if used with the directories or the parent directory of the given file does not exist.

Source code in src/robot/libraries/OperatingSystem.py 
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
def touch(self, path):
    """Emulates the UNIX touch command.

    Creates a file, if it does not exist. Otherwise changes its access and
    modification times to the current time.

    Fails if used with the directories or the parent directory of the given
    file does not exist.
    """
    path = self._absnorm(path)
    if os.path.isdir(path):
        self._error("Cannot touch '%s' because it is a directory." % path)
    if not os.path.exists(os.path.dirname(path)):
        self._error("Cannot touch '%s' because its parent directory does "
                    "not exist." % path)
    if os.path.exists(path):
        mtime = round(time.time())
        os.utime(path, (mtime, mtime))
        self._link("Touched existing file '%s'.", path)
    else:
        open(path, 'w', encoding='ASCII').close()
        self._link("Touched new file '%s'.", path)