fixed gcc logging failure

[platform/upstream/glog.git] / src / logging_unittest.cc

diff --git a/src/logging_unittest.cc b/src/logging_unittest.cc
index 0c32823..b8a9a87 100644 (file)
--- a/src/logging_unittest.cc
+++ b/src/logging_unittest.cc
@@ -43,6 +43,7 @@
 
 #include <iomanip>
 #include <iostream>
+#include <memory>
 #include <queue>
 #include <sstream>
 #include <string>
@@ -58,6 +59,11 @@
 
 DECLARE_string(log_backtrace_at);  // logging.cc
 
+#ifdef HAVE_LIB_GFLAGS
+#include <gflags/gflags.h>
+using namespace GFLAGS_NAMESPACE;
+#endif
+
 #ifdef HAVE_LIB_GMOCK
 #include <gmock/gmock.h>
 #include "mock-log.h"
@@ -150,7 +156,8 @@ static void BM_Check2(int n) {
 }
 BENCHMARK(BM_Check2);
 
-static void CheckFailure(int a, int b, const char* file, int line, const char* msg) {
+static void CheckFailure(int, int, const char* /* file */, int /* line */,
+                         const char* /* msg */) {
 }
 
 static void BM_logspeed(int n) {
@@ -168,6 +175,14 @@ static void BM_vlog(int n) {
 BENCHMARK(BM_vlog);
 
 int main(int argc, char **argv) {
+  FLAGS_colorlogtostderr = false;
+#ifdef HAVE_LIB_GFLAGS
+  ParseCommandLineFlags(&argc, &argv, true);
+#endif
+  // Make sure stderr is not buffered as stderr seems to be buffered
+  // on recent windows.
+  setbuf(stderr, NULL);
+
   // Test some basics before InitGoogleLogging:
   CaptureTestStderr();
   LogWithLevels(FLAGS_v, FLAGS_stderrthreshold,
@@ -192,7 +207,7 @@ int main(int argc, char **argv) {
   CaptureTestStderr();
 
   // re-emit early_stderr
-  LogMessage("dummy", LogMessage::kNoLogPrefix, INFO).stream() << early_stderr;
+  LogMessage("dummy", LogMessage::kNoLogPrefix, GLOG_INFO).stream() << early_stderr;
 
   TestLogging(true);
   TestRawLogging();
@@ -218,14 +233,16 @@ int main(int argc, char **argv) {
   TestErrno();
   TestTruncate();
 
+  ShutdownGoogleLogging();
+
   fprintf(stdout, "PASS\n");
   return 0;
 }
 
 void TestLogging(bool check_counts) {
-  int64 base_num_infos   = LogMessage::num_messages(INFO);
-  int64 base_num_warning = LogMessage::num_messages(WARNING);
-  int64 base_num_errors  = LogMessage::num_messages(ERROR);
+  int64 base_num_infos   = LogMessage::num_messages(GLOG_INFO);
+  int64 base_num_warning = LogMessage::num_messages(GLOG_WARNING);
+  int64 base_num_errors  = LogMessage::num_messages(GLOG_ERROR);
 
   LOG(INFO) << string("foo ") << "bar " << 10 << ' ' << 3.4;
   for ( int i = 0; i < 10; ++i ) {
@@ -255,17 +272,24 @@ void TestLogging(bool check_counts) {
   LOG(ERROR) << string("foo") << ' '<< j << ' ' << setw(10) << j << " "
              << setw(1) << hex << j;
 
-  LogMessage("foo", LogMessage::kNoLogPrefix, INFO).stream() << "no prefix";
+  {
+    google::LogMessage outer(__FILE__, __LINE__, google::ERROR);
+    outer.stream() << "outer";
+
+    LOG(ERROR) << "inner";
+  }
+
+  LogMessage("foo", LogMessage::kNoLogPrefix, GLOG_INFO).stream() << "no prefix";
 
   if (check_counts) {
-    CHECK_EQ(base_num_infos   + 14, LogMessage::num_messages(INFO));
-    CHECK_EQ(base_num_warning + 3,  LogMessage::num_messages(WARNING));
-    CHECK_EQ(base_num_errors  + 15, LogMessage::num_messages(ERROR));
+    CHECK_EQ(base_num_infos   + 14, LogMessage::num_messages(GLOG_INFO));
+    CHECK_EQ(base_num_warning + 3,  LogMessage::num_messages(GLOG_WARNING));
+    CHECK_EQ(base_num_errors  + 17, LogMessage::num_messages(GLOG_ERROR));
   }
 }
 
 static void NoAllocNewHook() {
-  CHECK(false) << "unexpected new";
+  LOG(FATAL) << "unexpected new";
 }
 
 struct NewHook {
@@ -405,16 +429,16 @@ void LogWithLevels(int v, int severity, bool err, bool alsoerr) {
 }
 
 void TestLoggingLevels() {
-  LogWithLevels(0, INFO, false, false);
-  LogWithLevels(1, INFO, false, false);
-  LogWithLevels(-1, INFO, false, false);
-  LogWithLevels(0, WARNING, false, false);
-  LogWithLevels(0, ERROR, false, false);
-  LogWithLevels(0, FATAL, false, false);
-  LogWithLevels(0, FATAL, true, false);
-  LogWithLevels(0, FATAL, false, true);
-  LogWithLevels(1, WARNING, false, false);
-  LogWithLevels(1, FATAL, false, true);
+  LogWithLevels(0, GLOG_INFO, false, false);
+  LogWithLevels(1, GLOG_INFO, false, false);
+  LogWithLevels(-1, GLOG_INFO, false, false);
+  LogWithLevels(0, GLOG_WARNING, false, false);
+  LogWithLevels(0, GLOG_ERROR, false, false);
+  LogWithLevels(0, GLOG_FATAL, false, false);
+  LogWithLevels(0, GLOG_FATAL, true, false);
+  LogWithLevels(0, GLOG_FATAL, false, true);
+  LogWithLevels(1, GLOG_WARNING, false, false);
+  LogWithLevels(1, GLOG_FATAL, false, true);
 }
 
 TEST(DeathRawCHECK, logging) {
@@ -460,7 +484,7 @@ void TestLogToString() {
 class TestLogSinkImpl : public LogSink {
  public:
   vector<string> errors;
-  virtual void send(LogSeverity severity, const char* full_filename,
+  virtual void send(LogSeverity severity, const char* /* full_filename */,
                     const char* base_filename, int line,
                     const struct tm* tm_time,
                     const char* message, size_t message_len) {
@@ -497,7 +521,7 @@ void TestLogSink() {
 
   LOG(INFO) << "Captured by LOG_TO_SINK:";
   for (size_t i = 0; i < sink.errors.size(); ++i) {
-    LogMessage("foo", LogMessage::kNoLogPrefix, INFO).stream()
+    LogMessage("foo", LogMessage::kNoLogPrefix, GLOG_INFO).stream()
       << sink.errors[i];
   }
 }
@@ -547,6 +571,10 @@ void TestDCHECK() {
   DCHECK_LE(1, 2);
   DCHECK_GT(2, 1);
   DCHECK_LT(1, 2);
+
+  auto_ptr<int64> sptr(new int64);
+  int64* ptr = DCHECK_NOTNULL(sptr.get());
+  CHECK_EQ(ptr, sptr.get());
 }
 
 void TestSTREQ() {
@@ -578,10 +606,10 @@ TEST(CheckNOTNULL, Simple) {
   void *ptr = static_cast<void *>(&t);
   void *ref = CHECK_NOTNULL(ptr);
   EXPECT_EQ(ptr, ref);
-  CHECK_NOTNULL(reinterpret_cast<char *>(&t));
-  CHECK_NOTNULL(reinterpret_cast<unsigned char *>(&t));
-  CHECK_NOTNULL(reinterpret_cast<int *>(&t));
-  CHECK_NOTNULL(reinterpret_cast<int64 *>(&t));
+  CHECK_NOTNULL(reinterpret_cast<char *>(ptr));
+  CHECK_NOTNULL(reinterpret_cast<unsigned char *>(ptr));
+  CHECK_NOTNULL(reinterpret_cast<int *>(ptr));
+  CHECK_NOTNULL(reinterpret_cast<int64 *>(ptr));
 }
 
 TEST(DeathCheckNN, Simple) {
@@ -595,7 +623,7 @@ static void GetFiles(const string& pattern, vector<string>* files) {
   glob_t g;
   const int r = glob(pattern.c_str(), 0, NULL, &g);
   CHECK((r == 0) || (r == GLOB_NOMATCH)) << ": error matching " << pattern;
-  for (int i = 0; i < g.gl_pathc; i++) {
+  for (size_t i = 0; i < g.gl_pathc; i++) {
     files->push_back(string(g.gl_pathv[i]));
   }
   globfree(&g);
@@ -607,14 +635,15 @@ static void GetFiles(const string& pattern, vector<string>* files) {
     LOG(FATAL) << "No directory separator.";
   }
   const string dirname = pattern.substr(0, index + 1);
-  if (FAILED(handle)) {
+  if (handle == INVALID_HANDLE_VALUE) {
     // Finding no files is OK.
     return;
   }
   do {
     files->push_back(dirname + data.cFileName);
   } while (FindNextFileA(handle, &data));
-  LOG_SYSRESULT(FindClose(handle));
+  BOOL result = FindClose(handle);
+  LOG_SYSRESULT(result);
 #else
 # error There is no way to do glob.
 #endif
@@ -632,7 +661,7 @@ static void DeleteFiles(const string& pattern) {
 static void CheckFile(const string& name, const string& expected_string) {
   vector<string> files;
   GetFiles(name + "*", &files);
-  CHECK_EQ(files.size(), 1);
+  CHECK_EQ(files.size(), 1UL);
 
   FILE* file = fopen(files[0].c_str(), "r");
   CHECK(file != NULL) << ": could not open " << files[0];
@@ -652,9 +681,9 @@ static void TestBasename() {
   const string dest = FLAGS_test_tmpdir + "/logging_test_basename";
   DeleteFiles(dest + "*");
 
-  SetLogDestination(INFO, dest.c_str());
+  SetLogDestination(GLOG_INFO, dest.c_str());
   LOG(INFO) << "message to new base";
-  FlushLogFiles(INFO);
+  FlushLogFiles(GLOG_INFO);
 
   CheckFile(dest, "message to new base");
 
@@ -671,10 +700,10 @@ static void TestSymlink() {
   DeleteFiles(dest + "*");
   DeleteFiles(sym + "*");
 
-  SetLogSymlink(INFO, "symlinkbase");
-  SetLogDestination(INFO, dest.c_str());
+  SetLogSymlink(GLOG_INFO, "symlinkbase");
+  SetLogDestination(GLOG_INFO, dest.c_str());
   LOG(INFO) << "message to new symlink";
-  FlushLogFiles(INFO);
+  FlushLogFiles(GLOG_INFO);
   CheckFile(sym, "message to new symlink");
 
   DeleteFiles(dest + "*");
@@ -687,16 +716,16 @@ static void TestExtension() {
   string dest = FLAGS_test_tmpdir + "/logging_test_extension";
   DeleteFiles(dest + "*");
 
-  SetLogDestination(INFO, dest.c_str());
+  SetLogDestination(GLOG_INFO, dest.c_str());
   SetLogFilenameExtension("specialextension");
   LOG(INFO) << "message to new extension";
-  FlushLogFiles(INFO);
+  FlushLogFiles(GLOG_INFO);
   CheckFile(dest, "message to new extension");
 
   // Check that file name ends with extension
   vector<string> filenames;
   GetFiles(dest + "*", &filenames);
-  CHECK_EQ(filenames.size(), 1);
+  CHECK_EQ(filenames.size(), 1UL);
   CHECK(strstr(filenames[0].c_str(), "specialextension") != NULL);
 
   // Release file handle for the destination file to unlock the file in Windows.
@@ -707,8 +736,8 @@ static void TestExtension() {
 struct MyLogger : public base::Logger {
   string data;
 
-  virtual void Write(bool should_flush,
-                     time_t timestamp,
+  virtual void Write(bool /* should_flush */,
+                     time_t /* timestamp */,
                      const char* message,
                      int length) {
     data.append(message, length);
@@ -723,11 +752,11 @@ static void TestWrapper() {
   fprintf(stderr, "==== Test log wrapper\n");
 
   MyLogger my_logger;
-  base::Logger* old_logger = base::GetLogger(INFO);
-  base::SetLogger(INFO, &my_logger);
+  base::Logger* old_logger = base::GetLogger(GLOG_INFO);
+  base::SetLogger(GLOG_INFO, &my_logger);
   LOG(INFO) << "Send to wrapped logger";
-  FlushLogFiles(INFO);
-  base::SetLogger(INFO, old_logger);
+  FlushLogFiles(GLOG_INFO);
+  base::SetLogger(GLOG_INFO, old_logger);
 
   CHECK(strstr(my_logger.data.c_str(), "Send to wrapped logger") != NULL);
 }
@@ -770,9 +799,9 @@ static void TestOneTruncate(const char *path, int64 limit, int64 keep,
   CHECK_ERR(lseek(fd, 0, SEEK_SET));
 
   // File should contain the suffix of the original file
-  int buf_size = statbuf.st_size + 1;
+  const size_t buf_size = statbuf.st_size + 1;
   char* buf = new char[buf_size];
-  memset(buf, 0, sizeof(buf));
+  memset(buf, 0, buf_size);
   CHECK_ERR(read(fd, buf, buf_size));
 
   const char *p = buf;
@@ -976,7 +1005,7 @@ class TestWaitingLogSink : public LogSink {
 
   // (re)define LogSink interface
 
-  virtual void send(LogSeverity severity, const char* full_filename,
+  virtual void send(LogSeverity severity, const char* /* full_filename */,
                     const char* base_filename, int line,
                     const struct tm* tm_time,
                     const char* message, size_t message_len) {
@@ -1015,20 +1044,20 @@ static void TestLogSinkWaitTillSent() {
   for (size_t i = 0; i < global_messages.size(); ++i) {
     LOG(INFO) << "Sink capture: " << global_messages[i];
   }
-  CHECK_EQ(global_messages.size(), 3);
+  CHECK_EQ(global_messages.size(), 3UL);
 }
 
 TEST(Strerror, logging) {
   int errcode = EINTR;
   char *msg = strdup(strerror(errcode));
-  int buf_size = strlen(msg) + 1;
+  const size_t buf_size = strlen(msg) + 1;
   char *buf = new char[buf_size];
   CHECK_EQ(posix_strerror_r(errcode, NULL, 0), -1);
   buf[0] = 'A';
   CHECK_EQ(posix_strerror_r(errcode, buf, 0), -1);
   CHECK_EQ(buf[0], 'A');
   CHECK_EQ(posix_strerror_r(errcode, NULL, buf_size), -1);
-#if defined(OS_MACOSX) || defined(OS_FREEBSD)
+#if defined(OS_MACOSX) || defined(OS_FREEBSD) || defined(OS_OPENBSD)
   // MacOSX or FreeBSD considers this case is an error since there is
   // no enough space.
   CHECK_EQ(posix_strerror_r(errcode, buf, 1), -1);
@@ -1038,8 +1067,9 @@ TEST(Strerror, logging) {
   CHECK_STREQ(buf, "");
   CHECK_EQ(posix_strerror_r(errcode, buf, buf_size), 0);
   CHECK_STREQ(buf, msg);
-  free(msg);
   delete[] buf;
+  CHECK_EQ(msg, StrError(errcode));
+  free(msg);
 }
 
 // Simple routines to look at the sizes of generated code for LOG(FATAL) and
@@ -1120,10 +1150,12 @@ TEST(TestExitOnDFatal, ToBeOrNotToBe) {
   base::internal::SetExitOnDFatal(true);
   EXPECT_TRUE(base::internal::GetExitOnDFatal());
 
+#ifdef GTEST_HAS_DEATH_TEST
   // Death comes on little cats' feet.
   EXPECT_DEBUG_DEATH({
       LOG(DFATAL) << "This should be fatal in debug mode";
     }, "This should be fatal in debug mode");
+#endif
 }
 
 #ifdef HAVE_STACKTRACE
@@ -1173,10 +1205,10 @@ TEST(LogBacktraceAt, DoesBacktraceAtRightLineWhenEnabled) {
 #endif // HAVE_LIB_GMOCK
 
 struct UserDefinedClass {
-  bool operator==(const UserDefinedClass& rhs) const { return true; }
+  bool operator==(const UserDefinedClass&) const { return true; }
 };
 
-inline ostream& operator<<(ostream& out, const UserDefinedClass& u) {
+inline ostream& operator<<(ostream& out, const UserDefinedClass&) {
   out << "OK";
   return out;
 }
@@ -1185,7 +1217,7 @@ TEST(UserDefinedClass, logging) {
   UserDefinedClass u;
   vector<string> buf;
   LOG_STRING(INFO, &buf) << u;
-  CHECK_EQ(1, buf.size());
+  CHECK_EQ(1UL, buf.size());
   CHECK(buf[0].find("OK") != string::npos);
 
   // We must be able to compile this.