Lab_1 0.1.1
Matrix Library
Loading...
Searching...
No Matches
gmock_link_test.h
1// Copyright 2009, Google Inc.
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met:
7//
8// * Redistributions of source code must retain the above copyright
9// notice, this list of conditions and the following disclaimer.
10// * Redistributions in binary form must reproduce the above
11// copyright notice, this list of conditions and the following disclaimer
12// in the documentation and/or other materials provided with the
13// distribution.
14// * Neither the name of Google Inc. nor the names of its
15// contributors may be used to endorse or promote products derived from
16// this software without specific prior written permission.
17//
18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30// Google Mock - a framework for writing C++ mock classes.
31//
32// This file tests that:
33// a. A header file defining a mock class can be included in multiple
34// translation units without causing a link error.
35// b. Actions and matchers can be instantiated with identical template
36// arguments in different translation units without causing link
37// errors.
38// The following constructs are currently tested:
39// Actions:
40// Return()
41// Return(value)
42// ReturnNull
43// ReturnRef
44// Assign
45// SetArgPointee
46// SetArrayArgument
47// SetErrnoAndReturn
48// Invoke(function)
49// Invoke(object, method)
50// InvokeWithoutArgs(function)
51// InvokeWithoutArgs(object, method)
52// InvokeArgument
53// WithArg
54// WithArgs
55// WithoutArgs
56// DoAll
57// DoDefault
58// IgnoreResult
59// Throw
60// ACTION()-generated
61// ACTION_P()-generated
62// ACTION_P2()-generated
63// Matchers:
64// _
65// A
66// An
67// Eq
68// Gt, Lt, Ge, Le, Ne
69// NotNull
70// Ref
71// TypedEq
72// DoubleEq
73// FloatEq
74// NanSensitiveDoubleEq
75// NanSensitiveFloatEq
76// ContainsRegex
77// MatchesRegex
78// EndsWith
79// HasSubstr
80// StartsWith
81// StrCaseEq
82// StrCaseNe
83// StrEq
84// StrNe
85// ElementsAre
86// ElementsAreArray
87// ContainerEq
88// Field
89// Property
90// ResultOf(function)
91// ResultOf(callback)
92// Pointee
93// Truly(predicate)
94// AddressSatisfies
95// AllOf
96// AnyOf
97// Not
98// MatcherCast<T>
99//
100// Please note: this test does not verify the functioning of these
101// constructs, only that the programs using them will link successfully.
102//
103// Implementation note:
104// This test requires identical definitions of Interface and Mock to be
105// included in different translation units. We achieve this by writing
106// them in this header and #including it in gmock_link_test.cc and
107// gmock_link2_test.cc. Because the symbols generated by the compiler for
108// those constructs must be identical in both translation units,
109// definitions of Interface and Mock tests MUST be kept in the SAME
110// NON-ANONYMOUS namespace in this file. The test fixture class LinkTest
111// is defined as LinkTest1 in gmock_link_test.cc and as LinkTest2 in
112// gmock_link2_test.cc to avoid producing linker errors.
113
114#ifndef GOOGLEMOCK_TEST_GMOCK_LINK_TEST_H_
115#define GOOGLEMOCK_TEST_GMOCK_LINK_TEST_H_
116
117#include "gmock/gmock.h"
118
119#if !GTEST_OS_WINDOWS_MOBILE
120#include <errno.h>
121#endif
122
123#include <iostream>
124#include <vector>
125
126#include "gtest/gtest.h"
127#include "gtest/internal/gtest-port.h"
128
129using testing::_;
130using testing::A;
131using testing::Action;
132using testing::AllOf;
133using testing::AnyOf;
134using testing::Assign;
135using testing::ContainerEq;
136using testing::DoAll;
137using testing::DoDefault;
138using testing::DoubleEq;
139using testing::ElementsAre;
140using testing::ElementsAreArray;
141using testing::EndsWith;
142using testing::Eq;
143using testing::Field;
144using testing::FloatEq;
145using testing::Ge;
146using testing::Gt;
147using testing::HasSubstr;
148using testing::IgnoreResult;
149using testing::Invoke;
150using testing::InvokeArgument;
151using testing::InvokeWithoutArgs;
152using testing::IsNull;
153using testing::IsSubsetOf;
154using testing::IsSupersetOf;
155using testing::Le;
156using testing::Lt;
157using testing::Matcher;
158using testing::MatcherCast;
159using testing::NanSensitiveDoubleEq;
160using testing::NanSensitiveFloatEq;
161using testing::Ne;
162using testing::Not;
163using testing::NotNull;
164using testing::Pointee;
165using testing::Property;
166using testing::Ref;
167using testing::ResultOf;
168using testing::Return;
169using testing::ReturnNull;
170using testing::ReturnRef;
171using testing::SetArgPointee;
172using testing::SetArrayArgument;
173using testing::StartsWith;
174using testing::StrCaseEq;
175using testing::StrCaseNe;
176using testing::StrEq;
177using testing::StrNe;
178using testing::Truly;
179using testing::TypedEq;
180using testing::WithArg;
181using testing::WithArgs;
182using testing::WithoutArgs;
183
184#if !GTEST_OS_WINDOWS_MOBILE
185using testing::SetErrnoAndReturn;
186#endif
187
188#if GTEST_HAS_EXCEPTIONS
189using testing::Throw;
190#endif
191
192using testing::ContainsRegex;
193using testing::MatchesRegex;
194
196 public:
197 virtual ~Interface() {}
198 virtual void VoidFromString(char* str) = 0;
199 virtual char* StringFromString(char* str) = 0;
200 virtual int IntFromString(char* str) = 0;
201 virtual int& IntRefFromString(char* str) = 0;
202 virtual void VoidFromFunc(void (*func)(char* str)) = 0;
203 virtual void VoidFromIntRef(int& n) = 0; // NOLINT
204 virtual void VoidFromFloat(float n) = 0;
205 virtual void VoidFromDouble(double n) = 0;
206 virtual void VoidFromVector(const std::vector<int>& v) = 0;
207};
208
209class Mock : public Interface {
210 public:
211 Mock() {}
212
213 MOCK_METHOD1(VoidFromString, void(char* str));
214 MOCK_METHOD1(StringFromString, char*(char* str));
215 MOCK_METHOD1(IntFromString, int(char* str));
216 MOCK_METHOD1(IntRefFromString, int&(char* str));
217 MOCK_METHOD1(VoidFromFunc, void(void (*func)(char* str)));
218 MOCK_METHOD1(VoidFromIntRef, void(int& n)); // NOLINT
219 MOCK_METHOD1(VoidFromFloat, void(float n));
220 MOCK_METHOD1(VoidFromDouble, void(double n));
221 MOCK_METHOD1(VoidFromVector, void(const std::vector<int>& v));
222
223 private:
224 Mock(const Mock&) = delete;
225 Mock& operator=(const Mock&) = delete;
226};
227
229 public:
230 static void StaticVoidFromVoid() {}
231 void VoidFromVoid() {}
232 static void StaticVoidFromString(char* /* str */) {}
233 void VoidFromString(char* /* str */) {}
234 static int StaticIntFromString(char* /* str */) { return 1; }
235 static bool StaticBoolFromString(const char* /* str */) { return true; }
236};
237
239 public:
240 explicit FieldHelper(int a_field) : field_(a_field) {}
241 int field() const { return field_; }
242 int field_; // NOLINT -- need external access to field_ to test
243 // the Field matcher.
244};
245
246// Tests the linkage of the ReturnVoid action.
247TEST(LinkTest, TestReturnVoid) {
248 Mock mock;
249
250 EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Return());
251 mock.VoidFromString(nullptr);
252}
253
254// Tests the linkage of the Return action.
255TEST(LinkTest, TestReturn) {
256 Mock mock;
257 char ch = 'x';
258
259 EXPECT_CALL(mock, StringFromString(_)).WillOnce(Return(&ch));
260 mock.StringFromString(nullptr);
261}
262
263// Tests the linkage of the ReturnNull action.
264TEST(LinkTest, TestReturnNull) {
265 Mock mock;
266
267 EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Return());
268 mock.VoidFromString(nullptr);
269}
270
271// Tests the linkage of the ReturnRef action.
272TEST(LinkTest, TestReturnRef) {
273 Mock mock;
274 int n = 42;
275
276 EXPECT_CALL(mock, IntRefFromString(_)).WillOnce(ReturnRef(n));
277 mock.IntRefFromString(nullptr);
278}
279
280// Tests the linkage of the Assign action.
281TEST(LinkTest, TestAssign) {
282 Mock mock;
283 char ch = 'x';
284
285 EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Assign(&ch, 'y'));
286 mock.VoidFromString(nullptr);
287}
288
289// Tests the linkage of the SetArgPointee action.
290TEST(LinkTest, TestSetArgPointee) {
291 Mock mock;
292 char ch = 'x';
293
294 EXPECT_CALL(mock, VoidFromString(_)).WillOnce(SetArgPointee<0>('y'));
295 mock.VoidFromString(&ch);
296}
297
298// Tests the linkage of the SetArrayArgument action.
299TEST(LinkTest, TestSetArrayArgument) {
300 Mock mock;
301 char ch = 'x';
302 char ch2 = 'y';
303
304 EXPECT_CALL(mock, VoidFromString(_))
305 .WillOnce(SetArrayArgument<0>(&ch2, &ch2 + 1));
306 mock.VoidFromString(&ch);
307}
308
309#if !GTEST_OS_WINDOWS_MOBILE
310
311// Tests the linkage of the SetErrnoAndReturn action.
312TEST(LinkTest, TestSetErrnoAndReturn) {
313 Mock mock;
314
315 int saved_errno = errno;
316 EXPECT_CALL(mock, IntFromString(_)).WillOnce(SetErrnoAndReturn(1, -1));
317 mock.IntFromString(nullptr);
318 errno = saved_errno;
319}
320
321#endif // !GTEST_OS_WINDOWS_MOBILE
322
323// Tests the linkage of the Invoke(function) and Invoke(object, method) actions.
324TEST(LinkTest, TestInvoke) {
325 Mock mock;
326 InvokeHelper test_invoke_helper;
327
328 EXPECT_CALL(mock, VoidFromString(_))
329 .WillOnce(Invoke(&InvokeHelper::StaticVoidFromString))
330 .WillOnce(Invoke(&test_invoke_helper, &InvokeHelper::VoidFromString));
331 mock.VoidFromString(nullptr);
332 mock.VoidFromString(nullptr);
333}
334
335// Tests the linkage of the InvokeWithoutArgs action.
336TEST(LinkTest, TestInvokeWithoutArgs) {
337 Mock mock;
338 InvokeHelper test_invoke_helper;
339
340 EXPECT_CALL(mock, VoidFromString(_))
341 .WillOnce(InvokeWithoutArgs(&InvokeHelper::StaticVoidFromVoid))
342 .WillOnce(
343 InvokeWithoutArgs(&test_invoke_helper, &InvokeHelper::VoidFromVoid));
344 mock.VoidFromString(nullptr);
345 mock.VoidFromString(nullptr);
346}
347
348// Tests the linkage of the InvokeArgument action.
349TEST(LinkTest, TestInvokeArgument) {
350 Mock mock;
351 char ch = 'x';
352
353 EXPECT_CALL(mock, VoidFromFunc(_)).WillOnce(InvokeArgument<0>(&ch));
354 mock.VoidFromFunc(InvokeHelper::StaticVoidFromString);
355}
356
357// Tests the linkage of the WithArg action.
358TEST(LinkTest, TestWithArg) {
359 Mock mock;
360
361 EXPECT_CALL(mock, VoidFromString(_))
362 .WillOnce(WithArg<0>(Invoke(&InvokeHelper::StaticVoidFromString)));
363 mock.VoidFromString(nullptr);
364}
365
366// Tests the linkage of the WithArgs action.
367TEST(LinkTest, TestWithArgs) {
368 Mock mock;
369
370 EXPECT_CALL(mock, VoidFromString(_))
371 .WillOnce(WithArgs<0>(Invoke(&InvokeHelper::StaticVoidFromString)));
372 mock.VoidFromString(nullptr);
373}
374
375// Tests the linkage of the WithoutArgs action.
376TEST(LinkTest, TestWithoutArgs) {
377 Mock mock;
378
379 EXPECT_CALL(mock, VoidFromString(_)).WillOnce(WithoutArgs(Return()));
380 mock.VoidFromString(nullptr);
381}
382
383// Tests the linkage of the DoAll action.
384TEST(LinkTest, TestDoAll) {
385 Mock mock;
386 char ch = 'x';
387
388 EXPECT_CALL(mock, VoidFromString(_))
389 .WillOnce(DoAll(SetArgPointee<0>('y'), Return()));
390 mock.VoidFromString(&ch);
391}
392
393// Tests the linkage of the DoDefault action.
394TEST(LinkTest, TestDoDefault) {
395 Mock mock;
396 char ch = 'x';
397
398 ON_CALL(mock, VoidFromString(_)).WillByDefault(Return());
399 EXPECT_CALL(mock, VoidFromString(_)).WillOnce(DoDefault());
400 mock.VoidFromString(&ch);
401}
402
403// Tests the linkage of the IgnoreResult action.
404TEST(LinkTest, TestIgnoreResult) {
405 Mock mock;
406
407 EXPECT_CALL(mock, VoidFromString(_)).WillOnce(IgnoreResult(Return(42)));
408 mock.VoidFromString(nullptr);
409}
410
411#if GTEST_HAS_EXCEPTIONS
412// Tests the linkage of the Throw action.
413TEST(LinkTest, TestThrow) {
414 Mock mock;
415
416 EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Throw(42));
417 EXPECT_THROW(mock.VoidFromString(nullptr), int);
418}
419#endif // GTEST_HAS_EXCEPTIONS
420
421// The ACTION*() macros trigger warning C4100 (unreferenced formal
422// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in
423// the macro definition, as the warnings are generated when the macro
424// is expanded and macro expansion cannot contain #pragma. Therefore
425// we suppress them here.
426#ifdef _MSC_VER
427#pragma warning(push)
428#pragma warning(disable : 4100)
429#endif
430
431// Tests the linkage of actions created using ACTION macro.
432namespace {
433ACTION(Return1) { return 1; }
434} // namespace
435
436TEST(LinkTest, TestActionMacro) {
437 Mock mock;
438
439 EXPECT_CALL(mock, IntFromString(_)).WillOnce(Return1());
440 mock.IntFromString(nullptr);
441}
442
443// Tests the linkage of actions created using ACTION_P macro.
444namespace {
445ACTION_P(ReturnArgument, ret_value) { return ret_value; }
446} // namespace
447
448TEST(LinkTest, TestActionPMacro) {
449 Mock mock;
450
451 EXPECT_CALL(mock, IntFromString(_)).WillOnce(ReturnArgument(42));
452 mock.IntFromString(nullptr);
453}
454
455// Tests the linkage of actions created using ACTION_P2 macro.
456namespace {
457ACTION_P2(ReturnEqualsEitherOf, first, second) {
458 return arg0 == first || arg0 == second;
459}
460} // namespace
461
462#ifdef _MSC_VER
463#pragma warning(pop)
464#endif
465
466TEST(LinkTest, TestActionP2Macro) {
467 Mock mock;
468 char ch = 'x';
469
470 EXPECT_CALL(mock, IntFromString(_))
471 .WillOnce(ReturnEqualsEitherOf("one", "two"));
472 mock.IntFromString(&ch);
473}
474
475// Tests the linkage of the "_" matcher.
476TEST(LinkTest, TestMatcherAnything) {
477 Mock mock;
478
479 ON_CALL(mock, VoidFromString(_)).WillByDefault(Return());
480}
481
482// Tests the linkage of the A matcher.
483TEST(LinkTest, TestMatcherA) {
484 Mock mock;
485
486 ON_CALL(mock, VoidFromString(A<char*>())).WillByDefault(Return());
487}
488
489// Tests the linkage of the Eq and the "bare value" matcher.
490TEST(LinkTest, TestMatchersEq) {
491 Mock mock;
492 const char* p = "x";
493
494 ON_CALL(mock, VoidFromString(Eq(p))).WillByDefault(Return());
495 ON_CALL(mock, VoidFromString(const_cast<char*>("y"))).WillByDefault(Return());
496}
497
498// Tests the linkage of the Lt, Gt, Le, Ge, and Ne matchers.
499TEST(LinkTest, TestMatchersRelations) {
500 Mock mock;
501
502 ON_CALL(mock, VoidFromFloat(Lt(1.0f))).WillByDefault(Return());
503 ON_CALL(mock, VoidFromFloat(Gt(1.0f))).WillByDefault(Return());
504 ON_CALL(mock, VoidFromFloat(Le(1.0f))).WillByDefault(Return());
505 ON_CALL(mock, VoidFromFloat(Ge(1.0f))).WillByDefault(Return());
506 ON_CALL(mock, VoidFromFloat(Ne(1.0f))).WillByDefault(Return());
507}
508
509// Tests the linkage of the NotNull matcher.
510TEST(LinkTest, TestMatcherNotNull) {
511 Mock mock;
512
513 ON_CALL(mock, VoidFromString(NotNull())).WillByDefault(Return());
514}
515
516// Tests the linkage of the IsNull matcher.
517TEST(LinkTest, TestMatcherIsNull) {
518 Mock mock;
519
520 ON_CALL(mock, VoidFromString(IsNull())).WillByDefault(Return());
521}
522
523// Tests the linkage of the Ref matcher.
524TEST(LinkTest, TestMatcherRef) {
525 Mock mock;
526 int a = 0;
527
528 ON_CALL(mock, VoidFromIntRef(Ref(a))).WillByDefault(Return());
529}
530
531// Tests the linkage of the TypedEq matcher.
532TEST(LinkTest, TestMatcherTypedEq) {
533 Mock mock;
534 long a = 0;
535
536 ON_CALL(mock, VoidFromIntRef(TypedEq<int&>(a))).WillByDefault(Return());
537}
538
539// Tests the linkage of the FloatEq, DoubleEq, NanSensitiveFloatEq and
540// NanSensitiveDoubleEq matchers.
541TEST(LinkTest, TestMatchersFloatingPoint) {
542 Mock mock;
543 float a = 0;
544
545 ON_CALL(mock, VoidFromFloat(FloatEq(a))).WillByDefault(Return());
546 ON_CALL(mock, VoidFromDouble(DoubleEq(a))).WillByDefault(Return());
547 ON_CALL(mock, VoidFromFloat(NanSensitiveFloatEq(a))).WillByDefault(Return());
548 ON_CALL(mock, VoidFromDouble(NanSensitiveDoubleEq(a)))
549 .WillByDefault(Return());
550}
551
552// Tests the linkage of the ContainsRegex matcher.
553TEST(LinkTest, TestMatcherContainsRegex) {
554 Mock mock;
555
556 ON_CALL(mock, VoidFromString(ContainsRegex(".*"))).WillByDefault(Return());
557}
558
559// Tests the linkage of the MatchesRegex matcher.
560TEST(LinkTest, TestMatcherMatchesRegex) {
561 Mock mock;
562
563 ON_CALL(mock, VoidFromString(MatchesRegex(".*"))).WillByDefault(Return());
564}
565
566// Tests the linkage of the StartsWith, EndsWith, and HasSubstr matchers.
567TEST(LinkTest, TestMatchersSubstrings) {
568 Mock mock;
569
570 ON_CALL(mock, VoidFromString(StartsWith("a"))).WillByDefault(Return());
571 ON_CALL(mock, VoidFromString(EndsWith("c"))).WillByDefault(Return());
572 ON_CALL(mock, VoidFromString(HasSubstr("b"))).WillByDefault(Return());
573}
574
575// Tests the linkage of the StrEq, StrNe, StrCaseEq, and StrCaseNe matchers.
576TEST(LinkTest, TestMatchersStringEquality) {
577 Mock mock;
578 ON_CALL(mock, VoidFromString(StrEq("a"))).WillByDefault(Return());
579 ON_CALL(mock, VoidFromString(StrNe("a"))).WillByDefault(Return());
580 ON_CALL(mock, VoidFromString(StrCaseEq("a"))).WillByDefault(Return());
581 ON_CALL(mock, VoidFromString(StrCaseNe("a"))).WillByDefault(Return());
582}
583
584// Tests the linkage of the ElementsAre matcher.
585TEST(LinkTest, TestMatcherElementsAre) {
586 Mock mock;
587
588 ON_CALL(mock, VoidFromVector(ElementsAre('a', _))).WillByDefault(Return());
589}
590
591// Tests the linkage of the ElementsAreArray matcher.
592TEST(LinkTest, TestMatcherElementsAreArray) {
593 Mock mock;
594 char arr[] = {'a', 'b'};
595
596 ON_CALL(mock, VoidFromVector(ElementsAreArray(arr))).WillByDefault(Return());
597}
598
599// Tests the linkage of the IsSubsetOf matcher.
600TEST(LinkTest, TestMatcherIsSubsetOf) {
601 Mock mock;
602 char arr[] = {'a', 'b'};
603
604 ON_CALL(mock, VoidFromVector(IsSubsetOf(arr))).WillByDefault(Return());
605}
606
607// Tests the linkage of the IsSupersetOf matcher.
608TEST(LinkTest, TestMatcherIsSupersetOf) {
609 Mock mock;
610 char arr[] = {'a', 'b'};
611
612 ON_CALL(mock, VoidFromVector(IsSupersetOf(arr))).WillByDefault(Return());
613}
614
615// Tests the linkage of the ContainerEq matcher.
616TEST(LinkTest, TestMatcherContainerEq) {
617 Mock mock;
618 std::vector<int> v;
619
620 ON_CALL(mock, VoidFromVector(ContainerEq(v))).WillByDefault(Return());
621}
622
623// Tests the linkage of the Field matcher.
624TEST(LinkTest, TestMatcherField) {
625 FieldHelper helper(0);
626
627 Matcher<const FieldHelper&> m = Field(&FieldHelper::field_, Eq(0));
628 EXPECT_TRUE(m.Matches(helper));
629
630 Matcher<const FieldHelper*> m2 = Field(&FieldHelper::field_, Eq(0));
631 EXPECT_TRUE(m2.Matches(&helper));
632}
633
634// Tests the linkage of the Property matcher.
635TEST(LinkTest, TestMatcherProperty) {
636 FieldHelper helper(0);
637
638 Matcher<const FieldHelper&> m = Property(&FieldHelper::field, Eq(0));
639 EXPECT_TRUE(m.Matches(helper));
640
641 Matcher<const FieldHelper*> m2 = Property(&FieldHelper::field, Eq(0));
642 EXPECT_TRUE(m2.Matches(&helper));
643}
644
645// Tests the linkage of the ResultOf matcher.
646TEST(LinkTest, TestMatcherResultOf) {
647 Matcher<char*> m = ResultOf(&InvokeHelper::StaticIntFromString, Eq(1));
648 EXPECT_TRUE(m.Matches(nullptr));
649}
650
651// Tests the linkage of the ResultOf matcher.
652TEST(LinkTest, TestMatcherPointee) {
653 int n = 1;
654
655 Matcher<int*> m = Pointee(Eq(1));
656 EXPECT_TRUE(m.Matches(&n));
657}
658
659// Tests the linkage of the Truly matcher.
660TEST(LinkTest, TestMatcherTruly) {
661 Matcher<const char*> m = Truly(&InvokeHelper::StaticBoolFromString);
662 EXPECT_TRUE(m.Matches(nullptr));
663}
664
665// Tests the linkage of the AllOf matcher.
666TEST(LinkTest, TestMatcherAllOf) {
667 Matcher<int> m = AllOf(_, Eq(1));
668 EXPECT_TRUE(m.Matches(1));
669}
670
671// Tests the linkage of the AnyOf matcher.
672TEST(LinkTest, TestMatcherAnyOf) {
673 Matcher<int> m = AnyOf(_, Eq(1));
674 EXPECT_TRUE(m.Matches(1));
675}
676
677// Tests the linkage of the Not matcher.
678TEST(LinkTest, TestMatcherNot) {
679 Matcher<int> m = Not(_);
680 EXPECT_FALSE(m.Matches(1));
681}
682
683// Tests the linkage of the MatcherCast<T>() function.
684TEST(LinkTest, TestMatcherCast) {
685 Matcher<const char*> m = MatcherCast<const char*>(_);
686 EXPECT_TRUE(m.Matches(nullptr));
687}
688
689#endif // GOOGLEMOCK_TEST_GMOCK_LINK_TEST_H_
Definition gmock_link_test.h:238
Definition gmock_link_test.h:195
Definition gmock_link_test.h:228
Definition gmock-nice-strict_test.cc:41
Definition gmock-actions.h:720
Definition gmock-internal-utils.h:55