C/C++生态工具链——单元测试工具Catch2简介

Scenario: Blog Search
    Given I visit the blog page
    When I search for “BDD”
    Then I get posts related to BDD

Scenario: user logs in to application
    Given authorized user “John”
    When I enter “John” in the username field
    And I enter “sekret1” in the password field
    And I click the login button
    Then the homepage should open

#define CATCH_CONFIG_MAIN#include <catch2/catch.hpp>

$ git clone https://github.com/catchorg/Catch2.git
$ cd Catch2
$ cmake -Bbuild -H. -DBUILD_TESTING=OFF
$ sudo cmake --build build/ --target install

find_package(Catch2 3 REQUIRED)
#不需要自定义main()函数时使用
add_executable(tests_01 test.cpp)
target_link_libraries(tests_01 PRIVATE Catch2::Catch2WithMain)

#需要自定义main()函数时使用
add_executable(tests_02 test.cpp main.cpp)
target_link_libraries(tests_02 PRIVATE Catch2::Catch2)

set(CATCH_INCLUDE_DIR  ${CMAKE_CURRENT_SOURCE_DIR}/catch2)

add_library(Catch2 INTERFACE)
target_include_directories(Catch2 INTERFACE ${CATCH_INCLUDE_DIR})

target_link_libraries(cpp_test Catch2)

#include <catch2/catch_test_macros.hpp>

static int Factorial( int number ) {
   return number <= 1 ? 1 : Factorial( number - 1 ) * number;  
}

TEST_CASE( "Factorial of 0 is 1 (fail)", "[single-file]" ) {
    REQUIRE( Factorial(0) == 1 );
}

TEST_CASE( "Factorials of 1 and higher are computed (pass)", "[single-file]" ) {
    REQUIRE( Factorial(1) == 1 );
    REQUIRE( Factorial(2) == 2 );
    REQUIRE( Factorial(3) == 6 );
    REQUIRE( Factorial(10) == 3628800 );
}

CHECK( str == "string value" );
CHECK( thisReturnsTrue() );
REQUIRE( i == 42 );

using Catch::Matchers::EndsWith;
using Catch::Matchers::ContainsSubstring;

REQUIRE_THAT( getSomeString(),
              EndsWith("as a service") && ContainsSubstring("webserver"));

TEMPLATE_TEST_CASE( "vectors can be sized and resized", "[vector][template]", int, std::string, (std::tuple<int,float>) ) {

    std::vector<TestType> v( 5 );

    REQUIRE( v.size() == 5 );
    REQUIRE( v.capacity() >= 5 );

    SECTION( "resizing bigger changes size and capacity" ) {
        v.resize( 10 );

        REQUIRE( v.size() == 10 );
        REQUIRE( v.capacity() >= 10 );
    }
    SECTION( "resizing smaller changes size but not capacity" ) {
        v.resize( 0 );

        REQUIRE( v.size() == 0 );
        REQUIRE( v.capacity() >= 5 );

        SECTION( "We can use the 'swap trick' to reset the capacity" ) {
            std::vector<TestType> empty;
            empty.swap( v );

            REQUIRE( v.capacity() == 0 );
        }
    }
    SECTION( "reserving smaller does not change size or capacity" ) {
        v.reserve( 0 );

        REQUIRE( v.size() == 5 );
        REQUIRE( v.capacity() >= 5 );
    }
}

std::uint64_t Fibonacci(std::uint64_t number) {
    return number < 2 ? 1 : Fibonacci(number - 1) + Fibonacci(number - 2);
}

TEST_CASE("Fibonacci") {
    CHECK(Fibonacci(0) == 1);
    // some more asserts..
    CHECK(Fibonacci(5) == 8);
    // some more asserts..

    // now let's benchmark:
    BENCHMARK("Fibonacci 20") {
        return Fibonacci(20);
    };

    BENCHMARK("Fibonacci 25") {
        return Fibonacci(25);
    };

}

SCENARIO( "vector can be sized and resized" ) {
    GIVEN( "An empty vector" ) {
        auto v = std::vector<std::string>{};

        // Validate assumption of the GIVEN clause
        THEN( "The size and capacity start at 0" ) {
            REQUIRE( v.size() == 0 );
            REQUIRE( v.capacity() == 0 );
        }

        // Validate one use case for the GIVEN object
        WHEN( "push_back() is called" ) {
            v.push_back("hullo");

            THEN( "The size changes" ) {
                REQUIRE( v.size() == 1 );
                REQUIRE( v.capacity() >= 1 );
            }
        }
    }
}

Scenario : vector can be sized and resized
  Given  : An empty vector
  Then   : The size and capacity start at 0

Scenario : vector can be sized and resized
  Given  : An empty vector
  When   : push_back() is called
  Then   : The size changes

#include <catch.hpp>
#include "string_utils.h"

SCENARIO("strings can be left-padded") {
  GIVEN("a string") {
    using namespace std::string_literals;
    auto string = "schneide"s;

    WHEN("the string is padded with lower length") {
      auto length = 4;
      REQUIRE(length < string.length());
      THEN("it stays the same") {
        REQUIRE(string_utils::left_pad(string, length) == string);
      }
    }

    WHEN("the string is padded with a higher length") {
      std::size_t length = 16;
      REQUIRE(length > string.length());
      THEN("empty characters are inserted to the left and the length is changed") {
        auto padded = string_utils::left_pad(string, length);
        REQUIRE(length == padded.length());
        auto padding = padded.substr(0, length - string.length());
        REQUIRE(padding == std::string(8, ' '));
      }
    }
  }
}

#编译
mkdir build
cd build/
cmake ..
make

#运行测试样例
cd tests/
./tests