gmock-internal-utils_test.cc 27.5 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

Abseil Team's avatar
Abseil Team committed
39
#include <cstdint>
40
#include <map>
41
#include <memory>
42
#include <sstream>
kuzkry's avatar
kuzkry committed
43
#include <string>
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 {

73
74
TEST(JoinAsKeyValueTupleTest, JoinsEmptyTuple) {
  EXPECT_EQ("", JoinAsKeyValueTuple({}, Strings()));
Gennadiy Civil's avatar
Gennadiy Civil committed
75
76
}

77
78
TEST(JoinAsKeyValueTupleTest, JoinsOneTuple) {
  EXPECT_EQ("(a: 1)", JoinAsKeyValueTuple({"a"}, {"1"}));
Gennadiy Civil's avatar
Gennadiy Civil committed
79
80
}

81
82
TEST(JoinAsKeyValueTupleTest, JoinsTwoTuple) {
  EXPECT_EQ("(a: 1, b: 2)", JoinAsKeyValueTuple({"a", "b"}, {"1", "2"}));
Gennadiy Civil's avatar
Gennadiy Civil committed
83
84
}

85
86
87
88
89
TEST(JoinAsKeyValueTupleTest, JoinsTenTuple) {
  EXPECT_EQ(
      "(a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10)",
      JoinAsKeyValueTuple({"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"},
                          {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"}));
Gennadiy Civil's avatar
Gennadiy Civil committed
90
91
}

zhanyong.wan's avatar
zhanyong.wan committed
92
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
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_"));
}

126
TEST(GetRawPointerTest, WorksForSmartPointers) {
127
128
129
130
131
132
  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));
133
134
135
}

TEST(GetRawPointerTest, WorksForRawPointers) {
136
137
  int* p = nullptr;
  EXPECT_TRUE(nullptr == GetRawPointer(p));
138
139
140
141
  int n = 1;
  EXPECT_EQ(&n, GetRawPointer(&n));
}

142
143
144
145
146
147
TEST(GetRawPointerTest, WorksForStdReferenceWrapper) {
  int n = 1;
  EXPECT_EQ(&n, GetRawPointer(std::ref(n)));
  EXPECT_EQ(&n, GetRawPointer(std::cref(n)));
}

148
149
// Tests KindOf<T>.

150
151
152
class Base {};
class Derived : public Base {};

153
154
155
156
157
158
159
160
161
162
163
164
165
166
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
Abseil Team's avatar
Abseil Team committed
167
168
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(long long));  // NOLINT
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long long));  // NOLINT
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
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(wchar_t));  // 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.
Abseil Team's avatar
Abseil Team committed
217
218
  EXPECT_TRUE((LosslessArithmeticConvertible<
               unsigned short, uint64_t>::value));  // NOLINT
219
220

  // Signed => unsigned is not fine.
Abseil Team's avatar
Abseil Team committed
221
222
  EXPECT_FALSE((LosslessArithmeticConvertible<
                short, uint64_t>::value));  // NOLINT
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
  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));
Abseil Team's avatar
Abseil Team committed
238
  EXPECT_FALSE((LosslessArithmeticConvertible<uint64_t, int64_t>::value));
239
240
241
242

  // Larger size => smaller size is not fine.
  EXPECT_FALSE((LosslessArithmeticConvertible<long, char>::value));  // NOLINT
  EXPECT_FALSE((LosslessArithmeticConvertible<int, signed char>::value));
Abseil Team's avatar
Abseil Team committed
243
  EXPECT_FALSE((LosslessArithmeticConvertible<int64_t, unsigned int>::value));
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
}

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
Abseil Team's avatar
Abseil Team committed
262
  EXPECT_FALSE((LosslessArithmeticConvertible<double, int64_t>::value));
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
  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
278
  GTEST_INTENTIONAL_CONST_COND_PUSH_()
279
  if (sizeof(double) == sizeof(long double)) {  // NOLINT
billydonahue's avatar
billydonahue committed
280
  GTEST_INTENTIONAL_CONST_COND_POP_()
281
282
283
284
285
286
287
288
    // 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));
  }
}

289
290
291
// Tests the TupleMatches() template function.

TEST(TupleMatchesTest, WorksForSize0) {
Abseil Team's avatar
Abseil Team committed
292
293
  std::tuple<> matchers;
  std::tuple<> values;
294
295
296
297
298

  EXPECT_TRUE(TupleMatches(matchers, values));
}

TEST(TupleMatchesTest, WorksForSize1) {
Abseil Team's avatar
Abseil Team committed
299
300
  std::tuple<Matcher<int> > matchers(Eq(1));
  std::tuple<int> values1(1), values2(2);
301
302
303
304
305
306

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

TEST(TupleMatchesTest, WorksForSize2) {
Abseil Team's avatar
Abseil Team committed
307
308
  std::tuple<Matcher<int>, Matcher<char> > matchers(Eq(1), Eq('a'));
  std::tuple<int, char> values1(1, 'a'), values2(1, 'b'), values3(2, 'a'),
309
310
311
312
313
314
315
316
317
      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
318
319
320
  std::tuple<Matcher<int>, Matcher<char>, Matcher<bool>,
             Matcher<long>,  // NOLINT
             Matcher<std::string> >
321
      matchers(Eq(1), Eq('a'), Eq(true), Eq(2L), Eq("hi"));
Abseil Team's avatar
Abseil Team committed
322
  std::tuple<int, char, bool, long, std::string>  // NOLINT
323
      values1(1, 'a', true, 2L, "hi"), values2(1, 'a', true, 2L, "hello"),
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
      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) {
339
  EXPECT_DEATH_IF_SUPPORTED({
340
341
342
    Assert(false, __FILE__, __LINE__, "This should fail.");
  }, "");

343
  EXPECT_DEATH_IF_SUPPORTED({
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
    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");
}

365
366
367
368
// Tests LogIsVisible().

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

Abseil Team's avatar
Abseil Team committed
371
  void TearDown() override { GMOCK_FLAG_SET(verbose, original_verbose_); }
372

373
  std::string original_verbose_;
374
375
376
};

TEST_F(LogIsVisibleTest, AlwaysReturnsTrueIfVerbosityIsInfo) {
Abseil Team's avatar
Abseil Team committed
377
  GMOCK_FLAG_SET(verbose, kInfoVerbosity);
zhanyong.wan's avatar
zhanyong.wan committed
378
379
  EXPECT_TRUE(LogIsVisible(kInfo));
  EXPECT_TRUE(LogIsVisible(kWarning));
380
381
382
}

TEST_F(LogIsVisibleTest, AlwaysReturnsFalseIfVerbosityIsError) {
Abseil Team's avatar
Abseil Team committed
383
  GMOCK_FLAG_SET(verbose, kErrorVerbosity);
zhanyong.wan's avatar
zhanyong.wan committed
384
385
  EXPECT_FALSE(LogIsVisible(kInfo));
  EXPECT_FALSE(LogIsVisible(kWarning));
386
387
388
}

TEST_F(LogIsVisibleTest, WorksWhenVerbosityIsWarning) {
Abseil Team's avatar
Abseil Team committed
389
  GMOCK_FLAG_SET(verbose, kWarningVerbosity);
zhanyong.wan's avatar
zhanyong.wan committed
390
391
  EXPECT_FALSE(LogIsVisible(kInfo));
  EXPECT_TRUE(LogIsVisible(kWarning));
392
393
}

394
#if GTEST_HAS_STREAM_REDIRECTION
395
396
397
398
399

// Tests the Log() function.

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

// Tests that when the stack_frames_to_skip parameter is negative,
// Log() doesn't include the stack trace in the output.
TEST(LogTest, NoStackTraceWhenStackFramesToSkipIsNegative) {
Abseil Team's avatar
Abseil Team committed
421
  const std::string saved_flag = GMOCK_FLAG_GET(verbose);
Abseil Team's avatar
Abseil Team committed
422
  GMOCK_FLAG_SET(verbose, kInfoVerbosity);
423
  CaptureStdout();
zhanyong.wan's avatar
zhanyong.wan committed
424
  Log(kInfo, "Test log.\n", -1);
425
  EXPECT_STREQ("\nTest log.\n", GetCapturedStdout().c_str());
Abseil Team's avatar
Abseil Team committed
426
  GMOCK_FLAG_SET(verbose, saved_flag);
427
428
}

kosak's avatar
kosak committed
429
struct MockStackTraceGetter : testing::internal::OsStackTraceGetterInterface {
Abseil Team's avatar
Abseil Team committed
430
  std::string CurrentStackTrace(int max_depth, int skip_count) override {
kosak's avatar
kosak committed
431
432
433
    return (testing::Message() << max_depth << "::" << skip_count << "\n")
        .GetString();
  }
Abseil Team's avatar
Abseil Team committed
434
  void UponLeavingGTest() override {}
kosak's avatar
kosak committed
435
436
};

437
438
439
// Tests that in opt mode, a positive stack_frames_to_skip argument is
// treated as 0.
TEST(LogTest, NoSkippingStackFrameInOptMode) {
kosak's avatar
kosak committed
440
441
442
  MockStackTraceGetter* mock_os_stack_trace_getter = new MockStackTraceGetter;
  GetUnitTestImpl()->set_os_stack_trace_getter(mock_os_stack_trace_getter);

443
  CaptureStdout();
zhanyong.wan's avatar
zhanyong.wan committed
444
  Log(kWarning, "Test log.\n", 100);
445
  const std::string log = GetCapturedStdout();
446

447
  std::string expected_trace =
Abseil Team's avatar
Abseil Team committed
448
449
      (testing::Message() << GTEST_FLAG_GET(stack_trace_depth) << "::")
          .GetString();
450
  std::string expected_message =
kosak's avatar
kosak committed
451
452
453
454
455
456
457
458
      "\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)
459
  // In opt mode, no stack frame should be skipped.
kosak's avatar
kosak committed
460
  const int expected_skip_count = 0;
461
# else
462
  // In dbg mode, the stack frames should be skipped.
kosak's avatar
kosak committed
463
  const int expected_skip_count = 100;
464
# endif
kosak's avatar
kosak committed
465
466
467
468
469
470
471
472

  // 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.
473
  GetUnitTestImpl()->set_os_stack_trace_getter(nullptr);
474
475
476
477
478
}

// 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
479
480
  TestLogWithSeverity(kInfoVerbosity, kInfo, true);
  TestLogWithSeverity(kInfoVerbosity, kWarning, true);
481
482
483
484
485
}

// 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
486
487
  TestLogWithSeverity(kWarningVerbosity, kInfo, false);
  TestLogWithSeverity(kWarningVerbosity, kWarning, true);
488
489
490
491
492
}

// 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
493
494
  TestLogWithSeverity(kErrorVerbosity, kInfo, false);
  TestLogWithSeverity(kErrorVerbosity, kWarning, false);
495
496
497
498
499
}

// 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
500
501
  TestLogWithSeverity("invalid", kInfo, false);
  TestLogWithSeverity("invalid", kWarning, true);
502
503
504
505
}

// Verifies that Log() behaves correctly for the given verbosity level
// and log severity.
506
std::string GrabOutput(void(*logger)(), const char* verbosity) {
Abseil Team's avatar
Abseil Team committed
507
  const std::string saved_flag = GMOCK_FLAG_GET(verbose);
Abseil Team's avatar
Abseil Team committed
508
  GMOCK_FLAG_SET(verbose, verbosity);
509
  CaptureStdout();
510
  logger();
Abseil Team's avatar
Abseil Team committed
511
  GMOCK_FLAG_SET(verbose, saved_flag);
512
  return GetCapturedStdout();
513
514
515
516
517
518
519
520
521
522
523
524
}

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
525
}
526
527
528

// Verifies that EXPECT_CALL logs if the --gmock_verbose flag is set to "info".
TEST(ExpectCallTest, LogsWhenVerbosityIsInfo) {
529
  EXPECT_THAT(std::string(GrabOutput(ExpectCallLogger, kInfoVerbosity)),
530
531
532
533
534
535
              HasSubstr("EXPECT_CALL(mock, TestMethod())"));
}

// Verifies that EXPECT_CALL doesn't log
// if the --gmock_verbose flag is set to "warning".
TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsWarning) {
536
  EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kWarningVerbosity).c_str());
537
538
539
540
541
}

// Verifies that EXPECT_CALL doesn't log
// if the --gmock_verbose flag is set to "error".
TEST(ExpectCallTest,  DoesNotLogWhenVerbosityIsError) {
542
  EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kErrorVerbosity).c_str());
543
544
545
546
547
}

void OnCallLogger() {
  DummyMock mock;
  ON_CALL(mock, TestMethod());
Abseil Team's avatar
Abseil Team committed
548
}
549
550
551

// Verifies that ON_CALL logs if the --gmock_verbose flag is set to "info".
TEST(OnCallTest, LogsWhenVerbosityIsInfo) {
552
  EXPECT_THAT(std::string(GrabOutput(OnCallLogger, kInfoVerbosity)),
553
554
555
556
557
558
              HasSubstr("ON_CALL(mock, TestMethod())"));
}

// Verifies that ON_CALL doesn't log
// if the --gmock_verbose flag is set to "warning".
TEST(OnCallTest, DoesNotLogWhenVerbosityIsWarning) {
559
  EXPECT_STREQ("", GrabOutput(OnCallLogger, kWarningVerbosity).c_str());
560
561
562
563
564
}

// Verifies that ON_CALL doesn't log if
// the --gmock_verbose flag is set to "error".
TEST(OnCallTest, DoesNotLogWhenVerbosityIsError) {
565
  EXPECT_STREQ("", GrabOutput(OnCallLogger, kErrorVerbosity).c_str());
566
567
568
569
570
571
572
573
574
}

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

// Verifies that ON_CALL prints provided _ argument.
TEST(OnCallTest, LogsAnythingArgument) {
575
  EXPECT_THAT(std::string(GrabOutput(OnCallAnyArgumentLogger, kInfoVerbosity)),
576
577
578
              HasSubstr("ON_CALL(mock, TestMethodArg(_)"));
}

579
#endif  // GTEST_HAS_STREAM_REDIRECTION
580

581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
// 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);
612
  EXPECT_EQ(3U, a2.size());
613
614
615
  EXPECT_EQ(a1, a2.begin());

  const NativeArray<int> a3 = StlContainerView<int[3]>::Copy(a1);
616
  ASSERT_EQ(3U, a3.size());
617
618
619
620
621
622
623
624
625
626
627
  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
628
629
630
                     StlContainerView<std::tuple<const int*, size_t> >::type>();
  StaticAssertTypeEq<
      NativeArray<double>,
misterg's avatar
misterg committed
631
      StlContainerView<std::tuple<std::shared_ptr<double>, int> >::type>();
632

Abseil Team's avatar
Abseil Team committed
633
634
635
  StaticAssertTypeEq<
      const NativeArray<int>,
      StlContainerView<std::tuple<const int*, int> >::const_reference>();
636
637

  int a1[3] = { 0, 1, 2 };
638
  const int* const p1 = a1;
Abseil Team's avatar
Abseil Team committed
639
640
641
  NativeArray<int> a2 =
      StlContainerView<std::tuple<const int*, int> >::ConstReference(
          std::make_tuple(p1, 3));
642
  EXPECT_EQ(3U, a2.size());
643
644
  EXPECT_EQ(a1, a2.begin());

Abseil Team's avatar
Abseil Team committed
645
646
  const NativeArray<int> a3 = StlContainerView<std::tuple<int*, size_t> >::Copy(
      std::make_tuple(static_cast<int*>(a1), 3));
647
  ASSERT_EQ(3U, a3.size());
648
649
650
651
652
653
654
655
656
  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
657
658
659
660
661
// Tests the Function template struct.

TEST(FunctionTest, Nullary) {
  typedef Function<int()> F;  // NOLINT
  EXPECT_EQ(0u, F::ArgumentCount);
Hosein Ghahremanzadeh's avatar
Hosein Ghahremanzadeh committed
662
663
664
665
666
  EXPECT_TRUE((std::is_same<int, F::Result>::value));
  EXPECT_TRUE((std::is_same<std::tuple<>, F::ArgumentTuple>::value));
  EXPECT_TRUE((std::is_same<std::tuple<>, F::ArgumentMatcherTuple>::value));
  EXPECT_TRUE((std::is_same<void(), F::MakeResultVoid>::value));
  EXPECT_TRUE((std::is_same<IgnoredValue(), F::MakeResultIgnoredValue>::value));
Abseil Team's avatar
Abseil Team committed
667
668
669
670
671
}

TEST(FunctionTest, Unary) {
  typedef Function<int(bool)> F;  // NOLINT
  EXPECT_EQ(1u, F::ArgumentCount);
Hosein Ghahremanzadeh's avatar
Hosein Ghahremanzadeh committed
672
673
674
675
676
677
678
679
  EXPECT_TRUE((std::is_same<int, F::Result>::value));
  EXPECT_TRUE((std::is_same<bool, F::Arg<0>::type>::value));
  EXPECT_TRUE((std::is_same<std::tuple<bool>, F::ArgumentTuple>::value));
  EXPECT_TRUE((
      std::is_same<std::tuple<Matcher<bool>>, F::ArgumentMatcherTuple>::value));
  EXPECT_TRUE((std::is_same<void(bool), F::MakeResultVoid>::value));  // NOLINT
  EXPECT_TRUE((std::is_same<IgnoredValue(bool),                       // NOLINT
                            F::MakeResultIgnoredValue>::value));
Abseil Team's avatar
Abseil Team committed
680
681
682
683
684
}

TEST(FunctionTest, Binary) {
  typedef Function<int(bool, const long&)> F;  // NOLINT
  EXPECT_EQ(2u, F::ArgumentCount);
Hosein Ghahremanzadeh's avatar
Hosein Ghahremanzadeh committed
685
686
687
688
689
690
691
692
693
694
695
696
  EXPECT_TRUE((std::is_same<int, F::Result>::value));
  EXPECT_TRUE((std::is_same<bool, F::Arg<0>::type>::value));
  EXPECT_TRUE((std::is_same<const long&, F::Arg<1>::type>::value));  // NOLINT
  EXPECT_TRUE((std::is_same<std::tuple<bool, const long&>,           // NOLINT
                            F::ArgumentTuple>::value));
  EXPECT_TRUE(
      (std::is_same<std::tuple<Matcher<bool>, Matcher<const long&>>,  // NOLINT
                    F::ArgumentMatcherTuple>::value));
  EXPECT_TRUE((std::is_same<void(bool, const long&),  // NOLINT
                            F::MakeResultVoid>::value));
  EXPECT_TRUE((std::is_same<IgnoredValue(bool, const long&),  // NOLINT
                            F::MakeResultIgnoredValue>::value));
Abseil Team's avatar
Abseil Team committed
697
698
699
700
701
}

TEST(FunctionTest, LongArgumentList) {
  typedef Function<char(bool, int, char*, int&, const long&)> F;  // NOLINT
  EXPECT_EQ(5u, F::ArgumentCount);
Hosein Ghahremanzadeh's avatar
Hosein Ghahremanzadeh committed
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
  EXPECT_TRUE((std::is_same<char, F::Result>::value));
  EXPECT_TRUE((std::is_same<bool, F::Arg<0>::type>::value));
  EXPECT_TRUE((std::is_same<int, F::Arg<1>::type>::value));
  EXPECT_TRUE((std::is_same<char*, F::Arg<2>::type>::value));
  EXPECT_TRUE((std::is_same<int&, F::Arg<3>::type>::value));
  EXPECT_TRUE((std::is_same<const long&, F::Arg<4>::type>::value));  // NOLINT
  EXPECT_TRUE(
      (std::is_same<std::tuple<bool, int, char*, int&, const long&>,  // NOLINT
                    F::ArgumentTuple>::value));
  EXPECT_TRUE(
      (std::is_same<
          std::tuple<Matcher<bool>, Matcher<int>, Matcher<char*>, Matcher<int&>,
                     Matcher<const long&>>,  // NOLINT
          F::ArgumentMatcherTuple>::value));
  EXPECT_TRUE(
      (std::is_same<void(bool, int, char*, int&, const long&),  // NOLINT
                    F::MakeResultVoid>::value));
  EXPECT_TRUE((
      std::is_same<IgnoredValue(bool, int, char*, int&, const long&),  // NOLINT
                   F::MakeResultIgnoredValue>::value));
Abseil Team's avatar
Abseil Team committed
722
723
}

Abseil Team's avatar
Abseil Team committed
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
TEST(Base64Unescape, InvalidString) {
  std::string unescaped;
  EXPECT_FALSE(Base64Unescape("(invalid)", &unescaped));
}

TEST(Base64Unescape, ShortString) {
  std::string unescaped;
  EXPECT_TRUE(Base64Unescape("SGVsbG8gd29ybGQh", &unescaped));
  EXPECT_EQ("Hello world!", unescaped);
}

TEST(Base64Unescape, ShortStringWithPadding) {
  std::string unescaped;
  EXPECT_TRUE(Base64Unescape("SGVsbG8gd29ybGQ=", &unescaped));
  EXPECT_EQ("Hello world", unescaped);
}

TEST(Base64Unescape, ShortStringWithoutPadding) {
  std::string unescaped;
  EXPECT_TRUE(Base64Unescape("SGVsbG8gd29ybGQ", &unescaped));
  EXPECT_EQ("Hello world", unescaped);
}

TEST(Base64Unescape, LongStringWithWhiteSpaces) {
  std::string escaped =
      R"(TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz
  IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2Yg
  dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu
  dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRo
  ZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=)";
  std::string expected =
      "Man is distinguished, not only by his reason, but by this singular "
      "passion from other animals, which is a lust of the mind, that by a "
      "perseverance of delight in the continued and indefatigable generation "
      "of knowledge, exceeds the short vehemence of any carnal pleasure.";
  std::string unescaped;
  EXPECT_TRUE(Base64Unescape(escaped, &unescaped));
  EXPECT_EQ(expected, unescaped);
}

764
765
766
}  // namespace
}  // namespace internal
}  // namespace testing