gmock-actions_test.cc 46.8 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 built-in actions.

Gennadiy Civil's avatar
 
Gennadiy Civil committed
35
// Silence C4800 (C4800: 'int *const ': forcing value
36
// to bool 'true' or 'false') for MSVC 15
Gennadiy Civil's avatar
 
Gennadiy Civil committed
37
#ifdef _MSC_VER
38
#if _MSC_VER == 1900
Gennadiy Civil's avatar
 
Gennadiy Civil committed
39
40
41
42
43
#  pragma warning(push)
#  pragma warning(disable:4800)
#endif
#endif

44
#include "gmock/gmock-actions.h"
45
46
#include <algorithm>
#include <iterator>
47
#include <memory>
48
#include <string>
49
50
51
52
#include "gmock/gmock.h"
#include "gmock/internal/gmock-port.h"
#include "gtest/gtest.h"
#include "gtest/gtest-spi.h"
53
54
55
56
57
58
59

namespace {

// This list should be kept sorted.
using testing::Action;
using testing::ActionInterface;
using testing::Assign;
60
using testing::ByMove;
61
using testing::ByRef;
62
63
64
65
66
67
68
69
70
71
72
using testing::DefaultValue;
using testing::DoDefault;
using testing::IgnoreResult;
using testing::Invoke;
using testing::InvokeWithoutArgs;
using testing::MakePolymorphicAction;
using testing::Ne;
using testing::PolymorphicAction;
using testing::Return;
using testing::ReturnNull;
using testing::ReturnRef;
73
using testing::ReturnRefOfCopy;
74
using testing::SetArgPointee;
75
using testing::SetArgumentPointee;
Gennadiy Civil's avatar
 
Gennadiy Civil committed
76
using testing::Unused;
Abseil Team's avatar
Abseil Team committed
77
using testing::WithArgs;
78
79
80
81
using testing::_;
using testing::internal::BuiltInDefaultValue;
using testing::internal::Int64;
using testing::internal::UInt64;
82

83
#if !GTEST_OS_WINDOWS_MOBILE
84
using testing::SetErrnoAndReturn;
85
#endif
86
87
88

// Tests that BuiltInDefaultValue<T*>::Get() returns NULL.
TEST(BuiltInDefaultValueTest, IsNullForPointerTypes) {
89
90
91
  EXPECT_TRUE(BuiltInDefaultValue<int*>::Get() == nullptr);
  EXPECT_TRUE(BuiltInDefaultValue<const char*>::Get() == nullptr);
  EXPECT_TRUE(BuiltInDefaultValue<void*>::Get() == nullptr);
92
93
}

94
95
96
97
98
99
100
// Tests that BuiltInDefaultValue<T*>::Exists() return true.
TEST(BuiltInDefaultValueTest, ExistsForPointerTypes) {
  EXPECT_TRUE(BuiltInDefaultValue<int*>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<const char*>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<void*>::Exists());
}

101
102
103
// Tests that BuiltInDefaultValue<T>::Get() returns 0 when T is a
// built-in numeric type.
TEST(BuiltInDefaultValueTest, IsZeroForNumericTypes) {
104
  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned char>::Get());
105
106
  EXPECT_EQ(0, BuiltInDefaultValue<signed char>::Get());
  EXPECT_EQ(0, BuiltInDefaultValue<char>::Get());
107
#if GMOCK_HAS_SIGNED_WCHAR_T_
108
  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned wchar_t>::Get());
109
  EXPECT_EQ(0, BuiltInDefaultValue<signed wchar_t>::Get());
110
111
#endif
#if GMOCK_WCHAR_T_IS_NATIVE_
112
#if !defined(__WCHAR_UNSIGNED__)
113
  EXPECT_EQ(0, BuiltInDefaultValue<wchar_t>::Get());
114
115
116
#else
  EXPECT_EQ(0U, BuiltInDefaultValue<wchar_t>::Get());
#endif
117
#endif
118
  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned short>::Get());  // NOLINT
119
120
  EXPECT_EQ(0, BuiltInDefaultValue<signed short>::Get());  // NOLINT
  EXPECT_EQ(0, BuiltInDefaultValue<short>::Get());  // NOLINT
121
  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned int>::Get());
122
123
  EXPECT_EQ(0, BuiltInDefaultValue<signed int>::Get());
  EXPECT_EQ(0, BuiltInDefaultValue<int>::Get());
124
  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned long>::Get());  // NOLINT
125
126
  EXPECT_EQ(0, BuiltInDefaultValue<signed long>::Get());  // NOLINT
  EXPECT_EQ(0, BuiltInDefaultValue<long>::Get());  // NOLINT
127
  EXPECT_EQ(0U, BuiltInDefaultValue<UInt64>::Get());
128
129
130
131
132
  EXPECT_EQ(0, BuiltInDefaultValue<Int64>::Get());
  EXPECT_EQ(0, BuiltInDefaultValue<float>::Get());
  EXPECT_EQ(0, BuiltInDefaultValue<double>::Get());
}

133
134
135
136
137
138
// Tests that BuiltInDefaultValue<T>::Exists() returns true when T is a
// built-in numeric type.
TEST(BuiltInDefaultValueTest, ExistsForNumericTypes) {
  EXPECT_TRUE(BuiltInDefaultValue<unsigned char>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<signed char>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<char>::Exists());
139
#if GMOCK_HAS_SIGNED_WCHAR_T_
140
141
  EXPECT_TRUE(BuiltInDefaultValue<unsigned wchar_t>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<signed wchar_t>::Exists());
142
143
#endif
#if GMOCK_WCHAR_T_IS_NATIVE_
144
  EXPECT_TRUE(BuiltInDefaultValue<wchar_t>::Exists());
145
#endif
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
  EXPECT_TRUE(BuiltInDefaultValue<unsigned short>::Exists());  // NOLINT
  EXPECT_TRUE(BuiltInDefaultValue<signed short>::Exists());  // NOLINT
  EXPECT_TRUE(BuiltInDefaultValue<short>::Exists());  // NOLINT
  EXPECT_TRUE(BuiltInDefaultValue<unsigned int>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<signed int>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<int>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<unsigned long>::Exists());  // NOLINT
  EXPECT_TRUE(BuiltInDefaultValue<signed long>::Exists());  // NOLINT
  EXPECT_TRUE(BuiltInDefaultValue<long>::Exists());  // NOLINT
  EXPECT_TRUE(BuiltInDefaultValue<UInt64>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<Int64>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<float>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<double>::Exists());
}

161
162
163
164
165
// Tests that BuiltInDefaultValue<bool>::Get() returns false.
TEST(BuiltInDefaultValueTest, IsFalseForBool) {
  EXPECT_FALSE(BuiltInDefaultValue<bool>::Get());
}

166
167
168
169
170
// Tests that BuiltInDefaultValue<bool>::Exists() returns true.
TEST(BuiltInDefaultValueTest, BoolExists) {
  EXPECT_TRUE(BuiltInDefaultValue<bool>::Exists());
}

171
172
173
174
175
176
177
178
179
180
// Tests that BuiltInDefaultValue<T>::Get() returns "" when T is a
// string type.
TEST(BuiltInDefaultValueTest, IsEmptyStringForString) {
#if GTEST_HAS_GLOBAL_STRING
  EXPECT_EQ("", BuiltInDefaultValue< ::string>::Get());
#endif  // GTEST_HAS_GLOBAL_STRING

  EXPECT_EQ("", BuiltInDefaultValue< ::std::string>::Get());
}

181
182
183
184
185
186
187
188
189
190
// Tests that BuiltInDefaultValue<T>::Exists() returns true when T is a
// string type.
TEST(BuiltInDefaultValueTest, ExistsForString) {
#if GTEST_HAS_GLOBAL_STRING
  EXPECT_TRUE(BuiltInDefaultValue< ::string>::Exists());
#endif  // GTEST_HAS_GLOBAL_STRING

  EXPECT_TRUE(BuiltInDefaultValue< ::std::string>::Exists());
}

191
192
193
194
195
// Tests that BuiltInDefaultValue<const T>::Get() returns the same
// value as BuiltInDefaultValue<T>::Get() does.
TEST(BuiltInDefaultValueTest, WorksForConstTypes) {
  EXPECT_EQ("", BuiltInDefaultValue<const std::string>::Get());
  EXPECT_EQ(0, BuiltInDefaultValue<const int>::Get());
196
  EXPECT_TRUE(BuiltInDefaultValue<char* const>::Get() == nullptr);
197
198
199
  EXPECT_FALSE(BuiltInDefaultValue<const bool>::Get());
}

200
201
202
203
204
205
// A type that's default constructible.
class MyDefaultConstructible {
 public:
  MyDefaultConstructible() : value_(42) {}

  int value() const { return value_; }
206

207
208
 private:
  int value_;
209
210
};

211
212
213
214
215
216
217
218
219
220
221
222
// A type that's not default constructible.
class MyNonDefaultConstructible {
 public:
  // Does not have a default ctor.
  explicit MyNonDefaultConstructible(int a_value) : value_(a_value) {}

  int value() const { return value_; }

 private:
  int value_;
};

223
#if GTEST_LANG_CXX11
224
225
226
227
228
229
230
231
232

TEST(BuiltInDefaultValueTest, ExistsForDefaultConstructibleType) {
  EXPECT_TRUE(BuiltInDefaultValue<MyDefaultConstructible>::Exists());
}

TEST(BuiltInDefaultValueTest, IsDefaultConstructedForDefaultConstructibleType) {
  EXPECT_EQ(42, BuiltInDefaultValue<MyDefaultConstructible>::Get().value());
}

233
#endif  // GTEST_LANG_CXX11
234
235
236

TEST(BuiltInDefaultValueTest, DoesNotExistForNonDefaultConstructibleType) {
  EXPECT_FALSE(BuiltInDefaultValue<MyNonDefaultConstructible>::Exists());
237
238
}

239
240
// Tests that BuiltInDefaultValue<T&>::Get() aborts the program.
TEST(BuiltInDefaultValueDeathTest, IsUndefinedForReferences) {
241
  EXPECT_DEATH_IF_SUPPORTED({
242
243
    BuiltInDefaultValue<int&>::Get();
  }, "");
244
  EXPECT_DEATH_IF_SUPPORTED({
245
246
247
248
    BuiltInDefaultValue<const char&>::Get();
  }, "");
}

249
TEST(BuiltInDefaultValueDeathTest, IsUndefinedForNonDefaultConstructibleType) {
250
  EXPECT_DEATH_IF_SUPPORTED({
251
    BuiltInDefaultValue<MyNonDefaultConstructible>::Get();
252
253
254
255
256
257
  }, "");
}

// Tests that DefaultValue<T>::IsSet() is false initially.
TEST(DefaultValueTest, IsInitiallyUnset) {
  EXPECT_FALSE(DefaultValue<int>::IsSet());
258
259
  EXPECT_FALSE(DefaultValue<MyDefaultConstructible>::IsSet());
  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::IsSet());
260
261
262
263
}

// Tests that DefaultValue<T> can be set and then unset.
TEST(DefaultValueTest, CanBeSetAndUnset) {
264
  EXPECT_TRUE(DefaultValue<int>::Exists());
265
  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::Exists());
266

267
  DefaultValue<int>::Set(1);
268
269
  DefaultValue<const MyNonDefaultConstructible>::Set(
      MyNonDefaultConstructible(42));
270
271

  EXPECT_EQ(1, DefaultValue<int>::Get());
272
  EXPECT_EQ(42, DefaultValue<const MyNonDefaultConstructible>::Get().value());
273

274
  EXPECT_TRUE(DefaultValue<int>::Exists());
275
  EXPECT_TRUE(DefaultValue<const MyNonDefaultConstructible>::Exists());
276

277
  DefaultValue<int>::Clear();
278
  DefaultValue<const MyNonDefaultConstructible>::Clear();
279
280

  EXPECT_FALSE(DefaultValue<int>::IsSet());
281
  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::IsSet());
282
283

  EXPECT_TRUE(DefaultValue<int>::Exists());
284
  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::Exists());
285
286
287
288
289
290
291
}

// Tests that DefaultValue<T>::Get() returns the
// BuiltInDefaultValue<T>::Get() when DefaultValue<T>::IsSet() is
// false.
TEST(DefaultValueDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
  EXPECT_FALSE(DefaultValue<int>::IsSet());
292
  EXPECT_TRUE(DefaultValue<int>::Exists());
293
294
  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible>::IsSet());
  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible>::Exists());
295
296
297

  EXPECT_EQ(0, DefaultValue<int>::Get());

298
  EXPECT_DEATH_IF_SUPPORTED({
299
    DefaultValue<MyNonDefaultConstructible>::Get();
300
301
302
  }, "");
}

303
#if GTEST_HAS_STD_UNIQUE_PTR_
304
305
TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) {
  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
306
  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Get() == nullptr);
307
308
309
310
311
312
313
  DefaultValue<std::unique_ptr<int>>::SetFactory([] {
    return std::unique_ptr<int>(new int(42));
  });
  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
  std::unique_ptr<int> i = DefaultValue<std::unique_ptr<int>>::Get();
  EXPECT_EQ(42, *i);
}
314
#endif  // GTEST_HAS_STD_UNIQUE_PTR_
315

316
317
318
319
320
321
322
323
324
325
// Tests that DefaultValue<void>::Get() returns void.
TEST(DefaultValueTest, GetWorksForVoid) {
  return DefaultValue<void>::Get();
}

// Tests using DefaultValue with a reference type.

// Tests that DefaultValue<T&>::IsSet() is false initially.
TEST(DefaultValueOfReferenceTest, IsInitiallyUnset) {
  EXPECT_FALSE(DefaultValue<int&>::IsSet());
326
327
  EXPECT_FALSE(DefaultValue<MyDefaultConstructible&>::IsSet());
  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
328
329
}

330
331
332
// Tests that DefaultValue<T&>::Exists is false initiallly.
TEST(DefaultValueOfReferenceTest, IsInitiallyNotExisting) {
  EXPECT_FALSE(DefaultValue<int&>::Exists());
333
334
  EXPECT_FALSE(DefaultValue<MyDefaultConstructible&>::Exists());
  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::Exists());
335
336
}

337
338
339
340
// Tests that DefaultValue<T&> can be set and then unset.
TEST(DefaultValueOfReferenceTest, CanBeSetAndUnset) {
  int n = 1;
  DefaultValue<const int&>::Set(n);
341
342
  MyNonDefaultConstructible x(42);
  DefaultValue<MyNonDefaultConstructible&>::Set(x);
343

344
  EXPECT_TRUE(DefaultValue<const int&>::Exists());
345
  EXPECT_TRUE(DefaultValue<MyNonDefaultConstructible&>::Exists());
346

347
  EXPECT_EQ(&n, &(DefaultValue<const int&>::Get()));
348
  EXPECT_EQ(&x, &(DefaultValue<MyNonDefaultConstructible&>::Get()));
349
350

  DefaultValue<const int&>::Clear();
351
  DefaultValue<MyNonDefaultConstructible&>::Clear();
352

353
  EXPECT_FALSE(DefaultValue<const int&>::Exists());
354
  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::Exists());
355

356
  EXPECT_FALSE(DefaultValue<const int&>::IsSet());
357
  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
358
359
360
361
362
363
364
}

// Tests that DefaultValue<T&>::Get() returns the
// BuiltInDefaultValue<T&>::Get() when DefaultValue<T&>::IsSet() is
// false.
TEST(DefaultValueOfReferenceDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
  EXPECT_FALSE(DefaultValue<int&>::IsSet());
365
  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
366

367
  EXPECT_DEATH_IF_SUPPORTED({
368
369
    DefaultValue<int&>::Get();
  }, "");
370
  EXPECT_DEATH_IF_SUPPORTED({
371
    DefaultValue<MyNonDefaultConstructible>::Get();
372
373
374
375
376
377
  }, "");
}

// Tests that ActionInterface can be implemented by defining the
// Perform method.

378
typedef int MyGlobalFunction(bool, int);
379

380
class MyActionImpl : public ActionInterface<MyGlobalFunction> {
381
 public:
Abseil Team's avatar
Abseil Team committed
382
383
  virtual int Perform(const std::tuple<bool, int>& args) {
    return std::get<0>(args) ? std::get<1>(args) : 0;
384
385
386
387
388
  }
};

TEST(ActionInterfaceTest, CanBeImplementedByDefiningPerform) {
  MyActionImpl my_action_impl;
389
  (void)my_action_impl;
390
391
392
}

TEST(ActionInterfaceTest, MakeAction) {
393
  Action<MyGlobalFunction> action = MakeAction(new MyActionImpl);
394
395
396
397
398

  // When exercising the Perform() method of Action<F>, we must pass
  // it a tuple whose size and type are compatible with F's argument
  // types.  For example, if F is int(), then Perform() takes a
  // 0-tuple; if F is void(bool, int), then Perform() takes a
Abseil Team's avatar
Abseil Team committed
399
400
  // std::tuple<bool, int>, and so on.
  EXPECT_EQ(5, action.Perform(std::make_tuple(true, 5)));
401
402
403
404
405
}

// Tests that Action<F> can be contructed from a pointer to
// ActionInterface<F>.
TEST(ActionTest, CanBeConstructedFromActionInterface) {
406
  Action<MyGlobalFunction> action(new MyActionImpl);
407
408
409
410
}

// Tests that Action<F> delegates actual work to ActionInterface<F>.
TEST(ActionTest, DelegatesWorkToActionInterface) {
411
  const Action<MyGlobalFunction> action(new MyActionImpl);
412

Abseil Team's avatar
Abseil Team committed
413
414
  EXPECT_EQ(5, action.Perform(std::make_tuple(true, 5)));
  EXPECT_EQ(0, action.Perform(std::make_tuple(false, 1)));
415
416
417
418
}

// Tests that Action<F> can be copied.
TEST(ActionTest, IsCopyable) {
419
420
  Action<MyGlobalFunction> a1(new MyActionImpl);
  Action<MyGlobalFunction> a2(a1);  // Tests the copy constructor.
421
422

  // a1 should continue to work after being copied from.
Abseil Team's avatar
Abseil Team committed
423
424
  EXPECT_EQ(5, a1.Perform(std::make_tuple(true, 5)));
  EXPECT_EQ(0, a1.Perform(std::make_tuple(false, 1)));
425
426

  // a2 should work like the action it was copied from.
Abseil Team's avatar
Abseil Team committed
427
428
  EXPECT_EQ(5, a2.Perform(std::make_tuple(true, 5)));
  EXPECT_EQ(0, a2.Perform(std::make_tuple(false, 1)));
429
430
431
432

  a2 = a1;  // Tests the assignment operator.

  // a1 should continue to work after being copied from.
Abseil Team's avatar
Abseil Team committed
433
434
  EXPECT_EQ(5, a1.Perform(std::make_tuple(true, 5)));
  EXPECT_EQ(0, a1.Perform(std::make_tuple(false, 1)));
435
436

  // a2 should work like the action it was copied from.
Abseil Team's avatar
Abseil Team committed
437
438
  EXPECT_EQ(5, a2.Perform(std::make_tuple(true, 5)));
  EXPECT_EQ(0, a2.Perform(std::make_tuple(false, 1)));
439
440
441
442
443
444
445
}

// Tests that an Action<From> object can be converted to a
// compatible Action<To> object.

class IsNotZero : public ActionInterface<bool(int)> {  // NOLINT
 public:
Abseil Team's avatar
Abseil Team committed
446
447
  virtual bool Perform(const std::tuple<int>& arg) {
    return std::get<0>(arg) != 0;
448
449
450
  }
};

451
452
453
454
455
456
#if !GTEST_OS_SYMBIAN
// Compiling this test on Nokia's Symbian compiler fails with:
//  'Result' is not a member of class 'testing::internal::Function<int>'
//  (point of instantiation: '@unnamed@gmock_actions_test_cc@::
//      ActionTest_CanBeConvertedToOtherActionType_Test::TestBody()')
// with no obvious fix.
457
458
459
TEST(ActionTest, CanBeConvertedToOtherActionType) {
  const Action<bool(int)> a1(new IsNotZero);  // NOLINT
  const Action<int(char)> a2 = Action<int(char)>(a1);  // NOLINT
Abseil Team's avatar
Abseil Team committed
460
461
  EXPECT_EQ(1, a2.Perform(std::make_tuple('a')));
  EXPECT_EQ(0, a2.Perform(std::make_tuple('\0')));
462
}
463
#endif  // !GTEST_OS_SYMBIAN
464
465
466
467
468
469
470
471
472
473
474

// The following two classes are for testing MakePolymorphicAction().

// Implements a polymorphic action that returns the second of the
// arguments it receives.
class ReturnSecondArgumentAction {
 public:
  // We want to verify that MakePolymorphicAction() can work with a
  // polymorphic action whose Perform() method template is either
  // const or not.  This lets us verify the non-const case.
  template <typename Result, typename ArgumentTuple>
Abseil Team's avatar
Abseil Team committed
475
476
477
  Result Perform(const ArgumentTuple& args) {
    return std::get<1>(args);
  }
478
479
480
481
482
483
484
485
486
487
488
489
490
491
};

// Implements a polymorphic action that can be used in a nullary
// function to return 0.
class ReturnZeroFromNullaryFunctionAction {
 public:
  // For testing that MakePolymorphicAction() works when the
  // implementation class' Perform() method template takes only one
  // template parameter.
  //
  // We want to verify that MakePolymorphicAction() can work with a
  // polymorphic action whose Perform() method template is either
  // const or not.  This lets us verify the const case.
  template <typename Result>
Abseil Team's avatar
Abseil Team committed
492
493
494
  Result Perform(const std::tuple<>&) const {
    return 0;
  }
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
};

// These functions verify that MakePolymorphicAction() returns a
// PolymorphicAction<T> where T is the argument's type.

PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {
  return MakePolymorphicAction(ReturnSecondArgumentAction());
}

PolymorphicAction<ReturnZeroFromNullaryFunctionAction>
ReturnZeroFromNullaryFunction() {
  return MakePolymorphicAction(ReturnZeroFromNullaryFunctionAction());
}

// Tests that MakePolymorphicAction() turns a polymorphic action
// implementation class into a polymorphic action.
TEST(MakePolymorphicActionTest, ConstructsActionFromImpl) {
  Action<int(bool, int, double)> a1 = ReturnSecondArgument();  // NOLINT
Abseil Team's avatar
Abseil Team committed
513
  EXPECT_EQ(5, a1.Perform(std::make_tuple(false, 5, 2.0)));
514
515
516
517
518
519
}

// Tests that MakePolymorphicAction() works when the implementation
// class' Perform() method template has only one template parameter.
TEST(MakePolymorphicActionTest, WorksWhenPerformHasOneTemplateParameter) {
  Action<int()> a1 = ReturnZeroFromNullaryFunction();
Abseil Team's avatar
Abseil Team committed
520
  EXPECT_EQ(0, a1.Perform(std::make_tuple()));
521
522

  Action<void*()> a2 = ReturnZeroFromNullaryFunction();
Abseil Team's avatar
Abseil Team committed
523
  EXPECT_TRUE(a2.Perform(std::make_tuple()) == nullptr);
524
525
526
527
528
529
}

// Tests that Return() works as an action for void-returning
// functions.
TEST(ReturnTest, WorksForVoid) {
  const Action<void(int)> ret = Return();  // NOLINT
Abseil Team's avatar
Abseil Team committed
530
  return ret.Perform(std::make_tuple(1));
531
532
533
534
535
}

// Tests that Return(v) returns v.
TEST(ReturnTest, ReturnsGivenValue) {
  Action<int()> ret = Return(1);  // NOLINT
Abseil Team's avatar
Abseil Team committed
536
  EXPECT_EQ(1, ret.Perform(std::make_tuple()));
537
538

  ret = Return(-5);
Abseil Team's avatar
Abseil Team committed
539
  EXPECT_EQ(-5, ret.Perform(std::make_tuple()));
540
541
542
543
544
}

// Tests that Return("string literal") works.
TEST(ReturnTest, AcceptsStringLiteral) {
  Action<const char*()> a1 = Return("Hello");
Abseil Team's avatar
Abseil Team committed
545
  EXPECT_STREQ("Hello", a1.Perform(std::make_tuple()));
546
547

  Action<std::string()> a2 = Return("world");
Abseil Team's avatar
Abseil Team committed
548
  EXPECT_EQ("world", a2.Perform(std::make_tuple()));
549
550
}

551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
// Test struct which wraps a vector of integers. Used in
// 'SupportsWrapperReturnType' test.
struct IntegerVectorWrapper {
  std::vector<int> * v;
  IntegerVectorWrapper(std::vector<int>& _v) : v(&_v) {}  // NOLINT
};

// Tests that Return() works when return type is a wrapper type.
TEST(ReturnTest, SupportsWrapperReturnType) {
  // Initialize vector of integers.
  std::vector<int> v;
  for (int i = 0; i < 5; ++i) v.push_back(i);

  // Return() called with 'v' as argument. The Action will return the same data
  // as 'v' (copy) but it will be wrapped in an IntegerVectorWrapper.
  Action<IntegerVectorWrapper()> a = Return(v);
Abseil Team's avatar
Abseil Team committed
567
  const std::vector<int>& result = *(a.Perform(std::make_tuple()).v);
568
569
570
  EXPECT_THAT(result, ::testing::ElementsAre(0, 1, 2, 3, 4));
}

571
572
573
574
575
576
577
578
579
580
581
582
583
584
// Tests that Return(v) is covaraint.

struct Base {
  bool operator==(const Base&) { return true; }
};

struct Derived : public Base {
  bool operator==(const Derived&) { return true; }
};

TEST(ReturnTest, IsCovariant) {
  Base base;
  Derived derived;
  Action<Base*()> ret = Return(&base);
Abseil Team's avatar
Abseil Team committed
585
  EXPECT_EQ(&base, ret.Perform(std::make_tuple()));
586
587

  ret = Return(&derived);
Abseil Team's avatar
Abseil Team committed
588
  EXPECT_EQ(&derived, ret.Perform(std::make_tuple()));
589
590
}

591
592
593
594
595
596
// Tests that the type of the value passed into Return is converted into T
// when the action is cast to Action<T(...)> rather than when the action is
// performed. See comments on testing::internal::ReturnAction in
// gmock-actions.h for more information.
class FromType {
 public:
597
  explicit FromType(bool* is_converted) : converted_(is_converted) {}
598
599
600
601
  bool* converted() const { return converted_; }

 private:
  bool* const converted_;
602
603

  GTEST_DISALLOW_ASSIGN_(FromType);
604
605
606
607
};

class ToType {
 public:
608
609
  // Must allow implicit conversion due to use in ImplicitCast_<T>.
  ToType(const FromType& x) { *x.converted() = true; }  // NOLINT
610
611
612
613
614
615
616
617
618
};

TEST(ReturnTest, ConvertsArgumentWhenConverted) {
  bool converted = false;
  FromType x(&converted);
  Action<ToType()> action(Return(x));
  EXPECT_TRUE(converted) << "Return must convert its argument in its own "
                         << "conversion operator.";
  converted = false;
Abseil Team's avatar
Abseil Team committed
619
  action.Perform(std::tuple<>());
620
  EXPECT_FALSE(converted) << "Action must NOT convert its argument "
621
                          << "when performed.";
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
}

class DestinationType {};

class SourceType {
 public:
  // Note: a non-const typecast operator.
  operator DestinationType() { return DestinationType(); }
};

TEST(ReturnTest, CanConvertArgumentUsingNonConstTypeCastOperator) {
  SourceType s;
  Action<DestinationType()> action(Return(s));
}

637
638
639
// Tests that ReturnNull() returns NULL in a pointer-returning function.
TEST(ReturnNullTest, WorksInPointerReturningFunction) {
  const Action<int*()> a1 = ReturnNull();
Abseil Team's avatar
Abseil Team committed
640
  EXPECT_TRUE(a1.Perform(std::make_tuple()) == nullptr);
641
642

  const Action<const char*(bool)> a2 = ReturnNull();  // NOLINT
Abseil Team's avatar
Abseil Team committed
643
  EXPECT_TRUE(a2.Perform(std::make_tuple(true)) == nullptr);
644
645
}

646
647
648
649
650
#if GTEST_HAS_STD_UNIQUE_PTR_
// Tests that ReturnNull() returns NULL for shared_ptr and unique_ptr returning
// functions.
TEST(ReturnNullTest, WorksInSmartPointerReturningFunction) {
  const Action<std::unique_ptr<const int>()> a1 = ReturnNull();
Abseil Team's avatar
Abseil Team committed
651
  EXPECT_TRUE(a1.Perform(std::make_tuple()) == nullptr);
652
653

  const Action<std::shared_ptr<int>(std::string)> a2 = ReturnNull();
Abseil Team's avatar
Abseil Team committed
654
  EXPECT_TRUE(a2.Perform(std::make_tuple("foo")) == nullptr);
655
656
657
}
#endif  // GTEST_HAS_STD_UNIQUE_PTR_

658
659
660
661
662
// Tests that ReturnRef(v) works for reference types.
TEST(ReturnRefTest, WorksForReference) {
  const int n = 0;
  const Action<const int&(bool)> ret = ReturnRef(n);  // NOLINT

Abseil Team's avatar
Abseil Team committed
663
  EXPECT_EQ(&n, &ret.Perform(std::make_tuple(true)));
664
665
666
667
668
669
670
}

// Tests that ReturnRef(v) is covariant.
TEST(ReturnRefTest, IsCovariant) {
  Base base;
  Derived derived;
  Action<Base&()> a = ReturnRef(base);
Abseil Team's avatar
Abseil Team committed
671
  EXPECT_EQ(&base, &a.Perform(std::make_tuple()));
672
673

  a = ReturnRef(derived);
Abseil Team's avatar
Abseil Team committed
674
  EXPECT_EQ(&derived, &a.Perform(std::make_tuple()));
675
676
}

677
678
679
680
681
// Tests that ReturnRefOfCopy(v) works for reference types.
TEST(ReturnRefOfCopyTest, WorksForReference) {
  int n = 42;
  const Action<const int&()> ret = ReturnRefOfCopy(n);

Abseil Team's avatar
Abseil Team committed
682
683
  EXPECT_NE(&n, &ret.Perform(std::make_tuple()));
  EXPECT_EQ(42, ret.Perform(std::make_tuple()));
684
685

  n = 43;
Abseil Team's avatar
Abseil Team committed
686
687
  EXPECT_NE(&n, &ret.Perform(std::make_tuple()));
  EXPECT_EQ(42, ret.Perform(std::make_tuple()));
688
689
690
691
692
693
694
}

// Tests that ReturnRefOfCopy(v) is covariant.
TEST(ReturnRefOfCopyTest, IsCovariant) {
  Base base;
  Derived derived;
  Action<Base&()> a = ReturnRefOfCopy(base);
Abseil Team's avatar
Abseil Team committed
695
  EXPECT_NE(&base, &a.Perform(std::make_tuple()));
696
697

  a = ReturnRefOfCopy(derived);
Abseil Team's avatar
Abseil Team committed
698
  EXPECT_NE(&derived, &a.Perform(std::make_tuple()));
699
700
}

701
702
703
704
// Tests that DoDefault() does the default action for the mock method.

class MockClass {
 public:
705
706
  MockClass() {}

707
  MOCK_METHOD1(IntFunc, int(bool flag));  // NOLINT
708
  MOCK_METHOD0(Foo, MyNonDefaultConstructible());
709
#if GTEST_HAS_STD_UNIQUE_PTR_
710
  MOCK_METHOD0(MakeUnique, std::unique_ptr<int>());
711
  MOCK_METHOD0(MakeUniqueBase, std::unique_ptr<Base>());
712
  MOCK_METHOD0(MakeVectorUnique, std::vector<std::unique_ptr<int>>());
Gennadiy Civil's avatar
Gennadiy Civil committed
713
  MOCK_METHOD1(TakeUnique, int(std::unique_ptr<int>));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
714
715
  MOCK_METHOD2(TakeUnique,
               int(const std::unique_ptr<int>&, std::unique_ptr<int>));
716
#endif
717
718
719

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockClass);
720
721
722
723
724
725
726
727
728
729
730
};

// Tests that DoDefault() returns the built-in default value for the
// return type by default.
TEST(DoDefaultTest, ReturnsBuiltInDefaultValueByDefault) {
  MockClass mock;
  EXPECT_CALL(mock, IntFunc(_))
      .WillOnce(DoDefault());
  EXPECT_EQ(0, mock.IntFunc(true));
}

731
732
// Tests that DoDefault() throws (when exceptions are enabled) or aborts
// the process when there is no built-in default value for the return type.
733
734
735
736
TEST(DoDefaultDeathTest, DiesForUnknowType) {
  MockClass mock;
  EXPECT_CALL(mock, Foo())
      .WillRepeatedly(DoDefault());
737
738
739
#if GTEST_HAS_EXCEPTIONS
  EXPECT_ANY_THROW(mock.Foo());
#else
740
  EXPECT_DEATH_IF_SUPPORTED({
741
742
    mock.Foo();
  }, "");
743
#endif
744
745
746
747
748
}

// Tests that using DoDefault() inside a composite action leads to a
// run-time error.

749
void VoidFunc(bool /* flag */) {}
750
751
752
753
754
755
756
757
758
759
760

TEST(DoDefaultDeathTest, DiesIfUsedInCompositeAction) {
  MockClass mock;
  EXPECT_CALL(mock, IntFunc(_))
      .WillRepeatedly(DoAll(Invoke(VoidFunc),
                            DoDefault()));

  // Ideally we should verify the error message as well.  Sadly,
  // EXPECT_DEATH() can only capture stderr, while Google Mock's
  // errors are printed on stdout.  Therefore we have to settle for
  // not verifying the message.
761
  EXPECT_DEATH_IF_SUPPORTED({
762
763
764
765
766
    mock.IntFunc(true);
  }, "");
}

// Tests that DoDefault() returns the default value set by
Gennadiy Civil's avatar
 
Gennadiy Civil committed
767
// DefaultValue<T>::Set() when it's not overriden by an ON_CALL().
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
TEST(DoDefaultTest, ReturnsUserSpecifiedPerTypeDefaultValueWhenThereIsOne) {
  DefaultValue<int>::Set(1);
  MockClass mock;
  EXPECT_CALL(mock, IntFunc(_))
      .WillOnce(DoDefault());
  EXPECT_EQ(1, mock.IntFunc(false));
  DefaultValue<int>::Clear();
}

// Tests that DoDefault() does the action specified by ON_CALL().
TEST(DoDefaultTest, DoesWhatOnCallSpecifies) {
  MockClass mock;
  ON_CALL(mock, IntFunc(_))
      .WillByDefault(Return(2));
  EXPECT_CALL(mock, IntFunc(_))
      .WillOnce(DoDefault());
  EXPECT_EQ(2, mock.IntFunc(false));
}

// Tests that using DoDefault() in ON_CALL() leads to a run-time failure.
TEST(DoDefaultTest, CannotBeUsedInOnCall) {
  MockClass mock;
  EXPECT_NONFATAL_FAILURE({  // NOLINT
    ON_CALL(mock, IntFunc(_))
      .WillByDefault(DoDefault());
  }, "DoDefault() cannot be used in ON_CALL()");
}

796
797
798
799
800
801
802
803
// Tests that SetArgPointee<N>(v) sets the variable pointed to by
// the N-th (0-based) argument to v.
TEST(SetArgPointeeTest, SetsTheNthPointee) {
  typedef void MyFunction(bool, int*, char*);
  Action<MyFunction> a = SetArgPointee<1>(2);

  int n = 0;
  char ch = '\0';
Abseil Team's avatar
Abseil Team committed
804
  a.Perform(std::make_tuple(true, &n, &ch));
805
806
807
808
809
810
  EXPECT_EQ(2, n);
  EXPECT_EQ('\0', ch);

  a = SetArgPointee<2>('a');
  n = 0;
  ch = '\0';
Abseil Team's avatar
Abseil Team committed
811
  a.Perform(std::make_tuple(true, &n, &ch));
812
813
814
815
  EXPECT_EQ(0, n);
  EXPECT_EQ('a', ch);
}

816
#if !((GTEST_GCC_VER_ && GTEST_GCC_VER_ < 40000) || GTEST_OS_SYMBIAN)
817
// Tests that SetArgPointee<N>() accepts a string literal.
818
// GCC prior to v4.0 and the Symbian compiler do not support this.
819
TEST(SetArgPointeeTest, AcceptsStringLiteral) {
820
821
  typedef void MyFunction(std::string*, const char**);
  Action<MyFunction> a = SetArgPointee<0>("hi");
822
  std::string str;
823
  const char* ptr = nullptr;
Abseil Team's avatar
Abseil Team committed
824
  a.Perform(std::make_tuple(&str, &ptr));
825
  EXPECT_EQ("hi", str);
826
  EXPECT_TRUE(ptr == nullptr);
827

828
  a = SetArgPointee<1>("world");
829
  str = "";
Abseil Team's avatar
Abseil Team committed
830
  a.Perform(std::make_tuple(&str, &ptr));
831
832
833
834
  EXPECT_EQ("", str);
  EXPECT_STREQ("world", ptr);
}

835
836
837
TEST(SetArgPointeeTest, AcceptsWideStringLiteral) {
  typedef void MyFunction(const wchar_t**);
  Action<MyFunction> a = SetArgPointee<0>(L"world");
838
  const wchar_t* ptr = nullptr;
Abseil Team's avatar
Abseil Team committed
839
  a.Perform(std::make_tuple(&ptr));
840
841
842
843
844
845
846
  EXPECT_STREQ(L"world", ptr);

# if GTEST_HAS_STD_WSTRING

  typedef void MyStringFunction(std::wstring*);
  Action<MyStringFunction> a2 = SetArgPointee<0>(L"world");
  std::wstring str = L"";
Abseil Team's avatar
Abseil Team committed
847
  a2.Perform(std::make_tuple(&str));
848
849
850
851
852
853
  EXPECT_EQ(L"world", str);

# endif
}
#endif

854
855
856
857
858
859
// Tests that SetArgPointee<N>() accepts a char pointer.
TEST(SetArgPointeeTest, AcceptsCharPointer) {
  typedef void MyFunction(bool, std::string*, const char**);
  const char* const hi = "hi";
  Action<MyFunction> a = SetArgPointee<1>(hi);
  std::string str;
860
  const char* ptr = nullptr;
Abseil Team's avatar
Abseil Team committed
861
  a.Perform(std::make_tuple(true, &str, &ptr));
862
  EXPECT_EQ("hi", str);
863
  EXPECT_TRUE(ptr == nullptr);
864
865
866
867
868

  char world_array[] = "world";
  char* const world = world_array;
  a = SetArgPointee<2>(world);
  str = "";
Abseil Team's avatar
Abseil Team committed
869
  a.Perform(std::make_tuple(true, &str, &ptr));
870
871
872
873
  EXPECT_EQ("", str);
  EXPECT_EQ(world, ptr);
}

874
875
876
877
TEST(SetArgPointeeTest, AcceptsWideCharPointer) {
  typedef void MyFunction(bool, const wchar_t**);
  const wchar_t* const hi = L"hi";
  Action<MyFunction> a = SetArgPointee<1>(hi);
878
  const wchar_t* ptr = nullptr;
Abseil Team's avatar
Abseil Team committed
879
  a.Perform(std::make_tuple(true, &ptr));
880
881
882
883
884
885
886
887
888
  EXPECT_EQ(hi, ptr);

# if GTEST_HAS_STD_WSTRING

  typedef void MyStringFunction(bool, std::wstring*);
  wchar_t world_array[] = L"world";
  wchar_t* const world = world_array;
  Action<MyStringFunction> a2 = SetArgPointee<1>(world);
  std::wstring str;
Abseil Team's avatar
Abseil Team committed
889
  a2.Perform(std::make_tuple(true, &str));
890
891
892
893
  EXPECT_EQ(world_array, str);
# endif
}

894
895
896
897
898
899
900
901
// Tests that SetArgumentPointee<N>(v) sets the variable pointed to by
// the N-th (0-based) argument to v.
TEST(SetArgumentPointeeTest, SetsTheNthPointee) {
  typedef void MyFunction(bool, int*, char*);
  Action<MyFunction> a = SetArgumentPointee<1>(2);

  int n = 0;
  char ch = '\0';
Abseil Team's avatar
Abseil Team committed
902
  a.Perform(std::make_tuple(true, &n, &ch));
903
904
905
906
907
908
  EXPECT_EQ(2, n);
  EXPECT_EQ('\0', ch);

  a = SetArgumentPointee<2>('a');
  n = 0;
  ch = '\0';
Abseil Team's avatar
Abseil Team committed
909
  a.Perform(std::make_tuple(true, &n, &ch));
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
  EXPECT_EQ(0, n);
  EXPECT_EQ('a', ch);
}

// Sample functions and functors for testing Invoke() and etc.
int Nullary() { return 1; }

class NullaryFunctor {
 public:
  int operator()() { return 2; }
};

bool g_done = false;
void VoidNullary() { g_done = true; }

class VoidNullaryFunctor {
 public:
  void operator()() { g_done = true; }
};

Abseil Team's avatar
Abseil Team committed
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
short Short(short n) { return n; }  // NOLINT
char Char(char ch) { return ch; }

const char* CharPtr(const char* s) { return s; }

bool Unary(int x) { return x < 0; }

const char* Binary(const char* input, short n) { return input + n; }  // NOLINT

void VoidBinary(int, char) { g_done = true; }

int Ternary(int x, char y, short z) { return x + y + z; }  // NOLINT

int SumOf4(int a, int b, int c, int d) { return a + b + c + d; }

945
946
947
948
949
class Foo {
 public:
  Foo() : value_(123) {}

  int Nullary() const { return value_; }
950

951
952
953
954
955
956
957
958
 private:
  int value_;
};

// Tests InvokeWithoutArgs(function).
TEST(InvokeWithoutArgsTest, Function) {
  // As an action that takes one argument.
  Action<int(int)> a = InvokeWithoutArgs(Nullary);  // NOLINT
Abseil Team's avatar
Abseil Team committed
959
  EXPECT_EQ(1, a.Perform(std::make_tuple(2)));
960
961

  // As an action that takes two arguments.
962
  Action<int(int, double)> a2 = InvokeWithoutArgs(Nullary);  // NOLINT
Abseil Team's avatar
Abseil Team committed
963
  EXPECT_EQ(1, a2.Perform(std::make_tuple(2, 3.5)));
964
965
966
967

  // As an action that returns void.
  Action<void(int)> a3 = InvokeWithoutArgs(VoidNullary);  // NOLINT
  g_done = false;
Abseil Team's avatar
Abseil Team committed
968
  a3.Perform(std::make_tuple(1));
969
970
971
972
973
974
975
  EXPECT_TRUE(g_done);
}

// Tests InvokeWithoutArgs(functor).
TEST(InvokeWithoutArgsTest, Functor) {
  // As an action that takes no argument.
  Action<int()> a = InvokeWithoutArgs(NullaryFunctor());  // NOLINT
Abseil Team's avatar
Abseil Team committed
976
  EXPECT_EQ(2, a.Perform(std::make_tuple()));
977
978

  // As an action that takes three arguments.
979
  Action<int(int, double, char)> a2 =  // NOLINT
980
      InvokeWithoutArgs(NullaryFunctor());
Abseil Team's avatar
Abseil Team committed
981
  EXPECT_EQ(2, a2.Perform(std::make_tuple(3, 3.5, 'a')));
982
983
984
985

  // As an action that returns void.
  Action<void()> a3 = InvokeWithoutArgs(VoidNullaryFunctor());
  g_done = false;
Abseil Team's avatar
Abseil Team committed
986
  a3.Perform(std::make_tuple());
987
988
989
990
991
992
993
994
  EXPECT_TRUE(g_done);
}

// Tests InvokeWithoutArgs(obj_ptr, method).
TEST(InvokeWithoutArgsTest, Method) {
  Foo foo;
  Action<int(bool, char)> a =  // NOLINT
      InvokeWithoutArgs(&foo, &Foo::Nullary);
Abseil Team's avatar
Abseil Team committed
995
  EXPECT_EQ(123, a.Perform(std::make_tuple(true, 'a')));
996
997
998
999
1000
}

// Tests using IgnoreResult() on a polymorphic action.
TEST(IgnoreResultTest, PolymorphicAction) {
  Action<void(int)> a = IgnoreResult(Return(5));  // NOLINT
Abseil Team's avatar
Abseil Team committed
1001
  a.Perform(std::make_tuple(1));
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
}

// Tests using IgnoreResult() on a monomorphic action.

int ReturnOne() {
  g_done = true;
  return 1;
}

TEST(IgnoreResultTest, MonomorphicAction) {
  g_done = false;
  Action<void()> a = IgnoreResult(Invoke(ReturnOne));
Abseil Team's avatar
Abseil Team committed
1014
  a.Perform(std::make_tuple());
1015
1016
1017
1018
1019
  EXPECT_TRUE(g_done);
}

// Tests using IgnoreResult() on an action that returns a class type.

1020
MyNonDefaultConstructible ReturnMyNonDefaultConstructible(double /* x */) {
1021
  g_done = true;
1022
  return MyNonDefaultConstructible(42);
1023
1024
1025
1026
}

TEST(IgnoreResultTest, ActionReturningClass) {
  g_done = false;
1027
1028
  Action<void(int)> a =
      IgnoreResult(Invoke(ReturnMyNonDefaultConstructible));  // NOLINT
Abseil Team's avatar
Abseil Team committed
1029
  a.Perform(std::make_tuple(2));
1030
1031
1032
1033
1034
1035
  EXPECT_TRUE(g_done);
}

TEST(AssignTest, Int) {
  int x = 0;
  Action<void(int)> a = Assign(&x, 5);
Abseil Team's avatar
Abseil Team committed
1036
  a.Perform(std::make_tuple(0));
1037
1038
1039
1040
1041
1042
  EXPECT_EQ(5, x);
}

TEST(AssignTest, String) {
  ::std::string x;
  Action<void(void)> a = Assign(&x, "Hello, world");
Abseil Team's avatar
Abseil Team committed
1043
  a.Perform(std::make_tuple());
1044
1045
1046
1047
1048
1049
  EXPECT_EQ("Hello, world", x);
}

TEST(AssignTest, CompatibleTypes) {
  double x = 0;
  Action<void(int)> a = Assign(&x, 5);
Abseil Team's avatar
Abseil Team committed
1050
  a.Perform(std::make_tuple(0));
1051
1052
1053
  EXPECT_DOUBLE_EQ(5, x);
}

Abseil Team's avatar
Abseil Team committed
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141

// Tests using WithArgs and with an action that takes 1 argument.
TEST(WithArgsTest, OneArg) {
  Action<bool(double x, int n)> a = WithArgs<1>(Invoke(Unary));  // NOLINT
  EXPECT_TRUE(a.Perform(std::make_tuple(1.5, -1)));
  EXPECT_FALSE(a.Perform(std::make_tuple(1.5, 1)));
}

// Tests using WithArgs with an action that takes 2 arguments.
TEST(WithArgsTest, TwoArgs) {
  Action<const char*(const char* s, double x, short n)> a =  // NOLINT
      WithArgs<0, 2>(Invoke(Binary));
  const char s[] = "Hello";
  EXPECT_EQ(s + 2, a.Perform(std::make_tuple(CharPtr(s), 0.5, Short(2))));
}

struct ConcatAll {
  std::string operator()() const { return {}; }
  template <typename... I>
  std::string operator()(const char* a, I... i) const {
    return a + ConcatAll()(i...);
  }
};

// Tests using WithArgs with an action that takes 10 arguments.
TEST(WithArgsTest, TenArgs) {
  Action<std::string(const char*, const char*, const char*, const char*)> a =
      WithArgs<0, 1, 2, 3, 2, 1, 0, 1, 2, 3>(Invoke(ConcatAll{}));
  EXPECT_EQ("0123210123",
            a.Perform(std::make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
                                      CharPtr("3"))));
}

// Tests using WithArgs with an action that is not Invoke().
class SubtractAction : public ActionInterface<int(int, int)> {
 public:
  virtual int Perform(const std::tuple<int, int>& args) {
    return std::get<0>(args) - std::get<1>(args);
  }
};

TEST(WithArgsTest, NonInvokeAction) {
  Action<int(const std::string&, int, int)> a =
      WithArgs<2, 1>(MakeAction(new SubtractAction));
  std::tuple<std::string, int, int> dummy =
      std::make_tuple(std::string("hi"), 2, 10);
  EXPECT_EQ(8, a.Perform(dummy));
}

// Tests using WithArgs to pass all original arguments in the original order.
TEST(WithArgsTest, Identity) {
  Action<int(int x, char y, short z)> a =  // NOLINT
      WithArgs<0, 1, 2>(Invoke(Ternary));
  EXPECT_EQ(123, a.Perform(std::make_tuple(100, Char(20), Short(3))));
}

// Tests using WithArgs with repeated arguments.
TEST(WithArgsTest, RepeatedArguments) {
  Action<int(bool, int m, int n)> a =  // NOLINT
      WithArgs<1, 1, 1, 1>(Invoke(SumOf4));
  EXPECT_EQ(4, a.Perform(std::make_tuple(false, 1, 10)));
}

// Tests using WithArgs with reversed argument order.
TEST(WithArgsTest, ReversedArgumentOrder) {
  Action<const char*(short n, const char* input)> a =  // NOLINT
      WithArgs<1, 0>(Invoke(Binary));
  const char s[] = "Hello";
  EXPECT_EQ(s + 2, a.Perform(std::make_tuple(Short(2), CharPtr(s))));
}

// Tests using WithArgs with compatible, but not identical, argument types.
TEST(WithArgsTest, ArgsOfCompatibleTypes) {
  Action<long(short x, char y, double z, char c)> a =  // NOLINT
      WithArgs<0, 1, 3>(Invoke(Ternary));
  EXPECT_EQ(123,
            a.Perform(std::make_tuple(Short(100), Char(20), 5.6, Char(3))));
}

// Tests using WithArgs with an action that returns void.
TEST(WithArgsTest, VoidAction) {
  Action<void(double x, char c, int n)> a = WithArgs<2, 1>(Invoke(VoidBinary));
  g_done = false;
  a.Perform(std::make_tuple(1.5, 'a', 3));
  EXPECT_TRUE(g_done);
}

TEST(WithArgsTest, ReturnReference) {
misterg's avatar
misterg committed
1142
  Action<int&(int&, void*)> aa = WithArgs<0>([](int& a) -> int& { return a; });
Abseil Team's avatar
Abseil Team committed
1143
  int i = 0;
misterg's avatar
misterg committed
1144
  const int& res = aa.Perform(std::forward_as_tuple(i, nullptr));
Abseil Team's avatar
Abseil Team committed
1145
1146
1147
1148
1149
1150
1151
1152
1153
  EXPECT_EQ(&i, &res);
}

TEST(WithArgsTest, InnerActionWithConversion) {
  Action<Derived*()> inner = [] { return nullptr; };
  Action<Base*(double)> a = testing::WithoutArgs(inner);
  EXPECT_EQ(nullptr, a.Perform(std::make_tuple(1.1)));
}

1154
#if !GTEST_OS_WINDOWS_MOBILE
1155

1156
1157
1158
1159
1160
1161
1162
1163
class SetErrnoAndReturnTest : public testing::Test {
 protected:
  virtual void SetUp() { errno = 0; }
  virtual void TearDown() { errno = 0; }
};

TEST_F(SetErrnoAndReturnTest, Int) {
  Action<int(void)> a = SetErrnoAndReturn(ENOTTY, -5);
Abseil Team's avatar
Abseil Team committed
1164
  EXPECT_EQ(-5, a.Perform(std::make_tuple()));
1165
1166
1167
1168
1169
1170
  EXPECT_EQ(ENOTTY, errno);
}

TEST_F(SetErrnoAndReturnTest, Ptr) {
  int x;
  Action<int*(void)> a = SetErrnoAndReturn(ENOTTY, &x);
Abseil Team's avatar
Abseil Team committed
1171
  EXPECT_EQ(&x, a.Perform(std::make_tuple()));
1172
1173
1174
1175
1176
  EXPECT_EQ(ENOTTY, errno);
}

TEST_F(SetErrnoAndReturnTest, CompatibleTypes) {
  Action<double()> a = SetErrnoAndReturn(EINVAL, 5);
Abseil Team's avatar
Abseil Team committed
1177
  EXPECT_DOUBLE_EQ(5.0, a.Perform(std::make_tuple()));
1178
1179
1180
  EXPECT_EQ(EINVAL, errno);
}

1181
#endif  // !GTEST_OS_WINDOWS_MOBILE
1182

1183
1184
1185
1186
1187
1188
1189
// Tests ByRef().

// Tests that ReferenceWrapper<T> is copyable.
TEST(ByRefTest, IsCopyable) {
  const std::string s1 = "Hi";
  const std::string s2 = "Hello";

1190
1191
  ::testing::internal::ReferenceWrapper<const std::string> ref_wrapper =
      ByRef(s1);
1192
1193
1194
1195
1196
1197
1198
1199
  const std::string& r1 = ref_wrapper;
  EXPECT_EQ(&s1, &r1);

  // Assigns a new value to ref_wrapper.
  ref_wrapper = ByRef(s2);
  const std::string& r2 = ref_wrapper;
  EXPECT_EQ(&s2, &r2);

1200
1201
  ::testing::internal::ReferenceWrapper<const std::string> ref_wrapper1 =
      ByRef(s1);
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
  // Copies ref_wrapper1 to ref_wrapper.
  ref_wrapper = ref_wrapper1;
  const std::string& r3 = ref_wrapper;
  EXPECT_EQ(&s1, &r3);
}

// Tests using ByRef() on a const value.
TEST(ByRefTest, ConstValue) {
  const int n = 0;
  // int& ref = ByRef(n);  // This shouldn't compile - we have a
                           // negative compilation test to catch it.
  const int& const_ref = ByRef(n);
  EXPECT_EQ(&n, &const_ref);
}

// Tests using ByRef() on a non-const value.
TEST(ByRefTest, NonConstValue) {
  int n = 0;

  // ByRef(n) can be used as either an int&,
  int& ref = ByRef(n);
  EXPECT_EQ(&n, &ref);

  // or a const int&.
  const int& const_ref = ByRef(n);
  EXPECT_EQ(&n, &const_ref);
}

// Tests explicitly specifying the type when using ByRef().
TEST(ByRefTest, ExplicitType) {
  int n = 0;
  const int& r1 = ByRef<const int>(n);
  EXPECT_EQ(&n, &r1);

  // ByRef<char>(n);  // This shouldn't compile - we have a negative
                      // compilation test to catch it.

  Derived d;
  Derived& r2 = ByRef<Derived>(d);
  EXPECT_EQ(&d, &r2);

  const Derived& r3 = ByRef<const Derived>(d);
  EXPECT_EQ(&d, &r3);

  Base& r4 = ByRef<Base>(d);
  EXPECT_EQ(&d, &r4);

  const Base& r5 = ByRef<const Base>(d);
  EXPECT_EQ(&d, &r5);

  // The following shouldn't compile - we have a negative compilation
  // test for it.
  //
  // Base b;
  // ByRef<Derived>(b);
}

// Tests that Google Mock prints expression ByRef(x) as a reference to x.
TEST(ByRefTest, PrintsCorrectly) {
  int n = 42;
  ::std::stringstream expected, actual;
  testing::internal::UniversalPrinter<const int&>::Print(n, &expected);
  testing::internal::UniversalPrint(ByRef(n), &actual);
  EXPECT_EQ(expected.str(), actual.str());
}

1268
#if GTEST_HAS_STD_UNIQUE_PTR_
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279

std::unique_ptr<int> UniquePtrSource() {
  return std::unique_ptr<int>(new int(19));
}

std::vector<std::unique_ptr<int>> VectorUniquePtrSource() {
  std::vector<std::unique_ptr<int>> out;
  out.emplace_back(new int(7));
  return out;
}

1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
TEST(MockMethodTest, CanReturnMoveOnlyValue_Return) {
  MockClass mock;
  std::unique_ptr<int> i(new int(19));
  EXPECT_CALL(mock, MakeUnique()).WillOnce(Return(ByMove(std::move(i))));
  EXPECT_CALL(mock, MakeVectorUnique())
      .WillOnce(Return(ByMove(VectorUniquePtrSource())));
  Derived* d = new Derived;
  EXPECT_CALL(mock, MakeUniqueBase())
      .WillOnce(Return(ByMove(std::unique_ptr<Derived>(d))));

  std::unique_ptr<int> result1 = mock.MakeUnique();
  EXPECT_EQ(19, *result1);

  std::vector<std::unique_ptr<int>> vresult = mock.MakeVectorUnique();
1294
  EXPECT_EQ(1u, vresult.size());
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
  EXPECT_NE(nullptr, vresult[0]);
  EXPECT_EQ(7, *vresult[0]);

  std::unique_ptr<Base> result2 = mock.MakeUniqueBase();
  EXPECT_EQ(d, result2.get());
}

TEST(MockMethodTest, CanReturnMoveOnlyValue_DoAllReturn) {
  testing::MockFunction<void()> mock_function;
  MockClass mock;
  std::unique_ptr<int> i(new int(19));
  EXPECT_CALL(mock_function, Call());
  EXPECT_CALL(mock, MakeUnique()).WillOnce(DoAll(
      InvokeWithoutArgs(&mock_function, &testing::MockFunction<void()>::Call),
      Return(ByMove(std::move(i)))));

  std::unique_ptr<int> result1 = mock.MakeUnique();
  EXPECT_EQ(19, *result1);
}

TEST(MockMethodTest, CanReturnMoveOnlyValue_Invoke) {
1316
1317
1318
1319
1320
1321
1322
1323
  MockClass mock;

  // Check default value
  DefaultValue<std::unique_ptr<int>>::SetFactory([] {
    return std::unique_ptr<int>(new int(42));
  });
  EXPECT_EQ(42, *mock.MakeUnique());

1324
  EXPECT_CALL(mock, MakeUnique()).WillRepeatedly(Invoke(UniquePtrSource));
1325
1326
1327
1328
1329
1330
1331
1332
1333
  EXPECT_CALL(mock, MakeVectorUnique())
      .WillRepeatedly(Invoke(VectorUniquePtrSource));
  std::unique_ptr<int> result1 = mock.MakeUnique();
  EXPECT_EQ(19, *result1);
  std::unique_ptr<int> result2 = mock.MakeUnique();
  EXPECT_EQ(19, *result2);
  EXPECT_NE(result1, result2);

  std::vector<std::unique_ptr<int>> vresult = mock.MakeVectorUnique();
1334
  EXPECT_EQ(1u, vresult.size());
1335
1336
1337
1338
  EXPECT_NE(nullptr, vresult[0]);
  EXPECT_EQ(7, *vresult[0]);
}

Gennadiy Civil's avatar
 
Gennadiy Civil committed
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
TEST(MockMethodTest, CanTakeMoveOnlyValue) {
  MockClass mock;
  auto make = [](int i) { return std::unique_ptr<int>(new int(i)); };

  EXPECT_CALL(mock, TakeUnique(_)).WillRepeatedly([](std::unique_ptr<int> i) {
    return *i;
  });
  // DoAll() does not compile, since it would move from its arguments twice.
  // EXPECT_CALL(mock, TakeUnique(_, _))
  //     .WillRepeatedly(DoAll(Invoke([](std::unique_ptr<int> j) {}),
  //     Return(1)));
  EXPECT_CALL(mock, TakeUnique(testing::Pointee(7)))
      .WillOnce(Return(-7))
      .RetiresOnSaturation();
  EXPECT_CALL(mock, TakeUnique(testing::IsNull()))
      .WillOnce(Return(-1))
      .RetiresOnSaturation();

  EXPECT_EQ(5, mock.TakeUnique(make(5)));
  EXPECT_EQ(-7, mock.TakeUnique(make(7)));
  EXPECT_EQ(7, mock.TakeUnique(make(7)));
  EXPECT_EQ(7, mock.TakeUnique(make(7)));
  EXPECT_EQ(-1, mock.TakeUnique({}));

  // Some arguments are moved, some passed by reference.
  auto lvalue = make(6);
  EXPECT_CALL(mock, TakeUnique(_, _))
      .WillOnce([](const std::unique_ptr<int>& i, std::unique_ptr<int> j) {
        return *i * *j;
      });
  EXPECT_EQ(42, mock.TakeUnique(lvalue, make(7)));

  // The unique_ptr can be saved by the action.
  std::unique_ptr<int> saved;
  EXPECT_CALL(mock, TakeUnique(_)).WillOnce([&saved](std::unique_ptr<int> i) {
    saved = std::move(i);
    return 0;
  });
  EXPECT_EQ(0, mock.TakeUnique(make(42)));
  EXPECT_EQ(42, *saved);
}

1381
#endif  // GTEST_HAS_STD_UNIQUE_PTR_
1382

Gennadiy Civil's avatar
 
Gennadiy Civil committed
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
#if GTEST_LANG_CXX11
// Tests for std::function based action.

int Add(int val, int& ref, int* ptr) {  // NOLINT
  int result = val + ref + *ptr;
  ref = 42;
  *ptr = 43;
  return result;
}

int Deref(std::unique_ptr<int> ptr) { return *ptr; }

struct Double {
  template <typename T>
  T operator()(T t) { return 2 * t; }
};

std::unique_ptr<int> UniqueInt(int i) {
  return std::unique_ptr<int>(new int(i));
}

TEST(FunctorActionTest, ActionFromFunction) {
  Action<int(int, int&, int*)> a = &Add;
  int x = 1, y = 2, z = 3;
  EXPECT_EQ(6, a.Perform(std::forward_as_tuple(x, y, &z)));
  EXPECT_EQ(42, y);
  EXPECT_EQ(43, z);

  Action<int(std::unique_ptr<int>)> a1 = &Deref;
  EXPECT_EQ(7, a1.Perform(std::make_tuple(UniqueInt(7))));
}

TEST(FunctorActionTest, ActionFromLambda) {
  Action<int(bool, int)> a1 = [](bool b, int i) { return b ? i : 0; };
Abseil Team's avatar
Abseil Team committed
1417
1418
  EXPECT_EQ(5, a1.Perform(std::make_tuple(true, 5)));
  EXPECT_EQ(0, a1.Perform(std::make_tuple(false, 5)));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1419
1420
1421
1422
1423

  std::unique_ptr<int> saved;
  Action<void(std::unique_ptr<int>)> a2 = [&saved](std::unique_ptr<int> p) {
    saved = std::move(p);
  };
Abseil Team's avatar
Abseil Team committed
1424
  a2.Perform(std::make_tuple(UniqueInt(5)));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1425
1426
1427
1428
1429
  EXPECT_EQ(5, *saved);
}

TEST(FunctorActionTest, PolymorphicFunctor) {
  Action<int(int)> ai = Double();
Abseil Team's avatar
Abseil Team committed
1430
  EXPECT_EQ(2, ai.Perform(std::make_tuple(1)));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1431
  Action<double(double)> ad = Double();  // Double? Double double!
Abseil Team's avatar
Abseil Team committed
1432
  EXPECT_EQ(3.0, ad.Perform(std::make_tuple(1.5)));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1433
1434
1435
1436
1437
1438
}

TEST(FunctorActionTest, TypeConversion) {
  // Numeric promotions are allowed.
  const Action<bool(int)> a1 = [](int i) { return i > 1; };
  const Action<int(bool)> a2 = Action<int(bool)>(a1);
Abseil Team's avatar
Abseil Team committed
1439
1440
  EXPECT_EQ(1, a1.Perform(std::make_tuple(42)));
  EXPECT_EQ(0, a2.Perform(std::make_tuple(42)));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1441
1442
1443
1444

  // Implicit constructors are allowed.
  const Action<bool(std::string)> s1 = [](std::string s) { return !s.empty(); };
  const Action<int(const char*)> s2 = Action<int(const char*)>(s1);
Abseil Team's avatar
Abseil Team committed
1445
1446
  EXPECT_EQ(0, s2.Perform(std::make_tuple("")));
  EXPECT_EQ(1, s2.Perform(std::make_tuple("hello")));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1447
1448
1449

  // Also between the lambda and the action itself.
  const Action<bool(std::string)> x = [](Unused) { return 42; };
Abseil Team's avatar
Abseil Team committed
1450
  EXPECT_TRUE(x.Perform(std::make_tuple("hello")));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1451
1452
1453
1454
}

TEST(FunctorActionTest, UnusedArguments) {
  // Verify that users can ignore uninteresting arguments.
Gennadiy Civil's avatar
merging  
Gennadiy Civil committed
1455
  Action<int(int, double y, double z)> a =
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1456
      [](int i, Unused, Unused) { return 2 * i; };
Abseil Team's avatar
Abseil Team committed
1457
  std::tuple<int, double, double> dummy = std::make_tuple(3, 7.3, 9.44);
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1458
  EXPECT_EQ(6, a.Perform(dummy));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1459
1460
1461
}

// Test that basic built-in actions work with move-only arguments.
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1462
// FIXME: Currently, almost all ActionInterface-based actions will not
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1463
1464
1465
1466
1467
// work, even if they only try to use other, copyable arguments. Implement them
// if necessary (but note that DoAll cannot work on non-copyable types anyway -
// so maybe it's better to make users use lambdas instead.
TEST(MoveOnlyArgumentsTest, ReturningActions) {
  Action<int(std::unique_ptr<int>)> a = Return(1);
Abseil Team's avatar
Abseil Team committed
1468
  EXPECT_EQ(1, a.Perform(std::make_tuple(nullptr)));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1469
1470

  a = testing::WithoutArgs([]() { return 7; });
Abseil Team's avatar
Abseil Team committed
1471
  EXPECT_EQ(7, a.Perform(std::make_tuple(nullptr)));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1472
1473
1474

  Action<void(std::unique_ptr<int>, int*)> a2 = testing::SetArgPointee<1>(3);
  int x = 0;
Abseil Team's avatar
Abseil Team committed
1475
  a2.Perform(std::make_tuple(nullptr, &x));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1476
1477
1478
1479
1480
  EXPECT_EQ(x, 3);
}

#endif  // GTEST_LANG_CXX11

1481
}  // Unnamed namespace
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1482
1483
1484
1485
1486
1487
1488

#ifdef _MSC_VER
#if _MSC_VER == 1900
#  pragma warning(pop)
#endif
#endif