busser-robot 0.1.3

data/vendor/robot/atest/testdata/running/test_template_with_embeded_args.robot

@@ -0,0 +1,47 @@
+*** Test Cases ***
+Matching arguments
+    [Documentation]    FAIL 4 != 5
+    [Template]    The result of ${calculation} should be ${expected}
+    1 + 1    2
+    1 + 2    3
+    1 + 3    5
+
+Argument names do not need to be same as in definition
+    [Documentation]    FAIL 4 != 5
+    [Template]    The result of ${foo} should be ${bar}
+    1 + 1    2
+    1 + 2    3
+    1 + 3    5
+
+Some arguments can be hard-coded
+    [Documentation]    FAIL Several failures occurred:\n\n1) 2 != 3\n\n2) 4 != 3
+    [Template]    The result of ${expression} should be 3
+    1 + 1
+    1 + 2
+    1 + 3
+
+Can have different arguments than definition
+    [Documentation]    FAIL No keyword with name 'The non-existing of 666 should be 42' found.
+    [Template]    The ${meaning} of ${life} should be 42
+    result    38 + 3 + 1
+    non-existing    666
+
+Can use variables
+    [Template]    The result of ${calculation} should be ${expected}
+    ${1} + ${2}    ${3}
+
+Cannot have more arguments than variables
+    [Documentation]    FAIL Keyword 'The result of ${calculation} should be ${expected}' expected 0 arguments, got 2.
+    [Template]    The result of ${calc} should be 3
+    1 + 2    extra
+
+Cannot have less arguments than variables
+    [Documentation]    FAIL Keyword 'The result of ${calculation} should be ${expected}' expected 0 arguments, got 1.
+    [Template]    The result of ${calc} should be ${extra}
+    1 + 2
+    4 - 1
+
+*** Keywords ***
+The result of ${calculation} should be ${expected}
+    ${result} =    Evaluate    ${calculation}
+    Should Be Equal As Integers   ${result}    ${expected}

data/vendor/robot/atest/testdata/standard_libraries/builtin/DynamicRegisteredLibrary.py

@@ -0,0 +1,14 @@
+from robot.libraries.BuiltIn import BuiltIn, register_run_keyword
+
+class DynamicRegisteredLibrary:
+    
+    def get_keyword_names(self):
+        return ['dynamic_run_keyword']
+    
+    def run_keyword(self, name, args):
+        dynamic_run_keyword(*args)
+
+def dynamic_run_keyword(name, *args):
+    return BuiltIn().run_keyword(name, *args)
+
+register_run_keyword('DynamicRegisteredLibrary', 'dynamic_run_keyword', 1)

data/vendor/robot/atest/testdata/standard_libraries/builtin/FailUntilSucceeds.py

@@ -0,0 +1,14 @@
+class FailUntilSucceeds:
+    ROBOT_LIBRARY_SCOPE = 'TESTCASE'
+
+    def __init__(self, times_to_fail=0):
+        self.times_to_fail = int(times_to_fail)
+
+    def set_times_to_fail(self, times_to_fail):
+        self.__init__(times_to_fail)
+
+    def fail_until_retried_often_enough(self, message="Hello"):
+        self.times_to_fail -= 1
+        if self.times_to_fail >= 0:
+            raise Exception('Still %d times to fail!' % self.times_to_fail)
+        return message

data/vendor/robot/atest/testdata/standard_libraries/builtin/NotRegisteringLibrary.py

@@ -0,0 +1,5 @@
+from robot.libraries.BuiltIn import BuiltIn
+
+
+def my_run_keyword(name, *args):
+    return BuiltIn().run_keyword(name, *args)

data/vendor/robot/atest/testdata/standard_libraries/builtin/RegisteredClass.py

@@ -0,0 +1,12 @@
+from robot.libraries.BuiltIn import BuiltIn, register_run_keyword
+
+
+class RegisteredClass:
+    def run_keyword_if_method(self, expression, name, *args):
+        return BuiltIn().run_keyword_if(expression, name, *args)
+
+    def run_keyword_method(self, name, *args):
+        return BuiltIn().run_keyword(name, *args)
+
+register_run_keyword("RegisteredClass", "Run Keyword If Method", 2)
+register_run_keyword("RegisteredClass", "run_keyword_method", 1)

data/vendor/robot/atest/testdata/standard_libraries/builtin/RegisteringLibrary.py

@@ -0,0 +1,13 @@
+from robot.libraries.BuiltIn import BuiltIn, register_run_keyword
+
+
+def run_keyword_function(name, *args):
+    return BuiltIn().run_keyword(name, *args)
+
+
+register_run_keyword(__name__, 'run_keyword_function', 1)
+
+def run_keyword_without_keyword(*args):
+    return BuiltIn().run_keyword('\Log Many', *args)
+
+register_run_keyword(__name__, 'run_keyword_without_keyword', 0)

data/vendor/robot/atest/testdata/standard_libraries/builtin/UseBuiltIn.py

@@ -0,0 +1,17 @@
+from robot.libraries.BuiltIn import BuiltIn
+
+
+def log_debug_message():
+    b = BuiltIn()
+    b.set_log_level('DEBUG')
+    b.log('Hello, debug world!', 'DEBUG')
+
+def get_test_name():
+    return BuiltIn().get_variables()['${TEST NAME}']
+
+def set_secret_variable():
+    BuiltIn().set_test_variable('${SECRET}', '*****')
+
+def use_run_keyword_with_non_unicode_values():
+    BuiltIn().run_keyword('Log', 42)
+    BuiltIn().run_keyword('Log', b'\xff')

data/vendor/robot/atest/testdata/standard_libraries/builtin/call_method.robot

@@ -0,0 +1,60 @@
+*** Settings ***
+Variables         objects_for_call_method.py
+
+*** Test Cases ***
+Call Method
+    Call Method    ${obj}    my_method
+    Should Be True    ${obj.args} == ()
+    Call Method    ${obj}    my_method    arg
+    Should Be True    ${obj.args} == ('arg',)
+    Call Method    ${obj}    my_method    a1    a2
+    Should Be True    ${obj.args} == ('a1','a2')
+
+Call Method Returns
+    ${res} =    Call Method    my_str    upper
+    Should Be Equal    ${res}    MY_STR
+    ${a}    ${b}    ${c} =    Call Method    a,b,c    split    ,
+    Should Be Equal    ${a}    a
+    Should Be Equal    ${b}    b
+    Should Be Equal    ${c}    c
+
+Called Method Fails
+    [Documentation]    FAIL Calling method 'my_method' failed: Expected failure
+    Call Method    ${obj}    my_method    FAIL!
+
+Call Method With Kwargs
+    ${ret} =    Call Method    ${obj}    kwargs    first    arg3=new
+    Should Be Equal    ${ret}    first, default, arg3: new
+    ${ret} =    Call Method    ${obj}    kwargs    arg1=first    arg3=new
+    Should Be Equal    ${ret}    first, default, arg3: new
+    ${ret} =    Call Method    ${obj}    kwargs    k1=override    arg1=override
+    ...    k2=2    k3=3   arg2=2    k4=4    arg1=1    k5=5    k1=1
+    Should Be Equal    ${ret}    1, 2, k1: 1, k2: 2, k3: 3, k4: 4, k5: 5
+
+Equals in non-kwargs must be escaped
+    [Documentation]    FAIL STARTS: Calling method 'my_method' failed: TypeError:
+    ${ret} =    Call Method    ${obj}    kwargs    arg1\=here    arg2\\\=\=
+    ...    arg3\\=    arg4====
+    Should Be Equal    ${ret}    arg1=here, arg2\\==, arg3\\: , arg4: ===
+    Call Method    ${obj}    my_method    this=fails
+
+Call Method From Module
+    ${path} =    Call Method    ${os.path}    join    ${CURDIR}    foo    bar.txt
+    Should Be Equal    ${path}    ${CURDIR}${/}foo${/}bar.txt
+
+Call Non Existing Method
+    [Documentation]    FAIL Object 'String presentation of MyObject' does not have method 'non_existing'.
+    Call Method    ${obj}    non_existing
+
+Call Java Method
+    ${isempty} =    Call Method    ${hashtable}    isEmpty
+    Should Be True    ${isempty}
+    Call Method    ${hashtable}    put    myname    myvalue
+    ${value} =    Call Method    ${hashtable}    get    myname
+    Should Be Equal    ${value}    myvalue
+    ${isempty} =    Call Method    ${hashtable}    isEmpty
+    Should Not Be True    ${isempty}
+
+Call Non Existing Java Method
+    [Documentation]    FAIL Object '{myname: myvalue}' does not have method 'nonExisting'.
+    Call Method    ${hashtable}    nonExisting

data/vendor/robot/atest/testdata/standard_libraries/builtin/convert_to_bytes.robot

@@ -0,0 +1,170 @@
+*** Settings ***
+Test Template    Correct bytes should be created
+Library          String
+
+*** Variables ***
+@{CHAR LIST}     h    y    v    ä    \x00
+@{INT LIST}      0    ${1}    0b10    0o3    0xff
+@{HEX LIST}      0    1    007    ff
+@{BIN LIST}      0    1    111    11111111
+@{BIG LIST}      100000000
+@{SMALL LIST}    -1
+
+*** Test Cases ***
+Default input type is text
+    [Template]    NONE
+    ${bytes} =    Convert To Bytes    Tämä on testi
+    Bytes should be equal to    ${bytes}    84, 228, 109, 228, 32, 111, 110, 32, 116, 101, 115, 116, 105
+    ${bytes} =    Convert To Bytes    0 1 2    input_type=int
+    Bytes should be equal to    ${bytes}    0, 1, 2
+
+Invalid input type fails
+    [Template]    Creating bytes should fail
+    whatever    invalid    Invalid input type 'invalid'.
+
+ASCII string
+    H           text    72
+    hello       text    104, 101, 108, 108, 111
+    \x00\x01    text    0, 1
+    0 1 2       text    48, 32, 49, 32, 50
+
+Non-ASCII string
+    åäö         text    229, 228, 246
+    \xe4\xff    text    228, 255
+
+Non-ASCII above 255 fails
+    [Template]    Creating bytes should fail
+    \u0100      text    Character '\u0100' cannot be represented as a byte.
+    \u2603      text    Character '\u2603' cannot be represented as a byte.
+
+Characters as a list
+    ${CHAR LIST}    text    104, 121, 118, 228, 0
+
+Byte string
+    [Template]    NONE
+    ${b1} =    Convert To Bytes    \x00-a-ä-\xff
+    ${b2} =    Convert To Bytes    ${b1}
+    Should Be Equal    ${b1}    ${b2}
+
+Bytearray
+    [Template]    NONE
+    ${bytearray} =    Evaluate    bytearray([0, 1, 2, 255])
+    ${bytes} =    Convert To Bytes    ${bytearray}
+    ${expected} =    Convert To Bytes    \x00\x01\x02\xff
+    Should Be Equal    ${bytes}    ${expected}
+
+Integers
+    4                      int    4
+    0 255                  int    0, 255
+    104 101 108 108 111    int    104, 101, 108, 108, 111
+    0 1 2 3 4              int    0, 1, 2, 3, 4
+
+Any whitespace as integer separator
+    0\t1 255               int    0, 1, 255
+    0\n1${SPACE*5}2\r33    int    0, 1, 2, 33
+
+Integers with prefixes
+    0b111 0B0010           int    7, 2
+    0o111 0O0010           int    73, 8
+    0xF 0X0f               int    15, 15
+    0b10 0o10 10 0x10      int    2, 8, 10, 16
+    0b11111111 0o377 0xff  int    255, 255, 255
+
+Integers as list
+    ${INT LIST}    int    0, 1, 2, 3, 255
+
+Integer as integer
+    ${0}     int    0
+    ${42}    int    42
+
+Integers without separators does not work
+    [Template]    Creating bytes should fail
+    001007    int    Integer '001007' cannot be represented as a byte.
+
+Too big or small integers
+    [Template]    Creating bytes should fail
+    256 1            int    Integer '256' cannot be represented as a byte.
+    0 0xfff          int    Integer '0xfff' cannot be represented as a byte.
+    -1               int    Integer '-1' cannot be represented as a byte.
+    ${BIG LIST}      int    Integer '100000000' cannot be represented as a byte.
+    ${SMALL LIST}    int    Integer '-1' cannot be represented as a byte.
+
+Invalid integers
+    [Template]    Creating bytes should fail
+    hello 1      int    'hello' cannot be converted to an integer: ValueError: *
+    0 0xa 0ba    int    '0ba' cannot be converted to an integer: ValueError: *
+
+Hex without whitespace
+    0a                 hex    10
+    aBbA               hex    171, 186
+    000102ff           hex    0, 1, 2, 255
+    68656c6C6f         hex    104, 101, 108, 108, 111
+
+Hex with whitespace
+    68 65 6c 6C 6f     hex    104, 101, 108, 108, 111
+    6865 6c6C 6f       hex    104, 101, 108, 108, 111
+    6 8 6 5 6 c 6 C    hex    104, 101, 108, 108
+    01\t02\n\r03       hex    1, 2, 3
+    f${SPACE*10}f      hex    255
+
+Hex requires even input
+    [Template]    Creating bytes should fail
+    abc     hex    Expected input to be multiple of 2.
+    ab c    hex    Expected input to be multiple of 2.
+
+Hex as list
+    ${HEX LIST}    hex    0, 1, 7, 255
+
+Too big or small hex
+    [Template]    Creating bytes should fail
+    ${BIG LIST}      hex    Hex value '100000000' cannot be represented as a byte.
+    ${SMALL LIST}    hex    Hex value '-1' cannot be represented as a byte.
+
+Invalid hex
+    [Template]    Creating bytes should fail
+    ff hello!    hex     'he' cannot be converted to an integer: ValueError: *
+
+Binary without spaces
+    00000000                     bin   0
+    0000000000000001             bin   0, 1
+    000000110000111111111111     bin   3, 15, 255
+
+Binary with whitespace
+    0000 0000                    bin   0
+    00 00 00 00 00 00 00 01      bin   0, 1
+    0 0 0 0 0 0 1 1 0000 1111    bin   3, 15
+
+Binary requires input to be multiple of 8
+    [Template]    Creating bytes should fail
+    00000000111111110    bin    Expected input to be multiple of 8.
+    0000 0000 1111       bin    Expected input to be multiple of 8.
+
+Binary as list
+    ${BIN LIST}    bin    0, 1, 7, 255
+
+Invalid binary
+    [Template]    Creating bytes should fail
+    hello!!!            bin    'hello!!!' cannot be converted to an integer: ValueError: *
+    0000000100000002    bin    '00000002' cannot be converted to an integer: ValueError: *
+
+Too big or small binary
+    [Template]    Creating bytes should fail
+    ${BIG LIST}         bin    Binary value '100000000' cannot be represented as a byte.
+    ${SMALL LIST}       bin    Binary value '-1' cannot be represented as a byte.
+
+*** Keywords ***
+Correct bytes should be created
+    [Arguments]    ${input}    ${type}    ${expected}
+    ${bytes} =    Convert To Bytes    ${input}    ${type}
+    Bytes should be equal to    ${bytes}    ${expected}
+
+Bytes should be equal to
+    [Arguments]    ${bytes}    ${expected}
+    ${expected} =    Evaluate    bytes(bytearray(int(i) for i in [${expected}]))
+    Should Be Equal    ${bytes}   ${expected}
+    Should Be Byte String    ${bytes}
+
+Creating bytes should fail
+    [Arguments]    ${input}    ${type}    ${error}
+    Run Keyword And Expect Error    Creating bytes failed: ${error}
+    ...    Convert To Bytes    ${input}    ${type}

data/vendor/robot/atest/testdata/standard_libraries/builtin/converter.robot

@@ -0,0 +1,220 @@
+*** Settings ***
+Variables       numbers_to_convert.py
+
+*** Test Cases ***
+Convert To Integer
+    [Documentation]    FAIL STARTS: 'MyObject' cannot be converted to an integer: ZeroDivisionError:
+    [Template]    Test Convert To Integer
+    1                    1
+    -42                  -42
+    10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+    ...                  10**100
+    ${OBJECT}            42
+    ${OBJECT_FAILING}    This fails!
+
+Convert To Integer With Java Objects
+    [Documentation]    FAIL STARTS: 'foobar' cannot be converted to an integer: ValueError:
+    [Template]    Test Convert To Integer
+    ${JAVA_STRING_INT}
+    ${JAVA_INTEGER}
+    ${JAVA_LONG}
+    ${JAVA_SHORT}
+    ${JAVA_FLOAT}
+    ${JAVA_DOUBLE}
+    ${JAVA_STRING_INVALID}    This fails!
+
+Convert To Integer With Base
+    [Documentation]    FAIL STARTS: 'A' cannot be converted to an integer: ValueError:
+    [Template]    Test Convert To Integer
+    10           10        10
+    A            10        16
+    -10          -8        ${8}
+    +10          8         ${8}
+    10           2         2
+    -FF 00       -65280    16
+    1010 1010    170       2
+    A            fails
+
+Convert To Integer With Invalid Base
+    [Documentation]    FAIL STARTS: '1' cannot be converted to an integer: 'invalid' cannot be converted to an integer: ValueError:
+    Convert To Integer    1    invalid
+
+Convert To Integer With Embedded Base
+    [Documentation]    FAIL STARTS: '0xXXX' cannot be converted to an integer: ValueError:
+    [Template]    Test Convert To Integer
+    0xf00           3840
+    -0XF00          -3840
+    0b10            2
+    -0B10           -2
+    +0B10           2
+    0B10            2832    base=16    # Explicit base wins
+    0o101           65
+    0O102           66
+    - 0x FF 00      -65280
+    + 0x FF 00      65280
+    0b 1010 1010    170
+    0xXXX           fails
+
+Convert To Integer With Base And Java Objects
+    [Documentation]    FAIL STARTS: 'F00' cannot be converted to an integer: ValueError:
+    [Template]    Test Convert To Integer
+    ${JAVA_STRING_HEX}            3840   16
+    ${JAVA_STRING_EMBEDDED_BASE}    3840
+    ${JAVA_STRING_HEX}            fails    8
+
+Convert To Binary
+    [Template]    Test Convert To Binary
+    0             0
+    1             ${1}
+    -10           ${-2}
+    0b10          2        prefix=0b
+    -0b10         -2       prefix=0b
+    0b10          +2       prefix=0b
+    00001000      10       base=8     length=8
+    11111111      0xFF
+    -11111111     -0xFF
+    11111111      +0xFF
+    -100000000    -100     base=16    length=2
+    B0101         101      base=2     prefix=B    length=4
+
+Convert To Octal
+    [Template]    Test Convert To Octal
+    0            0
+    1            ${1}
+    -2           ${-2}
+    0o10         8            prefix=0o
+    -0o10        -8           prefix=0o
+    0o10         +8           prefix=0o
+    00001000     200          base=16    length=8
+    52746757     +0xABCDEF    length=5
+    -52746757    -0xABCDEF    length=5
+    xXx007       111          base=2     prefix=xXx    length=3
+
+Convert To Hex
+    [Template]    Test Convert To Hex
+    0          0
+    1          ${1}
+    -2         ${-2}
+    0xA        10       prefix=0x    length=0
+    -0xA       -10      prefix=0x    length=0
+    0xA        +0o12    prefix=0x    length=0
+    0000abcd   ABCD     base=16      length=8     lowercase=yes
+    -0A0a      -10      base=10      prefix=0A    lowercase=please    length=2
+
+Convert To Number
+    [Documentation]    FAIL REGEXP: ^'MyObject' cannot be converted to a floating point number: (Attribute|Type)Error: .*$
+    [Template]    Test Convert To Number
+    -10.000              -10
+    ${OBJECT}            42.0
+    ${OBJECT_FAILING}    This fails!
+
+Convert To Number With Java Objects
+    [Documentation]    FAIL STARTS: 'foobar' cannot be converted to a floating point number: ValueError:
+    [Template]    Test Convert To Number
+    ${JAVA_STRING_INT}        1.0
+    ${JAVA_STRING_FLOAT}      1.1
+    ${JAVA_INTEGER}           1.0
+    ${JAVA_LONG}              1.0
+    ${JAVA_SHORT}             1.0
+    ${JAVA_FLOAT}             1.1
+    ${JAVA_DOUBLE}            1.1
+    ${JAVA_STRING_INVALID}    This fails!
+
+Convert To Number With Precision
+    [Documentation]    FAIL STARTS: 'invalid' cannot be converted to an integer: ValueError:
+    [Template]    Test Convert To Number With Precision
+    1.01      0          1
+    1.02      ${0}       1
+    1.03      ${NONE}    1.03
+    1.14      1          1.1
+    9.1      -1          10
+    1         invalid    This fails!
+
+Numeric conversions with long types
+    [Template]    Numeric conversions with long types
+    # 0x8000000000000000 == sys.maxint+1 on 64bit machines
+    Convert To Integer    0                     0
+    Convert To Integer    42                    42
+    Convert To Integer    0x8000000000000000    9223372036854775808
+    Convert To Hex        0                     0
+    Convert To Hex        42                    2A
+    Convert To Hex        0x8000000000000000    8000000000000000
+    Convert To Octal      0                     0
+    Convert To Octal      42                    52
+    Convert To Octal      0x8000000000000000    1000000000000000000000
+    Convert To Binary     0                     0
+    Convert To Binary     42                    101010
+    Convert To Binary     0x8000000000000000    1000000000000000000000000000000000000000000000000000000000000000
+
+Convert To String
+    ${int42} =    Convert To Integer    42
+    Should Not Be Equal    ${int42}    42
+    ${str42} =    Convert To String    ${int42}
+    Should Be Equal    ${str42}    42
+
+Convert To Boolean
+    ${True} =    Convert To Boolean    True
+    ${False} =    Convert To Boolean    false
+    Should Be True    ${True} == True
+    Should Be True    ${False} == False
+    ${one} =    Convert To Integer    1
+    ${zero} =    Convert To Integer    0
+    ${True} =    Convert To Boolean    ${one}
+    ${False} =    Convert To Boolean    ${zero}
+    Should Be True    ${True} == True
+    Should Be True    ${False} == False
+
+Create List
+    ${list} =    Create List    hello    world
+    Should Be True    ${list} == ['hello','world']
+    @{list} =    Create List    hello    world
+    Should Be Equal    @{list}[0]    hello
+    Should Be Equal    @{list}[1]    world
+    ${one_item} =    Create List    one item
+    Should Be True    ${one_item} == ['one item']
+    ${empty} =    Create List
+    Should Be True    ${empty} == [ ]
+    ${int_one} =    Convert To Number    1
+    ${mixed} =    Create List    one    ${int_one}
+    Should Be True    ${mixed} == ['one', 1]
+
+*** Keywords ***
+Test Convert To Integer
+    [Arguments]    ${item}    ${exp}=1    ${base}=
+    ${act} =    Convert To Integer    ${item}    ${base}
+    ${exp} =    Evaluate    ${exp}
+    Should Be Equal    ${act}    ${exp}
+
+Test Convert To Binary
+    [Arguments]    ${exp}    ${item}    ${base}=    ${prefix}=    ${length}=
+    ${act} =    Convert To Binary    ${item}    base=${base}
+    ...    prefix=${prefix}    length=${length}
+    Should Be Equal    ${act}    ${exp}
+
+Test Convert To Octal
+    [Arguments]    ${exp}    ${item}    ${base}=    ${prefix}=    ${length}=
+    ${act} =    Convert To Octal    ${item}    base=${base}
+    ...    prefix=${prefix}    length=${length}
+    Should Be Equal    ${act}    ${exp}
+
+Test Convert To Hex
+    [Arguments]    ${exp}    ${item}    ${base}=    ${prefix}=    ${length}=    ${lowercase}=
+    ${act} =    Convert To Hex    ${item}    base=${base}
+    ...    prefix=${prefix}    length=${length}    lowercase=${lowercase}
+    Should Be Equal    ${act}    ${exp}
+
+Test Convert To Number
+    [Arguments]    ${item}    ${exp}=1.0
+    ${act} =    Convert To Number    ${item}
+    Should Be True    round(${act}, 6) == ${exp}
+
+Test Convert To Number With Precision
+    [Arguments]    ${item}    ${precision}    ${exp}
+    ${act} =    Convert To Number    ${item}    ${precision}
+    Should Be True    round(${act}, 6) == ${exp}
+
+Numeric conversions with long types
+    [Arguments]    ${keyword}    ${input}    ${expected}
+    ${input} =    Evaluate    (long if sys.version_info[0] == 2 else int)(${input})    modules=sys
+    ${result} =    Run Keyword    ${keyword}    ${input}
+    Should Be Equal As Strings    ${result}    ${expected}