blc/test/blc_test.h - C++ 유닛 테스트 라이브러리

blc_test.h 에는 유닛 테스트를 위한 클래스와 (assertion 을 위한) 매크로 함수들이 포함되어 있습니다. 인라인 함수 대신 매크로 함수를 사용한 이유는, assertion 문이 위치한 라인 넘버를 메시지에 포함시키기 위함입니다. 물론 매크로 함수가 인라인 함수에 비해 갖는 단점들이 있으므로, 이 점을 주의해서 사용해야 합니다.

모든 기능을 사용한 예제는 이 문서의 제일 아래에서 찾을 수 있습니다.

이 문서에서는 blc_test.h에 포함된 클래스와 매크로 함수에 대해 설명합니다. 아래에 설명된 요소들은 모두 namespace blc::test 내부에 선언되어 있습니다(매크로 함수 제외).

• class UnitTest

  ---

  유닛 테스트를 위한 클래스 입니다. 이 클래스를 상속받은 자식 클래스에서, 실제 테스트를 수행할 코드를 작성해야 합니다. 다음은 예제 코드 입니다.
  
  

  1. #include "blc/test/blc_test.h"
  2. using namespace blc::test;
  3.  
  4. class TestGroup : public UnitTest // blc::test::UnitTest를 상속받습니다.
  5. {
  6. public:
  7. TestGroup() : UnitTest(u8"Test Group Name") { // blc::test::UnitTest의 생성자에
  8. // 그룹 이름을 넘겨줍니다
  9. // (UTF-8 인코딩 사용).
  10.  
  11. Test(u8"Test Name", // 생성자 내부에서 blc::test::UnitTest의 protected
  12. // 멤버 함수를 사용하여 테스트 케이스를 생성합니다.
  13. // 테스트 코드에 사용되는 모든 문자열은 UTF-8 인코딩이
  14. // 요구됩니다.
  16. []() { // 실제 테스트 코드는 람다를 이용해 작성합니다.
  17. double a = 0.0; // this를 갈무리(캡쳐)하면, 람다가 TestGroup의 멤버에
  18. double b = 1.0; // 접근할 수 있습니다.
  19.  
  20. for (int i = 0; i < 10; ++i) {
  21. a += 0.1;
  22. }
  23.  
  24. ASSERT_TRUE(a == b); // 매크로 함수로 정의된 assertion 문으로
  25. // 테스트 코드를 작성합니다.
  26. }
  27. );
  28. }
  29. };
  30.  
  31. int main()
  32. {
  33. TestGroup test_group; // 테스트 그룹의 객체가 한 개 이상 있어야 해당 그룹의
  34. // 테스트가 수행됩니다. 테스트 그룹의 객체가 두 개 이상일
  35. // 필요는 없습니다
  36. // (두 개 이상이면 선언한 수만큼 테스트가 반복됨).
  37.  
  38. UnitTest::Run("A:\\test_result_1.html", u8"Unit Test Name", true);
  39. // blc::test::UnitTest의 정적 멤버 함수 Run에 테스트 결과를 담을 HTML 파일의 경로 및
  40. // 이름, 유닛 테스트 이름, 어두운(true)/밝은(false) 테마를 인자로 넘겨줍니다.
  41.  
  42. // 이 코드를 실행하면 blc::test::UnitTest::Run에서 설정한 경로에
  43. // HTML로 작성된 테스트 보고서 파일이 생성됩니다.
  44.  
  45. return 0;
  46. }

  
  다음은 위의 코드를 실행시켜 얻은 테스트 보고서 파일(HTML) 입니다.
  test_result_1.html
  
  테스트 시간을 측정하는 기능이 있지만 그렇게 정확하지 않으므로 참고만 하세요(컴퓨터 사양이나 CPU 사용률, 캐시 히트 여부 등에 따라서 다른 결과가 나올 수 있습니다). assertion 문을 예외 기능으로 구현했기 때문에 실패한 테스트의 테스트 타임이 대체로 더 길게 측정됩니다.
  
  위의 예제 코드에서 생성자 내부에서 호출한 함수 Test는 람다로 작성된 테스트 케이스를 등록해주는 역할을 합니다. 이와 같은 역할을 하는 함수는 네 가지가 제공됩니다.

  1. Test
  2. ParameterizedTestWithException
  3. ParameterizedTest
  4. RepeatedTest

  
  위의 예제 코드에서 테스트 케이스(람다) 내부에 사용된 ASSERT_TRUE(매크로 함수)는 테스트 케이스가 패스해야 하는 조건을 서술해 줍니다. 이와 같은 역할을 하는 assertion 매크로 함수는 12 가지가 제공됩니다.

  1. ASSERT_TIMEOUT
  2. ASSERT_THROWS
  3. ASSERT_TRUE_MSG
  4. ASSERT_FALSE_MSG
  5. ASSERT_FLOAT_EQUALS_MSG
  6. ASSERT_EQUALS_MSG
  7. FAIL_MSG
  8. ASSERT_TRUE
  9. ASSERT_FALSE
  10. ASSERT_FLOAT_EQUALS
  11. ASSERT_EQUALS
  12. FAIL

  ---

  
  
  • public 내부 선언 타입
    • struct TestGroup final

      ---

      유닛 테스트 그룹에 관한 정보를 담는 구조체 입니다. class UnitTest 내부에서 사용하는 타입으로, 직접 이 구조체를 사용할 일은 없습니다. (이 구조체의 멤버에 직접 접근하여 사용하는 것은 권장하지 않습니다)

      ---

      
      
    • struct BasicTestCase

      ---

      테스트 케이스들의 부모 클래스가 될 구조체 입니다. 테스트 케이스들이 공통으로 갖는 데이터들을 담아두는 역할을 합니다. class UnitTest 내부에서 사용하는 타입으로, 직접 이 구조체를 사용할 일은 없습니다. (이 구조체의 멤버에 직접 접근하여 사용하는 것은 권장하지 않습니다)

      ---

      
      
    • using TestCaseSP

      ---

      BasicTestCase의 스마트 포인터(std::shared_ptr) 타입 별칭입니다.

      ---

      
      
    • using TestGroupVector

      ---

      struct TestGroup을 담는 벡터(std::vector)의 별칭입니다. 모든 테스트 그룹들을 담습니다.

      ---

      
      
    • using TestCaseVector

      ---

      TestCaseSP를 담는 벡터(std::vector)의 별칭입니다. 테스트 그룹마다 하나씩 멤버로 가지고 있으며, 각 그룹의 모든 테스트 케이스들을 담습니다.

      ---

      
      
  • protected 내부 선언 타입
    • class Assert final

      ---

      assertion(매크로 함수)이 실패했을 때 던져지는 예외 처리용 클래스 입니다. 직접 이 클래스의 객체를 던지는 것은 권장되지 않습니다. assertion 매크로 함수를 통해 사용하는 것이 권장됩니다.

      ---

      
      
    • class RepeatedTestCaseHeader

      ---

      반복 테스트나 매개변수 사용 테스트에서, 반복되는 테스트와 관련된 정보를 집계하는 역할을 하는 클래스 입니다. struct BasicTestCase를 상속받아 구현되며, RepeatedTestCaseHeader 스스로는 어떤 테스트도 수행하지 않습니다. 직접 이 클래스를 사용하는것은 권장되지 않습니다. UnitTest의 protected 멤버 함수를 통해 사용하는 것이 권장됩니다.

      ---

      
      
    • class TestCase

      ---

      하나의 테스트 케이스에 대한 정보를 담는 역할을 하는 클래스 입니다. struct BasicTestCase를 상속받아 구현됩니다. 직접 이 클래스를 사용하는 것은 권장되지 않습니다. UnitTest의 protected 멤버 함수를 통해 사용하는 것이 권장됩니다.

      ---

      
      
    • template class ParameterizedTestCase

      ---

      매개변수를 받는, 테스트 케이스에 대한 정보를 담는 역할을 하는 클래스 템플릿 입니다. struct BasicTestCase를 상속받아 구현됩니다. 직접 이 클래스 템플릿을 사용하는 것은 권장되지 않습니다. UnitTest의 protected 멤버 함수를 통해 사용하는 것이 권장됩니다.

      ---

      
      
    • template class TestCaseWithException

      ---

      특정 예외가 던져지는지 테스트하는, 테스트 케이스에 대한 정보를 담는 역할을 하는 클래스 템플릿 입니다. 다른 테스트 케이스 계열 클래스를 상속받아 구현됩니다. 직접 이 클래스 템플릿을 사용하는 것은 권장되지 않습니다. UnitTest의 protected 멤버 함수를 통해 사용하는 것이 권장됩니다.

      ---

      
      
    • class RepetitionInfo

      ---

      반복 테스트에서, 현재 반복 횟수와 전체 반복 횟수에 관한 정보를 담는 클래스 입니다.

      • RepetitionInfo(size_t current_repetition, size_t total_repetitions)
        생성자 입니다. 현재 반복 횟수와 전체 반복 횟수를 넘겨받아 멤버 변수에 담아둡니다.
      • size_t get_current_repetition() const noexcept
        멤버 변수에 담아둔 현재 반복 횟수를 얻습니다.
      • size_t get_total_repetitions() const noexcept
        멤버 변수에 담아둔 전체 반복 횟수를 얻습니다.

      ---

      
      
  • public 멤버 함수
    • static int Run(
      const char* file_name,
      const char* main_title = "BLC Unit Test Report",
      bool dark_thema = true
      )

      ---

      유닛 테스트를 위한 자식 클래스들의 생성자가 등록해둔 테스트 케이스들을 모두 실행합니다. file_name에는 테스트 결과 보고서가 저장될 경로와 파일 이름을 넘겨줍니다. 테스트 결과 보고서는 HTML 파일이므로, 파일 이름의 확장자는 ".html" 이어야 합니다. main_title에는 유닛 테스트 이름(테스트 결과 보고서의 이름)을 넘겨줍니다. 마지막으로 dark_thema에는, 테스트 결과 보고서의 다크 테마 사용 여부를 넘겨줍니다. true를 넘겨주면 다크 테마가 적용되고, false를 넘겨주면 라이트 테마가 적용됩니다. Run 함수를 호출할 때마다, 모든 테스트 케이스들을 다시 실행하여 결과 보고서를 생성합니다. 오류 없이 실행을 완료하였다면 0을 반환하고, 그렇지 않으면 0이 아닌 값을 반환합니다.

      ---

      
      
    • static void clear()

      ---

      등록된 모든 테스트 그룹의 테스트 케이스들과, 실행 결과 데이터를 제거합니다. 여러 테스트 그룹이 있을 때, 몇몇 그룹을 묶어서 각 묶음마다 다른 테스트 결과 보고서를 생성하고자 할 때 사용합니다. 다음은 예제 코드입니다.
      
      

      1. ...
      2.  
      3. int main()
      4. {
      5. // 테스트 그룹의 생성자가, 테스트 그룹에 포함된 모든 테스트 케이스를
      6. // blc::test::UnitTest 클래스에 등록합니다.
      7. TestGroup1 test_group1;
      8. TestGroup2 test_group2;
      9.  
      10. // 테스트 그룹 1과 2는 test_result_1.html 파일에 결과를 보고합니다.
      11. UnitTest::Run("A:\\test_result_1.html", u8"Unit Test Name", true);
      12. UnitTest::clear(); // UnitTest 초기화
      14. TestGroup3 test_group3;
      15. TestGroup4 test_group4;
      17. // 테스트 그룹 3과 4는 test_result_2.html 파일에 결과를 보고합니다.
      18. UnitTest::Run("A:\\test_result_2.html"); // 디폴트 인수 사용으로 2, 3번째 인수 생략
      19.  
      20. return 0;
      21. }

      ---

      
      
    • static size_t get_total_pass_count() noexcept

      ---

      Run 실행 후 집계된, 통과한 테스트 케이스의 개수를 반환합니다.

      ---

      
      
    • static size_t get_total_fail_count() noexcept

      ---

      Run 실행 후 집계된, 실패한 테스트 케이스의 개수를 반환합니다.

      ---

      
      
    • static size_t get_total_ignore_count() noexcept

      ---

      Run 실행 후 집계된, 무시된 테스트 케이스의 개수를 반환합니다.

      ---

      
      
    • static const TestGroupVector& get_const_test_group_vector() noexcept

      ---

      UnitTest에 등록된 모든 테스트 그룹을 담는 TestGroupVector타입 객체의 상수 참조자를 얻습니다.

      ---

      
      
    • const TestCaseVector& get_test_case_vector() const noexcept

      ---

      특정 테스트 그룹 객체에 포함된 모든 테스트 케이스를 담는 TestCaseVector타입 객체의 상수 참조자를 얻습니다.

      ---

      
      
  • protected 멤버 함수
    • UnitTest(const std::string& group_name)

      ---

      생성자 입니다. UnitTest의 생성자와 소멸자는 protected 영역에 선언되어 있으므로, UnitTest 객체를 직접 생성할 수는 없습니다. UnitTest를 상속받은 자식 클래스 객체의 생성을 통해서만 생성이 가능합니다. 생성자는 테스트 그룹의 이름을 받아, 그 이름으로 해당 그룹(자식 클래스의 객체)을 TestGroupVector타입 객체에 집어넣습니다.

      ---

      
      
    • virtual ~UnitTest()

      ---

      소멸자 입니다. 소멸 시 멤버 변수(객체)의 소멸자를 호출하는 일 이외에 별다른 일을 하지 않습니다. UnitTest의 생성자와 소멸자는 protected 영역에 선언되어 있으므로 UnitTest 객체를 직접 생성할 수는 없습니다. UnitTest를 상속받은 자식 클래스 객체의 생성을 통해서만 생성이 가능합니다.

      ---

      
      
    • template void Test(...)

      ---

      UnitTest를 상속받은 테스트 그룹 클래스의 생성자 정의에서, 테스트 케이스를 등록해주는 함수 템플릿 입니다. 가장 기본적인 테스트 케이스를 등록합니다. 이 함수 템플릿은 두 가지 오버로딩 버전이 제공됩니다.
      
      

      1. //-----------------------------------------------------------------------------
      2. // 1
      3. template <typename ExceptionType_ = void, typename TimeUnit_>
      4. std::enable_if_t<impl::IsDuration<std::decay_t<TimeUnit_>>::value>
      5. Test(
      6. const std::string& test_name,
      7. TimeUnit_&& time_limit,
      8. typename TestCaseWithException<ExceptionType_, TestCase>::TestFuncType test_case,
      9. bool ignore = false
      10. );
      11.  
      12. // 템플릿 타입인수 ExceptionType_으로 테스트 케이스가 던져야 할 예외를
      13. // 지정할 수 있습니다. 기본값은 void(예외를 던지지 않아야 패스) 입니다.
      14.  
      15. // 첫 번째 매개변수(test_name)로 등록할 테스트 케이스의 이름을 넘겨줍니다.
      16. // test_name은 UTF-8로 인코딩 되어 있어야 합니다.
      17.  
      18. // 두 번째 매개변수(time_limit)로 테스트 케이스의 시간 제한을 설정할 수 있습니다.
      19. // std::chrono 네임스페이스에 선언된 리터럴을 사용할 수 있습니다.
      20. // 예를 들어 6 밀리초 제한을 두고 싶으면, time_limit에 6ms를 넘겨줍니다.
      21. // 시간 제한을 두지 않으려면 0ms를 넘겨주거나 아래에 설명할 두 번재 오버로딩 버전의
      22. // Test 함수 템플릿을 사용합니다.
      23.  
      24. // 세 번째 매개변수(test_case)로 실제 테스트를 수행할 함수자를 넘겨줍니다.
      25. // 가장 편한 방법인 람다를 사용하는 것을 권장합니다. 여기서 함수자는
      26. // 인자를 하나도 받지 않고 반환 타입이 void이어야 합니다.
      27.  
      28. // 네 번째 매개변수(ignore)에 디폴트 인자값 false가 아닌 true를 넘겨주면,
      29. // 해당 테스트 케이스는, blc::test::UnitTest::Run 함수 호출 시
      30. // 테스트를 수행하지 않고 건너뜁니다(무시합니다).
      31.  
      32.  
      33. //-----------------------------------------------------------------------------
      34. // 2
      35. template <typename ExceptionType_ = void>
      36. void Test(
      37. const std::string& test_name,
      38. typename TestCaseWithException<ExceptionType_, TestCase>::TestFuncType test_case,
      39. bool ignore = false
      40. );
      41.  
      42. // 위의 첫 번째 오버로딩 버전과 실행 시간 제한을 두지 않는다는 점만 다르고,
      43. // 나머지는 전부 동일합니다.
      44.  
      45.  
      46. //-----------------------------------------------------------------------------
      47. // 예제(컴파일까지 되는 완전한 예제는 이 문서의 제일 아래에서 찾을 수 있습니다.)
      48.  
      49. // 다음의 코드는 람다에 포함된 assertion 문들 중
      50. // 하나라도 실패하면 실패하는 테스트 케이스를 등록합니다.
      51. Test(u8"Test case name",
      52. []() {
      53. ...
      54. 테스트를 위한 assertion 문들;
      55. }
      56. );
      57.  
      58. // 첫 예제와 같으나, 정수형(int) 예외를 던져야
      59. // 패스되는 테스트 케이스를 등록합니다.
      60. Test<int>(u8"Test case name",
      61. []() {
      62. ...
      63. 테스트를 위한 assertion 문들;
      65. throw 0; // 다른 타입의 예외가 던져지거나,
      66. // 예외가 전혀 던져지지 않으면 실패합니다.
      67. }
      68. );
      69.  
      70. // 첫 예제와 같으나, 테스트 코드가 1밀리초 내에
      71. // 실행되지 않으면 실패하는 테스트 케이스를 등록합니다.
      72. using namespace std::chrono;
      73. Test(u8"Test case name", 1ms,
      74. []() {
      75. ...
      76. 테스트를 위한 assertion 문들;
      77. }
      78. );
      79.  
      80. // 두 번째 예제와 세 번째 예제를 섞을수도 있습니다.
      81. using namespace std::chrono;
      82. Test<int>(u8"Test case name", 1ms,
      83. []() {
      84. ...
      85. 테스트를 위한 assertion 문들;
      86. }
      87. );
      88.  
      89. // 첫 예제와 같으나, 테스트가 실행되지 않고 건너뜁니다(무시됩니다).
      90. Test(u8"Test case name",
      91. []() {
      92. ...
      93. 테스트를 위한 assertion 문들;
      94. }, true
      95. );
      96.  

      
      시간 제한 기능은 그렇게 정확하지 않으므로 참고만 하세요(컴퓨터 사양이나 CPU 사용률, 캐시 히트 여부 등에 따라서 다른 결과가 나올 수 있습니다). 예제에는 밀리초 단위만을 사용했으나 다른 시간 단위도 사용할 수 있습니다.

      ---

      
      
    • template void ParameterizedTestWithException(...)

      ---

      UnitTest를 상속받은 테스트 그룹 클래스의 생성자 정의에서, 테스트 케이스를 등록해주는 함수 템플릿 입니다. 매개변수를 받고, 특정 예외를 던져야 통과하는 테스트 케이스를 등록합니다. 이 함수 템플릿은 두 가지 오버로딩 버전이 제공됩니다.
      
      

      1. //-----------------------------------------------------------------------------
      2. // 1
      3. template <typename ExceptionType_, typename... Args_, typename TimeUnit1_, typename TimeUnit2_>
      4. std::enable_if_t<
      5. impl::IsDuration<std::decay_t<TimeUnit1_>>::value &&
      6. impl::IsDuration<std::decay_t<TimeUnit2_>>::value
      7. >
      8. ParameterizedTestWithException(
      9. const std::string& test_name,
      10. TimeUnit1_&& time_limit,
      11. TimeUnit2_&& total_time_limit,
      12. const std::vector<impl::TupleOrType_t<Args_...>>& arg_list,
      13. typename TestCaseWithException<ExceptionType_, ParameterizedTestCase<Args_...>>::TestFuncType test_case,
      14. bool ignore = false
      15. );
      16.  
      17. // 템플릿 타입인수 ExceptionType_으로 테스트 케이스가 던져야 할 예외를
      18. // 지정할 수 있습니다. 예외 지정을 하지 않으려면, ParameterizedTest를 사용해 주세요.
      19.  
      20. // 가변 인자 템플릿(Args_)을 통해 테스트 케이스가 받아들일 매개변수의 타입들을
      21. // 지정할 수 있습니다.
      22.  
      23. // 첫 번째 매개변수(test_name)로 등록할 테스트 케이스의 이름을 넘겨줍니다.
      24. // test_name은 UTF-8로 인코딩 되어 있어야 합니다.
      25.  
      26. // 두 번째 매개변수(time_limit)로 테스트 케이스의 시간 제한을 설정할 수 있습니다.
      27.  
      28. // 세 번째 매개변수(total_time_limit)로, 이 함수 템플릿을 한번 호출해 등록된
      29. // 테스트 케이스들의 실행시간 총합의 제한을 설정할 수 있습니다.
      30. // 이 시간을 초과하더라도 실패하지는 않지만, 제한 시간을 초과했다는 메시지가 표시됩니다.
      31.  
      32. // 두 번째와 세 번째 매개변수에는 std::chrono 네임스페이스에 선언된 리터럴을
      33. // 사용할 수 있습니다. 예를 들어 6 밀리초 제한을 두고 싶으면, time_limit에
      34. // 6ms를 넘겨줍니다. 시간 제한을 두지 않으려면 0ms을 넘겨주면 됩니다. 만일
      35. // time_limit와 total_time_limit를 모두 사용하지 않는다면, 아래에 설명할 두 번째
      36. // 오버로딩 버전을 사용합니다.
      37.  
      38. // 네 번째 매개변수(arg_list)로 테스트 케이스에 넘겨줄 인수값들을
      39. // 지정할 수 있습니다. 한 번에 넘겨줄 매개변수들을 튜플에 담고,
      40. // 그 튜플들을 담은 벡터(std::vector)가 arg_list입니다.
      41.  
      42. // 다섯 번째 매개변수(test_case)로 실제로 테스트를 수행할 함수자를
      43. // 지정할 수 있습니다. 가장 간편한 람다를 사용하는것을 권장합니다.
      44. // 이 함수자는 매개변수로 Args_... 를 받아들여야 하며,
      45. // ExceptionType_으로 지정된 예외를 던져야 실패하지 않습니다.
      46. // 또한 반환 타입이 void이어야 합니다.
      47.  
      48. // 여섯 번째 매개변수(ignore)에 디폴트 인자값 false가 아닌 true를 넘겨주면,
      49. // 해당 테스트 케이스는, blc::test::UnitTest::Run 함수 호출 시
      50. // 테스트를 수행하지 않고 건너뜁니다(무시합니다).
      51.  
      52.  
      53. //-----------------------------------------------------------------------------
      54. // 2
      55. template <typename ExceptionType_, typename... Args_>
      56. void ParameterizedTestWithException(
      57. const std::string& test_name,
      58. const std::vector<impl::TupleOrType_t<Args_...>>& arg_list,
      59. typename TestCaseWithException<ExceptionType_, ParameterizedTestCase<Args_...>>::TestFuncType test_case,
      60. bool ignore = false
      61. );
      62.  
      63. // 위의 첫 번째 오버로딩 버전과 실행 시간 제한을 두지 않는다는 점만 다르고,
      64. // 나머지는 전부 동일합니다.
      65.  
      66.  
      67. //-----------------------------------------------------------------------------
      68. // 예제(컴파일까지 되는 완전한 예제는 이 문서의 제일 아래에서 찾을 수 있습니다.)
      69.  
      70. // 다음의 코드는 람다에 포함된 assertion 문들 중
      71. // 하나라도 실패하거나 const char*형 예외를 던지지
      72. // 않으면 실패하는 테스트 케이스를 등록합니다.
      73. // 이 테스트 케이스는 int형 매개변수와 double형 매개변수를
      74. // 각각 하나씩 받습니다.
      75. ParameterizedTestWithException<const char*, int, double>(
      76. u8"Test case name",
      77. {
      78. {1, 0.1}, // 총 세 세트의 매개변수 세트가 있으므로
      79. {2, 0.2}, // 한 세트식 매개변수를 받아 총 세 번의
      80. {3, 0.3}, // 테스트를 수행합니다.
      81. },
      82. [](int i, double d) {
      83. ...
      84. 테스트를 위한 assertion 문들;
      86. throw "Some string"; // 다른 타입의 예외가 던져지거나,
      87. // 예외가 전혀 던져지지 않으면 실패합니다.
      88. }
      89. );
      90.  
      91. // 첫 예제와 같으나, 매개변수 종류가 int형 한 개인
      92. // 테스트 케이스를 등록합니다.
      93. ParameterizedTestWithException<const char*, int>(
      94. u8"Test case name",
      95. {
      96. 1, // 총 세 세트의 매개변수 세트가 있으므로
      97. 2, // 한 세트식 매개변수를 받아 총 세 번의
      98. 3, // 테스트를 수행합니다.
      99. },
      100. [](int i) {
      101. ...
      102. 테스트를 위한 assertion 문들;
      104. throw "Some string"; // 다른 타입의 예외가 던져지거나,
      105. // 예외가 전혀 던져지지 않으면 실패합니다.
      106. }
      107. );
      108.  
      109. // 첫 예제와 같으나, 각 매개변수 세트마다 1밀리초,
      110. // 모든 매개변수 세트를 테스트 하는데는 2밀리초 만큼의
      111. // 시간 제한이 있는 테스트 케이스를 등록합니다.
      112. using namespace std::chrono;
      113. ParameterizedTestWithException<const char*, int, double>(
      114. u8"Test case name",
      115. 1ms, // 시간 제한을 두지 않으려면, 0ms를 넘기면 됩니다.
      116. 2ms, // 마찬가지
      117. {
      118. {1, 0.1}, // 총 세 세트의 매개변수 세트가 있으므로
      119. {2, 0.2}, // 한 세트식 매개변수를 받아 총 세 번의
      120. {3, 0.3}, // 테스트를 수행합니다.
      121. },
      122. [](int i, double d) {
      123. ...
      124. 테스트를 위한 assertion 문들;
      126. throw "Some string"; // 다른 타입의 예외가 던져지거나,
      127. // 예외가 전혀 던져지지 않으면 실패합니다.
      128. }
      129. );
      130.  
      131. // 첫 예제와 같으나, 테스트가 실행되지 않고 건너뜁니다(무시됩니다).
      132. ParameterizedTestWithException<const char*, int, double>(
      133. u8"Test case name",
      134. {
      135. {1, 0.1}, // 총 세 세트의 매개변수 세트가 있으므로
      136. {2, 0.2}, // 한 세트식 매개변수를 받아 총 세 번의
      137. {3, 0.3}, // 테스트를 수행합니다.
      138. },
      139. [](int i, double d) {
      140. ...
      141. 테스트를 위한 assertion 문들;
      143. throw "Some string"; // 다른 타입의 예외가 던져지거나,
      144. // 예외가 전혀 던져지지 않으면 실패합니다.
      145. }, true
      146. );
      147.  

      
      시간 제한 기능은 그렇게 정확하지 않으므로 참고만 하세요(컴퓨터 사양이나 CPU 사용률, 캐시 히트 여부 등에 따라서 다른 결과가 나올 수 있습니다). 예제에는 밀리초 단위만을 사용했으나 다른 시간 단위도 사용할 수 있습니다.

      ---

      
      
    • template void ParameterizedTest(...)

      ---

      UnitTest를 상속받은 테스트 그룹 클래스의 생성자 정의에서, 테스트 케이스를 등록해주는 함수 템플릿 입니다. ParameterizedTestWithException에서 예외 지정 기능만 뺀 버전입니다. 이 함수 템플릿 역시 두 개의 오버로딩 버전이 제공됩니다.
      
      

      1. //-----------------------------------------------------------------------------
      2. // 1
      3. template <typename... Args_, typename TimeUnit1_, typename TimeUnit2_>
      4. std::enable_if_t<
      5. impl::IsDuration<std::decay_t<TimeUnit1_>>::value&&
      6. impl::IsDuration<std::decay_t<TimeUnit2_>>::value
      7. >
      8. ParameterizedTest(
      9. const std::string& test_name,
      10. TimeUnit1_&& time_limit,
      11. TimeUnit2_&& total_time_limit,
      12. const std::vector<impl::TupleOrType_t<Args_...>>& arg_list,
      13. typename ParameterizedTestCase<Args_...>::TestFuncType test_case,
      14. bool ignore = false
      15. );
      16.  
      17. // 가변 인자 템플릿(Args_)을 통해 테스트 케이스가 받아들일 매개변수의 타입들을
      18. // 지정할 수 있습니다.
      19.  
      20. // 첫 번째 매개변수(test_name)로 등록할 테스트 케이스의 이름을 넘겨줍니다.
      21. // test_name은 UTF-8로 인코딩 되어 있어야 합니다.
      22.  
      23. // 두 번째 매개변수(time_limit)로 테스트 케이스의 시간 제한을 설정할 수 있습니다.
      24.  
      25. // 세 번째 매개변수(total_time_limit)로, 이 함수 템플릿을 한번 호출해 등록된
      26. // 테스트 케이스들의 실행시간 총합의 제한을 설정할 수 있습니다.
      27. // 이 시간을 초과하더라도 실패하지는 않지만, 제한 시간을 초과했다는 메시지가 표시됩니다.
      28.  
      29. // 두 번째와 세 번째 매개변수에는 std::chrono 네임스페이스에 선언된 리터럴을
      30. // 사용할 수 있습니다. 예를 들어 6 밀리초 제한을 두고 싶으면, time_limit에
      31. // 6ms를 넘겨줍니다. 시간 제한을 두지 않으려면 0ms을 넘겨주면 됩니다. 만일
      32. // time_limit와 total_time_limit를 모두 사용하지 않는다면, 아래에 설명할 두 번째
      33. // 오버로딩 버전을 사용합니다.
      34.  
      35. // 네 번째 매개변수(arg_list)로 테스트 케이스에 넘겨줄 인수값들을
      36. // 지정할 수 있습니다. 한 번에 넘겨줄 매개변수들을 튜플에 담고,
      37. // 그 튜플들을 담은 벡터(std::vector)가 arg_list입니다.
      38.  
      39. // 다섯 번째 매개변수(test_case)로 실제로 테스트를 수행할 함수자를
      40. // 지정할 수 있습니다. 가장 간편한 람다를 사용하는것을 권장합니다.
      41. // 이 함수자는 매개변수로 Args_... 를 받아들여야 하고,
      42. // 반환 타입이 void이어야 합니다.
      43.  
      44. // 여섯 번째 매개변수(ignore)에 디폴트 인자값 false가 아닌 true를 넘겨주면,
      45. // 해당 테스트 케이스는, blc::test::UnitTest::Run 함수 호출 시
      46. // 테스트를 수행하지 않고 건너뜁니다(무시합니다).
      47.  
      48.  
      49. //-----------------------------------------------------------------------------
      50. // 2
      51. template <typename... Args_>
      52. void ParameterizedTest(
      53. const std::string& test_name,
      54. const std::vector<impl::TupleOrType_t<Args_...>>& arg_list,
      55. typename ParameterizedTestCase<Args_...>::TestFuncType test_case,
      56. bool ignore = false
      57. );
      58.  
      59. // 위의 첫 번째 오버로딩 버전과 실행 시간 제한을 두지 않는다는 점만 다르고,
      60. // 나머지는 전부 동일합니다.
      61.  
      62.  
      63. //-----------------------------------------------------------------------------
      64. // 예제(컴파일까지 되는 완전한 예제는 이 문서의 제일 아래에서 찾을 수 있습니다.)
      65.  
      66. // 다음의 코드는 람다에 포함된 assertion 문들 중
      67. // 하나라도 실패하면 실패하는 테스트 케이스를 등록합니다.
      68. // 이 테스트 케이스는 int형 매개변수와 double형 매개변수를
      69. // 각각 하나씩 받습니다.
      70. ParameterizedTest<int, double>(
      71. u8"Test case name",
      72. {
      73. {1, 0.1}, // 총 세 세트의 매개변수 세트가 있으므로
      74. {2, 0.2}, // 한 세트식 매개변수를 받아 총 세 번의
      75. {3, 0.3}, // 테스트를 수행합니다.
      76. },
      77. [](int i, double d) {
      78. ...
      79. 테스트를 위한 assertion 문들;
      80. }
      81. );
      82.  
      83. // 첫 예제와 같으나, 매개변수 종류가 int형 한 개인
      84. // 테스트 케이스를 등록합니다.
      85. ParameterizedTest<int>(
      86. u8"Test case name",
      87. {
      88. 1, // 총 세 세트의 매개변수 세트가 있으므로
      89. 2, // 한 세트식 매개변수를 받아 총 세 번의
      90. 3, // 테스트를 수행합니다.
      91. },
      92. [](int i) {
      93. ...
      94. 테스트를 위한 assertion 문들;
      95. }
      96. );
      97.  
      98. // 첫 예제와 같으나, 모든 매개변수 세트를
      99. // 테스트 하는데는 2초 만큼의 시간 제한이
      100. // 있는 테스트 케이스를 등록합니다.
      101. using namespace std::chrono;
      102. ParameterizedTest<int, double>(
      103. u8"Test case name",
      104. 0ms, // 시간 제한을 두지 않으려면, 0ms를 넘기면 됩니다.
      105. 2s, // 마찬가지
      106. {
      107. {1, 0.1}, // 총 세 세트의 매개변수 세트가 있으므로
      108. {2, 0.2}, // 한 세트식 매개변수를 받아 총 세 번의
      109. {3, 0.3}, // 테스트를 수행합니다.
      110. },
      111. [](int i, double d) {
      112. ...
      113. 테스트를 위한 assertion 문들;
      114. }
      115. );
      116.  
      117. // 첫 예제와 같으나, 테스트가 실행되지 않고 건너뜁니다(무시됩니다).
      118. ParameterizedTest<int, double>(
      119. u8"Test case name",
      120. {
      121. {1, 0.1}, // 총 세 세트의 매개변수 세트가 있으므로
      122. {2, 0.2}, // 한 세트식 매개변수를 받아 총 세 번의
      123. {3, 0.3}, // 테스트를 수행합니다.
      124. },
      125. [](int i, double d) {
      126. ...
      127. 테스트를 위한 assertion 문들;
      128. }, true
      129. );
      130.  

      
      시간 제한 기능은 그렇게 정확하지 않으므로 참고만 하세요(컴퓨터 사양이나 CPU 사용률, 캐시 히트 여부 등에 따라서 다른 결과가 나올 수 있습니다).

      ---

      
      
    • template void RepeatedTest(...)

      ---

      UnitTest를 상속받은 테스트 그룹 클래스의 생성자 정의에서, 테스트 케이스를 등록해주는 함수 템플릿 입니다. 이 함수 템플릿이 등록하는 테스트 케이스는 매개변수로 지정된 횟수만큼 반복하여 테스트를 수행합니다. 이 함수 템플릿은 네 가지 오버로딩 버전이 제공됩니다.
      
      

      1. //-----------------------------------------------------------------------------
      2. // 1
      3. template <typename ExceptionType_ = void, typename TimeUnit1_, typename TimeUnit2_>
      4. std::enable_if_t<
      5. impl::IsDuration<std::decay_t<TimeUnit1_>>::value &&
      6. impl::IsDuration<std::decay_t<TimeUnit2_>>::value
      7. >
      8. RepeatedTest(
      9. const std::string& test_name,
      10. TimeUnit1_&& time_limit,
      11. TimeUnit2_&& total_time_limit,
      12. size_t value,
      13. typename TestCaseWithException<ExceptionType_, ParameterizedTestCase<RepetitionInfo>>::TestFuncType test_case,
      14. bool ignore = false
      15. );
      16.  
      17. // 템플릿 타입인수 ExceptionType_으로 테스트 케이스가 던져야 할 예외를
      18. // 지정할 수 있습니다. 기본값은 void(예외를 던지지 않아야 패스) 입니다.
      19.  
      20. // 첫 번째 매개변수(test_name)로 등록할 테스트 케이스의 이름을 넘겨줍니다.
      21. // test_name은 UTF-8로 인코딩 되어 있어야 합니다.
      22.  
      23. // 두 번째 매개변수(time_limit)로 테스트 케이스의 시간 제한을 설정할 수 있습니다.
      25. // 세 번째 매개변수(total_time_limit)로, 이 함수 템플릿을 한번 호출해 등록된
      26. // 테스트 케이스들의 실행시간 총합의 제한을 설정할 수 있습니다.
      27. // 이 시간을 초과하더라도 실패하지는 않지만, 제한 시간을 초과했다는 메시지가 표시됩니다.
      29. // 두 번째와 세 번째 매개변수에는 std::chrono 네임스페이스에 선언된 리터럴을
      30. // 사용할 수 있습니다. 예를 들어 6 밀리초 제한을 두고 싶으면, time_limit에
      31. // 6ms를 넘겨줍니다. 시간 제한을 두지 않으려면 0ms을 넘겨주면 됩니다. 만일
      32. // time_limit와 total_time_limit를 모두 사용하지 않는다면, 아래에 설명할 두 번째
      33. // 오버로딩 버전을 사용합니다.
      34.  
      35. // 네 번째 매개변수(value)로 총 반복 횟수를 설정할 수 있습니다.
      36.  
      37. // 다섯 번째 매개변수(test_case)로 실제로 테스트를 수행할 함수자를
      38. // 지정할 수 있습니다. 가장 간편한 람다를 사용하는것을 권장합니다.
      39. // 이 함수자는 매개변수로 RepetitionInfo 타입의 객체를 하나 받아야 하며,
      40. // 반환 타입은 void이어야 합니다.
      41.  
      42. // 여섯 번째 매개변수(ignore)에 디폴트 인자값 false가 아닌 true를 넘겨주면,
      43. // 해당 테스트 케이스는, blc::test::UnitTest::Run 함수 호출 시
      44. // 테스트를 수행하지 않고 건너뜁니다(무시합니다).
      45.  
      46.  
      47. //-----------------------------------------------------------------------------
      48. // 2
      49. template <typename ExceptionType_ = void>
      50. void RepeatedTest(
      51. const std::string& test_name,
      52. size_t value,
      53. typename TestCaseWithException<ExceptionType_, ParameterizedTestCase<RepetitionInfo>>::TestFuncType test_case,
      54. bool ignore = false
      55. );
      56.  
      57. // 위의 첫 번째 오버로딩 버전과 실행 시간 제한을 두지 않는다는 점만 다르고,
      58. // 나머지는 전부 동일합니다.
      59.  
      60.  
      61. //-----------------------------------------------------------------------------
      62. // 3
      63. template <typename ExceptionType_ = void, typename TimeUnit1_, typename TimeUnit2_>
      64. std::enable_if_t<
      65. impl::IsDuration<std::decay_t<TimeUnit1_>>::value&&
      66. impl::IsDuration<std::decay_t<TimeUnit2_>>::value
      67. >
      68. RepeatedTest(
      69. const std::string& test_name,
      70. TimeUnit1_&& time_limit,
      71. TimeUnit2_&& total_time_limit,
      72. size_t value,
      73. typename TestCaseWithException<ExceptionType_, ParameterizedTestCase<>>::TestFuncType test_case,
      74. bool ignore = false
      75. );
      76.  
      77. // 다섯 번째 매개변수(test_case)로 넘겨줄 함수자가
      78. // 아무런 매개변수를 받지 않는다는 점만 다르고,
      79. // 위의 첫 번째 오버로딩 버전과 동일합니다.
      80.  
      81.  
      82. //-----------------------------------------------------------------------------
      83. // 4
      84. template <typename ExceptionType_ = void>
      85. void RepeatedTest(
      86. const std::string& test_name,
      87. size_t value,
      88. typename TestCaseWithException<ExceptionType_, ParameterizedTestCase<>>::TestFuncType test_case,
      89. bool ignore = false
      90. );
      91.  
      92. // 세 번째 매개변수(test_case)로 넘겨줄 함수자가
      93. // 아무런 매개변수를 받지 않는다는 점만 다르고,
      94. // 위의 두 번째 오버로딩 버전과 동일합니다.
      95.  
      96.  
      97. //-----------------------------------------------------------------------------
      98. // 예제(컴파일까지 되는 완전한 예제는 이 문서의 제일 아래에서 찾을 수 있습니다.)
      99.  
      100. // 다음의 코드는 람다에 포함된 assertion 문들 중
      101. // 하나라도 실패하면 실패하는 테스트 케이스를, 3 번 반복하도록
      102. // 등록합니다.
      103. RepeatedTest(u8"Test case name",
      104. 3, // 총 3회 반복합니다.
      105. [](const RepetitionInfo& repetition_info) { // RepetitionInfo 매개변수는
      106. // 없어도 됨니다.
      107. ...
      109. // 현재 몇 번째 반복중인지를 얻습니다.
      110. auto current_repetition = repetition_info.get_current_repetition();
      112. // 전체 반복 횟수를 얻습니다.
      113. auto total_repetitions = repetition_info.get_total_repetitions();
      114. ...
      115. 테스트를 위한 assertion 문들;
      116. }
      117. );
      118.  
      119. // 첫 예제와 같으나, 실수형(double) 예외를 던져야
      120. // 패스되는 테스트 케이스를 등록합니다.
      121. RepeatedTest<double>(u8"Test case name",
      122. 3, // 총 3회 반복합니다.
      123. [](const RepetitionInfo& repetition_info) { // RepetitionInfo 매개변수는
      124. // 없어도 됨니다.
      125. ...
      127. // 현재 몇 번째 반복중인지를 얻습니다.
      128. auto current_repetition = repetition_info.get_current_repetition();
      130. // 전체 반복 횟수를 얻습니다.
      131. auto total_repetitions = repetition_info.get_total_repetitions();
      132. ...
      133. 테스트를 위한 assertion 문들;
      135. throw 0.0;
      136. }
      137. );
      138.  
      139. // 첫 예제외 같으나, 테스트 케이스가 반복될 때
      140. // 각각의 실행마다 1초의 시간 제한이 있는
      141. // 테스트 케이스를 등록합니다.
      142. RepeatedTest(u8"Test case name",
      143. 1s, // 시간 제한을 두지 않으려면, 0ms를 넘기면 됩니다.
      144. 0ms, // 마찬가지
      145. 3, // 총 3회 반복합니다.
      146. [](const RepetitionInfo& repetition_info) { // RepetitionInfo 매개변수는
      147. // 없어도 됨니다.
      148. ...
      150. // 현재 몇 번째 반복중인지를 얻습니다.
      151. auto current_repetition = repetition_info.get_current_repetition();
      153. // 전체 반복 횟수를 얻습니다.
      154. auto total_repetitions = repetition_info.get_total_repetitions();
      155. ...
      156. 테스트를 위한 assertion 문들;
      157. }
      158. );
      159.  
      160. // 두 번째 예제와 세 번째 예제를 섞을수도 있습니다.
      161. RepeatedTest<double>(u8"Test case name",
      162. 1s, // 시간 제한을 두지 않으려면, 0ms를 넘기면 됩니다.
      163. 0ms, // 마찬가지
      164. 3, // 총 3회 반복합니다.
      165. [](const RepetitionInfo& repetition_info) { // RepetitionInfo 매개변수는
      166. // 없어도 됨니다.
      167. ...
      169. // 현재 몇 번째 반복중인지를 얻습니다.
      170. auto current_repetition = repetition_info.get_current_repetition();
      172. // 전체 반복 횟수를 얻습니다.
      173. auto total_repetitions = repetition_info.get_total_repetitions();
      174. ...
      175. 테스트를 위한 assertion 문들;
      177. throw 0.0;
      178. }
      179. );
      180.  
      181. // 첫 예제와 같으나, 테스트가 실행되지 않고 건너뜁니다(무시됩니다).
      182. RepeatedTest(u8"Test case name",
      183. 3, // 총 3회 반복합니다.
      184. [](const RepetitionInfo& repetition_info) { // RepetitionInfo 매개변수는
      185. // 없어도 됨니다.
      186. ...
      188. // 현재 몇 번째 반복중인지를 얻습니다.
      189. auto current_repetition = repetition_info.get_current_repetition();
      191. // 전체 반복 횟수를 얻습니다.
      192. auto total_repetitions = repetition_info.get_total_repetitions();
      193. ...
      194. 테스트를 위한 assertion 문들;
      195. }, true
      196. );
      197.  

      
      시간 제한 기능은 그렇게 정확하지 않으므로 참고만 하세요(컴퓨터 사양이나 CPU 사용률, 캐시 히트 여부 등에 따라서 다른 결과가 나올 수 있습니다).

      ---

      
      
    • template auto AssertTimeout(...)

      ---

      시간 제한 assertion 의 구현을 위한 멤버 함수입니다. 이 멤버 함수를 직접 호출하는 것은 권장되지 않으며, 이 멤버함수를 사용하는 assertion 매크로 함수를 사용하는 것이 권장됩니다.

      ---

      
      
    • template auto AssertThrows(...)

      ---

      예외 지정 assertion 의 구현을 위한 멤버 함수입니다. 이 멤버 함수를 직접 호출하는 것은 권장되지 않으며, 이 멤버함수를 사용하는 assertion 매크로 함수를 사용하는 것이 권장됩니다.

      ---

      
      
  • private 가상 함수
    • virtual void Before()

      ---

      각 테스트 케이스를 실행하기 전에 호출되는 가상 멤버 함수입니다. 직접 호출은 불가능하지만, 오버라이딩을 통해 동작을 변경하는 것이 가능합니다. 기본 동작은 "아무것도 하지 않음" 입니다.

      ---

      
      
    • virtual void After()

      ---

      각 테스트 케이스를 실행한 후에 호출되는 가상 멤버 함수입니다. 직접 호출은 불가능하지만, 오버라이딩을 통해 동작을 변경하는 것이 가능합니다. 기본 동작은 "아무것도 하지 않음" 입니다.

      ---

      
      
    • virtual void BeforeClass()

      ---

      각 테스트 그룹을 실행하기 전에 호출되는 가상 멤버 함수입니다. 직접 호출은 불가능하지만, 오버라이딩을 통해 동작을 변경하는 것이 가능합니다. 기본 동작은 "아무것도 하지 않음" 입니다.

      ---

      
      
    • virtual void AfterClass()

      ---

      각 테스트 그룹을 실행한 후에 호출되는 가상 멤버 함수입니다. 직접 호출은 불가능하지만, 오버라이딩을 통해 동작을 변경하는 것이 가능합니다. 기본 동작은 "아무것도 하지 않음" 입니다.

      ---

      
      
• assertion 매크로 함수

  ---

  테스트 케이스 내부에서 사용할 assertion 매크로 함수의 목록입니다. 인라인 함수 대신 매크로 함수를 사용하는 이유는, 테스트 결과 보고서에 assertion 문이 위치한 라인 넘버를 표시해 주기 위해서 입니다. 매크로 함수는 인라인 함수에 비해 여러 단점이 있으므로 주의해서 사용해야 합니다. 모든 assertion 매크로 함수는 실패 시, 실패한 assertion이 위치한 파일 이름과 파일 내의 line 넘버가 테스트 결과 보고서에 출력됩니다.

  ---

  
  
  • #define ASSERT_TIMEOUT(time_limit, task)

    ---

    함수자 task가 제한시간 time_limit 내에 실행되면 패스, 제한시간을 초과하면 실패하는 assertion 입니다. time_limit에는 std::chrono 네임스페이스에 선언된 리터럴을 사용할 수 있습니다. task의 반환 타입이 void가 아닌 경우 ASSERT_TIMEOUT문장은 그 반환 값을 갖습니다. 다음은 예제 코드입니다.
    
    

    1. Test(u8"Test case name",
    2. []() {
    3. using namespace std::chrono;
    5. auto task1 = [](){
    6. ...
    7. };
    8. ASSERT_TIMEOUT(1s, task1);
    9. // task1이 1초 내에 실행이 완료되면 패스, 그렇지 않으면 실패입니다.
    11. auto task2 = [](){
    12. ...
    13. return 10;
    14. };
    15. int a = ASSERT_TIMEOUT(1s, task2);
    16. // task1의 경우와 같지만 task2는 반환 타입이 void가
    17. // 아닙니다. 이 경우 a는 10의 값을 갖습니다.
    18. }
    19. );

    
    컴파일까지 되는 완전한 예제는 이 문서의 제일 아래에서 찾을 수 있습니다.

    ---

    
    
  • #define ASSERT_THROWS(exception_type, task)

    ---

    함수자 task가 지정한 예외 exception_type 타입의 예외를 던지면 패스, 다른 타입의 예외를 던지거나 예외를 던지지 않으면 실패하는 assertion 입니다. exception_type이 void인 경우에는 어떤 예외도 던지지 않아야 패스합니다. task가 지정한 타입과 일치하는 예외를 던진 경우 ASSERT_THROWS문장은 던져진 예외 값을 갖습니다. 다음은 예제 코드입니다.
    
    

    1. Test(u8"Test case name",
    2. []() {
    3. using namespace std::chrono;
    5. auto task1 = [](){
    6. ...
    7. };
    8. ASSERT_THROWS(void, task1);
    9. // 지정된 예외가 void이므로 task1은 어떤 예외도 던지지 않아야 패스,
    10. // 어떤 예외라도 던지면 실패 합니다.
    12. auto task2 = [](){
    13. ...
    14. throw 10;
    15. };
    16. int a = ASSERT_THROWS(int, task2);
    17. // 지정된 타입의 예외가 던져져야 패스, 다른 타입의 예외가 던져지거나
    18. // 예외가 던져지지 않으면 실패합니다. ASSERT_THROWS 문의 값은,
    19. // 지정된 예외가 던져진 경우 그 값이 됩니다. 즉, 이 경우
    20. // a의 값은 10이 됩니다.
    22. auto e = ASSERT_THROWS(std::exception,
    23. []() {
    24. throw std::logic_error(u8"로직오류 발생!!");
    25. }
    26. );
    27. // 예외 지정된 타입의 자식 타입 예외가 던져져도 됩니다.
    28. // 다만, 환경에 따라서 e.what() 함수가 u8"로직오류 발생!!"를
    29. // 반환하지 않을 수도 있습니다.
    30. }
    31. );

    
    컴파일까지 되는 완전한 예제는 이 문서의 제일 아래에서 찾을 수 있습니다.

    ---

    
    
  • #define ASSERT_TRUE_MSG(condition, message)

    ---

    condition이 true일 경우 패스, false일 경우 실패하는 assertion 입니다. message는 assertion 실패 시 테스트 결과 보고서에 표시할 문자열로, UTF-8로 인코딩 된 문자열이어야 합니다.
    컴파일까지 되는 완전한 예제는 이 문서의 제일 아래에서 찾을 수 있습니다.

    ---

    
    
  • #define ASSERT_FALSE_MSG(condition, message)

    ---

    condition이 false일 경우 패스, true일 경우 실패하는 assertion 입니다. message는 assertion 실패 시 테스트 결과 보고서에 표시할 문자열로, UTF-8로 인코딩 된 문자열이어야 합니다.
    컴파일까지 되는 완전한 예제는 이 문서의 제일 아래에서 찾을 수 있습니다.

    ---

    
    
  • #define ASSERT_FLOAT_EQUALS_MSG(expected, actual, delta, message)

    ---

    부동 소수점 값, expected와 actual을 비교하여 같으면 패스, 다르면 실패하는 assertion 입니다. ±delta 만큼의 오차를 허용합니다. message는 assertion 실패 시 테스트 결과 보고서에 표시할 문자열로, UTF-8로 인코딩 된 문자열이어야 합니다.
    컴파일까지 되는 완전한 예제는 이 문서의 제일 아래에서 찾을 수 있습니다.

    ---

    
    
  • #define ASSERT_EQUALS_MSG(expected, actual, message)

    ---

    부동 소수점 값이 아닌 다른 모든 타입에 대해, expected와 actual을 비교하여 같으면 패스, 다르면 실패하는 assertion 입니다. message는 assertion 실패 시 테스트 결과 보고서에 표시할 문자열로, UTF-8로 인코딩 된 문자열이어야 합니다.
    컴파일까지 되는 완전한 예제는 이 문서의 제일 아래에서 찾을 수 있습니다.

    ---

    
    
  • #define FAIL_MSG(message)

    ---

    이 assertion 이 실행되면 무조건 실패하는 assertion 입니다. message는 assertion 실패 시 테스트 결과 보고서에 표시할 문자열로, UTF-8로 인코딩 된 문자열이어야 합니다.
    컴파일까지 되는 완전한 예제는 이 문서의 제일 아래에서 찾을 수 있습니다.

    ---

    
    
  • #define ASSERT_TRUE(condition)

    ---

    condition이 true일 경우 패스, false일 경우 실패하는 assertion 입니다. assertion 실패시 #condition을 테스트 결과 보고서에 표시합니다.
    컴파일까지 되는 완전한 예제는 이 문서의 제일 아래에서 찾을 수 있습니다.

    ---

    
    
  • #define ASSERT_FALSE(condition)

    ---

    condition이 false일 경우 패스, true일 경우 실패하는 assertion 입니다. assertion 실패시 "!("#condition")"을 테스트 결과 보고서에 표시합니다.
    컴파일까지 되는 완전한 예제는 이 문서의 제일 아래에서 찾을 수 있습니다.

    ---

    
    
  • #define ASSERT_FLOAT_EQUALS(expected, actual, delta)

    ---

    부동 소수점 값, expected와 actual을 비교하여 같으면 패스, 다르면 실패하는 assertion 입니다. ±delta 만큼의 오차를 허용합니다. assertion 실패 시 actual, expected, delta의 값을 테스트 결과 보고서에 표시합니다.
    컴파일까지 되는 완전한 예제는 이 문서의 제일 아래에서 찾을 수 있습니다.

    ---

    
    
  • #define ASSERT_EQUALS(expected, actual)

    ---

    부동 소수점 값이 아닌 다른 모든 타입에 대해, expected와 actual을 비교하여 같으면 패스, 다르면 실패하는 assertion 입니다. assertion 실패 시 actual, expected, delta의 값을 테스트 결과 보고서에 표시합니다. 이때 std::ofstream에 대한 operator << 연산자가 사용되므로, actual의 타입(expected의 타입과 동일)에 대해 std::ostream과의 operator << 연산자가 오버로딩 되어 있어야 합니다.
    컴파일까지 되는 완전한 예제는 이 문서의 제일 아래에서 찾을 수 있습니다.

    ---

    
    
  • #define FAIL()

    ---

    이 assertion 이 실행되면 무조건 실패하는 assertion 입니다. assertion 실패 시 기본적인 메시지(assertion 실패가 발생한 파일 및 line 넘버)만 테스트 결과 보고서에 표시합니다.
    컴파일까지 되는 완전한 예제는 이 문서의 제일 아래에서 찾을 수 있습니다.

    ---