QUnit.qm.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
/*  QUnit.qm Copyright (C) 2013 - 2023 Qore Technologies, s.r.o.
 
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:
 
    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
*/
 
 
 
 
 
 
 
namespace QUnit {}
 
class QUnit::AbstractTestResult {
 
public:
        string m_type;
        *string m_subType;
        auto m_value;
    constructor(string type);
 
    constructor(string type, string subType);
 
    // test
    abstract  bool equals(AbstractTestResult r);    abstract  string toString();};
 
class QUnit::TestResultSuccess : public QUnit::AbstractTestResult {
 
public:
    constructor() ;
 
 
     bool equals(QUnit::AbstractTestResult r);
 
     string toString();
};
 
class QUnit::TestResultFailure : public QUnit::AbstractTestResult {
 
public:
protected:
        *string m_detail;
 
public:
 
    constructor() ;
 
 
    constructor(string s) ;
 
 
     bool equals(QUnit::AbstractTestResult r);
 
     string toString();
};
 
class QUnit::TestResultValue : public QUnit::AbstractTestResult {
 
public:
    constructor(auto value) ;
 
 
     bool equals(QUnit::AbstractTestResult r);
 
     string toString();
};
 
class QUnit::TestResultPartialHashMatch : public QUnit::AbstractTestResult {
 
public:
    constructor(hash<auto> value) ;
 
 
     bool equals(QUnit::AbstractTestResult r);
 
     string toString();
};
 
class QUnit::TestResultExceptionType : public QUnit::AbstractTestResult {
 
public:
        string m_exceptionType;
 
 
    constructor(string exceptionType) ;
 
 
protected:
     constructor(string exceptionType, string subType) ;
public:
 
 
     bool equals(QUnit::AbstractTestResult r);
 
     string toString();
};
 
class QUnit::TestResultExceptionDetail : public QUnit::TestResultExceptionType {
 
public:
protected:
        string m_exceptionDetail;
 
public:
 
 
    constructor(string exceptionType, string exceptionDetail) ;
 
 
     bool equals(QUnit::AbstractTestResult r);
 
     string toString();
 
    string getDetail();
 
};
 
class QUnit::TestResultExceptionRegexp : public QUnit::TestResultExceptionType {
 
public:
protected:
        string m_exceptionRegexp;
 
public:
 
    constructor(string exceptionType, string exceptionRegexp) ;
 
 
     bool equals(QUnit::AbstractTestResult r);
 
     string toString();
};
 
class QUnit::TestResultExceptionSubstring : public QUnit::TestResultExceptionRegexp {
 
public:
    constructor(string exceptionType, string exceptionSubstring) ;
 
 
     string toString();
};
 
class QUnit::TestCase {
 
public:
protected:
        string m_name;
 
        code m_code;
 
        *list<auto> m_args;
 
        int num_asserts = 0;
 
        int num_asserts_ok = 0;
 
        int num_asserts_skip = 0;
 
        auto saved_tc;
 
public:
 
    constructor(string name, code code, *softlist<auto> args);
 
 
    run(QUnit::Test test);
 
 
      static list<auto> getStackList(list stack, bool ok = False);
 
      static string getPos(hash<auto> ex);
 
    checkException(QUnit::Test test, hash<auto> e);
 
 
    string getName();
 
 
    incAssertions();
 
 
    incAssertionsOk();
 
 
    incAssertionsSkip();
 
 
    int getAssertionCount();
 
 
    int getAssertionOkCount();
 
 
    int getAssertionSkipCount();
 
 
    setupThread();
 
 
    restoreThread();
 
 
    rename(string n_name);
 
};
 
class QUnit::TestReporter {
 
public:
protected:
        const PLAINQUIET = 0;
        const PLAIN = 1;
        const JUNIT = 2;
 
        const OUT_TYPES = ...;
 
 
        const RESULT_TYPE_DESCRIPTION = ...;
 
 
        const OffsetColumn = 20;
 
        hash<string, hash<string, code>> m_printMethods;
 
        list<hash<auto>> m_results = ();
        int m_output;
        *string m_comment;
 
 
        hash<auto> m_options;
 
        string m_name;
        string m_version;
 
        int num_asserts = 0;
 
        int num_asserts_ok = 0;
 
        int num_asserts_skip = 0;
 
        *list<auto> new_argv;
 
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;
 
protected:
     printOption(string left, string right, int offset = OffsetColumn);
public:
 
 
protected:
     usageIntern(int offset = OffsetColumn);
public:
 
 
protected:
     usage();
public:
 
 
protected:
     processOptions(reference<list<string>> p_argv);
public:
 
 
 
    constructor(string name, string version, reference<list<string>> p_argv, hash<auto> opts = Opts);
 
 
 
    constructor(string name, string version, *list<auto> p_argv, hash<auto> opts = Opts);
 
 
protected:
     init(string name, string version, reference<list<string>> p_argv, hash<auto> opts = Opts);
public:
 
 
protected:
     callPrinterFunction(string type, *softlist<auto> args);
public:
 
 
protected:
     printHeader() { callPrinterFunction("header"); }     printSummary() { callPrinterFunction("summary"); }     printTestReport(hash testcase) { callPrinterFunction("testreport", testcase); }
     printPlaintextHeader();
 
     printPlaintextSummary();
 
     printPlaintextOneTest(hash testcase);
 
     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:
protected:
        list<TestCase> testCases();
 
        static QUnit::TestResultSuccess RESULT_SUCCESS = new QUnit::TestResultSuccess();
        static QUnit::TestResultFailure RESULT_FAILURE = new QUnit::TestResultFailure();
 
public:
 
private:
        const QUC_EQ = "eq";
        const QUC_NEQ = "neq";
        const QUC_GT = "gt";
        const QUC_GE = "ge";
        const QUC_LT = "lt";
        const QUC_LE = "le";
        const QUC_RE = "re";
        const QUC_NRE = "nre";
 
        const QUC_Map = ...;
 
 
        const DEFAULT_EPSILON = 0.0000000001;
 
public:
 
    constructor(string name, string version, reference<list<string>> p_argv, *hash<auto> opts) ;
 
 
    constructor(string name, string version, *list<auto> p_argv, *hash<auto> opts) ;
 
 
    globalSetUp() {}
 
    globalTearDown() {}
 
    setUp() {}
 
    tearDown() {}
 
    *string getEnv(string key, *string def);
 
 
 
    addTestCase(string name, code call, *softlist<auto> args);
 
 
 
    addTestCase(QUnit::TestCase tc);
 
 
     string escapeSpecialChars(string str);
 
     string escapeSpecialChars2(string str);
 
     bool diffInSpecialCharsOnly(string a, string b);
 
     string printUnexpectedData(auto exp, auto act, *bool neg, *bool soft_comparisons, *string comparitor);
 
     string shorten(auto value);
 
     compare(auto v1, auto v2, reference<list<string>> out, string path, *bool soft_comparisons);
 
     compareHashes(hash h1, hash h2, reference<list<string>> out, string path = '', *bool soft_comparisons);
 
     compareLists(list<auto> l1, list<auto> l2, reference<list<string>> out, string path = '', *bool soft_comparisons);
 
//######## Assertions & test control functions
 
 
     auto testAssertionValue(*string name, auto actual, auto expected);
 
 
     auto testAssertionValue(*string name, number actual, number expected, number epsilon = DEFAULT_EPSILON);
 
 
     auto testAssertionValue(*string name, float actual, float expected, float epsilon = DEFAULT_EPSILON);
 
     assertRegex(string regex_pattern, string actual, *string name);
 
 
     assertNRegex(string regex_pattern, string actual, *string name);
 
 
     assertNothing(auto actual, *string name);
 
 
     assertEqSoft(auto expected, auto actual, *string name);
 
 
     assertNeqSoft(auto expected, auto actual, *string name);
 
 
     assertEq(auto expected, auto actual, *string name);
 
 
     assertNeq(auto expected, auto actual, *string name);
 
 
     assertFloatEq(float expected, float actual, float epsilon = DEFAULT_EPSILON, *string name);
 
 
     assertNumberEq(number expected, number actual, number epsilon = DEFAULT_EPSILON, *string name);
 
 
     assertGtSoft(auto expected, auto actual, *string name);
 
 
     assertGt(auto expected, auto actual, *string name);
 
 
     assertGeSoft(auto expected, auto actual, *string name);
 
 
     assertGe(auto expected, auto actual, *string name);
 
 
     assertLtSoft(auto expected, auto actual, *string name);
 
 
     assertLt(auto expected, auto actual, *string name);
 
 
     assertLeSoft(auto expected, auto actual, *string name);
 
 
     assertLe(auto expected, auto actual, *string name);
 
     assertionOk(*string name);
 
 
     assertTrue(auto actual, *string name);
 
 
     assertFalse(auto actual, *string name);
 
 
     assertThrows(string expectedErr, *string expectedDesc, *hash<auto> arg, code theCode, *softlist<auto> args, *string name);
 
 
     assertThrows(string expectedErr, *string expectedDesc, code theCode, *softlist<auto> args, *string name);
 
 
     assertThrows(string expectedErr, code theCode, *softlist<auto> args, *string name);
 
 
     assertSkip (*string name);
 
    TestCase getTestCase(string meth);
 
 
 
     fail(*string msg);
 
 
     testNullAssertion(string name, code condition, *softlist<auto> args);
 
 
     auto testAssertion(string name, code condition, *softlist<auto> args, int expectedResultValue);
 
 
     auto testAssertion(string name, code condition, *softlist<auto> args, float expectedResultValue);
 
 
     auto testAssertion(string name, code condition, *softlist<auto> args, number expectedResultValue);
 
 
     auto testAssertion(string name, code condition, *softlist<auto> args, bool expectedResultValue);
 
 
     auto testAssertion(string name, code condition, *softlist<auto> args, string expectedResultValue);
 
 
     auto testAssertion(string name, code condition, *softlist<auto> args, date expectedResultValue);
 
 
     auto testAssertion(string name, code condition, *softlist<auto> args, binary expectedResultValue);
 
 
     auto testAssertion(string name, code condition, *softlist<auto> args, hash<auto> expectedResultValue);
 
 
     auto testAssertion(string name, code condition, *softlist<auto> args, list<auto> expectedResultValue);
 
 
     auto testAssertion(string name, code condition, *softlist<auto> args, QUnit::AbstractTestResult expectedResult = new QUnit::TestResultSuccess());
 
     auto testAssertionIntern(TestCase tc, string name, QUnit::AbstractTestResult actualResult, QUnit::AbstractTestResult expectedResult, auto ret, *string pos);
 
 
     testSkip(string reason);
 
//######## Test conditions passable to test assertions
 
 
    bool equals(auto a, auto b);
 
 
 
    bool notEquals(auto a, auto 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);
 
      static bool comparePartialHash(hash<auto> expects, auto value);
};
 
class QUnit::DependencyInjectedTest : public QUnit::Test {
 
public:
protected:
        string testedFile;
 
        Program child;
 
        hash<string, Program> modules;
 
        static bool instantiated = False;
 
public:
 
    constructor(string name, string version, reference<list<string>> p_argv, *hash<auto> opts) ;
 
 
    constructor(string name, string version, *list<auto> p_argv, *hash<auto> opts) ;
 
 
     init();
 
     createProgram();
 
     performInjections();
 
     reloadAndCommitProgram();
 
     string getScriptPath();
 
     Program createInjectedProgram(string path);
 
     int getParseOptions();
 
     injectClass(string class_name, *string new_name);
 
     injectFunction(string func_name, *string new_name);
 
 
     injectUserModule(string module, *code custom_setup, *code custom_parsing);
 
    int main();
 
 
     reloadSelf();
 
     setReloadedParseOptions(Program p, string file_data);
 
     performCommonInjections(Program p);
 
     abstract performInjectionsImpl();
     abstract string getScriptPathImpl();};
 
class QUnit::DependencyInjectedTestRunner : public QUnit::Test {
 
public:
protected:
        // necessary to allow the original class to run with the injected runtime class
        Program child;
 
public:
 
    // dummethods never executed in the runtime class
     injectClass(string name, *string new_name) {}     injectFunction(string name, *string new_name) {}     injectUserModule(string module, *code custom_setup, *code custom_parsing) {}
    constructor(string name, string version, reference<list<string>> p_argv, *hash<auto> opts) ;
 
 
    constructor(string name, string version, *list<auto> p_argv, *hash<auto> opts) ;
 
};