source: trunk/MFCtooling/replay/replay.cpp @ 231

// replay.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include "LogParser.h"
#include "SAXContentHandlerImpl.h"
#include <iostream>

#include "options.h"

const char * optv[] = {
        "r:resultfile <string>",
        "d:msgdelay <number>",
        "w:wait <number>",
        "s:startdelay <number>",
        "p:path <string>"
};

void convertTCharToChar(const TCHAR * source, char ** dest) {
#ifdef UNICODE
        std::wstring wstr(source);
    int size_needed = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL);
    std::string strTo( size_needed, 0 );
    WideCharToMultiByte                  (CP_UTF8, 0, &wstr[0], (int)wstr.size(), &strTo[0], size_needed, NULL, NULL);
        *dest = new char[strTo.size()+1];
        memcpy((void*)*dest, strTo.c_str(), strTo.size()+1);
#else
        std::string str(source);
        *dest = new char[strTo.size()+1];
        memcpy(*dest, strTo.c_str(), strTo.size()+1);
#endif
}

void convertCharToTChar(const char * source, TCHAR ** dest) {
#ifdef UNICODE
        std::string str(source);
        int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), NULL, 0);
        std::wstring wstrTo( size_needed, 0 );
        MultiByteToWideChar                  (CP_UTF8, 0, &str[0], (int)str.size(), &wstrTo[0], size_needed);
        *dest = new TCHAR[wstrTo.size()+1];
        memcpy((void*)*dest, wstrTo.c_str(), (wstrTo.size()+1)*sizeof(TCHAR));
#else
        std::string str(source);
        *dest = new char[strTo.size()+1];
        memcpy(*dest, strTo.c_str(), strTo.size()+1);
#endif
}

int _tmain(int argc, _TCHAR* argv[])
{
        if( argc < 3 ) {
                std::wcout << L"Usage: " << argv[0] << L"<replayfile> <applicationundertest> [-r <resultfile>] [-d <useDefaultDelay>] [-w <waitAfterFinish>] [-p <workingPath>] [-s <startupDelay>]" << std::endl;
                return 1;
        }

        int optchar = 0;
        const char * optarg;
        // set default values
        TCHAR * resultfile = NULL;
        int msgdelay = 0;
        int startdelay = 5000;
        int wait = 1;
        TCHAR * workingPath = NULL;

        int argc_char = argc-2;
        char ** argv_char = new char*[argc_char];

        // convert argv to char*[]
        convertTCharToChar(argv[0], &argv_char[0]);
        for( int i=3; i<argc; i++ ) {
                convertTCharToChar(argv[i], &argv_char[i-2]);
        }

        // parse options
        Options opts(*argv_char, optv);
        OptArgvIter iter(--argc_char, ++argv_char);
        while( optchar = opts(iter, optarg) ) {
                switch(optchar) {
                        case 'r':
                                convertCharToTChar(optarg, &resultfile);
                                break;
                        case 'd':
                                msgdelay = atoi(optarg);
                                break;
                        case 'w':
                                wait = atoi(optarg);
                                break;
                        case 'p':
                                convertCharToTChar(optarg, &workingPath);
                                break;
                        case 's':
                                startdelay = atoi(optarg);
                                break;
                        default:
                                break;
                }
        }
        for( int i=0; i<argc_char; i++ ) {
                delete[] argv_char[i];
        }
        //delete[] argv_char; //TODO does not work?!

        TCHAR * replayfile = argv[1];
        TCHAR * appUnderTest = argv[2];

        // initialize COM library for the current thread
        CoInitialize(NULL); 
        MSXML2::ISAXXMLReader* pXMLReader = NULL;

        // create an instance of the XML reader
        HRESULT hr = CoCreateInstance(
                __uuidof(MSXML2::SAXXMLReader), 
                NULL, 
                CLSCTX_ALL, 
                __uuidof(MSXML2::ISAXXMLReader), 
                (void **)&pXMLReader);

        if( !FAILED(hr) ) {
                TestResults results(replayfile);
                std::wcout << L"replaying sessions in " << argv[1] << std::endl;
                LogParser * parser = new LogParser(appUnderTest, startdelay, &results, (bool) msgdelay);
                parser->setWorkingPath(workingPath);
                pXMLReader->putContentHandler(parser);
                hr = pXMLReader->parseURL(replayfile);
                if( hr!=S_OK ) {
                        std::wcout << L"failure parsing XML file" << std::endl;
                        return 1;
                }
                pXMLReader->Release();
                std::wcout << L"================================================" << std::endl;
                std::wcout << L"replay completed" << std::endl;
                if( resultfile!=NULL ) {
                        results.write(resultfile);
                        std::wcout << L"results written to " << resultfile << std::endl;
                }
        }

        CoUninitialize();
        
        if( wait!=0 ) {
                std::wcout << L"press enter to exit ...";
                getchar();
        }

        delete resultfile;

        return 0;
}