PageRenderTime 109ms CodeModel.GetById 16ms app.highlight 84ms RepoModel.GetById 1ms app.codeStats 1ms

/Unittests/googletest/test/gtest-port_test.cc

http://unladen-swallow.googlecode.com/
C++ | 699 lines | 574 code | 77 blank | 48 comment | 8 complexity | ace832568da81d4b480471bb087d64b5 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#if GTEST_OS_MAC
 37#include <pthread.h>
 38#include <time.h>
 39#endif  // GTEST_OS_MAC
 40
 41#include <gtest/gtest.h>
 42#include <gtest/gtest-spi.h>
 43
 44// Indicates that this translation unit is part of Google Test's
 45// implementation.  It must come before gtest-internal-inl.h is
 46// included, or there will be a compiler error.  This trick is to
 47// prevent a user from accidentally including gtest-internal-inl.h in
 48// his code.
 49#define GTEST_IMPLEMENTATION_ 1
 50#include "src/gtest-internal-inl.h"
 51#undef GTEST_IMPLEMENTATION_
 52
 53namespace testing {
 54namespace internal {
 55
 56TEST(GtestCheckSyntaxTest, BehavesLikeASingleStatement) {
 57  if (AlwaysFalse())
 58    GTEST_CHECK_(false) << "This should never be executed; "
 59                           "It's a compilation test only.";
 60
 61  if (AlwaysTrue())
 62    GTEST_CHECK_(true);
 63  else
 64    ;  // NOLINT
 65
 66  if (AlwaysFalse())
 67    ;  // NOLINT
 68  else
 69    GTEST_CHECK_(true) << "";
 70}
 71
 72TEST(GtestCheckSyntaxTest, WorksWithSwitch) {
 73  switch (0) {
 74    case 1:
 75      break;
 76    default:
 77      GTEST_CHECK_(true);
 78  }
 79
 80  switch(0)
 81    case 0:
 82      GTEST_CHECK_(true) << "Check failed in switch case";
 83}
 84
 85#if GTEST_OS_MAC
 86void* ThreadFunc(void* data) {
 87  pthread_mutex_t* mutex = reinterpret_cast<pthread_mutex_t*>(data);
 88  pthread_mutex_lock(mutex);
 89  pthread_mutex_unlock(mutex);
 90  return NULL;
 91}
 92
 93TEST(GetThreadCountTest, ReturnsCorrectValue) {
 94  EXPECT_EQ(1U, GetThreadCount());
 95  pthread_mutex_t mutex;
 96  pthread_attr_t  attr;
 97  pthread_t       thread_id;
 98
 99  // TODO(vladl@google.com): turn mutex into internal::Mutex for automatic
100  // destruction.
101  pthread_mutex_init(&mutex, NULL);
102  pthread_mutex_lock(&mutex);
103  ASSERT_EQ(0, pthread_attr_init(&attr));
104  ASSERT_EQ(0, pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE));
105
106  const int status = pthread_create(&thread_id, &attr, &ThreadFunc, &mutex);
107  ASSERT_EQ(0, pthread_attr_destroy(&attr));
108  ASSERT_EQ(0, status);
109  EXPECT_EQ(2U, GetThreadCount());
110  pthread_mutex_unlock(&mutex);
111
112  void* dummy;
113  ASSERT_EQ(0, pthread_join(thread_id, &dummy));
114
115  // MacOS X may not immediately report the updated thread count after
116  // joining a thread, causing flakiness in this test. To counter that, we
117  // wait for up to .5 seconds for the OS to report the correct value.
118  for (int i = 0; i < 5; ++i) {
119    if (GetThreadCount() == 1)
120      break;
121
122    timespec time;
123    time.tv_sec = 0;
124    time.tv_nsec = 100L * 1000 * 1000;  // .1 seconds.
125    nanosleep(&time, NULL);
126  }
127  EXPECT_EQ(1U, GetThreadCount());
128  pthread_mutex_destroy(&mutex);
129}
130#else
131TEST(GetThreadCountTest, ReturnsZeroWhenUnableToCountThreads) {
132  EXPECT_EQ(0U, GetThreadCount());
133}
134#endif  // GTEST_OS_MAC
135
136TEST(GtestCheckDeathTest, DiesWithCorrectOutputOnFailure) {
137  const bool a_false_condition = false;
138  const char regex[] =
139#ifdef _MSC_VER
140     "gtest-port_test\\.cc\\(\\d+\\):"
141#else
142     "gtest-port_test\\.cc:[0-9]+"
143#endif  // _MSC_VER
144     ".*a_false_condition.*Extra info.*";
145
146  EXPECT_DEATH_IF_SUPPORTED(GTEST_CHECK_(a_false_condition) << "Extra info",
147                            regex);
148}
149
150#if GTEST_HAS_DEATH_TEST
151
152TEST(GtestCheckDeathTest, LivesSilentlyOnSuccess) {
153  EXPECT_EXIT({
154      GTEST_CHECK_(true) << "Extra info";
155      ::std::cerr << "Success\n";
156      exit(0); },
157      ::testing::ExitedWithCode(0), "Success");
158}
159
160#endif  // GTEST_HAS_DEATH_TEST
161
162#if GTEST_USES_POSIX_RE
163
164template <typename Str>
165class RETest : public ::testing::Test {};
166
167// Defines StringTypes as the list of all string types that class RE
168// supports.
169typedef testing::Types<
170#if GTEST_HAS_STD_STRING
171    ::std::string,
172#endif  // GTEST_HAS_STD_STRING
173#if GTEST_HAS_GLOBAL_STRING
174    ::string,
175#endif  // GTEST_HAS_GLOBAL_STRING
176    const char*> StringTypes;
177
178TYPED_TEST_CASE(RETest, StringTypes);
179
180// Tests RE's implicit constructors.
181TYPED_TEST(RETest, ImplicitConstructorWorks) {
182  const RE empty(TypeParam(""));
183  EXPECT_STREQ("", empty.pattern());
184
185  const RE simple(TypeParam("hello"));
186  EXPECT_STREQ("hello", simple.pattern());
187
188  const RE normal(TypeParam(".*(\\w+)"));
189  EXPECT_STREQ(".*(\\w+)", normal.pattern());
190}
191
192// Tests that RE's constructors reject invalid regular expressions.
193TYPED_TEST(RETest, RejectsInvalidRegex) {
194  EXPECT_NONFATAL_FAILURE({
195    const RE invalid(TypeParam("?"));
196  }, "\"?\" is not a valid POSIX Extended regular expression.");
197}
198
199// Tests RE::FullMatch().
200TYPED_TEST(RETest, FullMatchWorks) {
201  const RE empty(TypeParam(""));
202  EXPECT_TRUE(RE::FullMatch(TypeParam(""), empty));
203  EXPECT_FALSE(RE::FullMatch(TypeParam("a"), empty));
204
205  const RE re(TypeParam("a.*z"));
206  EXPECT_TRUE(RE::FullMatch(TypeParam("az"), re));
207  EXPECT_TRUE(RE::FullMatch(TypeParam("axyz"), re));
208  EXPECT_FALSE(RE::FullMatch(TypeParam("baz"), re));
209  EXPECT_FALSE(RE::FullMatch(TypeParam("azy"), re));
210}
211
212// Tests RE::PartialMatch().
213TYPED_TEST(RETest, PartialMatchWorks) {
214  const RE empty(TypeParam(""));
215  EXPECT_TRUE(RE::PartialMatch(TypeParam(""), empty));
216  EXPECT_TRUE(RE::PartialMatch(TypeParam("a"), empty));
217
218  const RE re(TypeParam("a.*z"));
219  EXPECT_TRUE(RE::PartialMatch(TypeParam("az"), re));
220  EXPECT_TRUE(RE::PartialMatch(TypeParam("axyz"), re));
221  EXPECT_TRUE(RE::PartialMatch(TypeParam("baz"), re));
222  EXPECT_TRUE(RE::PartialMatch(TypeParam("azy"), re));
223  EXPECT_FALSE(RE::PartialMatch(TypeParam("zza"), re));
224}
225
226#elif GTEST_USES_SIMPLE_RE
227
228TEST(IsInSetTest, NulCharIsNotInAnySet) {
229  EXPECT_FALSE(IsInSet('\0', ""));
230  EXPECT_FALSE(IsInSet('\0', "\0"));
231  EXPECT_FALSE(IsInSet('\0', "a"));
232}
233
234TEST(IsInSetTest, WorksForNonNulChars) {
235  EXPECT_FALSE(IsInSet('a', "Ab"));
236  EXPECT_FALSE(IsInSet('c', ""));
237
238  EXPECT_TRUE(IsInSet('b', "bcd"));
239  EXPECT_TRUE(IsInSet('b', "ab"));
240}
241
242TEST(IsDigitTest, IsFalseForNonDigit) {
243  EXPECT_FALSE(IsDigit('\0'));
244  EXPECT_FALSE(IsDigit(' '));
245  EXPECT_FALSE(IsDigit('+'));
246  EXPECT_FALSE(IsDigit('-'));
247  EXPECT_FALSE(IsDigit('.'));
248  EXPECT_FALSE(IsDigit('a'));
249}
250
251TEST(IsDigitTest, IsTrueForDigit) {
252  EXPECT_TRUE(IsDigit('0'));
253  EXPECT_TRUE(IsDigit('1'));
254  EXPECT_TRUE(IsDigit('5'));
255  EXPECT_TRUE(IsDigit('9'));
256}
257
258TEST(IsPunctTest, IsFalseForNonPunct) {
259  EXPECT_FALSE(IsPunct('\0'));
260  EXPECT_FALSE(IsPunct(' '));
261  EXPECT_FALSE(IsPunct('\n'));
262  EXPECT_FALSE(IsPunct('a'));
263  EXPECT_FALSE(IsPunct('0'));
264}
265
266TEST(IsPunctTest, IsTrueForPunct) {
267  for (const char* p = "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~"; *p; p++) {
268    EXPECT_PRED1(IsPunct, *p);
269  }
270}
271
272TEST(IsRepeatTest, IsFalseForNonRepeatChar) {
273  EXPECT_FALSE(IsRepeat('\0'));
274  EXPECT_FALSE(IsRepeat(' '));
275  EXPECT_FALSE(IsRepeat('a'));
276  EXPECT_FALSE(IsRepeat('1'));
277  EXPECT_FALSE(IsRepeat('-'));
278}
279
280TEST(IsRepeatTest, IsTrueForRepeatChar) {
281  EXPECT_TRUE(IsRepeat('?'));
282  EXPECT_TRUE(IsRepeat('*'));
283  EXPECT_TRUE(IsRepeat('+'));
284}
285
286TEST(IsWhiteSpaceTest, IsFalseForNonWhiteSpace) {
287  EXPECT_FALSE(IsWhiteSpace('\0'));
288  EXPECT_FALSE(IsWhiteSpace('a'));
289  EXPECT_FALSE(IsWhiteSpace('1'));
290  EXPECT_FALSE(IsWhiteSpace('+'));
291  EXPECT_FALSE(IsWhiteSpace('_'));
292}
293
294TEST(IsWhiteSpaceTest, IsTrueForWhiteSpace) {
295  EXPECT_TRUE(IsWhiteSpace(' '));
296  EXPECT_TRUE(IsWhiteSpace('\n'));
297  EXPECT_TRUE(IsWhiteSpace('\r'));
298  EXPECT_TRUE(IsWhiteSpace('\t'));
299  EXPECT_TRUE(IsWhiteSpace('\v'));
300  EXPECT_TRUE(IsWhiteSpace('\f'));
301}
302
303TEST(IsWordCharTest, IsFalseForNonWordChar) {
304  EXPECT_FALSE(IsWordChar('\0'));
305  EXPECT_FALSE(IsWordChar('+'));
306  EXPECT_FALSE(IsWordChar('.'));
307  EXPECT_FALSE(IsWordChar(' '));
308  EXPECT_FALSE(IsWordChar('\n'));
309}
310
311TEST(IsWordCharTest, IsTrueForLetter) {
312  EXPECT_TRUE(IsWordChar('a'));
313  EXPECT_TRUE(IsWordChar('b'));
314  EXPECT_TRUE(IsWordChar('A'));
315  EXPECT_TRUE(IsWordChar('Z'));
316}
317
318TEST(IsWordCharTest, IsTrueForDigit) {
319  EXPECT_TRUE(IsWordChar('0'));
320  EXPECT_TRUE(IsWordChar('1'));
321  EXPECT_TRUE(IsWordChar('7'));
322  EXPECT_TRUE(IsWordChar('9'));
323}
324
325TEST(IsWordCharTest, IsTrueForUnderscore) {
326  EXPECT_TRUE(IsWordChar('_'));
327}
328
329TEST(IsValidEscapeTest, IsFalseForNonPrintable) {
330  EXPECT_FALSE(IsValidEscape('\0'));
331  EXPECT_FALSE(IsValidEscape('\007'));
332}
333
334TEST(IsValidEscapeTest, IsFalseForDigit) {
335  EXPECT_FALSE(IsValidEscape('0'));
336  EXPECT_FALSE(IsValidEscape('9'));
337}
338
339TEST(IsValidEscapeTest, IsFalseForWhiteSpace) {
340  EXPECT_FALSE(IsValidEscape(' '));
341  EXPECT_FALSE(IsValidEscape('\n'));
342}
343
344TEST(IsValidEscapeTest, IsFalseForSomeLetter) {
345  EXPECT_FALSE(IsValidEscape('a'));
346  EXPECT_FALSE(IsValidEscape('Z'));
347}
348
349TEST(IsValidEscapeTest, IsTrueForPunct) {
350  EXPECT_TRUE(IsValidEscape('.'));
351  EXPECT_TRUE(IsValidEscape('-'));
352  EXPECT_TRUE(IsValidEscape('^'));
353  EXPECT_TRUE(IsValidEscape('$'));
354  EXPECT_TRUE(IsValidEscape('('));
355  EXPECT_TRUE(IsValidEscape(']'));
356  EXPECT_TRUE(IsValidEscape('{'));
357  EXPECT_TRUE(IsValidEscape('|'));
358}
359
360TEST(IsValidEscapeTest, IsTrueForSomeLetter) {
361  EXPECT_TRUE(IsValidEscape('d'));
362  EXPECT_TRUE(IsValidEscape('D'));
363  EXPECT_TRUE(IsValidEscape('s'));
364  EXPECT_TRUE(IsValidEscape('S'));
365  EXPECT_TRUE(IsValidEscape('w'));
366  EXPECT_TRUE(IsValidEscape('W'));
367}
368
369TEST(AtomMatchesCharTest, EscapedPunct) {
370  EXPECT_FALSE(AtomMatchesChar(true, '\\', '\0'));
371  EXPECT_FALSE(AtomMatchesChar(true, '\\', ' '));
372  EXPECT_FALSE(AtomMatchesChar(true, '_', '.'));
373  EXPECT_FALSE(AtomMatchesChar(true, '.', 'a'));
374
375  EXPECT_TRUE(AtomMatchesChar(true, '\\', '\\'));
376  EXPECT_TRUE(AtomMatchesChar(true, '_', '_'));
377  EXPECT_TRUE(AtomMatchesChar(true, '+', '+'));
378  EXPECT_TRUE(AtomMatchesChar(true, '.', '.'));
379}
380
381TEST(AtomMatchesCharTest, Escaped_d) {
382  EXPECT_FALSE(AtomMatchesChar(true, 'd', '\0'));
383  EXPECT_FALSE(AtomMatchesChar(true, 'd', 'a'));
384  EXPECT_FALSE(AtomMatchesChar(true, 'd', '.'));
385
386  EXPECT_TRUE(AtomMatchesChar(true, 'd', '0'));
387  EXPECT_TRUE(AtomMatchesChar(true, 'd', '9'));
388}
389
390TEST(AtomMatchesCharTest, Escaped_D) {
391  EXPECT_FALSE(AtomMatchesChar(true, 'D', '0'));
392  EXPECT_FALSE(AtomMatchesChar(true, 'D', '9'));
393
394  EXPECT_TRUE(AtomMatchesChar(true, 'D', '\0'));
395  EXPECT_TRUE(AtomMatchesChar(true, 'D', 'a'));
396  EXPECT_TRUE(AtomMatchesChar(true, 'D', '-'));
397}
398
399TEST(AtomMatchesCharTest, Escaped_s) {
400  EXPECT_FALSE(AtomMatchesChar(true, 's', '\0'));
401  EXPECT_FALSE(AtomMatchesChar(true, 's', 'a'));
402  EXPECT_FALSE(AtomMatchesChar(true, 's', '.'));
403  EXPECT_FALSE(AtomMatchesChar(true, 's', '9'));
404
405  EXPECT_TRUE(AtomMatchesChar(true, 's', ' '));
406  EXPECT_TRUE(AtomMatchesChar(true, 's', '\n'));
407  EXPECT_TRUE(AtomMatchesChar(true, 's', '\t'));
408}
409
410TEST(AtomMatchesCharTest, Escaped_S) {
411  EXPECT_FALSE(AtomMatchesChar(true, 'S', ' '));
412  EXPECT_FALSE(AtomMatchesChar(true, 'S', '\r'));
413
414  EXPECT_TRUE(AtomMatchesChar(true, 'S', '\0'));
415  EXPECT_TRUE(AtomMatchesChar(true, 'S', 'a'));
416  EXPECT_TRUE(AtomMatchesChar(true, 'S', '9'));
417}
418
419TEST(AtomMatchesCharTest, Escaped_w) {
420  EXPECT_FALSE(AtomMatchesChar(true, 'w', '\0'));
421  EXPECT_FALSE(AtomMatchesChar(true, 'w', '+'));
422  EXPECT_FALSE(AtomMatchesChar(true, 'w', ' '));
423  EXPECT_FALSE(AtomMatchesChar(true, 'w', '\n'));
424
425  EXPECT_TRUE(AtomMatchesChar(true, 'w', '0'));
426  EXPECT_TRUE(AtomMatchesChar(true, 'w', 'b'));
427  EXPECT_TRUE(AtomMatchesChar(true, 'w', 'C'));
428  EXPECT_TRUE(AtomMatchesChar(true, 'w', '_'));
429}
430
431TEST(AtomMatchesCharTest, Escaped_W) {
432  EXPECT_FALSE(AtomMatchesChar(true, 'W', 'A'));
433  EXPECT_FALSE(AtomMatchesChar(true, 'W', 'b'));
434  EXPECT_FALSE(AtomMatchesChar(true, 'W', '9'));
435  EXPECT_FALSE(AtomMatchesChar(true, 'W', '_'));
436
437  EXPECT_TRUE(AtomMatchesChar(true, 'W', '\0'));
438  EXPECT_TRUE(AtomMatchesChar(true, 'W', '*'));
439  EXPECT_TRUE(AtomMatchesChar(true, 'W', '\n'));
440}
441
442TEST(AtomMatchesCharTest, EscapedWhiteSpace) {
443  EXPECT_FALSE(AtomMatchesChar(true, 'f', '\0'));
444  EXPECT_FALSE(AtomMatchesChar(true, 'f', '\n'));
445  EXPECT_FALSE(AtomMatchesChar(true, 'n', '\0'));
446  EXPECT_FALSE(AtomMatchesChar(true, 'n', '\r'));
447  EXPECT_FALSE(AtomMatchesChar(true, 'r', '\0'));
448  EXPECT_FALSE(AtomMatchesChar(true, 'r', 'a'));
449  EXPECT_FALSE(AtomMatchesChar(true, 't', '\0'));
450  EXPECT_FALSE(AtomMatchesChar(true, 't', 't'));
451  EXPECT_FALSE(AtomMatchesChar(true, 'v', '\0'));
452  EXPECT_FALSE(AtomMatchesChar(true, 'v', '\f'));
453
454  EXPECT_TRUE(AtomMatchesChar(true, 'f', '\f'));
455  EXPECT_TRUE(AtomMatchesChar(true, 'n', '\n'));
456  EXPECT_TRUE(AtomMatchesChar(true, 'r', '\r'));
457  EXPECT_TRUE(AtomMatchesChar(true, 't', '\t'));
458  EXPECT_TRUE(AtomMatchesChar(true, 'v', '\v'));
459}
460
461TEST(AtomMatchesCharTest, UnescapedDot) {
462  EXPECT_FALSE(AtomMatchesChar(false, '.', '\n'));
463
464  EXPECT_TRUE(AtomMatchesChar(false, '.', '\0'));
465  EXPECT_TRUE(AtomMatchesChar(false, '.', '.'));
466  EXPECT_TRUE(AtomMatchesChar(false, '.', 'a'));
467  EXPECT_TRUE(AtomMatchesChar(false, '.', ' '));
468}
469
470TEST(AtomMatchesCharTest, UnescapedChar) {
471  EXPECT_FALSE(AtomMatchesChar(false, 'a', '\0'));
472  EXPECT_FALSE(AtomMatchesChar(false, 'a', 'b'));
473  EXPECT_FALSE(AtomMatchesChar(false, '$', 'a'));
474
475  EXPECT_TRUE(AtomMatchesChar(false, '$', '$'));
476  EXPECT_TRUE(AtomMatchesChar(false, '5', '5'));
477  EXPECT_TRUE(AtomMatchesChar(false, 'Z', 'Z'));
478}
479
480TEST(ValidateRegexTest, GeneratesFailureAndReturnsFalseForInvalid) {
481  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(NULL)),
482                          "NULL is not a valid simple regular expression");
483  EXPECT_NONFATAL_FAILURE(
484      ASSERT_FALSE(ValidateRegex("a\\")),
485      "Syntax error at index 1 in simple regular expression \"a\\\": ");
486  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a\\")),
487                          "'\\' cannot appear at the end");
488  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\n\\")),
489                          "'\\' cannot appear at the end");
490  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\s\\hb")),
491                          "invalid escape sequence \"\\h\"");
492  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^^")),
493                          "'^' can only appear at the beginning");
494  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(".*^b")),
495                          "'^' can only appear at the beginning");
496  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("$$")),
497                          "'$' can only appear at the end");
498  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^$a")),
499                          "'$' can only appear at the end");
500  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a(b")),
501                          "'(' is unsupported");
502  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("ab)")),
503                          "')' is unsupported");
504  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("[ab")),
505                          "'[' is unsupported");
506  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a{2")),
507                          "'{' is unsupported");
508  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("?")),
509                          "'?' can only follow a repeatable token");
510  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^*")),
511                          "'*' can only follow a repeatable token");
512  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("5*+")),
513                          "'+' can only follow a repeatable token");
514}
515
516TEST(ValidateRegexTest, ReturnsTrueForValid) {
517  EXPECT_TRUE(ValidateRegex(""));
518  EXPECT_TRUE(ValidateRegex("a"));
519  EXPECT_TRUE(ValidateRegex(".*"));
520  EXPECT_TRUE(ValidateRegex("^a_+"));
521  EXPECT_TRUE(ValidateRegex("^a\\t\\&?"));
522  EXPECT_TRUE(ValidateRegex("09*$"));
523  EXPECT_TRUE(ValidateRegex("^Z$"));
524  EXPECT_TRUE(ValidateRegex("a\\^Z\\$\\(\\)\\|\\[\\]\\{\\}"));
525}
526
527TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrOne) {
528  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "a", "ba"));
529  // Repeating more than once.
530  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "aab"));
531
532  // Repeating zero times.
533  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ba"));
534  // Repeating once.
535  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ab"));
536  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '#', '?', ".", "##"));
537}
538
539TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrMany) {
540  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '*', "a$", "baab"));
541
542  // Repeating zero times.
543  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "bc"));
544  // Repeating once.
545  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "abc"));
546  // Repeating more than once.
547  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '*', "-", "ab_1-g"));
548}
549
550TEST(MatchRepetitionAndRegexAtHeadTest, WorksForOneOrMany) {
551  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "a$", "baab"));
552  // Repeating zero times.
553  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "bc"));
554
555  // Repeating once.
556  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "abc"));
557  // Repeating more than once.
558  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '+', "-", "ab_1-g"));
559}
560
561TEST(MatchRegexAtHeadTest, ReturnsTrueForEmptyRegex) {
562  EXPECT_TRUE(MatchRegexAtHead("", ""));
563  EXPECT_TRUE(MatchRegexAtHead("", "ab"));
564}
565
566TEST(MatchRegexAtHeadTest, WorksWhenDollarIsInRegex) {
567  EXPECT_FALSE(MatchRegexAtHead("$", "a"));
568
569  EXPECT_TRUE(MatchRegexAtHead("$", ""));
570  EXPECT_TRUE(MatchRegexAtHead("a$", "a"));
571}
572
573TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithEscapeSequence) {
574  EXPECT_FALSE(MatchRegexAtHead("\\w", "+"));
575  EXPECT_FALSE(MatchRegexAtHead("\\W", "ab"));
576
577  EXPECT_TRUE(MatchRegexAtHead("\\sa", "\nab"));
578  EXPECT_TRUE(MatchRegexAtHead("\\d", "1a"));
579}
580
581TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithRepetition) {
582  EXPECT_FALSE(MatchRegexAtHead(".+a", "abc"));
583  EXPECT_FALSE(MatchRegexAtHead("a?b", "aab"));
584
585  EXPECT_TRUE(MatchRegexAtHead(".*a", "bc12-ab"));
586  EXPECT_TRUE(MatchRegexAtHead("a?b", "b"));
587  EXPECT_TRUE(MatchRegexAtHead("a?b", "ab"));
588}
589
590TEST(MatchRegexAtHeadTest,
591     WorksWhenRegexStartsWithRepetionOfEscapeSequence) {
592  EXPECT_FALSE(MatchRegexAtHead("\\.+a", "abc"));
593  EXPECT_FALSE(MatchRegexAtHead("\\s?b", "  b"));
594
595  EXPECT_TRUE(MatchRegexAtHead("\\(*a", "((((ab"));
596  EXPECT_TRUE(MatchRegexAtHead("\\^?b", "^b"));
597  EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "b"));
598  EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "\\b"));
599}
600
601TEST(MatchRegexAtHeadTest, MatchesSequentially) {
602  EXPECT_FALSE(MatchRegexAtHead("ab.*c", "acabc"));
603
604  EXPECT_TRUE(MatchRegexAtHead("ab.*c", "ab-fsc"));
605}
606
607TEST(MatchRegexAnywhereTest, ReturnsFalseWhenStringIsNull) {
608  EXPECT_FALSE(MatchRegexAnywhere("", NULL));
609}
610
611TEST(MatchRegexAnywhereTest, WorksWhenRegexStartsWithCaret) {
612  EXPECT_FALSE(MatchRegexAnywhere("^a", "ba"));
613  EXPECT_FALSE(MatchRegexAnywhere("^$", "a"));
614
615  EXPECT_TRUE(MatchRegexAnywhere("^a", "ab"));
616  EXPECT_TRUE(MatchRegexAnywhere("^", "ab"));
617  EXPECT_TRUE(MatchRegexAnywhere("^$", ""));
618}
619
620TEST(MatchRegexAnywhereTest, ReturnsFalseWhenNoMatch) {
621  EXPECT_FALSE(MatchRegexAnywhere("a", "bcde123"));
622  EXPECT_FALSE(MatchRegexAnywhere("a.+a", "--aa88888888"));
623}
624
625TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingPrefix) {
626  EXPECT_TRUE(MatchRegexAnywhere("\\w+", "ab1_ - 5"));
627  EXPECT_TRUE(MatchRegexAnywhere(".*=", "="));
628  EXPECT_TRUE(MatchRegexAnywhere("x.*ab?.*bc", "xaaabc"));
629}
630
631TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingNonPrefix) {
632  EXPECT_TRUE(MatchRegexAnywhere("\\w+", "$$$ ab1_ - 5"));
633  EXPECT_TRUE(MatchRegexAnywhere("\\.+=", "=  ...="));
634}
635
636// Tests RE's implicit constructors.
637TEST(RETest, ImplicitConstructorWorks) {
638  const RE empty("");
639  EXPECT_STREQ("", empty.pattern());
640
641  const RE simple("hello");
642  EXPECT_STREQ("hello", simple.pattern());
643}
644
645// Tests that RE's constructors reject invalid regular expressions.
646TEST(RETest, RejectsInvalidRegex) {
647  EXPECT_NONFATAL_FAILURE({
648    const RE normal(NULL);
649  }, "NULL is not a valid simple regular expression");
650
651  EXPECT_NONFATAL_FAILURE({
652    const RE normal(".*(\\w+");
653  }, "'(' is unsupported");
654
655  EXPECT_NONFATAL_FAILURE({
656    const RE invalid("^?");
657  }, "'?' can only follow a repeatable token");
658}
659
660// Tests RE::FullMatch().
661TEST(RETest, FullMatchWorks) {
662  const RE empty("");
663  EXPECT_TRUE(RE::FullMatch("", empty));
664  EXPECT_FALSE(RE::FullMatch("a", empty));
665
666  const RE re1("a");
667  EXPECT_TRUE(RE::FullMatch("a", re1));
668
669  const RE re("a.*z");
670  EXPECT_TRUE(RE::FullMatch("az", re));
671  EXPECT_TRUE(RE::FullMatch("axyz", re));
672  EXPECT_FALSE(RE::FullMatch("baz", re));
673  EXPECT_FALSE(RE::FullMatch("azy", re));
674}
675
676// Tests RE::PartialMatch().
677TEST(RETest, PartialMatchWorks) {
678  const RE empty("");
679  EXPECT_TRUE(RE::PartialMatch("", empty));
680  EXPECT_TRUE(RE::PartialMatch("a", empty));
681
682  const RE re("a.*z");
683  EXPECT_TRUE(RE::PartialMatch("az", re));
684  EXPECT_TRUE(RE::PartialMatch("axyz", re));
685  EXPECT_TRUE(RE::PartialMatch("baz", re));
686  EXPECT_TRUE(RE::PartialMatch("azy", re));
687  EXPECT_FALSE(RE::PartialMatch("zza", re));
688}
689
690#endif  // GTEST_USES_POSIX_RE
691
692TEST(CaptureStderrTest, CapturesStdErr) {
693  CaptureStderr();
694  fprintf(stderr, "abc");
695  ASSERT_STREQ("abc", GetCapturedStderr().c_str());
696}
697
698}  // namespace internal
699}  // namespace testing