PageRenderTime 91ms CodeModel.GetById 19ms app.highlight 64ms RepoModel.GetById 1ms app.codeStats 0ms

/thirdparty/breakpad/third_party/protobuf/protobuf/gtest/test/gtest-port_test.cc

http://github.com/tomahawk-player/tomahawk
C++ | 1018 lines | 883 code | 84 blank | 51 comment | 8 complexity | 3d56b57c2a8054d00bc4d5c5b370329b MD5 | raw file
   1// Copyright 2008, Google Inc.
   2// All rights reserved.
   3//
   4// Redistribution and use in source and binary forms, with or without
   5// modification, are permitted provided that the following conditions are
   6// met:
   7//
   8//     * Redistributions of source code must retain the above copyright
   9// notice, this list of conditions and the following disclaimer.
  10//     * Redistributions in binary form must reproduce the above
  11// copyright notice, this list of conditions and the following disclaimer
  12// in the documentation and/or other materials provided with the
  13// distribution.
  14//     * Neither the name of Google Inc. nor the names of its
  15// contributors may be used to endorse or promote products derived from
  16// this software without specific prior written permission.
  17//
  18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29//
  30// Authors: vladl@google.com (Vlad Losev), wan@google.com (Zhanyong Wan)
  31//
  32// This file tests the internal cross-platform support utilities.
  33
  34#include <gtest/internal/gtest-port.h>
  35
  36#include <stdio.h>
  37
  38#if GTEST_OS_MAC
  39#include <time.h>
  40#endif  // GTEST_OS_MAC
  41
  42#include <utility>  // For std::pair and std::make_pair.
  43
  44#include <gtest/gtest.h>
  45#include <gtest/gtest-spi.h>
  46
  47// Indicates that this translation unit is part of Google Test's
  48// implementation.  It must come before gtest-internal-inl.h is
  49// included, or there will be a compiler error.  This trick is to
  50// prevent a user from accidentally including gtest-internal-inl.h in
  51// his code.
  52#define GTEST_IMPLEMENTATION_ 1
  53#include "src/gtest-internal-inl.h"
  54#undef GTEST_IMPLEMENTATION_
  55
  56using std::make_pair;
  57using std::pair;
  58
  59namespace testing {
  60namespace internal {
  61
  62// Tests that the element_type typedef is available in scoped_ptr and refers
  63// to the parameter type.
  64TEST(ScopedPtrTest, DefinesElementType) {
  65  StaticAssertTypeEq<int, ::testing::internal::scoped_ptr<int>::element_type>();
  66}
  67
  68// TODO(vladl@google.com): Implement THE REST of scoped_ptr tests.
  69
  70TEST(GtestCheckSyntaxTest, BehavesLikeASingleStatement) {
  71  if (AlwaysFalse())
  72    GTEST_CHECK_(false) << "This should never be executed; "
  73                           "It's a compilation test only.";
  74
  75  if (AlwaysTrue())
  76    GTEST_CHECK_(true);
  77  else
  78    ;  // NOLINT
  79
  80  if (AlwaysFalse())
  81    ;  // NOLINT
  82  else
  83    GTEST_CHECK_(true) << "";
  84}
  85
  86TEST(GtestCheckSyntaxTest, WorksWithSwitch) {
  87  switch (0) {
  88    case 1:
  89      break;
  90    default:
  91      GTEST_CHECK_(true);
  92  }
  93
  94  switch(0)
  95    case 0:
  96      GTEST_CHECK_(true) << "Check failed in switch case";
  97}
  98
  99#if GTEST_OS_MAC
 100void* ThreadFunc(void* data) {
 101  pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data);
 102  pthread_mutex_lock(mutex);
 103  pthread_mutex_unlock(mutex);
 104  return NULL;
 105}
 106
 107TEST(GetThreadCountTest, ReturnsCorrectValue) {
 108  EXPECT_EQ(1U, GetThreadCount());
 109  pthread_mutex_t mutex;
 110  pthread_attr_t  attr;
 111  pthread_t       thread_id;
 112
 113  // TODO(vladl@google.com): turn mutex into internal::Mutex for automatic
 114  // destruction.
 115  pthread_mutex_init(&mutex, NULL);
 116  pthread_mutex_lock(&mutex);
 117  ASSERT_EQ(0, pthread_attr_init(&attr));
 118  ASSERT_EQ(0, pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE));
 119
 120  const int status = pthread_create(&thread_id, &attr, &ThreadFunc, &mutex);
 121  ASSERT_EQ(0, pthread_attr_destroy(&attr));
 122  ASSERT_EQ(0, status);
 123  EXPECT_EQ(2U, GetThreadCount());
 124  pthread_mutex_unlock(&mutex);
 125
 126  void* dummy;
 127  ASSERT_EQ(0, pthread_join(thread_id, &dummy));
 128
 129  // MacOS X may not immediately report the updated thread count after
 130  // joining a thread, causing flakiness in this test. To counter that, we
 131  // wait for up to .5 seconds for the OS to report the correct value.
 132  for (int i = 0; i < 5; ++i) {
 133    if (GetThreadCount() == 1)
 134      break;
 135
 136    SleepMilliseconds(100);
 137  }
 138  EXPECT_EQ(1U, GetThreadCount());
 139  pthread_mutex_destroy(&mutex);
 140}
 141#else
 142TEST(GetThreadCountTest, ReturnsZeroWhenUnableToCountThreads) {
 143  EXPECT_EQ(0U, GetThreadCount());
 144}
 145#endif  // GTEST_OS_MAC
 146
 147TEST(GtestCheckDeathTest, DiesWithCorrectOutputOnFailure) {
 148  const bool a_false_condition = false;
 149  const char regex[] =
 150#ifdef _MSC_VER
 151     "gtest-port_test\\.cc\\(\\d+\\):"
 152#else
 153     "gtest-port_test\\.cc:[0-9]+"
 154#endif  // _MSC_VER
 155     ".*a_false_condition.*Extra info.*";
 156
 157  EXPECT_DEATH_IF_SUPPORTED(GTEST_CHECK_(a_false_condition) << "Extra info",
 158                            regex);
 159}
 160
 161#if GTEST_HAS_DEATH_TEST
 162
 163TEST(GtestCheckDeathTest, LivesSilentlyOnSuccess) {
 164  EXPECT_EXIT({
 165      GTEST_CHECK_(true) << "Extra info";
 166      ::std::cerr << "Success\n";
 167      exit(0); },
 168      ::testing::ExitedWithCode(0), "Success");
 169}
 170
 171#endif  // GTEST_HAS_DEATH_TEST
 172
 173#if GTEST_USES_POSIX_RE
 174
 175#if GTEST_HAS_TYPED_TEST
 176
 177template <typename Str>
 178class RETest : public ::testing::Test {};
 179
 180// Defines StringTypes as the list of all string types that class RE
 181// supports.
 182typedef testing::Types<
 183    ::std::string,
 184#if GTEST_HAS_GLOBAL_STRING
 185    ::string,
 186#endif  // GTEST_HAS_GLOBAL_STRING
 187    const char*> StringTypes;
 188
 189TYPED_TEST_CASE(RETest, StringTypes);
 190
 191// Tests RE's implicit constructors.
 192TYPED_TEST(RETest, ImplicitConstructorWorks) {
 193  const RE empty(TypeParam(""));
 194  EXPECT_STREQ("", empty.pattern());
 195
 196  const RE simple(TypeParam("hello"));
 197  EXPECT_STREQ("hello", simple.pattern());
 198
 199  const RE normal(TypeParam(".*(\\w+)"));
 200  EXPECT_STREQ(".*(\\w+)", normal.pattern());
 201}
 202
 203// Tests that RE's constructors reject invalid regular expressions.
 204TYPED_TEST(RETest, RejectsInvalidRegex) {
 205  EXPECT_NONFATAL_FAILURE({
 206    const RE invalid(TypeParam("?"));
 207  }, "\"?\" is not a valid POSIX Extended regular expression.");
 208}
 209
 210// Tests RE::FullMatch().
 211TYPED_TEST(RETest, FullMatchWorks) {
 212  const RE empty(TypeParam(""));
 213  EXPECT_TRUE(RE::FullMatch(TypeParam(""), empty));
 214  EXPECT_FALSE(RE::FullMatch(TypeParam("a"), empty));
 215
 216  const RE re(TypeParam("a.*z"));
 217  EXPECT_TRUE(RE::FullMatch(TypeParam("az"), re));
 218  EXPECT_TRUE(RE::FullMatch(TypeParam("axyz"), re));
 219  EXPECT_FALSE(RE::FullMatch(TypeParam("baz"), re));
 220  EXPECT_FALSE(RE::FullMatch(TypeParam("azy"), re));
 221}
 222
 223// Tests RE::PartialMatch().
 224TYPED_TEST(RETest, PartialMatchWorks) {
 225  const RE empty(TypeParam(""));
 226  EXPECT_TRUE(RE::PartialMatch(TypeParam(""), empty));
 227  EXPECT_TRUE(RE::PartialMatch(TypeParam("a"), empty));
 228
 229  const RE re(TypeParam("a.*z"));
 230  EXPECT_TRUE(RE::PartialMatch(TypeParam("az"), re));
 231  EXPECT_TRUE(RE::PartialMatch(TypeParam("axyz"), re));
 232  EXPECT_TRUE(RE::PartialMatch(TypeParam("baz"), re));
 233  EXPECT_TRUE(RE::PartialMatch(TypeParam("azy"), re));
 234  EXPECT_FALSE(RE::PartialMatch(TypeParam("zza"), re));
 235}
 236
 237#endif  // GTEST_HAS_TYPED_TEST
 238
 239#elif GTEST_USES_SIMPLE_RE
 240
 241TEST(IsInSetTest, NulCharIsNotInAnySet) {
 242  EXPECT_FALSE(IsInSet('\0', ""));
 243  EXPECT_FALSE(IsInSet('\0', "\0"));
 244  EXPECT_FALSE(IsInSet('\0', "a"));
 245}
 246
 247TEST(IsInSetTest, WorksForNonNulChars) {
 248  EXPECT_FALSE(IsInSet('a', "Ab"));
 249  EXPECT_FALSE(IsInSet('c', ""));
 250
 251  EXPECT_TRUE(IsInSet('b', "bcd"));
 252  EXPECT_TRUE(IsInSet('b', "ab"));
 253}
 254
 255TEST(IsDigitTest, IsFalseForNonDigit) {
 256  EXPECT_FALSE(IsDigit('\0'));
 257  EXPECT_FALSE(IsDigit(' '));
 258  EXPECT_FALSE(IsDigit('+'));
 259  EXPECT_FALSE(IsDigit('-'));
 260  EXPECT_FALSE(IsDigit('.'));
 261  EXPECT_FALSE(IsDigit('a'));
 262}
 263
 264TEST(IsDigitTest, IsTrueForDigit) {
 265  EXPECT_TRUE(IsDigit('0'));
 266  EXPECT_TRUE(IsDigit('1'));
 267  EXPECT_TRUE(IsDigit('5'));
 268  EXPECT_TRUE(IsDigit('9'));
 269}
 270
 271TEST(IsPunctTest, IsFalseForNonPunct) {
 272  EXPECT_FALSE(IsPunct('\0'));
 273  EXPECT_FALSE(IsPunct(' '));
 274  EXPECT_FALSE(IsPunct('\n'));
 275  EXPECT_FALSE(IsPunct('a'));
 276  EXPECT_FALSE(IsPunct('0'));
 277}
 278
 279TEST(IsPunctTest, IsTrueForPunct) {
 280  for (const char* p = "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~"; *p; p++) {
 281    EXPECT_PRED1(IsPunct, *p);
 282  }
 283}
 284
 285TEST(IsRepeatTest, IsFalseForNonRepeatChar) {
 286  EXPECT_FALSE(IsRepeat('\0'));
 287  EXPECT_FALSE(IsRepeat(' '));
 288  EXPECT_FALSE(IsRepeat('a'));
 289  EXPECT_FALSE(IsRepeat('1'));
 290  EXPECT_FALSE(IsRepeat('-'));
 291}
 292
 293TEST(IsRepeatTest, IsTrueForRepeatChar) {
 294  EXPECT_TRUE(IsRepeat('?'));
 295  EXPECT_TRUE(IsRepeat('*'));
 296  EXPECT_TRUE(IsRepeat('+'));
 297}
 298
 299TEST(IsWhiteSpaceTest, IsFalseForNonWhiteSpace) {
 300  EXPECT_FALSE(IsWhiteSpace('\0'));
 301  EXPECT_FALSE(IsWhiteSpace('a'));
 302  EXPECT_FALSE(IsWhiteSpace('1'));
 303  EXPECT_FALSE(IsWhiteSpace('+'));
 304  EXPECT_FALSE(IsWhiteSpace('_'));
 305}
 306
 307TEST(IsWhiteSpaceTest, IsTrueForWhiteSpace) {
 308  EXPECT_TRUE(IsWhiteSpace(' '));
 309  EXPECT_TRUE(IsWhiteSpace('\n'));
 310  EXPECT_TRUE(IsWhiteSpace('\r'));
 311  EXPECT_TRUE(IsWhiteSpace('\t'));
 312  EXPECT_TRUE(IsWhiteSpace('\v'));
 313  EXPECT_TRUE(IsWhiteSpace('\f'));
 314}
 315
 316TEST(IsWordCharTest, IsFalseForNonWordChar) {
 317  EXPECT_FALSE(IsWordChar('\0'));
 318  EXPECT_FALSE(IsWordChar('+'));
 319  EXPECT_FALSE(IsWordChar('.'));
 320  EXPECT_FALSE(IsWordChar(' '));
 321  EXPECT_FALSE(IsWordChar('\n'));
 322}
 323
 324TEST(IsWordCharTest, IsTrueForLetter) {
 325  EXPECT_TRUE(IsWordChar('a'));
 326  EXPECT_TRUE(IsWordChar('b'));
 327  EXPECT_TRUE(IsWordChar('A'));
 328  EXPECT_TRUE(IsWordChar('Z'));
 329}
 330
 331TEST(IsWordCharTest, IsTrueForDigit) {
 332  EXPECT_TRUE(IsWordChar('0'));
 333  EXPECT_TRUE(IsWordChar('1'));
 334  EXPECT_TRUE(IsWordChar('7'));
 335  EXPECT_TRUE(IsWordChar('9'));
 336}
 337
 338TEST(IsWordCharTest, IsTrueForUnderscore) {
 339  EXPECT_TRUE(IsWordChar('_'));
 340}
 341
 342TEST(IsValidEscapeTest, IsFalseForNonPrintable) {
 343  EXPECT_FALSE(IsValidEscape('\0'));
 344  EXPECT_FALSE(IsValidEscape('\007'));
 345}
 346
 347TEST(IsValidEscapeTest, IsFalseForDigit) {
 348  EXPECT_FALSE(IsValidEscape('0'));
 349  EXPECT_FALSE(IsValidEscape('9'));
 350}
 351
 352TEST(IsValidEscapeTest, IsFalseForWhiteSpace) {
 353  EXPECT_FALSE(IsValidEscape(' '));
 354  EXPECT_FALSE(IsValidEscape('\n'));
 355}
 356
 357TEST(IsValidEscapeTest, IsFalseForSomeLetter) {
 358  EXPECT_FALSE(IsValidEscape('a'));
 359  EXPECT_FALSE(IsValidEscape('Z'));
 360}
 361
 362TEST(IsValidEscapeTest, IsTrueForPunct) {
 363  EXPECT_TRUE(IsValidEscape('.'));
 364  EXPECT_TRUE(IsValidEscape('-'));
 365  EXPECT_TRUE(IsValidEscape('^'));
 366  EXPECT_TRUE(IsValidEscape('$'));
 367  EXPECT_TRUE(IsValidEscape('('));
 368  EXPECT_TRUE(IsValidEscape(']'));
 369  EXPECT_TRUE(IsValidEscape('{'));
 370  EXPECT_TRUE(IsValidEscape('|'));
 371}
 372
 373TEST(IsValidEscapeTest, IsTrueForSomeLetter) {
 374  EXPECT_TRUE(IsValidEscape('d'));
 375  EXPECT_TRUE(IsValidEscape('D'));
 376  EXPECT_TRUE(IsValidEscape('s'));
 377  EXPECT_TRUE(IsValidEscape('S'));
 378  EXPECT_TRUE(IsValidEscape('w'));
 379  EXPECT_TRUE(IsValidEscape('W'));
 380}
 381
 382TEST(AtomMatchesCharTest, EscapedPunct) {
 383  EXPECT_FALSE(AtomMatchesChar(true, '\\', '\0'));
 384  EXPECT_FALSE(AtomMatchesChar(true, '\\', ' '));
 385  EXPECT_FALSE(AtomMatchesChar(true, '_', '.'));
 386  EXPECT_FALSE(AtomMatchesChar(true, '.', 'a'));
 387
 388  EXPECT_TRUE(AtomMatchesChar(true, '\\', '\\'));
 389  EXPECT_TRUE(AtomMatchesChar(true, '_', '_'));
 390  EXPECT_TRUE(AtomMatchesChar(true, '+', '+'));
 391  EXPECT_TRUE(AtomMatchesChar(true, '.', '.'));
 392}
 393
 394TEST(AtomMatchesCharTest, Escaped_d) {
 395  EXPECT_FALSE(AtomMatchesChar(true, 'd', '\0'));
 396  EXPECT_FALSE(AtomMatchesChar(true, 'd', 'a'));
 397  EXPECT_FALSE(AtomMatchesChar(true, 'd', '.'));
 398
 399  EXPECT_TRUE(AtomMatchesChar(true, 'd', '0'));
 400  EXPECT_TRUE(AtomMatchesChar(true, 'd', '9'));
 401}
 402
 403TEST(AtomMatchesCharTest, Escaped_D) {
 404  EXPECT_FALSE(AtomMatchesChar(true, 'D', '0'));
 405  EXPECT_FALSE(AtomMatchesChar(true, 'D', '9'));
 406
 407  EXPECT_TRUE(AtomMatchesChar(true, 'D', '\0'));
 408  EXPECT_TRUE(AtomMatchesChar(true, 'D', 'a'));
 409  EXPECT_TRUE(AtomMatchesChar(true, 'D', '-'));
 410}
 411
 412TEST(AtomMatchesCharTest, Escaped_s) {
 413  EXPECT_FALSE(AtomMatchesChar(true, 's', '\0'));
 414  EXPECT_FALSE(AtomMatchesChar(true, 's', 'a'));
 415  EXPECT_FALSE(AtomMatchesChar(true, 's', '.'));
 416  EXPECT_FALSE(AtomMatchesChar(true, 's', '9'));
 417
 418  EXPECT_TRUE(AtomMatchesChar(true, 's', ' '));
 419  EXPECT_TRUE(AtomMatchesChar(true, 's', '\n'));
 420  EXPECT_TRUE(AtomMatchesChar(true, 's', '\t'));
 421}
 422
 423TEST(AtomMatchesCharTest, Escaped_S) {
 424  EXPECT_FALSE(AtomMatchesChar(true, 'S', ' '));
 425  EXPECT_FALSE(AtomMatchesChar(true, 'S', '\r'));
 426
 427  EXPECT_TRUE(AtomMatchesChar(true, 'S', '\0'));
 428  EXPECT_TRUE(AtomMatchesChar(true, 'S', 'a'));
 429  EXPECT_TRUE(AtomMatchesChar(true, 'S', '9'));
 430}
 431
 432TEST(AtomMatchesCharTest, Escaped_w) {
 433  EXPECT_FALSE(AtomMatchesChar(true, 'w', '\0'));
 434  EXPECT_FALSE(AtomMatchesChar(true, 'w', '+'));
 435  EXPECT_FALSE(AtomMatchesChar(true, 'w', ' '));
 436  EXPECT_FALSE(AtomMatchesChar(true, 'w', '\n'));
 437
 438  EXPECT_TRUE(AtomMatchesChar(true, 'w', '0'));
 439  EXPECT_TRUE(AtomMatchesChar(true, 'w', 'b'));
 440  EXPECT_TRUE(AtomMatchesChar(true, 'w', 'C'));
 441  EXPECT_TRUE(AtomMatchesChar(true, 'w', '_'));
 442}
 443
 444TEST(AtomMatchesCharTest, Escaped_W) {
 445  EXPECT_FALSE(AtomMatchesChar(true, 'W', 'A'));
 446  EXPECT_FALSE(AtomMatchesChar(true, 'W', 'b'));
 447  EXPECT_FALSE(AtomMatchesChar(true, 'W', '9'));
 448  EXPECT_FALSE(AtomMatchesChar(true, 'W', '_'));
 449
 450  EXPECT_TRUE(AtomMatchesChar(true, 'W', '\0'));
 451  EXPECT_TRUE(AtomMatchesChar(true, 'W', '*'));
 452  EXPECT_TRUE(AtomMatchesChar(true, 'W', '\n'));
 453}
 454
 455TEST(AtomMatchesCharTest, EscapedWhiteSpace) {
 456  EXPECT_FALSE(AtomMatchesChar(true, 'f', '\0'));
 457  EXPECT_FALSE(AtomMatchesChar(true, 'f', '\n'));
 458  EXPECT_FALSE(AtomMatchesChar(true, 'n', '\0'));
 459  EXPECT_FALSE(AtomMatchesChar(true, 'n', '\r'));
 460  EXPECT_FALSE(AtomMatchesChar(true, 'r', '\0'));
 461  EXPECT_FALSE(AtomMatchesChar(true, 'r', 'a'));
 462  EXPECT_FALSE(AtomMatchesChar(true, 't', '\0'));
 463  EXPECT_FALSE(AtomMatchesChar(true, 't', 't'));
 464  EXPECT_FALSE(AtomMatchesChar(true, 'v', '\0'));
 465  EXPECT_FALSE(AtomMatchesChar(true, 'v', '\f'));
 466
 467  EXPECT_TRUE(AtomMatchesChar(true, 'f', '\f'));
 468  EXPECT_TRUE(AtomMatchesChar(true, 'n', '\n'));
 469  EXPECT_TRUE(AtomMatchesChar(true, 'r', '\r'));
 470  EXPECT_TRUE(AtomMatchesChar(true, 't', '\t'));
 471  EXPECT_TRUE(AtomMatchesChar(true, 'v', '\v'));
 472}
 473
 474TEST(AtomMatchesCharTest, UnescapedDot) {
 475  EXPECT_FALSE(AtomMatchesChar(false, '.', '\n'));
 476
 477  EXPECT_TRUE(AtomMatchesChar(false, '.', '\0'));
 478  EXPECT_TRUE(AtomMatchesChar(false, '.', '.'));
 479  EXPECT_TRUE(AtomMatchesChar(false, '.', 'a'));
 480  EXPECT_TRUE(AtomMatchesChar(false, '.', ' '));
 481}
 482
 483TEST(AtomMatchesCharTest, UnescapedChar) {
 484  EXPECT_FALSE(AtomMatchesChar(false, 'a', '\0'));
 485  EXPECT_FALSE(AtomMatchesChar(false, 'a', 'b'));
 486  EXPECT_FALSE(AtomMatchesChar(false, '$', 'a'));
 487
 488  EXPECT_TRUE(AtomMatchesChar(false, '$', '$'));
 489  EXPECT_TRUE(AtomMatchesChar(false, '5', '5'));
 490  EXPECT_TRUE(AtomMatchesChar(false, 'Z', 'Z'));
 491}
 492
 493TEST(ValidateRegexTest, GeneratesFailureAndReturnsFalseForInvalid) {
 494  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(NULL)),
 495                          "NULL is not a valid simple regular expression");
 496  EXPECT_NONFATAL_FAILURE(
 497      ASSERT_FALSE(ValidateRegex("a\\")),
 498      "Syntax error at index 1 in simple regular expression \"a\\\": ");
 499  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a\\")),
 500                          "'\\' cannot appear at the end");
 501  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\n\\")),
 502                          "'\\' cannot appear at the end");
 503  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\s\\hb")),
 504                          "invalid escape sequence \"\\h\"");
 505  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^^")),
 506                          "'^' can only appear at the beginning");
 507  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(".*^b")),
 508                          "'^' can only appear at the beginning");
 509  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("$$")),
 510                          "'$' can only appear at the end");
 511  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^$a")),
 512                          "'$' can only appear at the end");
 513  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a(b")),
 514                          "'(' is unsupported");
 515  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("ab)")),
 516                          "')' is unsupported");
 517  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("[ab")),
 518                          "'[' is unsupported");
 519  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a{2")),
 520                          "'{' is unsupported");
 521  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("?")),
 522                          "'?' can only follow a repeatable token");
 523  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^*")),
 524                          "'*' can only follow a repeatable token");
 525  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("5*+")),
 526                          "'+' can only follow a repeatable token");
 527}
 528
 529TEST(ValidateRegexTest, ReturnsTrueForValid) {
 530  EXPECT_TRUE(ValidateRegex(""));
 531  EXPECT_TRUE(ValidateRegex("a"));
 532  EXPECT_TRUE(ValidateRegex(".*"));
 533  EXPECT_TRUE(ValidateRegex("^a_+"));
 534  EXPECT_TRUE(ValidateRegex("^a\\t\\&?"));
 535  EXPECT_TRUE(ValidateRegex("09*$"));
 536  EXPECT_TRUE(ValidateRegex("^Z$"));
 537  EXPECT_TRUE(ValidateRegex("a\\^Z\\$\\(\\)\\|\\[\\]\\{\\}"));
 538}
 539
 540TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrOne) {
 541  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "a", "ba"));
 542  // Repeating more than once.
 543  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "aab"));
 544
 545  // Repeating zero times.
 546  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ba"));
 547  // Repeating once.
 548  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ab"));
 549  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '#', '?', ".", "##"));
 550}
 551
 552TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrMany) {
 553  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '*', "a$", "baab"));
 554
 555  // Repeating zero times.
 556  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "bc"));
 557  // Repeating once.
 558  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "abc"));
 559  // Repeating more than once.
 560  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '*', "-", "ab_1-g"));
 561}
 562
 563TEST(MatchRepetitionAndRegexAtHeadTest, WorksForOneOrMany) {
 564  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "a$", "baab"));
 565  // Repeating zero times.
 566  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "bc"));
 567
 568  // Repeating once.
 569  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "abc"));
 570  // Repeating more than once.
 571  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '+', "-", "ab_1-g"));
 572}
 573
 574TEST(MatchRegexAtHeadTest, ReturnsTrueForEmptyRegex) {
 575  EXPECT_TRUE(MatchRegexAtHead("", ""));
 576  EXPECT_TRUE(MatchRegexAtHead("", "ab"));
 577}
 578
 579TEST(MatchRegexAtHeadTest, WorksWhenDollarIsInRegex) {
 580  EXPECT_FALSE(MatchRegexAtHead("$", "a"));
 581
 582  EXPECT_TRUE(MatchRegexAtHead("$", ""));
 583  EXPECT_TRUE(MatchRegexAtHead("a$", "a"));
 584}
 585
 586TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithEscapeSequence) {
 587  EXPECT_FALSE(MatchRegexAtHead("\\w", "+"));
 588  EXPECT_FALSE(MatchRegexAtHead("\\W", "ab"));
 589
 590  EXPECT_TRUE(MatchRegexAtHead("\\sa", "\nab"));
 591  EXPECT_TRUE(MatchRegexAtHead("\\d", "1a"));
 592}
 593
 594TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithRepetition) {
 595  EXPECT_FALSE(MatchRegexAtHead(".+a", "abc"));
 596  EXPECT_FALSE(MatchRegexAtHead("a?b", "aab"));
 597
 598  EXPECT_TRUE(MatchRegexAtHead(".*a", "bc12-ab"));
 599  EXPECT_TRUE(MatchRegexAtHead("a?b", "b"));
 600  EXPECT_TRUE(MatchRegexAtHead("a?b", "ab"));
 601}
 602
 603TEST(MatchRegexAtHeadTest,
 604     WorksWhenRegexStartsWithRepetionOfEscapeSequence) {
 605  EXPECT_FALSE(MatchRegexAtHead("\\.+a", "abc"));
 606  EXPECT_FALSE(MatchRegexAtHead("\\s?b", "  b"));
 607
 608  EXPECT_TRUE(MatchRegexAtHead("\\(*a", "((((ab"));
 609  EXPECT_TRUE(MatchRegexAtHead("\\^?b", "^b"));
 610  EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "b"));
 611  EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "\\b"));
 612}
 613
 614TEST(MatchRegexAtHeadTest, MatchesSequentially) {
 615  EXPECT_FALSE(MatchRegexAtHead("ab.*c", "acabc"));
 616
 617  EXPECT_TRUE(MatchRegexAtHead("ab.*c", "ab-fsc"));
 618}
 619
 620TEST(MatchRegexAnywhereTest, ReturnsFalseWhenStringIsNull) {
 621  EXPECT_FALSE(MatchRegexAnywhere("", NULL));
 622}
 623
 624TEST(MatchRegexAnywhereTest, WorksWhenRegexStartsWithCaret) {
 625  EXPECT_FALSE(MatchRegexAnywhere("^a", "ba"));
 626  EXPECT_FALSE(MatchRegexAnywhere("^$", "a"));
 627
 628  EXPECT_TRUE(MatchRegexAnywhere("^a", "ab"));
 629  EXPECT_TRUE(MatchRegexAnywhere("^", "ab"));
 630  EXPECT_TRUE(MatchRegexAnywhere("^$", ""));
 631}
 632
 633TEST(MatchRegexAnywhereTest, ReturnsFalseWhenNoMatch) {
 634  EXPECT_FALSE(MatchRegexAnywhere("a", "bcde123"));
 635  EXPECT_FALSE(MatchRegexAnywhere("a.+a", "--aa88888888"));
 636}
 637
 638TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingPrefix) {
 639  EXPECT_TRUE(MatchRegexAnywhere("\\w+", "ab1_ - 5"));
 640  EXPECT_TRUE(MatchRegexAnywhere(".*=", "="));
 641  EXPECT_TRUE(MatchRegexAnywhere("x.*ab?.*bc", "xaaabc"));
 642}
 643
 644TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingNonPrefix) {
 645  EXPECT_TRUE(MatchRegexAnywhere("\\w+", "$$$ ab1_ - 5"));
 646  EXPECT_TRUE(MatchRegexAnywhere("\\.+=", "=  ...="));
 647}
 648
 649// Tests RE's implicit constructors.
 650TEST(RETest, ImplicitConstructorWorks) {
 651  const RE empty("");
 652  EXPECT_STREQ("", empty.pattern());
 653
 654  const RE simple("hello");
 655  EXPECT_STREQ("hello", simple.pattern());
 656}
 657
 658// Tests that RE's constructors reject invalid regular expressions.
 659TEST(RETest, RejectsInvalidRegex) {
 660  EXPECT_NONFATAL_FAILURE({
 661    const RE normal(NULL);
 662  }, "NULL is not a valid simple regular expression");
 663
 664  EXPECT_NONFATAL_FAILURE({
 665    const RE normal(".*(\\w+");
 666  }, "'(' is unsupported");
 667
 668  EXPECT_NONFATAL_FAILURE({
 669    const RE invalid("^?");
 670  }, "'?' can only follow a repeatable token");
 671}
 672
 673// Tests RE::FullMatch().
 674TEST(RETest, FullMatchWorks) {
 675  const RE empty("");
 676  EXPECT_TRUE(RE::FullMatch("", empty));
 677  EXPECT_FALSE(RE::FullMatch("a", empty));
 678
 679  const RE re1("a");
 680  EXPECT_TRUE(RE::FullMatch("a", re1));
 681
 682  const RE re("a.*z");
 683  EXPECT_TRUE(RE::FullMatch("az", re));
 684  EXPECT_TRUE(RE::FullMatch("axyz", re));
 685  EXPECT_FALSE(RE::FullMatch("baz", re));
 686  EXPECT_FALSE(RE::FullMatch("azy", re));
 687}
 688
 689// Tests RE::PartialMatch().
 690TEST(RETest, PartialMatchWorks) {
 691  const RE empty("");
 692  EXPECT_TRUE(RE::PartialMatch("", empty));
 693  EXPECT_TRUE(RE::PartialMatch("a", empty));
 694
 695  const RE re("a.*z");
 696  EXPECT_TRUE(RE::PartialMatch("az", re));
 697  EXPECT_TRUE(RE::PartialMatch("axyz", re));
 698  EXPECT_TRUE(RE::PartialMatch("baz", re));
 699  EXPECT_TRUE(RE::PartialMatch("azy", re));
 700  EXPECT_FALSE(RE::PartialMatch("zza", re));
 701}
 702
 703#endif  // GTEST_USES_POSIX_RE
 704
 705#if !GTEST_OS_WINDOWS_MOBILE
 706
 707TEST(CaptureTest, CapturesStdout) {
 708  CaptureStdout();
 709  fprintf(stdout, "abc");
 710  EXPECT_STREQ("abc", GetCapturedStdout().c_str());
 711
 712  CaptureStdout();
 713  fprintf(stdout, "def%cghi", '\0');
 714  EXPECT_EQ(::std::string("def\0ghi", 7), ::std::string(GetCapturedStdout()));
 715}
 716
 717TEST(CaptureTest, CapturesStderr) {
 718  CaptureStderr();
 719  fprintf(stderr, "jkl");
 720  EXPECT_STREQ("jkl", GetCapturedStderr().c_str());
 721
 722  CaptureStderr();
 723  fprintf(stderr, "jkl%cmno", '\0');
 724  EXPECT_EQ(::std::string("jkl\0mno", 7), ::std::string(GetCapturedStderr()));
 725}
 726
 727// Tests that stdout and stderr capture don't interfere with each other.
 728TEST(CaptureTest, CapturesStdoutAndStderr) {
 729  CaptureStdout();
 730  CaptureStderr();
 731  fprintf(stdout, "pqr");
 732  fprintf(stderr, "stu");
 733  EXPECT_STREQ("pqr", GetCapturedStdout().c_str());
 734  EXPECT_STREQ("stu", GetCapturedStderr().c_str());
 735}
 736
 737TEST(CaptureDeathTest, CannotReenterStdoutCapture) {
 738  CaptureStdout();
 739  EXPECT_DEATH_IF_SUPPORTED(CaptureStdout();,
 740                            "Only one stdout capturer can exist at a time");
 741  GetCapturedStdout();
 742
 743  // We cannot test stderr capturing using death tests as they use it
 744  // themselves.
 745}
 746
 747#endif  // !GTEST_OS_WINDOWS_MOBILE
 748
 749TEST(ThreadLocalTest, DefaultConstructorInitializesToDefaultValues) {
 750  ThreadLocal<int> t1;
 751  EXPECT_EQ(0, t1.get());
 752
 753  ThreadLocal<void*> t2;
 754  EXPECT_TRUE(t2.get() == NULL);
 755}
 756
 757TEST(ThreadLocalTest, SingleParamConstructorInitializesToParam) {
 758  ThreadLocal<int> t1(123);
 759  EXPECT_EQ(123, t1.get());
 760
 761  int i = 0;
 762  ThreadLocal<int*> t2(&i);
 763  EXPECT_EQ(&i, t2.get());
 764}
 765
 766class NoDefaultContructor {
 767 public:
 768  explicit NoDefaultContructor(const char*) {}
 769  NoDefaultContructor(const NoDefaultContructor&) {}
 770};
 771
 772TEST(ThreadLocalTest, ValueDefaultContructorIsNotRequiredForParamVersion) {
 773  ThreadLocal<NoDefaultContructor> bar(NoDefaultContructor("foo"));
 774  bar.pointer();
 775}
 776
 777TEST(ThreadLocalTest, GetAndPointerReturnSameValue) {
 778  ThreadLocal<String> thread_local;
 779
 780  EXPECT_EQ(thread_local.pointer(), &(thread_local.get()));
 781
 782  // Verifies the condition still holds after calling set.
 783  thread_local.set("foo");
 784  EXPECT_EQ(thread_local.pointer(), &(thread_local.get()));
 785}
 786
 787TEST(ThreadLocalTest, PointerAndConstPointerReturnSameValue) {
 788  ThreadLocal<String> thread_local;
 789  const ThreadLocal<String>& const_thread_local = thread_local;
 790
 791  EXPECT_EQ(thread_local.pointer(), const_thread_local.pointer());
 792
 793  thread_local.set("foo");
 794  EXPECT_EQ(thread_local.pointer(), const_thread_local.pointer());
 795}
 796
 797#if GTEST_IS_THREADSAFE
 798
 799void AddTwo(int* param) { *param += 2; }
 800
 801TEST(ThreadWithParamTest, ConstructorExecutesThreadFunc) {
 802  int i = 40;
 803  ThreadWithParam<int*> thread(&AddTwo, &i, NULL);
 804  thread.Join();
 805  EXPECT_EQ(42, i);
 806}
 807
 808TEST(MutexDeathTest, AssertHeldShouldAssertWhenNotLocked) {
 809  // AssertHeld() is flaky only in the presence of multiple threads accessing
 810  // the lock. In this case, the test is robust.
 811  EXPECT_DEATH_IF_SUPPORTED({
 812    Mutex m;
 813    { MutexLock lock(&m); }
 814    m.AssertHeld();
 815  },
 816  "thread .*hold");
 817}
 818
 819TEST(MutexTest, AssertHeldShouldNotAssertWhenLocked) {
 820  Mutex m;
 821  MutexLock lock(&m);
 822  m.AssertHeld();
 823}
 824
 825class AtomicCounterWithMutex {
 826 public:
 827  explicit AtomicCounterWithMutex(Mutex* mutex) :
 828    value_(0), mutex_(mutex), random_(42) {}
 829
 830  void Increment() {
 831    MutexLock lock(mutex_);
 832    int temp = value_;
 833    {
 834      // Locking a mutex puts up a memory barrier, preventing reads and
 835      // writes to value_ rearranged when observed from other threads.
 836      //
 837      // We cannot use Mutex and MutexLock here or rely on their memory
 838      // barrier functionality as we are testing them here.
 839      pthread_mutex_t memory_barrier_mutex;
 840      GTEST_CHECK_POSIX_SUCCESS_(
 841          pthread_mutex_init(&memory_barrier_mutex, NULL));
 842      GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&memory_barrier_mutex));
 843
 844      SleepMilliseconds(random_.Generate(30));
 845
 846      GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&memory_barrier_mutex));
 847    }
 848    value_ = temp + 1;
 849  }
 850  int value() const { return value_; }
 851
 852 private:
 853  volatile int value_;
 854  Mutex* const mutex_;  // Protects value_.
 855  Random       random_;
 856};
 857
 858void CountingThreadFunc(pair<AtomicCounterWithMutex*, int> param) {
 859  for (int i = 0; i < param.second; ++i)
 860      param.first->Increment();
 861}
 862
 863// Tests that the mutex only lets one thread at a time to lock it.
 864TEST(MutexTest, OnlyOneThreadCanLockAtATime) {
 865  Mutex mutex;
 866  AtomicCounterWithMutex locked_counter(&mutex);
 867
 868  typedef ThreadWithParam<pair<AtomicCounterWithMutex*, int> > ThreadType;
 869  const int kCycleCount = 20;
 870  const int kThreadCount = 7;
 871  scoped_ptr<ThreadType> counting_threads[kThreadCount];
 872  Notification threads_can_start;
 873  // Creates and runs kThreadCount threads that increment locked_counter
 874  // kCycleCount times each.
 875  for (int i = 0; i < kThreadCount; ++i) {
 876    counting_threads[i].reset(new ThreadType(&CountingThreadFunc,
 877                                             make_pair(&locked_counter,
 878                                                       kCycleCount),
 879                                             &threads_can_start));
 880  }
 881  threads_can_start.Notify();
 882  for (int i = 0; i < kThreadCount; ++i)
 883    counting_threads[i]->Join();
 884
 885  // If the mutex lets more than one thread to increment the counter at a
 886  // time, they are likely to encounter a race condition and have some
 887  // increments overwritten, resulting in the lower then expected counter
 888  // value.
 889  EXPECT_EQ(kCycleCount * kThreadCount, locked_counter.value());
 890}
 891
 892template <typename T>
 893void RunFromThread(void (func)(T), T param) {
 894  ThreadWithParam<T> thread(func, param, NULL);
 895  thread.Join();
 896}
 897
 898void RetrieveThreadLocalValue(pair<ThreadLocal<String>*, String*> param) {
 899  *param.second = param.first->get();
 900}
 901
 902TEST(ThreadLocalTest, ParameterizedConstructorSetsDefault) {
 903  ThreadLocal<String> thread_local("foo");
 904  EXPECT_STREQ("foo", thread_local.get().c_str());
 905
 906  thread_local.set("bar");
 907  EXPECT_STREQ("bar", thread_local.get().c_str());
 908
 909  String result;
 910  RunFromThread(&RetrieveThreadLocalValue, make_pair(&thread_local, &result));
 911  EXPECT_STREQ("foo", result.c_str());
 912}
 913
 914// DestructorTracker keeps track of whether its instances have been
 915// destroyed.
 916static std::vector<bool> g_destroyed;
 917
 918class DestructorTracker {
 919 public:
 920  DestructorTracker() : index_(GetNewIndex()) {}
 921  DestructorTracker(const DestructorTracker& /* rhs */)
 922      : index_(GetNewIndex()) {}
 923  ~DestructorTracker() {
 924    // We never access g_destroyed concurrently, so we don't need to
 925    // protect the write operation under a mutex.
 926    g_destroyed[index_] = true;
 927  }
 928
 929 private:
 930  static int GetNewIndex() {
 931    g_destroyed.push_back(false);
 932    return g_destroyed.size() - 1;
 933  }
 934  const int index_;
 935};
 936
 937typedef ThreadLocal<DestructorTracker>* ThreadParam;
 938
 939void CallThreadLocalGet(ThreadParam thread_local) {
 940  thread_local->get();
 941}
 942
 943// Tests that when a ThreadLocal object dies in a thread, it destroys
 944// the managed object for that thread.
 945TEST(ThreadLocalTest, DestroysManagedObjectForOwnThreadWhenDying) {
 946  g_destroyed.clear();
 947
 948  {
 949    // The next line default constructs a DestructorTracker object as
 950    // the default value of objects managed by thread_local.
 951    ThreadLocal<DestructorTracker> thread_local;
 952    ASSERT_EQ(1U, g_destroyed.size());
 953    ASSERT_FALSE(g_destroyed[0]);
 954
 955    // This creates another DestructorTracker object for the main thread.
 956    thread_local.get();
 957    ASSERT_EQ(2U, g_destroyed.size());
 958    ASSERT_FALSE(g_destroyed[0]);
 959    ASSERT_FALSE(g_destroyed[1]);
 960  }
 961
 962  // Now thread_local has died.  It should have destroyed both the
 963  // default value shared by all threads and the value for the main
 964  // thread.
 965  ASSERT_EQ(2U, g_destroyed.size());
 966  EXPECT_TRUE(g_destroyed[0]);
 967  EXPECT_TRUE(g_destroyed[1]);
 968
 969  g_destroyed.clear();
 970}
 971
 972// Tests that when a thread exits, the thread-local object for that
 973// thread is destroyed.
 974TEST(ThreadLocalTest, DestroysManagedObjectAtThreadExit) {
 975  g_destroyed.clear();
 976
 977  {
 978    // The next line default constructs a DestructorTracker object as
 979    // the default value of objects managed by thread_local.
 980    ThreadLocal<DestructorTracker> thread_local;
 981    ASSERT_EQ(1U, g_destroyed.size());
 982    ASSERT_FALSE(g_destroyed[0]);
 983
 984    // This creates another DestructorTracker object in the new thread.
 985    ThreadWithParam<ThreadParam> thread(
 986        &CallThreadLocalGet, &thread_local, NULL);
 987    thread.Join();
 988
 989    // Now the new thread has exited.  The per-thread object for it
 990    // should have been destroyed.
 991    ASSERT_EQ(2U, g_destroyed.size());
 992    ASSERT_FALSE(g_destroyed[0]);
 993    ASSERT_TRUE(g_destroyed[1]);
 994  }
 995
 996  // Now thread_local has died.  The default value should have been
 997  // destroyed too.
 998  ASSERT_EQ(2U, g_destroyed.size());
 999  EXPECT_TRUE(g_destroyed[0]);
1000  EXPECT_TRUE(g_destroyed[1]);
1001
1002  g_destroyed.clear();
1003}
1004
1005TEST(ThreadLocalTest, ThreadLocalMutationsAffectOnlyCurrentThread) {
1006  ThreadLocal<String> thread_local;
1007  thread_local.set("Foo");
1008  EXPECT_STREQ("Foo", thread_local.get().c_str());
1009
1010  String result;
1011  RunFromThread(&RetrieveThreadLocalValue, make_pair(&thread_local, &result));
1012  EXPECT_TRUE(result.c_str() == NULL);
1013}
1014
1015#endif  // GTEST_IS_THREADSAFE
1016
1017}  // namespace internal
1018}  // namespace testing