removed libspecs

<?xml version="1.0" encoding="UTF-8"?>

<keywordspec name="DateTime" type="library" format="ROBOT" generated="20200529 10:52:02">

<version>3.1</version>

<scope>global</scope>

<namedargs>yes</namedargs>

<doc>A test library for handling date and time values.

``DateTime`` is a Robot Framework standard library that supports creating and

converting date and time values (e.g. `Get Current Date`, `Convert Time`),

as well as doing simple calculations with them (e.g. `Subtract Time From Date`,

`Add Time To Time`). It supports dates and times in various formats, and can

also be used by other libraries programmatically.

= Table of Contents =

- `Terminology`

- `Date formats`

- `Time formats`

- `Millisecond handling`

- `Programmatic usage`

- `Shortcuts`

- `Keywords`

= Terminology =

In the context of this library, ``date`` and ``time`` generally have following

meanings:

- ``date``: An entity with both date and time components but without any

   timezone information. For example, ``2014-06-11 10:07:42``.

- ``time``: A time interval. For example, ``1 hour 20 minutes`` or ``01:20:00``.

This terminology differs from what Python's standard

[http://docs.python.org/library/datetime.html|datetime] module uses.

Basically its

[http://docs.python.org/library/datetime.html#datetime-objects|datetime] and

[http://docs.python.org/library/datetime.html#timedelta-objects|timedelta]

objects match ``date`` and ``time`` as defined by this library.

= Date formats =

Dates can given to and received from keywords in `timestamp`, `custom

timestamp`, `Python datetime` and `epoch time` formats. These formats are

discussed thoroughly in subsequent sections.

Input format is determined automatically based on the given date except when

using custom timestamps, in which case it needs to be given using

``date_format`` argument. Default result format is timestamp, but it can

be overridden using ``result_format`` argument.

== Timestamp ==

If a date is given as a string, it is always considered to be a timestamp.

If no custom formatting is given using ``date_format`` argument, the timestamp

is expected to be in [http://en.wikipedia.org/wiki/ISO_8601|ISO 8601] like

format ``YYYY-MM-DD hh:mm:ss.mil``, where any non-digit character can be used

as a separator or separators can be omitted altogether. Additionally,

only the date part is mandatory, all possibly missing time components are

considered to be zeros.

Dates can also be returned in the same ``YYYY-MM-DD hh:mm:ss.mil`` format by

using ``timestamp`` value with ``result_format`` argument. This is also the

default format that keywords returning dates use. Milliseconds can be excluded

using ``exclude_millis`` as explained in `Millisecond handling` section.

Examples:

| ${date1} =      | Convert Date | 2014-06-11 10:07:42.000 |

| ${date2} =      | Convert Date | 20140611 100742         | result_format=timestamp |

| Should Be Equal | ${date1}     | ${date2}                |

| ${date} =       | Convert Date | 20140612 12:57          | exclude_millis=yes |

| Should Be Equal | ${date}      | 2014-06-12 12:57:00     |

== Custom timestamp ==

It is possible to use custom timestamps in both input and output.

The custom format is same as accepted by Python's

[http://docs.python.org/library/datetime.html#strftime-strptime-behavior|

datatime.strptime] function. For example, the default timestamp discussed

in the previous section would match ``%Y-%m-%d %H:%M:%S.%f``.

When using a custom timestamp in input, it must be specified using

``date_format`` argument. The actual input value must be a string that matches

the specified format exactly. When using a custom timestamp in output, it must

be given using ``result_format`` argument.

Examples:

| ${date} =       | Convert Date | 28.05.2014 12:05        | date_format=%d.%m.%Y %H:%M |

| Should Be Equal | ${date}      | 2014-05-28 12:05:00.000 |

| ${date} =       | Convert Date | ${date}                 | result_format=%d.%m.%Y |

| Should Be Equal | ${date}      | 28.05.2014              |

Notice that locale aware directives like ``%b``  do not work correctly with

Jython on non-English locales: http://bugs.jython.org/issue2285

== Python datetime ==

Python's standard

[http://docs.python.org/library/datetime.html#datetime-objects|datetime]

objects can be used both in input and output. In input they are recognized

automatically, and in output it is possible to get them by giving ``datetime``

value to ``result_format`` argument.

One nice benefit with datetime objects is that they have different time

components available as attributes that can be easily accessed using the

extended variable syntax.

Examples:

| ${datetime} = | Convert Date | 2014-06-11 10:07:42.123 | datetime |

| Should Be Equal As Integers | ${datetime.year}        | 2014   |

| Should Be Equal As Integers | ${datetime.month}       | 6      |

| Should Be Equal As Integers | ${datetime.day}         | 11     |

| Should Be Equal As Integers | ${datetime.hour}        | 10     |

| Should Be Equal As Integers | ${datetime.minute}      | 7      |

| Should Be Equal As Integers | ${datetime.second}      | 42     |

| Should Be Equal As Integers | ${datetime.microsecond} | 123000 |

== Epoch time ==

Epoch time is the time in seconds since the

[http://en.wikipedia.org/wiki/Unix_time|UNIX epoch] i.e. 00:00:00.000 (UTC)

1 January 1970. To give a date in epoch time, it must be given as a number

(integer or float), not as a string. To return a date in epoch time,

it is possible to use ``epoch`` value with ``result_format`` argument.

Epoch time is returned as a floating point number.

Notice that epoch time itself is independent on timezones and thus same

around the world at a certain time. What local time a certain epoch time

matches obviously then depends on the timezone. For example, examples below

were tested in Finland but verifications would fail on other timezones.

Examples:

| ${date} =       | Convert Date | ${1000000000}           |

| Should Be Equal | ${date}      | 2001-09-09 04:46:40.000 |

| ${date} =       | Convert Date | 2014-06-12 13:27:59.279 | epoch |

| Should Be Equal | ${date}      | ${1402568879.279}       |

== Earliest supported date ==

The earliest date that is supported depends on the date format and to some

extend on the platform:

- Timestamps support year 1900 and above.

- Python datetime objects support year 1 and above.

- Epoch time supports 1970 and above on Windows with Python and IronPython.

- On other platforms epoch time supports 1900 and above or even earlier.

Prior to Robot Framework 2.9.2, all formats had same limitation as epoch time

has nowadays.

= Time formats =

Similarly as dates, times can be given to and received from keywords in

various different formats. Supported formats are `number`, `time string`

(verbose and compact), `timer string` and `Python timedelta`.

Input format for time is always determined automatically based on the input.

Result format is number by default, but it can be customised using

``result_format`` argument.

== Number ==

Time given as a number is interpreted to be seconds. It can be given

either as an integer or a float, or it can be a string that can be converted

to a number.

To return a time as a number, ``result_format`` argument must have value

``number``, which is also the default. Returned number is always a float.

Examples:

| ${time} =       | Convert Time | 3.14    |

| Should Be Equal | ${time}      | ${3.14} |

| ${time} =       | Convert Time | ${time} | result_format=number |

| Should Be Equal | ${time}      | ${3.14} |

== Time string ==

Time strings are strings in format like ``1 minute 42 seconds`` or ``1min 42s``.

The basic idea of this format is having first a number and then a text

specifying what time that number represents. Numbers can be either

integers or floating point numbers, the whole format is case and space

insensitive, and it is possible to add a minus prefix to specify negative

times. The available time specifiers are:

- ``days``, ``day``, ``d``

- ``hours``, ``hour``, ``h``

- ``minutes``, ``minute``, ``mins``, ``min``, ``m``

- ``seconds``, ``second``, ``secs``, ``sec``, ``s``

- ``milliseconds``, ``millisecond``, ``millis``, ``ms``

When returning a time string, it is possible to select between ``verbose``

and ``compact`` representations using ``result_format`` argument. The verbose

format uses long specifiers ``day``, ``hour``, ``minute``, ``second`` and

``millisecond``, and adds ``s`` at the end when needed. The compact format uses

shorter specifiers ``d``, ``h``, ``min``, ``s`` and ``ms``, and even drops

the space between the number and the specifier.

Examples:

| ${time} =       | Convert Time | 1 minute 42 seconds |

| Should Be Equal | ${time}      | ${102}              |

| ${time} =       | Convert Time | 4200                | verbose |

| Should Be Equal | ${time}      | 1 hour 10 minutes   |

| ${time} =       | Convert Time | - 1.5 hours         | compact |

| Should Be Equal | ${time}      | - 1h 30min          |

== Timer string ==

Timer string is a string given in timer like format ``hh:mm:ss.mil``. In this

format both hour and millisecond parts are optional, leading and trailing

zeros can be left out when they are not meaningful, and negative times can

be represented by adding a minus prefix.

To return a time as timer string, ``result_format`` argument must be given

value ``timer``. Timer strings are by default returned in full ``hh:mm:ss.mil``

format, but milliseconds can be excluded using ``exclude_millis`` as explained

in `Millisecond handling` section.

Examples:

| ${time} =       | Convert Time | 01:42        |

| Should Be Equal | ${time}      | ${102}       |

| ${time} =       | Convert Time | 01:10:00.123 |

| Should Be Equal | ${time}      | ${4200.123}  |

| ${time} =       | Convert Time | 102          | timer |

| Should Be Equal | ${time}      | 00:01:42.000 |

| ${time} =       | Convert Time | -101.567     | timer | exclude_millis=yes |

| Should Be Equal | ${time}      | -00:01:42    |

== Python timedelta ==

Python's standard

[http://docs.python.org/library/datetime.html#datetime.timedelta|timedelta]

objects are also supported both in input and in output. In input they are

recognized automatically, and in output it is possible to receive them by

giving ``timedelta`` value to ``result_format`` argument.

Examples:

| ${timedelta} =  | Convert Time                 | 01:10:02.123 | timedelta |

| Should Be Equal | ${timedelta.total_seconds()} | ${4202.123}  |

= Millisecond handling =

This library handles dates and times internally using the precision of the

given input. With `timestamp`, `time string`, and `timer string` result

formats seconds are, however, rounded to millisecond accuracy. Milliseconds

may also be included even if there would be none.

All keywords returning dates or times have an option to leave milliseconds out

by giving a true value to ``exclude_millis`` argument. If the argument is given

as a string, it is considered true unless it is empty or case-insensitively

equal to ``false``, ``none`` or ``no``. Other argument types are tested using

same [http://docs.python.org/library/stdtypes.html#truth|rules as in

Python]. Notice that prior to Robot Framework 2.9, all strings except

the empty string were considered true, and that considering ``none`` false is

new in Robot Framework 3.0.3.

When milliseconds are excluded, seconds in returned dates and times are

rounded to the nearest full second. With `timestamp` and `timer string`

result formats, milliseconds will also be removed from the returned string

altogether.

Examples:

| ${date} =       | Convert Date | 2014-06-11 10:07:42     |

| Should Be Equal | ${date}      | 2014-06-11 10:07:42.000 |

| ${date} =       | Convert Date | 2014-06-11 10:07:42.500 | exclude_millis=yes |

| Should Be Equal | ${date}      | 2014-06-11 10:07:43     |

| ${dt} =         | Convert Date | 2014-06-11 10:07:42.500 | datetime | exclude_millis=yes |

| Should Be Equal | ${dt.second} | ${43}        |

| Should Be Equal | ${dt.microsecond} | ${0}    |

| ${time} =       | Convert Time | 102          | timer | exclude_millis=false |

| Should Be Equal | ${time}      | 00:01:42.000 |       |

| ${time} =       | Convert Time | 102.567      | timer | exclude_millis=true |

| Should Be Equal | ${time}      | 00:01:43     |       |

= Programmatic usage =

In addition to be used as normal library, this library is intended to

provide a stable API for other libraries to use if they want to support

same date and time formats as this library. All the provided keywords

are available as functions that can be easily imported:

| from robot.libraries.DateTime import convert_time

|

| def example_keyword(timeout):

|     seconds = convert_time(timeout)

|     # ...

Additionally helper classes ``Date`` and ``Time`` can be used directly:

| from robot.libraries.DateTime import Date, Time

|

| def example_keyword(date, interval):

|     date = Date(date).convert('datetime')

|     interval = Time(interval).convert('number')

|     # ...</doc>

<kw name="Add Time To Date">

<arguments>

<arg>date</arg>

<arg>time</arg>

<arg>result_format=timestamp</arg>

<arg>exclude_millis=False</arg>

<arg>date_format=None</arg>

</arguments>

<doc>Adds time to date and returns the resulting date.

Arguments:

- ``date:``           Date to add time to in one of the supported

                      `date formats`.

- ``time:``           Time that is added in one of the supported

                      `time formats`.

- ``result_format:``  Format of the returned date.

- ``exclude_millis:`` When set to any true value, rounds and drops

                      milliseconds as explained in `millisecond handling`.

- ``date_format:``    Possible `custom timestamp` format of ``date``.

Examples:

| ${date} =       | Add Time To Date | 2014-05-28 12:05:03.111 | 7 days       |

| Should Be Equal | ${date}          | 2014-06-04 12:05:03.111 |              |

| ${date} =       | Add Time To Date | 2014-05-28 12:05:03.111 | 01:02:03:004 |

| Should Be Equal | ${date}          | 2014-05-28 13:07:06.115 |</doc>

<tags>

</tags>

</kw>

<kw name="Add Time To Time">

<arguments>

<arg>time1</arg>

<arg>time2</arg>

<arg>result_format=number</arg>

<arg>exclude_millis=False</arg>

</arguments>

<doc>Adds time to another time and returns the resulting time.

Arguments:

- ``time1:``          First time in one of the supported `time formats`.

- ``time2:``          Second time in one of the supported `time formats`.

- ``result_format:``  Format of the returned time.

- ``exclude_millis:`` When set to any true value, rounds and drops

                      milliseconds as explained in `millisecond handling`.

Examples:

| ${time} =       | Add Time To Time | 1 minute          | 42       |

| Should Be Equal | ${time}          | ${102}            |

| ${time} =       | Add Time To Time | 3 hours 5 minutes | 01:02:03 | timer | exclude_millis=yes |

| Should Be Equal | ${time}          | 04:07:03          |</doc>

<tags>

</tags>

</kw>

<kw name="Convert Date">

<arguments>

<arg>date</arg>

<arg>result_format=timestamp</arg>

<arg>exclude_millis=False</arg>

<arg>date_format=None</arg>

</arguments>

<doc>Converts between supported `date formats`.

Arguments:

- ``date:``           Date in one of the supported `date formats`.

- ``result_format:``  Format of the returned date.

- ``exclude_millis:`` When set to any true value, rounds and drops

                      milliseconds as explained in `millisecond handling`.

- ``date_format:``    Specifies possible `custom timestamp` format.

Examples:

| ${date} =       | Convert Date | 20140528 12:05:03.111   |

| Should Be Equal | ${date}      | 2014-05-28 12:05:03.111 |

| ${date} =       | Convert Date | ${date}                 | epoch |

| Should Be Equal | ${date}      | ${1401267903.111}       |

| ${date} =       | Convert Date | 5.28.2014 12:05         | exclude_millis=yes | date_format=%m.%d.%Y %H:%M |

| Should Be Equal | ${date}      | 2014-05-28 12:05:00     |</doc>

<tags>

</tags>

</kw>

<kw name="Convert Time">

<arguments>

<arg>time</arg>

<arg>result_format=number</arg>

<arg>exclude_millis=False</arg>

</arguments>

<doc>Converts between supported `time formats`.

Arguments:

- ``time:``           Time in one of the supported `time formats`.

- ``result_format:``  Format of the returned time.

- ``exclude_millis:`` When set to any true value, rounds and drops

                      milliseconds as explained in `millisecond handling`.

Examples:

| ${time} =       | Convert Time  | 10 seconds        |

| Should Be Equal | ${time}       | ${10}             |

| ${time} =       | Convert Time  | 1:00:01           | verbose |

| Should Be Equal | ${time}       | 1 hour 1 second   |

| ${time} =       | Convert Time  | ${3661.5} | timer | exclude_milles=yes |

| Should Be Equal | ${time}       | 01:01:02          |</doc>

<tags>

</tags>

</kw>

<kw name="Get Current Date">

<arguments>

<arg>time_zone=local</arg>

<arg>increment=0</arg>

<arg>result_format=timestamp</arg>

<arg>exclude_millis=False</arg>

</arguments>

<doc>Returns current local or UTC time with an optional increment.

Arguments:

- ``time_zone:``      Get the current time on this time zone. Currently only

                      ``local`` (default) and ``UTC`` are supported.

- ``increment:``      Optional time increment to add to the returned date in

                      one of the supported `time formats`. Can be negative.

- ``result_format:``  Format of the returned date (see `date formats`).

- ``exclude_millis:`` When set to any true value, rounds and drops

                      milliseconds as explained in `millisecond handling`.

Examples:

| ${date} =       | Get Current Date |

| Should Be Equal | ${date}          | 2014-06-12 20:00:58.946 |

| ${date} =       | Get Current Date | UTC                     |

| Should Be Equal | ${date}          | 2014-06-12 17:00:58.946 |

| ${date} =       | Get Current Date | increment=02:30:00      |

| Should Be Equal | ${date}          | 2014-06-12 22:30:58.946 |

| ${date} =       | Get Current Date | UTC                     | - 5 hours |

| Should Be Equal | ${date}          | 2014-06-12 12:00:58.946 |

| ${date} =       | Get Current Date | result_format=datetime  |

| Should Be Equal | ${date.year}     | ${2014}                 |

| Should Be Equal | ${date.month}    | ${6}                    |</doc>

<tags>

</tags>

</kw>

<kw name="Subtract Date From Date">

<arguments>

<arg>date1</arg>

<arg>date2</arg>

<arg>result_format=number</arg>

<arg>exclude_millis=False</arg>

<arg>date1_format=None</arg>

<arg>date2_format=None</arg>

</arguments>

<doc>Subtracts date from another date and returns time between.

Arguments:

- ``date1:``          Date to subtract another date from in one of the

                      supported `date formats`.

- ``date2:``          Date that is subtracted in one of the supported

                      `date formats`.

- ``result_format:``  Format of the returned time (see `time formats`).

- ``exclude_millis:`` When set to any true value, rounds and drops

                      milliseconds as explained in `millisecond handling`.

- ``date1_format:``   Possible `custom timestamp` format of ``date1``.

- ``date2_format:``   Possible `custom timestamp` format of ``date2``.

 Examples:

| ${time} =       | Subtract Date From Date | 2014-05-28 12:05:52     | 2014-05-28 12:05:10 |

| Should Be Equal | ${time}                 | ${42}                   |

| ${time} =       | Subtract Date From Date | 2014-05-28 12:05:52     | 2014-05-27 12:05:10 | verbose |

| Should Be Equal | ${time}                 | 1 day 42 seconds        |</doc>

<tags>

</tags>

</kw>

<kw name="Subtract Time From Date">

<arguments>

<arg>date</arg>

<arg>time</arg>

<arg>result_format=timestamp</arg>

<arg>exclude_millis=False</arg>

<arg>date_format=None</arg>

</arguments>

<doc>Subtracts time from date and returns the resulting date.

Arguments:

- ``date:``           Date to subtract time from in one of the supported

                      `date formats`.

- ``time:``           Time that is subtracted in one of the supported

                     `time formats`.

- ``result_format:``  Format of the returned date.

- ``exclude_millis:`` When set to any true value, rounds and drops

                      milliseconds as explained in `millisecond handling`.

- ``date_format:``    Possible `custom timestamp` format of ``date``.

Examples:

| ${date} =       | Subtract Time From Date | 2014-06-04 12:05:03.111 | 7 days |

| Should Be Equal | ${date}                 | 2014-05-28 12:05:03.111 |

| ${date} =       | Subtract Time From Date | 2014-05-28 13:07:06.115 | 01:02:03:004 |

| Should Be Equal | ${date}                 | 2014-05-28 12:05:03.111 |</doc>

<tags>

</tags>

</kw>

<kw name="Subtract Time From Time">

<arguments>

<arg>time1</arg>

<arg>time2</arg>

<arg>result_format=number</arg>

<arg>exclude_millis=False</arg>

</arguments>

<doc>Subtracts time from another time and returns the resulting time.

Arguments:

- ``time1:``          Time to subtract another time from in one of

                      the supported `time formats`.

- ``time2:``          Time to subtract in one of the supported `time formats`.

- ``result_format:``  Format of the returned time.

- ``exclude_millis:`` When set to any true value, rounds and drops

                      milliseconds as explained in `millisecond handling`.

Examples:

| ${time} =       | Subtract Time From Time | 00:02:30 | 100      |

| Should Be Equal | ${time}                 | ${50}    |

| ${time} =       | Subtract Time From Time | ${time}  | 1 minute | compact |

| Should Be Equal | ${time}                 | - 10s    |</doc>

<tags>

</tags>

</kw>

</keywordspec>

<?xml version="1.0" encoding="UTF-8"?>

<keywordspec name="DependencyLibrary" type="library" format="ROBOT" generated="20200529 11:03:07">

<version></version>

<scope>global</scope>

<namedargs>yes</namedargs>

<doc>Documentation for library ``DependencyLibrary``.</doc>

<kw name="Depends On Suite">

<arguments>

<arg>name</arg>

</arguments>

<doc></doc>

<tags>

</tags>

</kw>

<kw name="Depends On Suite Failure">

<arguments>

<arg>name</arg>

</arguments>

<doc></doc>

<tags>

</tags>

</kw>

<kw name="Depends On Suite Success">

<arguments>

<arg>name</arg>

</arguments>

<doc></doc>

<tags>

</tags>

</kw>

<kw name="Depends On Test">

<arguments>

<arg>name</arg>

</arguments>

<doc></doc>

<tags>

</tags>

</kw>

<kw name="Depends On Test Failure">

<arguments>

<arg>name</arg>

</arguments>

<doc></doc>

<tags>

</tags>

</kw>

<kw name="Depends On Test Success">

<arguments>

<arg>name</arg>

</arguments>

<doc></doc>

<tags>

</tags>

</kw>

</keywordspec>