coretest.cpp

ncbi源码

    SIZE_TYPE n_flush = CNcbiApplication::Instance()->FlushDiag(&NcbiCout);
    NcbiCout << "FLUSHed diag: " << n_flush << " bytes" << NcbiEndl <<NcbiEndl;

    {{
        CNcbiDiag diagWarning;
        SetDiagHandler(s_TestDiagHandler, 0, 0);
        diagWarning << "*Warning* -- must be printed by Installed Handler!";
    }}

    SetDiagStream(&NcbiCerr);
    diag << "***ERROR*** THIS MESSAGE MUST NOT BE VISIBLE!!!\n\n";
    SetDiagStream(0);
    diag << Endm;
    diag << "01234";

    SetDiagStream(&NcbiCerr);
    assert(  IsDiagStream(&NcbiCerr) );
    assert( !IsDiagStream(&NcbiCout) );
    diag << "56789" << Endm;
    diag <<   "[Set Diag Stream(cerr)]  Diagnostics double = " << d << Endm;
    ERR_POST("[Set Diag Stream(cerr)]  Std.Diag. double = "    << d );
    _TRACE  ( "[Set Diag Stream(cerr)]  Trace double = "       << d );

    CNcbiTestDiag cntd;
    SetDiagPostLevel(eDiag_Error);
    diag << Warning << cntd << Endm;
    SetDiagPostLevel(eDiag_Info);
    diag << Warning << cntd << Endm;

    diag << Error << "This message has severity \"Info\"" << Reset
         << Info  << "This message has severity \"Info\"" << Endm;

    diag << Critical << "This message has severity \"Critical\"" << Endm;

    diag << Trace << "1This message has severity \"Trace\"" << Endm;

    SetDiagPostFlag(eDPF_All);
    SetDiagPostPrefix("Foo-Prefix");
    ERR_POST("This is the most detailed " << "error posting");
    SetDiagPostPrefix(0);
    UnsetDiagPostFlag(eDPF_Line);
    UnsetDiagPostFlag(eDPF_LongFilename);
    ERR_POST(Warning << "No line #, " << "Short filename, " << "No prefix");
    _TRACE("_TRACE:  must have all possible info in the posted message");
    UnsetDiagPostFlag(eDPF_Severity);
    ERR_POST("...and no severity");
    SetDiagPostFlag(eDPF_Line);
    SetDiagPostFlag(eDPF_Severity);
    SetDiagPostPrefix("Bad!!! No Prefix!!!");
    UnsetDiagPostFlag(eDPF_Prefix);
    ERR_POST("Short filename, " << "No prefix");
    UnsetDiagPostFlag(eDPF_All);
    ERR_POST("This is the least detailed error posting");
    SetDiagPostFlag(eDPF_All);
    UnsetDiagPostFlag(eDPF_LongFilename);

    PushDiagPostPrefix("Prefix1");
    ERR_POST("Message with prefix");
    PushDiagPostPrefix("Prefix2");
    ERR_POST("Message with prefixes");
    PushDiagPostPrefix("Prefix3");
    ERR_POST("Message with prefixes");
    PopDiagPostPrefix();
    ERR_POST("Message with prefixes");
    PopDiagPostPrefix();
    PopDiagPostPrefix();
    PopDiagPostPrefix();
    {{
        CDiagAutoPrefix a("AutoPrefix");
        ERR_POST("Message with auto prefix");
    }}
    ERR_POST("Message without prefixes");
    ERR_POST_EX(8, 0, "Message without prefix");
    SetDiagPostPrefix(0);

    PushDiagPostPrefix("ERROR");
    PopDiagPostPrefix();
    ERR_POST_EX(1, 2, "Message with error code, without prefix");

    PushDiagPostPrefix("ERROR");
    SetDiagPostPrefix(0);
    diag << Error << ErrCode(3, 4) << "Message with error code" << Endm;

    UnsetDiagPostFlag(eDPF_DateTime);
    diag << Warning << "Message without datetime stamp" << Endm;
    SetDiagPostFlag(eDPF_DateTime);

    EDiagSev prev_sev;
    IgnoreDiagDieLevel(true, &prev_sev);
    {{
        CNcbiDiag x_diag;
        x_diag << Fatal << "Fatal message w/o exit()/abort()!" << Endm;
    }}
    IgnoreDiagDieLevel(false);
    SetDiagDieLevel(prev_sev);
}


static void TestDiag_ErrCodeInfo(void)
{
    CNcbiDiag diag;

    CDiagErrCodeInfo        info;
    SDiagErrCodeDescription desc;

    CNcbiIstrstream is("\
# Comment line\n\
\n\
MODULE coretest\n\
\n\
$$ DATE, 1 : Short message for error code (1,0)\n\
\n\
$^   NameOfError, 1, 3 : Short message for error code (1,1)\n\
This is a long message for error code (1,1).\n\
$^   NameOfWarning, 2, WARNING: Some short text with ':' and ',' characters\n\
This is first line of the error explanation.\n\
This is second line of the error explanation.\n\
\n\
$$ PRINT, 9, 2\n\
Error with code (9,0).\n\
$^   EmptyString, 1, info:Error with subcode 1.\n\
$^   BadFormat, 2\n\
Message for warning error PRINT_BadFormat.\n\
");

    info.Read(is);
    info.SetDescription(ErrCode(2,3), 
                        SDiagErrCodeDescription("Err 2.3", "Error 2.3"
                                                /*, default severity */));
    info.SetDescription(ErrCode(2,4), 
                        SDiagErrCodeDescription("Err 2.4", "Error 2.4",
                                                eDiag_Error));

    assert(info.GetDescription(ErrCode(1,1), &desc));
    assert(desc.m_Message     == "Short message for error code (1,1)");
    assert(desc.m_Explanation == "This is a long message for error code (1,1).");
    assert(desc.m_Severity    == 3);

    assert(info.GetDescription(ErrCode(9,0), &desc));
    assert(desc.m_Severity    == 2);
    assert(info.GetDescription(ErrCode(9,1), &desc));
    assert(desc.m_Severity    == eDiag_Info);
    assert(info.GetDescription(ErrCode(9,2), &desc));
    assert(desc.m_Severity    == 2);

    assert(info.GetDescription(ErrCode(2,4), &desc));
    assert(desc.m_Message     == "Err 2.4");
    assert(desc.m_Explanation == "Error 2.4");
    assert(desc.m_Severity    == eDiag_Error);

    assert(!info.GetDescription(ErrCode(1,3), &desc));

    SetDiagErrCodeInfo(&info);
    SetDiagPostFlag(eDPF_All);
    SetDiagPostPrefix("Prefix");

    ERR_POST("This message has default severity \"Error\"");
    ERR_POST_EX(1,1,"This message has severity \"Critical\"");

    diag << ErrCode(1,1) << Info << "This message has severity \"Critical\"" 
         << Endm;
    UnsetDiagPostFlag(eDPF_ErrCodeMessage);
    diag << ErrCode(1,1) << Info << "This message has severity \"Critical\"" 
         << Endm;
    UnsetDiagPostFlag(eDPF_Prefix);
    diag << ErrCode(1,1) << Info << "This message has severity \"Critical\""
         << Endm;
    UnsetDiagPostFlag(eDPF_ErrCode);
    UnsetDiagPostFlag(eDPF_ErrCodeUseSeverity);
    diag << ErrCode(1,1) << Info << "This message has severity \"Info\""
         << Endm;
    UnsetDiagPostFlag(eDPF_ErrCodeExplanation);
    SetDiagPostFlag(eDPF_ErrCodeUseSeverity);
    diag << ErrCode(1,1) << "This message has severity \"Critical\"" << Endm;
}


/////////////////////////////////
// Exceptions
//

static void TE_runtime(void) {
    throw runtime_error("TE_runtime::runtime_error");
}

static void TE_none(void) THROWS_NONE {
    return;
}

static void TE_logic(void) THROWS((runtime_error,logic_error)) {
    throw logic_error("TE_logic::logic_error");
}


class XXX {
    string mess;
public:
    XXX(const XXX&    x);
    XXX(const string& m);
    ~XXX(void);
    const string& what(void) const { return mess; }
};

XXX::XXX(const string& m) : mess(m) {
    NcbiCerr << "XXX: " << long(this) << NcbiEndl;
}
XXX::XXX(const XXX&x) : mess(x.mess) {
    NcbiCerr << "XXX(" << long(&x) << "): " << long(this) << NcbiEndl;
}
XXX::~XXX(void) {
    NcbiCerr << "~XXX: " << long(this) << NcbiEndl;
}

static void s_ThrowXXX(void) {
    NcbiCerr << NcbiEndl << "Throw class XXX" << NcbiEndl;
    throw XXX("s_ThrowXXX message");
   
}

static void TestException_Features(void)
{
    try {
        s_ThrowXXX();
    } catch (XXX& x) {
        NcbiCerr << "Catch (XXX& x): " << x.what() << NcbiEndl;
    }

    try {
        s_ThrowXXX();
    } catch (XXX x) {
        NcbiCerr << "Catch (XXX x): " << x.what() << NcbiEndl << NcbiEndl;
    }
}


static void TestException_Std(void)
{
    try { TE_runtime(); }
    catch (runtime_error& e) {
        NcbiCerr << "CATCH TE_runtime::runtime_error : " << e.what()<<NcbiEndl;
    }

    try { TE_runtime(); }
    catch (exception& e) {
        NcbiCerr << "CATCH TE_runtime::exception " << e.what() << NcbiEndl;
    }

    try { TE_runtime(); }
    STD_CATCH ("STD_CATCH" << ' ' << "TE_runtime ");

    try { TE_runtime(); }
    catch (logic_error& e) {
        NcbiCerr << "CATCH TE_runtime::logic_error " << e.what() << NcbiEndl;
        _TROUBLE; }
    STD_CATCH_ALL ("STD_CATCH_ALL" << " " << "TE_runtime");

    TE_none();

    try { TE_logic(); }
    catch (logic_error& e) {
        NcbiCerr << "CATCH TE_logic " << e.what() << NcbiEndl; }
    STD_CATCH_ALL ("try { TE_logic(); }  SOMETHING IS WRONG!");
}


static void TestException_Aux(void)
{
    try {
        assert( !strtod("1e-999999", 0) );
        NCBI_THROW(CErrnoTemplException<CCoreException>,eErrno,
            "Failed strtod(\"1e-999999\", 0)");
    }
    catch (CErrnoTemplException<CCoreException>& e) {
        NCBI_REPORT_EXCEPTION("TEST CErrnoTemplException<CCoreException> ---> ",e);
    }
    try {
        NCBI_THROW2(CParseTemplException<CCoreException>,eErr,
            "Failed parsing (at pos. 123)",123);
    }
    catch (CException& e) {
        NCBI_REPORT_EXCEPTION("TEST CParseTemplException<CCoreException> ---> ",e);
    }
    catch (...) {
        // Should never be here
        _TROUBLE;
    }
}


static void TestException_AuxTrace(void)
{
    try {
        assert( !strtod("1e-999999", 0) );
        NCBI_THROW(CErrnoTemplException<CCoreException>,eErrno,
            "Failed strtod('1e-999999', 0)");
    }
    catch (CErrnoTemplException<CCoreException>& e) {
        NCBI_REPORT_EXCEPTION("throw CErrnoTemplException<CCoreException> ---> ",e);
    }

    try {
        try {
            // BW___WS53
            // Sigh.  WorkShop 5.3 is stupid, and complains about
            // const char* vs. const char[15] without this cast.
            THROW0_TRACE((const char*) "Throw a string");
        } catch (const char* _DEBUG_ARG(e)) {
            _TRACE("THROW0_TRACE: " << e);
            RETHROW_TRACE;
        }
    } catch (const char* _DEBUG_ARG(e)) {
        _TRACE("RETHROW_TRACE: " << e);
    }

    try {
        THROW_TRACE(bad_alloc, ());
    }
    STD_CATCH ("THROW_TRACE  bad_alloc ---> ");

    try {
        THROW_TRACE(runtime_error, ("Some message..."));
    }
    STD_CATCH ("THROW_TRACE  runtime_error ---> ");

    try {
        NCBI_THROW2(CParseTemplException<CCoreException>,eErr,
            "Failed parsing (at pos. 123)", 123);
    }
    catch (CException& e) {
        NCBI_REPORT_EXCEPTION("throw CParseTemplException<CCoreException> ---> ",e);
    }
}


static void TestException(void)
{
    SetDiagStream(&NcbiCout);

    TestException_Features();
    TestException_Std();
    TestException_Aux();
}


static void TestThrowTrace(void)
{
    SetDiagTrace(eDT_Enable);
    NcbiCerr << "The following lines should be equal pairs:" << NcbiEndl;
    try {
        THROW1_TRACE(runtime_error, "Message");
    }
    catch (...) {
        CNcbiDiag(__FILE__, __LINE__ - 3, eDiag_Trace) <<
            "runtime_error: Message";
    }
    string mess = "ERROR";
    try {
        THROW1_TRACE(runtime_error, mess);
    }
    catch (...) {
        CNcbiDiag(__FILE__, __LINE__ - 3, eDiag_Trace) <<
            "runtime_error: ERROR";
    }
    int i = 123;
    try {
        THROW0p_TRACE(i);
    }
    catch (...) {
        CNcbiDiag(__FILE__, __LINE__ - 3, eDiag_Trace) <<
            "i: 123";
    }
    SetDiagTrace(eDT_Default);
}

#include <corelib/ncbiobj.hpp>

class CObjectInt : public CObject
{
public:
  CObjectInt() : m_Int(0) {}
  CObjectInt(int i) : m_Int(i) {}
  int m_Int;
};

static void TestHeapStack(void)
{
    SetDiagTrace(eDT_Enable);
    {
      NcbiCerr << "Test CObjectInt in stack:" << NcbiEndl;
      CObjectInt stackObj;
      assert(!stackObj.CanBeDeleted());
    }
    {
      NcbiCerr << "Test CObjectInt on heap:" << NcbiEndl;
      CObjectInt* heapObj = new CObjectInt();
      assert(heapObj->CanBeDeleted());
    }
    {
      NcbiCerr << "Test static CObjectInt:" << NcbiEndl;
      static CObjectInt staticObj;
      assert(!staticObj.CanBeDeleted());