clause.cpp

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

            api.regist("test");
            TEST_CASE("1","API偼惓偟偔搊榐偱偒偰偄傞",StaticAPI::hasStaticAPI("test"));
            TEST_CASE("2","API僴儞僪儔偑惓偟偄", (*StaticAPI::getClauseMap(NAMESPACE_STATICAPI))["test"] == &api);

            api2.regist("test");
            TEST_CASE("3","API僴儞僪儔偑忋彂偒偝傟偰偄傞", (*StaticAPI::getClauseMap(NAMESPACE_STATICAPI))["test"] == &api2);

            api3.regist("test");
            TEST_CASE("4","API僴儞僪儔偑忋彂偒偝傟偰偄傞", (*StaticAPI::getClauseMap(NAMESPACE_STATICAPI))["test"] == &api3);
        } END_CASE;

        BEGIN_CASE("4","僐儞僗僩儔僋僞偱搊榐") {
            Singleton<Namespace>::renewInstance();
            StaticAPI_test api("API1,API2,API3");

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

    BEGIN_CASE("parseStaticAPI","parseStaticAPI") {
        BEGIN_CASE("1","惷揑API傪惓偟偔張棟偱偒傞") {
            Singleton<Namespace>::renewInstance();
            stringstream buf;
            StaticAPI_test api("API");

            buf.str("API();");
            Parser p(&buf, "test");

            TestSuite::clearCheckpoints();
            bool result = true;
            try { StaticAPI::parseStaticAPI(p); }
            catch(...) { result = false; }

            TEST_CASE("1","椺奜偼婲傜側偄", result);
            TEST_CASE("2","惷揑API偺杮懱偑屇偽傟偰偄傞", TestSuite::isReached("StaticAPI::body"));
        } END_CASE;

        BEGIN_CASE("2","'('朰傟偱椺奜") {
            Singleton<Namespace>::renewInstance();
            stringstream buf;
            StaticAPI_test api("API");

            buf.str("API);");
            Parser p(&buf, "test");

            TestSuite::clearCheckpoints();
            bool result = false;
            try { StaticAPI::parseStaticAPI(p); }
            catch(...) { result = true; }

            TEST_CASE("1","椺奜偑婲傞", result);
            TEST_CASE("2","惷揑API偺杮懱偑屇偽傟側偄", !TestSuite::isReached("StaticAPI::body"));
        } END_CASE;

        BEGIN_CASE("3","')'朰傟偱椺奜") {
            Singleton<Namespace>::renewInstance();
            stringstream buf;
            StaticAPI_test api("API");

            buf.str("API(; NEXT");
            Parser p(&buf, "test");

            TestSuite::clearCheckpoints();
            bool result = false;
            try { StaticAPI::parseStaticAPI(p); }
            catch(...) { result = true; }

            TEST_CASE("1","椺奜偑婲傞", result);
            TEST_CASE("2","惷揑API偺杮懱偑屇偽傟偰偄傞", TestSuite::isReached("StaticAPI::body"));
        } END_CASE;

        BEGIN_CASE("4","';'朰傟偱椺奜") {
            Singleton<Namespace>::renewInstance();
            stringstream buf;
            StaticAPI_test api("API");

            buf.str("API() NEXT");
            Parser p(&buf, "test");

            TestSuite::clearCheckpoints();
            bool result = false;
            try { StaticAPI::parseStaticAPI(p); }
            catch(...) { result = true; }

            TEST_CASE("1","椺奜偑婲傞", result);
            TEST_CASE("2","惷揑API偺杮懱偑屇偽傟偰偄傞", TestSuite::isReached("StaticAPI::body"));
        } END_CASE;
    } END_CASE;

    BEGIN_CASE("onFail","onFail") {
        BEGIN_CASE("1","僙儈僐儘儞傑偱撉傒旘偽偟") {
            Singleton<Namespace>::renewInstance();
            stringstream buf;
            Parser p(&buf, "test");
            StaticAPI_test api;
            Token token;
            buf.str("api parameter;next_api next_api_parameter;");

            api.onFail_super(Token(), p);

            TEST_CASE("1","僙儈僐儘儞偺師偑撉傔傞", p.getToken() == "next_api");
        } END_CASE;

        BEGIN_CASE("2","師偺API傑偱撉傒旘偽偟") {
            Singleton<Namespace>::renewInstance();
            stringstream buf;
            Parser p(&buf, "test");
            StaticAPI_test api("api,next_api");
            buf.str("api parameter_1 parameter_2 next_api next_api_parameter;");

            api.onFail_super(p.getToken(), p);

            TEST_CASE("1","師偺API柤偑撉傔傞", p.getToken() == "next_api");
        } END_CASE;
    } END_CASE;

    BEGIN_CASE("skip","skip") {
        BEGIN_CASE("1","僙儈僐儘儞傑偱撉傒旘偽偟") {
            Singleton<Namespace>::renewInstance();
            stringstream buf;
            Parser p(&buf, "test");
            StaticAPI_test api;
            Token token;
            buf.str("api parameter;next_api next_api_parameter;");

            StaticAPI::skip(p);

            TEST_CASE("1","僙儈僐儘儞偺師偑撉傔傞", p.getToken() == "next_api");
        } END_CASE;

        BEGIN_CASE("2","師偺API傑偱撉傒旘偽偟") {
            Singleton<Namespace>::renewInstance();
            stringstream buf;
            Parser p(&buf, "test");
            StaticAPI_test api("api,next_api");
            buf.str("parameter_1 parameter_2 next_api next_api_parameter;");

            StaticAPI::skip(p);

            TEST_CASE("1","師偺API柤師偑撉傔傞", p.getToken() == "next_api");
        } END_CASE;

        BEGIN_CASE("3","愭摢偑API柤偱傕撉傒旘偽偟偱偒傞") {
            Singleton<Namespace>::renewInstance();
            stringstream buf;
            Parser p(&buf, "test");
            StaticAPI_test api("api,next_api");
            buf.str("api parameter_1 parameter_2 next_api next_api_parameter;");

            StaticAPI::skip(p);

            TEST_CASE("1","師偺API柤偑撉傔傞", p.getToken() == "next_api");
        } END_CASE;
    } END_CASE;
    
    Singleton<Namespace>::restoreContext(context);
}


namespace {
    class Directives_test : public Directives
    {
    public:
        bool throws;

        Directives_test(void) throw() : Directives(), throws(false) {}
        Directives_test(string src) throw() : Directives(src), throws(false)  {}

        void body(const Token & , Parser & ) throw(int)
        {
            TestSuite::check("Directives::body");
            if(throws)
                throw 0;
        }
    };
}

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

    Exception::setThrowControl(true);

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

            api.regist("include");

            TEST_CASE("1","API偼惓偟偔搊榐偱偒偰偄傞",Directives::hasDirectives("include"));
        } END_CASE;

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

            api.regist("pragma,define,endif");

            TEST_CASE("1","僨傿儗僋僥傿僽偼惓偟偔搊榐偱偒偰偄傞",Directives::hasDirectives("pragma"));
            TEST_CASE("2","僨傿儗僋僥傿僽偼惓偟偔搊榐偱偒偰偄傞",Directives::hasDirectives("define"));
            TEST_CASE("3","僨傿儗僋僥傿僽偼惓偟偔搊榐偱偒偰偄傞",Directives::hasDirectives("endif"));
        } END_CASE;

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

            api.regist("test");
            TEST_CASE("1","僨傿儗僋僥傿僽偼惓偟偔搊榐偱偒偰偄傞",Directives::hasDirectives("test"));
            TEST_CASE("2","僨傿儗僋僥傿僽僴儞僪儔偑惓偟偄", (*Directives::getClauseMap(NAMESPACE_DIRECTIVES))["test"] == &api);

            api2.regist("test");
            TEST_CASE("3","僨傿儗僋僥傿僽僴儞僪儔偑忋彂偒偝傟偰偄傞", (*Directives::getClauseMap(NAMESPACE_DIRECTIVES))["test"] == &api2);

            api3.regist("test");
            TEST_CASE("4","僨傿儗僋僥傿僽僴儞僪儔偑忋彂偒偝傟偰偄傞", (*Directives::getClauseMap(NAMESPACE_DIRECTIVES))["test"] == &api3);
        } END_CASE;

        BEGIN_CASE("4","僐儞僗僩儔僋僞偱搊榐") {
            Singleton<Namespace>::renewInstance();
            Directives_test api("pragma,define,endif");

            TEST_CASE("1","僨傿儗僋僥傿僽偼惓偟偔搊榐偱偒偰偄傞",Directives::hasDirectives("pragma"));
            TEST_CASE("2","僨傿儗僋僥傿僽偼惓偟偔搊榐偱偒偰偄傞",Directives::hasDirectives("define"));
            TEST_CASE("3","僨傿儗僋僥傿僽偼惓偟偔搊榐偱偒偰偄傞",Directives::hasDirectives("endif"));
        } END_CASE;
    } END_CASE;
    
    BEGIN_CASE("parseDirectives","parseDirectives") {
        BEGIN_CASE("1","僨傿儗僋僥傿僽傪惓偟偔張棟偱偒傞") {
            Singleton<Namespace>::renewInstance();
            stringstream buf;
            Directives_test api("pragma");

            buf.str("pragma\nnext\n");
            Parser p(&buf, "test");

            TestSuite::clearCheckpoints();
            bool result = true;
            try { Directives::parseDirectives(p); }
            catch(...) { result = false; }

            TEST_CASE("1","椺奜偼婲傜側偄", result);
            TEST_CASE("2","僨傿儗僋僥傿僽偺杮懱偑屇偽傟偰偄傞", TestSuite::isReached("Directives::body"));
        } END_CASE;

        BEGIN_CASE("2","夵峴側偟(晄惓僷儔儊乕僞)偱椺奜") {
            Singleton<Namespace>::renewInstance();
            stringstream buf;
            Directives_test api("pragma");

            buf.str("pragma next\n");
            Parser p(&buf, "test");

            TestSuite::clearCheckpoints();
            bool result = false;
            try { Directives::parseDirectives(p); }
            catch(...) { result = true; }

            TEST_CASE("1","椺奜偑婲傞", result);
            TEST_CASE("2","僨傿儗僋僥傿僽偺杮懱偑屇偽傟偰偄傞", TestSuite::isReached("Directives::body"));
        } END_CASE;

        BEGIN_CASE("3","夵峴側偟(EOF)偱椺奜") {
            Singleton<Namespace>::renewInstance();
            stringstream buf;
            Directives_test api("pragma");

            buf.str("pragma");
            Parser p(&buf, "test");

            TestSuite::clearCheckpoints();
            bool result = false;
            try { Directives::parseDirectives(p); }
            catch(...) { result = true; }

            TEST_CASE("1","椺奜偑婲傞", result);
            TEST_CASE("2","僨傿儗僋僥傿僽偺杮懱偑屇偽傟偰偄傞", TestSuite::isReached("Directives::body"));
        } END_CASE;
    } END_CASE;

    BEGIN_CASE("onFail","onFail") {
        BEGIN_CASE("1","body偱椺奜偑婲傞偲onFail偑師偺夵峴傑偱撉傒旘偽偡") {
            Singleton<Namespace>::renewInstance();
            stringstream buf;
            Directives_test api("pragma");
            buf.str("pragma parameter\nnext\n");
            Parser p(&buf, "test");

            api.throws = true;
            bool result = false;
            try { Directives::parseDirectives(p); }
            catch(...) { result = true; }

            TEST_CASE("1","椺奜偑婲傞", result);
            TEST_CASE("2","巆偭偨撪梕偑惓偟偄", p.getToken() == "next");
            TEST_CASE("3","僩乕僋儞偼峴摢", p.isHeadofLine());
        } END_CASE;
    } END_CASE;
            
    Singleton<Namespace>::restoreContext(context);
}

#endif