source: TestRunnerClient.cpp@ 74a444

/*******************************************************************************
 * Copyright (c) 2008 Gerhard Leonhartsberger.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/

#include "TestRunnerClient.h"

#ifdef CPPUNIT_MAIN

#include "cppunit/TestResultCollector.h"
#include "cppunit/XmlOutputter.h"
#include "cppunit/TestSuite.h"
#include "cppunit/TestResult.h"
#include "cppunit/TestFailure.h"
#include "cppunit/SourceLine.h"
#include "cppunit/Exception.h"
#include "cppunit/extensions/TestFactoryRegistry.h"
#include "cppunit/extensions/TestDecorator.h"
#include "cppunit/ui/text/TestRunner.h"

#include <iostream>
#include <sstream>
#include <typeinfo>
#include <vector>
#include <cstring>

#include <errno.h>
#include <unistd.h>
#include <sys/time.h>
#include <stdlib.h>


#ifdef _WIN32 // Bugzilla 40710
#include <windows.h>
#include <winbase.h>
#include <winsock.h>
#else
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netdb.h>
#endif

enum { MAX_HOSTNAME_SIZE=255 };

/*
 * CppUnitServer protocol constants
 */
static const std::string TRACE_START = "%TRACES ";
static const std::string TRACE_END = "%TRACEE ";
static const std::string TEST_RUN_START = "%TESTC  ";
static const std::string TEST_START = "%TESTS  ";
static const std::string TEST_END = "%TESTE  ";
static const std::string TEST_ERROR = "%ERROR  ";
static const std::string TEST_FAILED = "%FAILED ";
static const std::string TEST_RUN_END = "%RUNTIME";
static const std::string TEST_STOPPED = "%TSTSTP ";
static const std::string TEST_TREE = "%TSTTREE";

TestRunnerClient::TestRunnerClient()
{
        fTestResult = 0;
        fClientSocket = -1;
        fPort = 0;
        fKeepAlive = 0;
        fDebugMode = 0;

        fHost = (char *) malloc(MAX_HOSTNAME_SIZE);
        strcpy(fHost, "");
}

TestRunnerClient::~TestRunnerClient() {

        if (fHost != NULL) {
                free(fHost);
        }
}

int TestRunnerClient::Run()
{
        if (fDebugMode)
        {
                std::cerr << "TestRunnerClient: Starting client." << std::endl;
        }

        if (Connect() == -1) {
                return -1;
        }

        InstallListeners();

        RunTests();

        UninstallListeners();

        if(fTestResult != NULL)
        {
                fTestResult->stop();
                fTestResult= NULL;
        }

        ShutDown();

        return 0;
}

void TestRunnerClient::Init(int n, char *args[])
{
        ParseCommandLine(n, args);
        DefineHostName();
}

void TestRunnerClient::ParseCommandLine(int n, char *args[])
{
        // parse all arguments passed by args
        for(int i = 0; i < n; i++)
        {
                std::string arg(args[i]);

                // port option
                std::string portOption("-port=");
                int pos = arg.find(portOption);
                if(pos> -1)
                {
                        std::string v = arg.substr(pos + portOption.length(), arg.length());
                        fPort = atoi(v.c_str());
                }

                // debug option
                std::string debugOption("-debug");
                pos = arg.find(debugOption);
                if(pos> - 1)
                {
                        fDebugMode = 1;
                }
        }
}

void TestRunnerClient::DefineHostName()
{
        // set fHost to hostname or localhost
        int ret = gethostname(fHost, MAX_HOSTNAME_SIZE);
        if (ret == -1)
        {
                strcpy(fHost, "localhost");
        }
}

int TestRunnerClient::Connect()
{

#ifdef _WIN32 // Bugzilla 40710
        if (fDebugMode)
        {
                std::cerr << "TestRunnerClient: Starting Windows Sockets WSAStartup()." << std:endl;
        }

        // start up Windows Sockets
        WSADATA WSAData;
        int result = WSAStartup (MAKEWORD(1, 1), &WSAData);
        if (result != NO_ERROR)
        {
                std::cerr << "TestRunnerClient: WSAStartup() failed! Error code: " << result << std::endl;
                return -1;
        }
#endif

        if (fDebugMode)
        {
                std::cerr << "TestRunnerClient: Trying to connect to " << fHost << ":" << fPort << std::endl;
        }

        fClientSocket = socket(AF_INET, SOCK_STREAM, 0);
        if (fClientSocket == -1)
        {
                std::cerr << "TestRunnerClient: Socket creation failed! error code: " << fClientSocket << std::endl;
                return -1;
        }

        struct hostent *host = gethostbyname(fHost);
        if (host == NULL)
        {
                std::cerr << "TestRunnerClient: Cannot find host address for " << fHost << "." << std::endl;
                fClientSocket = -1;
                return -1;
        }

        struct sockaddr_in name;
        memset((void *)&name, 0, sizeof(struct sockaddr_in));
        name.sin_family = AF_INET;
        name.sin_port = htons(fPort);

        memcpy(&name.sin_addr, host->h_addr, host->h_length);

        if (fDebugMode) {
                std::cerr << "TestRunnerClient: Waiting for the JVM to listen ... (trying 3 times)" << std::endl;
        }

        int ret = -1;
        int j = 0;
        while ((j < 3) && (ret == -1))
        {
                ret = ::connect(fClientSocket, (struct sockaddr *) &name, sizeof(struct sockaddr_in));
                if (ret == -1)
                {
                        if (fDebugMode) {
                                std::cerr << "TestRunnerClient: Connection request, waiting 1 second. "
                                << ((j-3)*-1) << " times left." << std::endl;
                        }
                        PrivateSleep(1000);
                        j++;
                }
        }
        if (ret == -1)
        {
                std::cerr << "TestRunnerClient: No connection established. Error code: " << errno << std::endl;
                fClientSocket = -1;
                return -1;
        }

        if (fDebugMode) {
                std::cerr << "TestRunnerClient: Connection established." << std::endl;
        }
        return 0;
}

void TestRunnerClient::InstallListeners()
{
        fTestResult = new CppUnit::TestResult();
        fTestResult->addListener(this);
}

void TestRunnerClient::UninstallListeners()
{
        fTestResult->removeListener(this);
}

void TestRunnerClient::RunTests()
{

        CppUnit::TestFactoryRegistry &registry = CppUnit::TestFactoryRegistry::getRegistry();
        CppUnit::Test *suite = registry.makeTest();
        int count = suite->countTestCases();
        NotifyTestRunStarted(count);

        if (count == 0)
        {
                NotifyTestRunEnded(0);
        }

        long startTime = CurrentTimeMillis();
        if (fDebugMode)
        {
                std::cerr <<"TestRunnerClient: Start sending test case tree ..." << std::endl;
        }

        SendTestTree(suite);

        int elapsedTime = CurrentTimeMillis() - startTime;
        if (fDebugMode) {
                std::cerr << "TestRunnerClient: Done sending test case tree. Elapsed time is "
                << elapsedTime << "ms." << std::endl;
        }

        long testStartTime = CurrentTimeMillis();
        if (fDebugMode) {
                std::cerr << "TestRunnerClient: Test start time is " << testStartTime
                << "ms." << std::endl;
        }

        suite->run(fTestResult);

        if (fTestResult == NULL || fTestResult->shouldStop())
        {
                NotifyTestRunStopped(CurrentTimeMillis() - testStartTime);
        }
        else
        {
                NotifyTestRunEnded(CurrentTimeMillis() - testStartTime);
        }
}

void TestRunnerClient::ShutDown()
{
        if (fClientSocket != -1)
        {
                if (fDebugMode) {
                        std::cerr << "TestRunnerClient: Closing connection to CppUnit sever at "
                        << fHost << ":" << fPort << std::endl;
                }

#ifdef _WIN32 // Bugzilla 40710
                // TODO: std:err output for error return codes
                closesocket(fClientSocket);
                WSACleanup();
#else
                int result = close(fClientSocket);
                if (result != 0)
                {
                        std::cerr << "TestRunnerClient: Close connection error: " << errno << std::endl;
                }
#endif

                fClientSocket = -1;
        }
}

void TestRunnerClient::Stop()
{
        if (fTestResult != NULL)
        {
                fTestResult->stop();
        }
}

void TestRunnerClient::SendTestTree(CppUnit::Test *test)
{
        if (typeid(*test) == typeid(CppUnit::TestDecorator))
        {
                class TmpClass : public CppUnit::TestDecorator {

                public:
                        TmpClass(Test *t):CppUnit::TestDecorator(t)
                        {
                                // nothing to do
                        }

                        ~TmpClass() // Bugzilla 39894
                        {
                                // nothing to do
                        }

                        CppUnit::Test *getTest()
                        {
                                return m_test;
                        }
                };

                TmpClass *t = (TmpClass *)test;
                SendTestTree(t->getTest());
        }
        else if (typeid(*test) == typeid(CppUnit::TestSuite))
        {
                CppUnit::TestSuite *suite = (CppUnit::TestSuite *)test;
                const std::vector<CppUnit::Test *> &x = suite->getTests();

                std::ostringstream os;
                os << suite->getName() << ",true," << x.size();
                NotifyTestTreeEntry(os.str());

                for(unsigned int i=0; i < x.size(); i++)
                {
                        SendTestTree(x[i]);
                }
        }
        else
        {
                std::ostringstream os;
                os << test->getName() << ",false," << test->countTestCases();
                NotifyTestTreeEntry(os.str());
        }
}

void TestRunnerClient::SendMessage(std::string msg)
{
        if (fClientSocket == -1)
        {
                return;
        }

#ifdef _WIN32 // Bugzilla 40710
        send (fClientSocket, msg.c_str(), msg.length(), 0);
        send (fClientSocket, "\n", 1, 0);
#else
        write(fClientSocket, msg.c_str(), msg.length());
        write(fClientSocket, "\n", 1);
#endif

        if (fDebugMode)
        {
                std::cerr << "TestRunnerClient: Sent message \"" << msg << "\""
                << std::endl;
        }
}

void TestRunnerClient::NotifyTestRunStarted(int testCount)
{
        std::ostringstream os;
        os << TEST_RUN_START << testCount;
        SendMessage(os.str());
}

void TestRunnerClient::NotifyTestRunEnded(long elapsedTime)
{
        std::ostringstream os;
        os << TEST_RUN_END << elapsedTime;
        SendMessage(os.str());
}

void TestRunnerClient::NotifyTestRunStopped(long elapsedTime)
{
        std::ostringstream os;
        os << TEST_STOPPED << elapsedTime;
        SendMessage(os.str());
}

void TestRunnerClient::NotifyTestTreeEntry(std::string treeEntry)
{
        SendMessage(TEST_TREE + treeEntry);
}

void TestRunnerClient::NotifyTestStarted(std::string testName)
{
        SendMessage(TEST_START + testName);
}

void TestRunnerClient::NotifyTestEnded(std::string testName)
{
        SendMessage(TEST_END + testName);
}

void TestRunnerClient::NotifyTestFailed(std::string status, std::string testName, std::string trace)
{
        SendMessage(status + testName);
        SendMessage(TRACE_START);
        SendMessage(trace);
        SendMessage(TRACE_END);
}

// From TestListener
void TestRunnerClient::startTest(CppUnit::Test *test)
{
        NotifyTestStarted(test->getName());
}

// From TestListener
void TestRunnerClient::addFailure(const CppUnit::TestFailure &failure)
{
        if(failure.isError())
        {
                NotifyTestFailed(TEST_ERROR,failure.failedTestName(),GetTrace(failure));
        }
        else
        {
                NotifyTestFailed(TEST_FAILED,failure.failedTestName(),GetTrace(failure));
        }
}

// From TestListener
void TestRunnerClient::endTest(CppUnit::Test *test)
{
        NotifyTestEnded(test->getName());
}

std::string TestRunnerClient::GetTrace(const CppUnit::TestFailure &failure)
{
        std::ostringstream os;

        CppUnit::Exception *e=failure.thrownException();
        if(e->sourceLine().lineNumber()!=-1)
        {
                os << "File " << e->sourceLine().fileName() << ":" << e->sourceLine().lineNumber() << "\n";
        }
        else
        {
                os << "File Unknown:1\n";
        }
        /* TODO: expected, actual value implementation
         if(typeid(*e)==typeid(CppUnit::NotEqualException))
         {
         CppUnit::NotEqualException *ne=(CppUnit::NotEqualException *)e;

         os << "Expected Value: " << ne->expectedValue() << "\n";
         os << "Actual Value: " << ne->expectedValue() << "\n";
         os << "Additional Message: " << ne->additionalMessage() << "\n";
         }
         else
         {
         End            */
        os << "Message: " << std::string(e->what()) << "\n";
        /*              } */

        return(os.str());
}

long TestRunnerClient::CurrentTimeMillis()
{
#ifdef _WIN32 // Bugzilla 40710
        unsigned long long p;
        __asm__ __volatile__ ("rdtsc" : "=A" (p));
        return (unsigned long)p;
#else
        struct timeval tv;
        gettimeofday(&tv, NULL);

        return((long)(tv.tv_sec*1000) + (tv.tv_usec/1000));
#endif
}

void TestRunnerClient::PrivateSleep(int millisecs)
{
        struct timeval delta;
        delta.tv_sec = (millisecs * 1000L) / 1000000L;
        delta.tv_usec = (millisecs * 1000L) % 1000000L;
        select (0, NULL, NULL, NULL, &delta);
}

/*!
 * This is the main routine. The TestRunnerClient is initialized and run. The
 * CppUnit tests are created, executed, and sent to the CppUnitServer.
 * If no connection to the CppUnitServer was established the CppUnit tests are
 * displayed on the console.
 *
 * @return <code>0</code> if the results of the CppUnit tests were sent to the
 *         CppUnitServer successfully.
 *         <code>-1</code> if a connection could not be established to the
 *         CppUnitServer.
 */
int CPPUNIT_MAIN(int n, char *arg[])
{
        TestRunnerClient client;

        client.Init(n, arg);
        int ret = client.Run();
        if (ret == -1)
        {
                CppUnit::TestFactoryRegistry &registry = CppUnit::TestFactoryRegistry::getRegistry();
                CppUnit::Test *suite = registry.makeTest();

                CppUnit::TextUi::TestRunner *runner = NULL;
                runner = new CppUnit::TextUi::TestRunner();
                runner->addTest(suite);
                runner->run();
        }

        exit(ret);
}

#endif /*CPPUNIT_MAIN*/