filecontainer.cpp

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

            TEST_CASE("2","梫慺偑捛壛偝傟偰偄傞 (tinib)", scope != fc.variableinfo.end());
            TEST_CASE("3","抣偑惓偟偄 (tinib)", scope->second.size == 32);

            scope = fc.variableinfo.find("task_initialization_block::texrtn");
            TEST_CASE("4","梫慺偑捛壛偝傟偰偄傞 (texrtn)", scope != fc.variableinfo.end());
            TEST_CASE("5","抣偑惓偟偄 (texrtn.size)", scope->second.size == 4);
            TEST_CASE("6","抣偑惓偟偄 (texrtn.address)", scope->second.address == 28);
        } END_CASE;
        remove("dummy");

        BEGIN_CASE("2","幆暿暥帤 'd' 傪柍帇偡傞") {
            fstream file("dummy",ios::out);
            file << "ddummy,0\ndtask_initialization_block::texrtn,4,28\n";
            file.close();

            TFileContainer fc;

            bool result = true;
            try { fc.attachInfo("dummy"); } catch(...) { result = false; }

            TEST_CASE("1","椺奜偼偍偒側偄", result);
            TEST_CASE("2","梫慺偼捛壛偝傟偰偄側偄", fc.variableinfo.size() == 0);
        } END_CASE;
        remove("dummy");

        BEGIN_CASE("3","嬻峴傪柍帇偱偒傞") {
            fstream file("dummy",ios::out);
            file << "s_kernel_tinib_table,32,0\n\nstask_initialization_block::texrtn,4,28\n";
            file.close();

            TFileContainer fc;

            bool result = true;
            try { fc.attachInfo("dummy"); } catch(...) { result = false; }

            TEST_CASE("1","椺奜偼偍偒側偄", result);

            map<string, struct tagVariableInfo>::iterator scope = fc.variableinfo.find("_kernel_tinib_table");
            TEST_CASE("2","梫慺偑捛壛偝傟偰偄傞 (tinib)", scope != fc.variableinfo.end());
            TEST_CASE("3","抣偑惓偟偄 (tinib)", scope->second.size == 32);

            scope = fc.variableinfo.find("task_initialization_block::texrtn");
            TEST_CASE("4","梫慺偑捛壛偝傟偰偄傞 (texrtn)", scope != fc.variableinfo.end());
            TEST_CASE("5","抣偑惓偟偄 (texrtn.size)", scope->second.size == 4);
            TEST_CASE("6","抣偑惓偟偄 (texrtn.address)", scope->second.address == 28);
        } END_CASE;
        remove("dummy");

        BEGIN_CASE("4","'s'偲'd'埲奜傪偼偠偔") {
            char c;
            char msg[2] = {0, 0};

            for(c=0;c<128;++c) {
                if(isprint(c) && (c != 's' && c != 'd')) {
                    fstream file("dummy",ios::out);
                    file << c;
                    file << "dummy,0\n";
                    file.close();

                    TFileContainer fc;

                    bool result = false;
                    try { fc.attachInfo("dummy"); } catch(...) { result = true; }

                    msg[0] = c;
                    TEST_CASE_("1","椺奜偑偍偒傞", result, string(msg));
                    TEST_CASE_("2","梫慺偼捛壛偝傟偰偄側偄", fc.variableinfo.size() == 0, string(msg));
                }
            }
        } END_CASE;
        remove("dummy");
    } END_CASE;

    chain.restoreContext();
}

class TTargetVariable : public TargetVariable<int>
{
    TESTSUITE_PROTOTYPE(main)

        /*
         * 僐儞僗僩儔僋僞 (TargetVariable<int>偵夞憲)
         */
    inline TTargetVariable(FileContainer::address_t addr) throw()
        : TargetVariable<int>(addr)
    {}
    
    inline TTargetVariable(FileContainer::address_t addr, size_t sz) throw()
        : TargetVariable<int>(addr, sz)
    {}

    inline TTargetVariable(FileContainer::address_t addr, size_t sz, size_t ofs, size_t ssz) throw()
        : TargetVariable<int>(addr, sz, ofs, ssz)
    {}

    inline TTargetVariable(const std::string & sym) throw()
        : TargetVariable<int>(sym)
    {}

    inline TTargetVariable(const std::string & sym, const std::string & sz) throw()
        : TargetVariable<int>(sym, sz)
    {}

        /* 僨僗僩儔僋僞 (摿偵壗傕偟側偄) */
    virtual ~TTargetVariable(void) throw() 
    {}
};

TESTSUITE(main, TTargetVariable)
{
    PREDECESSOR("SingletonBase");
    PREDECESSOR("TFileContainer");
    PREDECESSOR("RuntimeObjectTable");

    SingletonBase::ContextChain chain;
    chain.saveContext<RuntimeObjectTable>();
    chain.renewInstance();

    TFileContainer fc;
    fstream file("dummy",ios::out);
    file << "s_test,4,0\ns_kernel_tinib_table,32,0\nstask_initialization_block::texrtn,4,28\n";
    file.close();

    fc.attachInfo("dummy");

    BEGIN_CASE("constructor","僐儞僗僩儔僋僞") {
        BEGIN_CASE("1", "(address_t, size_t)") {
            TTargetVariable tv(1, 2);

            TEST_CASE("1","曄悢偼桳岠", tv.isValid());
            TEST_CASE("2","傾僪儗僗偼惓偟偄", tv.getAddress() == 1);
            TEST_CASE("3","僒僀僘偼惓偟偄", tv.getSize() == 2);
            TEST_CASE("4","僆僼僙僢僩偼0", tv.getOffset() == 0);
            TEST_CASE("5","峔憿懱僒僀僘偼曄悢僒僀僘偲堦弿", tv.getStructureSize() == tv.getSize());
        } END_CASE;

        BEGIN_CASE("2","(address_t, size_t, size_t, size_t)") {
            TTargetVariable tv(1,2,3,4);

            TEST_CASE("1","曄悢偼桳岠", tv.isValid());
            TEST_CASE("2","傾僪儗僗偼惓偟偄", tv.getAddress() == 1);
            TEST_CASE("3","僒僀僘偼惓偟偄", tv.getSize() == 2);
            TEST_CASE("4","僆僼僙僢僩偼惓偟偄", tv.getOffset() == 3);
            TEST_CASE("5","峔憿懱僒僀僘偼惓偟偄", tv.getStructureSize() == 4);
        } END_CASE;

        BEGIN_CASE("3","(string)") {
            TestSuite::clearCheckpoints();

            TTargetVariable tv("_test");

            TEST_CASE("1","曄悢偼桳岠", tv.isValid());
            TEST_CASE("2","getSymbolAddress偑僐乕儖偝傟偰偄傞", TestSuite::isReached("getSymbolAddress"));
            TEST_CASE("3","getSymbolAddress偺堷悢偑惓偟偄", fc.symbol.compare("_test") == 0);
            TEST_CASE("3","傾僪儗僗偼惓偟偄", tv.getAddress() == 1);
            TEST_CASE("4","僒僀僘偼惓偟偄", tv.getSize() == 4);
            TEST_CASE("5","僆僼僙僢僩偼惓偟偄", tv.getOffset() == 0);
            TEST_CASE("6","峔憿懱僒僀僘偼惓偟偄", tv.getStructureSize() == 4);
        } END_CASE;

        BEGIN_CASE("4","(string,string)") {
            TestSuite::clearCheckpoints();

            TTargetVariable tv("_kernel_tinib_table", "task_initialization_block::texrtn");

            TEST_CASE("1","曄悢偼桳岠", tv.isValid());
            TEST_CASE("2","getSymbolAddress偑僐乕儖偝傟偰偄傞", TestSuite::isReached("getSymbolAddress"));
            TEST_CASE("3","getSymbolAddress偺堷悢偑惓偟偄", fc.symbol.compare("_kernel_tinib_table") == 0);
            TEST_CASE("3","傾僪儗僗偼惓偟偄", tv.getAddress() == 1);
            TEST_CASE("4","僒僀僘偼惓偟偄", tv.getSize() == 4);
            TEST_CASE("5","僆僼僙僢僩偼惓偟偄", tv.getOffset() == 28);
            TEST_CASE("6","峔憿懱僒僀僘偼惓偟偄", tv.getStructureSize() == 32);
        } END_CASE;

        BEGIN_CASE("5","柍岠側働乕僗") {
            TEST_CASE("1","傾僪儗僗0偺曄悢偼柍岠 (1)", !TTargetVariable(0,4).isValid());
            TEST_CASE("2","傾僪儗僗0偺曄悢偼柍岠 (2)", !TTargetVariable(0,4,4,4).isValid());
            TEST_CASE("3","僒僀僘0偺曄悢偼柍岠 (1)", !TTargetVariable(4,0).isValid());
            TEST_CASE("4","僒僀僘0偺曄悢偼柍岠 (2)", !TTargetVariable(4,0,4,4).isValid());
            TEST_CASE("5","峔憿懱僒僀僘0偺曄悢偼柍岠", !TTargetVariable(4,4,4,0).isValid());

            TEST_CASE("6","懚嵼偟側偄僔儞儃儖柤偺曄悢傕柍岠(1)", !TTargetVariable("unknown").isValid());
            TEST_CASE("7","懚嵼偟側偄僔儞儃儖柤偺曄悢傕柍岠(2)", !TTargetVariable("unknown","task_initialization_block::texrtn").isValid());
            TEST_CASE("8","懚嵼偟側偄儊儞僶柤偺曄悢傕柍岠", !TTargetVariable("_kernel_tinib_table","unknown").isValid());

            TEST_CASE("10","奿擺椞堟偑晄懌偟偰偄傞曄悢", !TTargetVariable("_kernel_tinib_table").isValid());
            TEST_CASE("11","柍岠側堷悢傪傕傜偭偨応崌", !TTargetVariable(*((TTargetVariable *)0)).isValid());
        } END_CASE;
    } END_CASE;

    BEGIN_CASE("loadContents", "loadContents") {
        BEGIN_CASE("1","捠忢婲摦") {
            int i;
            TTargetVariable tv(0x100);

            bool result = true;
            try { tv.loadContent(&i, sizeof(int)); } catch(...) { result = false; }

            TEST_CASE("1","椺奜偼婲偙傜側偄", result);
            TEST_CASE("2","拞恎偼~0偱僼傿儖偝傟偰偄傞", i == ~0);
        } END_CASE;

        BEGIN_CASE("2","尦傛傝傕戝偒側宆偱庴偗傞") {
            struct { int first; int second; } i;
            TTargetVariable tv(0x100);

            bool result = true;
            try { tv.loadContent(&i, sizeof(i)); } catch(...) { result = false; }

            TEST_CASE("1","椺奜偼婲偙傜側偄", result);
            TEST_CASE("2","拞恎偼~0偱僼傿儖偝傟偰偄傞", i.first == ~0);
            TEST_CASE("3","巆傝偼0偱僼傿儖偝傟偰偄傞", i.second == 0);
        } END_CASE;

        BEGIN_CASE("3","柍岠側梫慺偵懳偟偰幚峴偡傞") {
            TTargetVariable tv(0, 0, 0, 0);
            int i;

            bool result = false;
            try{ tv.loadContent(&i, sizeof(i)); } catch(...) { result = true; }
            TEST_CASE("1","椺奜偑婲偒傞", result);
        } END_CASE;

        BEGIN_CASE("4","尦傛傝傕彫偝側宆偱庴偗傞") {
            char i;
            TTargetVariable tv(0x100);

            bool result = false;
            try { tv.loadContent(&i, sizeof(i)); } catch(...) { result = true; }

            TEST_CASE("1","椺奜偑婲偙傞", result);
        } END_CASE;

    } END_CASE;

    BEGIN_CASE("pointer_operators","億僀儞僞晽偺墘嶼") {
        TargetVariable<int> tv(0x100);
        TargetVariable<int> tvl(0x100);

        *tvl;

        TEST_CASE("0","[慜採] tv:傾僪儗僗偼0x100", tv.getAddress() == 0x100);
        TEST_CASE("0","[慜採] tv:僒僀僘偼4", tv.getSize() == 4);
        TEST_CASE("0","[慜採] tv:峔憿懱僒僀僘傕4", tv.getStructureSize() == 4);
        TEST_CASE("0","[慜採] tv:撉弌偟枹椆", !tv.isLoaded());
        TEST_CASE("0","[慜採] tvl:傾僪儗僗偼0x100", tvl.getAddress() == 0x100);
        TEST_CASE("0","[慜採] tvl:僒僀僘偼4", tvl.getSize() == 4);
        TEST_CASE("0","[慜採] tvl:峔憿懱僒僀僘傕4", tvl.getStructureSize() == 4);
        TEST_CASE("0","[慜採] tvl:撉弌偟姰椆", tvl.isLoaded());

        BEGIN_CASE("1","operator +") {
            TestSuite::clearCheckpoints();

            TargetVariable<int> work = tv + 0x10;
            TEST_CASE("1","work偺傾僪儗僗偼0x140", work.getAddress() == 0x100 + sizeof(int) * 0x10);
            TEST_CASE("2","work偼撉傒崬傑傟偰偄側偄", !work.isLoaded());
        } END_CASE;

        BEGIN_CASE("2","operator -") {
            TestSuite::clearCheckpoints();

            TargetVariable<int> work = tv - 0x10;
            TEST_CASE("1","work偺傾僪儗僗偼0xc0", work.getAddress() == 0x100 - sizeof(int) * 0x10);
            TEST_CASE("2","work偼撉傒崬傑傟偰偄側偄", !work.isLoaded());
        } END_CASE;

        BEGIN_CASE("3","operator ++") {
            TestSuite::clearCheckpoints();

            TargetVariable<int> work(tvl);

            TargetVariable<int> result = (++ work);

            TEST_CASE("1","work偺傾僪儗僗偼0x104", work.getAddress() == 0x100 + sizeof(int));
            TEST_CASE("2","work == result", work == result);
            TEST_CASE("3","撉傒崬傒枹椆忬懺", !result.isLoaded());
        } END_CASE;

        BEGIN_CASE("4","operator ++(int)") {
            TestSuite::clearCheckpoints();

            TargetVariable<int> work(tvl);

            TargetVariable<int> result = (work++);

            TEST_CASE("1","work偺傾僪儗僗偼0x104", work.getAddress() == 0x100 + sizeof(int));
            TEST_CASE("2","result偺傾僪儗僗偼0x100", result.getAddress() == 0x100);
            TEST_CASE("3","撉傒崬傒姰椆忬懺", result.isLoaded());
        } END_CASE;

        BEGIN_CASE("5","operator --") {
            TestSuite::clearCheckpoints();

            TargetVariable<int> work(tvl);

            TargetVariable<int> result = (-- work);

            TEST_CASE("1","work偺傾僪儗僗偼0x9c", work.getAddress() == 0x100 - sizeof(int));
            TEST_CASE("2","work == result", work == result);
            TEST_CASE("3","撉傒崬傒枹椆忬懺", !result.isLoaded());
        } END_CASE;

        BEGIN_CASE("6","operator --(int)") {
            TestSuite::clearCheckpoints();

            TargetVariable<int> work(tvl);

            TargetVariable<int> result = (work--);

            TEST_CASE("1","work偺傾僪儗僗偼0x9c", work.getAddress() == 0x100 - sizeof(int));
            TEST_CASE("2","result偺傾僪儗僗偼0x100", result.getAddress() == 0x100);
            TEST_CASE("3","撉傒崬傒姰椆忬懺", result.isLoaded());
        } END_CASE;

        BEGIN_CASE("7","operator +=") {
            TestSuite::clearCheckpoints();

            TargetVariable<int> work(tvl);

            work += 0x10;

            TEST_CASE("1","work偺傾僪儗僗偼0x140", work.getAddress() == 0x100 + sizeof(int) * 0x10);
            TEST_CASE("2","撉傒崬傒枹椆忬懺", !work.isLoaded());
        } END_CASE;

        BEGIN_CASE("8","operator -=") {
            TestSuite::clearCheckpoints();

            TargetVariable<int> work(tvl);

            work -= 0x10;

            TEST_CASE("1","work偺傾僪儗僗偼0xc0", work.getAddress() == 0x100 - sizeof(int) * 0x10);
            TEST_CASE("2","撉傒崬傒枹椆忬懺", !work.isLoaded());
        } END_CASE;

        BEGIN_CASE("9", "operator &") {
            TEST_CASE("1","傾僪儗僗偑敳偗傞", &tv == 0x100);
            TEST_CASE("2","NULL僀儞僗僞儞僗偵偼0偑曉傞", &(*((TargetVariable<int> *)0)) == 0);
        } END_CASE;

        BEGIN_CASE("10", "operator *") {
            TestSuite::clearCheckpoints();
            TargetVariable<int> work(0x100);

            const void * result = &(*work);

            TEST_CASE("1","loadContents偑幚峴偝傟偰偄傞", TestSuite::isReached("loadContents"));
            TEST_CASE("2","堷悢偑惓偟偄", fc.addr == 0x100);
            TEST_CASE("3","堷悢偑惓偟偄", fc.sz == sizeof(int));

            TestSuite::clearCheckpoints();
            *work;

            TEST_CASE("4","loadContents偼幚峴偝傟側偄", !TestSuite::isReached("loadContents"));
        } END_CASE;

        BEGIN_CASE("11","operator ==/!=") {
            TEST_CASE("1","傾僪儗僗偑堦抳偡傟偽OK", tv == TTargetVariable(tv.getAddress()));
            TEST_CASE("2","NULL僀儞僗僞儞僗偲偺斾妑傕偱偒傞", tv != *((TTargetVariable *)0));
        } END_CASE;

        BEGIN_CASE("cvr","僇僶儗僢僕懳嶔") {
            
            (*((TTargetVariable *)0)) ++;

        } END_CASE;

    } END_CASE;

    chain.restoreContext();
}


#endif