gtest-port.cc 26.9 KB
Newer Older
shiqian's avatar
shiqian committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: wan@google.com (Zhanyong Wan)

32
#include "gtest/internal/gtest-port.h"
shiqian's avatar
shiqian committed
33
34

#include <limits.h>
35
36
#include <stdlib.h>
#include <stdio.h>
37
#include <string.h>
38

39
#if GTEST_OS_WINDOWS_MOBILE
40
# include <windows.h>  // For TerminateProcess()
41
#elif GTEST_OS_WINDOWS
42
43
# include <io.h>
# include <sys/stat.h>
44
#else
45
# include <unistd.h>
46
#endif  // GTEST_OS_WINDOWS_MOBILE
47

48
#if GTEST_OS_MAC
49
50
51
# include <mach/mach_init.h>
# include <mach/task.h>
# include <mach/vm_map.h>
52
53
#endif  // GTEST_OS_MAC

54
55
56
57
58
#if GTEST_OS_QNX
# include <devctl.h>
# include <sys/procfs.h>
#endif  // GTEST_OS_QNX

59
60
#include "gtest/gtest-spi.h"
#include "gtest/gtest-message.h"
61
#include "gtest/internal/gtest-internal.h"
62
#include "gtest/internal/gtest-string.h"
shiqian's avatar
shiqian committed
63

64
65
66
67
68
// Indicates that this translation unit is part of Google Test's
// implementation.  It must come before gtest-internal-inl.h is
// included, or there will be a compiler error.  This trick is to
// prevent a user from accidentally including gtest-internal-inl.h in
// his code.
zhanyong.wan's avatar
zhanyong.wan committed
69
#define GTEST_IMPLEMENTATION_ 1
70
#include "src/gtest-internal-inl.h"
zhanyong.wan's avatar
zhanyong.wan committed
71
#undef GTEST_IMPLEMENTATION_
72

shiqian's avatar
shiqian committed
73
74
75
namespace testing {
namespace internal {

76
77
#if defined(_MSC_VER) || defined(__BORLANDC__)
// MSVC and C++Builder do not provide a definition of STDERR_FILENO.
78
const int kStdOutFileno = 1;
79
80
const int kStdErrFileno = 2;
#else
81
const int kStdOutFileno = STDOUT_FILENO;
82
const int kStdErrFileno = STDERR_FILENO;
83
#endif  // _MSC_VER
84

85
86
#if GTEST_OS_MAC

87
88
89
// Returns the number of threads running in the process, or 0 to indicate that
// we cannot detect it.
size_t GetThreadCount() {
90
  const task_t task = mach_task_self();
91
  mach_msg_type_number_t thread_count;
92
93
94
95
96
97
98
99
100
101
102
103
104
105
  thread_act_array_t thread_list;
  const kern_return_t status = task_threads(task, &thread_list, &thread_count);
  if (status == KERN_SUCCESS) {
    // task_threads allocates resources in thread_list and we need to free them
    // to avoid leaks.
    vm_deallocate(task,
                  reinterpret_cast<vm_address_t>(thread_list),
                  sizeof(thread_t) * thread_count);
    return static_cast<size_t>(thread_count);
  } else {
    return 0;
  }
}

106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
#elif GTEST_OS_QNX

// Returns the number of threads running in the process, or 0 to indicate that
// we cannot detect it.
size_t GetThreadCount() {
  const int fd = open("/proc/self/as", O_RDONLY);
  if (fd < 0) {
    return 0;
  }
  procfs_info process_info;
  const int status =
      devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info), NULL);
  close(fd);
  if (status == EOK) {
    return static_cast<size_t>(process_info.num_threads);
  } else {
    return 0;
  }
}

126
#else
127
128

size_t GetThreadCount() {
129
130
131
132
133
  // There's no portable way to detect the number of threads, so we just
  // return 0 to indicate that we cannot detect it.
  return 0;
}

134
135
#endif  // GTEST_OS_MAC

136
#if GTEST_USES_POSIX_RE
shiqian's avatar
shiqian committed
137
138
139
140

// Implements RE.  Currently only needed for death tests.

RE::~RE() {
141
142
143
144
145
146
147
148
  if (is_valid_) {
    // regfree'ing an invalid regex might crash because the content
    // of the regex is undefined. Since the regex's are essentially
    // the same, one cannot be valid (or invalid) without the other
    // being so too.
    regfree(&partial_regex_);
    regfree(&full_regex_);
  }
shiqian's avatar
shiqian committed
149
150
151
  free(const_cast<char*>(pattern_));
}

152
153
154
155
156
157
158
159
160
161
// Returns true iff regular expression re matches the entire str.
bool RE::FullMatch(const char* str, const RE& re) {
  if (!re.is_valid_) return false;

  regmatch_t match;
  return regexec(&re.full_regex_, str, 1, &match, 0) == 0;
}

// Returns true iff regular expression re matches a substring of str
// (including str itself).
shiqian's avatar
shiqian committed
162
163
164
165
bool RE::PartialMatch(const char* str, const RE& re) {
  if (!re.is_valid_) return false;

  regmatch_t match;
166
  return regexec(&re.partial_regex_, str, 1, &match, 0) == 0;
shiqian's avatar
shiqian committed
167
168
169
170
}

// Initializes an RE from its string representation.
void RE::Init(const char* regex) {
171
  pattern_ = posix::StrDup(regex);
172
173
174
175
176
177
178
179
180
181
182
183

  // Reserves enough bytes to hold the regular expression used for a
  // full match.
  const size_t full_regex_len = strlen(regex) + 10;
  char* const full_pattern = new char[full_regex_len];

  snprintf(full_pattern, full_regex_len, "^(%s)$", regex);
  is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0;
  // We want to call regcomp(&partial_regex_, ...) even if the
  // previous expression returns false.  Otherwise partial_regex_ may
  // not be properly initialized can may cause trouble when it's
  // freed.
184
185
186
187
  //
  // Some implementation of POSIX regex (e.g. on at least some
  // versions of Cygwin) doesn't accept the empty string as a valid
  // regex.  We change it to an equivalent form "()" to be safe.
188
189
190
191
  if (is_valid_) {
    const char* const partial_regex = (*regex == '\0') ? "()" : regex;
    is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0;
  }
shiqian's avatar
shiqian committed
192
193
194
  EXPECT_TRUE(is_valid_)
      << "Regular expression \"" << regex
      << "\" is not a valid POSIX Extended regular expression.";
195
196

  delete[] full_pattern;
shiqian's avatar
shiqian committed
197
198
}

199
200
201
202
203
204
205
206
207
208
209
#elif GTEST_USES_SIMPLE_RE

// Returns true iff ch appears anywhere in str (excluding the
// terminating '\0' character).
bool IsInSet(char ch, const char* str) {
  return ch != '\0' && strchr(str, ch) != NULL;
}

// Returns true iff ch belongs to the given classification.  Unlike
// similar functions in <ctype.h>, these aren't affected by the
// current locale.
210
211
bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
bool IsAsciiPunct(char ch) {
212
213
214
  return IsInSet(ch, "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~");
}
bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
215
216
bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
bool IsAsciiWordChar(char ch) {
217
218
219
220
221
222
  return ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') ||
      ('0' <= ch && ch <= '9') || ch == '_';
}

// Returns true iff "\\c" is a supported escape sequence.
bool IsValidEscape(char c) {
223
  return (IsAsciiPunct(c) || IsInSet(c, "dDfnrsStvwW"));
224
225
226
227
228
229
230
}

// Returns true iff the given atom (specified by escaped and pattern)
// matches ch.  The result is undefined if the atom is invalid.
bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
  if (escaped) {  // "\\p" where p is pattern_char.
    switch (pattern_char) {
231
232
      case 'd': return IsAsciiDigit(ch);
      case 'D': return !IsAsciiDigit(ch);
233
234
235
      case 'f': return ch == '\f';
      case 'n': return ch == '\n';
      case 'r': return ch == '\r';
236
237
      case 's': return IsAsciiWhiteSpace(ch);
      case 'S': return !IsAsciiWhiteSpace(ch);
238
239
      case 't': return ch == '\t';
      case 'v': return ch == '\v';
240
241
      case 'w': return IsAsciiWordChar(ch);
      case 'W': return !IsAsciiWordChar(ch);
242
    }
243
    return IsAsciiPunct(pattern_char) && pattern_char == ch;
244
245
246
247
248
249
  }

  return (pattern_char == '.' && ch != '\n') || pattern_char == ch;
}

// Helper function used by ValidateRegex() to format error messages.
250
std::string FormatRegexSyntaxError(const char* regex, int index) {
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
  return (Message() << "Syntax error at index " << index
          << " in simple regular expression \"" << regex << "\": ").GetString();
}

// Generates non-fatal failures and returns false if regex is invalid;
// otherwise returns true.
bool ValidateRegex(const char* regex) {
  if (regex == NULL) {
    // TODO(wan@google.com): fix the source file location in the
    // assertion failures to match where the regex is used in user
    // code.
    ADD_FAILURE() << "NULL is not a valid simple regular expression.";
    return false;
  }

  bool is_valid = true;

  // True iff ?, *, or + can follow the previous atom.
  bool prev_repeatable = false;
  for (int i = 0; regex[i]; i++) {
    if (regex[i] == '\\') {  // An escape sequence
      i++;
      if (regex[i] == '\0') {
        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
                      << "'\\' cannot appear at the end.";
        return false;
      }

      if (!IsValidEscape(regex[i])) {
        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
                      << "invalid escape sequence \"\\" << regex[i] << "\".";
        is_valid = false;
      }
      prev_repeatable = true;
    } else {  // Not an escape sequence.
      const char ch = regex[i];

      if (ch == '^' && i > 0) {
        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
                      << "'^' can only appear at the beginning.";
        is_valid = false;
      } else if (ch == '$' && regex[i + 1] != '\0') {
        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
                      << "'$' can only appear at the end.";
        is_valid = false;
      } else if (IsInSet(ch, "()[]{}|")) {
        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
                      << "'" << ch << "' is unsupported.";
        is_valid = false;
      } else if (IsRepeat(ch) && !prev_repeatable) {
        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
                      << "'" << ch << "' can only follow a repeatable token.";
        is_valid = false;
      }

      prev_repeatable = !IsInSet(ch, "^$?*+");
    }
  }

  return is_valid;
}

// Matches a repeated regex atom followed by a valid simple regular
// expression.  The regex atom is defined as c if escaped is false,
// or \c otherwise.  repeat is the repetition meta character (?, *,
// or +).  The behavior is undefined if str contains too many
// characters to be indexable by size_t, in which case the test will
// probably time out anyway.  We are fine with this limitation as
// std::string has it too.
bool MatchRepetitionAndRegexAtHead(
    bool escaped, char c, char repeat, const char* regex,
    const char* str) {
  const size_t min_count = (repeat == '+') ? 1 : 0;
  const size_t max_count = (repeat == '?') ? 1 :
      static_cast<size_t>(-1) - 1;
  // We cannot call numeric_limits::max() as it conflicts with the
  // max() macro on Windows.

  for (size_t i = 0; i <= max_count; ++i) {
    // We know that the atom matches each of the first i characters in str.
    if (i >= min_count && MatchRegexAtHead(regex, str + i)) {
      // We have enough matches at the head, and the tail matches too.
      // Since we only care about *whether* the pattern matches str
      // (as opposed to *how* it matches), there is no need to find a
      // greedy match.
      return true;
    }
    if (str[i] == '\0' || !AtomMatchesChar(escaped, c, str[i]))
      return false;
  }
  return false;
}

// Returns true iff regex matches a prefix of str.  regex must be a
// valid simple regular expression and not start with "^", or the
// result is undefined.
bool MatchRegexAtHead(const char* regex, const char* str) {
  if (*regex == '\0')  // An empty regex matches a prefix of anything.
    return true;

  // "$" only matches the end of a string.  Note that regex being
  // valid guarantees that there's nothing after "$" in it.
  if (*regex == '$')
    return *str == '\0';

  // Is the first thing in regex an escape sequence?
  const bool escaped = *regex == '\\';
  if (escaped)
    ++regex;
  if (IsRepeat(regex[1])) {
    // MatchRepetitionAndRegexAtHead() calls MatchRegexAtHead(), so
    // here's an indirect recursion.  It terminates as the regex gets
    // shorter in each recursion.
    return MatchRepetitionAndRegexAtHead(
        escaped, regex[0], regex[1], regex + 2, str);
  } else {
    // regex isn't empty, isn't "$", and doesn't start with a
    // repetition.  We match the first atom of regex with the first
    // character of str and recurse.
    return (*str != '\0') && AtomMatchesChar(escaped, *regex, *str) &&
        MatchRegexAtHead(regex + 1, str + 1);
  }
}

// Returns true iff regex matches any substring of str.  regex must be
// a valid simple regular expression, or the result is undefined.
//
// The algorithm is recursive, but the recursion depth doesn't exceed
// the regex length, so we won't need to worry about running out of
// stack space normally.  In rare cases the time complexity can be
// exponential with respect to the regex length + the string length,
// but usually it's must faster (often close to linear).
bool MatchRegexAnywhere(const char* regex, const char* str) {
  if (regex == NULL || str == NULL)
    return false;

  if (*regex == '^')
    return MatchRegexAtHead(regex + 1, str);

  // A successful match can be anywhere in str.
  do {
    if (MatchRegexAtHead(regex, str))
      return true;
  } while (*str++ != '\0');
  return false;
}

// Implements the RE class.

RE::~RE() {
  free(const_cast<char*>(pattern_));
  free(const_cast<char*>(full_pattern_));
}

// Returns true iff regular expression re matches the entire str.
bool RE::FullMatch(const char* str, const RE& re) {
  return re.is_valid_ && MatchRegexAnywhere(re.full_pattern_, str);
}

// Returns true iff regular expression re matches a substring of str
// (including str itself).
bool RE::PartialMatch(const char* str, const RE& re) {
  return re.is_valid_ && MatchRegexAnywhere(re.pattern_, str);
}

// Initializes an RE from its string representation.
void RE::Init(const char* regex) {
  pattern_ = full_pattern_ = NULL;
  if (regex != NULL) {
420
    pattern_ = posix::StrDup(regex);
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
  }

  is_valid_ = ValidateRegex(regex);
  if (!is_valid_) {
    // No need to calculate the full pattern when the regex is invalid.
    return;
  }

  const size_t len = strlen(regex);
  // Reserves enough bytes to hold the regular expression used for a
  // full match: we need space to prepend a '^', append a '$', and
  // terminate the string with '\0'.
  char* buffer = static_cast<char*>(malloc(len + 3));
  full_pattern_ = buffer;

  if (*regex != '^')
    *buffer++ = '^';  // Makes sure full_pattern_ starts with '^'.

  // We don't use snprintf or strncpy, as they trigger a warning when
  // compiled with VC++ 8.0.
  memcpy(buffer, regex, len);
  buffer += len;

  if (len == 0 || regex[len - 1] != '$')
    *buffer++ = '$';  // Makes sure full_pattern_ ends with '$'.

  *buffer = '\0';
}

#endif  // GTEST_USES_POSIX_RE
shiqian's avatar
shiqian committed
451

452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
const char kUnknownFile[] = "unknown file";

// Formats a source file path and a line number as they would appear
// in an error message from the compiler used to compile this code.
GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
  const char* const file_name = file == NULL ? kUnknownFile : file;

  if (line < 0) {
    return String::Format("%s:", file_name).c_str();
  }
#ifdef _MSC_VER
  return String::Format("%s(%d):", file_name, line).c_str();
#else
  return String::Format("%s:%d:", file_name, line).c_str();
#endif  // _MSC_VER
}

// Formats a file location for compiler-independent XML output.
// Although this function is not platform dependent, we put it next to
// FormatFileLocation in order to contrast the two functions.
// Note that FormatCompilerIndependentFileLocation() does NOT append colon
// to the file location it produces, unlike FormatFileLocation().
GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
    const char* file, int line) {
  const char* const file_name = file == NULL ? kUnknownFile : file;

  if (line < 0)
    return file_name;
  else
    return String::Format("%s:%d", file_name, line).c_str();
}

484
485
486

GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
    : severity_(severity) {
shiqian's avatar
shiqian committed
487
488
489
490
  const char* const marker =
      severity == GTEST_INFO ?    "[  INFO ]" :
      severity == GTEST_WARNING ? "[WARNING]" :
      severity == GTEST_ERROR ?   "[ ERROR ]" : "[ FATAL ]";
491
492
493
494
495
496
497
498
499
  GetStream() << ::std::endl << marker << " "
              << FormatFileLocation(file, line).c_str() << ": ";
}

// Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
GTestLog::~GTestLog() {
  GetStream() << ::std::endl;
  if (severity_ == GTEST_FATAL) {
    fflush(stderr);
500
    posix::Abort();
shiqian's avatar
shiqian committed
501
502
  }
}
503
504
505
// Disable Microsoft deprecation warnings for POSIX functions called from
// this class (creat, dup, dup2, and close)
#ifdef _MSC_VER
506
507
# pragma warning(push)
# pragma warning(disable: 4996)
508
#endif  // _MSC_VER
shiqian's avatar
shiqian committed
509

510
#if GTEST_HAS_STREAM_REDIRECTION
shiqian's avatar
shiqian committed
511

512
513
// Object that captures an output stream (stdout/stderr).
class CapturedStream {
shiqian's avatar
shiqian committed
514
 public:
515
  // The ctor redirects the stream to a temporary file.
516
  explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
517
# if GTEST_OS_WINDOWS
518
519
    char temp_dir_path[MAX_PATH + 1] = { '\0' };  // NOLINT
    char temp_file_path[MAX_PATH + 1] = { '\0' };  // NOLINT
shiqian's avatar
shiqian committed
520

521
    ::GetTempPathA(sizeof(temp_dir_path), temp_dir_path);
522
523
524
525
526
527
    const UINT success = ::GetTempFileNameA(temp_dir_path,
                                            "gtest_redir",
                                            0,  // Generate unique file name.
                                            temp_file_path);
    GTEST_CHECK_(success != 0)
        << "Unable to create a temporary file in " << temp_dir_path;
528
    const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE);
529
530
    GTEST_CHECK_(captured_fd != -1) << "Unable to open temporary file "
                                    << temp_file_path;
531
    filename_ = temp_file_path;
532
# else
533
    // There's no guarantee that a test has write access to the current
534
535
536
    // directory, so we create the temporary file in the /tmp directory
    // instead. We use /tmp on most systems, and /sdcard on Android.
    // That's because Android doesn't have /tmp.
537
#  if GTEST_OS_LINUX_ANDROID
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
    // Note: Android applications are expected to call the framework's
    // Context.getExternalStorageDirectory() method through JNI to get
    // the location of the world-writable SD Card directory. However,
    // this requires a Context handle, which cannot be retrieved
    // globally from native code. Doing so also precludes running the
    // code as part of a regular standalone executable, which doesn't
    // run in a Dalvik process (e.g. when running it through 'adb shell').
    //
    // The location /sdcard is directly accessible from native code
    // and is the only location (unofficially) supported by the Android
    // team. It's generally a symlink to the real SD Card mount point
    // which can be /mnt/sdcard, /mnt/sdcard0, /system/media/sdcard, or
    // other OEM-customized locations. Never rely on these, and always
    // use /sdcard.
    char name_template[] = "/sdcard/gtest_captured_stream.XXXXXX";
553
#  else
554
    char name_template[] = "/tmp/captured_stream.XXXXXX";
555
#  endif  // GTEST_OS_LINUX_ANDROID
shiqian's avatar
shiqian committed
556
557
    const int captured_fd = mkstemp(name_template);
    filename_ = name_template;
558
# endif  // GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
559
    fflush(NULL);
560
    dup2(captured_fd, fd_);
shiqian's avatar
shiqian committed
561
562
563
    close(captured_fd);
  }

564
  ~CapturedStream() {
shiqian's avatar
shiqian committed
565
566
567
    remove(filename_.c_str());
  }

568
  std::string GetCapturedString() {
569
570
571
572
573
574
575
    if (uncaptured_fd_ != -1) {
      // Restores the original stream.
      fflush(NULL);
      dup2(uncaptured_fd_, fd_);
      close(uncaptured_fd_);
      uncaptured_fd_ = -1;
    }
shiqian's avatar
shiqian committed
576

577
    FILE* const file = posix::FOpen(filename_.c_str(), "r");
578
    const std::string content = ReadEntireFile(file);
579
580
581
    posix::FClose(file);
    return content;
  }
shiqian's avatar
shiqian committed
582
583

 private:
584
585
  // Reads the entire content of a file as an std::string.
  static std::string ReadEntireFile(FILE* file);
586
587
588
589
590

  // Returns the size (in bytes) of a file.
  static size_t GetFileSize(FILE* file);

  const int fd_;  // A stream to capture.
shiqian's avatar
shiqian committed
591
  int uncaptured_fd_;
592
  // Name of the temporary file holding the stderr output.
shiqian's avatar
shiqian committed
593
  ::std::string filename_;
594

595
596
  GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream);
};
shiqian's avatar
shiqian committed
597
598

// Returns the size (in bytes) of a file.
599
size_t CapturedStream::GetFileSize(FILE* file) {
shiqian's avatar
shiqian committed
600
601
602
603
604
  fseek(file, 0, SEEK_END);
  return static_cast<size_t>(ftell(file));
}

// Reads the entire content of a file as a string.
605
std::string CapturedStream::ReadEntireFile(FILE* file) {
shiqian's avatar
shiqian committed
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
  const size_t file_size = GetFileSize(file);
  char* const buffer = new char[file_size];

  size_t bytes_last_read = 0;  // # of bytes read in the last fread()
  size_t bytes_read = 0;       // # of bytes read so far

  fseek(file, 0, SEEK_SET);

  // Keeps reading the file until we cannot read further or the
  // pre-determined file size is reached.
  do {
    bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file);
    bytes_read += bytes_last_read;
  } while (bytes_last_read > 0 && bytes_read < file_size);

621
  const std::string content(buffer, bytes_read);
shiqian's avatar
shiqian committed
622
623
624
625
626
  delete[] buffer;

  return content;
}

627
628
629
# ifdef _MSC_VER
#  pragma warning(pop)
# endif  // _MSC_VER
630
631
632
633
634
635
636
637
638

static CapturedStream* g_captured_stderr = NULL;
static CapturedStream* g_captured_stdout = NULL;

// Starts capturing an output stream (stdout/stderr).
void CaptureStream(int fd, const char* stream_name, CapturedStream** stream) {
  if (*stream != NULL) {
    GTEST_LOG_(FATAL) << "Only one " << stream_name
                      << " capturer can exist at a time.";
shiqian's avatar
shiqian committed
639
  }
640
  *stream = new CapturedStream(fd);
shiqian's avatar
shiqian committed
641
642
}

643
// Stops capturing the output stream and returns the captured string.
644
645
std::string GetCapturedStream(CapturedStream** captured_stream) {
  const std::string content = (*captured_stream)->GetCapturedString();
646

647
648
  delete *captured_stream;
  *captured_stream = NULL;
shiqian's avatar
shiqian committed
649
650
651
652

  return content;
}

653
654
655
656
657
658
659
660
661
662
663
// Starts capturing stdout.
void CaptureStdout() {
  CaptureStream(kStdOutFileno, "stdout", &g_captured_stdout);
}

// Starts capturing stderr.
void CaptureStderr() {
  CaptureStream(kStdErrFileno, "stderr", &g_captured_stderr);
}

// Stops capturing stdout and returns the captured string.
664
665
666
std::string GetCapturedStdout() {
  return GetCapturedStream(&g_captured_stdout);
}
667
668

// Stops capturing stderr and returns the captured string.
669
670
671
std::string GetCapturedStderr() {
  return GetCapturedStream(&g_captured_stderr);
}
672

673
#endif  // GTEST_HAS_STREAM_REDIRECTION
674

675
676
#if GTEST_HAS_DEATH_TEST

shiqian's avatar
shiqian committed
677
// A copy of all command line arguments.  Set by InitGoogleTest().
678
::std::vector<testing::internal::string> g_argvs;
shiqian's avatar
shiqian committed
679

680
681
static const ::std::vector<testing::internal::string>* g_injected_test_argvs =
                                        NULL;  // Owned.
shiqian's avatar
shiqian committed
682

683
684
685
686
687
688
689
690
691
692
693
694
void SetInjectableArgvs(const ::std::vector<testing::internal::string>* argvs) {
  if (g_injected_test_argvs != argvs)
    delete g_injected_test_argvs;
  g_injected_test_argvs = argvs;
}

const ::std::vector<testing::internal::string>& GetInjectableArgvs() {
  if (g_injected_test_argvs != NULL) {
    return *g_injected_test_argvs;
  }
  return g_argvs;
}
shiqian's avatar
shiqian committed
695
696
#endif  // GTEST_HAS_DEATH_TEST

697
#if GTEST_OS_WINDOWS_MOBILE
698
namespace posix {
699
void Abort() {
700
701
702
  DebugBreak();
  TerminateProcess(GetCurrentProcess(), 1);
}
703
}  // namespace posix
704
#endif  // GTEST_OS_WINDOWS_MOBILE
705

shiqian's avatar
shiqian committed
706
707
708
// Returns the name of the environment variable corresponding to the
// given flag.  For example, FlagToEnvVar("foo") will return
// "GTEST_FOO" in the open-source version.
709
710
static std::string FlagToEnvVar(const char* flag) {
  const std::string full_flag =
zhanyong.wan's avatar
zhanyong.wan committed
711
      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
shiqian's avatar
shiqian committed
712
713

  Message env_var;
714
  for (size_t i = 0; i != full_flag.length(); i++) {
715
    env_var << ToUpper(full_flag.c_str()[i]);
shiqian's avatar
shiqian committed
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
  }

  return env_var.GetString();
}

// Parses 'str' for a 32-bit signed integer.  If successful, writes
// the result to *value and returns true; otherwise leaves *value
// unchanged and returns false.
bool ParseInt32(const Message& src_text, const char* str, Int32* value) {
  // Parses the environment variable as a decimal integer.
  char* end = NULL;
  const long long_value = strtol(str, &end, 10);  // NOLINT

  // Has strtol() consumed all characters in the string?
  if (*end != '\0') {
    // No - an invalid character was encountered.
    Message msg;
    msg << "WARNING: " << src_text
        << " is expected to be a 32-bit integer, but actually"
        << " has value \"" << str << "\".\n";
    printf("%s", msg.GetString().c_str());
    fflush(stdout);
    return false;
  }

  // Is the parsed value in the range of an Int32?
  const Int32 result = static_cast<Int32>(long_value);
  if (long_value == LONG_MAX || long_value == LONG_MIN ||
      // The parsed value overflows as a long.  (strtol() returns
      // LONG_MAX or LONG_MIN when the input overflows.)
      result != long_value
      // The parsed value overflows as an Int32.
      ) {
    Message msg;
    msg << "WARNING: " << src_text
        << " is expected to be a 32-bit integer, but actually"
        << " has value " << str << ", which overflows.\n";
    printf("%s", msg.GetString().c_str());
    fflush(stdout);
    return false;
  }

  *value = result;
  return true;
}

762
763
764
765
766
// Reads and returns the Boolean environment variable corresponding to
// the given flag; if it's not set, returns default_value.
//
// The value is considered true iff it's not "0".
bool BoolFromGTestEnv(const char* flag, bool default_value) {
767
  const std::string env_var = FlagToEnvVar(flag);
768
  const char* const string_value = posix::GetEnv(env_var.c_str());
769
770
771
772
  return string_value == NULL ?
      default_value : strcmp(string_value, "0") != 0;
}

shiqian's avatar
shiqian committed
773
774
775
776
// Reads and returns a 32-bit integer stored in the environment
// variable corresponding to the given flag; if it isn't set or
// doesn't represent a valid 32-bit integer, returns default_value.
Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
777
  const std::string env_var = FlagToEnvVar(flag);
778
  const char* const string_value = posix::GetEnv(env_var.c_str());
shiqian's avatar
shiqian committed
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
  if (string_value == NULL) {
    // The environment variable is not set.
    return default_value;
  }

  Int32 result = default_value;
  if (!ParseInt32(Message() << "Environment variable " << env_var,
                  string_value, &result)) {
    printf("The default value %s is used.\n",
           (Message() << default_value).GetString().c_str());
    fflush(stdout);
    return default_value;
  }

  return result;
}

// Reads and returns the string environment variable corresponding to
// the given flag; if it's not set, returns default_value.
const char* StringFromGTestEnv(const char* flag, const char* default_value) {
799
  const std::string env_var = FlagToEnvVar(flag);
800
  const char* const value = posix::GetEnv(env_var.c_str());
shiqian's avatar
shiqian committed
801
802
803
804
805
  return value == NULL ? default_value : value;
}

}  // namespace internal
}  // namespace testing