CWineTest Class Reference

#include <CWineTest.h>

Inheritance diagram for CWineTest:

Collaboration diagram for CWineTest:

Public Member Functions
	CWineTest ()
	~CWineTest ()
void	Run ()
virtual void	Run ()=0

Private Member Functions
bool	GetNextFile ()
bool	GetNextTest ()
CTestInfo *	GetNextTestInfo ()
DWORD	DoListCommand ()
void	RunTest (CTestInfo *TestInfo)

Private Attributes
HANDLE	m_hFind
PCHAR	m_ListBuffer
string	m_CurrentTest
wstring	m_CurrentFile
wstring	m_CurrentListCommand
wstring	m_TestPath

Detailed Description

Definition at line 8 of file CWineTest.h.

Constructor & Destructor Documentation

CWineTest()

CWineTest::CWineTest

(

)

Constructs a CWineTest object.

Definition at line 20 of file CWineTest.cpp.

    : m_hFind(NULL), m_ListBuffer(NULL)
{
    WCHAR wszDirectory[MAX_PATH];
 
    /* Set up m_TestPath */
    if (GetEnvironmentVariableW(L"ROSAUTOTEST_DIR", wszDirectory, MAX_PATH))
    {
        m_TestPath = wszDirectory;
        if (*m_TestPath.rbegin() != L'\\')
            m_TestPath += L'\\';
    }
    else
    {
        if (!GetWindowsDirectoryW(wszDirectory, MAX_PATH))
            FATAL("GetWindowsDirectoryW failed\n");
 
        m_TestPath = wszDirectory;
        m_TestPath += L"\\bin\\";
    }
}

~CWineTest()

CWineTest::~CWineTest

(

)

Destructs a CWineTest object.

Definition at line 45 of file CWineTest.cpp.

{
    if(m_hFind)
        FindClose(m_hFind);
 
    if(m_ListBuffer)
        delete m_ListBuffer;
}

Member Function Documentation

DoListCommand()

DWORD CWineTest::DoListCommand ( )

private

Executes the –list command of a module test file to get information about the available tests.

Returns

The number of bytes we read into the m_ListBuffer member variable by capturing the output of the –list command.

Definition at line 144 of file CWineTest.cpp.

{
    DWORD BytesAvailable;
    DWORD Temp;
    wstring CommandLine;
    CPipe Pipe;
 
    /* Build the command line */
    CommandLine = m_TestPath;
    CommandLine += m_CurrentFile;
    CommandLine += L" --list";
 
    {
        /* Start the process for getting all available tests */
        CPipedProcess Process(CommandLine, Pipe);
 
        /* Wait till this process ended */
        if(WaitForSingleObject(Process.GetProcessHandle(), ListTimeout) == WAIT_FAILED)
            TESTEXCEPTION("WaitForSingleObject failed for the test list\n");
    }
 
    /* Read the output data into a buffer */
    if(!Pipe.Peek(NULL, 0, NULL, &BytesAvailable))
        TESTEXCEPTION("CPipe::Peek failed for the test list\n");
 
    /* Check if we got any */
    if(!BytesAvailable)
    {
        stringstream ss;
 
        ss << "The --list command did not return any data for " << UnicodeToAscii(m_CurrentFile) << endl;
        TESTEXCEPTION(ss.str());
    }
 
    /* Read the data */
    m_ListBuffer = new char[BytesAvailable];
 
    if(Pipe.Read(m_ListBuffer, BytesAvailable, &Temp, INFINITE) != ERROR_SUCCESS)
        TESTEXCEPTION("CPipe::Read failed\n");
 
    return BytesAvailable;
}

Referenced by GetNextTest().

GetNextFile()

bool CWineTest::GetNextFile ( )

private

Gets the next module test file using the FindFirstFileW/FindNextFileW API.

Returns

true if we found a next file, otherwise false.

Definition at line 61 of file CWineTest.cpp.

{
    bool FoundFile = false;
    WIN32_FIND_DATAW fd;
 
    /* Did we already begin searching for files? */
    if (m_hFind)
    {
        /* Then get the next file (if any) */
        if (FindNextFileW(m_hFind, &fd))
        {
            // printf("cFileName is '%S'.\n", fd.cFileName);
            /* If it was NOT rosautotest.exe then proceed as normal */
            if (_wcsicmp(fd.cFileName, TestName) != 0)
            {
                FoundFile = true;
            }
            else
            {
                /* It was rosautotest.exe so get the next file (if any) */
                if (FindNextFileW(m_hFind, &fd))
                {
                    FoundFile = true;
                }
                // printf("cFileName is '%S'.\n", fd.cFileName);
            }
        }
    }
    else
    {
        /* Start searching for test files */
        wstring FindPath = m_TestPath;
 
        /* Did the user specify a module? */
        if(Configuration.GetModule().empty())
        {
            /* No module, so search for all files in that directory */
            FindPath += L"*.exe";
        }
        else
        {
            /* Search for files with the pattern "modulename_*" */
            FindPath += Configuration.GetModule();
            FindPath += L"_*.exe";
        }
 
        /* Search for the first file and check whether we got one */
        m_hFind = FindFirstFileW(FindPath.c_str(), &fd);
 
        /* If we returned a good handle */
        if (m_hFind != INVALID_HANDLE_VALUE)
        {
            // printf("cFileName is '%S'.\n", fd.cFileName);
            /* If it was NOT rosautotest.exe then proceed as normal */
            if (_wcsicmp(fd.cFileName, TestName) != 0)
            {
                FoundFile = true;
            }
            else
            {
                /* It was rosautotest.exe so get the next file (if any) */
                if (FindNextFileW(m_hFind, &fd))
                {
                    FoundFile = true;
                }
                // printf("cFileName is '%S'.\n", fd.cFileName);
            }
        }
    }
 
    if(FoundFile)
        m_CurrentFile = fd.cFileName;
 
    return FoundFile;
}

Referenced by GetNextTestInfo().

GetNextTest()

bool CWineTest::GetNextTest ( )

private

Gets the next test from m_ListBuffer, which was filled with information from the –list command.

Returns

true if a next test was found, otherwise false.

Definition at line 194 of file CWineTest.cpp.

{
    PCHAR pEnd;
    static DWORD BufferSize;
    static PCHAR pStart;
 
    if(!m_ListBuffer)
    {
        /* Perform the --list command */
        BufferSize = DoListCommand();
 
        /* Move the pointer to the first test */
        pStart = strchr(m_ListBuffer, '\n');
        pStart += 5;
    }
 
    /* If we reach the buffer size, we finished analyzing the output of this test */
    if(pStart >= (m_ListBuffer + BufferSize))
    {
        /* Clear m_CurrentFile to indicate that */
        m_CurrentFile.clear();
 
        /* Also free the memory for the list buffer */
        delete[] m_ListBuffer;
        m_ListBuffer = NULL;
 
        return false;
    }
 
    /* Get start and end of this test name */
    pEnd = pStart;
 
    while(*pEnd != '\r')
        ++pEnd;
 
    /* Store the test name */
    m_CurrentTest = string(pStart, pEnd);
 
    /* Move the pointer to the next test */
    pStart = pEnd + 6;
 
    return true;
}

Referenced by GetNextTestInfo().

GetNextTestInfo()

CTestInfo * CWineTest::GetNextTestInfo ( )

privatevirtual

Interface to CTestList-derived classes for getting all information about the next test to be run.

Returns

Returns a pointer to a CTestInfo object containing all available information about the next test.

Implements CTest.

Definition at line 245 of file CWineTest.cpp.

{
    while(!m_CurrentFile.empty() || GetNextFile())
    {
        /* The user asked for a list of all modules */
        if (Configuration.ListModulesOnly())
        {
            std::stringstream ss;
            ss << "Module: " << UnicodeToAscii(m_CurrentFile) << endl;
            m_CurrentFile.clear();
            StringOut(ss.str());
            continue;
        }
 
        try
        {
            while(GetNextTest())
            {
                /* If the user specified a test through the command line, check this here */
                if(!Configuration.GetTest().empty() && Configuration.GetTest() != m_CurrentTest)
                    continue;
 
                {
                    auto_ptr<CTestInfo> TestInfo(new CTestInfo());
                    size_t UnderscorePosition;
 
                    /* Build the command line */
                    TestInfo->CommandLine = m_TestPath;
                    TestInfo->CommandLine += m_CurrentFile;
                    TestInfo->CommandLine += ' ';
                    TestInfo->CommandLine += AsciiToUnicode(m_CurrentTest);
 
                    /* Store the Module name */
                    UnderscorePosition = m_CurrentFile.find_last_of('_');
 
                    if(UnderscorePosition == m_CurrentFile.npos)
                    {
                        stringstream ss;
 
                        ss << "Invalid test file name: " << UnicodeToAscii(m_CurrentFile) << endl;
                        SSEXCEPTION;
                    }
 
                    TestInfo->Module = UnicodeToAscii(m_CurrentFile.substr(0, UnderscorePosition));
 
                    /* Store the test */
                    TestInfo->Test = m_CurrentTest;
 
                    return TestInfo.release();
                }
            }
        }
        catch(CTestException& e)
        {
            stringstream ss;
 
            ss << "An exception occurred trying to list tests for: " << UnicodeToAscii(m_CurrentFile) << endl;
            StringOut(ss.str());
            StringOut(e.GetMessage());
            StringOut("\n");
            m_CurrentFile.clear();
            delete[] m_ListBuffer;
        }
    }
 
    return NULL;
}

Run()

void CWineTest::Run ( )

virtual

Interface to other classes for running all desired Wine tests.

Implements CTest.

Definition at line 397 of file CWineTest.cpp.

{
    auto_ptr<CTestList> TestList;
    auto_ptr<CWebService> WebService;
    CTestInfo* TestInfo;
    DWORD ErrorMode = 0;
 
    /* The virtual test list is of course faster, so it should be preferred over
       the journaled one.
       Enable the journaled one only in case ...
          - we're running under ReactOS (as the journal is only useful in conjunction with sysreg2)
          - we shall keep information for Crash Recovery
          - and the user didn't specify a module (then doing Crash Recovery doesn't really make sense) */
    if(Configuration.IsReactOS() && Configuration.DoCrashRecovery() && Configuration.GetModule().empty())
    {
        /* Use a test list with a permanent journal */
        TestList.reset(new CJournaledTestList(this));
    }
    else
    {
        /* Use the fast virtual test list with no additional overhead */
        TestList.reset(new CVirtualTestList(this));
    }
 
    /* Initialize the Web Service interface if required */
    if (Configuration.DoSubmit())
    {
        if (CWebServiceLibCurl::CanUseLibCurl())
        {
            StringOut("[ROSAUTOTEST] Using libcurl\n");
            WebService.reset(new CWebServiceLibCurl());
        }
        else
        {
            StringOut("[ROSAUTOTEST] Using wininet\n");
            WebService.reset(new CWebServiceWinInet());
        }
    }
 
    /* Disable error dialogs if we're running in non-interactive mode */
    if(!Configuration.IsInteractive())
        ErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
 
    /* Get information for each test to run */
    while((TestInfo = TestList->GetNextTestInfo()) != 0)
    {
        auto_ptr<CTestInfo> TestInfoPtr(TestInfo);
 
        RunTest(TestInfo);
 
        if(Configuration.DoSubmit() && !TestInfo->Log.empty())
            WebService->Submit("wine", TestInfo);
 
        StringOut("\n\n");
    }
 
    /* We're done with all tests. Finish this run */
    if(Configuration.DoSubmit())
        WebService->Finish("wine");
 
    /* Restore the original error mode */
    if(!Configuration.IsInteractive())
        SetErrorMode(ErrorMode);
}

Referenced by wmain().

RunTest()

void CWineTest::RunTest ( CTestInfo *  TestInfo )

private

Runs a Wine test and captures the output

Parameters

TestInfo

Pointer to a CTestInfo object containing information about the test. Will contain the test log afterwards if the user wants to submit data.

Definition at line 321 of file CWineTest.cpp.

{
    DWORD BytesAvailable;
    stringstream ss, ssFinish;
    DWORD StartTime;
    float TotalTime;
    string tailString;
    CPipe Pipe;
    char Buffer[1024];
 
    ss << "Running Wine Test, Module: " << TestInfo->Module << ", Test: " << TestInfo->Test << endl;
    StringOut(ss.str());
 
    SetCurrentDirectoryW(m_TestPath.c_str());
 
    StartTime = GetTickCount();
 
    try
    {
        /* Execute the test */
        CPipedProcess Process(TestInfo->CommandLine, Pipe);
 
        /* Receive all the data from the pipe */
        for (;;)
        {
            DWORD dwReadResult = Pipe.Read(Buffer, sizeof(Buffer) - 1, &BytesAvailable, ProcessActivityTimeout);
            if (dwReadResult == ERROR_SUCCESS)
            {
                /* Output text through StringOut, even while the test is still running */
                Buffer[BytesAvailable] = 0;
                tailString = StringOut(tailString.append(string(Buffer)), false);
 
                if (Configuration.DoSubmit())
                    TestInfo->Log += Buffer;
            }
            else if (dwReadResult == ERROR_BROKEN_PIPE)
            {
                // The process finished and has been terminated.
                break;
            }
            else if (dwReadResult == WAIT_TIMEOUT)
            {
                // The process activity timeout above has elapsed without any new data.
                TESTEXCEPTION("Timeout while waiting for the test process\n");
            }
            else
            {
                // An unexpected error.
                TESTEXCEPTION("CPipe::Read failed for the test run\n");
            }
        }
    }
    catch(CTestException& e)
    {
        if(!tailString.empty())
            StringOut(tailString);
        tailString.clear();
        StringOut(e.GetMessage());
        TestInfo->Log += e.GetMessage();
    }
 
    /* Print what's left */
    if(!tailString.empty())
        StringOut(tailString);
 
    TotalTime = ((float)GetTickCount() - StartTime)/1000;
    ssFinish << "Test " << TestInfo->Test << " completed in ";
    ssFinish << setprecision(2) << fixed << TotalTime << " seconds." << endl;
    StringOut(ssFinish.str());
    TestInfo->Log += ssFinish.str();
}

Member Data Documentation

m_CurrentFile

wstring CWineTest::m_CurrentFile

private

Definition at line 14 of file CWineTest.h.

Referenced by DoListCommand(), GetNextFile(), GetNextTest(), and GetNextTestInfo().

m_CurrentListCommand

wstring CWineTest::m_CurrentListCommand

private

Definition at line 15 of file CWineTest.h.

m_CurrentTest

string CWineTest::m_CurrentTest

private

Definition at line 13 of file CWineTest.h.

Referenced by GetNextTest(), and GetNextTestInfo().

m_hFind

HANDLE CWineTest::m_hFind

private

Definition at line 11 of file CWineTest.h.

Referenced by GetNextFile(), and ~CWineTest().

m_ListBuffer

PCHAR CWineTest::m_ListBuffer

private

Definition at line 12 of file CWineTest.h.

Referenced by DoListCommand(), GetNextTest(), GetNextTestInfo(), and ~CWineTest().

m_TestPath

wstring CWineTest::m_TestPath

private

Definition at line 16 of file CWineTest.h.

Referenced by CWineTest(), DoListCommand(), GetNextFile(), GetNextTestInfo(), and RunTest().

---

The documentation for this class was generated from the following files:

• modules/rostests/rosautotest/CWineTest.h
• modules/rostests/rosautotest/CWineTest.cpp