#include <iomanip>
#include <iostream>
+#include <memory>
#include <queue>
#include <sstream>
#include <string>
#ifdef HAVE_LIB_GFLAGS
#include <gflags/gflags.h>
+using namespace GFLAGS_NAMESPACE;
#endif
#ifdef HAVE_LIB_GMOCK
}
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) {
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();
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();
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 ) {
LOG(ERROR) << string("foo") << ' '<< j << ' ' << setw(10) << j << " "
<< setw(1) << hex << j;
- LogMessage("foo", LogMessage::kNoLogPrefix, INFO).stream() << "no prefix";
+ 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 + 15, LogMessage::num_messages(GLOG_ERROR));
}
}
}
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) {
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) {
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];
}
}
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() {
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);
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
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];
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");
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 + "*");
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.
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);
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);
}
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;
// (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) {
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_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
#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;
}
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.