#include <cppunit/config/SourcePrefix.h>

#include <cppunit/XmlOutputter.h>

#include <cppunit/TestFailure.h>

#include <cppunit/XmlOutputter.h>

#include <cppunit/XmlOutputterHook.h>

#include "OutputSuite.h"

#include "XmlOutputterTest.h"

#include "XmlUniformiser.h"

CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( XmlOutputterTest, 

                                       outputSuiteName() );

XmlOutputterTest::XmlOutputterTest()

{

}

XmlOutputterTest::~XmlOutputterTest()

{

}

void 

XmlOutputterTest::setUp()

{

  m_dummyTests.clear();

  m_result = new CPPUNIT_NS::TestResultCollector();

}

void 

XmlOutputterTest::tearDown()

{

  delete m_result;

  for ( unsigned int index =0; index < m_dummyTests.size(); ++index )

    delete m_dummyTests[index];

  m_dummyTests.clear();

}

void 

XmlOutputterTest::testWriteXmlResultWithNoTest()

{

  CPPUNIT_NS::OStringStream stream;

  CPPUNIT_NS::XmlOutputter outputter( m_result, stream );

  outputter.write();

  std::string actualXml = stream.str();

  std::string expectedXml = 

    "<TestRun>"

      "<FailedTests></FailedTests>"

      "<SuccessfulTests></SuccessfulTests>"

      "<Statistics>"

        "<Tests>0</Tests>"

        "<FailuresTotal>0</FailuresTotal>"

        "<Errors>0</Errors>"

        "<Failures>0</Failures>"

      "</Statistics>"

    "</TestRun>";

  CPPUNITTEST_ASSERT_XML_EQUAL( expectedXml, actualXml );

}

void 

XmlOutputterTest::testWriteXmlResultWithOneFailure()

{

  addTestFailure( "test1", "message failure1", CPPUNIT_NS::SourceLine( "test.cpp", 3 ) );

  CPPUNIT_NS::OStringStream stream;

  CPPUNIT_NS::XmlOutputter outputter( m_result, stream );

  outputter.write();

  std::string actualXml = stream.str();

  std::string expectedXml = 

    "<TestRun>"

      "<FailedTests>"

        "<FailedTest id=\"1\">"

          "<Name>test1</Name>"

          "<FailureType>Assertion</FailureType>"

          "<Location>"

            "<File>test.cpp</File>"

            "<Line>3</Line>"

          "</Location>"

          "<Message>message failure1</Message>"

        "</FailedTest>"

      "</FailedTests>"

      "<SuccessfulTests></SuccessfulTests>"

      "<Statistics>"

        "<Tests>1</Tests>"

        "<FailuresTotal>1</FailuresTotal>"

        "<Errors>0</Errors>"

        "<Failures>1</Failures>"

      "</Statistics>"

    "</TestRun>";

  CPPUNITTEST_ASSERT_XML_EQUAL( expectedXml, actualXml );

}

void 

XmlOutputterTest::testWriteXmlResultWithOneError()

{

  addTestError( "test1", "message error1" );

  CPPUNIT_NS::OStringStream stream;

  CPPUNIT_NS::XmlOutputter outputter( m_result, stream );

  outputter.write();

  std::string actualXml = stream.str();

  std::string expectedXml = 

    "<TestRun>"

      "<FailedTests>"

        "<FailedTest id=\"1\">"

          "<Name>test1</Name>"

          "<FailureType>Error</FailureType>"

          "<Message>message error1</Message>"

        "</FailedTest>"

      "</FailedTests>"

      "<SuccessfulTests></SuccessfulTests>"

      "<Statistics>"

        "<Tests>1</Tests>"

        "<FailuresTotal>1</FailuresTotal>"

        "<Errors>1</Errors>"

        "<Failures>0</Failures>"

      "</Statistics>"

    "</TestRun>";

  CPPUNITTEST_ASSERT_XML_EQUAL( expectedXml, actualXml );

}

void 

XmlOutputterTest::testWriteXmlResultWithOneSuccess()

{

  addTest( "test1" );

  CPPUNIT_NS::OStringStream stream;

  CPPUNIT_NS::XmlOutputter outputter( m_result, stream );

  outputter.write();

  std::string actualXml = stream.str();

  std::string expectedXml = 

    "<TestRun>"

      "<FailedTests></FailedTests>"

      "<SuccessfulTests>"

        "<Test id=\"1\">"

          "<Name>test1</Name>"

        "</Test>"

      "</SuccessfulTests>"

      "<Statistics>"

        "<Tests>1</Tests>"

        "<FailuresTotal>0</FailuresTotal>"

        "<Errors>0</Errors>"

        "<Failures>0</Failures>"

      "</Statistics>"

    "</TestRun>";

  CPPUNITTEST_ASSERT_XML_EQUAL( expectedXml, actualXml );

}

void 

XmlOutputterTest::testWriteXmlResultWithThreeFailureTwoErrorsAndTwoSuccess()

{

  addTestFailure( "test1", "failure1" );

  addTestError( "test2", "error1" );

  addTestFailure( "test3", "failure2" );

  addTestFailure( "test4", "failure3" );

  addTest( "test5" );

  addTestError( "test6", "error2" );

  addTest( "test7" );

  CPPUNIT_NS::OStringStream stream;

  CPPUNIT_NS::XmlOutputter outputter( m_result, stream );

  outputter.write();

  std::string actualXml = stream.str();

  std::string expectedXml = 

    "<TestRun>"

       "<FailedTests>"

        "<FailedTest id=\"1\">"

          "<Name>test1</Name>"

          "<FailureType>Assertion</FailureType>"

          "<Message>failure1</Message>"

        "</FailedTest>"

        "<FailedTest id=\"2\">"

          "<Name>test2</Name>"

          "<FailureType>Error</FailureType>"

          "<Message>error1</Message>"

        "</FailedTest>"

        "<FailedTest id=\"3\">"

          "<Name>test3</Name>"

          "<FailureType>Assertion</FailureType>"

          "<Message>failure2</Message>"

        "</FailedTest>"

        "<FailedTest id=\"4\">"

          "<Name>test4</Name>"

          "<FailureType>Assertion</FailureType>"

          "<Message>failure3</Message>"

        "</FailedTest>"

        "<FailedTest id=\"6\">"

          "<Name>test6</Name>"

          "<FailureType>Error</FailureType>"

          "<Message>error2</Message>"

        "</FailedTest>"

      "</FailedTests>"

     "<SuccessfulTests>"

        "<Test id=\"5\">"

          "<Name>test5</Name>"

        "</Test>"

        "<Test id=\"7\">"

          "<Name>test7</Name>"

        "</Test>"

      "</SuccessfulTests>"

      "<Statistics>"

        "<Tests>7</Tests>"

        "<FailuresTotal>5</FailuresTotal>"

        "<Errors>2</Errors>"

        "<Failures>3</Failures>"

      "</Statistics>"

    "</TestRun>";

  CPPUNITTEST_ASSERT_XML_EQUAL( expectedXml, actualXml );

}

class XmlOutputterTest::MockHook : public CPPUNIT_NS::XmlOutputterHook

{

public:

  MockHook( int &beginCalls,

            int &endCalls,

            int &statisticsCalls,

            int &successfulTestCalls,

            int &failedTestCalls )

      : m_beginCalls( beginCalls )

      , m_endCalls( endCalls )

      , m_statisticsCalls( statisticsCalls )

      , m_successfulTestCalls( successfulTestCalls )

      , m_failedTestCalls( failedTestCalls )

  {

  }

  void beginDocument( CPPUNIT_NS::XmlDocument * )

  {

    ++m_beginCalls;

  }

  void endDocument( CPPUNIT_NS::XmlDocument * )

  {

    ++m_endCalls;

  }

  void failTestAdded( CPPUNIT_NS::XmlDocument *,

                      CPPUNIT_NS::XmlElement *,

                      CPPUNIT_NS::Test *,

                      CPPUNIT_NS::TestFailure * )

  {

    ++m_failedTestCalls;

  }

  void successfulTestAdded( CPPUNIT_NS::XmlDocument *,

                            CPPUNIT_NS::XmlElement *,

                            CPPUNIT_NS::Test * )

  {

    ++m_successfulTestCalls;

  }

  void statisticsAdded( CPPUNIT_NS::XmlDocument *,

                        CPPUNIT_NS::XmlElement * )

  {

    ++m_statisticsCalls;

  }

private:

  int &m_beginCalls;

  int &m_endCalls;

  int &m_statisticsCalls;

  int &m_successfulTestCalls;

  int &m_failedTestCalls;

};

void 

XmlOutputterTest::testHook()

{

  int begin =0, end =0, statistics =0, successful =0, failed =0;

  MockHook hook( begin, end, statistics, successful, failed );

  addTest( "test1" );

  addTest( "test2" );

  addTest( "test3" );

  addTestFailure( "testfail1", "assertion failed" );

  addTestError( "testerror1", "exception" );

  CPPUNIT_NS::OStringStream stream;

  CPPUNIT_NS::XmlOutputter outputter( m_result, stream );

  outputter.addHook( &hook );

  outputter.write();

  CPPUNIT_ASSERT_EQUAL( 1, begin );

  CPPUNIT_ASSERT_EQUAL( 1, end );

  CPPUNIT_ASSERT_EQUAL( 1, statistics );

  CPPUNIT_ASSERT_EQUAL( 3, successful );

  CPPUNIT_ASSERT_EQUAL( 2, failed );

}

void 

XmlOutputterTest::addTest( std::string testName )

{

  CPPUNIT_NS::Test *test = makeDummyTest( testName );

  m_result->startTest( test );

  m_result->endTest( test );

}

void 

XmlOutputterTest::addTestFailure( std::string testName,

                                  std::string message,

                                  CPPUNIT_NS::SourceLine sourceLine )

{

  addGenericTestFailure( testName, CPPUNIT_NS::Message(message), sourceLine, false );

}

void 

XmlOutputterTest::addTestError( std::string testName,

                                std::string message,

                                CPPUNIT_NS::SourceLine sourceLine )

{

  addGenericTestFailure( testName, CPPUNIT_NS::Message(message), sourceLine, true );

}

void 

XmlOutputterTest::addGenericTestFailure(  std::string testName,

                                          CPPUNIT_NS::Message message,

                                          CPPUNIT_NS::SourceLine sourceLine,

                                          bool isError )

{

  CPPUNIT_NS::Test *test = makeDummyTest( testName );

  m_result->startTest( test );

  CPPUNIT_NS::TestFailure failure( test, 

                                new CPPUNIT_NS::Exception( message, sourceLine ),

                                isError );

  m_result->addFailure( failure );

  m_result->endTest( test );

}

CPPUNIT_NS::Test *

XmlOutputterTest::makeDummyTest( std::string testName )

{

  CPPUNIT_NS::Test *test = new CPPUNIT_NS::TestCase( testName );

  m_dummyTests.push_back( test );

  return test;

}