testpathtest.cpp

这是国外的resip协议栈

#include "CoreSuite.h"
#include "TestPathTest.h"


CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( TestPathTest,
                                       coreSuiteName() );


TestPathTest::TestPathTest()
{
}


TestPathTest::~TestPathTest()
{
}


void 
TestPathTest::setUp()
{
  m_path = new CPPUNIT_NS::TestPath();
  m_test1 = new CPPUNIT_NS::TestCase( "test1" );
  m_test2 = new CPPUNIT_NS::TestCase( "test2" );
  m_test3 = new CPPUNIT_NS::TestCase( "test3" );
  m_test4 = new CPPUNIT_NS::TestCase( "test4" );

  m_suite1 = new CPPUNIT_NS::TestSuite( "All Tests" );
  m_suite2 = new CPPUNIT_NS::TestSuite( "Custom" );
  m_testSuite2a =  new CPPUNIT_NS::TestCase( "MyTest::testDefaultConstructor" );
  m_testSuite2b =  new CPPUNIT_NS::TestCase( "MyTest::testConstructor" );
  m_suite2->addTest( m_testSuite2a );
  m_suite2->addTest( m_testSuite2b );
  m_suite1->addTest( m_suite2 );
}


void 
TestPathTest::tearDown()
{
  delete m_suite1;
  delete m_path;
  delete m_test4;
  delete m_test3;
  delete m_test2;
  delete m_test1;
}


void 
TestPathTest::testDefaultConstructor()
{
  CPPUNIT_ASSERT_EQUAL( 0, m_path->getTestCount() );
  CPPUNIT_ASSERT( !m_path->isValid() );
}


void 
TestPathTest::testAddTest()
{
  m_path->add( m_test1 );
  CPPUNIT_ASSERT_EQUAL( 1, m_path->getTestCount() );
  CPPUNIT_ASSERT( m_path->isValid() );
  CPPUNIT_ASSERT( m_test1 == m_path->getTestAt(0) );
}


void 
TestPathTest::testGetTestAtThrow1()
{
  m_path->getTestAt( 0 );
}


void 
TestPathTest::testGetTestAtThrow2()
{
  m_path->add( m_test1 );
  m_path->getTestAt( 1 );
}


void 
TestPathTest::testGetChildTest()
{
  m_path->add( m_test1 );
  CPPUNIT_ASSERT( m_test1 == m_path->getChildTest() );
}


void 
TestPathTest::testGetChildTestManyTests()
{
  m_path->add( m_test1 );
  m_path->add( m_test2 );
  m_path->add( m_test3 );
  CPPUNIT_ASSERT( m_test3 == m_path->getChildTest() );
}


void 
TestPathTest::testGetChildTestThrowIfNotValid()
{
  m_path->getChildTest();
}


void 
TestPathTest::testAddPath()
{
  CPPUNIT_NS::TestPath path;
  path.add( m_test2 );
  path.add( m_test3 );

  m_path->add( m_test1 );
  m_path->add( path );

  CPPUNIT_ASSERT_EQUAL( 3, m_path->getTestCount() );
  CPPUNIT_ASSERT( m_test1 == m_path->getTestAt(0) );
  CPPUNIT_ASSERT( m_test2 == m_path->getTestAt(1) );
  CPPUNIT_ASSERT( m_test3 == m_path->getTestAt(2) );
}


void 
TestPathTest::testAddInvalidPath()
{
  CPPUNIT_NS::TestPath path;
  m_path->add( path );

  CPPUNIT_ASSERT( !m_path->isValid() );
}


void 
TestPathTest::testRemoveTests()
{
  m_path->add( m_test1 );
  m_path->add( m_test2 );

  m_path->removeTests();

  CPPUNIT_ASSERT( !m_path->isValid() );
}


void 
TestPathTest::testRemoveTest()
{
  m_path->add( m_test1 );
  m_path->add( m_test2 );

  m_path->removeTest( 0 );

  CPPUNIT_ASSERT_EQUAL( 1, m_path->getTestCount() );
  CPPUNIT_ASSERT( m_test2 == m_path->getTestAt(0) );
}


void 
TestPathTest::testRemoveTestThrow1()
{
  m_path->removeTest( -1 );
}


void 
TestPathTest::testRemoveTestThrow2()
{
  m_path->add( m_test1 );

  m_path->removeTest( 1 );
}


void 
TestPathTest::testUp()
{
  m_path->add( m_test1 );

  m_path->up();

  CPPUNIT_ASSERT( !m_path->isValid() );
}


void 
TestPathTest::testUpThrow()
{
  m_path->up();
}


void 
TestPathTest::testInsert()
{
  m_path->add( m_test1 );

  m_path->insert( m_test2, 0 );

  CPPUNIT_ASSERT_EQUAL( 2, m_path->getTestCount() );
  CPPUNIT_ASSERT( m_test2 == m_path->getTestAt(0) );
  CPPUNIT_ASSERT( m_test1 == m_path->getTestAt(1) );
}


void 
TestPathTest::testInsertAtEnd()
{
  m_path->add( m_test1 );

  m_path->insert( m_test2, 1 );

  CPPUNIT_ASSERT_EQUAL( 2, m_path->getTestCount() );
  CPPUNIT_ASSERT( m_test1 == m_path->getTestAt(0) );
  CPPUNIT_ASSERT( m_test2 == m_path->getTestAt(1) );
}


void 
TestPathTest::testInsertThrow1()
{
  m_path->insert( m_test1, -1 );
}


void 
TestPathTest::testInsertThrow2()
{
  m_path->add( m_test1 );

  m_path->insert( m_test1, 2 );
}


void 
TestPathTest::testInsertPath()
{
  CPPUNIT_NS::TestPath path;
  path.add( m_test2 );
  path.add( m_test3 );

  m_path->add( m_test1 );
  m_path->add( m_test4 );
  m_path->insert( path, 1 );

  CPPUNIT_ASSERT_EQUAL( 4, m_path->getTestCount() );
  CPPUNIT_ASSERT( m_test1 == m_path->getTestAt(0) );
  CPPUNIT_ASSERT( m_test2 == m_path->getTestAt(1) );
  CPPUNIT_ASSERT( m_test3 == m_path->getTestAt(2) );
  CPPUNIT_ASSERT( m_test4 == m_path->getTestAt(3) );
}


void 
TestPathTest::testInsertPathThrow()
{
  CPPUNIT_NS::TestPath path;
  path.add( m_test2 );

  m_path->insert( path, 1 );
}


void 
TestPathTest::testInsertPathDontThrowIfInvalid()
{
  CPPUNIT_NS::TestPath path;
  m_path->insert( path, 1 );
}


void 
TestPathTest::testRootConstructor()
{
  CPPUNIT_NS::TestPath path( m_test1 );
  CPPUNIT_ASSERT( path.isValid() );
  CPPUNIT_ASSERT_EQUAL( 1, path.getTestCount() );
  CPPUNIT_ASSERT( m_test1 == path.getTestAt(0) );
}


void 
TestPathTest::testPathSliceConstructorCopyUntilEnd()
{
  m_path->add( m_test1 );
  m_path->add( m_test2 );
  m_path->add( m_test3 );
  
  CPPUNIT_NS::TestPath path( *m_path, 1 );

  CPPUNIT_ASSERT_EQUAL( 2, path.getTestCount() );
  CPPUNIT_ASSERT( m_test2 == path.getTestAt(0) );
  CPPUNIT_ASSERT( m_test3 == path.getTestAt(1) );
}


void 
TestPathTest::testPathSliceConstructorCopySpecifiedCount()
{
  m_path->add( m_test1 );
  m_path->add( m_test2 );
  m_path->add( m_test3 );
  
  CPPUNIT_NS::TestPath path( *m_path, 0, 1 );

  CPPUNIT_ASSERT_EQUAL( 1, path.getTestCount() );
  CPPUNIT_ASSERT( m_test1 == path.getTestAt(0) );
}


void 
TestPathTest::testPathSliceConstructorCopyNone()
{
  m_path->add( m_test1 );
  
  CPPUNIT_NS::TestPath path( *m_path, 0, 0 );
  CPPUNIT_ASSERT_EQUAL( 0, path.getTestCount() );
}


void 
TestPathTest::testPathSliceConstructorNegativeIndex()
{
  m_path->add( m_test1 );
  m_path->add( m_test2 );

  CPPUNIT_NS::TestPath path( *m_path, -1, 2 );

  CPPUNIT_ASSERT_EQUAL( 1, path.getTestCount() );
  CPPUNIT_ASSERT( m_test1 == path.getTestAt(0) );
}


void 
TestPathTest::testPathSliceConstructorAfterEndIndex()
{
  m_path->add( m_test1 );
  m_path->add( m_test2 );

  CPPUNIT_NS::TestPath path( *m_path, 2, 5 );

  CPPUNIT_ASSERT_EQUAL( 0, path.getTestCount() );
}


void 
TestPathTest::testPathSliceConstructorNegativeIndexUntilEnd()
{
  m_path->add( m_test1 );
  m_path->add( m_test2 );

  CPPUNIT_NS::TestPath path( *m_path, -1 );

  CPPUNIT_ASSERT_EQUAL( 2, path.getTestCount() );
  CPPUNIT_ASSERT( m_test1 == path.getTestAt(0) );
  CPPUNIT_ASSERT( m_test2 == path.getTestAt(1) );
}


void 
TestPathTest::testPathSliceConstructorNegativeIndexNone()
{
  m_path->add( m_test1 );
  m_path->add( m_test2 );

  CPPUNIT_NS::TestPath path( *m_path, -2, 1 );

  CPPUNIT_ASSERT_EQUAL( 0, path.getTestCount() );
}


void 
TestPathTest::testToStringNoTest()
{
  std::string expected = "/";
  std::string actual = m_path->toString();

  CPPUNIT_ASSERT_EQUAL( expected, actual );
}


void 
TestPathTest::testToStringOneTest()
{
  m_path->add( m_test1 );

  std::string expected = "/test1";
  std::string actual = m_path->toString();

  CPPUNIT_ASSERT_EQUAL( expected, actual );
}


void 
TestPathTest::testToStringHierarchy()
{
  m_path->add( m_suite1 );
  m_path->add( m_suite2 );
  m_path->add( m_suite2->getChildTestAt(0) );

  std::string expected = "/All Tests/Custom/MyTest::testDefaultConstructor";
  std::string actual = m_path->toString();

  CPPUNIT_ASSERT_EQUAL( expected, actual );
}


void 
TestPathTest::testPathStringConstructorRoot()
{
  CPPUNIT_NS::TestPath path( m_suite1, "/All Tests" );

  CPPUNIT_ASSERT_EQUAL( 1, path.getTestCount() );
  CPPUNIT_ASSERT( m_suite1 == path.getTestAt(0) );
}


void 
TestPathTest::testPathStringConstructorEmptyIsRoot()
{
  CPPUNIT_NS::TestPath path( m_suite1, "" );

  CPPUNIT_ASSERT_EQUAL( 1, path.getTestCount() );
  CPPUNIT_ASSERT( m_suite1 == path.getTestAt(0) );
}


void 
TestPathTest::testPathStringConstructorHierarchy()
{
  CPPUNIT_NS::TestPath path( m_suite1, "/All Tests/Custom/MyTest::testDefaultConstructor" );

  CPPUNIT_ASSERT_EQUAL( 3, path.getTestCount() );
  CPPUNIT_ASSERT( m_suite1 == path.getTestAt(0) );
  CPPUNIT_ASSERT( m_suite2 == path.getTestAt(1) );
  CPPUNIT_ASSERT( m_testSuite2a == path.getTestAt(2) );
}


void 
TestPathTest::testPathStringConstructorBadRootThrow()
{
  CPPUNIT_NS::TestPath path( m_suite1, "/Custom" );
}


void 
TestPathTest::testPathStringConstructorRelativeRoot()
{
  CPPUNIT_NS::TestPath path( m_suite1, "All Tests" );

  CPPUNIT_ASSERT_EQUAL( 1, path.getTestCount() );
  CPPUNIT_ASSERT( m_suite1 == path.getTestAt(0) );
}


void 
TestPathTest::testPathStringConstructorRelativeRoot2()
{
  CPPUNIT_NS::TestPath path( m_suite1, "Custom" );

  CPPUNIT_ASSERT_EQUAL( 1, path.getTestCount() );
  CPPUNIT_ASSERT( m_suite2 == path.getTestAt(0) );
}


void 
TestPathTest::testPathStringConstructorThrow1()
{
  CPPUNIT_NS::TestPath path( m_suite1, "/" );
}


void 
TestPathTest::testPathStringConstructorRelativeHierarchy()
{
  CPPUNIT_NS::TestPath path( m_suite1, "Custom/MyTest::testConstructor" );

  CPPUNIT_ASSERT_EQUAL( 2, path.getTestCount() );
  CPPUNIT_ASSERT( m_suite2 == path.getTestAt(0) );
  CPPUNIT_ASSERT( m_testSuite2b == path.getTestAt(1) );
}


void 
TestPathTest::testPathStringConstructorBadRelativeHierarchyThrow()
{
  CPPUNIT_NS::TestPath path( m_suite1, "Custom/MyBadTest::testConstructor" );
}