| #ifdef GOOGLETEST_H__ |
| #error You must not include this file twice. |
| #endif |
| #define GOOGLETEST_H__ |
| |
| #include <ctype.h> |
| #include <setjmp.h> |
| #include <time.h> |
| |
| #include <map> |
| #include <sstream> |
| #include <string> |
| #include <vector> |
| |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| #include <unistd.h> |
| |
| #include "base/commandlineflags.h" |
| |
| using std::map; |
| using std::string; |
| using std::vector; |
| |
| DEFINE_string(test_tmpdir, "/tmp", "Dir we use for temp files"); |
| DEFINE_string(test_srcdir, ".", |
| "Source-dir root, needed to find glog_unittest_flagfile"); |
| DEFINE_int32(benchmark_iters, 100000000, "Number of iterations per benchmark"); |
| |
| _START_GOOGLE_NAMESPACE_ |
| |
| extern void (*g_logging_fail_func)(); |
| |
| // The following is some bare-bones testing infrastructure |
| |
| #define EXPECT_TRUE(cond) \ |
| do { \ |
| if (!(cond)) { \ |
| fprintf(stderr, "Check failed: %s\n", #cond); \ |
| exit(1); \ |
| } \ |
| } while (0) |
| |
| #define EXPECT_FALSE(cond) EXPECT_TRUE(!(cond)) |
| |
| #define EXPECT_OP(op, val1, val2) \ |
| do { \ |
| if (!((val1) op (val2))) { \ |
| fprintf(stderr, "Check failed: %s %s %s\n", #val1, #op, #val2); \ |
| exit(1); \ |
| } \ |
| } while (0) |
| |
| #define EXPECT_EQ(val1, val2) EXPECT_OP(==, val1, val2) |
| #define EXPECT_NE(val1, val2) EXPECT_OP(!=, val1, val2) |
| #define EXPECT_GT(val1, val2) EXPECT_OP(>, val1, val2) |
| #define EXPECT_LT(val1, val2) EXPECT_OP(<, val1, val2) |
| |
| #define EXPECT_NAN(arg) \ |
| do { \ |
| if (!isnan(arg)) { \ |
| fprintf(stderr, "Check failed: isnan(%s)\n", #arg); \ |
| exit(1); \ |
| } \ |
| } while (0) |
| |
| #define EXPECT_INF(arg) \ |
| do { \ |
| if (!isinf(arg)) { \ |
| fprintf(stderr, "Check failed: isinf(%s)\n", #arg); \ |
| exit(1); \ |
| } \ |
| } while (0) |
| |
| #define EXPECT_DOUBLE_EQ(val1, val2) \ |
| do { \ |
| if (((val1) < (val2) - 0.001 || (val1) > (val2) + 0.001)) { \ |
| fprintf(stderr, "Check failed: %s == %s\n", #val1, #val2); \ |
| exit(1); \ |
| } \ |
| } while (0) |
| |
| #define EXPECT_STREQ(val1, val2) \ |
| do { \ |
| if (strcmp((val1), (val2)) != 0) { \ |
| fprintf(stderr, "Check failed: streq(%s, %s)\n", #val1, #val2); \ |
| exit(1); \ |
| } \ |
| } while (0) |
| |
| static bool g_called_abort; |
| static jmp_buf g_jmp_buf; |
| static void CalledAbort() { |
| g_called_abort = true; |
| longjmp(g_jmp_buf, 1); |
| } |
| |
| #define ASSERT_DEATH(fn, msg) \ |
| do { \ |
| g_called_abort = false; \ |
| /* in logging.cc */ \ |
| void (*original_logging_fail_func)() = g_logging_fail_func; \ |
| g_logging_fail_func = &CalledAbort; \ |
| if (!setjmp(g_jmp_buf)) fn; \ |
| /* set back to their default */ \ |
| g_logging_fail_func = original_logging_fail_func; \ |
| if (!g_called_abort) { \ |
| fprintf(stderr, "Function didn't die (%s): %s\n", msg, #fn); \ |
| exit(1); \ |
| } \ |
| } while (0) |
| |
| #ifdef NDEBUG |
| #define ASSERT_DEBUG_DEATH(fn, msg) |
| #else |
| #define ASSERT_DEBUG_DEATH(fn, msg) ASSERT_DEATH(fn, msg) |
| #endif // NDEBUG |
| |
| vector<void (*)()> g_testlist; // the tests to run |
| |
| #define TEST(a, b) \ |
| struct Test_##a##_##b { \ |
| Test_##a##_##b() { g_testlist.push_back(&Run); } \ |
| static void Run() { FlagSaver fs; RunTest(); } \ |
| static void RunTest(); \ |
| }; \ |
| static Test_##a##_##b g_test_##a##_##b; \ |
| void Test_##a##_##b::RunTest() |
| |
| |
| static int RUN_ALL_TESTS() { |
| vector<void (*)()>::const_iterator it; |
| for (it = g_testlist.begin(); it != g_testlist.end(); ++it) { |
| (*it)(); |
| } |
| fprintf(stderr, "Passed %d tests\n\nPASS\n", (int)g_testlist.size()); |
| return 0; |
| } |
| |
| // Benchmark tools. |
| |
| #define BENCHMARK(n) static BenchmarkRegisterer __benchmark_ ## n (#n, &n); |
| |
| map<string, void (*)(int)> g_benchlist; // the benchmarks to run |
| |
| class BenchmarkRegisterer { |
| public: |
| BenchmarkRegisterer(const char* name, void (*function)(int iters)) { |
| EXPECT_TRUE(g_benchlist.insert(std::make_pair(name, function)).second); |
| } |
| }; |
| |
| static void RunSpecifiedBenchmarks() { |
| int iter_cnt = FLAGS_benchmark_iters; |
| puts("Benchmark\tTime(ns)\tIterations"); |
| for (map<string, void (*)(int)>::const_iterator iter = g_benchlist.begin(); |
| iter != g_benchlist.end(); |
| ++iter) { |
| clock_t start = clock(); |
| iter->second(iter_cnt); |
| double elapsed_ns = |
| ((double)clock() - start) / CLOCKS_PER_SEC * 1000*1000*1000; |
| printf("%s\t%8.2lf\t%10d\n", |
| iter->first.c_str(), elapsed_ns / iter_cnt, iter_cnt); |
| } |
| puts(""); |
| } |
| |
| // ---------------------------------------------------------------------- |
| // Golden file functions |
| // ---------------------------------------------------------------------- |
| |
| class CapturedStream { |
| public: |
| CapturedStream(int fd, const string & filename) : |
| fd_(fd), |
| uncaptured_fd_(-1), |
| filename_(filename) { |
| Capture(); |
| } |
| |
| ~CapturedStream() { |
| if (uncaptured_fd_ != -1) { |
| CHECK(close(uncaptured_fd_) != -1); |
| } |
| } |
| |
| // Start redirecting output to a file |
| void Capture() { |
| // Keep original stream for later |
| CHECK(uncaptured_fd_ == -1) << ", Stream " << fd_ << " already captured!"; |
| uncaptured_fd_ = dup(fd_); |
| CHECK(uncaptured_fd_ != -1); |
| |
| // Open file to save stream to |
| int cap_fd = open(filename_.c_str(), |
| O_CREAT | O_TRUNC | O_WRONLY, |
| S_IRUSR | S_IWUSR); |
| CHECK(cap_fd != -1); |
| |
| // Send stdout/stderr to this file |
| fflush(NULL); |
| CHECK(dup2(cap_fd, fd_) != -1); |
| CHECK(close(cap_fd) != -1); |
| } |
| |
| // Remove output redirection |
| void StopCapture() { |
| // Restore original stream |
| if (uncaptured_fd_ != -1) { |
| fflush(NULL); |
| CHECK(dup2(uncaptured_fd_, fd_) != -1); |
| } |
| } |
| |
| const string & filename() const { return filename_; } |
| |
| private: |
| int fd_; // file descriptor being captured |
| int uncaptured_fd_; // where the stream was originally being sent to |
| string filename_; // file where stream is being saved |
| }; |
| static CapturedStream * s_captured_streams[STDERR_FILENO+1]; |
| // Redirect a file descriptor to a file. |
| // fd - Should be STDOUT_FILENO or STDERR_FILENO |
| // filename - File where output should be stored |
| static void CaptureTestOutput(int fd, const string & filename) { |
| CHECK((fd == STDOUT_FILENO) || (fd == STDERR_FILENO)); |
| CHECK(s_captured_streams[fd] == NULL); |
| s_captured_streams[fd] = new CapturedStream(fd, filename); |
| } |
| static void CaptureTestStderr() { |
| CaptureTestOutput(STDERR_FILENO, FLAGS_test_tmpdir + "/captured.err"); |
| } |
| // Return the size (in bytes) of a file |
| static size_t GetFileSize(FILE * file) { |
| fseek(file, 0, SEEK_END); |
| return static_cast<size_t>(ftell(file)); |
| } |
| // Read the entire content of a file as a string |
| static string ReadEntireFile(FILE * file) { |
| 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); |
| |
| // Keep 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); |
| |
| const string content = string(buffer, buffer+bytes_read); |
| delete[] buffer; |
| |
| return content; |
| } |
| // Get the captured stdout (when fd is STDOUT_FILENO) or stderr (when |
| // fd is STDERR_FILENO) as a string |
| static string GetCapturedTestOutput(int fd) { |
| CHECK(fd == STDOUT_FILENO || fd == STDERR_FILENO); |
| CapturedStream * const cap = s_captured_streams[fd]; |
| CHECK(cap) |
| << ": did you forget CaptureTestStdout() or CaptureTestStderr()?"; |
| |
| // Make sure everything is flushed. |
| cap->StopCapture(); |
| |
| // Read the captured file. |
| FILE * const file = fopen(cap->filename().c_str(), "r"); |
| const string content = ReadEntireFile(file); |
| fclose(file); |
| |
| delete cap; |
| s_captured_streams[fd] = NULL; |
| |
| return content; |
| } |
| // Get the captured stderr of a test as a string. |
| static string GetCapturedTestStderr() { |
| return GetCapturedTestOutput(STDERR_FILENO); |
| } |
| |
| // Check if the string is [IWEF](\d{4}|DATE) |
| static bool IsLoggingPrefix(const string& s) { |
| if (s.size() != 5) return false; |
| if (!strchr("IWEF", s[0])) return false; |
| for (int i = 1; i <= 4; ++i) { |
| if (!isdigit(s[i]) && s[i] != "DATE"[i-1]) return false; |
| } |
| return true; |
| } |
| |
| // Convert log output into normalized form. |
| // |
| // Example: |
| // I0102 030405 logging_unittest.cc:345] RAW: vlog -1 |
| // => IDATE TIME__ logging_unittest.cc:LINE] RAW: vlog -1 |
| static string MungeLine(const string& line) { |
| std::istringstream iss(line); |
| string before, logcode_date, time, thread_lineinfo; |
| iss >> logcode_date; |
| while (!IsLoggingPrefix(logcode_date)) { |
| before += " " + logcode_date; |
| if (iss.eof()) { |
| // We cannot find the header of log output. |
| return before; |
| } |
| iss >> logcode_date; |
| } |
| if (!before.empty()) before += " "; |
| iss >> time; |
| CHECK_EQ(6, time.size()); |
| iss >> thread_lineinfo; |
| CHECK(!thread_lineinfo.empty()); |
| if (thread_lineinfo[thread_lineinfo.size() - 1] != ']') { |
| // We found thread ID. |
| string tmp; |
| iss >> tmp; |
| CHECK(!tmp.empty()); |
| CHECK_EQ(']', tmp[tmp.size() - 1]); |
| thread_lineinfo = "THREADID " + tmp; |
| } |
| size_t index = thread_lineinfo.find(':'); |
| CHECK_NE(string::npos, index); |
| thread_lineinfo = thread_lineinfo.substr(0, index+1) + "LINE]"; |
| string rest; |
| std::getline(iss, rest); |
| return (before + logcode_date[0] + "DATE TIME__ " + thread_lineinfo + |
| MungeLine(rest)); |
| } |
| |
| static void StringReplace(string* str, |
| const string& oldsub, |
| const string& newsub) { |
| size_t pos = str->find(oldsub); |
| if (pos != string::npos) { |
| str->replace(pos, oldsub.size(), newsub.c_str()); |
| } |
| } |
| |
| static string Munge(const string& filename) { |
| FILE* fp = fopen(filename.c_str(), "rb"); |
| CHECK(fp != NULL) << filename << ": couldn't open"; |
| char buf[4096]; |
| string result; |
| while (fgets(buf, 4095, fp)) { |
| string line = MungeLine(buf); |
| char null_str[256]; |
| sprintf(null_str, "%p", NULL); |
| StringReplace(&line, "__NULLP__", null_str); |
| |
| char errmsg_buf[100]; |
| posix_strerror_r(0, errmsg_buf, sizeof(errmsg_buf)); |
| if (*errmsg_buf == '\0') { |
| // MacOSX 10.4 and FreeBSD return empty string for errno=0. |
| // In such case, the we need to remove an extra space. |
| StringReplace(&line, "__SUCCESS__ ", ""); |
| } else { |
| StringReplace(&line, "__SUCCESS__", errmsg_buf); |
| } |
| StringReplace(&line, "__ENOENT__", strerror(ENOENT)); |
| StringReplace(&line, "__EINTR__", strerror(EINTR)); |
| StringReplace(&line, "__ENXIO__", strerror(ENXIO)); |
| StringReplace(&line, "__ENOEXEC__", strerror(ENOEXEC)); |
| result += line + "\n"; |
| } |
| fclose(fp); |
| return result; |
| } |
| |
| static void WriteToFile(const string& body, const string& file) { |
| FILE* fp = fopen(file.c_str(), "wb"); |
| fwrite(body.data(), 1, body.size(), fp); |
| fclose(fp); |
| } |
| |
| static bool MungeAndDiffTestStderr(const string& golden_filename) { |
| CapturedStream* cap = s_captured_streams[STDERR_FILENO]; |
| CHECK(cap) << ": did you forget CaptureTestStderr()?"; |
| |
| cap->StopCapture(); |
| |
| // Run munge |
| const string captured = Munge(cap->filename()); |
| const string golden = Munge(golden_filename); |
| if (captured != golden) { |
| fprintf(stderr, |
| "Test with golden file failed. We'll try to show the diff:\n"); |
| string munged_golden = golden_filename + ".munged"; |
| WriteToFile(golden, munged_golden); |
| string munged_captured = cap->filename() + ".munged"; |
| WriteToFile(captured, munged_captured); |
| string diffcmd("diff -u " + munged_golden + " " + munged_captured); |
| if (system(diffcmd.c_str()) != 0) { |
| fprintf(stderr, "diff command was failed.\n"); |
| } |
| unlink(munged_golden.c_str()); |
| unlink(munged_captured.c_str()); |
| return false; |
| } |
| LOG(INFO) << "Diff was successful"; |
| return true; |
| } |
| |
| // Save flags used from logging_unittest.cc. |
| #ifndef HAVE_LIB_GFLAGS |
| struct FlagSaver { |
| FlagSaver() |
| : v_(FLAGS_v), |
| stderrthreshold_(FLAGS_stderrthreshold), |
| logtostderr_(FLAGS_logtostderr), |
| alsologtostderr_(FLAGS_alsologtostderr) {} |
| ~FlagSaver() { |
| FLAGS_v = v_; |
| FLAGS_stderrthreshold = stderrthreshold_; |
| FLAGS_logtostderr = logtostderr_; |
| FLAGS_alsologtostderr = alsologtostderr_; |
| } |
| int v_; |
| int stderrthreshold_; |
| bool logtostderr_; |
| bool alsologtostderr_; |
| }; |
| #endif |
| |
| // TODO(hamaji): Make it portable. |
| class Thread { |
| public: |
| void SetJoinable(bool joinable) {} |
| void Start() { |
| pthread_create(&th_, NULL, &Thread::InvokeThread, this); |
| } |
| void Join() { |
| pthread_join(th_, NULL); |
| } |
| |
| protected: |
| virtual void Run() = 0; |
| |
| private: |
| static void* InvokeThread(void* self) { |
| ((Thread*)self)->Run(); |
| return NULL; |
| } |
| |
| pthread_t th_; |
| }; |
| |
| // TODO(hamaji): Make it portable. |
| static void SleepForMilliseconds(int t) { |
| usleep(t * 1000); |
| } |
| |
| // Add hook for operator new to ensure there are no memory allocation. |
| |
| void (*g_new_hook)() = NULL; |
| |
| _END_GOOGLE_NAMESPACE_ |
| |
| void* operator new(size_t size) { |
| if (GOOGLE_NAMESPACE::g_new_hook) { |
| GOOGLE_NAMESPACE::g_new_hook(); |
| } |
| return malloc(size); |
| } |
| |
| void* operator new[](size_t size) { |
| return ::operator new(size); |
| } |
| |
| void operator delete(void* p) { |
| free(p); |
| } |
| |
| void operator delete[](void* p) { |
| ::operator delete(p); |
| } |
