gmock-internal-utils_test.cc 26.1 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Gennadiy Civil's avatar
 
Gennadiy Civil committed
29

30
31
32
33
34

// Google Mock - a framework for writing C++ mock classes.
//
// This file tests the internal utilities.

35
#include "gmock/internal/gmock-internal-utils.h"
kuzkry's avatar
kuzkry committed
36

37
#include <stdlib.h>
kuzkry's avatar
kuzkry committed
38

39
#include <map>
40
#include <memory>
41
#include <sstream>
kuzkry's avatar
kuzkry committed
42
#include <string>
43
#include <type_traits>
44
#include <vector>
kuzkry's avatar
kuzkry committed
45

46
47
48
#include "gmock/gmock.h"
#include "gmock/internal/gmock-port.h"
#include "gtest/gtest-spi.h"
kuzkry's avatar
kuzkry committed
49
#include "gtest/gtest.h"
Gennadiy Civil's avatar
Gennadiy Civil committed
50
51
52
53
54
55
56

// Indicates that this translation unit is part of Google Test's
// implementation.  It must come before gtest-internal-inl.h is
// included, or there will be a compiler error.  This trick is to
// prevent a user from accidentally including gtest-internal-inl.h in
// their code.
#define GTEST_IMPLEMENTATION_ 1
kosak's avatar
kosak committed
57
#include "src/gtest-internal-inl.h"
Gennadiy Civil's avatar
Gennadiy Civil committed
58
#undef GTEST_IMPLEMENTATION_
kosak's avatar
kosak committed
59

60
#if GTEST_OS_CYGWIN
61
# include <sys/types.h>  // For ssize_t. NOLINT
62
63
#endif

zhanyong.wan's avatar
zhanyong.wan committed
64
65
66
67
namespace proto2 {
class Message;
}  // namespace proto2

68
69
70
71
72
namespace testing {
namespace internal {

namespace {

Gennadiy Civil's avatar
Gennadiy Civil committed
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
TEST(JoinAsTupleTest, JoinsEmptyTuple) {
  EXPECT_EQ("", JoinAsTuple(Strings()));
}

TEST(JoinAsTupleTest, JoinsOneTuple) {
  const char* fields[] = {"1"};
  EXPECT_EQ("1", JoinAsTuple(Strings(fields, fields + 1)));
}

TEST(JoinAsTupleTest, JoinsTwoTuple) {
  const char* fields[] = {"1", "a"};
  EXPECT_EQ("(1, a)", JoinAsTuple(Strings(fields, fields + 2)));
}

TEST(JoinAsTupleTest, JoinsTenTuple) {
  const char* fields[] = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"};
  EXPECT_EQ("(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)",
            JoinAsTuple(Strings(fields, fields + 10)));
}

zhanyong.wan's avatar
zhanyong.wan committed
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsNoWord) {
  EXPECT_EQ("", ConvertIdentifierNameToWords(""));
  EXPECT_EQ("", ConvertIdentifierNameToWords("_"));
  EXPECT_EQ("", ConvertIdentifierNameToWords("__"));
}

TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsDigits) {
  EXPECT_EQ("1", ConvertIdentifierNameToWords("_1"));
  EXPECT_EQ("2", ConvertIdentifierNameToWords("2_"));
  EXPECT_EQ("34", ConvertIdentifierNameToWords("_34_"));
  EXPECT_EQ("34 56", ConvertIdentifierNameToWords("_34_56"));
}

TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsCamelCaseWords) {
  EXPECT_EQ("a big word", ConvertIdentifierNameToWords("ABigWord"));
  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("FooBar"));
  EXPECT_EQ("foo", ConvertIdentifierNameToWords("Foo_"));
  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_Foo_Bar_"));
  EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_Foo__And_Bar"));
}

TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContains_SeparatedWords) {
  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("foo_bar"));
  EXPECT_EQ("foo", ConvertIdentifierNameToWords("_foo_"));
  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_foo_bar_"));
  EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_foo__and_bar"));
}

TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameIsMixture) {
  EXPECT_EQ("foo bar 123", ConvertIdentifierNameToWords("Foo_bar123"));
  EXPECT_EQ("chapter 11 section 1",
            ConvertIdentifierNameToWords("_Chapter11Section_1_"));
}

127
TEST(PointeeOfTest, WorksForSmartPointers) {
128
129
130
  CompileAssertTypesEqual<int, PointeeOf<std::unique_ptr<int> >::type>();
  CompileAssertTypesEqual<std::string,
                          PointeeOf<std::shared_ptr<std::string> >::type>();
131
132
133
134
135
136
137
138
139
}

TEST(PointeeOfTest, WorksForRawPointers) {
  CompileAssertTypesEqual<int, PointeeOf<int*>::type>();
  CompileAssertTypesEqual<const char, PointeeOf<const char*>::type>();
  CompileAssertTypesEqual<void, PointeeOf<void*>::type>();
}

TEST(GetRawPointerTest, WorksForSmartPointers) {
140
141
142
143
144
145
  const char* const raw_p1 = new const char('a');  // NOLINT
  const std::unique_ptr<const char> p1(raw_p1);
  EXPECT_EQ(raw_p1, GetRawPointer(p1));
  double* const raw_p2 = new double(2.5);  // NOLINT
  const std::shared_ptr<double> p2(raw_p2);
  EXPECT_EQ(raw_p2, GetRawPointer(p2));
146
147
148
}

TEST(GetRawPointerTest, WorksForRawPointers) {
149
150
  int* p = nullptr;
  EXPECT_TRUE(nullptr == GetRawPointer(p));
151
152
153
154
  int n = 1;
  EXPECT_EQ(&n, GetRawPointer(&n));
}

155
156
// Tests KindOf<T>.

157
158
159
class Base {};
class Derived : public Base {};

160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
TEST(KindOfTest, Bool) {
  EXPECT_EQ(kBool, GMOCK_KIND_OF_(bool));  // NOLINT
}

TEST(KindOfTest, Integer) {
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(char));  // NOLINT
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(signed char));  // NOLINT
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned char));  // NOLINT
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(short));  // NOLINT
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned short));  // NOLINT
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(int));  // NOLINT
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned int));  // NOLINT
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(long));  // NOLINT
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long));  // NOLINT
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(wchar_t));  // NOLINT
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(Int64));  // NOLINT
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(UInt64));  // NOLINT
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(size_t));  // NOLINT
#if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN
  // ssize_t is not defined on Windows and possibly some other OSes.
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(ssize_t));  // NOLINT
#endif
}

TEST(KindOfTest, FloatingPoint) {
  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(float));  // NOLINT
  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(double));  // NOLINT
  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(long double));  // NOLINT
}

TEST(KindOfTest, Other) {
  EXPECT_EQ(kOther, GMOCK_KIND_OF_(void*));  // NOLINT
  EXPECT_EQ(kOther, GMOCK_KIND_OF_(char**));  // NOLINT
  EXPECT_EQ(kOther, GMOCK_KIND_OF_(Base));  // NOLINT
}

// Tests LosslessArithmeticConvertible<T, U>.

TEST(LosslessArithmeticConvertibleTest, BoolToBool) {
  EXPECT_TRUE((LosslessArithmeticConvertible<bool, bool>::value));
}

TEST(LosslessArithmeticConvertibleTest, BoolToInteger) {
  EXPECT_TRUE((LosslessArithmeticConvertible<bool, char>::value));
  EXPECT_TRUE((LosslessArithmeticConvertible<bool, int>::value));
  EXPECT_TRUE(
      (LosslessArithmeticConvertible<bool, unsigned long>::value));  // NOLINT
}

TEST(LosslessArithmeticConvertibleTest, BoolToFloatingPoint) {
  EXPECT_TRUE((LosslessArithmeticConvertible<bool, float>::value));
  EXPECT_TRUE((LosslessArithmeticConvertible<bool, double>::value));
}

TEST(LosslessArithmeticConvertibleTest, IntegerToBool) {
  EXPECT_FALSE((LosslessArithmeticConvertible<unsigned char, bool>::value));
  EXPECT_FALSE((LosslessArithmeticConvertible<int, bool>::value));
}

TEST(LosslessArithmeticConvertibleTest, IntegerToInteger) {
  // Unsigned => larger signed is fine.
  EXPECT_TRUE((LosslessArithmeticConvertible<unsigned char, int>::value));

  // Unsigned => larger unsigned is fine.
  EXPECT_TRUE(
      (LosslessArithmeticConvertible<unsigned short, UInt64>::value)); // NOLINT

  // Signed => unsigned is not fine.
  EXPECT_FALSE((LosslessArithmeticConvertible<short, UInt64>::value)); // NOLINT
  EXPECT_FALSE((LosslessArithmeticConvertible<
      signed char, unsigned int>::value));  // NOLINT

  // Same size and same signedness: fine too.
  EXPECT_TRUE((LosslessArithmeticConvertible<
               unsigned char, unsigned char>::value));
  EXPECT_TRUE((LosslessArithmeticConvertible<int, int>::value));
  EXPECT_TRUE((LosslessArithmeticConvertible<wchar_t, wchar_t>::value));
  EXPECT_TRUE((LosslessArithmeticConvertible<
               unsigned long, unsigned long>::value));  // NOLINT

  // Same size, different signedness: not fine.
  EXPECT_FALSE((LosslessArithmeticConvertible<
                unsigned char, signed char>::value));
  EXPECT_FALSE((LosslessArithmeticConvertible<int, unsigned int>::value));
  EXPECT_FALSE((LosslessArithmeticConvertible<UInt64, Int64>::value));

  // Larger size => smaller size is not fine.
  EXPECT_FALSE((LosslessArithmeticConvertible<long, char>::value));  // NOLINT
  EXPECT_FALSE((LosslessArithmeticConvertible<int, signed char>::value));
  EXPECT_FALSE((LosslessArithmeticConvertible<Int64, unsigned int>::value));
}

TEST(LosslessArithmeticConvertibleTest, IntegerToFloatingPoint) {
  // Integers cannot be losslessly converted to floating-points, as
  // the format of the latter is implementation-defined.
  EXPECT_FALSE((LosslessArithmeticConvertible<char, float>::value));
  EXPECT_FALSE((LosslessArithmeticConvertible<int, double>::value));
  EXPECT_FALSE((LosslessArithmeticConvertible<
                short, long double>::value));  // NOLINT
}

TEST(LosslessArithmeticConvertibleTest, FloatingPointToBool) {
  EXPECT_FALSE((LosslessArithmeticConvertible<float, bool>::value));
  EXPECT_FALSE((LosslessArithmeticConvertible<double, bool>::value));
}

TEST(LosslessArithmeticConvertibleTest, FloatingPointToInteger) {
  EXPECT_FALSE((LosslessArithmeticConvertible<float, long>::value));  // NOLINT
  EXPECT_FALSE((LosslessArithmeticConvertible<double, Int64>::value));
  EXPECT_FALSE((LosslessArithmeticConvertible<long double, int>::value));
}

TEST(LosslessArithmeticConvertibleTest, FloatingPointToFloatingPoint) {
  // Smaller size => larger size is fine.
  EXPECT_TRUE((LosslessArithmeticConvertible<float, double>::value));
  EXPECT_TRUE((LosslessArithmeticConvertible<float, long double>::value));
  EXPECT_TRUE((LosslessArithmeticConvertible<double, long double>::value));

  // Same size: fine.
  EXPECT_TRUE((LosslessArithmeticConvertible<float, float>::value));
  EXPECT_TRUE((LosslessArithmeticConvertible<double, double>::value));

  // Larger size => smaller size is not fine.
  EXPECT_FALSE((LosslessArithmeticConvertible<double, float>::value));
billydonahue's avatar
billydonahue committed
284
  GTEST_INTENTIONAL_CONST_COND_PUSH_()
285
  if (sizeof(double) == sizeof(long double)) {  // NOLINT
billydonahue's avatar
billydonahue committed
286
  GTEST_INTENTIONAL_CONST_COND_POP_()
287
288
289
290
291
292
293
294
    // In some implementations (e.g. MSVC), double and long double
    // have the same size.
    EXPECT_TRUE((LosslessArithmeticConvertible<long double, double>::value));
  } else {
    EXPECT_FALSE((LosslessArithmeticConvertible<long double, double>::value));
  }
}

295
296
297
// Tests the TupleMatches() template function.

TEST(TupleMatchesTest, WorksForSize0) {
Abseil Team's avatar
Abseil Team committed
298
299
  std::tuple<> matchers;
  std::tuple<> values;
300
301
302
303
304

  EXPECT_TRUE(TupleMatches(matchers, values));
}

TEST(TupleMatchesTest, WorksForSize1) {
Abseil Team's avatar
Abseil Team committed
305
306
  std::tuple<Matcher<int> > matchers(Eq(1));
  std::tuple<int> values1(1), values2(2);
307
308
309
310
311
312

  EXPECT_TRUE(TupleMatches(matchers, values1));
  EXPECT_FALSE(TupleMatches(matchers, values2));
}

TEST(TupleMatchesTest, WorksForSize2) {
Abseil Team's avatar
Abseil Team committed
313
314
  std::tuple<Matcher<int>, Matcher<char> > matchers(Eq(1), Eq('a'));
  std::tuple<int, char> values1(1, 'a'), values2(1, 'b'), values3(2, 'a'),
315
316
317
318
319
320
321
322
323
      values4(2, 'b');

  EXPECT_TRUE(TupleMatches(matchers, values1));
  EXPECT_FALSE(TupleMatches(matchers, values2));
  EXPECT_FALSE(TupleMatches(matchers, values3));
  EXPECT_FALSE(TupleMatches(matchers, values4));
}

TEST(TupleMatchesTest, WorksForSize5) {
Abseil Team's avatar
Abseil Team committed
324
325
326
  std::tuple<Matcher<int>, Matcher<char>, Matcher<bool>,
             Matcher<long>,  // NOLINT
             Matcher<std::string> >
327
      matchers(Eq(1), Eq('a'), Eq(true), Eq(2L), Eq("hi"));
Abseil Team's avatar
Abseil Team committed
328
  std::tuple<int, char, bool, long, std::string>  // NOLINT
329
      values1(1, 'a', true, 2L, "hi"), values2(1, 'a', true, 2L, "hello"),
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
      values3(2, 'a', true, 2L, "hi");

  EXPECT_TRUE(TupleMatches(matchers, values1));
  EXPECT_FALSE(TupleMatches(matchers, values2));
  EXPECT_FALSE(TupleMatches(matchers, values3));
}

// Tests that Assert(true, ...) succeeds.
TEST(AssertTest, SucceedsOnTrue) {
  Assert(true, __FILE__, __LINE__, "This should succeed.");
  Assert(true, __FILE__, __LINE__);  // This should succeed too.
}

// Tests that Assert(false, ...) generates a fatal failure.
TEST(AssertTest, FailsFatallyOnFalse) {
345
  EXPECT_DEATH_IF_SUPPORTED({
346
347
348
    Assert(false, __FILE__, __LINE__, "This should fail.");
  }, "");

349
  EXPECT_DEATH_IF_SUPPORTED({
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
    Assert(false, __FILE__, __LINE__);
  }, "");
}

// Tests that Expect(true, ...) succeeds.
TEST(ExpectTest, SucceedsOnTrue) {
  Expect(true, __FILE__, __LINE__, "This should succeed.");
  Expect(true, __FILE__, __LINE__);  // This should succeed too.
}

// Tests that Expect(false, ...) generates a non-fatal failure.
TEST(ExpectTest, FailsNonfatallyOnFalse) {
  EXPECT_NONFATAL_FAILURE({  // NOLINT
    Expect(false, __FILE__, __LINE__, "This should fail.");
  }, "This should fail");

  EXPECT_NONFATAL_FAILURE({  // NOLINT
    Expect(false, __FILE__, __LINE__);
  }, "Expectation failed");
}

371
372
373
374
// Tests LogIsVisible().

class LogIsVisibleTest : public ::testing::Test {
 protected:
Abseil Team's avatar
Abseil Team committed
375
  void SetUp() override { original_verbose_ = GMOCK_FLAG(verbose); }
376

Abseil Team's avatar
Abseil Team committed
377
  void TearDown() override { GMOCK_FLAG(verbose) = original_verbose_; }
378

379
  std::string original_verbose_;
380
381
382
383
};

TEST_F(LogIsVisibleTest, AlwaysReturnsTrueIfVerbosityIsInfo) {
  GMOCK_FLAG(verbose) = kInfoVerbosity;
zhanyong.wan's avatar
zhanyong.wan committed
384
385
  EXPECT_TRUE(LogIsVisible(kInfo));
  EXPECT_TRUE(LogIsVisible(kWarning));
386
387
388
389
}

TEST_F(LogIsVisibleTest, AlwaysReturnsFalseIfVerbosityIsError) {
  GMOCK_FLAG(verbose) = kErrorVerbosity;
zhanyong.wan's avatar
zhanyong.wan committed
390
391
  EXPECT_FALSE(LogIsVisible(kInfo));
  EXPECT_FALSE(LogIsVisible(kWarning));
392
393
394
395
}

TEST_F(LogIsVisibleTest, WorksWhenVerbosityIsWarning) {
  GMOCK_FLAG(verbose) = kWarningVerbosity;
zhanyong.wan's avatar
zhanyong.wan committed
396
397
  EXPECT_FALSE(LogIsVisible(kInfo));
  EXPECT_TRUE(LogIsVisible(kWarning));
398
399
}

400
#if GTEST_HAS_STREAM_REDIRECTION
401
402
403
404
405

// Tests the Log() function.

// Verifies that Log() behaves correctly for the given verbosity level
// and log severity.
406
void TestLogWithSeverity(const std::string& verbosity, LogSeverity severity,
407
                         bool should_print) {
408
  const std::string old_flag = GMOCK_FLAG(verbose);
409
  GMOCK_FLAG(verbose) = verbosity;
410
  CaptureStdout();
411
412
  Log(severity, "Test log.\n", 0);
  if (should_print) {
413
414
    EXPECT_THAT(GetCapturedStdout().c_str(),
                ContainsRegex(
zhanyong.wan's avatar
zhanyong.wan committed
415
                    severity == kWarning ?
416
417
                    "^\nGMOCK WARNING:\nTest log\\.\nStack trace:\n" :
                    "^\nTest log\\.\nStack trace:\n"));
418
  } else {
419
    EXPECT_STREQ("", GetCapturedStdout().c_str());
420
421
422
423
424
425
426
  }
  GMOCK_FLAG(verbose) = old_flag;
}

// Tests that when the stack_frames_to_skip parameter is negative,
// Log() doesn't include the stack trace in the output.
TEST(LogTest, NoStackTraceWhenStackFramesToSkipIsNegative) {
427
  const std::string saved_flag = GMOCK_FLAG(verbose);
428
  GMOCK_FLAG(verbose) = kInfoVerbosity;
429
  CaptureStdout();
zhanyong.wan's avatar
zhanyong.wan committed
430
  Log(kInfo, "Test log.\n", -1);
431
  EXPECT_STREQ("\nTest log.\n", GetCapturedStdout().c_str());
432
  GMOCK_FLAG(verbose) = saved_flag;
433
434
}

kosak's avatar
kosak committed
435
struct MockStackTraceGetter : testing::internal::OsStackTraceGetterInterface {
Abseil Team's avatar
Abseil Team committed
436
  std::string CurrentStackTrace(int max_depth, int skip_count) override {
kosak's avatar
kosak committed
437
438
439
    return (testing::Message() << max_depth << "::" << skip_count << "\n")
        .GetString();
  }
Abseil Team's avatar
Abseil Team committed
440
  void UponLeavingGTest() override {}
kosak's avatar
kosak committed
441
442
};

443
444
445
// Tests that in opt mode, a positive stack_frames_to_skip argument is
// treated as 0.
TEST(LogTest, NoSkippingStackFrameInOptMode) {
kosak's avatar
kosak committed
446
447
448
  MockStackTraceGetter* mock_os_stack_trace_getter = new MockStackTraceGetter;
  GetUnitTestImpl()->set_os_stack_trace_getter(mock_os_stack_trace_getter);

449
  CaptureStdout();
zhanyong.wan's avatar
zhanyong.wan committed
450
  Log(kWarning, "Test log.\n", 100);
451
  const std::string log = GetCapturedStdout();
452

453
  std::string expected_trace =
kosak's avatar
kosak committed
454
      (testing::Message() << GTEST_FLAG(stack_trace_depth) << "::").GetString();
455
  std::string expected_message =
kosak's avatar
kosak committed
456
457
458
459
460
461
462
463
      "\nGMOCK WARNING:\n"
      "Test log.\n"
      "Stack trace:\n" +
      expected_trace;
  EXPECT_THAT(log, HasSubstr(expected_message));
  int skip_count = atoi(log.substr(expected_message.size()).c_str());

# if defined(NDEBUG)
464
  // In opt mode, no stack frame should be skipped.
kosak's avatar
kosak committed
465
  const int expected_skip_count = 0;
466
# else
467
  // In dbg mode, the stack frames should be skipped.
kosak's avatar
kosak committed
468
  const int expected_skip_count = 100;
469
# endif
kosak's avatar
kosak committed
470
471
472
473
474
475
476
477

  // Note that each inner implementation layer will +1 the number to remove
  // itself from the trace. This means that the value is a little higher than
  // expected, but close enough.
  EXPECT_THAT(skip_count,
              AllOf(Ge(expected_skip_count), Le(expected_skip_count + 10)));

  // Restores the default OS stack trace getter.
478
  GetUnitTestImpl()->set_os_stack_trace_getter(nullptr);
479
480
481
482
483
}

// Tests that all logs are printed when the value of the
// --gmock_verbose flag is "info".
TEST(LogTest, AllLogsArePrintedWhenVerbosityIsInfo) {
zhanyong.wan's avatar
zhanyong.wan committed
484
485
  TestLogWithSeverity(kInfoVerbosity, kInfo, true);
  TestLogWithSeverity(kInfoVerbosity, kWarning, true);
486
487
488
489
490
}

// Tests that only warnings are printed when the value of the
// --gmock_verbose flag is "warning".
TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsWarning) {
zhanyong.wan's avatar
zhanyong.wan committed
491
492
  TestLogWithSeverity(kWarningVerbosity, kInfo, false);
  TestLogWithSeverity(kWarningVerbosity, kWarning, true);
493
494
495
496
497
}

// Tests that no logs are printed when the value of the
// --gmock_verbose flag is "error".
TEST(LogTest, NoLogsArePrintedWhenVerbosityIsError) {
zhanyong.wan's avatar
zhanyong.wan committed
498
499
  TestLogWithSeverity(kErrorVerbosity, kInfo, false);
  TestLogWithSeverity(kErrorVerbosity, kWarning, false);
500
501
502
503
504
}

// Tests that only warnings are printed when the value of the
// --gmock_verbose flag is invalid.
TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsInvalid) {
zhanyong.wan's avatar
zhanyong.wan committed
505
506
  TestLogWithSeverity("invalid", kInfo, false);
  TestLogWithSeverity("invalid", kWarning, true);
507
508
}

509
#endif  // GTEST_HAS_STREAM_REDIRECTION
510
511

TEST(TypeTraitsTest, remove_reference) {
512
513
514
515
516
  EXPECT_TRUE((std::is_same<char, remove_reference<char&>::type>::value));
  EXPECT_TRUE(
      (std::is_same<const int, remove_reference<const int&>::type>::value));
  EXPECT_TRUE((std::is_same<int, remove_reference<int>::type>::value));
  EXPECT_TRUE((std::is_same<double*, remove_reference<double*>::type>::value));
517
518
}

519
#if GTEST_HAS_STREAM_REDIRECTION
520
521
522

// Verifies that Log() behaves correctly for the given verbosity level
// and log severity.
523
std::string GrabOutput(void(*logger)(), const char* verbosity) {
524
  const std::string saved_flag = GMOCK_FLAG(verbose);
525
  GMOCK_FLAG(verbose) = verbosity;
526
  CaptureStdout();
527
528
  logger();
  GMOCK_FLAG(verbose) = saved_flag;
529
  return GetCapturedStdout();
530
531
532
533
534
535
536
537
538
539
540
541
}

class DummyMock {
 public:
  MOCK_METHOD0(TestMethod, void());
  MOCK_METHOD1(TestMethodArg, void(int dummy));
};

void ExpectCallLogger() {
  DummyMock mock;
  EXPECT_CALL(mock, TestMethod());
  mock.TestMethod();
Abseil Team's avatar
Abseil Team committed
542
}
543
544
545

// Verifies that EXPECT_CALL logs if the --gmock_verbose flag is set to "info".
TEST(ExpectCallTest, LogsWhenVerbosityIsInfo) {
546
  EXPECT_THAT(std::string(GrabOutput(ExpectCallLogger, kInfoVerbosity)),
547
548
549
550
551
552
              HasSubstr("EXPECT_CALL(mock, TestMethod())"));
}

// Verifies that EXPECT_CALL doesn't log
// if the --gmock_verbose flag is set to "warning".
TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsWarning) {
553
  EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kWarningVerbosity).c_str());
554
555
556
557
558
}

// Verifies that EXPECT_CALL doesn't log
// if the --gmock_verbose flag is set to "error".
TEST(ExpectCallTest,  DoesNotLogWhenVerbosityIsError) {
559
  EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kErrorVerbosity).c_str());
560
561
562
563
564
}

void OnCallLogger() {
  DummyMock mock;
  ON_CALL(mock, TestMethod());
Abseil Team's avatar
Abseil Team committed
565
}
566
567
568

// Verifies that ON_CALL logs if the --gmock_verbose flag is set to "info".
TEST(OnCallTest, LogsWhenVerbosityIsInfo) {
569
  EXPECT_THAT(std::string(GrabOutput(OnCallLogger, kInfoVerbosity)),
570
571
572
573
574
575
              HasSubstr("ON_CALL(mock, TestMethod())"));
}

// Verifies that ON_CALL doesn't log
// if the --gmock_verbose flag is set to "warning".
TEST(OnCallTest, DoesNotLogWhenVerbosityIsWarning) {
576
  EXPECT_STREQ("", GrabOutput(OnCallLogger, kWarningVerbosity).c_str());
577
578
579
580
581
}

// Verifies that ON_CALL doesn't log if
// the --gmock_verbose flag is set to "error".
TEST(OnCallTest, DoesNotLogWhenVerbosityIsError) {
582
  EXPECT_STREQ("", GrabOutput(OnCallLogger, kErrorVerbosity).c_str());
583
584
585
586
587
588
589
590
591
}

void OnCallAnyArgumentLogger() {
  DummyMock mock;
  ON_CALL(mock, TestMethodArg(_));
}

// Verifies that ON_CALL prints provided _ argument.
TEST(OnCallTest, LogsAnythingArgument) {
592
  EXPECT_THAT(std::string(GrabOutput(OnCallAnyArgumentLogger, kInfoVerbosity)),
593
594
595
              HasSubstr("ON_CALL(mock, TestMethodArg(_)"));
}

596
#endif  // GTEST_HAS_STREAM_REDIRECTION
597

598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
// Tests StlContainerView.

TEST(StlContainerViewTest, WorksForStlContainer) {
  StaticAssertTypeEq<std::vector<int>,
      StlContainerView<std::vector<int> >::type>();
  StaticAssertTypeEq<const std::vector<double>&,
      StlContainerView<std::vector<double> >::const_reference>();

  typedef std::vector<char> Chars;
  Chars v1;
  const Chars& v2(StlContainerView<Chars>::ConstReference(v1));
  EXPECT_EQ(&v1, &v2);

  v1.push_back('a');
  Chars v3 = StlContainerView<Chars>::Copy(v1);
  EXPECT_THAT(v3, Eq(v3));
}

TEST(StlContainerViewTest, WorksForStaticNativeArray) {
  StaticAssertTypeEq<NativeArray<int>,
      StlContainerView<int[3]>::type>();
  StaticAssertTypeEq<NativeArray<double>,
      StlContainerView<const double[4]>::type>();
  StaticAssertTypeEq<NativeArray<char[3]>,
      StlContainerView<const char[2][3]>::type>();

  StaticAssertTypeEq<const NativeArray<int>,
      StlContainerView<int[2]>::const_reference>();

  int a1[3] = { 0, 1, 2 };
  NativeArray<int> a2 = StlContainerView<int[3]>::ConstReference(a1);
629
  EXPECT_EQ(3U, a2.size());
630
631
632
  EXPECT_EQ(a1, a2.begin());

  const NativeArray<int> a3 = StlContainerView<int[3]>::Copy(a1);
633
  ASSERT_EQ(3U, a3.size());
634
635
636
637
638
639
640
641
642
643
644
  EXPECT_EQ(0, a3.begin()[0]);
  EXPECT_EQ(1, a3.begin()[1]);
  EXPECT_EQ(2, a3.begin()[2]);

  // Makes sure a1 and a3 aren't aliases.
  a1[0] = 3;
  EXPECT_EQ(0, a3.begin()[0]);
}

TEST(StlContainerViewTest, WorksForDynamicNativeArray) {
  StaticAssertTypeEq<NativeArray<int>,
Abseil Team's avatar
Abseil Team committed
645
646
647
                     StlContainerView<std::tuple<const int*, size_t> >::type>();
  StaticAssertTypeEq<
      NativeArray<double>,
misterg's avatar
misterg committed
648
      StlContainerView<std::tuple<std::shared_ptr<double>, int> >::type>();
649

Abseil Team's avatar
Abseil Team committed
650
651
652
  StaticAssertTypeEq<
      const NativeArray<int>,
      StlContainerView<std::tuple<const int*, int> >::const_reference>();
653
654

  int a1[3] = { 0, 1, 2 };
655
  const int* const p1 = a1;
Abseil Team's avatar
Abseil Team committed
656
657
658
  NativeArray<int> a2 =
      StlContainerView<std::tuple<const int*, int> >::ConstReference(
          std::make_tuple(p1, 3));
659
  EXPECT_EQ(3U, a2.size());
660
661
  EXPECT_EQ(a1, a2.begin());

Abseil Team's avatar
Abseil Team committed
662
663
  const NativeArray<int> a3 = StlContainerView<std::tuple<int*, size_t> >::Copy(
      std::make_tuple(static_cast<int*>(a1), 3));
664
  ASSERT_EQ(3U, a3.size());
665
666
667
668
669
670
671
672
673
  EXPECT_EQ(0, a3.begin()[0]);
  EXPECT_EQ(1, a3.begin()[1]);
  EXPECT_EQ(2, a3.begin()[2]);

  // Makes sure a1 and a3 aren't aliases.
  a1[0] = 3;
  EXPECT_EQ(0, a3.begin()[0]);
}

Abseil Team's avatar
Abseil Team committed
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
// Tests the Function template struct.

TEST(FunctionTest, Nullary) {
  typedef Function<int()> F;  // NOLINT
  EXPECT_EQ(0u, F::ArgumentCount);
  CompileAssertTypesEqual<int, F::Result>();
  CompileAssertTypesEqual<std::tuple<>, F::ArgumentTuple>();
  CompileAssertTypesEqual<std::tuple<>, F::ArgumentMatcherTuple>();
  CompileAssertTypesEqual<void(), F::MakeResultVoid>();
  CompileAssertTypesEqual<IgnoredValue(), F::MakeResultIgnoredValue>();
}

TEST(FunctionTest, Unary) {
  typedef Function<int(bool)> F;  // NOLINT
  EXPECT_EQ(1u, F::ArgumentCount);
  CompileAssertTypesEqual<int, F::Result>();
  CompileAssertTypesEqual<bool, F::Arg<0>::type>();
  CompileAssertTypesEqual<std::tuple<bool>, F::ArgumentTuple>();
  CompileAssertTypesEqual<std::tuple<Matcher<bool> >,
                          F::ArgumentMatcherTuple>();
  CompileAssertTypesEqual<void(bool), F::MakeResultVoid>();  // NOLINT
  CompileAssertTypesEqual<IgnoredValue(bool),  // NOLINT
      F::MakeResultIgnoredValue>();
}

TEST(FunctionTest, Binary) {
  typedef Function<int(bool, const long&)> F;  // NOLINT
  EXPECT_EQ(2u, F::ArgumentCount);
  CompileAssertTypesEqual<int, F::Result>();
  CompileAssertTypesEqual<bool, F::Arg<0>::type>();
  CompileAssertTypesEqual<const long&, F::Arg<1>::type>();  // NOLINT
  CompileAssertTypesEqual<std::tuple<bool, const long&>,  // NOLINT
                          F::ArgumentTuple>();
  CompileAssertTypesEqual<
      std::tuple<Matcher<bool>, Matcher<const long&> >,  // NOLINT
      F::ArgumentMatcherTuple>();
  CompileAssertTypesEqual<void(bool, const long&), F::MakeResultVoid>();  // NOLINT
  CompileAssertTypesEqual<IgnoredValue(bool, const long&),  // NOLINT
      F::MakeResultIgnoredValue>();
}

TEST(FunctionTest, LongArgumentList) {
  typedef Function<char(bool, int, char*, int&, const long&)> F;  // NOLINT
  EXPECT_EQ(5u, F::ArgumentCount);
  CompileAssertTypesEqual<char, F::Result>();
  CompileAssertTypesEqual<bool, F::Arg<0>::type>();
  CompileAssertTypesEqual<int, F::Arg<1>::type>();
  CompileAssertTypesEqual<char*, F::Arg<2>::type>();
  CompileAssertTypesEqual<int&, F::Arg<3>::type>();
  CompileAssertTypesEqual<const long&, F::Arg<4>::type>();  // NOLINT
  CompileAssertTypesEqual<
      std::tuple<bool, int, char*, int&, const long&>,  // NOLINT
      F::ArgumentTuple>();
  CompileAssertTypesEqual<
      std::tuple<Matcher<bool>, Matcher<int>, Matcher<char*>, Matcher<int&>,
                 Matcher<const long&> >,  // NOLINT
      F::ArgumentMatcherTuple>();
  CompileAssertTypesEqual<void(bool, int, char*, int&, const long&),  // NOLINT
                          F::MakeResultVoid>();
  CompileAssertTypesEqual<
      IgnoredValue(bool, int, char*, int&, const long&),  // NOLINT
      F::MakeResultIgnoredValue>();
}

738
739
740
}  // namespace
}  // namespace internal
}  // namespace testing