1// Copyright 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: wan@google.com (Zhanyong Wan)
31
32// Google Mock - a framework for writing C++ mock classes.
33//
34// This file tests the internal utilities.
35
36#include "gmock/internal/gmock-internal-utils.h"
37#include <stdlib.h>
38#include <map>
39#include <memory>
40#include <string>
41#include <sstream>
42#include <vector>
43#include "gmock/gmock.h"
44#include "gmock/internal/gmock-port.h"
45#include "gtest/gtest.h"
46#include "gtest/gtest-spi.h"
47
48// Indicates that this translation unit is part of Google Test's
49// implementation.  It must come before gtest-internal-inl.h is
50// included, or there will be a compiler error.  This trick is to
51// prevent a user from accidentally including gtest-internal-inl.h in
52// his code.
53#define GTEST_IMPLEMENTATION_ 1
54#include "src/gtest-internal-inl.h"
55#undef GTEST_IMPLEMENTATION_
56
57#if GTEST_OS_CYGWIN
58# include <sys/types.h>  // For ssize_t. NOLINT
59#endif
60
61class ProtocolMessage;
62
63namespace proto2 {
64class Message;
65}  // namespace proto2
66
67namespace testing {
68namespace internal {
69
70namespace {
71
72TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsNoWord) {
73  EXPECT_EQ("", ConvertIdentifierNameToWords(""));
74  EXPECT_EQ("", ConvertIdentifierNameToWords("_"));
75  EXPECT_EQ("", ConvertIdentifierNameToWords("__"));
76}
77
78TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsDigits) {
79  EXPECT_EQ("1", ConvertIdentifierNameToWords("_1"));
80  EXPECT_EQ("2", ConvertIdentifierNameToWords("2_"));
81  EXPECT_EQ("34", ConvertIdentifierNameToWords("_34_"));
82  EXPECT_EQ("34 56", ConvertIdentifierNameToWords("_34_56"));
83}
84
85TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsCamelCaseWords) {
86  EXPECT_EQ("a big word", ConvertIdentifierNameToWords("ABigWord"));
87  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("FooBar"));
88  EXPECT_EQ("foo", ConvertIdentifierNameToWords("Foo_"));
89  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_Foo_Bar_"));
90  EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_Foo__And_Bar"));
91}
92
93TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContains_SeparatedWords) {
94  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("foo_bar"));
95  EXPECT_EQ("foo", ConvertIdentifierNameToWords("_foo_"));
96  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_foo_bar_"));
97  EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_foo__and_bar"));
98}
99
100TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameIsMixture) {
101  EXPECT_EQ("foo bar 123", ConvertIdentifierNameToWords("Foo_bar123"));
102  EXPECT_EQ("chapter 11 section 1",
103            ConvertIdentifierNameToWords("_Chapter11Section_1_"));
104}
105
106TEST(PointeeOfTest, WorksForSmartPointers) {
107  CompileAssertTypesEqual<const char,
108      PointeeOf<internal::linked_ptr<const char> >::type>();
109#if GTEST_HAS_STD_UNIQUE_PTR_
110  CompileAssertTypesEqual<int, PointeeOf<std::unique_ptr<int> >::type>();
111#endif  // GTEST_HAS_STD_UNIQUE_PTR_
112#if GTEST_HAS_STD_SHARED_PTR_
113  CompileAssertTypesEqual<std::string,
114                          PointeeOf<std::shared_ptr<std::string> >::type>();
115#endif  // GTEST_HAS_STD_SHARED_PTR_
116}
117
118TEST(PointeeOfTest, WorksForRawPointers) {
119  CompileAssertTypesEqual<int, PointeeOf<int*>::type>();
120  CompileAssertTypesEqual<const char, PointeeOf<const char*>::type>();
121  CompileAssertTypesEqual<void, PointeeOf<void*>::type>();
122}
123
124TEST(GetRawPointerTest, WorksForSmartPointers) {
125#if GTEST_HAS_STD_UNIQUE_PTR_
126  const char* const raw_p1 = new const char('a');  // NOLINT
127  const std::unique_ptr<const char> p1(raw_p1);
128  EXPECT_EQ(raw_p1, GetRawPointer(p1));
129#endif  // GTEST_HAS_STD_UNIQUE_PTR_
130#if GTEST_HAS_STD_SHARED_PTR_
131  double* const raw_p2 = new double(2.5);  // NOLINT
132  const std::shared_ptr<double> p2(raw_p2);
133  EXPECT_EQ(raw_p2, GetRawPointer(p2));
134#endif  // GTEST_HAS_STD_SHARED_PTR_
135
136  const char* const raw_p4 = new const char('a');  // NOLINT
137  const internal::linked_ptr<const char> p4(raw_p4);
138  EXPECT_EQ(raw_p4, GetRawPointer(p4));
139}
140
141TEST(GetRawPointerTest, WorksForRawPointers) {
142  int* p = NULL;
143  // Don't use EXPECT_EQ as no NULL-testing magic on Symbian.
144  EXPECT_TRUE(NULL == GetRawPointer(p));
145  int n = 1;
146  EXPECT_EQ(&n, GetRawPointer(&n));
147}
148
149// Tests KindOf<T>.
150
151class Base {};
152class Derived : public Base {};
153
154TEST(KindOfTest, Bool) {
155  EXPECT_EQ(kBool, GMOCK_KIND_OF_(bool));  // NOLINT
156}
157
158TEST(KindOfTest, Integer) {
159  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(char));  // NOLINT
160  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(signed char));  // NOLINT
161  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned char));  // NOLINT
162  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(short));  // NOLINT
163  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned short));  // NOLINT
164  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(int));  // NOLINT
165  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned int));  // NOLINT
166  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(long));  // NOLINT
167  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long));  // NOLINT
168  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(wchar_t));  // NOLINT
169  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(Int64));  // NOLINT
170  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(UInt64));  // NOLINT
171  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(size_t));  // NOLINT
172#if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN
173  // ssize_t is not defined on Windows and possibly some other OSes.
174  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(ssize_t));  // NOLINT
175#endif
176}
177
178TEST(KindOfTest, FloatingPoint) {
179  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(float));  // NOLINT
180  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(double));  // NOLINT
181  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(long double));  // NOLINT
182}
183
184TEST(KindOfTest, Other) {
185  EXPECT_EQ(kOther, GMOCK_KIND_OF_(void*));  // NOLINT
186  EXPECT_EQ(kOther, GMOCK_KIND_OF_(char**));  // NOLINT
187  EXPECT_EQ(kOther, GMOCK_KIND_OF_(Base));  // NOLINT
188}
189
190// Tests LosslessArithmeticConvertible<T, U>.
191
192TEST(LosslessArithmeticConvertibleTest, BoolToBool) {
193  EXPECT_TRUE((LosslessArithmeticConvertible<bool, bool>::value));
194}
195
196TEST(LosslessArithmeticConvertibleTest, BoolToInteger) {
197  EXPECT_TRUE((LosslessArithmeticConvertible<bool, char>::value));
198  EXPECT_TRUE((LosslessArithmeticConvertible<bool, int>::value));
199  EXPECT_TRUE(
200      (LosslessArithmeticConvertible<bool, unsigned long>::value));  // NOLINT
201}
202
203TEST(LosslessArithmeticConvertibleTest, BoolToFloatingPoint) {
204  EXPECT_TRUE((LosslessArithmeticConvertible<bool, float>::value));
205  EXPECT_TRUE((LosslessArithmeticConvertible<bool, double>::value));
206}
207
208TEST(LosslessArithmeticConvertibleTest, IntegerToBool) {
209  EXPECT_FALSE((LosslessArithmeticConvertible<unsigned char, bool>::value));
210  EXPECT_FALSE((LosslessArithmeticConvertible<int, bool>::value));
211}
212
213TEST(LosslessArithmeticConvertibleTest, IntegerToInteger) {
214  // Unsigned => larger signed is fine.
215  EXPECT_TRUE((LosslessArithmeticConvertible<unsigned char, int>::value));
216
217  // Unsigned => larger unsigned is fine.
218  EXPECT_TRUE(
219      (LosslessArithmeticConvertible<unsigned short, UInt64>::value)); // NOLINT
220
221  // Signed => unsigned is not fine.
222  EXPECT_FALSE((LosslessArithmeticConvertible<short, UInt64>::value)); // NOLINT
223  EXPECT_FALSE((LosslessArithmeticConvertible<
224      signed char, unsigned int>::value));  // NOLINT
225
226  // Same size and same signedness: fine too.
227  EXPECT_TRUE((LosslessArithmeticConvertible<
228               unsigned char, unsigned char>::value));
229  EXPECT_TRUE((LosslessArithmeticConvertible<int, int>::value));
230  EXPECT_TRUE((LosslessArithmeticConvertible<wchar_t, wchar_t>::value));
231  EXPECT_TRUE((LosslessArithmeticConvertible<
232               unsigned long, unsigned long>::value));  // NOLINT
233
234  // Same size, different signedness: not fine.
235  EXPECT_FALSE((LosslessArithmeticConvertible<
236                unsigned char, signed char>::value));
237  EXPECT_FALSE((LosslessArithmeticConvertible<int, unsigned int>::value));
238  EXPECT_FALSE((LosslessArithmeticConvertible<UInt64, Int64>::value));
239
240  // Larger size => smaller size is not fine.
241  EXPECT_FALSE((LosslessArithmeticConvertible<long, char>::value));  // NOLINT
242  EXPECT_FALSE((LosslessArithmeticConvertible<int, signed char>::value));
243  EXPECT_FALSE((LosslessArithmeticConvertible<Int64, unsigned int>::value));
244}
245
246TEST(LosslessArithmeticConvertibleTest, IntegerToFloatingPoint) {
247  // Integers cannot be losslessly converted to floating-points, as
248  // the format of the latter is implementation-defined.
249  EXPECT_FALSE((LosslessArithmeticConvertible<char, float>::value));
250  EXPECT_FALSE((LosslessArithmeticConvertible<int, double>::value));
251  EXPECT_FALSE((LosslessArithmeticConvertible<
252                short, long double>::value));  // NOLINT
253}
254
255TEST(LosslessArithmeticConvertibleTest, FloatingPointToBool) {
256  EXPECT_FALSE((LosslessArithmeticConvertible<float, bool>::value));
257  EXPECT_FALSE((LosslessArithmeticConvertible<double, bool>::value));
258}
259
260TEST(LosslessArithmeticConvertibleTest, FloatingPointToInteger) {
261  EXPECT_FALSE((LosslessArithmeticConvertible<float, long>::value));  // NOLINT
262  EXPECT_FALSE((LosslessArithmeticConvertible<double, Int64>::value));
263  EXPECT_FALSE((LosslessArithmeticConvertible<long double, int>::value));
264}
265
266TEST(LosslessArithmeticConvertibleTest, FloatingPointToFloatingPoint) {
267  // Smaller size => larger size is fine.
268  EXPECT_TRUE((LosslessArithmeticConvertible<float, double>::value));
269  EXPECT_TRUE((LosslessArithmeticConvertible<float, long double>::value));
270  EXPECT_TRUE((LosslessArithmeticConvertible<double, long double>::value));
271
272  // Same size: fine.
273  EXPECT_TRUE((LosslessArithmeticConvertible<float, float>::value));
274  EXPECT_TRUE((LosslessArithmeticConvertible<double, double>::value));
275
276  // Larger size => smaller size is not fine.
277  EXPECT_FALSE((LosslessArithmeticConvertible<double, float>::value));
278  GTEST_INTENTIONAL_CONST_COND_PUSH_()
279  if (sizeof(double) == sizeof(long double)) {  // NOLINT
280  GTEST_INTENTIONAL_CONST_COND_POP_()
281    // In some implementations (e.g. MSVC), double and long double
282    // have the same size.
283    EXPECT_TRUE((LosslessArithmeticConvertible<long double, double>::value));
284  } else {
285    EXPECT_FALSE((LosslessArithmeticConvertible<long double, double>::value));
286  }
287}
288
289// Tests the TupleMatches() template function.
290
291TEST(TupleMatchesTest, WorksForSize0) {
292  tuple<> matchers;
293  tuple<> values;
294
295  EXPECT_TRUE(TupleMatches(matchers, values));
296}
297
298TEST(TupleMatchesTest, WorksForSize1) {
299  tuple<Matcher<int> > matchers(Eq(1));
300  tuple<int> values1(1),
301      values2(2);
302
303  EXPECT_TRUE(TupleMatches(matchers, values1));
304  EXPECT_FALSE(TupleMatches(matchers, values2));
305}
306
307TEST(TupleMatchesTest, WorksForSize2) {
308  tuple<Matcher<int>, Matcher<char> > matchers(Eq(1), Eq('a'));
309  tuple<int, char> values1(1, 'a'),
310      values2(1, 'b'),
311      values3(2, 'a'),
312      values4(2, 'b');
313
314  EXPECT_TRUE(TupleMatches(matchers, values1));
315  EXPECT_FALSE(TupleMatches(matchers, values2));
316  EXPECT_FALSE(TupleMatches(matchers, values3));
317  EXPECT_FALSE(TupleMatches(matchers, values4));
318}
319
320TEST(TupleMatchesTest, WorksForSize5) {
321  tuple<Matcher<int>, Matcher<char>, Matcher<bool>, Matcher<long>,  // NOLINT
322      Matcher<string> >
323      matchers(Eq(1), Eq('a'), Eq(true), Eq(2L), Eq("hi"));
324  tuple<int, char, bool, long, string>  // NOLINT
325      values1(1, 'a', true, 2L, "hi"),
326      values2(1, 'a', true, 2L, "hello"),
327      values3(2, 'a', true, 2L, "hi");
328
329  EXPECT_TRUE(TupleMatches(matchers, values1));
330  EXPECT_FALSE(TupleMatches(matchers, values2));
331  EXPECT_FALSE(TupleMatches(matchers, values3));
332}
333
334// Tests that Assert(true, ...) succeeds.
335TEST(AssertTest, SucceedsOnTrue) {
336  Assert(true, __FILE__, __LINE__, "This should succeed.");
337  Assert(true, __FILE__, __LINE__);  // This should succeed too.
338}
339
340// Tests that Assert(false, ...) generates a fatal failure.
341TEST(AssertTest, FailsFatallyOnFalse) {
342  EXPECT_DEATH_IF_SUPPORTED({
343    Assert(false, __FILE__, __LINE__, "This should fail.");
344  }, "");
345
346  EXPECT_DEATH_IF_SUPPORTED({
347    Assert(false, __FILE__, __LINE__);
348  }, "");
349}
350
351// Tests that Expect(true, ...) succeeds.
352TEST(ExpectTest, SucceedsOnTrue) {
353  Expect(true, __FILE__, __LINE__, "This should succeed.");
354  Expect(true, __FILE__, __LINE__);  // This should succeed too.
355}
356
357// Tests that Expect(false, ...) generates a non-fatal failure.
358TEST(ExpectTest, FailsNonfatallyOnFalse) {
359  EXPECT_NONFATAL_FAILURE({  // NOLINT
360    Expect(false, __FILE__, __LINE__, "This should fail.");
361  }, "This should fail");
362
363  EXPECT_NONFATAL_FAILURE({  // NOLINT
364    Expect(false, __FILE__, __LINE__);
365  }, "Expectation failed");
366}
367
368// Tests LogIsVisible().
369
370class LogIsVisibleTest : public ::testing::Test {
371 protected:
372  virtual void SetUp() {
373    original_verbose_ = GMOCK_FLAG(verbose);
374  }
375
376  virtual void TearDown() { GMOCK_FLAG(verbose) = original_verbose_; }
377
378  string original_verbose_;
379};
380
381TEST_F(LogIsVisibleTest, AlwaysReturnsTrueIfVerbosityIsInfo) {
382  GMOCK_FLAG(verbose) = kInfoVerbosity;
383  EXPECT_TRUE(LogIsVisible(kInfo));
384  EXPECT_TRUE(LogIsVisible(kWarning));
385}
386
387TEST_F(LogIsVisibleTest, AlwaysReturnsFalseIfVerbosityIsError) {
388  GMOCK_FLAG(verbose) = kErrorVerbosity;
389  EXPECT_FALSE(LogIsVisible(kInfo));
390  EXPECT_FALSE(LogIsVisible(kWarning));
391}
392
393TEST_F(LogIsVisibleTest, WorksWhenVerbosityIsWarning) {
394  GMOCK_FLAG(verbose) = kWarningVerbosity;
395  EXPECT_FALSE(LogIsVisible(kInfo));
396  EXPECT_TRUE(LogIsVisible(kWarning));
397}
398
399#if GTEST_HAS_STREAM_REDIRECTION
400
401// Tests the Log() function.
402
403// Verifies that Log() behaves correctly for the given verbosity level
404// and log severity.
405void TestLogWithSeverity(const string& verbosity, LogSeverity severity,
406                         bool should_print) {
407  const string old_flag = GMOCK_FLAG(verbose);
408  GMOCK_FLAG(verbose) = verbosity;
409  CaptureStdout();
410  Log(severity, "Test log.\n", 0);
411  if (should_print) {
412    EXPECT_THAT(GetCapturedStdout().c_str(),
413                ContainsRegex(
414                    severity == kWarning ?
415                    "^\nGMOCK WARNING:\nTest log\\.\nStack trace:\n" :
416                    "^\nTest log\\.\nStack trace:\n"));
417  } else {
418    EXPECT_STREQ("", GetCapturedStdout().c_str());
419  }
420  GMOCK_FLAG(verbose) = old_flag;
421}
422
423// Tests that when the stack_frames_to_skip parameter is negative,
424// Log() doesn't include the stack trace in the output.
425TEST(LogTest, NoStackTraceWhenStackFramesToSkipIsNegative) {
426  const string saved_flag = GMOCK_FLAG(verbose);
427  GMOCK_FLAG(verbose) = kInfoVerbosity;
428  CaptureStdout();
429  Log(kInfo, "Test log.\n", -1);
430  EXPECT_STREQ("\nTest log.\n", GetCapturedStdout().c_str());
431  GMOCK_FLAG(verbose) = saved_flag;
432}
433
434struct MockStackTraceGetter : testing::internal::OsStackTraceGetterInterface {
435  virtual string CurrentStackTrace(int max_depth, int skip_count) {
436    return (testing::Message() << max_depth << "::" << skip_count << "\n")
437        .GetString();
438  }
439  virtual void UponLeavingGTest() {}
440};
441
442// Tests that in opt mode, a positive stack_frames_to_skip argument is
443// treated as 0.
444TEST(LogTest, NoSkippingStackFrameInOptMode) {
445  MockStackTraceGetter* mock_os_stack_trace_getter = new MockStackTraceGetter;
446  GetUnitTestImpl()->set_os_stack_trace_getter(mock_os_stack_trace_getter);
447
448  CaptureStdout();
449  Log(kWarning, "Test log.\n", 100);
450  const string log = GetCapturedStdout();
451
452  string expected_trace =
453      (testing::Message() << GTEST_FLAG(stack_trace_depth) << "::").GetString();
454  string expected_message =
455      "\nGMOCK WARNING:\n"
456      "Test log.\n"
457      "Stack trace:\n" +
458      expected_trace;
459  EXPECT_THAT(log, HasSubstr(expected_message));
460  int skip_count = atoi(log.substr(expected_message.size()).c_str());
461
462# if defined(NDEBUG)
463  // In opt mode, no stack frame should be skipped.
464  const int expected_skip_count = 0;
465# else
466  // In dbg mode, the stack frames should be skipped.
467  const int expected_skip_count = 100;
468# endif
469
470  // Note that each inner implementation layer will +1 the number to remove
471  // itself from the trace. This means that the value is a little higher than
472  // expected, but close enough.
473  EXPECT_THAT(skip_count,
474              AllOf(Ge(expected_skip_count), Le(expected_skip_count + 10)));
475
476  // Restores the default OS stack trace getter.
477  GetUnitTestImpl()->set_os_stack_trace_getter(NULL);
478}
479
480// Tests that all logs are printed when the value of the
481// --gmock_verbose flag is "info".
482TEST(LogTest, AllLogsArePrintedWhenVerbosityIsInfo) {
483  TestLogWithSeverity(kInfoVerbosity, kInfo, true);
484  TestLogWithSeverity(kInfoVerbosity, kWarning, true);
485}
486
487// Tests that only warnings are printed when the value of the
488// --gmock_verbose flag is "warning".
489TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsWarning) {
490  TestLogWithSeverity(kWarningVerbosity, kInfo, false);
491  TestLogWithSeverity(kWarningVerbosity, kWarning, true);
492}
493
494// Tests that no logs are printed when the value of the
495// --gmock_verbose flag is "error".
496TEST(LogTest, NoLogsArePrintedWhenVerbosityIsError) {
497  TestLogWithSeverity(kErrorVerbosity, kInfo, false);
498  TestLogWithSeverity(kErrorVerbosity, kWarning, false);
499}
500
501// Tests that only warnings are printed when the value of the
502// --gmock_verbose flag is invalid.
503TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsInvalid) {
504  TestLogWithSeverity("invalid", kInfo, false);
505  TestLogWithSeverity("invalid", kWarning, true);
506}
507
508#endif  // GTEST_HAS_STREAM_REDIRECTION
509
510TEST(TypeTraitsTest, true_type) {
511  EXPECT_TRUE(true_type::value);
512}
513
514TEST(TypeTraitsTest, false_type) {
515  EXPECT_FALSE(false_type::value);
516}
517
518TEST(TypeTraitsTest, is_reference) {
519  EXPECT_FALSE(is_reference<int>::value);
520  EXPECT_FALSE(is_reference<char*>::value);
521  EXPECT_TRUE(is_reference<const int&>::value);
522}
523
524TEST(TypeTraitsTest, is_pointer) {
525  EXPECT_FALSE(is_pointer<int>::value);
526  EXPECT_FALSE(is_pointer<char&>::value);
527  EXPECT_TRUE(is_pointer<const int*>::value);
528}
529
530TEST(TypeTraitsTest, type_equals) {
531  EXPECT_FALSE((type_equals<int, const int>::value));
532  EXPECT_FALSE((type_equals<int, int&>::value));
533  EXPECT_FALSE((type_equals<int, double>::value));
534  EXPECT_TRUE((type_equals<char, char>::value));
535}
536
537TEST(TypeTraitsTest, remove_reference) {
538  EXPECT_TRUE((type_equals<char, remove_reference<char&>::type>::value));
539  EXPECT_TRUE((type_equals<const int,
540               remove_reference<const int&>::type>::value));
541  EXPECT_TRUE((type_equals<int, remove_reference<int>::type>::value));
542  EXPECT_TRUE((type_equals<double*, remove_reference<double*>::type>::value));
543}
544
545#if GTEST_HAS_STREAM_REDIRECTION
546
547// Verifies that Log() behaves correctly for the given verbosity level
548// and log severity.
549std::string GrabOutput(void(*logger)(), const char* verbosity) {
550  const string saved_flag = GMOCK_FLAG(verbose);
551  GMOCK_FLAG(verbose) = verbosity;
552  CaptureStdout();
553  logger();
554  GMOCK_FLAG(verbose) = saved_flag;
555  return GetCapturedStdout();
556}
557
558class DummyMock {
559 public:
560  MOCK_METHOD0(TestMethod, void());
561  MOCK_METHOD1(TestMethodArg, void(int dummy));
562};
563
564void ExpectCallLogger() {
565  DummyMock mock;
566  EXPECT_CALL(mock, TestMethod());
567  mock.TestMethod();
568};
569
570// Verifies that EXPECT_CALL logs if the --gmock_verbose flag is set to "info".
571TEST(ExpectCallTest, LogsWhenVerbosityIsInfo) {
572  EXPECT_THAT(std::string(GrabOutput(ExpectCallLogger, kInfoVerbosity)),
573              HasSubstr("EXPECT_CALL(mock, TestMethod())"));
574}
575
576// Verifies that EXPECT_CALL doesn't log
577// if the --gmock_verbose flag is set to "warning".
578TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsWarning) {
579  EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kWarningVerbosity).c_str());
580}
581
582// Verifies that EXPECT_CALL doesn't log
583// if the --gmock_verbose flag is set to "error".
584TEST(ExpectCallTest,  DoesNotLogWhenVerbosityIsError) {
585  EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kErrorVerbosity).c_str());
586}
587
588void OnCallLogger() {
589  DummyMock mock;
590  ON_CALL(mock, TestMethod());
591};
592
593// Verifies that ON_CALL logs if the --gmock_verbose flag is set to "info".
594TEST(OnCallTest, LogsWhenVerbosityIsInfo) {
595  EXPECT_THAT(std::string(GrabOutput(OnCallLogger, kInfoVerbosity)),
596              HasSubstr("ON_CALL(mock, TestMethod())"));
597}
598
599// Verifies that ON_CALL doesn't log
600// if the --gmock_verbose flag is set to "warning".
601TEST(OnCallTest, DoesNotLogWhenVerbosityIsWarning) {
602  EXPECT_STREQ("", GrabOutput(OnCallLogger, kWarningVerbosity).c_str());
603}
604
605// Verifies that ON_CALL doesn't log if
606// the --gmock_verbose flag is set to "error".
607TEST(OnCallTest, DoesNotLogWhenVerbosityIsError) {
608  EXPECT_STREQ("", GrabOutput(OnCallLogger, kErrorVerbosity).c_str());
609}
610
611void OnCallAnyArgumentLogger() {
612  DummyMock mock;
613  ON_CALL(mock, TestMethodArg(_));
614}
615
616// Verifies that ON_CALL prints provided _ argument.
617TEST(OnCallTest, LogsAnythingArgument) {
618  EXPECT_THAT(std::string(GrabOutput(OnCallAnyArgumentLogger, kInfoVerbosity)),
619              HasSubstr("ON_CALL(mock, TestMethodArg(_)"));
620}
621
622#endif  // GTEST_HAS_STREAM_REDIRECTION
623
624// Tests StlContainerView.
625
626TEST(StlContainerViewTest, WorksForStlContainer) {
627  StaticAssertTypeEq<std::vector<int>,
628      StlContainerView<std::vector<int> >::type>();
629  StaticAssertTypeEq<const std::vector<double>&,
630      StlContainerView<std::vector<double> >::const_reference>();
631
632  typedef std::vector<char> Chars;
633  Chars v1;
634  const Chars& v2(StlContainerView<Chars>::ConstReference(v1));
635  EXPECT_EQ(&v1, &v2);
636
637  v1.push_back('a');
638  Chars v3 = StlContainerView<Chars>::Copy(v1);
639  EXPECT_THAT(v3, Eq(v3));
640}
641
642TEST(StlContainerViewTest, WorksForStaticNativeArray) {
643  StaticAssertTypeEq<NativeArray<int>,
644      StlContainerView<int[3]>::type>();
645  StaticAssertTypeEq<NativeArray<double>,
646      StlContainerView<const double[4]>::type>();
647  StaticAssertTypeEq<NativeArray<char[3]>,
648      StlContainerView<const char[2][3]>::type>();
649
650  StaticAssertTypeEq<const NativeArray<int>,
651      StlContainerView<int[2]>::const_reference>();
652
653  int a1[3] = { 0, 1, 2 };
654  NativeArray<int> a2 = StlContainerView<int[3]>::ConstReference(a1);
655  EXPECT_EQ(3U, a2.size());
656  EXPECT_EQ(a1, a2.begin());
657
658  const NativeArray<int> a3 = StlContainerView<int[3]>::Copy(a1);
659  ASSERT_EQ(3U, a3.size());
660  EXPECT_EQ(0, a3.begin()[0]);
661  EXPECT_EQ(1, a3.begin()[1]);
662  EXPECT_EQ(2, a3.begin()[2]);
663
664  // Makes sure a1 and a3 aren't aliases.
665  a1[0] = 3;
666  EXPECT_EQ(0, a3.begin()[0]);
667}
668
669TEST(StlContainerViewTest, WorksForDynamicNativeArray) {
670  StaticAssertTypeEq<NativeArray<int>,
671      StlContainerView<tuple<const int*, size_t> >::type>();
672  StaticAssertTypeEq<NativeArray<double>,
673      StlContainerView<tuple<linked_ptr<double>, int> >::type>();
674
675  StaticAssertTypeEq<const NativeArray<int>,
676      StlContainerView<tuple<const int*, int> >::const_reference>();
677
678  int a1[3] = { 0, 1, 2 };
679  const int* const p1 = a1;
680  NativeArray<int> a2 = StlContainerView<tuple<const int*, int> >::
681      ConstReference(make_tuple(p1, 3));
682  EXPECT_EQ(3U, a2.size());
683  EXPECT_EQ(a1, a2.begin());
684
685  const NativeArray<int> a3 = StlContainerView<tuple<int*, size_t> >::
686      Copy(make_tuple(static_cast<int*>(a1), 3));
687  ASSERT_EQ(3U, a3.size());
688  EXPECT_EQ(0, a3.begin()[0]);
689  EXPECT_EQ(1, a3.begin()[1]);
690  EXPECT_EQ(2, a3.begin()[2]);
691
692  // Makes sure a1 and a3 aren't aliases.
693  a1[0] = 3;
694  EXPECT_EQ(0, a3.begin()[0]);
695}
696
697}  // namespace
698}  // namespace internal
699}  // namespace testing
700