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 <list>
43 #include <utility> // For std::pair and std::make_pair.
44 #include <vector>
45
46 #include "gtest/gtest.h"
47 #include "gtest/gtest-spi.h"
48
49 // Indicates that this translation unit is part of Google Test's
50 // implementation. It must come before gtest-internal-inl.h is
51 // included, or there will be a compiler error. This trick is to
52 // prevent a user from accidentally including gtest-internal-inl.h in
53 // his code.
54 #define GTEST_IMPLEMENTATION_ 1
55 #include "src/gtest-internal-inl.h"
56 #undef GTEST_IMPLEMENTATION_
57
58 using std::make_pair;
59 using std::pair;
60
61 namespace testing {
62 namespace internal {
63
TEST(IsXDigitTest,WorksForNarrowAscii)64 TEST(IsXDigitTest, WorksForNarrowAscii) {
65 EXPECT_TRUE(IsXDigit('0'));
66 EXPECT_TRUE(IsXDigit('9'));
67 EXPECT_TRUE(IsXDigit('A'));
68 EXPECT_TRUE(IsXDigit('F'));
69 EXPECT_TRUE(IsXDigit('a'));
70 EXPECT_TRUE(IsXDigit('f'));
71
72 EXPECT_FALSE(IsXDigit('-'));
73 EXPECT_FALSE(IsXDigit('g'));
74 EXPECT_FALSE(IsXDigit('G'));
75 }
76
TEST(IsXDigitTest,ReturnsFalseForNarrowNonAscii)77 TEST(IsXDigitTest, ReturnsFalseForNarrowNonAscii) {
78 EXPECT_FALSE(IsXDigit('\x80'));
79 EXPECT_FALSE(IsXDigit(static_cast<char>('0' | '\x80')));
80 }
81
TEST(IsXDigitTest,WorksForWideAscii)82 TEST(IsXDigitTest, WorksForWideAscii) {
83 EXPECT_TRUE(IsXDigit(L'0'));
84 EXPECT_TRUE(IsXDigit(L'9'));
85 EXPECT_TRUE(IsXDigit(L'A'));
86 EXPECT_TRUE(IsXDigit(L'F'));
87 EXPECT_TRUE(IsXDigit(L'a'));
88 EXPECT_TRUE(IsXDigit(L'f'));
89
90 EXPECT_FALSE(IsXDigit(L'-'));
91 EXPECT_FALSE(IsXDigit(L'g'));
92 EXPECT_FALSE(IsXDigit(L'G'));
93 }
94
TEST(IsXDigitTest,ReturnsFalseForWideNonAscii)95 TEST(IsXDigitTest, ReturnsFalseForWideNonAscii) {
96 EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(0x80)));
97 EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x80)));
98 EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x100)));
99 }
100
101 class Base {
102 public:
103 // Copy constructor and assignment operator do exactly what we need, so we
104 // use them.
Base()105 Base() : member_(0) {}
Base(int n)106 explicit Base(int n) : member_(n) {}
~Base()107 virtual ~Base() {}
member()108 int member() { return member_; }
109
110 private:
111 int member_;
112 };
113
114 class Derived : public Base {
115 public:
Derived(int n)116 explicit Derived(int n) : Base(n) {}
117 };
118
TEST(ImplicitCastTest,ConvertsPointers)119 TEST(ImplicitCastTest, ConvertsPointers) {
120 Derived derived(0);
121 EXPECT_TRUE(&derived == ::testing::internal::ImplicitCast_<Base*>(&derived));
122 }
123
TEST(ImplicitCastTest,CanUseInheritance)124 TEST(ImplicitCastTest, CanUseInheritance) {
125 Derived derived(1);
126 Base base = ::testing::internal::ImplicitCast_<Base>(derived);
127 EXPECT_EQ(derived.member(), base.member());
128 }
129
130 class Castable {
131 public:
Castable(bool * converted)132 explicit Castable(bool* converted) : converted_(converted) {}
operator Base()133 operator Base() {
134 *converted_ = true;
135 return Base();
136 }
137
138 private:
139 bool* converted_;
140 };
141
TEST(ImplicitCastTest,CanUseNonConstCastOperator)142 TEST(ImplicitCastTest, CanUseNonConstCastOperator) {
143 bool converted = false;
144 Castable castable(&converted);
145 Base base = ::testing::internal::ImplicitCast_<Base>(castable);
146 EXPECT_TRUE(converted);
147 }
148
149 class ConstCastable {
150 public:
ConstCastable(bool * converted)151 explicit ConstCastable(bool* converted) : converted_(converted) {}
operator Base() const152 operator Base() const {
153 *converted_ = true;
154 return Base();
155 }
156
157 private:
158 bool* converted_;
159 };
160
TEST(ImplicitCastTest,CanUseConstCastOperatorOnConstValues)161 TEST(ImplicitCastTest, CanUseConstCastOperatorOnConstValues) {
162 bool converted = false;
163 const ConstCastable const_castable(&converted);
164 Base base = ::testing::internal::ImplicitCast_<Base>(const_castable);
165 EXPECT_TRUE(converted);
166 }
167
168 class ConstAndNonConstCastable {
169 public:
ConstAndNonConstCastable(bool * converted,bool * const_converted)170 ConstAndNonConstCastable(bool* converted, bool* const_converted)
171 : converted_(converted), const_converted_(const_converted) {}
operator Base()172 operator Base() {
173 *converted_ = true;
174 return Base();
175 }
operator Base() const176 operator Base() const {
177 *const_converted_ = true;
178 return Base();
179 }
180
181 private:
182 bool* converted_;
183 bool* const_converted_;
184 };
185
TEST(ImplicitCastTest,CanSelectBetweenConstAndNonConstCasrAppropriately)186 TEST(ImplicitCastTest, CanSelectBetweenConstAndNonConstCasrAppropriately) {
187 bool converted = false;
188 bool const_converted = false;
189 ConstAndNonConstCastable castable(&converted, &const_converted);
190 Base base = ::testing::internal::ImplicitCast_<Base>(castable);
191 EXPECT_TRUE(converted);
192 EXPECT_FALSE(const_converted);
193
194 converted = false;
195 const_converted = false;
196 const ConstAndNonConstCastable const_castable(&converted, &const_converted);
197 base = ::testing::internal::ImplicitCast_<Base>(const_castable);
198 EXPECT_FALSE(converted);
199 EXPECT_TRUE(const_converted);
200 }
201
202 class To {
203 public:
To(bool * converted)204 To(bool* converted) { *converted = true; } // NOLINT
205 };
206
TEST(ImplicitCastTest,CanUseImplicitConstructor)207 TEST(ImplicitCastTest, CanUseImplicitConstructor) {
208 bool converted = false;
209 To to = ::testing::internal::ImplicitCast_<To>(&converted);
210 (void)to;
211 EXPECT_TRUE(converted);
212 }
213
TEST(IteratorTraitsTest,WorksForSTLContainerIterators)214 TEST(IteratorTraitsTest, WorksForSTLContainerIterators) {
215 StaticAssertTypeEq<int,
216 IteratorTraits< ::std::vector<int>::const_iterator>::value_type>();
217 StaticAssertTypeEq<bool,
218 IteratorTraits< ::std::list<bool>::iterator>::value_type>();
219 }
220
TEST(IteratorTraitsTest,WorksForPointerToNonConst)221 TEST(IteratorTraitsTest, WorksForPointerToNonConst) {
222 StaticAssertTypeEq<char, IteratorTraits<char*>::value_type>();
223 StaticAssertTypeEq<const void*, IteratorTraits<const void**>::value_type>();
224 }
225
TEST(IteratorTraitsTest,WorksForPointerToConst)226 TEST(IteratorTraitsTest, WorksForPointerToConst) {
227 StaticAssertTypeEq<char, IteratorTraits<const char*>::value_type>();
228 StaticAssertTypeEq<const void*,
229 IteratorTraits<const void* const*>::value_type>();
230 }
231
232 // Tests that the element_type typedef is available in scoped_ptr and refers
233 // to the parameter type.
TEST(ScopedPtrTest,DefinesElementType)234 TEST(ScopedPtrTest, DefinesElementType) {
235 StaticAssertTypeEq<int, ::testing::internal::scoped_ptr<int>::element_type>();
236 }
237
238 // TODO(vladl@google.com): Implement THE REST of scoped_ptr tests.
239
TEST(GtestCheckSyntaxTest,BehavesLikeASingleStatement)240 TEST(GtestCheckSyntaxTest, BehavesLikeASingleStatement) {
241 if (AlwaysFalse())
242 GTEST_CHECK_(false) << "This should never be executed; "
243 "It's a compilation test only.";
244
245 if (AlwaysTrue())
246 GTEST_CHECK_(true);
247 else
248 ; // NOLINT
249
250 if (AlwaysFalse())
251 ; // NOLINT
252 else
253 GTEST_CHECK_(true) << "";
254 }
255
TEST(GtestCheckSyntaxTest,WorksWithSwitch)256 TEST(GtestCheckSyntaxTest, WorksWithSwitch) {
257 switch (0) {
258 case 1:
259 break;
260 default:
261 GTEST_CHECK_(true);
262 }
263
264 switch (0)
265 case 0:
266 GTEST_CHECK_(true) << "Check failed in switch case";
267 }
268
269 // Verifies behavior of FormatFileLocation.
TEST(FormatFileLocationTest,FormatsFileLocation)270 TEST(FormatFileLocationTest, FormatsFileLocation) {
271 EXPECT_PRED_FORMAT2(IsSubstring, "foo.cc", FormatFileLocation("foo.cc", 42));
272 EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation("foo.cc", 42));
273 }
274
TEST(FormatFileLocationTest,FormatsUnknownFile)275 TEST(FormatFileLocationTest, FormatsUnknownFile) {
276 EXPECT_PRED_FORMAT2(
277 IsSubstring, "unknown file", FormatFileLocation(NULL, 42));
278 EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation(NULL, 42));
279 }
280
TEST(FormatFileLocationTest,FormatsUknownLine)281 TEST(FormatFileLocationTest, FormatsUknownLine) {
282 EXPECT_EQ("foo.cc:", FormatFileLocation("foo.cc", -1));
283 }
284
TEST(FormatFileLocationTest,FormatsUknownFileAndLine)285 TEST(FormatFileLocationTest, FormatsUknownFileAndLine) {
286 EXPECT_EQ("unknown file:", FormatFileLocation(NULL, -1));
287 }
288
289 // Verifies behavior of FormatCompilerIndependentFileLocation.
TEST(FormatCompilerIndependentFileLocationTest,FormatsFileLocation)290 TEST(FormatCompilerIndependentFileLocationTest, FormatsFileLocation) {
291 EXPECT_EQ("foo.cc:42", FormatCompilerIndependentFileLocation("foo.cc", 42));
292 }
293
TEST(FormatCompilerIndependentFileLocationTest,FormatsUknownFile)294 TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFile) {
295 EXPECT_EQ("unknown file:42",
296 FormatCompilerIndependentFileLocation(NULL, 42));
297 }
298
TEST(FormatCompilerIndependentFileLocationTest,FormatsUknownLine)299 TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownLine) {
300 EXPECT_EQ("foo.cc", FormatCompilerIndependentFileLocation("foo.cc", -1));
301 }
302
TEST(FormatCompilerIndependentFileLocationTest,FormatsUknownFileAndLine)303 TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFileAndLine) {
304 EXPECT_EQ("unknown file", FormatCompilerIndependentFileLocation(NULL, -1));
305 }
306
307 #if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_QNX
ThreadFunc(void * data)308 void* ThreadFunc(void* data) {
309 internal::Mutex* mutex = static_cast<internal::Mutex*>(data);
310 mutex->Lock();
311 mutex->Unlock();
312 return NULL;
313 }
314
TEST(GetThreadCountTest,ReturnsCorrectValue)315 TEST(GetThreadCountTest, ReturnsCorrectValue) {
316 const size_t starting_count = GetThreadCount();
317 pthread_t thread_id;
318
319 internal::Mutex mutex;
320 {
321 internal::MutexLock lock(&mutex);
322 pthread_attr_t attr;
323 ASSERT_EQ(0, pthread_attr_init(&attr));
324 ASSERT_EQ(0, pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE));
325
326 const int status = pthread_create(&thread_id, &attr, &ThreadFunc, &mutex);
327 ASSERT_EQ(0, pthread_attr_destroy(&attr));
328 ASSERT_EQ(0, status);
329 EXPECT_EQ(starting_count + 1, GetThreadCount());
330 }
331
332 void* dummy;
333 ASSERT_EQ(0, pthread_join(thread_id, &dummy));
334
335 // The OS may not immediately report the updated thread count after
336 // joining a thread, causing flakiness in this test. To counter that, we
337 // wait for up to .5 seconds for the OS to report the correct value.
338 for (int i = 0; i < 5; ++i) {
339 if (GetThreadCount() == starting_count)
340 break;
341
342 SleepMilliseconds(100);
343 }
344
345 EXPECT_EQ(starting_count, GetThreadCount());
346 }
347 #else
TEST(GetThreadCountTest,ReturnsZeroWhenUnableToCountThreads)348 TEST(GetThreadCountTest, ReturnsZeroWhenUnableToCountThreads) {
349 EXPECT_EQ(0U, GetThreadCount());
350 }
351 #endif // GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_QNX
352
TEST(GtestCheckDeathTest,DiesWithCorrectOutputOnFailure)353 TEST(GtestCheckDeathTest, DiesWithCorrectOutputOnFailure) {
354 const bool a_false_condition = false;
355 const char regex[] =
356 #ifdef _MSC_VER
357 "gtest-port_test\\.cc\\(\\d+\\):"
358 #elif GTEST_USES_POSIX_RE
359 "gtest-port_test\\.cc:[0-9]+"
360 #else
361 "gtest-port_test\\.cc:\\d+"
362 #endif // _MSC_VER
363 ".*a_false_condition.*Extra info.*";
364
365 EXPECT_DEATH_IF_SUPPORTED(GTEST_CHECK_(a_false_condition) << "Extra info",
366 regex);
367 }
368
369 #if GTEST_HAS_DEATH_TEST
370
TEST(GtestCheckDeathTest,LivesSilentlyOnSuccess)371 TEST(GtestCheckDeathTest, LivesSilentlyOnSuccess) {
372 EXPECT_EXIT({
373 GTEST_CHECK_(true) << "Extra info";
374 ::std::cerr << "Success\n";
375 exit(0); },
376 ::testing::ExitedWithCode(0), "Success");
377 }
378
379 #endif // GTEST_HAS_DEATH_TEST
380
381 // Verifies that Google Test choose regular expression engine appropriate to
382 // the platform. The test will produce compiler errors in case of failure.
383 // For simplicity, we only cover the most important platforms here.
TEST(RegexEngineSelectionTest,SelectsCorrectRegexEngine)384 TEST(RegexEngineSelectionTest, SelectsCorrectRegexEngine) {
385 #if !GTEST_USES_PCRE
386 # if GTEST_HAS_POSIX_RE
387
388 EXPECT_TRUE(GTEST_USES_POSIX_RE);
389
390 # else
391
392 EXPECT_TRUE(GTEST_USES_SIMPLE_RE);
393
394 # endif
395 #endif // !GTEST_USES_PCRE
396 }
397
398 #if GTEST_USES_POSIX_RE
399
400 # if GTEST_HAS_TYPED_TEST
401
402 template <typename Str>
403 class RETest : public ::testing::Test {};
404
405 // Defines StringTypes as the list of all string types that class RE
406 // supports.
407 typedef testing::Types<
408 ::std::string,
409 # if GTEST_HAS_GLOBAL_STRING
410 ::string,
411 # endif // GTEST_HAS_GLOBAL_STRING
412 const char*> StringTypes;
413
414 TYPED_TEST_CASE(RETest, StringTypes);
415
416 // Tests RE's implicit constructors.
TYPED_TEST(RETest,ImplicitConstructorWorks)417 TYPED_TEST(RETest, ImplicitConstructorWorks) {
418 const RE empty(TypeParam(""));
419 EXPECT_STREQ("", empty.pattern());
420
421 const RE simple(TypeParam("hello"));
422 EXPECT_STREQ("hello", simple.pattern());
423
424 const RE normal(TypeParam(".*(\\w+)"));
425 EXPECT_STREQ(".*(\\w+)", normal.pattern());
426 }
427
428 // Tests that RE's constructors reject invalid regular expressions.
TYPED_TEST(RETest,RejectsInvalidRegex)429 TYPED_TEST(RETest, RejectsInvalidRegex) {
430 EXPECT_NONFATAL_FAILURE({
431 const RE invalid(TypeParam("?"));
432 }, "\"?\" is not a valid POSIX Extended regular expression.");
433 }
434
435 // Tests RE::FullMatch().
TYPED_TEST(RETest,FullMatchWorks)436 TYPED_TEST(RETest, FullMatchWorks) {
437 const RE empty(TypeParam(""));
438 EXPECT_TRUE(RE::FullMatch(TypeParam(""), empty));
439 EXPECT_FALSE(RE::FullMatch(TypeParam("a"), empty));
440
441 const RE re(TypeParam("a.*z"));
442 EXPECT_TRUE(RE::FullMatch(TypeParam("az"), re));
443 EXPECT_TRUE(RE::FullMatch(TypeParam("axyz"), re));
444 EXPECT_FALSE(RE::FullMatch(TypeParam("baz"), re));
445 EXPECT_FALSE(RE::FullMatch(TypeParam("azy"), re));
446 }
447
448 // Tests RE::PartialMatch().
TYPED_TEST(RETest,PartialMatchWorks)449 TYPED_TEST(RETest, PartialMatchWorks) {
450 const RE empty(TypeParam(""));
451 EXPECT_TRUE(RE::PartialMatch(TypeParam(""), empty));
452 EXPECT_TRUE(RE::PartialMatch(TypeParam("a"), empty));
453
454 const RE re(TypeParam("a.*z"));
455 EXPECT_TRUE(RE::PartialMatch(TypeParam("az"), re));
456 EXPECT_TRUE(RE::PartialMatch(TypeParam("axyz"), re));
457 EXPECT_TRUE(RE::PartialMatch(TypeParam("baz"), re));
458 EXPECT_TRUE(RE::PartialMatch(TypeParam("azy"), re));
459 EXPECT_FALSE(RE::PartialMatch(TypeParam("zza"), re));
460 }
461
462 # endif // GTEST_HAS_TYPED_TEST
463
464 #elif GTEST_USES_SIMPLE_RE
465
TEST(IsInSetTest,NulCharIsNotInAnySet)466 TEST(IsInSetTest, NulCharIsNotInAnySet) {
467 EXPECT_FALSE(IsInSet('\0', ""));
468 EXPECT_FALSE(IsInSet('\0', "\0"));
469 EXPECT_FALSE(IsInSet('\0', "a"));
470 }
471
TEST(IsInSetTest,WorksForNonNulChars)472 TEST(IsInSetTest, WorksForNonNulChars) {
473 EXPECT_FALSE(IsInSet('a', "Ab"));
474 EXPECT_FALSE(IsInSet('c', ""));
475
476 EXPECT_TRUE(IsInSet('b', "bcd"));
477 EXPECT_TRUE(IsInSet('b', "ab"));
478 }
479
TEST(IsAsciiDigitTest,IsFalseForNonDigit)480 TEST(IsAsciiDigitTest, IsFalseForNonDigit) {
481 EXPECT_FALSE(IsAsciiDigit('\0'));
482 EXPECT_FALSE(IsAsciiDigit(' '));
483 EXPECT_FALSE(IsAsciiDigit('+'));
484 EXPECT_FALSE(IsAsciiDigit('-'));
485 EXPECT_FALSE(IsAsciiDigit('.'));
486 EXPECT_FALSE(IsAsciiDigit('a'));
487 }
488
TEST(IsAsciiDigitTest,IsTrueForDigit)489 TEST(IsAsciiDigitTest, IsTrueForDigit) {
490 EXPECT_TRUE(IsAsciiDigit('0'));
491 EXPECT_TRUE(IsAsciiDigit('1'));
492 EXPECT_TRUE(IsAsciiDigit('5'));
493 EXPECT_TRUE(IsAsciiDigit('9'));
494 }
495
TEST(IsAsciiPunctTest,IsFalseForNonPunct)496 TEST(IsAsciiPunctTest, IsFalseForNonPunct) {
497 EXPECT_FALSE(IsAsciiPunct('\0'));
498 EXPECT_FALSE(IsAsciiPunct(' '));
499 EXPECT_FALSE(IsAsciiPunct('\n'));
500 EXPECT_FALSE(IsAsciiPunct('a'));
501 EXPECT_FALSE(IsAsciiPunct('0'));
502 }
503
TEST(IsAsciiPunctTest,IsTrueForPunct)504 TEST(IsAsciiPunctTest, IsTrueForPunct) {
505 for (const char* p = "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~"; *p; p++) {
506 EXPECT_PRED1(IsAsciiPunct, *p);
507 }
508 }
509
TEST(IsRepeatTest,IsFalseForNonRepeatChar)510 TEST(IsRepeatTest, IsFalseForNonRepeatChar) {
511 EXPECT_FALSE(IsRepeat('\0'));
512 EXPECT_FALSE(IsRepeat(' '));
513 EXPECT_FALSE(IsRepeat('a'));
514 EXPECT_FALSE(IsRepeat('1'));
515 EXPECT_FALSE(IsRepeat('-'));
516 }
517
TEST(IsRepeatTest,IsTrueForRepeatChar)518 TEST(IsRepeatTest, IsTrueForRepeatChar) {
519 EXPECT_TRUE(IsRepeat('?'));
520 EXPECT_TRUE(IsRepeat('*'));
521 EXPECT_TRUE(IsRepeat('+'));
522 }
523
TEST(IsAsciiWhiteSpaceTest,IsFalseForNonWhiteSpace)524 TEST(IsAsciiWhiteSpaceTest, IsFalseForNonWhiteSpace) {
525 EXPECT_FALSE(IsAsciiWhiteSpace('\0'));
526 EXPECT_FALSE(IsAsciiWhiteSpace('a'));
527 EXPECT_FALSE(IsAsciiWhiteSpace('1'));
528 EXPECT_FALSE(IsAsciiWhiteSpace('+'));
529 EXPECT_FALSE(IsAsciiWhiteSpace('_'));
530 }
531
TEST(IsAsciiWhiteSpaceTest,IsTrueForWhiteSpace)532 TEST(IsAsciiWhiteSpaceTest, IsTrueForWhiteSpace) {
533 EXPECT_TRUE(IsAsciiWhiteSpace(' '));
534 EXPECT_TRUE(IsAsciiWhiteSpace('\n'));
535 EXPECT_TRUE(IsAsciiWhiteSpace('\r'));
536 EXPECT_TRUE(IsAsciiWhiteSpace('\t'));
537 EXPECT_TRUE(IsAsciiWhiteSpace('\v'));
538 EXPECT_TRUE(IsAsciiWhiteSpace('\f'));
539 }
540
TEST(IsAsciiWordCharTest,IsFalseForNonWordChar)541 TEST(IsAsciiWordCharTest, IsFalseForNonWordChar) {
542 EXPECT_FALSE(IsAsciiWordChar('\0'));
543 EXPECT_FALSE(IsAsciiWordChar('+'));
544 EXPECT_FALSE(IsAsciiWordChar('.'));
545 EXPECT_FALSE(IsAsciiWordChar(' '));
546 EXPECT_FALSE(IsAsciiWordChar('\n'));
547 }
548
TEST(IsAsciiWordCharTest,IsTrueForLetter)549 TEST(IsAsciiWordCharTest, IsTrueForLetter) {
550 EXPECT_TRUE(IsAsciiWordChar('a'));
551 EXPECT_TRUE(IsAsciiWordChar('b'));
552 EXPECT_TRUE(IsAsciiWordChar('A'));
553 EXPECT_TRUE(IsAsciiWordChar('Z'));
554 }
555
TEST(IsAsciiWordCharTest,IsTrueForDigit)556 TEST(IsAsciiWordCharTest, IsTrueForDigit) {
557 EXPECT_TRUE(IsAsciiWordChar('0'));
558 EXPECT_TRUE(IsAsciiWordChar('1'));
559 EXPECT_TRUE(IsAsciiWordChar('7'));
560 EXPECT_TRUE(IsAsciiWordChar('9'));
561 }
562
TEST(IsAsciiWordCharTest,IsTrueForUnderscore)563 TEST(IsAsciiWordCharTest, IsTrueForUnderscore) {
564 EXPECT_TRUE(IsAsciiWordChar('_'));
565 }
566
TEST(IsValidEscapeTest,IsFalseForNonPrintable)567 TEST(IsValidEscapeTest, IsFalseForNonPrintable) {
568 EXPECT_FALSE(IsValidEscape('\0'));
569 EXPECT_FALSE(IsValidEscape('\007'));
570 }
571
TEST(IsValidEscapeTest,IsFalseForDigit)572 TEST(IsValidEscapeTest, IsFalseForDigit) {
573 EXPECT_FALSE(IsValidEscape('0'));
574 EXPECT_FALSE(IsValidEscape('9'));
575 }
576
TEST(IsValidEscapeTest,IsFalseForWhiteSpace)577 TEST(IsValidEscapeTest, IsFalseForWhiteSpace) {
578 EXPECT_FALSE(IsValidEscape(' '));
579 EXPECT_FALSE(IsValidEscape('\n'));
580 }
581
TEST(IsValidEscapeTest,IsFalseForSomeLetter)582 TEST(IsValidEscapeTest, IsFalseForSomeLetter) {
583 EXPECT_FALSE(IsValidEscape('a'));
584 EXPECT_FALSE(IsValidEscape('Z'));
585 }
586
TEST(IsValidEscapeTest,IsTrueForPunct)587 TEST(IsValidEscapeTest, IsTrueForPunct) {
588 EXPECT_TRUE(IsValidEscape('.'));
589 EXPECT_TRUE(IsValidEscape('-'));
590 EXPECT_TRUE(IsValidEscape('^'));
591 EXPECT_TRUE(IsValidEscape('$'));
592 EXPECT_TRUE(IsValidEscape('('));
593 EXPECT_TRUE(IsValidEscape(']'));
594 EXPECT_TRUE(IsValidEscape('{'));
595 EXPECT_TRUE(IsValidEscape('|'));
596 }
597
TEST(IsValidEscapeTest,IsTrueForSomeLetter)598 TEST(IsValidEscapeTest, IsTrueForSomeLetter) {
599 EXPECT_TRUE(IsValidEscape('d'));
600 EXPECT_TRUE(IsValidEscape('D'));
601 EXPECT_TRUE(IsValidEscape('s'));
602 EXPECT_TRUE(IsValidEscape('S'));
603 EXPECT_TRUE(IsValidEscape('w'));
604 EXPECT_TRUE(IsValidEscape('W'));
605 }
606
TEST(AtomMatchesCharTest,EscapedPunct)607 TEST(AtomMatchesCharTest, EscapedPunct) {
608 EXPECT_FALSE(AtomMatchesChar(true, '\\', '\0'));
609 EXPECT_FALSE(AtomMatchesChar(true, '\\', ' '));
610 EXPECT_FALSE(AtomMatchesChar(true, '_', '.'));
611 EXPECT_FALSE(AtomMatchesChar(true, '.', 'a'));
612
613 EXPECT_TRUE(AtomMatchesChar(true, '\\', '\\'));
614 EXPECT_TRUE(AtomMatchesChar(true, '_', '_'));
615 EXPECT_TRUE(AtomMatchesChar(true, '+', '+'));
616 EXPECT_TRUE(AtomMatchesChar(true, '.', '.'));
617 }
618
TEST(AtomMatchesCharTest,Escaped_d)619 TEST(AtomMatchesCharTest, Escaped_d) {
620 EXPECT_FALSE(AtomMatchesChar(true, 'd', '\0'));
621 EXPECT_FALSE(AtomMatchesChar(true, 'd', 'a'));
622 EXPECT_FALSE(AtomMatchesChar(true, 'd', '.'));
623
624 EXPECT_TRUE(AtomMatchesChar(true, 'd', '0'));
625 EXPECT_TRUE(AtomMatchesChar(true, 'd', '9'));
626 }
627
TEST(AtomMatchesCharTest,Escaped_D)628 TEST(AtomMatchesCharTest, Escaped_D) {
629 EXPECT_FALSE(AtomMatchesChar(true, 'D', '0'));
630 EXPECT_FALSE(AtomMatchesChar(true, 'D', '9'));
631
632 EXPECT_TRUE(AtomMatchesChar(true, 'D', '\0'));
633 EXPECT_TRUE(AtomMatchesChar(true, 'D', 'a'));
634 EXPECT_TRUE(AtomMatchesChar(true, 'D', '-'));
635 }
636
TEST(AtomMatchesCharTest,Escaped_s)637 TEST(AtomMatchesCharTest, Escaped_s) {
638 EXPECT_FALSE(AtomMatchesChar(true, 's', '\0'));
639 EXPECT_FALSE(AtomMatchesChar(true, 's', 'a'));
640 EXPECT_FALSE(AtomMatchesChar(true, 's', '.'));
641 EXPECT_FALSE(AtomMatchesChar(true, 's', '9'));
642
643 EXPECT_TRUE(AtomMatchesChar(true, 's', ' '));
644 EXPECT_TRUE(AtomMatchesChar(true, 's', '\n'));
645 EXPECT_TRUE(AtomMatchesChar(true, 's', '\t'));
646 }
647
TEST(AtomMatchesCharTest,Escaped_S)648 TEST(AtomMatchesCharTest, Escaped_S) {
649 EXPECT_FALSE(AtomMatchesChar(true, 'S', ' '));
650 EXPECT_FALSE(AtomMatchesChar(true, 'S', '\r'));
651
652 EXPECT_TRUE(AtomMatchesChar(true, 'S', '\0'));
653 EXPECT_TRUE(AtomMatchesChar(true, 'S', 'a'));
654 EXPECT_TRUE(AtomMatchesChar(true, 'S', '9'));
655 }
656
TEST(AtomMatchesCharTest,Escaped_w)657 TEST(AtomMatchesCharTest, Escaped_w) {
658 EXPECT_FALSE(AtomMatchesChar(true, 'w', '\0'));
659 EXPECT_FALSE(AtomMatchesChar(true, 'w', '+'));
660 EXPECT_FALSE(AtomMatchesChar(true, 'w', ' '));
661 EXPECT_FALSE(AtomMatchesChar(true, 'w', '\n'));
662
663 EXPECT_TRUE(AtomMatchesChar(true, 'w', '0'));
664 EXPECT_TRUE(AtomMatchesChar(true, 'w', 'b'));
665 EXPECT_TRUE(AtomMatchesChar(true, 'w', 'C'));
666 EXPECT_TRUE(AtomMatchesChar(true, 'w', '_'));
667 }
668
TEST(AtomMatchesCharTest,Escaped_W)669 TEST(AtomMatchesCharTest, Escaped_W) {
670 EXPECT_FALSE(AtomMatchesChar(true, 'W', 'A'));
671 EXPECT_FALSE(AtomMatchesChar(true, 'W', 'b'));
672 EXPECT_FALSE(AtomMatchesChar(true, 'W', '9'));
673 EXPECT_FALSE(AtomMatchesChar(true, 'W', '_'));
674
675 EXPECT_TRUE(AtomMatchesChar(true, 'W', '\0'));
676 EXPECT_TRUE(AtomMatchesChar(true, 'W', '*'));
677 EXPECT_TRUE(AtomMatchesChar(true, 'W', '\n'));
678 }
679
TEST(AtomMatchesCharTest,EscapedWhiteSpace)680 TEST(AtomMatchesCharTest, EscapedWhiteSpace) {
681 EXPECT_FALSE(AtomMatchesChar(true, 'f', '\0'));
682 EXPECT_FALSE(AtomMatchesChar(true, 'f', '\n'));
683 EXPECT_FALSE(AtomMatchesChar(true, 'n', '\0'));
684 EXPECT_FALSE(AtomMatchesChar(true, 'n', '\r'));
685 EXPECT_FALSE(AtomMatchesChar(true, 'r', '\0'));
686 EXPECT_FALSE(AtomMatchesChar(true, 'r', 'a'));
687 EXPECT_FALSE(AtomMatchesChar(true, 't', '\0'));
688 EXPECT_FALSE(AtomMatchesChar(true, 't', 't'));
689 EXPECT_FALSE(AtomMatchesChar(true, 'v', '\0'));
690 EXPECT_FALSE(AtomMatchesChar(true, 'v', '\f'));
691
692 EXPECT_TRUE(AtomMatchesChar(true, 'f', '\f'));
693 EXPECT_TRUE(AtomMatchesChar(true, 'n', '\n'));
694 EXPECT_TRUE(AtomMatchesChar(true, 'r', '\r'));
695 EXPECT_TRUE(AtomMatchesChar(true, 't', '\t'));
696 EXPECT_TRUE(AtomMatchesChar(true, 'v', '\v'));
697 }
698
TEST(AtomMatchesCharTest,UnescapedDot)699 TEST(AtomMatchesCharTest, UnescapedDot) {
700 EXPECT_FALSE(AtomMatchesChar(false, '.', '\n'));
701
702 EXPECT_TRUE(AtomMatchesChar(false, '.', '\0'));
703 EXPECT_TRUE(AtomMatchesChar(false, '.', '.'));
704 EXPECT_TRUE(AtomMatchesChar(false, '.', 'a'));
705 EXPECT_TRUE(AtomMatchesChar(false, '.', ' '));
706 }
707
TEST(AtomMatchesCharTest,UnescapedChar)708 TEST(AtomMatchesCharTest, UnescapedChar) {
709 EXPECT_FALSE(AtomMatchesChar(false, 'a', '\0'));
710 EXPECT_FALSE(AtomMatchesChar(false, 'a', 'b'));
711 EXPECT_FALSE(AtomMatchesChar(false, '$', 'a'));
712
713 EXPECT_TRUE(AtomMatchesChar(false, '$', '$'));
714 EXPECT_TRUE(AtomMatchesChar(false, '5', '5'));
715 EXPECT_TRUE(AtomMatchesChar(false, 'Z', 'Z'));
716 }
717
TEST(ValidateRegexTest,GeneratesFailureAndReturnsFalseForInvalid)718 TEST(ValidateRegexTest, GeneratesFailureAndReturnsFalseForInvalid) {
719 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(NULL)),
720 "NULL is not a valid simple regular expression");
721 EXPECT_NONFATAL_FAILURE(
722 ASSERT_FALSE(ValidateRegex("a\\")),
723 "Syntax error at index 1 in simple regular expression \"a\\\": ");
724 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a\\")),
725 "'\\' cannot appear at the end");
726 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\n\\")),
727 "'\\' cannot appear at the end");
728 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\s\\hb")),
729 "invalid escape sequence \"\\h\"");
730 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^^")),
731 "'^' can only appear at the beginning");
732 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(".*^b")),
733 "'^' can only appear at the beginning");
734 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("$$")),
735 "'$' can only appear at the end");
736 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^$a")),
737 "'$' can only appear at the end");
738 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a(b")),
739 "'(' is unsupported");
740 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("ab)")),
741 "')' is unsupported");
742 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("[ab")),
743 "'[' is unsupported");
744 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a{2")),
745 "'{' is unsupported");
746 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("?")),
747 "'?' can only follow a repeatable token");
748 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^*")),
749 "'*' can only follow a repeatable token");
750 EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("5*+")),
751 "'+' can only follow a repeatable token");
752 }
753
TEST(ValidateRegexTest,ReturnsTrueForValid)754 TEST(ValidateRegexTest, ReturnsTrueForValid) {
755 EXPECT_TRUE(ValidateRegex(""));
756 EXPECT_TRUE(ValidateRegex("a"));
757 EXPECT_TRUE(ValidateRegex(".*"));
758 EXPECT_TRUE(ValidateRegex("^a_+"));
759 EXPECT_TRUE(ValidateRegex("^a\\t\\&?"));
760 EXPECT_TRUE(ValidateRegex("09*$"));
761 EXPECT_TRUE(ValidateRegex("^Z$"));
762 EXPECT_TRUE(ValidateRegex("a\\^Z\\$\\(\\)\\|\\[\\]\\{\\}"));
763 }
764
TEST(MatchRepetitionAndRegexAtHeadTest,WorksForZeroOrOne)765 TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrOne) {
766 EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "a", "ba"));
767 // Repeating more than once.
768 EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "aab"));
769
770 // Repeating zero times.
771 EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ba"));
772 // Repeating once.
773 EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ab"));
774 EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '#', '?', ".", "##"));
775 }
776
TEST(MatchRepetitionAndRegexAtHeadTest,WorksForZeroOrMany)777 TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrMany) {
778 EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '*', "a$", "baab"));
779
780 // Repeating zero times.
781 EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "bc"));
782 // Repeating once.
783 EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "abc"));
784 // Repeating more than once.
785 EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '*', "-", "ab_1-g"));
786 }
787
TEST(MatchRepetitionAndRegexAtHeadTest,WorksForOneOrMany)788 TEST(MatchRepetitionAndRegexAtHeadTest, WorksForOneOrMany) {
789 EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "a$", "baab"));
790 // Repeating zero times.
791 EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "bc"));
792
793 // Repeating once.
794 EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "abc"));
795 // Repeating more than once.
796 EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '+', "-", "ab_1-g"));
797 }
798
TEST(MatchRegexAtHeadTest,ReturnsTrueForEmptyRegex)799 TEST(MatchRegexAtHeadTest, ReturnsTrueForEmptyRegex) {
800 EXPECT_TRUE(MatchRegexAtHead("", ""));
801 EXPECT_TRUE(MatchRegexAtHead("", "ab"));
802 }
803
TEST(MatchRegexAtHeadTest,WorksWhenDollarIsInRegex)804 TEST(MatchRegexAtHeadTest, WorksWhenDollarIsInRegex) {
805 EXPECT_FALSE(MatchRegexAtHead("$", "a"));
806
807 EXPECT_TRUE(MatchRegexAtHead("$", ""));
808 EXPECT_TRUE(MatchRegexAtHead("a$", "a"));
809 }
810
TEST(MatchRegexAtHeadTest,WorksWhenRegexStartsWithEscapeSequence)811 TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithEscapeSequence) {
812 EXPECT_FALSE(MatchRegexAtHead("\\w", "+"));
813 EXPECT_FALSE(MatchRegexAtHead("\\W", "ab"));
814
815 EXPECT_TRUE(MatchRegexAtHead("\\sa", "\nab"));
816 EXPECT_TRUE(MatchRegexAtHead("\\d", "1a"));
817 }
818
TEST(MatchRegexAtHeadTest,WorksWhenRegexStartsWithRepetition)819 TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithRepetition) {
820 EXPECT_FALSE(MatchRegexAtHead(".+a", "abc"));
821 EXPECT_FALSE(MatchRegexAtHead("a?b", "aab"));
822
823 EXPECT_TRUE(MatchRegexAtHead(".*a", "bc12-ab"));
824 EXPECT_TRUE(MatchRegexAtHead("a?b", "b"));
825 EXPECT_TRUE(MatchRegexAtHead("a?b", "ab"));
826 }
827
TEST(MatchRegexAtHeadTest,WorksWhenRegexStartsWithRepetionOfEscapeSequence)828 TEST(MatchRegexAtHeadTest,
829 WorksWhenRegexStartsWithRepetionOfEscapeSequence) {
830 EXPECT_FALSE(MatchRegexAtHead("\\.+a", "abc"));
831 EXPECT_FALSE(MatchRegexAtHead("\\s?b", " b"));
832
833 EXPECT_TRUE(MatchRegexAtHead("\\(*a", "((((ab"));
834 EXPECT_TRUE(MatchRegexAtHead("\\^?b", "^b"));
835 EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "b"));
836 EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "\\b"));
837 }
838
TEST(MatchRegexAtHeadTest,MatchesSequentially)839 TEST(MatchRegexAtHeadTest, MatchesSequentially) {
840 EXPECT_FALSE(MatchRegexAtHead("ab.*c", "acabc"));
841
842 EXPECT_TRUE(MatchRegexAtHead("ab.*c", "ab-fsc"));
843 }
844
TEST(MatchRegexAnywhereTest,ReturnsFalseWhenStringIsNull)845 TEST(MatchRegexAnywhereTest, ReturnsFalseWhenStringIsNull) {
846 EXPECT_FALSE(MatchRegexAnywhere("", NULL));
847 }
848
TEST(MatchRegexAnywhereTest,WorksWhenRegexStartsWithCaret)849 TEST(MatchRegexAnywhereTest, WorksWhenRegexStartsWithCaret) {
850 EXPECT_FALSE(MatchRegexAnywhere("^a", "ba"));
851 EXPECT_FALSE(MatchRegexAnywhere("^$", "a"));
852
853 EXPECT_TRUE(MatchRegexAnywhere("^a", "ab"));
854 EXPECT_TRUE(MatchRegexAnywhere("^", "ab"));
855 EXPECT_TRUE(MatchRegexAnywhere("^$", ""));
856 }
857
TEST(MatchRegexAnywhereTest,ReturnsFalseWhenNoMatch)858 TEST(MatchRegexAnywhereTest, ReturnsFalseWhenNoMatch) {
859 EXPECT_FALSE(MatchRegexAnywhere("a", "bcde123"));
860 EXPECT_FALSE(MatchRegexAnywhere("a.+a", "--aa88888888"));
861 }
862
TEST(MatchRegexAnywhereTest,ReturnsTrueWhenMatchingPrefix)863 TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingPrefix) {
864 EXPECT_TRUE(MatchRegexAnywhere("\\w+", "ab1_ - 5"));
865 EXPECT_TRUE(MatchRegexAnywhere(".*=", "="));
866 EXPECT_TRUE(MatchRegexAnywhere("x.*ab?.*bc", "xaaabc"));
867 }
868
TEST(MatchRegexAnywhereTest,ReturnsTrueWhenMatchingNonPrefix)869 TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingNonPrefix) {
870 EXPECT_TRUE(MatchRegexAnywhere("\\w+", "$$$ ab1_ - 5"));
871 EXPECT_TRUE(MatchRegexAnywhere("\\.+=", "= ...="));
872 }
873
874 // Tests RE's implicit constructors.
TEST(RETest,ImplicitConstructorWorks)875 TEST(RETest, ImplicitConstructorWorks) {
876 const RE empty("");
877 EXPECT_STREQ("", empty.pattern());
878
879 const RE simple("hello");
880 EXPECT_STREQ("hello", simple.pattern());
881 }
882
883 // Tests that RE's constructors reject invalid regular expressions.
TEST(RETest,RejectsInvalidRegex)884 TEST(RETest, RejectsInvalidRegex) {
885 EXPECT_NONFATAL_FAILURE({
886 const RE normal(NULL);
887 }, "NULL is not a valid simple regular expression");
888
889 EXPECT_NONFATAL_FAILURE({
890 const RE normal(".*(\\w+");
891 }, "'(' is unsupported");
892
893 EXPECT_NONFATAL_FAILURE({
894 const RE invalid("^?");
895 }, "'?' can only follow a repeatable token");
896 }
897
898 // Tests RE::FullMatch().
TEST(RETest,FullMatchWorks)899 TEST(RETest, FullMatchWorks) {
900 const RE empty("");
901 EXPECT_TRUE(RE::FullMatch("", empty));
902 EXPECT_FALSE(RE::FullMatch("a", empty));
903
904 const RE re1("a");
905 EXPECT_TRUE(RE::FullMatch("a", re1));
906
907 const RE re("a.*z");
908 EXPECT_TRUE(RE::FullMatch("az", re));
909 EXPECT_TRUE(RE::FullMatch("axyz", re));
910 EXPECT_FALSE(RE::FullMatch("baz", re));
911 EXPECT_FALSE(RE::FullMatch("azy", re));
912 }
913
914 // Tests RE::PartialMatch().
TEST(RETest,PartialMatchWorks)915 TEST(RETest, PartialMatchWorks) {
916 const RE empty("");
917 EXPECT_TRUE(RE::PartialMatch("", empty));
918 EXPECT_TRUE(RE::PartialMatch("a", empty));
919
920 const RE re("a.*z");
921 EXPECT_TRUE(RE::PartialMatch("az", re));
922 EXPECT_TRUE(RE::PartialMatch("axyz", re));
923 EXPECT_TRUE(RE::PartialMatch("baz", re));
924 EXPECT_TRUE(RE::PartialMatch("azy", re));
925 EXPECT_FALSE(RE::PartialMatch("zza", re));
926 }
927
928 #endif // GTEST_USES_POSIX_RE
929
930 #if !GTEST_OS_WINDOWS_MOBILE
931
TEST(CaptureTest,CapturesStdout)932 TEST(CaptureTest, CapturesStdout) {
933 CaptureStdout();
934 fprintf(stdout, "abc");
935 EXPECT_STREQ("abc", GetCapturedStdout().c_str());
936
937 CaptureStdout();
938 fprintf(stdout, "def%cghi", '\0');
939 EXPECT_EQ(::std::string("def\0ghi", 7), ::std::string(GetCapturedStdout()));
940 }
941
TEST(CaptureTest,CapturesStderr)942 TEST(CaptureTest, CapturesStderr) {
943 CaptureStderr();
944 fprintf(stderr, "jkl");
945 EXPECT_STREQ("jkl", GetCapturedStderr().c_str());
946
947 CaptureStderr();
948 fprintf(stderr, "jkl%cmno", '\0');
949 EXPECT_EQ(::std::string("jkl\0mno", 7), ::std::string(GetCapturedStderr()));
950 }
951
952 // Tests that stdout and stderr capture don't interfere with each other.
TEST(CaptureTest,CapturesStdoutAndStderr)953 TEST(CaptureTest, CapturesStdoutAndStderr) {
954 CaptureStdout();
955 CaptureStderr();
956 fprintf(stdout, "pqr");
957 fprintf(stderr, "stu");
958 EXPECT_STREQ("pqr", GetCapturedStdout().c_str());
959 EXPECT_STREQ("stu", GetCapturedStderr().c_str());
960 }
961
TEST(CaptureDeathTest,CannotReenterStdoutCapture)962 TEST(CaptureDeathTest, CannotReenterStdoutCapture) {
963 CaptureStdout();
964 EXPECT_DEATH_IF_SUPPORTED(CaptureStdout(),
965 "Only one stdout capturer can exist at a time");
966 GetCapturedStdout();
967
968 // We cannot test stderr capturing using death tests as they use it
969 // themselves.
970 }
971
972 #endif // !GTEST_OS_WINDOWS_MOBILE
973
TEST(ThreadLocalTest,DefaultConstructorInitializesToDefaultValues)974 TEST(ThreadLocalTest, DefaultConstructorInitializesToDefaultValues) {
975 ThreadLocal<int> t1;
976 EXPECT_EQ(0, t1.get());
977
978 ThreadLocal<void*> t2;
979 EXPECT_TRUE(t2.get() == NULL);
980 }
981
TEST(ThreadLocalTest,SingleParamConstructorInitializesToParam)982 TEST(ThreadLocalTest, SingleParamConstructorInitializesToParam) {
983 ThreadLocal<int> t1(123);
984 EXPECT_EQ(123, t1.get());
985
986 int i = 0;
987 ThreadLocal<int*> t2(&i);
988 EXPECT_EQ(&i, t2.get());
989 }
990
991 class NoDefaultContructor {
992 public:
NoDefaultContructor(const char *)993 explicit NoDefaultContructor(const char*) {}
NoDefaultContructor(const NoDefaultContructor &)994 NoDefaultContructor(const NoDefaultContructor&) {}
995 };
996
TEST(ThreadLocalTest,ValueDefaultContructorIsNotRequiredForParamVersion)997 TEST(ThreadLocalTest, ValueDefaultContructorIsNotRequiredForParamVersion) {
998 ThreadLocal<NoDefaultContructor> bar(NoDefaultContructor("foo"));
999 bar.pointer();
1000 }
1001
TEST(ThreadLocalTest,GetAndPointerReturnSameValue)1002 TEST(ThreadLocalTest, GetAndPointerReturnSameValue) {
1003 ThreadLocal<std::string> thread_local_string;
1004
1005 EXPECT_EQ(thread_local_string.pointer(), &(thread_local_string.get()));
1006
1007 // Verifies the condition still holds after calling set.
1008 thread_local_string.set("foo");
1009 EXPECT_EQ(thread_local_string.pointer(), &(thread_local_string.get()));
1010 }
1011
TEST(ThreadLocalTest,PointerAndConstPointerReturnSameValue)1012 TEST(ThreadLocalTest, PointerAndConstPointerReturnSameValue) {
1013 ThreadLocal<std::string> thread_local_string;
1014 const ThreadLocal<std::string>& const_thread_local_string =
1015 thread_local_string;
1016
1017 EXPECT_EQ(thread_local_string.pointer(), const_thread_local_string.pointer());
1018
1019 thread_local_string.set("foo");
1020 EXPECT_EQ(thread_local_string.pointer(), const_thread_local_string.pointer());
1021 }
1022
1023 #if GTEST_IS_THREADSAFE
1024
AddTwo(int * param)1025 void AddTwo(int* param) { *param += 2; }
1026
TEST(ThreadWithParamTest,ConstructorExecutesThreadFunc)1027 TEST(ThreadWithParamTest, ConstructorExecutesThreadFunc) {
1028 int i = 40;
1029 ThreadWithParam<int*> thread(&AddTwo, &i, NULL);
1030 thread.Join();
1031 EXPECT_EQ(42, i);
1032 }
1033
TEST(MutexDeathTest,AssertHeldShouldAssertWhenNotLocked)1034 TEST(MutexDeathTest, AssertHeldShouldAssertWhenNotLocked) {
1035 // AssertHeld() is flaky only in the presence of multiple threads accessing
1036 // the lock. In this case, the test is robust.
1037 EXPECT_DEATH_IF_SUPPORTED({
1038 Mutex m;
1039 { MutexLock lock(&m); }
1040 m.AssertHeld();
1041 },
1042 "thread .*hold");
1043 }
1044
TEST(MutexTest,AssertHeldShouldNotAssertWhenLocked)1045 TEST(MutexTest, AssertHeldShouldNotAssertWhenLocked) {
1046 Mutex m;
1047 MutexLock lock(&m);
1048 m.AssertHeld();
1049 }
1050
1051 class AtomicCounterWithMutex {
1052 public:
AtomicCounterWithMutex(Mutex * mutex)1053 explicit AtomicCounterWithMutex(Mutex* mutex) :
1054 value_(0), mutex_(mutex), random_(42) {}
1055
Increment()1056 void Increment() {
1057 MutexLock lock(mutex_);
1058 int temp = value_;
1059 {
1060 // We need to put up a memory barrier to prevent reads and writes to
1061 // value_ rearranged with the call to SleepMilliseconds when observed
1062 // from other threads.
1063 #if GTEST_HAS_PTHREAD
1064 // On POSIX, locking a mutex puts up a memory barrier. We cannot use
1065 // Mutex and MutexLock here or rely on their memory barrier
1066 // functionality as we are testing them here.
1067 pthread_mutex_t memory_barrier_mutex;
1068 GTEST_CHECK_POSIX_SUCCESS_(
1069 pthread_mutex_init(&memory_barrier_mutex, NULL));
1070 GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&memory_barrier_mutex));
1071
1072 SleepMilliseconds(random_.Generate(30));
1073
1074 GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&memory_barrier_mutex));
1075 GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&memory_barrier_mutex));
1076 #elif GTEST_OS_WINDOWS
1077 // On Windows, performing an interlocked access puts up a memory barrier.
1078 volatile LONG dummy = 0;
1079 ::InterlockedIncrement(&dummy);
1080 SleepMilliseconds(random_.Generate(30));
1081 ::InterlockedIncrement(&dummy);
1082 #else
1083 # error "Memory barrier not implemented on this platform."
1084 #endif // GTEST_HAS_PTHREAD
1085 }
1086 value_ = temp + 1;
1087 }
value() const1088 int value() const { return value_; }
1089
1090 private:
1091 volatile int value_;
1092 Mutex* const mutex_; // Protects value_.
1093 Random random_;
1094 };
1095
CountingThreadFunc(pair<AtomicCounterWithMutex *,int> param)1096 void CountingThreadFunc(pair<AtomicCounterWithMutex*, int> param) {
1097 for (int i = 0; i < param.second; ++i)
1098 param.first->Increment();
1099 }
1100
1101 // Tests that the mutex only lets one thread at a time to lock it.
TEST(MutexTest,OnlyOneThreadCanLockAtATime)1102 TEST(MutexTest, OnlyOneThreadCanLockAtATime) {
1103 Mutex mutex;
1104 AtomicCounterWithMutex locked_counter(&mutex);
1105
1106 typedef ThreadWithParam<pair<AtomicCounterWithMutex*, int> > ThreadType;
1107 const int kCycleCount = 20;
1108 const int kThreadCount = 7;
1109 scoped_ptr<ThreadType> counting_threads[kThreadCount];
1110 Notification threads_can_start;
1111 // Creates and runs kThreadCount threads that increment locked_counter
1112 // kCycleCount times each.
1113 for (int i = 0; i < kThreadCount; ++i) {
1114 counting_threads[i].reset(new ThreadType(&CountingThreadFunc,
1115 make_pair(&locked_counter,
1116 kCycleCount),
1117 &threads_can_start));
1118 }
1119 threads_can_start.Notify();
1120 for (int i = 0; i < kThreadCount; ++i)
1121 counting_threads[i]->Join();
1122
1123 // If the mutex lets more than one thread to increment the counter at a
1124 // time, they are likely to encounter a race condition and have some
1125 // increments overwritten, resulting in the lower then expected counter
1126 // value.
1127 EXPECT_EQ(kCycleCount * kThreadCount, locked_counter.value());
1128 }
1129
1130 template <typename T>
RunFromThread(void (func)(T),T param)1131 void RunFromThread(void (func)(T), T param) {
1132 ThreadWithParam<T> thread(func, param, NULL);
1133 thread.Join();
1134 }
1135
RetrieveThreadLocalValue(pair<ThreadLocal<std::string> *,std::string * > param)1136 void RetrieveThreadLocalValue(
1137 pair<ThreadLocal<std::string>*, std::string*> param) {
1138 *param.second = param.first->get();
1139 }
1140
TEST(ThreadLocalTest,ParameterizedConstructorSetsDefault)1141 TEST(ThreadLocalTest, ParameterizedConstructorSetsDefault) {
1142 ThreadLocal<std::string> thread_local_string("foo");
1143 EXPECT_STREQ("foo", thread_local_string.get().c_str());
1144
1145 thread_local_string.set("bar");
1146 EXPECT_STREQ("bar", thread_local_string.get().c_str());
1147
1148 std::string result;
1149 RunFromThread(&RetrieveThreadLocalValue,
1150 make_pair(&thread_local_string, &result));
1151 EXPECT_STREQ("foo", result.c_str());
1152 }
1153
1154 // Keeps track of whether of destructors being called on instances of
1155 // DestructorTracker. On Windows, waits for the destructor call reports.
1156 class DestructorCall {
1157 public:
DestructorCall()1158 DestructorCall() {
1159 invoked_ = false;
1160 #if GTEST_OS_WINDOWS
1161 wait_event_.Reset(::CreateEvent(NULL, TRUE, FALSE, NULL));
1162 GTEST_CHECK_(wait_event_.Get() != NULL);
1163 #endif
1164 }
1165
CheckDestroyed() const1166 bool CheckDestroyed() const {
1167 #if GTEST_OS_WINDOWS
1168 if (::WaitForSingleObject(wait_event_.Get(), 1000) != WAIT_OBJECT_0)
1169 return false;
1170 #endif
1171 return invoked_;
1172 }
1173
ReportDestroyed()1174 void ReportDestroyed() {
1175 invoked_ = true;
1176 #if GTEST_OS_WINDOWS
1177 ::SetEvent(wait_event_.Get());
1178 #endif
1179 }
1180
List()1181 static std::vector<DestructorCall*>& List() { return *list_; }
1182
ResetList()1183 static void ResetList() {
1184 for (size_t i = 0; i < list_->size(); ++i) {
1185 delete list_->at(i);
1186 }
1187 list_->clear();
1188 }
1189
1190 private:
1191 bool invoked_;
1192 #if GTEST_OS_WINDOWS
1193 AutoHandle wait_event_;
1194 #endif
1195 static std::vector<DestructorCall*>* const list_;
1196
1197 GTEST_DISALLOW_COPY_AND_ASSIGN_(DestructorCall);
1198 };
1199
1200 std::vector<DestructorCall*>* const DestructorCall::list_ =
1201 new std::vector<DestructorCall*>;
1202
1203 // DestructorTracker keeps track of whether its instances have been
1204 // destroyed.
1205 class DestructorTracker {
1206 public:
DestructorTracker()1207 DestructorTracker() : index_(GetNewIndex()) {}
DestructorTracker(const DestructorTracker &)1208 DestructorTracker(const DestructorTracker& /* rhs */)
1209 : index_(GetNewIndex()) {}
~DestructorTracker()1210 ~DestructorTracker() {
1211 // We never access DestructorCall::List() concurrently, so we don't need
1212 // to protect this acccess with a mutex.
1213 DestructorCall::List()[index_]->ReportDestroyed();
1214 }
1215
1216 private:
GetNewIndex()1217 static size_t GetNewIndex() {
1218 DestructorCall::List().push_back(new DestructorCall);
1219 return DestructorCall::List().size() - 1;
1220 }
1221 const size_t index_;
1222
1223 GTEST_DISALLOW_ASSIGN_(DestructorTracker);
1224 };
1225
1226 typedef ThreadLocal<DestructorTracker>* ThreadParam;
1227
CallThreadLocalGet(ThreadParam thread_local_param)1228 void CallThreadLocalGet(ThreadParam thread_local_param) {
1229 thread_local_param->get();
1230 }
1231
1232 // Tests that when a ThreadLocal object dies in a thread, it destroys
1233 // the managed object for that thread.
TEST(ThreadLocalTest,DestroysManagedObjectForOwnThreadWhenDying)1234 TEST(ThreadLocalTest, DestroysManagedObjectForOwnThreadWhenDying) {
1235 DestructorCall::ResetList();
1236
1237 {
1238 ThreadLocal<DestructorTracker> thread_local_tracker;
1239 ASSERT_EQ(0U, DestructorCall::List().size());
1240
1241 // This creates another DestructorTracker object for the main thread.
1242 thread_local_tracker.get();
1243 ASSERT_EQ(1U, DestructorCall::List().size());
1244 ASSERT_FALSE(DestructorCall::List()[0]->CheckDestroyed());
1245 }
1246
1247 // Now thread_local_tracker has died.
1248 ASSERT_EQ(1U, DestructorCall::List().size());
1249 EXPECT_TRUE(DestructorCall::List()[0]->CheckDestroyed());
1250
1251 DestructorCall::ResetList();
1252 }
1253
1254 // Tests that when a thread exits, the thread-local object for that
1255 // thread is destroyed.
TEST(ThreadLocalTest,DestroysManagedObjectAtThreadExit)1256 TEST(ThreadLocalTest, DestroysManagedObjectAtThreadExit) {
1257 DestructorCall::ResetList();
1258
1259 {
1260 ThreadLocal<DestructorTracker> thread_local_tracker;
1261 ASSERT_EQ(0U, DestructorCall::List().size());
1262
1263 // This creates another DestructorTracker object in the new thread.
1264 ThreadWithParam<ThreadParam> thread(
1265 &CallThreadLocalGet, &thread_local_tracker, NULL);
1266 thread.Join();
1267
1268 // The thread has exited, and we should have a DestroyedTracker
1269 // instance created for it. But it may not have been destroyed yet.
1270 ASSERT_EQ(1U, DestructorCall::List().size());
1271 }
1272
1273 // The thread has exited and thread_local_tracker has died.
1274 ASSERT_EQ(1U, DestructorCall::List().size());
1275 EXPECT_TRUE(DestructorCall::List()[0]->CheckDestroyed());
1276
1277 DestructorCall::ResetList();
1278 }
1279
TEST(ThreadLocalTest,ThreadLocalMutationsAffectOnlyCurrentThread)1280 TEST(ThreadLocalTest, ThreadLocalMutationsAffectOnlyCurrentThread) {
1281 ThreadLocal<std::string> thread_local_string;
1282 thread_local_string.set("Foo");
1283 EXPECT_STREQ("Foo", thread_local_string.get().c_str());
1284
1285 std::string result;
1286 RunFromThread(&RetrieveThreadLocalValue,
1287 make_pair(&thread_local_string, &result));
1288 EXPECT_TRUE(result.empty());
1289 }
1290
1291 #endif // GTEST_IS_THREADSAFE
1292
1293 #if GTEST_OS_WINDOWS
TEST(WindowsTypesTest,HANDLEIsVoidStar)1294 TEST(WindowsTypesTest, HANDLEIsVoidStar) {
1295 StaticAssertTypeEq<HANDLE, void*>();
1296 }
1297
TEST(WindowsTypesTest,CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION)1298 TEST(WindowsTypesTest, CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION) {
1299 StaticAssertTypeEq<CRITICAL_SECTION, _RTL_CRITICAL_SECTION>();
1300 }
1301 #endif // GTEST_OS_WINDOWS
1302
1303 } // namespace internal
1304 } // namespace testing
1305