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