1 // Copyright (c) 2002, Google Inc.
2 // All rights reserved.
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
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
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.
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.
32 #include "config_for_unittests.h"
33 #include "utilities.h"
55 #include "base/commandlineflags.h"
56 #include "glog/logging.h"
57 #include "glog/raw_logging.h"
58 #include "googletest.h"
60 DECLARE_string(log_backtrace_at); // logging.cc
62 #ifdef HAVE_LIB_GFLAGS
63 #include <gflags/gflags.h>
64 using namespace GFLAGS_NAMESPACE;
68 #include <gmock/gmock.h>
70 // Introduce several symbols from gmock.
72 using testing::AnyNumber;
73 using testing::HasSubstr;
76 using testing::StrictMock;
77 using testing::InitGoogleMock;
78 using GOOGLE_NAMESPACE::glog_testing::ScopedMockLog;
82 using namespace GOOGLE_NAMESPACE;
84 // Some non-advertised functions that we want to test or use.
85 _START_GOOGLE_NAMESPACE_
88 bool GetExitOnDFatal();
89 void SetExitOnDFatal(bool value);
90 } // namespace internal
92 _END_GOOGLE_NAMESPACE_
94 static void TestLogging(bool check_counts);
95 static void TestRawLogging();
96 static void LogWithLevels(int v, int severity, bool err, bool alsoerr);
97 static void TestLoggingLevels();
98 static void TestLogString();
99 static void TestLogSink();
100 static void TestLogToString();
101 static void TestLogSinkWaitTillSent();
102 static void TestCHECK();
103 static void TestDCHECK();
104 static void TestSTREQ();
105 static void TestBasename();
106 static void TestSymlink();
107 static void TestExtension();
108 static void TestWrapper();
109 static void TestErrno();
110 static void TestTruncate();
113 static void BM_Check1(int n) {
125 BENCHMARK(BM_Check1);
127 static void CheckFailure(int a, int b, const char* file, int line, const char* msg);
128 static void BM_Check3(int n) {
130 if (n < x) CheckFailure(n, x, __FILE__, __LINE__, "n < x");
131 if (n < x) CheckFailure(n, x, __FILE__, __LINE__, "n < x");
132 if (n < x) CheckFailure(n, x, __FILE__, __LINE__, "n < x");
133 if (n < x) CheckFailure(n, x, __FILE__, __LINE__, "n < x");
134 if (n < x) CheckFailure(n, x, __FILE__, __LINE__, "n < x");
135 if (n < x) CheckFailure(n, x, __FILE__, __LINE__, "n < x");
136 if (n < x) CheckFailure(n, x, __FILE__, __LINE__, "n < x");
137 if (n < x) CheckFailure(n, x, __FILE__, __LINE__, "n < x");
140 BENCHMARK(BM_Check3);
142 static void BM_Check2(int n) {
157 BENCHMARK(BM_Check2);
159 static void CheckFailure(int, int, const char* /* file */, int /* line */,
160 const char* /* msg */) {
163 static void BM_logspeed(int n) {
165 LOG(INFO) << "test message";
168 BENCHMARK(BM_logspeed);
170 static void BM_vlog(int n) {
172 VLOG(1) << "test message";
177 int main(int argc, char **argv) {
178 FLAGS_colorlogtostderr = false;
179 #ifdef HAVE_LIB_GFLAGS
180 ParseCommandLineFlags(&argc, &argv, true);
182 // Make sure stderr is not buffered as stderr seems to be buffered
183 // on recent windows.
184 setbuf(stderr, NULL);
186 // Test some basics before InitGoogleLogging:
188 LogWithLevels(FLAGS_v, FLAGS_stderrthreshold,
189 FLAGS_logtostderr, FLAGS_alsologtostderr);
190 LogWithLevels(0, 0, 0, 0); // simulate "before global c-tors"
191 const string early_stderr = GetCapturedTestStderr();
193 InitGoogleLogging(argv[0]);
195 RunSpecifiedBenchmarks();
197 FLAGS_logtostderr = true;
199 InitGoogleTest(&argc, argv);
200 #ifdef HAVE_LIB_GMOCK
201 InitGoogleMock(&argc, argv);
204 // so that death tests run before we use threads
205 CHECK_EQ(RUN_ALL_TESTS(), 0);
209 // re-emit early_stderr
210 LogMessage("dummy", LogMessage::kNoLogPrefix, GLOG_INFO).stream() << early_stderr;
218 TestLogSinkWaitTillSent();
223 // TODO: The golden test portion of this test is very flakey.
225 MungeAndDiffTestStderr(FLAGS_test_srcdir + "/src/logging_unittest.err"));
227 FLAGS_logtostderr = false;
236 ShutdownGoogleLogging();
238 fprintf(stdout, "PASS\n");
242 void TestLogging(bool check_counts) {
243 int64 base_num_infos = LogMessage::num_messages(GLOG_INFO);
244 int64 base_num_warning = LogMessage::num_messages(GLOG_WARNING);
245 int64 base_num_errors = LogMessage::num_messages(GLOG_ERROR);
247 LOG(INFO) << string("foo ") << "bar " << 10 << ' ' << 3.4;
248 for ( int i = 0; i < 10; ++i ) {
249 int old_errno = errno;
251 PLOG_EVERY_N(ERROR, 2) << "Plog every 2, iteration " << COUNTER;
254 LOG_EVERY_N(ERROR, 3) << "Log every 3, iteration " << COUNTER << endl;
255 LOG_EVERY_N(ERROR, 4) << "Log every 4, iteration " << COUNTER << endl;
257 LOG_IF_EVERY_N(WARNING, true, 5) << "Log if every 5, iteration " << COUNTER;
258 LOG_IF_EVERY_N(WARNING, false, 3)
259 << "Log if every 3, iteration " << COUNTER;
260 LOG_IF_EVERY_N(INFO, true, 1) << "Log if every 1, iteration " << COUNTER;
261 LOG_IF_EVERY_N(ERROR, (i < 3), 2)
262 << "Log if less than 3 every 2, iteration " << COUNTER;
264 LOG_IF(WARNING, true) << "log_if this";
265 LOG_IF(WARNING, false) << "don't log_if this";
269 const char const_s[] = "const array";
270 LOG(INFO) << const_s;
272 LOG(ERROR) << string("foo") << ' '<< j << ' ' << setw(10) << j << " "
273 << setw(1) << hex << j;
275 LOG(ERROR) << (&LOG(ERROR) && 0) << " nested LOG";
277 LogMessage("foo", LogMessage::kNoLogPrefix, GLOG_INFO).stream() << "no prefix";
280 CHECK_EQ(base_num_infos + 14, LogMessage::num_messages(GLOG_INFO));
281 CHECK_EQ(base_num_warning + 3, LogMessage::num_messages(GLOG_WARNING));
282 CHECK_EQ(base_num_errors + 17, LogMessage::num_messages(GLOG_ERROR));
286 static void NoAllocNewHook() {
287 LOG(FATAL) << "unexpected new";
292 g_new_hook = &NoAllocNewHook;
299 TEST(DeathNoAllocNewHook, logging) {
300 // tests that NewHook used below works
304 }, "unexpected new");
307 void TestRawLogging() {
308 string* foo = new string("foo ");
309 string huge_str(50000, 'a');
313 // Check that RAW loggging does not use mallocs.
316 RAW_LOG(INFO, "%s%s%d%c%f", foo->c_str(), "bar ", 10, ' ', 3.4);
318 RAW_LOG(WARNING, "%s", s);
319 const char const_s[] = "const array";
320 RAW_LOG(INFO, "%s", const_s);
321 void* p = reinterpret_cast<void*>(0x12345678);
322 RAW_LOG(INFO, "ptr %p", p);
324 RAW_LOG(INFO, "ptr %p", p);
326 RAW_LOG(ERROR, "%s%d%c%010d%s%1x", foo->c_str(), j, ' ', j, " ", j);
327 RAW_VLOG(0, "foo %d", j);
330 RAW_LOG(INFO, "foo %d", j); // so that have same stderr to compare
332 RAW_DLOG(INFO, "foo %d", j); // test RAW_DLOG in debug mode
335 // test how long messages are chopped:
336 RAW_LOG(WARNING, "Huge string: %s", huge_str.c_str());
337 RAW_VLOG(0, "Huge string: %s", huge_str.c_str());
340 RAW_LOG(INFO, "log");
341 RAW_VLOG(0, "vlog 0 on");
342 RAW_VLOG(1, "vlog 1 off");
343 RAW_VLOG(2, "vlog 2 off");
344 RAW_VLOG(3, "vlog 3 off");
346 RAW_LOG(INFO, "log");
347 RAW_VLOG(1, "vlog 1 on");
348 RAW_VLOG(2, "vlog 2 on");
349 RAW_VLOG(3, "vlog 3 off");
352 RAW_DCHECK(1 == 2, " RAW_DCHECK's shouldn't be compiled in normal mode");
355 RAW_CHECK(1 == 1, "should be ok");
356 RAW_DCHECK(true, "should be ok");
361 void LogWithLevels(int v, int severity, bool err, bool alsoerr) {
363 "Test: v=%d stderrthreshold=%d logtostderr=%d alsologtostderr=%d",
364 v, severity, err, alsoerr);
369 FLAGS_stderrthreshold = severity;
370 FLAGS_logtostderr = err;
371 FLAGS_alsologtostderr = alsoerr;
373 RAW_VLOG(-1, "vlog -1");
374 RAW_VLOG(0, "vlog 0");
375 RAW_VLOG(1, "vlog 1");
376 RAW_LOG(INFO, "log info");
377 RAW_LOG(WARNING, "log warning");
378 RAW_LOG(ERROR, "log error");
380 VLOG(-1) << "vlog -1";
383 LOG(INFO) << "log info";
384 LOG(WARNING) << "log warning";
385 LOG(ERROR) << "log error";
387 VLOG_IF(-1, true) << "vlog_if -1";
388 VLOG_IF(-1, false) << "don't vlog_if -1";
389 VLOG_IF(0, true) << "vlog_if 0";
390 VLOG_IF(0, false) << "don't vlog_if 0";
391 VLOG_IF(1, true) << "vlog_if 1";
392 VLOG_IF(1, false) << "don't vlog_if 1";
393 LOG_IF(INFO, true) << "log_if info";
394 LOG_IF(INFO, false) << "don't log_if info";
395 LOG_IF(WARNING, true) << "log_if warning";
396 LOG_IF(WARNING, false) << "don't log_if warning";
397 LOG_IF(ERROR, true) << "log_if error";
398 LOG_IF(ERROR, false) << "don't log_if error";
401 c = 1; VLOG_IF(100, c -= 2) << "vlog_if 100 expr"; EXPECT_EQ(c, -1);
402 c = 1; VLOG_IF(0, c -= 2) << "vlog_if 0 expr"; EXPECT_EQ(c, -1);
403 c = 1; LOG_IF(INFO, c -= 2) << "log_if info expr"; EXPECT_EQ(c, -1);
404 c = 1; LOG_IF(ERROR, c -= 2) << "log_if error expr"; EXPECT_EQ(c, -1);
405 c = 2; VLOG_IF(0, c -= 2) << "don't vlog_if 0 expr"; EXPECT_EQ(c, 0);
406 c = 2; LOG_IF(ERROR, c -= 2) << "don't log_if error expr"; EXPECT_EQ(c, 0);
408 c = 3; LOG_IF_EVERY_N(INFO, c -= 4, 1) << "log_if info every 1 expr";
410 c = 3; LOG_IF_EVERY_N(ERROR, c -= 4, 1) << "log_if error every 1 expr";
412 c = 4; LOG_IF_EVERY_N(ERROR, c -= 4, 3) << "don't log_if info every 3 expr";
414 c = 4; LOG_IF_EVERY_N(ERROR, c -= 4, 3) << "don't log_if error every 3 expr";
416 c = 5; VLOG_IF_EVERY_N(0, c -= 4, 1) << "vlog_if 0 every 1 expr";
418 c = 5; VLOG_IF_EVERY_N(100, c -= 4, 3) << "vlog_if 100 every 3 expr";
420 c = 6; VLOG_IF_EVERY_N(0, c -= 6, 1) << "don't vlog_if 0 every 1 expr";
422 c = 6; VLOG_IF_EVERY_N(100, c -= 6, 3) << "don't vlog_if 100 every 1 expr";
426 void TestLoggingLevels() {
427 LogWithLevels(0, GLOG_INFO, false, false);
428 LogWithLevels(1, GLOG_INFO, false, false);
429 LogWithLevels(-1, GLOG_INFO, false, false);
430 LogWithLevels(0, GLOG_WARNING, false, false);
431 LogWithLevels(0, GLOG_ERROR, false, false);
432 LogWithLevels(0, GLOG_FATAL, false, false);
433 LogWithLevels(0, GLOG_FATAL, true, false);
434 LogWithLevels(0, GLOG_FATAL, false, true);
435 LogWithLevels(1, GLOG_WARNING, false, false);
436 LogWithLevels(1, GLOG_FATAL, false, true);
439 TEST(DeathRawCHECK, logging) {
440 ASSERT_DEATH(RAW_CHECK(false, "failure 1"),
441 "RAW: Check false failed: failure 1");
442 ASSERT_DEBUG_DEATH(RAW_DCHECK(1 == 2, "failure 2"),
443 "RAW: Check 1 == 2 failed: failure 2");
446 void TestLogString() {
447 vector<string> errors;
448 vector<string> *no_errors = NULL;
450 LOG_STRING(INFO, &errors) << "LOG_STRING: " << "collected info";
451 LOG_STRING(WARNING, &errors) << "LOG_STRING: " << "collected warning";
452 LOG_STRING(ERROR, &errors) << "LOG_STRING: " << "collected error";
454 LOG_STRING(INFO, no_errors) << "LOG_STRING: " << "reported info";
455 LOG_STRING(WARNING, no_errors) << "LOG_STRING: " << "reported warning";
456 LOG_STRING(ERROR, NULL) << "LOG_STRING: " << "reported error";
458 for (size_t i = 0; i < errors.size(); ++i) {
459 LOG(INFO) << "Captured by LOG_STRING: " << errors[i];
463 void TestLogToString() {
465 string* no_error = NULL;
467 LOG_TO_STRING(INFO, &error) << "LOG_TO_STRING: " << "collected info";
468 LOG(INFO) << "Captured by LOG_TO_STRING: " << error;
469 LOG_TO_STRING(WARNING, &error) << "LOG_TO_STRING: " << "collected warning";
470 LOG(INFO) << "Captured by LOG_TO_STRING: " << error;
471 LOG_TO_STRING(ERROR, &error) << "LOG_TO_STRING: " << "collected error";
472 LOG(INFO) << "Captured by LOG_TO_STRING: " << error;
474 LOG_TO_STRING(INFO, no_error) << "LOG_TO_STRING: " << "reported info";
475 LOG_TO_STRING(WARNING, no_error) << "LOG_TO_STRING: " << "reported warning";
476 LOG_TO_STRING(ERROR, NULL) << "LOG_TO_STRING: " << "reported error";
479 class TestLogSinkImpl : public LogSink {
481 vector<string> errors;
482 virtual void send(LogSeverity severity, const char* /* full_filename */,
483 const char* base_filename, int line,
484 const struct tm* tm_time,
485 const char* message, size_t message_len) {
487 ToString(severity, base_filename, line, tm_time, message, message_len));
492 TestLogSinkImpl sink;
493 LogSink *no_sink = NULL;
495 LOG_TO_SINK(&sink, INFO) << "LOG_TO_SINK: " << "collected info";
496 LOG_TO_SINK(&sink, WARNING) << "LOG_TO_SINK: " << "collected warning";
497 LOG_TO_SINK(&sink, ERROR) << "LOG_TO_SINK: " << "collected error";
499 LOG_TO_SINK(no_sink, INFO) << "LOG_TO_SINK: " << "reported info";
500 LOG_TO_SINK(no_sink, WARNING) << "LOG_TO_SINK: " << "reported warning";
501 LOG_TO_SINK(NULL, ERROR) << "LOG_TO_SINK: " << "reported error";
503 LOG_TO_SINK_BUT_NOT_TO_LOGFILE(&sink, INFO)
504 << "LOG_TO_SINK_BUT_NOT_TO_LOGFILE: " << "collected info";
505 LOG_TO_SINK_BUT_NOT_TO_LOGFILE(&sink, WARNING)
506 << "LOG_TO_SINK_BUT_NOT_TO_LOGFILE: " << "collected warning";
507 LOG_TO_SINK_BUT_NOT_TO_LOGFILE(&sink, ERROR)
508 << "LOG_TO_SINK_BUT_NOT_TO_LOGFILE: " << "collected error";
510 LOG_TO_SINK_BUT_NOT_TO_LOGFILE(no_sink, INFO)
511 << "LOG_TO_SINK_BUT_NOT_TO_LOGFILE: " << "thrashed info";
512 LOG_TO_SINK_BUT_NOT_TO_LOGFILE(no_sink, WARNING)
513 << "LOG_TO_SINK_BUT_NOT_TO_LOGFILE: " << "thrashed warning";
514 LOG_TO_SINK_BUT_NOT_TO_LOGFILE(NULL, ERROR)
515 << "LOG_TO_SINK_BUT_NOT_TO_LOGFILE: " << "thrashed error";
517 LOG(INFO) << "Captured by LOG_TO_SINK:";
518 for (size_t i = 0; i < sink.errors.size(); ++i) {
519 LogMessage("foo", LogMessage::kNoLogPrefix, GLOG_INFO).stream()
524 // For testing using CHECK*() on anonymous enums.
531 // Tests using CHECK*() on int values.
542 // Tests using CHECK*() on anonymous enums.
543 // Apple's GCC doesn't like this.
544 #if !defined(OS_MACOSX)
545 CHECK_EQ(CASE_A, CASE_A);
546 CHECK_NE(CASE_A, CASE_B);
547 CHECK_GE(CASE_A, CASE_A);
548 CHECK_GE(CASE_B, CASE_A);
549 CHECK_LE(CASE_A, CASE_A);
550 CHECK_LE(CASE_A, CASE_B);
551 CHECK_GT(CASE_B, CASE_A);
552 CHECK_LT(CASE_A, CASE_B);
558 DCHECK( 1 == 2 ) << " DCHECK's shouldn't be compiled in normal mode";
570 auto_ptr<int64> sptr(new int64);
571 int64* ptr = DCHECK_NOTNULL(sptr.get());
572 CHECK_EQ(ptr, sptr.get());
576 CHECK_STREQ("this", "this");
577 CHECK_STREQ(NULL, NULL);
578 CHECK_STRCASEEQ("this", "tHiS");
579 CHECK_STRCASEEQ(NULL, NULL);
580 CHECK_STRNE("this", "tHiS");
581 CHECK_STRNE("this", NULL);
582 CHECK_STRCASENE("this", "that");
583 CHECK_STRCASENE(NULL, "that");
584 CHECK_STREQ((string("a")+"b").c_str(), "ab");
585 CHECK_STREQ(string("test").c_str(),
586 (string("te") + string("st")).c_str());
589 TEST(DeathSTREQ, logging) {
590 ASSERT_DEATH(CHECK_STREQ(NULL, "this"), "");
591 ASSERT_DEATH(CHECK_STREQ("this", "siht"), "");
592 ASSERT_DEATH(CHECK_STRCASEEQ(NULL, "siht"), "");
593 ASSERT_DEATH(CHECK_STRCASEEQ("this", "siht"), "");
594 ASSERT_DEATH(CHECK_STRNE(NULL, NULL), "");
595 ASSERT_DEATH(CHECK_STRNE("this", "this"), "");
596 ASSERT_DEATH(CHECK_STREQ((string("a")+"b").c_str(), "abc"), "");
599 TEST(CheckNOTNULL, Simple) {
601 void *ptr = static_cast<void *>(&t);
602 void *ref = CHECK_NOTNULL(ptr);
604 CHECK_NOTNULL(reinterpret_cast<char *>(ptr));
605 CHECK_NOTNULL(reinterpret_cast<unsigned char *>(ptr));
606 CHECK_NOTNULL(reinterpret_cast<int *>(ptr));
607 CHECK_NOTNULL(reinterpret_cast<int64 *>(ptr));
610 TEST(DeathCheckNN, Simple) {
611 ASSERT_DEATH(CHECK_NOTNULL(static_cast<void *>(NULL)), "");
614 // Get list of file names that match pattern
615 static void GetFiles(const string& pattern, vector<string>* files) {
617 #if defined(HAVE_GLOB_H)
619 const int r = glob(pattern.c_str(), 0, NULL, &g);
620 CHECK((r == 0) || (r == GLOB_NOMATCH)) << ": error matching " << pattern;
621 for (size_t i = 0; i < g.gl_pathc; i++) {
622 files->push_back(string(g.gl_pathv[i]));
625 #elif defined(OS_WINDOWS)
626 WIN32_FIND_DATAA data;
627 HANDLE handle = FindFirstFileA(pattern.c_str(), &data);
628 size_t index = pattern.rfind('\\');
629 if (index == string::npos) {
630 LOG(FATAL) << "No directory separator.";
632 const string dirname = pattern.substr(0, index + 1);
633 if (handle == INVALID_HANDLE_VALUE) {
634 // Finding no files is OK.
638 files->push_back(dirname + data.cFileName);
639 } while (FindNextFileA(handle, &data));
640 BOOL result = FindClose(handle);
641 LOG_SYSRESULT(result);
643 # error There is no way to do glob.
647 // Delete files patching pattern
648 static void DeleteFiles(const string& pattern) {
649 vector<string> files;
650 GetFiles(pattern, &files);
651 for (size_t i = 0; i < files.size(); i++) {
652 CHECK(unlink(files[i].c_str()) == 0) << ": " << strerror(errno);
656 static void CheckFile(const string& name, const string& expected_string) {
657 vector<string> files;
658 GetFiles(name + "*", &files);
659 CHECK_EQ(files.size(), 1UL);
661 FILE* file = fopen(files[0].c_str(), "r");
662 CHECK(file != NULL) << ": could not open " << files[0];
664 while (fgets(buf, sizeof(buf), file) != NULL) {
665 if (strstr(buf, expected_string.c_str()) != NULL) {
671 LOG(FATAL) << "Did not find " << expected_string << " in " << files[0];
674 static void TestBasename() {
675 fprintf(stderr, "==== Test setting log file basename\n");
676 const string dest = FLAGS_test_tmpdir + "/logging_test_basename";
677 DeleteFiles(dest + "*");
679 SetLogDestination(GLOG_INFO, dest.c_str());
680 LOG(INFO) << "message to new base";
681 FlushLogFiles(GLOG_INFO);
683 CheckFile(dest, "message to new base");
685 // Release file handle for the destination file to unlock the file in Windows.
687 DeleteFiles(dest + "*");
690 static void TestSymlink() {
692 fprintf(stderr, "==== Test setting log file symlink\n");
693 string dest = FLAGS_test_tmpdir + "/logging_test_symlink";
694 string sym = FLAGS_test_tmpdir + "/symlinkbase";
695 DeleteFiles(dest + "*");
696 DeleteFiles(sym + "*");
698 SetLogSymlink(GLOG_INFO, "symlinkbase");
699 SetLogDestination(GLOG_INFO, dest.c_str());
700 LOG(INFO) << "message to new symlink";
701 FlushLogFiles(GLOG_INFO);
702 CheckFile(sym, "message to new symlink");
704 DeleteFiles(dest + "*");
705 DeleteFiles(sym + "*");
709 static void TestExtension() {
710 fprintf(stderr, "==== Test setting log file extension\n");
711 string dest = FLAGS_test_tmpdir + "/logging_test_extension";
712 DeleteFiles(dest + "*");
714 SetLogDestination(GLOG_INFO, dest.c_str());
715 SetLogFilenameExtension("specialextension");
716 LOG(INFO) << "message to new extension";
717 FlushLogFiles(GLOG_INFO);
718 CheckFile(dest, "message to new extension");
720 // Check that file name ends with extension
721 vector<string> filenames;
722 GetFiles(dest + "*", &filenames);
723 CHECK_EQ(filenames.size(), 1UL);
724 CHECK(strstr(filenames[0].c_str(), "specialextension") != NULL);
726 // Release file handle for the destination file to unlock the file in Windows.
728 DeleteFiles(dest + "*");
731 struct MyLogger : public base::Logger {
734 virtual void Write(bool /* should_flush */,
735 time_t /* timestamp */,
738 data.append(message, length);
741 virtual void Flush() { }
743 virtual uint32 LogSize() { return data.length(); }
746 static void TestWrapper() {
747 fprintf(stderr, "==== Test log wrapper\n");
750 base::Logger* old_logger = base::GetLogger(GLOG_INFO);
751 base::SetLogger(GLOG_INFO, &my_logger);
752 LOG(INFO) << "Send to wrapped logger";
753 FlushLogFiles(GLOG_INFO);
754 base::SetLogger(GLOG_INFO, old_logger);
756 CHECK(strstr(my_logger.data.c_str(), "Send to wrapped logger") != NULL);
759 static void TestErrno() {
760 fprintf(stderr, "==== Test errno preservation\n");
764 CHECK_EQ(errno, ENOENT);
767 static void TestOneTruncate(const char *path, int64 limit, int64 keep,
768 int64 dsize, int64 ksize, int64 expect) {
770 CHECK_ERR(fd = open(path, O_RDWR | O_CREAT | O_TRUNC, 0600));
772 const char *discardstr = "DISCARDME!", *keepstr = "KEEPME!";
774 // Fill the file with the requested data; first discard data, then kept data
776 while (written < dsize) {
777 int bytes = min<int64>(dsize - written, strlen(discardstr));
778 CHECK_ERR(write(fd, discardstr, bytes));
782 while (written < ksize) {
783 int bytes = min<int64>(ksize - written, strlen(keepstr));
784 CHECK_ERR(write(fd, keepstr, bytes));
788 TruncateLogFile(path, limit, keep);
790 // File should now be shorter
792 CHECK_ERR(fstat(fd, &statbuf));
793 CHECK_EQ(statbuf.st_size, expect);
794 CHECK_ERR(lseek(fd, 0, SEEK_SET));
796 // File should contain the suffix of the original file
797 const size_t buf_size = statbuf.st_size + 1;
798 char* buf = new char[buf_size];
799 memset(buf, 0, buf_size);
800 CHECK_ERR(read(fd, buf, buf_size));
804 while (checked < expect) {
805 int bytes = min<int64>(expect - checked, strlen(keepstr));
806 CHECK(!memcmp(p, keepstr, bytes));
813 static void TestTruncate() {
815 fprintf(stderr, "==== Test log truncation\n");
816 string path = FLAGS_test_tmpdir + "/truncatefile";
818 // Test on a small file
819 TestOneTruncate(path.c_str(), 10, 10, 10, 10, 10);
821 // And a big file (multiple blocks to copy)
822 TestOneTruncate(path.c_str(), 2<<20, 4<<10, 3<<20, 4<<10, 4<<10);
824 // Check edge-case limits
825 TestOneTruncate(path.c_str(), 10, 20, 0, 20, 20);
826 TestOneTruncate(path.c_str(), 10, 0, 0, 0, 0);
827 TestOneTruncate(path.c_str(), 10, 50, 0, 10, 10);
828 TestOneTruncate(path.c_str(), 50, 100, 0, 30, 30);
830 // MacOSX 10.4 doesn't fail in this case.
831 // Windows doesn't have symlink.
832 // Let's just ignore this test for these cases.
833 #if !defined(OS_MACOSX) && !defined(OS_WINDOWS)
834 // Through a symlink should fail to truncate
835 string linkname = path + ".link";
836 unlink(linkname.c_str());
837 CHECK_ERR(symlink(path.c_str(), linkname.c_str()));
838 TestOneTruncate(linkname.c_str(), 10, 10, 0, 30, 30);
841 // The /proc/self path makes sense only for linux.
842 #if defined(OS_LINUX)
843 // Through an open fd symlink should work
845 CHECK_ERR(fd = open(path.c_str(), O_APPEND | O_WRONLY));
847 snprintf(fdpath, sizeof(fdpath), "/proc/self/fd/%d", fd);
848 TestOneTruncate(fdpath, 10, 10, 10, 10, 10);
854 _START_GOOGLE_NAMESPACE_
855 namespace glog_internal_namespace_ {
856 extern // in logging.cc
857 bool SafeFNMatch_(const char* pattern, size_t patt_len,
858 const char* str, size_t str_len);
859 } // namespace glog_internal_namespace_
860 using glog_internal_namespace_::SafeFNMatch_;
861 _END_GOOGLE_NAMESPACE_
863 static bool WrapSafeFNMatch(string pattern, string str) {
866 return SafeFNMatch_(pattern.data(), pattern.size() - 3,
867 str.data(), str.size() - 5);
870 TEST(SafeFNMatch, logging) {
871 CHECK(WrapSafeFNMatch("foo", "foo"));
872 CHECK(!WrapSafeFNMatch("foo", "bar"));
873 CHECK(!WrapSafeFNMatch("foo", "fo"));
874 CHECK(!WrapSafeFNMatch("foo", "foo2"));
875 CHECK(WrapSafeFNMatch("bar/foo.ext", "bar/foo.ext"));
876 CHECK(WrapSafeFNMatch("*ba*r/fo*o.ext*", "bar/foo.ext"));
877 CHECK(!WrapSafeFNMatch("bar/foo.ext", "bar/baz.ext"));
878 CHECK(!WrapSafeFNMatch("bar/foo.ext", "bar/foo"));
879 CHECK(!WrapSafeFNMatch("bar/foo.ext", "bar/foo.ext.zip"));
880 CHECK(WrapSafeFNMatch("ba?/*.ext", "bar/foo.ext"));
881 CHECK(WrapSafeFNMatch("ba?/*.ext", "baZ/FOO.ext"));
882 CHECK(!WrapSafeFNMatch("ba?/*.ext", "barr/foo.ext"));
883 CHECK(!WrapSafeFNMatch("ba?/*.ext", "bar/foo.ext2"));
884 CHECK(WrapSafeFNMatch("ba?/*", "bar/foo.ext2"));
885 CHECK(WrapSafeFNMatch("ba?/*", "bar/"));
886 CHECK(!WrapSafeFNMatch("ba?/?", "bar/"));
887 CHECK(!WrapSafeFNMatch("ba?/*", "bar"));
890 // TestWaitingLogSink will save messages here
891 // No lock: Accessed only by TestLogSinkWriter thread
892 // and after its demise by its creator.
893 static vector<string> global_messages;
895 // helper for TestWaitingLogSink below.
896 // Thread that does the logic of TestWaitingLogSink
897 // It's free to use LOG() itself.
898 class TestLogSinkWriter : public Thread {
901 TestLogSinkWriter() : should_exit_(false) {
906 // Just buffer it (can't use LOG() here).
907 void Buffer(const string& message) {
909 RAW_LOG(INFO, "Buffering");
910 messages_.push(message);
912 RAW_LOG(INFO, "Buffered");
915 // Wait for the buffer to clear (can't use LOG() here).
917 RAW_LOG(INFO, "Waiting");
921 SleepForMilliseconds(1);
924 RAW_LOG(INFO, "Waited");
928 // Trigger thread exit.
930 MutexLock l(&mutex_);
936 // helpers ---------------
938 // For creating a "Condition".
939 bool NoWork() { return messages_.empty(); }
940 bool HaveWork() { return !messages_.empty() || should_exit_; }
942 // Thread body; CAN use LOG() here!
946 while (!HaveWork()) {
948 SleepForMilliseconds(1);
951 if (should_exit_ && messages_.empty()) {
955 // Give the main thread time to log its message,
956 // so that we get a reliable log capture to compare to golden file.
957 // Same for the other sleep below.
958 SleepForMilliseconds(20);
959 RAW_LOG(INFO, "Sink got a messages"); // only RAW_LOG under mutex_ here
960 string message = messages_.front();
962 // Normally this would be some more real/involved logging logic
963 // where LOG() usage can't be eliminated,
964 // e.g. pushing the message over with an RPC:
965 int messages_left = messages_.size();
967 SleepForMilliseconds(20);
968 // May not use LOG while holding mutex_, because Buffer()
969 // acquires mutex_, and Buffer is called from LOG(),
970 // which has its own internal mutex:
971 // LOG()->LogToSinks()->TestWaitingLogSink::send()->Buffer()
972 LOG(INFO) << "Sink is sending out a message: " << message;
973 LOG(INFO) << "Have " << messages_left << " left";
974 global_messages.push_back(message);
978 // data ---------------
982 queue<string> messages_; // messages to be logged
985 // A log sink that exercises WaitTillSent:
986 // it pushes data to a buffer and wakes up another thread to do the logging
987 // (that other thread can than use LOG() itself),
988 class TestWaitingLogSink : public LogSink {
991 TestWaitingLogSink() {
992 tid_ = pthread_self(); // for thread-specific behavior
995 ~TestWaitingLogSink() {
1001 // (re)define LogSink interface
1003 virtual void send(LogSeverity severity, const char* /* full_filename */,
1004 const char* base_filename, int line,
1005 const struct tm* tm_time,
1006 const char* message, size_t message_len) {
1007 // Push it to Writer thread if we are the original logging thread.
1008 // Note: Something like ThreadLocalLogSink is a better choice
1009 // to do thread-specific LogSink logic for real.
1010 if (pthread_equal(tid_, pthread_self())) {
1011 writer_.Buffer(ToString(severity, base_filename, line,
1012 tm_time, message, message_len));
1015 virtual void WaitTillSent() {
1016 // Wait for Writer thread if we are the original logging thread.
1017 if (pthread_equal(tid_, pthread_self())) writer_.Wait();
1023 TestLogSinkWriter writer_;
1026 // Check that LogSink::WaitTillSent can be used in the advertised way.
1027 // We also do golden-stderr comparison.
1028 static void TestLogSinkWaitTillSent() {
1029 { TestWaitingLogSink sink;
1030 // Sleeps give the sink threads time to do all their work,
1031 // so that we get a reliable log capture to compare to the golden file.
1032 LOG(INFO) << "Message 1";
1033 SleepForMilliseconds(60);
1034 LOG(ERROR) << "Message 2";
1035 SleepForMilliseconds(60);
1036 LOG(WARNING) << "Message 3";
1037 SleepForMilliseconds(60);
1039 for (size_t i = 0; i < global_messages.size(); ++i) {
1040 LOG(INFO) << "Sink capture: " << global_messages[i];
1042 CHECK_EQ(global_messages.size(), 3UL);
1045 TEST(Strerror, logging) {
1046 int errcode = EINTR;
1047 char *msg = strdup(strerror(errcode));
1048 const size_t buf_size = strlen(msg) + 1;
1049 char *buf = new char[buf_size];
1050 CHECK_EQ(posix_strerror_r(errcode, NULL, 0), -1);
1052 CHECK_EQ(posix_strerror_r(errcode, buf, 0), -1);
1053 CHECK_EQ(buf[0], 'A');
1054 CHECK_EQ(posix_strerror_r(errcode, NULL, buf_size), -1);
1055 #if defined(OS_MACOSX) || defined(OS_FREEBSD) || defined(OS_OPENBSD)
1056 // MacOSX or FreeBSD considers this case is an error since there is
1058 CHECK_EQ(posix_strerror_r(errcode, buf, 1), -1);
1060 CHECK_EQ(posix_strerror_r(errcode, buf, 1), 0);
1062 CHECK_STREQ(buf, "");
1063 CHECK_EQ(posix_strerror_r(errcode, buf, buf_size), 0);
1064 CHECK_STREQ(buf, msg);
1066 CHECK_EQ(msg, StrError(errcode));
1070 // Simple routines to look at the sizes of generated code for LOG(FATAL) and
1071 // CHECK(..) via objdump
1073 LOG(FATAL) << "Failed";
1075 void MyCheck(bool a, bool b) {
1079 #ifdef HAVE_LIB_GMOCK
1081 TEST(DVLog, Basic) {
1085 // We are expecting that nothing is logged.
1086 EXPECT_CALL(log, Log(_, _, _)).Times(0);
1088 EXPECT_CALL(log, Log(INFO, __FILE__, "debug log"));
1092 DVLOG(1) << "debug log";
1098 // We are expecting that nothing is logged.
1099 EXPECT_CALL(log, Log(_, _, _)).Times(0);
1102 DVLOG(1) << "debug log";
1105 TEST(LogAtLevel, Basic) {
1108 // The function version outputs "logging.h" as a file name.
1109 EXPECT_CALL(log, Log(WARNING, StrNe(__FILE__), "function version"));
1110 EXPECT_CALL(log, Log(INFO, __FILE__, "macro version"));
1112 int severity = WARNING;
1113 LogAtLevel(severity, "function version");
1116 // We can use the macro version as a C++ stream.
1117 LOG_AT_LEVEL(severity) << "macro" << ' ' << "version";
1120 TEST(TestExitOnDFatal, ToBeOrNotToBe) {
1121 // Check the default setting...
1122 EXPECT_TRUE(base::internal::GetExitOnDFatal());
1125 base::internal::SetExitOnDFatal(false);
1126 EXPECT_FALSE(base::internal::GetExitOnDFatal());
1131 //EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
1132 // LOG(DFATAL) has severity FATAL if debugging, but is
1133 // downgraded to ERROR if not debugging.
1134 const LogSeverity severity =
1140 EXPECT_CALL(log, Log(severity, __FILE__, "This should not be fatal"));
1141 LOG(DFATAL) << "This should not be fatal";
1145 base::internal::SetExitOnDFatal(true);
1146 EXPECT_TRUE(base::internal::GetExitOnDFatal());
1148 #ifdef GTEST_HAS_DEATH_TEST
1149 // Death comes on little cats' feet.
1150 EXPECT_DEBUG_DEATH({
1151 LOG(DFATAL) << "This should be fatal in debug mode";
1152 }, "This should be fatal in debug mode");
1156 #ifdef HAVE_STACKTRACE
1158 static void BacktraceAtHelper() {
1159 LOG(INFO) << "Not me";
1161 // The vertical spacing of the next 3 lines is significant.
1162 LOG(INFO) << "Backtrace me";
1164 static int kBacktraceAtLine = __LINE__ - 2; // The line of the LOG(INFO) above
1166 TEST(LogBacktraceAt, DoesNotBacktraceWhenDisabled) {
1167 StrictMock<ScopedMockLog> log;
1169 FLAGS_log_backtrace_at = "";
1171 EXPECT_CALL(log, Log(_, _, "Backtrace me"));
1172 EXPECT_CALL(log, Log(_, _, "Not me"));
1174 BacktraceAtHelper();
1177 TEST(LogBacktraceAt, DoesBacktraceAtRightLineWhenEnabled) {
1178 StrictMock<ScopedMockLog> log;
1181 snprintf(where, 100, "%s:%d", const_basename(__FILE__), kBacktraceAtLine);
1182 FLAGS_log_backtrace_at = where;
1184 // The LOG at the specified line should include a stacktrace which includes
1185 // the name of the containing function, followed by the log message.
1186 // We use HasSubstr()s instead of ContainsRegex() for environments
1187 // which don't have regexp.
1188 EXPECT_CALL(log, Log(_, _, AllOf(HasSubstr("stacktrace:"),
1189 HasSubstr("BacktraceAtHelper"),
1191 HasSubstr("Backtrace me"))));
1192 // Other LOGs should not include a backtrace.
1193 EXPECT_CALL(log, Log(_, _, "Not me"));
1195 BacktraceAtHelper();
1198 #endif // HAVE_STACKTRACE
1200 #endif // HAVE_LIB_GMOCK
1202 struct UserDefinedClass {
1203 bool operator==(const UserDefinedClass&) const { return true; }
1206 inline ostream& operator<<(ostream& out, const UserDefinedClass&) {
1211 TEST(UserDefinedClass, logging) {
1214 LOG_STRING(INFO, &buf) << u;
1215 CHECK_EQ(1UL, buf.size());
1216 CHECK(buf[0].find("OK") != string::npos);
1218 // We must be able to compile this.