본 글은 GoogleTest의 공식 문서를 번역한 것입니다. 원문은 여기서 확인하실 수 있습니다.
현재 글은 2021년 6월 3일 형상을 기준으로 번역하였으므로 시간이 지남에 따라 원문과 차이가 있을 수 있습니다.
This post is translated version of GoogleTest User’s Guide webpage. You can check original post by link.
Current translation is based on the version of June 3, 2021. So the contents may differ when time goes by.

본 문서에서는 GoogleTest에서 코드의 행동을 검증하기 위해 제공되는 단언문의 목록을 설명합니다. 아래 단언문들을 사용하려면 gtest/gtest.h헤더를 포함하면 됩니다.

앞으로 설명할 대부분의 매크로는 EXPECT_나 ASSERT_의 형태로 제공됩니다. 단언문의 조건이 실패했을 때, EXPECT_ 계열의 매크로는 심각하지 않은 실패를 발생시키고, 현재 함수가 계속 실행되게 합니다. 반면 ASSERT_ 매크로는 심각한 실패를 발생시켜 현재 함수를 강제로 중지시킵니다.

모든 단언문 매크로에 << 연산자로 스트림하여 사용자 정의 실패 메시지를 추가할 수 있습니다. 아래 예시처럼 사용할 수 있습니다.

EXPECT_TRUE(my_condition) << "My condition is not true";

C 문자열과 string 객체를 포함하여 ostream으로 스트림할 수 있는 것들은 모두 단언문 매크로에 스트림 할 수 있습니다. 확장 문자열(wide string, Windows에서 UNICODE 환경이라면 wchar_t*, TCHAR*, std::wstring)를 매크로에 스트림한다면, 출력될 때 UTF-8로 변환되어 출력됩니다.

명시적인 성공과 실패

본 문단에서 설명하는 단언문들은 값이나 표현식의 검사를 하지 않고 직접적으로 성공이나 실패를 발생시킵니다. 부울 논리식(Boolean expression) 대신 코드의 제어 흐름에 따라 테스트의 성공과 실패가 결정되는 상황에 사용하면 좋습니다. 예시는 아래와 같습니다.

switch(expression) {
  case 1:
    ... some checks ...
  case 2:
    ... some other checks ...
  default:
    FAIL() << "We shouldn't get here.";
}

SUCCEED

SUCCEED()

위 매크로를 사용하여 성공을 발생시킵니다. 이 매크로를 사용한다고 해서 전체 테스트를 성공시키는 것이 아닙니다. 각 테스트가 실행되는 동안 단언문에서 실패가 발생하지 않아야 해당 테스트가 성공했다고 합니다.

현재 SUCCEED 단언문은 사용자가 볼 수 있는 출력을 생성하지 않으며, 문서상으로만 존재하는 수준입니다. 하지만 우리는 추후 SUCCEED 단언문에 GoogleTest 출력 메시지를 추가할 예정입니다.

FAIL

FAIL()

위 매크로를 사용하여 심각한 실패를 발생시킵니다. 현재 함수에서 즉각 반환하게 합니다.

해당 단언문은 void로 반환하는 함수 안에서만 사용할 수 있습니다. 더 알고싶다면 단언문 배치하기를 참고하기 바랍니다.

ADD_FAILURE

ADD_FAILURE()

위 매크로를 사용하여 심각하지 않은 실패를 발생시킵니다. 실패 이후에도 현재 함수가 계속 동작할 수 있게 합니다.

ADD_FAILURE_AT

ADD_FAILURE_AT(file_path, line_number)

위 매크로를 사용하여 심각하지 않은 실패를 발생시킵니다. 실패 메시지에 파일 경로, 몇번째 줄 정보를 추가할 수 있습니다.

일반화된 단언문

아래 단언문들은 일치자(matchers)를 통해 값을 검증할 수 있게 해줍니다.

EXPECT_THAT

EXPECT_THAT(value, matcher)
ASSERT_THAT(value, matcher)

위 단언문은 value가 일치자 matcher의 조건을 만족하는지 검증해줍니다.

아래 예시를 보면, 문자열 value1이 "Hello"로 시작하는지 검증하고, value2가 정규표현식을 만족하는지, value3의 값이 5와 10 사이의 값인지 검증합니다.

#include "gmock/gmock.h"

using ::testing::AllOf;
using ::testing::Gt;
using ::testing::Lt;
using ::testing::MatchesRegex;
using ::testing::StartsWith;

...
EXPECT_THAT(value1, StartsWith("Hello"));
EXPECT_THAT(value2, MatchesRegex("Line \\d+"));
ASSERT_THAT(value3, AllOf(Gt(5), Lt(10)));

위의 형식처럼 단언문에서 일치자를 활용하면, 마치 영어로 된 문장을 읽듯이 자연스럽게 테스트 코드를 작성할 수 있게 하며, 테스트 실패에 대해 자세한 정보를 알 수 있는 메시지를 생성합니다. 예를 들어, 위의 value1의 검증이 실패했다면, 아래와 유사한 실패 메시지가 나타날 것입니다.

Value of: value1
  Actual: "Hi, world!"
Expected: starts with "Hello"

GoogleTest는 일치자에 관련된 내부 라이브러리를 제공합니다. 심지어 여러분이 일치자를 직접 작성할 수도 있습니다. 일치자를 사용하여 EXPECT_THAT 단언문을 강력하게, 확장하여 사용할 수 있습니다.

GoogleTest의 일치자 관련된 세부 사항은 일치자 참고 문서를 보길 바랍니다. 만약 일치자를 직접 작성하고자 한다면, 빠르게 일치자 작성하기 문단을 보길 바랍니다.

이 단언문에 대한 아이디어는 Joe Walnes의 Hamcrest 프로젝트에서 JUnit 내부에 assertThat()을 추가한 것을 차용했습니다.

부울 조건식(Boolean conditions)

아래 단언문들은 부울 조건식을 검사합니다.

EXPECT_TRUE

EXPECT_TRUE(condition)
ASSERT_TRUE(condition)

위 단언문은 논리 조건 condition이 참인지 검증합니다.

EXPECT_FALSE

EXPECT_FALSE(condition)
ASSERT_FALSE(condition)

위 단언문은 논리조건 condition이 거짓인지 검증합니다.

값 비교

앞으로 다룰 단언문들은 두 값을 비교합니다. 단언문에 전달할 인자들은 단언문에서 하려는 비교가 가능한 객체여야 합니다. 만약 비교가 불가능한 객체라면 컴파일 오류가 발생할 것입니다.

만약 전달 인자가 << 연산자를 지원한다면, 각 단언문이 실패할 경우 해당 인자를 출력하기 위해 해당 연산자를 호출할 것입니다. 만약 연산자를 통한 출력이 지원되지 않는다면, GoogleTest는 각 전달 인자를 출력하기에 가장 좋은 방법을 찾습니다. 자세한 내용은 GoogleTest에게 값을 출력하는 방법을 가르쳐주기 문단을 보기 바랍니다.

전달 인자들은 단 한번 평가(evaluate)됩니다. 그러므로 각 인자에 부수 효과가 발생해도 괜찮습니다. 하지만 평가 순서(evaluation order)는 정의되지 않았으므로 코드를 작성할 때 각 인자의 평가 순서에 종속되지 않게 코드를 작성해야 합니다.

값 비교는 일반 문자열과 확장문자열 모두 적용 가능합니다. (string과 wstring)

부동 소수점 숫자 비교 방법이나 반올림, 근사값 처리(rounding)로 인한 문제를 피하려면 부동 소수점 비교 단언문 문단을 참고하시기 바랍니다.

EXPECT_EQ

EXPECT_EQ(val1, val2)
ASSERT_EQ(val1, val2)

위 단언문은 val1==val2임을 검사합니다.

포인터 일치 검사도 지원합니다. 만약 2개의 C 문자열을 비교한다면, 위 단언문은 두 변수가 같은 메모리 위치를 가지고 있는지 검증할 뿐, 해당 문자열의 내용이 같은지 검증하는 것이 아닙니다. C 문자열(const char* 등의 자료형)의 비교에는 EXPECT_STREQ를 사용하십시오.

포인터의 값이 NULL인지 비교하려면, EXPECT_EQ(ptr, NULL) 대신 EXPECT_EQ(ptr, nullptr)를 사용해야 합니다.

EXPECT_NE

EXPECT_NE(val1, val2)
ASSERT_NE(val1, val2)

위 단언문은 val1!=val2 임을 검사합니다.

포인터 일치 검사도 지원합니다. 만약 2개의 C 문자열을 비교한다면, 위 단언문은 두 변수가 서로 다른 메모리 위치를 가지고 있는지 검증할 뿐, 해당 문자열의 내용이 다른지 검증하는 것이 아닙니다. C 문자열(const char* 등의 자료형)의 비교에는 EXPECT_STRNE를 사용하십시오.

포인터의 값이 NULL이 아닌지 비교하려면, EXPECT_NE(ptr, NULL) 대신 EXPECT_NE(ptr, nullptr)를 사용해야 합니다.

EXPECT_LT

EXPECT_LT(val1, val2)
ASSERT_LT(val1, val2)

위 단언문은 val1<val2 임을 검사합니다.

EXPECT_LE

EXPECT_LE(val1, val2)
ASSERT_LE(val1, val2)

위 단언문은 val1<=val2 임을 검사합니다.

EXPECT_GT

EXPECT_GT(val1, val2)
ASSERT_GT(val1, val2)

위 단언문은 val1>val2 임을 검사합니다.

EXPECT_GE

EXPECT_GE(val1, val2)
ASSERT_GE(val1, val2)

위 단언문은 val1>=val2 임을 검사합니다.

문자열 비교 (C 문자열)

아래 단언문들은 두 C 문자열을 비교할 때 사용합니다. 만약 두 string 객체를 비교하고자 한다면, EXPECT_EQ나 EXPECT_NE를 샤용해야 합니다.

이 단언문들은 확장 C 문자열(wchar_t*)도 지원합니다. 만약 두 확장 문자열의 비교가 실패한다면, 해당 값이 출력될 때는 UTF-8 문자열로 출력됩니다.

C 문자열이 NULL인지 비교하고싶다면, EXPECT_EQ(c_string, nullptr) 나 EXPECT_NE(c_string, nullptr)를 사용해야 합니다.

EXPECT_STREQ

EXPECT_STREQ(str1, str2)
ASSERT_STREQ(str1, str2)

위 단언문은 두 C 문자열 str1과 str2의 내용이 같은지 검사합니다.

EXPECT_STRNE

EXPECT_STRNE(str1, str2)
ASSERT_STRNE(str1, str2)

위 단언문은 두 C 문자열 str1과 str2의 내용이 다른지 검사합니다.

EXPECT_STRCASEEQ

EXPECT_STRCASEEQ(str1, str2)
ASSERT_STRCASEEQ(str1, str2)

위 단언문은 두 C 문자열 str1과 str2의 내용이 같은지 검사합니다. (대소문자 무시)

EXPECT_STRCASENE

EXPECT_STRCASENE(str1, str2)
ASSERT_STRCASENE(str1, str2)

위 단언문은 두 C 문자열 str1과 str2의 내용이 다른지 검사합니다. (대소문자 무시)

부동소수점 비교

아래 단언문들은 두 부동소수점 값을 비교합니다.

반올림, 근사값 오류로 인해 두 부동소수점 값이 정확하게 일치하는 경우는 드물기 때문에 EXPECT_EQ는 사용하기 적합하지 않습니다. 일반적으로 부동소수점 비교 시 적절한 오차 범위에 대한 처리가 필요합니다.

GoogleTest는 마지막 자리의 단위(ULPs, Units in the Last Place)를 이용한 기본적인 오차 범위를 지원하는 단언문을 지원합니다. 마지막 자리의 단위를 이용한 비교법을 자세히 알고 싶다면 부동소수점 숫자를 비교하는 방법 글을 읽어 보시기 바랍니다.

EXPECT_FLOAT_EQ

EXPECT_FLOAT_EQ(val1, val2)
ASSERT_FLOAT_EQ(val1, val2)

위 단언문은 두 float값 val1과 val2가 근사하게 같은지 비교합니다. (마지막 자리의 단위 4개 이하의 오차를 기준으로 판정)

EXPECT_DOUBLE_EQ

EXPECT_DOUBLE_EQ(val1, val2)
ASSERT_DOUBLE_EQ(val1, val2)

위 단언문은 두 double값 val1과 val2가 근사하게 같은지 비교합니다. (마지막 자리의 단위 4개 이하의 오차를 기준으로 판정)

EXPECT_NEAR

EXPECT_NEAR(val1, val2, abs_error)
ASSERT_NEAR(val1, val2, abs_error)

위 단언문은 부동소수점 값 val1과 val2의 차이가 절대값 abs_error이하인지를 확인합니다.

예외 처리 단언문

아래 단언문들은 주어진 코드 조각이 예외를 발생시키는지, 발생시키지 않는지 검증합니다. 이 기능을 사용하려면 빌드 환경에서 예외 처리를 활성화 해야 합니다.

아래 설명에서 테스트 인자로 전달되는 코드 조각은 여러 구문의 혼합(compound statement)일 수 있습니다. 아래 예시를 참고하시기 바랍니다.

EXPECT_NO_THROW({
  int n = 5;
  DoSomething(&n);
});

EXPECT_THROW

EXPECT_THROW(statement, exception_type)
ASSERT_THROW(statement, exception_type)

위 단언문은 코드 구문 statement에서 exception_type 자료형의 예외가 발생하는지 검증합니다.

EXPECT_ANY_THROW

EXPECT_ANY_THROW(statement)
ASSERT_ANY_THROW(statement)

위 단언문은 코드 구문 statement에서 자료형에 관계없이 예외가 발생하는지 검증합니다.

EXPECT_NO_THROW

EXPECT_NO_THROW(statement)
ASSERT_NO_THROW(statement)

위 단언문은 코드 구문 statement에서 예외가 발생하지 않는지 검증합니다.

서술부 단언문

아래 단언문들은 복잡한 서술부에 대한 검증을 지원합니다. 기존 EXPECT_TRUE만 단독으로 사용했을 때와 달리 좀 더 명확한 실패 메시지를 출력할 수 있습니다.

EXPECT_PRED*

EXPECT_PRED1(pred, val1)
EXPECT_PRED2(pred, val1, val2)
EXPECT_PRED3(pred, val1, val2, val3)
EXPECT_PRED4(pred, val1, val2, val3, val4)
EXPECT_PRED5(pred, val1, val2, val3, val4, val5)

ASSERT_PRED1(pred, val1)
ASSERT_PRED2(pred, val1, val2)
ASSERT_PRED3(pred, val1, val2, val3)
ASSERT_PRED4(pred, val1, val2, val3, val4)
ASSERT_PRED5(pred, val1, val2, val3, val4, val5)

위 단언문은 서술부 pred가 뒤이어 주어진 값들을 인자로 받았을 때 참인지 (true를 반환하는지) 검증합니다.

전달 인자인 pred는 함수 혹은 함수자로서 그 인자의 개수가 각 매크로의 인자 개수와 같아야 합니다. 만약 해당 pred가 주어진 인자에 대해 true를 반환한다면 그 단언문이 성공한 것이며, 아닐 경우 실패로 취급합니다.

만약 단언문이 실패한다면, 각 전달 인자의 값을 출력합니다. 모든 인자들은 언제나 각각 한번씩 평가됩니다.

예시로 아래 코드를 보기 바랍니다.

// Returns true if m and n have no common divisors except 1.
bool MutuallyPrime(int m, int n) { ... }
...
const int a = 3;
const int b = 4;
const int c = 10;
...
EXPECT_PRED2(MutuallyPrime, a, b);  // Succeeds
EXPECT_PRED2(MutuallyPrime, b, c);  // Fails

위 예시를 실행하면 첫 번째 단언문은 성공하고, 두 번째 단언문은 실패하며 아래와 같은 메시지를 남깁니다.

MutuallyPrime(b, c) is false, where
b is 4
c is 10

만약 주어진 서술부가 오버로딩 된 함수거나 템플릿 함수인 경우, 단언문 매크로는 그 중 어떤 함수를 사용해야 할 지 결정하지 못할 수도 있습니다. 이런 경우 어떤 함수를 사용할 지 알려주기 위해 명시적으로 함수의 자료형을 표현해야 합니다. 예를 들어 1개의 인자를 받는 부울 함수 IsPositive() 가 인자의 자료형이 int와 double에 대해 오버로딩 되었다면 아래와 같이 작성해야 합니다.

EXPECT_PRED1(static_cast<bool (*)(int)>(IsPositive), 5);
EXPECT_PRED1(static_cast<bool (*)(double)>(IsPositive), 3.14);

단순하게 EXPECT_PRED1(IsPositive, 5);와 같이 작성하면 컴파일 오류가 발생할 수 있습니다. 위와 비슷하게 템플릿 함수의 경우, 아래와 같이 템플릿의 자료형을 명시해야 합니다.

template <typename T>
bool IsNegative(T x) {
  return x < 0;
}
...
EXPECT_PRED1(IsNegative<int>, -5);  // Must specify type for IsNegative

만약 여러 인자를 사용하는 템플릿 함수의 경우, 해당 서술부를 괄호로 감싸서 매크로가 정확히 해석할 수 있도록 해야합니다.

ASSERT_PRED2((MyPredicate<int, int>), 5, 0);

EXPECT_PRED_FORMAT*

EXPECT_PRED_FORMAT1(pred_formatter, val1)
EXPECT_PRED_FORMAT2(pred_formatter, val1, val2)
EXPECT_PRED_FORMAT3(pred_formatter, val1, val2, val3)
EXPECT_PRED_FORMAT4(pred_formatter, val1, val2, val3, val4)
EXPECT_PRED_FORMAT5(pred_formatter, val1, val2, val3, val4, val5)

ASSERT_PRED_FORMAT1(pred_formatter, val1)
ASSERT_PRED_FORMAT2(pred_formatter, val1, val2)
ASSERT_PRED_FORMAT3(pred_formatter, val1, val2, val3)
ASSERT_PRED_FORMAT4(pred_formatter, val1, val2, val3, val4)
ASSERT_PRED_FORMAT5(pred_formatter, val1, val2, val3, val4, val5)

위 단언문은 서술부 pred_formatter가 뒤이어 주어진 값들을 인자로 받았을 때 참인지 (true를 반환하는지) 검증합니다.

전달 인자인 pred_formatter는 아래와 같은 함수 형식을 가진 서술부 형식 출력화기 (predicate-formatter) 입니다.

testing::AssertionResult PredicateFormatter(const char* expr1,
                                            const char* expr2,
                                            ...
                                            const char* exprn,
                                            T1 val1,
                                            T2 val2,
                                            ...
                                            Tn valn);

여기서 val1, val2, …, valn은 서술부의 인자로 전달되는 값을 뜻하며, expr1, expr2, …, exprn는 각 인자들이 소스 코드에 작성된 표현식을 나타냅니다. 각 자료형인 T1, T2, …, Tn는 일반 값 자료형 뿐만 아니라 레퍼런스 자료형이 될 수도 있습니다. 만약 전달 인자의 자료형이 T 일때, 해당 자료형을 적합한 상황에 따라 T 혹은 const T&로 선언할 수 있습니다. 반환 자료형인 testing::AssertionResult에 대해 더 알고싶다면 AssertionResult를 반환하는 함수 활용하기 문단을 참고하시기 바랍니다.

예시로 아래 코드를 보기 바랍니다.

// Returns the smallest prime common divisor of m and n,
// or 1 when m and n are mutually prime.
int SmallestPrimeCommonDivisor(int m, int n) { ... }

// Returns true if m and n have no common divisors except 1.
bool MutuallyPrime(int m, int n) { ... }

// A predicate-formatter for asserting that two integers are mutually prime.
testing::AssertionResult AssertMutuallyPrime(const char* m_expr,
                                             const char* n_expr,
                                             int m,
                                             int n) {
  if (MutuallyPrime(m, n)) return testing::AssertionSuccess();

  return testing::AssertionFailure() << m_expr << " and " << n_expr
      << " (" << m << " and " << n << ") are not mutually prime, "
      << "as they have a common divisor " << SmallestPrimeCommonDivisor(m, n);
}

...
const int a = 3;
const int b = 4;
const int c = 10;
...
EXPECT_PRED_FORMAT2(AssertMutuallyPrime, a, b);  // Succeeds
EXPECT_PRED_FORMAT2(AssertMutuallyPrime, b, c);  // Fails

위의 예시에서, 마지막 단언문은 실패할것이며, 서술부 형식 출력기가 아래와 같은 메시지를 남깁니다.

b and c (4 and 10) are not mutually prime, as they have a common divisor 2

Windows HRESULT 단언문

아래 단언문들은 HRESULT의 성공 혹은 실패 여부를 검증합니다. 아래 예시를 참고하기 바랍니다.

CComPtr<IShellDispatch2> shell;
ASSERT_HRESULT_SUCCEEDED(shell.CoCreateInstance(L"Shell.Application"));
CComVariant empty;
ASSERT_HRESULT_SUCCEEDED(shell->ShellExecute(CComBSTR(url), empty, empty, empty, empty));

위 단언문은 HRESULT 반환 값의 의미에 따라 사람이 쉽게 읽을 수 있는 오류 메시지를 출력합니다.

EXPECT_HRESULT_SUCCEEDED

EXPECT_HRESULT_SUCCEEDED(expression)
ASSERT_HRESULT_SUCCEEDED(expression)

위 단언문은 expression이 성공한 HRESULT를 반환하는지 검증합니다.

EXPECT_HRESULT_FAILED

EXPECT_HRESULT_FAILED(expression)
EXPECT_HRESULT_FAILED(expression)

위 단언문은 expression이 실패한 HRESULT를 반환하는지 검증합니다.

종료 단언문

아래 단언문들은 주어진 코드 조각이 프로세스를 종료시키는지 검증합니다. 이 테스트에 대한 자세한 내용은 종료 테스트 문단을 참고하시기 바랍니다.

이 단언문들은 테스트 시 새로운 프로세스를 생성하여 주어진 코드를 실행합니다. 종료테스트의 동작 원리는 동작 플랫폼의 종류에 따라 결정됩니다. 명령행 인자 --gtest_death_test_style로 전달한 설정 ::testing::GTEST_FLAG(death_test_style) 변수 값도 동작 방식에 영향을 줍니다.

• POSIX 시스템에서 fork() (혹은 Linux에서 clone()) 으로 자식을 생성합니다.
  • 만약 ::testing::GTEST_FLAG(death_test_style)의 값이 "fast"인 경우, 종료 테스트 구문은 즉시 실행됩니다.
  • 만약 ::testing::GTEST_FLAG(death_test_style)의 값이 "threadsafe"인 경우, 자식 프로세스는 현재 단위 테스트 실행파일이 실행된 방식과 동일하게 다시 실행합니다. 이 때 일부 설정을 추가하여 종료 테스트가 동시에 하나만 실행될 수 있도록 합니다.
• Windows에서는 CreateProcess() API를 통해 자식 프로세스가 생성됩니다. POSIX 시스템에서 "threadsafe" 모드로 실행한 것과 같이 동작합니다. (현재 실행파일을 다시 실행하여 종료 테스트가 동시에 하나만 실행될 수 있도록)

::testing::GTEST_FLAG(death_test_style)의 기본 값은 "fast"이며, 위에서 설명하지 않은 값으로 설정될 경우, 종료 테스트를 실패하게 합니다.

만약 종료 테스트 구문이 종료되지 않고 정상적으로 실행되더라도, 자식 프로세스는 결국에는 종료될 것이며 해당 단언문은 실패한 것으로 간주됩니다.

아래 설명에서 테스트 인자로 전달되는 코드 조각은 여러 구문의 혼합(compound statement)일 수 있습니다. 아래 예시를 참고하시기 바랍니다.

EXPECT_DEATH({
  int n = 5;
  DoSomething(&n);
}, "Error on line .* of DoSomething()");

EXPECT_DEATH

EXPECT_DEATH(statement, matcher)
ASSERT_DEATH(statement, matcher)

위 단언문은 구문 statement가 프로세스를 0이 아닌 종료상태로 종료시키는지, 그리고 stderr로 출력하는 결과가 일치자 matcher의 조건을 만족하는지 검증합니다.

전달 인자인 matcher는 const std::string&에 대한 일치자 혹은 정규표현식이어야 합니다. (정규표현식 문법 참고) 그냥 문자열 s(일치자 없이)는 Eq(s)가 아니라 ContainsRegex(s)로 취급됩니다.

예를 들어 아래 코드는 DoSomething(42)를 호출하면 프로세를 종료시키면서, My error라는 문구를 포함한 오류 메시지를 출력하는지 검증합니다.

EXPECT_DEATH(DoSomething(42), "My error");

EXPECT_DEATH_IF_SUPPORTED

EXPECT_DEATH_IF_SUPPORTED(statement, matcher)
ASSERT_DEATH_IF_SUPPORTED(statement, matcher)

위 단언문은 종료 테스트가 지원되는 경우 EXPECT_DEATH와 동일한 역할을 합니다. 종료 테스트가 지원되지 않는다면 아무 일도 일어나지 않습니다.

EXPECT_DEBUG_DEATH

EXPECT_DEBUG_DEATH(statement, matcher)
ASSERT_DEBUG_DEATH(statement, matcher)

위 단언문은 디버그 모드에서 EXPECT_DEATH와 동일한 역할을 합니다. 만약 디버그 모드가 아니라면 (예를 들어 NDEBUG가 정의됨) 구문 statement만 그냥 실행함.

EXPECT_EXIT

EXPECT_EXIT(statement, predicate, matcher)
ASSERT_EXIT(statement, predicate, matcher)

위 단언문은 구문 statement가 predicate의 조건을 만족하는 종료 상태로 종료시키는지, 그리고 stderr로 출력하는 결과가 일치자 matcher의 조건을 만족하는지 검증합니다.

전달 인자 predicate는 int 종료 상태를 인자로 입력받아 bool을 반환하는 함수 혹은 함수자입니다. GoogleTest에서는 일반적인 경우에 사용할 만한 두가지 서술부를 제공합니다.

// Returns true if the program exited normally with the given exit status code.
::testing::ExitedWithCode(exit_code);

// Returns true if the program was killed by the given signal.
// Not available on Windows.
::testing::KilledBySignal(signal_number);

전달 인자인 matcher는 const std::string&에 대한 일치자 혹은 정규표현식이어야 합니다. (정규표현식 문법 참고) 그냥 문자열 s(일치자 없이)는 Eq(s)가 아니라 ContainsRegex(s)로 취급됩니다.

예를 들어 아래 코드는 NormalExit()을 호출하면 stderr에 Success가 포함된 메시지를 출력하면서, 종료상태 0으로 프로세스를 종료시키는지 검증합니다.

EXPECT_EXIT(NormalExit(), testing::ExitedWithCode(0), "Success");

번역 관련 주석 (원문에 존재하지 않음)

원문과 번역한 단어의 목록은 다음과 같습니다. (그대로 음차한 번역은 생략합니다.) 익숙하지 않은 표현이거나, 오해의 가능성이 있는 번역의 경우, 처음 해당 표현이 나온 부분에 원문을 추가로 작성했습니다.