File Coverage

Catch_xsgen.cc

Criterion	Covered	Total	%
statement	14	15	93.3
branch	7	16	43.7
condition			n/a
subroutine			n/a
pod			n/a
total	21	31	67.7

/*
 * This file was generated automatically by ExtUtils::ParseXS version 3.34 from the
 * contents of Catch.xs. Do not edit this file, edit Catch.xs instead.
 *
 *    ANY CHANGES MADE HERE WILL BE LOST!
 *
 */

#line 1 "Catch.xs"
#include  // this fixes win32 because  that is included by  breaks  unless previously included
#include
#include
#include
#include
#include
#include
#include
#include

using namespace Catch;
using namespace std;

static Catch::Session session;

struct Printer {
    Printer (ostream& _stream, const AssertionStats& _stats)
        : stream(_stream), result(_stats.assertionResult), messages(_stats.infoMessages), itMessage(_stats.infoMessages.begin()) {}

    void print () {
        itMessage = messages.begin();

        switch (result.getResultType()) {
            case ResultWas::Ok:
                printOriginalExpression();
                printReconstructedExpression();
                printRemainingMessages();
                break;
            case ResultWas::ExpressionFailed:
                printOriginalExpression();
                printReconstructedExpression();
                if (result.isOk()) printIssue(" # TODO");
                printRemainingMessages();
                break;
            case ResultWas::ThrewException:
                printIssue("unexpected exception ");
                printExpressionWas();
                printRemainingMessages();
                break;
            case ResultWas::FatalErrorCondition:
                printIssue("fatal error condition with message:");
                printMessage();
                printExpressionWas();
                printRemainingMessages();
                break;
            case ResultWas::DidntThrowException:
                printIssue("expected exception, got none");
                printExpressionWas();
                printRemainingMessages();
                break;
            case ResultWas::Info:
                stream << "#info";
                printMessage();
                printRemainingMessages();
                break;
            case ResultWas::Warning:
                stream << "#warning";
                printMessage();
                printRemainingMessages();
                break;
            case ResultWas::ExplicitFailure:
                printIssue("explicitly");
                printRemainingMessages();
                break;
            // These cases are here to prevent compiler warnings
            case ResultWas::Unknown:
            case ResultWas::FailureBit:
            case ResultWas::Exception:
                stream << "** unsupported ResultWas (should not happenned) **";
                break;
        }
    }

private:
    static inline void expr_replace (string& expr, const string& c, const string& subs) {
        size_t pos = expr.find(c);
        while (pos < expr.length()) {
            expr.replace(pos, c.length(), subs);
            pos = expr.find(c, pos + subs.length());
        }
    }

    void printIssue (const string& issue) const {
        stream << " " << issue;
    }

    void printExpressionWas () {
        if (!result.hasExpression()) return;
        stream << "; expression was:";
        printOriginalExpression();
    }

    void printOriginalExpression () const {
        if (result.hasExpression()) stream << " " << result.getExpression();
    }

    void printReconstructedExpression () const {
        if (!result.hasExpandedExpression()) return;
        stream << " for: ";
        string expr = result.getExpandedExpression();
        // prevent "str" == "str" splitting into several lines
        expr_replace(expr, "\"\r\n==\r\n\"", "\" == \"");
        expr_replace(expr, "\"\n==\n\"", "\" == \"");
        // replace remaining newlines in text/expressions
        expr_replace(expr, "\r", "\\r");
        expr_replace(expr, "\n", "\\n");
        stream << expr;
    }

    void printMessage () {
        if (itMessage != messages.end()) {
            stream << " '" << itMessage->message << "'";
            ++itMessage;
        }
    }

    void printRemainingMessages () {
        if (itMessage == messages.cend()) return;

        // using messages.end() directly (or auto) yields compilation error:
        auto itEnd = messages.cend();
        const size_t N = static_cast(std::distance(itMessage, itEnd));

        stream << " with " << pluralise( N, "message" ) << ":";

        for (; itMessage != itEnd; ++itMessage) {
            // If this assertion is a warning ignore any INFO messages
            if (itMessage->type != ResultWas::Info) {
                stream << "\n#   " << itMessage->message;
            }
        }
    }

    ostream& stream;
    AssertionResult const& result;
    vector messages;
    vector::const_iterator itMessage;
};


struct PerlReporter : StreamingReporterBase {
    struct Scope {
        uint32_t count;
        uint32_t failed;
        uint32_t depth;
        string   name;
        string   fullname;
    };
    static Scope context;

    static string getDescription () { return "Reports test results in perl test-harness compatible format"; }

    PerlReporter (const ReporterConfig& config) : StreamingReporterBase(config), scope(), sliding_scope(), fatal() {
        m_preferences.shouldRedirectStdOut = false;
        m_preferences.shouldReportAllAssertions = true;
    }

    void noMatchingTestCases (StringRef unmatchedSpec) override {
        startErrorLine() << "# No test cases matched '" << unmatchedSpec << "'" << endl;
    }

    void reportInvalidArguments(StringRef invalidArgument) override {
        startErrorLine() << "# invalid argument '" << invalidArgument << "'" << endl;
    }

    void testRunStarting (const TestRunInfo&) override {
        scopes.push_back(context);
        scope = &scopes.back();
    }

    void testRunEnded (const TestRunStats&) override {
        context.count  = scope->count;
        context.failed = scope->failed;
        scopes.clear();
        scope = nullptr;
    }

    void testCaseStarting (const TestCaseInfo&)  override {}

    void testCaseEnded (const TestCaseStats&) override {
        if (fatal) {
            commitAssertions();
            sliding_scope = &scopes[1];
        }
        commitSlidingScope();
    }

    void sectionStarting (const SectionInfo& info) override {
        if (sliding_scope && sliding_scope->name == info.name) {
            ++sliding_scope;
            return;
        }
        commitSlidingScope();
        startScope(info);
    }

    void startScope (const SectionInfo& info) {
        startLine();
        auto fullname = scope->fullname.length() ? (scope->fullname + " / " + info.name) : info.name;
        m_stream << "# Subtest: " << fullname << endl;
        scopes.push_back({0, 0, scope->depth + 1, info.name, fullname});
        scope = &scopes.back();
    }

    void sectionEnded (const SectionStats&) override {
        if (fatal) return;
        if (!sliding_scope) sliding_scope = scope + 1;
        --sliding_scope;
        if (sliding_scope == &scopes[1]) commitAssertions();
    }

    void commitSlidingScope () {
        if (!sliding_scope) return;
        size_t cnt = &scopes.back() - sliding_scope + 1;
        while (cnt--) closeCurrentScope();
        sliding_scope = nullptr;
    }

    void closeCurrentScope () {
        auto name = scope->fullname;
        bool failed = scope->failed;
        startLine() << "1.." << scope->count << endl;
        if (scope->failed) {
            startErrorLine() << "# Looks like you failed " << scope->failed << " test of " << scope->count << " at [" << name << "]." << endl;
        }

        scopes.pop_back();
        if (scopes.empty()) throw "WTF?";
        scope = &scopes.back();

        ++scope->count;
        startLine();
        if (failed) {
            ++scope->failed;
            m_stream << "not ok";
        }
        else m_stream << "ok";
        m_stream << " " << scope->count << " - [" << name << "]" << endl;
    }

    ostream& startLine () {
        for (size_t i = 0; i < scope->depth; ++i) m_stream << "    ";
        return m_stream;
    }

    ostream& startErrorLine () {
        for (size_t i = 0; i < scope->depth; ++i) std::cerr << "    ";
        return std::cerr;
    }

    void assertionStarting (const AssertionInfo&) override {}

    void assertionEnded (const AssertionStats& stats) override {
        ostringstream s;
        Printer(s, stats).print();
        assertions.push_back({stats, s.str()});
    }

    void commitAssertions () {
        for (auto& row : assertions) {
            auto& stats = row.stats;
            auto result = stats.assertionResult;
            // prevent diagnostic messages from counting
            bool is_test = result.getResultType() != ResultWas::Info && result.getResultType() != ResultWas::Warning;

            Colour::Code color = Colour::None;
            ostream& ss = result.succeeded() ? startLine() : startErrorLine();

            if (is_test) {
                ++scope->count;
                if (result.succeeded()) {
                    ss << "ok";
                } else {
                    ++scope->failed;
                    ss << "not ok";
                    color = Colour::ResultError;
                }
                ss << " " << scope->count << " -";
            }

            {
                Colour cg(color); (void)cg;
                ss << row.expr;
                ss << " # at " << result.getSourceInfo();
            }

            ss << endl;

            if (is_test && !result.succeeded()) {
                startErrorLine() << "#\e[1;31m Failed test in section [" << scope->fullname << "] at " << result.getSourceInfo() << "\e[0m" << endl;
            }
        }
        assertions.clear();
    }

    void fatalErrorEncountered (StringRef) override {
        fatal = true;
    }

    void benchmarkEnded(const BenchmarkStats<>& stats) override {
        ostream& ss = startLine();
        ++scope->count;
        ss << "ok " << scope->count << " - ";
        if (stats.info.name.length()) ss << stats.info.name << ": ";
        ss << speed(stats.mean.point.count()) << ", " << spent(stats.mean.point.count()) << endl;
    }

private:
    struct AData {
        AssertionStats stats;
        string         expr;
    };

    vector scopes;
    Scope*        scope;
    Scope*        sliding_scope;
    vector assertions;
    bool          fatal;

    static constexpr const uint64_t usec = 1000;
    static constexpr const uint64_t msec = 1000 * usec;
    static constexpr const uint64_t sec  = 1000 * msec;
    static constexpr const uint64_t min  = 60 * sec;

    static inline string spent (double ns) {
        double val;
        const char* units;
        if      (ns < usec) { val = ns; units = "ns"; }
        else if (ns < msec) { val = ns / usec; units = "us"; }
        else if (ns < sec)  { val = ns / static_cast(msec); units = "ms"; }
        else if (ns < min)  { val = ns / static_cast(sec);  units = "s"; }
        else                { val = ns / static_cast(min);  units = "m"; }
        char buf[30];
        auto sz = snprintf(buf, sizeof(buf), "%.2f %s", val, units);
        assert(sz > 0);
        return string(buf, sz);
    }

    static inline string speed (double ns) {
        double val;
        const char* units;
        if      (ns < usec) { val = 1000/ns; units = "M"; }
        else if (ns < msec) { val = 1000000/ns; units = "K"; }
        else                { val = 1000000000 / ns; units = ""; }
        char buf[30];
        auto sz = snprintf(buf, sizeof(buf), "%.2f %s/sec", val, units);
        assert(sz > 0);
        return string(buf, sz);
    }
};

PerlReporter::Scope PerlReporter::context;

CATCH_REGISTER_REPORTER("perl", PerlReporter);

#line 366 "Catch_xsgen.cc"
#ifndef PERL_UNUSED_VAR
#  define PERL_UNUSED_VAR(var) if (0) var = var
#endif

#ifndef dVAR
#  define dVAR		dNOOP
#endif


/* This stuff is not part of the API! You have been warned. */
#ifndef PERL_VERSION_DECIMAL
#  define PERL_VERSION_DECIMAL(r,v,s) (r*1000000 + v*1000 + s)
#endif
#ifndef PERL_DECIMAL_VERSION
#  define PERL_DECIMAL_VERSION \
	  PERL_VERSION_DECIMAL(PERL_REVISION,PERL_VERSION,PERL_SUBVERSION)
#endif
#ifndef PERL_VERSION_GE
#  define PERL_VERSION_GE(r,v,s) \
	  (PERL_DECIMAL_VERSION >= PERL_VERSION_DECIMAL(r,v,s))
#endif
#ifndef PERL_VERSION_LE
#  define PERL_VERSION_LE(r,v,s) \
	  (PERL_DECIMAL_VERSION <= PERL_VERSION_DECIMAL(r,v,s))
#endif

/* XS_INTERNAL is the explicit static-linkage variant of the default
 * XS macro.
 *
 * XS_EXTERNAL is the same as XS_INTERNAL except it does not include
 * "STATIC", ie. it exports XSUB symbols. You probably don't want that
 * for anything but the BOOT XSUB.
 *
 * See XSUB.h in core!
 */


/* TODO: This might be compatible further back than 5.10.0. */
#if PERL_VERSION_GE(5, 10, 0) && PERL_VERSION_LE(5, 15, 1)
#  undef XS_EXTERNAL
#  undef XS_INTERNAL
#  if defined(__CYGWIN__) && defined(USE_DYNAMIC_LOADING)
#    define XS_EXTERNAL(name) __declspec(dllexport) XSPROTO(name)
#    define XS_INTERNAL(name) STATIC XSPROTO(name)
#  endif
#  if defined(__SYMBIAN32__)
#    define XS_EXTERNAL(name) EXPORT_C XSPROTO(name)
#    define XS_INTERNAL(name) EXPORT_C STATIC XSPROTO(name)
#  endif
#  ifndef XS_EXTERNAL
#    if defined(HASATTRIBUTE_UNUSED) && !defined(__cplusplus)
#      define XS_EXTERNAL(name) void name(pTHX_ CV* cv __attribute__unused__)
#      define XS_INTERNAL(name) STATIC void name(pTHX_ CV* cv __attribute__unused__)
#    else
#      ifdef __cplusplus
#        define XS_EXTERNAL(name) extern "C" XSPROTO(name)
#        define XS_INTERNAL(name) static XSPROTO(name)
#      else
#        define XS_EXTERNAL(name) XSPROTO(name)
#        define XS_INTERNAL(name) STATIC XSPROTO(name)
#      endif
#    endif
#  endif
#endif

/* perl >= 5.10.0 && perl <= 5.15.1 */


/* The XS_EXTERNAL macro is used for functions that must not be static
 * like the boot XSUB of a module. If perl didn't have an XS_EXTERNAL
 * macro defined, the best we can do is assume XS is the same.
 * Dito for XS_INTERNAL.
 */
#ifndef XS_EXTERNAL
#  define XS_EXTERNAL(name) XS(name)
#endif
#ifndef XS_INTERNAL
#  define XS_INTERNAL(name) XS(name)
#endif

/* Now, finally, after all this mess, we want an ExtUtils::ParseXS
 * internal macro that we're free to redefine for varying linkage due
 * to the EXPORT_XSUB_SYMBOLS XS keyword. This is internal, use
 * XS_EXTERNAL(name) or XS_INTERNAL(name) in your code if you need to!
 */

#undef XS_EUPXS
#if defined(PERL_EUPXS_ALWAYS_EXPORT)
#  define XS_EUPXS(name) XS_EXTERNAL(name)
#else
   /* default to internal */
#  define XS_EUPXS(name) XS_INTERNAL(name)
#endif

#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE
#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params)

/* prototype to pass -Wmissing-prototypes */
STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params);

STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params)
{
    const GV *const gv = CvGV(cv);

    PERL_ARGS_ASSERT_CROAK_XS_USAGE;

    if (gv) {
        const char *const gvname = GvNAME(gv);
        const HV *const stash = GvSTASH(gv);
        const char *const hvname = stash ? HvNAME(stash) : NULL;

        if (hvname)
	    Perl_croak_nocontext("Usage: %s::%s(%s)", hvname, gvname, params);
        else
	    Perl_croak_nocontext("Usage: %s(%s)", gvname, params);
    } else {
        /* Pants. I don't think that it should be possible to get here. */
	Perl_croak_nocontext("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params);
    }
}
#undef  PERL_ARGS_ASSERT_CROAK_XS_USAGE

#define croak_xs_usage        S_croak_xs_usage

#endif

/* NOTE: the prototype of newXSproto() is different in versions of perls,
 * so we define a portable version of newXSproto()
 */
#ifdef newXS_flags
#define newXSproto_portable(name, c_impl, file, proto) newXS_flags(name, c_impl, file, proto, 0)
#else
#define newXSproto_portable(name, c_impl, file, proto) (PL_Sv=(SV*)newXS(name, c_impl, file), sv_setpv(PL_Sv, proto), (CV*)PL_Sv)
#endif /* !defined(newXS_flags) */

#if PERL_VERSION_LE(5, 21, 5)
#  define newXS_deffile(a,b) Perl_newXS(aTHX_ a,b,file)
#else
#  define newXS_deffile(a,b) Perl_newXS_deffile(aTHX_ a,b)
#endif

#line 510 "Catch_xsgen.cc"


XS_EUPXS(XS_Test__Catch__run)
{
    dVAR; dXSARGS;
    if (items < 3)
       croak_xs_usage(cv,  "count, failed, depth, ...");
    {
	bool	RETVAL;
	SV*	count = ST(0)
;
	SV*	failed = ST(1)
;
	int	depth = (int)SvIV(ST(2))
;
#line 360 "Catch.xs"
    int err;
    {
        std::vector argv = {"test"};

        for (int i = 3; i < items; ++i) {
            SV* arg = ST(i);
            if (!SvOK(arg)) continue;
            argv.push_back(SvPV_nolen(arg));
        }

        argv.push_back("-i");
        argv.push_back("-r");
        argv.push_back("perl");

        session.useConfigData({});
        err = session.applyCommandLine(argv.size(), argv.data());
    }
    if (err) croak("session.applyCommandLine: error %d", err);

    PerlReporter::context.count  = SvUV(count);
    PerlReporter::context.failed = SvUV(failed);
    PerlReporter::context.depth  = depth;

    RETVAL = session.run() == 0;

    sv_setuv(count, PerlReporter::context.count);
    sv_setuv(failed, PerlReporter::context.failed);
#line 554 "Catch_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}

#ifdef __cplusplus
extern "C"
#endif

XS_EXTERNAL(boot_Test__Catch)
{
#if PERL_VERSION_LE(5, 21, 5)
    dVAR; dXSARGS;
#else
    dVAR; dXSBOOTARGSXSAPIVERCHK;
#endif
#if (PERL_REVISION == 5 && PERL_VERSION < 9)
    char* file = __FILE__;
#else
    const char* file = __FILE__;
#endif

    PERL_UNUSED_VAR(file);

    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
#if PERL_VERSION_LE(5, 21, 5)
    XS_VERSION_BOOTCHECK;
#  ifdef XS_APIVERSION_BOOTCHECK
    XS_APIVERSION_BOOTCHECK;
#  endif
#endif

        newXS_deffile("Test::Catch::_run", XS_Test__Catch__run);
#if PERL_VERSION_LE(5, 21, 5)
#  if PERL_VERSION_GE(5, 9, 0)
    if (PL_unitcheckav)
        call_list(PL_scopestack_ix, PL_unitcheckav);
#  endif
    XSRETURN_YES;
#else
    Perl_xs_boot_epilog(aTHX_ ax);
#endif
}