busser-robot 0.1.3

data/vendor/robot/atest/testresources/listeners/listeners.py

@@ -0,0 +1,139 @@
+import os
+
+from robot.libraries.BuiltIn import BuiltIn
+
+
+class ListenSome:
+    ROBOT_LISTENER_API_VERSION = '2'
+
+    def __init__(self):
+        outpath = os.path.join(os.getenv('TEMPDIR'), 'listen_some.txt')
+        self.outfile = open(outpath, 'w')
+
+    def startTest(self, name, attrs):
+        self.outfile.write(name + '\n')
+
+    def endSuite(self, name, attrs):
+        self.outfile.write(attrs['statistics'] + '\n')
+
+    def close(self):
+        self.outfile.close()
+
+
+class WithArgs(object):
+    ROBOT_LISTENER_API_VERSION = '2'
+
+    def __init__(self, arg1, arg2='default'):
+        outpath = os.path.join(os.getenv('TEMPDIR'), 'listener_with_args.txt')
+        outfile = open(outpath, 'a')
+        outfile.write("I got arguments '%s' and '%s'\n" % (arg1, arg2))
+        outfile.close()
+
+
+class SuiteAndTestCounts(object):
+    ROBOT_LISTENER_API_VERSION = '2'
+    exp_data = {
+        'Subsuites & Subsuites2': ([], ['Subsuites', 'Subsuites2'], 5),
+        'Subsuites':              ([], ['Sub1', 'Sub2'], 2),
+        'Sub1':                   (['SubSuite1 First'], [], 1),
+        'Sub2':                   (['SubSuite2 First'], [], 1),
+        'Subsuites2':             ([], ['Sub.Suite.4', 'Subsuite3'], 3),
+        'Subsuite3':              (['SubSuite3 First', 'SubSuite3 Second'], [], 2),
+        'Sub.Suite.4':            (['Test From Sub Suite 4'], [], 1)
+        }
+
+    def start_suite(self, name, attrs):
+        data = attrs['tests'], attrs['suites'], attrs['totaltests']
+        if data != self.exp_data[name]:
+            raise RuntimeError('Wrong tests or suites in %s, %s != %s' %
+                               (name, self.exp_data[name], data))
+
+
+class KeywordType(object):
+    ROBOT_LISTENER_API_VERSION = '2'
+
+    def start_keyword(self, name, attrs):
+        expected = self._get_expected_kw_type(name, attrs['args'])
+        if attrs['type'] != expected:
+            raise RuntimeError("Wrong keyword type '%s', expected '%s'."
+                               % (attrs['type'], expected))
+
+    def _get_expected_kw_type(self, name, args):
+        if 'IN' in name:
+            return 'For'
+        if '=' in name:
+            return 'For Item'
+        expected = args[0] if name.startswith('BuiltIn.') else name
+        return {'Suite Setup': 'Setup', 'Suite Teardown': 'Teardown',
+                'Test Setup': 'Setup', 'Test Teardown': 'Teardown',
+                'Keyword Teardown': 'Teardown'}.get(expected, 'Keyword')
+
+    end_keyword = start_keyword
+
+
+class KeywordExecutingListener(object):
+    ROBOT_LISTENER_API_VERSION = '2'
+
+    def start_suite(self, name, attrs):
+        self._start(name)
+
+    def end_suite(self, name, attrs):
+        self._end(name)
+
+    def start_test(self, name, attrs):
+        self._start(name)
+
+    def end_test(self, name, attrs):
+        self._end(name)
+
+    def _start(self, name):
+        self._run_keyword('Start %s' % name)
+
+    def _end(self, name):
+        self._run_keyword('End %s' % name)
+
+    def _run_keyword(self, arg):
+        BuiltIn().run_keyword('Log', arg)
+
+
+class SuiteSource(object):
+    ROBOT_LISTENER_API_VERSION = '2'
+
+    def __init__(self):
+        self._started = 0
+        self._ended = 0
+
+    def start_suite(self, name, attrs):
+        self._started += 1
+        self._test_source(name, attrs['source'])
+
+    def end_suite(self, name, attrs):
+        self._ended += 1
+        self._test_source(name, attrs['source'])
+
+    def _test_source(self, suite, source):
+        default = os.path.isfile
+        verifier = {'Root': lambda source: source == '',
+                    'Subsuites': os.path.isdir}.get(suite, default)
+        if (source and not os.path.isabs(source)) or not verifier(source):
+            raise AssertionError("Suite '%s' has wrong source '%s'."
+                                 % (suite, source))
+
+    def close(self):
+        if not (self._started == self._ended == 5):
+            raise AssertionError("Wrong number of started (%d) or ended (%d) "
+                                 "suites. Expected 5."
+                                 % (self._started, self._ended))
+
+
+class Messages(object):
+    ROBOT_LISTENER_API_VERSION = '2'
+
+    def __init__(self, path):
+        self.output = open(path, 'w')
+
+    def log_message(self, msg):
+        self.output.write('%s: %s\n' % (msg['level'], msg['message']))
+
+    def close(self):
+        self.output.close()

data/vendor/robot/atest/testresources/listeners/module_listener.py

@@ -0,0 +1,67 @@
+import os
+
+outpath = os.path.join(os.getenv('TEMPDIR'), 'listen_by_module.txt')
+OUTFILE = open(outpath, 'w')
+ROBOT_LISTENER_API_VERSION = 2
+
+
+def start_suite(name, attrs):
+    metastr = ' '.join('%s: %s' % (k, v) for k, v in attrs['metadata'].items())
+    OUTFILE.write("SUITE START: %s (%s) '%s' [%s]\n"
+                  % (name, attrs['id'], attrs['doc'], metastr))
+
+def start_test(name, attrs):
+    tags = [str(tag) for tag in attrs['tags']]
+    OUTFILE.write("TEST START: %s (%s) '%s' %s crit: %s\n"
+                  % (name, attrs['id'], attrs['doc'], tags,  attrs['critical']))
+
+def start_keyword(name, attrs):
+    args = [str(arg) for arg in attrs['args']]
+    if attrs['assign']:
+        assign = '%s = ' % ', '.join(attrs['assign'])
+    else:
+        assign = ''
+    OUTFILE.write("KW START: %s%s %s\n" % (assign, name, args))
+
+def log_message(message):
+    msg, level = message['message'], message['level']
+    if level != 'TRACE' and 'Traceback' not in msg:
+        OUTFILE.write('LOG MESSAGE: [%s] %s\n' % (level, msg))
+
+def message(message):
+    msg, level = message['message'], message['level']
+    if 'Settings' in msg:
+        OUTFILE.write('Got settings on level: %s\n' % level)
+
+def end_keyword(name, attrs):
+    OUTFILE.write("KW END: %s\n" % (attrs['status']))
+
+def end_test(name, attrs):
+    if attrs['status'] == 'PASS':
+        OUTFILE.write('TEST END: PASS crit: %s\n' % attrs['critical'])
+    else:
+        OUTFILE.write("TEST END: %s %s crit: %s\n"
+                      % (attrs['status'], attrs['message'], attrs['critical']))
+
+def end_suite(name, attrs):
+    OUTFILE.write('SUITE END: %s %s\n' % (attrs['status'], attrs['statistics']))
+
+def output_file(path):
+    _out_file('Output', path)
+
+def report_file(path):
+    _out_file('Report', path)
+
+def log_file(path):
+    _out_file('Log', path)
+
+def debug_file(path):
+    _out_file('Debug', path)
+
+def _out_file(name, path):
+    assert os.path.isabs(path)
+    OUTFILE.write('%s: %s\n' % (name, os.path.basename(path)))
+
+def close():
+    OUTFILE.write('Closing...\n')
+    OUTFILE.close()

data/vendor/robot/atest/testresources/listeners/unsupported_listeners.py

@@ -0,0 +1,19 @@
+import sys
+
+
+def close():
+    sys.exit('This should not be called')
+
+
+class V1ClassListener:
+    ROBOT_LISTENER_API_VERSION = 1
+
+    def close(self):
+        close()
+
+
+class InvalidVersionClassListener:
+    ROBOT_LISTENER_API_VERSION = 'kekkonen'
+
+    def close(self):
+        close()

data/vendor/robot/atest/testresources/res_and_var_files/cli.yaml

@@ -0,0 +1 @@
+yaml file from cli: woot!

data/vendor/robot/atest/testresources/res_and_var_files/different_variables.py

@@ -0,0 +1,3 @@
+list1 = [1, 2, 3, 4, 'foo', 'bar']
+dictionary1 = {'a': 1}
+dictionary2 = {'a': 1, 'b': 2}

data/vendor/robot/atest/testresources/res_and_var_files/pythonpath.yaml

@@ -0,0 +1 @@
+yaml file in pythonpath:    true

data/vendor/robot/atest/testresources/res_and_var_files/resource_in_pythonpath.robot

@@ -0,0 +1,8 @@
+*** Setting ***
+
+*** Variable ***
+${PPATH_RESFILE}    Variable from resource file in PYTHONPATH
+
+*** Keyword ***
+PPATH KW
+    Log    Keyword from resource in PYTHONPATH

data/vendor/robot/atest/testresources/res_and_var_files/resvar_subdir/resource_in_pythonpath_2.robot

@@ -0,0 +1,8 @@
+*** Setting ***
+
+*** Variable ***
+${PPATH_RESFILE_2}    Variable from resource file in PYTHONPATH (version 2)
+
+*** Keyword ***
+PPATH KW 2
+    Log    Keyword from resource in PYTHONPATH (version 2)

data/vendor/robot/atest/testresources/res_and_var_files/resvar_subdir/variables_in_pythonpath_2.py

@@ -0,0 +1,3 @@
+def get_variables(*args):
+    return { 'PPATH_VARFILE_2' : ' '.join(args),
+             'LIST__PPATH_VARFILE_2_LIST' : args }

data/vendor/robot/atest/testresources/res_and_var_files/variables_in_pythonpath.py

@@ -0,0 +1 @@
+PPATH_VARFILE = "Variable from variable file in PYTHONPATH"

data/vendor/robot/atest/testresources/testlibs/ArgDocDynamicJavaLibrary.java

@@ -0,0 +1,61 @@
+public class ArgDocDynamicJavaLibrary {
+
+    public ArgDocDynamicJavaLibrary() {}
+
+    public ArgDocDynamicJavaLibrary(String name) {}
+
+    public String[] getKeywordNames() {
+        return new String[] {"Java No Arg",
+                             "Java One Arg",
+                             "Java One or Two Args",
+                             "Java Many Args",
+                             "Unsupported Java Kwargs",
+                             "Invalid Java Args",
+                             "Invalid Java Doc"};
+    }
+
+    public Object runKeyword(String name, Object[] args) {
+        System.out.print("Executed keyword " + name + " with ");
+        if (args.length == 0) {
+            System.out.print("no ");
+        }
+        System.out.print("arguments");
+        for (Object arg : args) {
+            System.out.print(' ' + (String)arg);
+        }
+        System.out.println();
+        return null;
+    }
+
+    public String getKeywordDocumentation(String name) {
+        if (name.equals("Invalid Java Doc"))
+            throw new RuntimeException("Get doc failure");
+        if (name.equals("__intro__"))
+            return "Dynamic Java intro doc.";
+        else if (name.equals("__init__"))
+            return "Dynamic Java init doc.";
+        return "Keyword documentation for " + name;
+    }
+
+    public String[] getKeywordArguments(String name) {
+        if (name.equals("Java No Arg"))
+            return new String[0];
+        if (name.equals("Java One Arg"))
+            return new String[] {"arg"};
+        if (name.equals("Java One or Two Args"))
+            return new String[] {"arg", "default=default"};
+        if (name.equals("Java Many Args"))
+            return new String[] {"*args"};
+        if (name.equals("Unsupported Java Kwargs"))
+            // Must raise a DataError,
+            // because runKeyword has no kwargs support:
+            return new String[] {"**kwargs"};
+        if (name.equals("Invalid Java Args"))
+            throw new RuntimeException("Get args failure");
+        return null;
+    }
+
+    public String[] getKeywordTags(String name) {
+        return new String[] {"tag", name};
+    }
+}

data/vendor/robot/atest/testresources/testlibs/ArgDocDynamicJavaLibraryWithKwargsSupport.java

@@ -0,0 +1,26 @@
+import java.util.*;
+
+public class ArgDocDynamicJavaLibraryWithKwargsSupport extends ArgDocDynamicJavaLibrary {
+
+    public String[] getKeywordNames() {
+        List<String> names = new ArrayList<String>(Arrays.asList(super.getKeywordNames()));
+        names.add("Java Kwargs");
+        names.add("Java Varargs and Kwargs");
+        return names.toArray(new String[0]);
+    }
+
+    public Object runKeyword(String name, List<Object> args, Map<String, Object> kwargs) {
+        List<Object> superArgs = new ArrayList<Object>(args);
+        for (String key: kwargs.keySet())
+            superArgs.add(key+":"+kwargs.get(key).toString());
+        return super.runKeyword(name, superArgs.toArray());
+    }
+
+    public String[] getKeywordArguments(String name) {
+        if (name.equals("Java Kwargs"))
+            return new String[] {"**kwargs"};
+        if (name.equals("Java Varargs and Kwargs"))
+            return new String[] {"*args", "**kwargs"};
+        return super.getKeywordArguments(name);
+    }
+}

data/vendor/robot/atest/testresources/testlibs/ArgTypeCoercion.java

@@ -0,0 +1,73 @@
+public class ArgTypeCoercion {
+
+    public int myInt;
+    public boolean myBool;
+
+    public ArgTypeCoercion(int myInt, boolean myBool) {
+        this.myInt = myInt;
+        this.myBool = myBool;
+    }
+
+    public void noArgument() {}
+
+    public void intArgument(int arg) {
+        String judgement = "";
+        if (arg > 0) judgement = "greater than 0.";
+        else if (arg == 0) judgement = "0.";
+        else judgement = "smaller than 0.";
+        System.out.println("Number " + arg + " is " + judgement);
+    }
+
+    public void booleanArgument(boolean arg) {
+        if (arg)
+            System.out.println("It is true!");
+        else
+            System.out.println("It is false!");
+    }
+
+    public void doubleArgument(double arg) {
+        if (arg > 0)
+            System.out.println("Got a positive argument");
+    }
+
+    public void floatArgument(float arg) {
+        if (arg > 0)
+            System.out.println("Got a positive argument");
+    }
+
+    public String coercableKeyword(double arg1) {
+        return coercableKeyword(arg1, 0, false);
+    }
+
+    public String coercableKeyword(double arg1, int arg2) {
+        return coercableKeyword(arg1, arg2, false);
+    }
+
+    public String coercableKeyword(double arg1, int arg2, boolean arg3) {
+        doubleArgument(arg1);
+        intArgument(arg2);
+        booleanArgument(arg3);
+        return "Got: " + arg1 + " and " + arg2 + " and " + arg3;
+    }
+
+    public void coercableKeywordWithCompatibleTypes(int arg1, Short arg2, Boolean arg3, float arg4) {}
+
+    public void coercableKeywordWithCompatibleTypes(byte arg1, Long arg2, boolean arg3, Float arg4) {}
+
+    public void coercableKeywordWithCompatibleTypes(Integer arg1, long arg2, boolean arg3, Double arg4) {}
+
+    public void unCoercableKeyword(int arg1, boolean arg2) {}
+
+    public void unCoercableKeyword(boolean arg1, int arg2) {}
+
+    public void coercableAndUnCoercableArgs(boolean arg1, boolean arg2, Long arg3, String arg4) {}
+
+    public void coercableAndUnCoercableArgs(String arg1, boolean arg2, Long arg3, String arg4) {}
+
+    public void coercableAndUnCoercableArgs(int arg1, boolean arg2, Long arg3) {}
+
+    public void coercableAndUnCoercableArgs(int arg1, boolean arg2, Long arg3, boolean arg4) {}
+
+    public void primitiveAndArray(int arg1, int[] arg2) {}
+
+}

data/vendor/robot/atest/testresources/testlibs/ArgumentTypes.java

@@ -0,0 +1,202 @@
+import java.util.*;
+
+
+public class ArgumentTypes {
+
+    public int handler_count = 41;
+
+    /* Primitive types (8) */
+
+    public void byte1(byte i) {
+        System.out.println(i);
+    }
+    public void short1(short i) {
+        System.out.println(i);
+    }
+    public void integer1(int i) {
+        System.out.println(i);
+    }
+    public void long1(long i) {
+        System.out.println(i);
+    }
+    public void float1(float f) {
+        System.out.println(f);
+    }
+    public void double1(double d) {
+        System.out.println(d);
+    }
+    public void boolean1(boolean b) {
+        if (b)
+            System.out.println("Oh Yes!!");
+        else
+            System.out.println("Oh No!!");
+    }
+    public void char1(char c) {
+        System.out.println(c);
+    }
+
+    /* java.lang types (10) */
+
+    public void byte2(Byte i) {
+        System.out.println(i);
+    }
+    public void short2(Short i) {
+        System.out.println(i);
+    }
+    public void integer2(Integer i) {
+        System.out.println(i);
+    }
+    public void long2(Long i) {
+        System.out.println(i);
+    }
+    public void float2(Float f) {
+        System.out.println(f);
+    }
+    public void double2(Double d) {
+        System.out.println(d);
+    }
+    public void boolean2(Boolean b) {
+        if (b.booleanValue())
+            System.out.println("Oh Yes!!");
+        else
+            System.out.println("Oh No!!");
+    }
+    public void char2(Character c) {
+        System.out.println(c);
+    }
+    public void string(String s) {
+        System.out.println(s);
+    }
+    public void object(Object o) {
+        try {
+            System.out.println(o.toString());
+        }
+        catch (NullPointerException n) {
+            System.out.println("null");
+        }
+    }
+
+    /* Primitive arrays (8) */
+
+    public void byte1_array(byte[] ia) {
+        for (int i=0; i<ia.length; i++) {
+            this.byte1(ia[i]);
+        }
+    }
+    public void short1_array(short[] ia) {
+        for (int i=0; i<ia.length; i++) {
+            this.short1(ia[i]);
+        }
+    }
+    public void integer1_array(int[] ia) {
+        for (int i=0; i<ia.length; i++) {
+            this.integer1(ia[i]);
+        }
+    }
+    public void long1_array(long[] ia) {
+        for (int i=0; i<ia.length; i++) {
+            this.long1(ia[i]);
+        }
+    }
+    public void float1_array(float[] fa) {
+        for (int i=0; i<fa.length; i++) {
+            this.float1(fa[i]);
+        }
+    }
+    public void double1_array(double[] da) {
+        for (int i=0; i<da.length; i++) {
+            this.double1(da[i]);
+        }
+    }
+    public void boolean1_array(boolean[] ba) {
+        for (int i=0; i<ba.length; i++) {
+            this.boolean1(ba[i]);
+        }
+    }
+    public void char1_array(char[] ca) {
+        for (int i=0; i<ca.length; i++) {
+            this.char1(ca[i]);
+        }
+    }
+
+    /* java.lang arrays (10) */
+
+    public void byte2_array(Byte[] ia) {
+        for (int i=0; i<ia.length; i++) {
+            this.byte2(ia[i]);
+        }
+    }
+    public void short2_array(Short[] ia) {
+        for (int i=0; i<ia.length; i++) {
+            this.short2(ia[i]);
+        }
+    }
+    public void integer2_array(Integer[] ia) {
+        for (int i=0; i<ia.length; i++) {
+            this.integer2(ia[i]);
+        }
+    }
+    public void long2_array(Long[] ia) {
+        for (int i=0; i<ia.length; i++) {
+            this.long2(ia[i]);
+        }
+    }
+    public void float2_array(Float[] fa) {
+        for (int i=0; i<fa.length; i++) {
+            this.float2(fa[i]);
+        }
+    }
+    public void double2_array(Double[] da) {
+        for (int i=0; i<da.length; i++) {
+            this.double2(da[i]);
+        }
+    }
+    public void boolean2_array(Boolean[] ba) {
+        for (int i=0; i<ba.length; i++) {
+            this.boolean2(ba[i]);
+        }
+    }
+    public void char2_array(Character[] ca) {
+        for (int i=0; i<ca.length; i++) {
+            this.char2(ca[i]);
+        }
+    }
+    public void string_array(String[] sa) {
+        for (int i=0; i<sa.length; i++) {
+            this.string(sa[i]);
+        }
+    }
+    public void object_array(Object[] oa) {
+        for (int i=0; i<oa.length; i++) {
+            this.object(oa[i]);
+        }
+    }
+
+    /* Lists (5) - No element type cast on coercion! */
+
+    public void integer_list(List<Integer> il) {
+        for (int i : il) {
+            this.integer1(i);
+        }
+    }
+    public void double_list(List<Double> dl) {
+        for (double d : dl) {
+            this.double1(d);
+        }
+    }
+    public void boolean_list(List<Boolean> bl) {
+        for (boolean b : bl) {
+            this.boolean1(b);
+        }
+    }
+    public void string_list(List<String> sl) {
+        for (String s : sl) {
+            this.string(s);
+        }
+    }
+    public void object_list(List<Object> ol) {
+        for (Object o : ol) {
+            this.object(o);
+        }
+    }
+}