QUnit.qm.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
// @file QUnit.qm Qore user module for automatic testing






namespace QUnit {}

class QUnit::AbstractTestResult {

public:
    public :
        string m_type;
        *string m_subType;
        any m_value;

public:
    constructor(string type);

    constructor(string type, string subType);

    // test
    abstract public bool equals(AbstractTestResult r);
    abstract public string toString();
};

class QUnit::TestResultSuccess : public QUnit::AbstractTestResult {

public:
    constructor() ;


    public bool equals(QUnit::AbstractTestResult r);


    public string toString();

};

class QUnit::TestResultFailure : public QUnit::AbstractTestResult {

public:
    private :
        *string m_detail;

public:

    constructor() ;


    constructor(string s) ;


    public bool equals(QUnit::AbstractTestResult r);


    public string toString();

};

class QUnit::TestResultValue : public QUnit::AbstractTestResult {

public:
    constructor(any value) ;


    public bool equals(QUnit::AbstractTestResult r);


    public string toString();

};

class QUnit::TestResultPartialHashMatch : public QUnit::AbstractTestResult {

public:
    constructor(hash value) ;


    public bool equals(QUnit::AbstractTestResult r);


    public string toString();

};

class QUnit::TestResultExceptionType : public QUnit::AbstractTestResult {

public:
    public :
        string m_exceptionType;

public:


    constructor(string exceptionType) ;


    private constructor(string exceptionType, string subType) ;


    public bool equals(QUnit::AbstractTestResult r);


    public string toString();

};

class QUnit::TestResultExceptionDetail : public QUnit::TestResultExceptionType {

public:
    private :
        string m_exceptionDetail;

public:


    constructor(string exceptionType, string exceptionDetail) ;


    public bool equals(QUnit::AbstractTestResult r);


    public string toString();


    string getDetail();

};

class QUnit::TestResultExceptionRegexp : public QUnit::TestResultExceptionType {

public:
    private :
        string m_exceptionRegexp;

public:

    constructor(string exceptionType, string exceptionRegexp) ;


    public bool equals(QUnit::AbstractTestResult r);


    public string toString();

};

class QUnit::TestResultExceptionSubstring : public QUnit::TestResultExceptionRegexp {

public:
    constructor(string exceptionType, string exceptionSubstring) ;


    public string toString();

};

class QUnit::TestCase {

public:
    private :
        string m_name;

        code m_code;

        *list m_args;

        int num_asserts = 0;

        int num_asserts_ok = 0;

        int num_asserts_skip = 0;

public:

    constructor(string name, code code, *softlist args);


    run(QUnit::Test test);


      static *string getStackPos(list stack);

      static string getPos(hash ex);

    checkException(QUnit::Test test, hash e);


    string getName();


    incAssertions();


    incAssertionsOk();


    incAssertionsSkip();


    int getAssertionCount();


    int getAssertionOkCount();


    int getAssertionSkipCount();


    setupThread();


    restoreThread();


    rename(string n_name);

};

class QUnit::TestReporter {

public:
    private :
        const PLAINQUIET = 0;
        const PLAIN = 1;
        const JUNIT = 2;

        const OUT_TYPES = (
            "plainquiet" : PLAINQUIET,
            "plain" : PLAIN,
            "junit" : JUNIT,
        );

        const RESULT_TYPE_DESCRIPTION = (
            TEST_SUCCESS : ("desc": "Success", "junittag" : NOTHING), // Success does not have a junit child tag
            TEST_FAILURE : ("desc": "FAILURE", "junittag" : "failure"),
            TEST_ERROR   : ("desc": "ERROR", "junittag" : "error"),
            TEST_SKIPPED : ("desc": "Skipped", "junittag" : "skipped"),
        );

        const OffsetColumn = 20;

        hash m_printMethods;

        list m_results = ();
        int m_output;
        *string m_comment;


        hash m_options;

        string m_name;
        string m_version;

        int num_asserts = 0;

        int num_asserts_ok = 0;

        int num_asserts_skip = 0;

public:

    public :
        const Opts = (
            "help"    : "h,help",
            "verbose" : "v,verbose:i+",
            "quiet"   : "q,quiet",
            "format"  : "format=s",
            );

        const TEST_SUCCESS = 0;
        const TEST_FAILURE = 1;
        const TEST_ERROR = 2;
        const TEST_SKIPPED = 3;

public:

    private printOption(string left, string right, int offset = OffsetColumn);


    private usageIntern(int offset = OffsetColumn);


    private usage();


    private processOptions(reference p_argv);



    constructor(string name, string version, *reference p_argv, hash opts = Opts);


    private callPrinterFunction(string type, *softlist args);


    private printHeader() { callPrinterFunction("header"); }
    private printSummary() { callPrinterFunction("summary"); }
    private printTestReport(hash testcase) { callPrinterFunction("testreport", testcase); }

    private printPlaintextHeader();


    private printPlaintextSummary();


    private printPlaintextOneTest(hash testcase);


    private printJunitSummary();


    int errors();


    int skipped();


    int testCount();


    addTestResult(TestCase tc, int success, *string error, *string pos, *string detail);

};

class QUnit::Test : public QUnit::TestReporter {

public:
    private :
        list testCases = ();

        static QUnit::TestResultSuccess RESULT_SUCCESS = new QUnit::TestResultSuccess();
        static QUnit::TestResultFailure RESULT_FAILURE = new QUnit::TestResultFailure();

public:

    constructor(string name, string version, *reference p_argv, *hash opts) ;


    globalSetUp() {}

    globalTearDown() {}

    setUp() {}

    tearDown() {}

    *string getEnv(string key, *string def);



    addTestCase(string name, code call, *softlist args);



    addTestCase(QUnit::TestCase tc);


    private string printUnexpectedData(any exp, any act, *bool neg, *bool soft_comparisons);


    private string shorten(any value);


    private compare(any v1, any v2, reference out, string path, *bool soft_comparisons);


    private compareHashes(hash h1, hash h2, reference out, string path = "", *bool soft_comparisons);


    private compareLists(list l1, list l2, reference out, string path = "", *bool soft_comparisons);


//######## Assertions & test control functions


    public any testAssertionValue(*string name, any actual, any expected);



    public assertEqSoft(any expected, any actual, *string name);



    public assertEq(any expected, any actual, *string name);



    public assertFloatEq(float expected, float actual, float epsilon = 0.0000000001, *string name);



    public assertNumberEq(number expected, number actual, number epsilon = 0.0000000001, *string name);



    public assertTrue(any actual, *string name);



    public assertFalse(any actual, *string name);



    public assertThrows(string expectedErr, *string expectedDesc, code theCode, *softlist args, *string name);



    public assertThrows(string expectedErr, code theCode, *softlist args, *string name);



    public assertSkip (*string name);


    TestCase getTestCase(string meth);



    public fail(*string msg);



    public testNullAssertion(string name, code condition, *softlist args);



    public any testAssertion(string name, code condition, *softlist args, int expectedResultValue);



    public any testAssertion(string name, code condition, *softlist args, float expectedResultValue);



    public any testAssertion(string name, code condition, *softlist args, number expectedResultValue);



    public any testAssertion(string name, code condition, *softlist args, bool expectedResultValue);



    public any testAssertion(string name, code condition, *softlist args, string expectedResultValue);



    public any testAssertion(string name, code condition, *softlist args, date expectedResultValue);



    public any testAssertion(string name, code condition, *softlist args, binary expectedResultValue);



    public any testAssertion(string name, code condition, *softlist args, hash expectedResultValue);



    public any testAssertion(string name, code condition, *softlist args, list expectedResultValue);



    public any testAssertion(string name, code condition, *softlist args, QUnit::AbstractTestResult expectedResult = new QUnit::TestResultSuccess());


    private any testAssertionIntern(TestCase tc, string name, QUnit::AbstractTestResult actualResult, QUnit::AbstractTestResult expectedResult, any ret, *string pos);



    public testSkip(string reason);


//######## Test conditions passable to test assertions


    bool equals(any a, any b);



    bool notEquals(any a, any b);



    bool regexpMatches(string s, string regexp);



    bool equalsIterated(AbstractIterator a, AbstractIterator b);


//######## Main function and test running helpers

    int main();


      static string getAssertionName(*string name);
};

class QUnit::DependencyInjectedTest : public QUnit::Test {

public:
    private :
        *string m_testedFile;
        Program m_child;
        *hash m_modules;

        static bool instantiated = False;

public:

    constructor(string name, string version, *reference p_argv, *hash opts) ;


    setScriptPath(*string testedFile);


    setUp() { }
    tearDown() { }

    private Program createInjectedProgram();


    abstract performInjections(Program p);
    abstract performModuleInjections();

    private injectIntoModule(string module);


    destructor();


    int main();

};

class QUnit::DependencyInjectedTestRunner : public QUnit::Test {

public:
    public setScriptPath(*string testedFile) {}
    private injectIntoModule(string module) {}

    constructor(string name, string version, *reference p_argv, *hash opts) ;

};