clause.cpp

epson usb2.0 控制芯片 S1R72V05 固件程序。

#ifdef TESTSUITE

#include "coverage_undefs.h"
#include <sstream>

namespace {
    class Clause_test : public Clause
    {
    public:
        Token        first;
        Token        second;
        bool         throw_exception;

        Clause_test(void) throw() : first(Token::ERROR), throw_exception(false) {}

        void body(const Token & _first, Parser & _p)
        {
            TestSuite::check("Clause_test::body");
            first = _first;
            second = _p.getToken();
            if(throw_exception)
                throw 0;
        }

        void before(const Token & , Parser & )
        {
            TestSuite::check("Clause_test::before");
        }

        void after(const Token &, Parser &)
        {
            TestSuite::check("Clause_test::after");
        }

        void onFail(const Token & _first, Parser & p) throw()
        {
            TestSuite::check("Clause_test::onFail");
            first = _first;
        }

        void onFail_super(const Token & _first, Parser & p) throw()
        {   Clause::onFail(_first, p);   }
    };
}

TESTSUITE(main, Clause)
{
    SingletonBase::ContextChain chain;
    chain.saveContext<Namespace>();

    BEGIN_CASE("getClauseIdentifier","getClauseIdentifier") {
        BEGIN_CASE("1","晛捠偺幆暿巕偼偦偺傑傑偑拞恎偵側傞") {
            Token token(Token::IDENTIFIER, "test");

            if(getClauseIdentifier(token).compare("test") != 0)
                TEST_FAIL;
        } END_CASE;

        BEGIN_CASE("2","悢抣偼拞恎偵娭學側偔" INTEGER_CLAUSE_IDENTIFIER "偑曉傞") {
            Token token(Token::INTEGER, "", "", 0);

            if(getClauseIdentifier(token).compare(INTEGER_CLAUSE_IDENTIFIER) != 0)
                TEST_FAIL;
        } END_CASE;

        BEGIN_CASE("3","儕僥儔儖偼拞恎偵娭學側偔" LITERAL_CLAUSE_IDENTIFIER "偑曉傞") {
            Token token(Token::LITERAL, "");

            if(getClauseIdentifier(token).compare(LITERAL_CLAUSE_IDENTIFIER) != 0)
                TEST_FAIL;
        } END_CASE;

        BEGIN_CASE("4","墘嶼巕偼拞恎偵娭學側偔" OPERATOR_CLAUSE_IDENTIFIER "偑曉傞") {
            Token token(Token::OPERATOR);

            if(getClauseIdentifier(token).compare(OPERATOR_CLAUSE_IDENTIFIER) != 0)
                TEST_FAIL;
        } END_CASE;

        BEGIN_CASE("5","嬻敀偺僩乕僋儞偵偼嬻暥帤(==旕庴棟)偑曉傞") {
            Token token(Token::SPACE);

            if(!getClauseIdentifier(token).empty())
                TEST_FAIL;
        } END_CASE;

        TEST_CASE("6","僄儔乕僩乕僋儞偵偼嬻暥帤(==旕庴棟)偑曉傞", getClauseIdentifier(Token(Token::ERROR)).empty());
        TEST_CASE("7","EOS僩乕僋儞偵偼嬻暥帤(==旕庴棟)偑曉傞",   getClauseIdentifier(Token(Token::END_OF_STREAM)).empty());

    } END_CASE;

    BEGIN_CASE("getClauseMap","getClauseMap") {
        BEGIN_CASE("1","壗傕搊榐偟偰偄側偄嬻娫偵偼NULL偑曉傞") {
            chain.renewInstance();
            if(Clause::getClauseMap("unknown") != 0)
                TEST_FAIL;
        } END_CASE;

        BEGIN_CASE("2","梫慺偑偁傟偽旕0偑曉傞") {
            chain.renewInstance();
            Singleton<Namespace>::getInstance()->operator []("test");

            if(Clause::getClauseMap("test") == 0)
                TEST_FAIL;
        } END_CASE;
    } END_CASE;

    BEGIN_CASE("addClause","addClause") {
        BEGIN_CASE("1","僆僽僕僃僋僩傪搊榐偱偒傞") {
            chain.renewInstance();
            Clause_test ct;
            Clause_test ct2;

            BEGIN_CASE("1","晛捠偵搊榐偡傞") {
                ct.addClause("test","first_literal");

                TEST_CASE("1","柤慜嬻娫偑憹偊偰偄傞", Singleton<Namespace>::getInstance()->size() == 1);
                TEST_CASE("2","\"test\"偲偄偆嬻娫偑偁傞", Singleton<Namespace>::getInstance()->find("test") != Singleton<Namespace>::getInstance()->end());
                TEST_CASE("3","getClause偱傾僪儗僗偑庢傟傞", Clause::getClauseMap("test") != 0); 
                TEST_CASE("4","柤慜嬻娫偺愡偺悢偼1",  Clause::getClauseMap("test")->size() == 1);
                TEST_CASE("5","\"first_literal\"偺僲乕僪偑偁傞", Clause::getClauseMap("test")->find("first_literal") != Clause::getClauseMap("test")->end());
                TEST_CASE("6","娭楢晅偗傜傟偨抣偑惓偟偄", (*Clause::getClauseMap("test"))["first_literal"] == &ct);
            } END_CASE;

            BEGIN_CASE("2","2屄栚傪搊榐偡傞") {
                ct2.addClause("test","second_literal");

                TEST_CASE("1","柤慜嬻娫偑憹偊偰偄側偄", Singleton<Namespace>::getInstance()->size() == 1);
                TEST_CASE("2","\"test\"偲偄偆嬻娫偑偁傞", Singleton<Namespace>::getInstance()->find("test") != Singleton<Namespace>::getInstance()->end());
                TEST_CASE("3","柤慜嬻娫偺愡偺悢偼2",  Clause::getClauseMap("test")->size() == 2);
                TEST_CASE("4","\"second_literal\"偺僲乕僪偑偁傞", Clause::getClauseMap("test")->find("second_literal") != Clause::getClauseMap("test")->end());
                TEST_CASE("5","娭楢晅偗傜傟偨抣偑惓偟偄", (*Clause::getClauseMap("test"))["second_literal"] == &ct2);
            } END_CASE;

            BEGIN_CASE("3","2屄栚傪1屄栚偱忋彂偒搊榐偡傞") {
                ct.addClause("test","second_literal");
                TEST_CASE("1","忋彂偒偝傟偰偄傞", (*Clause::getClauseMap("test"))["second_literal"] == &ct);
            } END_CASE;

            BEGIN_CASE("4","堘偆柤慜嬻娫偵搊榐偡傞") {
                ct.addClause("TEST","first_literal");

                TEST_CASE("1","柤慜嬻娫偑憹偊偰偄傞", Singleton<Namespace>::getInstance()->size() == 2);
                TEST_CASE("2","\"TEST\"偲偄偆嬻娫偑偁傞", Singleton<Namespace>::getInstance()->find("TEST") != Singleton<Namespace>::getInstance()->end());
                TEST_CASE("3","getClause偱傾僪儗僗偑庢傟傞", Clause::getClauseMap("TEST") != 0); 
                TEST_CASE("4","柤慜嬻娫偺愡偺悢偼1",  Clause::getClauseMap("TEST")->size() == 1);
                TEST_CASE("5","\"first_literal\"偺僲乕僪偑偁傞", Clause::getClauseMap("TEST")->find("first_literal") != Clause::getClauseMap("TEST")->end());
                TEST_CASE("6","娭楢晅偗傜傟偨抣偑惓偟偄", (*Clause::getClauseMap("TEST"))["first_literal"] == &ct);
            } END_CASE;

        } END_CASE;

        BEGIN_CASE("2","柍岠側僆僽僕僃僋僩偼搊榐偝傟側偄") {
            chain.renewInstance();

            ((Clause_test *)0)->addClause("test","first_literal");

            TEST_CASE("1","柤慜嬻娫偑憹偊偰偄側偄", Singleton<Namespace>::getInstance()->size() == 0);
        } END_CASE;

    } END_CASE;

    BEGIN_CASE("hasClause","hasClause") {
        Clause_test ct;
        chain.renewInstance();

        TEST_CASE("1","壗傕梫慺偑側偄偲偒偵傕惓忢偵摦嶌偡傞", !Clause::hasClause("dummy","null"));

        ct.addClause("test","first_literal");

        TEST_CASE("2","搊榐偟偨梫慺傪扵偣丄true偑曉傞", Clause::hasClause("test","first_literal"));
        TEST_CASE("3","懚嵼偟側偄梫慺偵false偑曉傞", !Clause::hasClause("dummy","null"));
    } END_CASE;

    BEGIN_CASE("addMultipleClauses","addMultipleClauses") {
        BEGIN_CASE("1","扨堦偺愡傪搊榐偱偒傞") {
            chain.renewInstance();
            Clause_test ct;

            ct.addMultipleClauses("test","first");

            TEST_CASE("1","搊榐偟偨愡偑偁傞", Clause::hasClause("test","first"));
        } END_CASE;

        BEGIN_CASE("2","暋悢偺愡傪搊榐偡傞") {
            chain.renewInstance();
            Clause_test ct;

            ct.addMultipleClauses("test","first,second,third");

            TEST_CASE("1","搊榐偟偨愡偑偁傞", Clause::hasClause("test","first"));
            TEST_CASE("2","搊榐偟偨愡偑偁傞", Clause::hasClause("test","second"));
            TEST_CASE("3","搊榐偟偨愡偑偁傞", Clause::hasClause("test","third"));
        } END_CASE;

    } END_CASE;

    BEGIN_CASE("Clause::onFail","Clause::onFail") {
        stringstream buf;
        Parser p(&buf, "test");
        Token token;
        Clause_test ct;

        buf.str("first second third 4 5 6 siebt acht neunt 0xa");

        ct.onFail_super(token, p);
        TEST_CASE("1","僗僩儕乕儉偼嵟屻傑偱恑傫偱偄傞", p.eof());
    } END_CASE;

    BEGIN_CASE("parseClause","parseClause") {
        chain.renewInstance();
        Clause_test ct;

        ct.addClause("test","first");

        BEGIN_CASE("1","柤慜嬻娫傪慖戰偟偰惓偟偔愡傪幚峴偱偒傞") {
            stringstream buf;
            Parser p(&buf, "test");
            buf.str("first second");

            TestSuite::clearCheckpoints();
            TEST_CASE("1","娭悢偼惉岟偡傞", Clause::parseClause("test", p));
            TEST_CASE("2","Clause::before偑幚峴偝傟偰偄傞", TestSuite::isReached("Clause_test::before"));
            TEST_CASE("3","Clause::body偑幚峴偝傟偰偄傞", TestSuite::isReached("Clause_test::body"));
            TEST_CASE("4","body偺first偑惓偟偄", ct.first == "first");
            TEST_CASE("5","body偱撉傒弌偟偨僩乕僋儞偑惓偟偄", ct.second == "second");
            TEST_CASE("6","Clause::after偑幚峴偝傟偰偄傞", TestSuite::isReached("Clause_test::after"));
        } END_CASE;

        BEGIN_CASE("2","愡偺張棟拞偵椺奜偑婲偙傞偲onFail偑屇偽傟傞") {
            stringstream buf;
            Parser p(&buf, "test");
            buf.str("first second");

            ct.throw_exception = true;
            TestSuite::clearCheckpoints();

            bool result = false;
            try { Clause::parseClause("test", p); }
            catch(...){ result = true; }

            TEST_CASE("1","椺奜偑婲偙傞", result);
            TEST_CASE("2","Clause::body偑幚峴偝傟偰偄傞", TestSuite::isReached("Clause_test::body"));
            TEST_CASE("3","Clause::onFail偑幚峴偝傟偰偄傞", TestSuite::isReached("Clause_test::onFail"));
        } END_CASE;

        BEGIN_CASE("3","懚嵼偟側偄柤慜嬻娫傪巜掕偡傞") {
            stringstream buf;
            Parser p(&buf, "test");
            buf.str("first second");

            TEST_CASE("1","娭悢偼幐攕偡傞", !Clause::parseClause("unknown", p));
        } END_CASE;

        BEGIN_CASE("4","EOF偵払偟偨僗僩儕乕儉傪巜掕偡傞") {
            stringstream buf;
            Parser p(&buf, "test");
            buf.str("");
            buf.get();

            TEST_CASE("0","[慜採]僗僩儕乕儉偼廔抂偵払偟偰偄傞", buf.eof());
            TEST_CASE("1","娭悢偼幐攕偡傞", !Clause::parseClause("unknown", p));
        } END_CASE;
    } END_CASE;

    chain.restoreContext();
}




namespace {
    class StaticAPI_test : public StaticAPI
    {
    public:
        StaticAPI_test(void) throw() : StaticAPI() {}
        StaticAPI_test(string src) throw() : StaticAPI(src) {}

        void body(const Token & , Parser &) { TestSuite::check("StaticAPI::body"); }
        void onFail_super(const Token & first, Parser & p) throw() { StaticAPI::onFail(first, p); }
    };
}

TESTSUITE(main, StaticAPI)
{
    Singleton<Namespace>::Context context;
    Singleton<Namespace>::saveContext(context);

    Exception::setThrowControl(true);

    BEGIN_CASE("regist","regist") {
        BEGIN_CASE("1","扨堦偺柤慜傪巜掕偟偰搊榐偱偒傞") {
            Singleton<Namespace>::renewInstance();
            StaticAPI_test api;

            api.regist("VTST_API");

            TEST_CASE("1","API偼惓偟偔搊榐偱偒偰偄傞",StaticAPI::hasStaticAPI("VTST_API"));
        } END_CASE;

        BEGIN_CASE("2","暋悢偺柤慜傪巜掕偟偰搊榐偡傞") {
            Singleton<Namespace>::renewInstance();
            StaticAPI_test api;

            api.regist("API_1,API_2,API_3");

            TEST_CASE("1","API偼惓偟偔搊榐偱偒偰偄傞",StaticAPI::hasStaticAPI("API_1"));
            TEST_CASE("2","API偼惓偟偔搊榐偱偒偰偄傞",StaticAPI::hasStaticAPI("API_2"));
            TEST_CASE("3","API偼惓偟偔搊榐偱偒偰偄傞",StaticAPI::hasStaticAPI("API_3"));
        } END_CASE;

        BEGIN_CASE("3","忋彂偒偡傞") {
            Singleton<Namespace>::renewInstance();
            StaticAPI_test api;
            StaticAPI_test api2;
            StaticAPI_test api3;