1 // Copyright (c) 2007, Google Inc. 2 // All rights reserved. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are 6 // met: 7 // 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 13 // distribution. 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. 17 // 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. 29 // 30 // Author: Zhanyong Wan 31 // 32 // Defines the ScopedMockLog class (using Google C++ Mocking 33 // Framework), which is convenient for testing code that uses LOG(). 34 // 35 // NOTE(keir): This is a fork until Google Log exports the scoped mock log 36 // class; see: http://code.google.com/p/google-glog/issues/detail?id=88 37 38 #ifndef GOOGLE_CERES_INTERNAL_MOCK_LOG_H_ 39 #define GOOGLE_CERES_INTERNAL_MOCK_LOG_H_ 40 41 #include <string> 42 43 #include <gmock/gmock.h> 44 45 #include "glog/logging.h" 46 47 // Needed to make the scoped mock log tests work without modification. 48 namespace ceres { 49 namespace internal { 50 using google::WARNING; 51 } // namespace internal 52 } // namespace ceres 53 54 namespace testing { 55 56 // A ScopedMockLog object intercepts LOG() messages issued during its 57 // lifespan. Using this together with Google C++ Mocking Framework, 58 // it's very easy to test how a piece of code calls LOG(). The 59 // typical usage: 60 // 61 // TEST(FooTest, LogsCorrectly) { 62 // ScopedMockLog log; 63 // 64 // // We expect the WARNING "Something bad!" exactly twice. 65 // EXPECT_CALL(log, Log(WARNING, _, "Something bad!")) 66 // .Times(2); 67 // 68 // // We allow foo.cc to call LOG(INFO) any number of times. 69 // EXPECT_CALL(log, Log(INFO, HasSubstr("/foo.cc"), _)) 70 // .Times(AnyNumber()); 71 // 72 // Foo(); // Exercises the code under test. 73 // } 74 class ScopedMockLog : public google::LogSink { 75 public: 76 // When a ScopedMockLog object is constructed, it starts to 77 // intercept logs. ScopedMockLog()78 ScopedMockLog() { AddLogSink(this); } 79 80 // When the object is destructed, it stops intercepting logs. ~ScopedMockLog()81 virtual ~ScopedMockLog() { RemoveLogSink(this); } 82 83 // Implements the mock method: 84 // 85 // void Log(LogSeverity severity, const string& file_path, 86 // const string& message); 87 // 88 // The second argument to Send() is the full path of the source file 89 // in which the LOG() was issued. 90 // 91 // Note, that in a multi-threaded environment, all LOG() messages from a 92 // single thread will be handled in sequence, but that cannot be guaranteed 93 // for messages from different threads. In fact, if the same or multiple 94 // expectations are matched on two threads concurrently, their actions will 95 // be executed concurrently as well and may interleave. 96 MOCK_METHOD3(Log, void(google::LogSeverity severity, 97 const std::string& file_path, 98 const std::string& message)); 99 100 private: 101 // Implements the send() virtual function in class LogSink. 102 // Whenever a LOG() statement is executed, this function will be 103 // invoked with information presented in the LOG(). 104 // 105 // The method argument list is long and carries much information a 106 // test usually doesn't care about, so we trim the list before 107 // forwarding the call to Log(), which is much easier to use in 108 // tests. 109 // 110 // We still cannot call Log() directly, as it may invoke other LOG() 111 // messages, either due to Invoke, or due to an error logged in 112 // Google C++ Mocking Framework code, which would trigger a deadlock 113 // since a lock is held during send(). 114 // 115 // Hence, we save the message for WaitTillSent() which will be called after 116 // the lock on send() is released, and we'll call Log() inside 117 // WaitTillSent(). Since while a single send() call may be running at a 118 // time, multiple WaitTillSent() calls (along with the one send() call) may 119 // be running simultaneously, we ensure thread-safety of the exchange between 120 // send() and WaitTillSent(), and that for each message, LOG(), send(), 121 // WaitTillSent() and Log() are executed in the same thread. send(google::LogSeverity severity,const char * full_filename,const char * base_filename,int line,const tm * tm_time,const char * message,size_t message_len)122 virtual void send(google::LogSeverity severity, 123 const char* full_filename, 124 const char* base_filename, int line, const tm* tm_time, 125 const char* message, size_t message_len) { 126 // We are only interested in the log severity, full file name, and 127 // log message. 128 message_info_.severity = severity; 129 message_info_.file_path = full_filename; 130 message_info_.message = std::string(message, message_len); 131 } 132 133 // Implements the WaitTillSent() virtual function in class LogSink. 134 // It will be executed after send() and after the global logging lock is 135 // released, so calls within it (or rather within the Log() method called 136 // within) may also issue LOG() statements. 137 // 138 // LOG(), send(), WaitTillSent() and Log() will occur in the same thread for 139 // a given log message. WaitTillSent()140 virtual void WaitTillSent() { 141 // First, and very importantly, we save a copy of the message being 142 // processed before calling Log(), since Log() may indirectly call send() 143 // and WaitTillSent() in the same thread again. 144 MessageInfo message_info = message_info_; 145 Log(message_info.severity, message_info.file_path, message_info.message); 146 } 147 148 // All relevant information about a logged message that needs to be passed 149 // from send() to WaitTillSent(). 150 struct MessageInfo { 151 google::LogSeverity severity; 152 std::string file_path; 153 std::string message; 154 }; 155 MessageInfo message_info_; 156 }; 157 158 } // namespace testing 159 160 #endif // GOOGLE_CERES_INTERNAL_MOCK_LOG_H_ 161