text: // 207-Rpt-TeamCityReporter.cpp
  
  // Catch has built-in and external reporters:
  // Built-in:
  // - compact
  // - console
  // - junit
  // - xml
  // External:
  // - automake
  // - tap
  // - teamcity (this example)
  
  // main() and reporter code provided in 200-Rpt-CatchMain.cpp
  
  #include <catch2/catch.hpp>
  
  #ifdef _MSC_VER
  # pragma warning (disable : 4702) // Disable warning: unreachable code
  #endif
  
  TEST_CASE( "TeamCity passes unconditionally succeeding assertion", "[teamcity]" ) {
  
      SUCCEED();
  }
  
  TEST_CASE( "TeamCity reports unconditionally failing assertion", "[teamcity]" ) {
  
      FAIL();
  }
  
  TEST_CASE( "TeamCity reports failing check", "[teamcity]" ) {
  
      REQUIRE( 3 == 7 );
  }
  
  TEST_CASE( "TeamCity reports failing check-false", "[teamcity]" ) {
  
      REQUIRE_FALSE( 3 == 3 );
  }
  
  TEST_CASE( "TeamCity reports failing check-that", "[teamcity]" ) {
  
      using namespace Catch;
  
      REQUIRE_THAT( "hello", Contains( "world" ) );
  }
  
  TEST_CASE( "TeamCity reports unexpected exception", "[teamcity]" ) {
  
      REQUIRE( (throw std::runtime_error("surprise!"), true) );
  }
  
  TEST_CASE( "TeamCity reports undesired exception", "[teamcity]" ) {
  
      REQUIRE_NOTHROW( (throw std::runtime_error("surprise!"), true) );
  }
  
  TEST_CASE( "TeamCity reports missing expected exception", "[teamcity]" ) {
  
      REQUIRE_THROWS( true );
  }
  
  TEST_CASE( "TeamCity reports missing specific expected exception", "[teamcity]" ) {
  
      REQUIRE_THROWS_AS( throw std::bad_alloc(), std::runtime_error );
  }
  
  TEST_CASE( "TeamCity reports unexpected message in expected exception", "[teamcity]" ) {
  
      using namespace Catch;
  
      CHECK_THROWS_WITH( throw std::runtime_error("hello"), "world" );
      CHECK_THROWS_WITH( throw std::runtime_error("hello"), Contains("world") );
  }
  
  struct MyException: public std::runtime_error
  {
      MyException( char const * text )
      : std::runtime_error( text ) {}
      
      ~MyException() override;
  };
  
  // prevent -Wweak-vtables:
  MyException::~MyException() = default;
  
  struct MyExceptionMatcher : Catch::MatcherBase< std::runtime_error >
  {
      std::string m_text;
  
      MyExceptionMatcher( char const * text )
      : m_text( text )
      {}
  
      ~MyExceptionMatcher() override;
      
      bool match( std::runtime_error const & arg ) const override
      { 
          return m_text == arg.what() ; 
      }
      
      std::string describe() const override 
      { 
          return "it's me";
      }
  };
  
  // prevent -Wweak-vtables:
  MyExceptionMatcher::~MyExceptionMatcher() = default;
  
  TEST_CASE( "TeamCity failing check-throws-matches", "[teamcity]" ) {
  
      CHECK_THROWS_MATCHES( throw MyException("hello"), MyException, MyExceptionMatcher("world") );
  }
  
  // [!throws] - lets Catch know that this test is likely to throw an exception even if successful. 
  // This causes the test to be excluded when running with -e or --nothrow.
  
  // No special effects for the reporter.
  
  TEST_CASE( "TeamCity throwing exception with tag [!throws]", "[teamcity][!throws]" ) {
  
      REQUIRE_THROWS( throw std::runtime_error("unsurprisingly") );
  }
  
  // [!mayfail] - doesn't fail the test if any given assertion fails (but still reports it). This can be useful to flag a work-in-progress, or a known issue that you don't want to immediately fix but still want to track in your tests.
  
  TEST_CASE( "TeamCity failing assertion with tag [!mayfail]", "[teamcity][!mayfail] " ) {
  
      REQUIRE( 3 == 7 );  // doesn't fail test case this time, reports: testIgnored
      REQUIRE( 3 == 3 );
  }
  
  // [!shouldfail] - like [!mayfail] but fails the test if it passes. 
  // This can be useful if you want to be notified of accidental, or third-party, fixes.
  
  TEST_CASE( "TeamCity succeeding assertion with tag [!shouldfail]", "[teamcity][!shouldfail]" ) {
  
      SUCCEED( "Marked [!shouldfail]" );
  }
  
  // Compile & run:
  // - g++ -std=c++11 -Wall -I$(CATCH_ROOT) -DCATCH_EXAMPLE_RPT_1=\"include/reporters/catch_reporter_teamcity.hpp\" -o 200-Rpt-CatchMainTeamCity.o -c 200-Rpt-CatchMain.cpp
  // - g++ -std=c++11 -Wall -I$(CATCH_ROOT) -o 207-Rpt-TeamCityReporter 207-Rpt-TeamCityReporter.cpp 200-Rpt-CatchMainTeamCity.o && 207-Rpt-TeamCityReporter --list-reporters
  //
  // - cl -EHsc -I%CATCH_ROOT% -DCATCH_EXAMPLE_RPT_1=\"include/reporters/catch_reporter_teamcity.hpp\" -Fo200-Rpt-CatchMainTeamCity.obj -c 200-Rpt-CatchMain.cpp
  // - cl -EHsc -I%CATCH_ROOT% 207-Rpt-TeamCityReporter.cpp 200-Rpt-CatchMainTeamCity.o && 207-Rpt-TeamCityReporter --list-reporters
  
  // Compilation output (--list-reporters):
  // Available reporters:
  //   compact:   Reports test results on a single line, suitable for IDEs
  //   console:   Reports test results as plain lines of text
  //   junit:     Reports test results in an XML format that looks like Ant's
  //                junitreport target
  //   teamcity:  Reports test results as TeamCity service messages
  //   xml:       Reports test results as an XML document
  
  // Expected output (abbreviated and broken into shorter lines):
  //
  // prompt> 207-Rpt-TeamCityReporter.exe --reporter teamcity
  // ##teamcity[testSuiteStarted name='207-Rpt-TeamCityReporter.exe']
  // ##teamcity[testStarted name='TeamCity passes unconditionally succeeding assertion']
  // ##teamcity[testFinished name='TeamCity passes unconditionally succeeding assertion' duration='1']
  // ##teamcity[testStarted name='TeamCity reports unconditionally failing assertion']
  // ##teamcity[testFailed name='TeamCity reports unconditionally failing assertion' /
  // message='.../examples/207-Rpt-TeamCityReporter.cpp:23|n/
  // ...............................................................................|n|n/
  // .../examples/207-Rpt-TeamCityReporter.cpp:25|nexplicit failure']
  // ##teamcity[testFinished name='TeamCity reports unconditionally failing assertion' duration='3']
  // ...
  