internal/ceres/gmock/mock-log.h

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