proxygen
gmock-internal-utils_test.cc
Go to the documentation of this file.
1 // Copyright 2007, Google Inc.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 //
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following disclaimer
12 // in the documentation and/or other materials provided with the
13 // distribution.
14 // * Neither the name of Google Inc. nor the names of its
15 // contributors may be used to endorse or promote products derived from
16 // this software without specific prior written permission.
17 //
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 //
30 // Author: wan@google.com (Zhanyong Wan)
31 
32 // Google Mock - a framework for writing C++ mock classes.
33 //
34 // This file tests the internal utilities.
35 
36 #include "gmock/internal/gmock-internal-utils.h"
37 #include <stdlib.h>
38 #include <map>
39 #include <memory>
40 #include <string>
41 #include <sstream>
42 #include <vector>
43 #include "gmock/gmock.h"
44 #include "gmock/internal/gmock-port.h"
45 #include "gtest/gtest.h"
46 #include "gtest/gtest-spi.h"
47 
48 // Indicates that this translation unit is part of Google Test's
49 // implementation. It must come before gtest-internal-inl.h is
50 // included, or there will be a compiler error. This trick is to
51 // prevent a user from accidentally including gtest-internal-inl.h in
52 // his code.
53 #define GTEST_IMPLEMENTATION_ 1
54 #include "src/gtest-internal-inl.h"
55 #undef GTEST_IMPLEMENTATION_
56 
57 #if GTEST_OS_CYGWIN
58 # include <sys/types.h> // For ssize_t. NOLINT
59 #endif
60 
61 class ProtocolMessage;
62 
63 namespace proto2 {
64 class Message;
65 } // namespace proto2
66 
67 namespace testing {
68 namespace internal {
69 
70 namespace {
71 
72 TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsNoWord) {
76 }
77 
78 TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsDigits) {
82  EXPECT_EQ("34 56", ConvertIdentifierNameToWords("_34_56"));
83 }
84 
85 TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsCamelCaseWords) {
86  EXPECT_EQ("a big word", ConvertIdentifierNameToWords("ABigWord"));
87  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("FooBar"));
89  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_Foo_Bar_"));
90  EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_Foo__And_Bar"));
91 }
92 
93 TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContains_SeparatedWords) {
94  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("foo_bar"));
95  EXPECT_EQ("foo", ConvertIdentifierNameToWords("_foo_"));
96  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_foo_bar_"));
97  EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_foo__and_bar"));
98 }
99 
100 TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameIsMixture) {
101  EXPECT_EQ("foo bar 123", ConvertIdentifierNameToWords("Foo_bar123"));
102  EXPECT_EQ("chapter 11 section 1",
103  ConvertIdentifierNameToWords("_Chapter11Section_1_"));
104 }
105 
106 TEST(PointeeOfTest, WorksForSmartPointers) {
107  CompileAssertTypesEqual<const char,
108  PointeeOf<internal::linked_ptr<const char> >::type>();
109 #if GTEST_HAS_STD_UNIQUE_PTR_
110  CompileAssertTypesEqual<int, PointeeOf<std::unique_ptr<int> >::type>();
111 #endif // GTEST_HAS_STD_UNIQUE_PTR_
112 #if GTEST_HAS_STD_SHARED_PTR_
113  CompileAssertTypesEqual<std::string,
114  PointeeOf<std::shared_ptr<std::string> >::type>();
115 #endif // GTEST_HAS_STD_SHARED_PTR_
116 }
117 
118 TEST(PointeeOfTest, WorksForRawPointers) {
122 }
123 
124 TEST(GetRawPointerTest, WorksForSmartPointers) {
125 #if GTEST_HAS_STD_UNIQUE_PTR_
126  const char* const raw_p1 = new const char('a'); // NOLINT
127  const std::unique_ptr<const char> p1(raw_p1);
128  EXPECT_EQ(raw_p1, GetRawPointer(p1));
129 #endif // GTEST_HAS_STD_UNIQUE_PTR_
130 #if GTEST_HAS_STD_SHARED_PTR_
131  double* const raw_p2 = new double(2.5); // NOLINT
132  const std::shared_ptr<double> p2(raw_p2);
133  EXPECT_EQ(raw_p2, GetRawPointer(p2));
134 #endif // GTEST_HAS_STD_SHARED_PTR_
135 
136  const char* const raw_p4 = new const char('a'); // NOLINT
137  const internal::linked_ptr<const char> p4(raw_p4);
138  EXPECT_EQ(raw_p4, GetRawPointer(p4));
139 }
140 
141 TEST(GetRawPointerTest, WorksForRawPointers) {
142  int* p = NULL;
143  // Don't use EXPECT_EQ as no NULL-testing magic on Symbian.
144  EXPECT_TRUE(NULL == GetRawPointer(p));
145  int n = 1;
146  EXPECT_EQ(&n, GetRawPointer(&n));
147 }
148 
149 // Tests KindOf<T>.
150 
151 class Base {};
152 class Derived : public Base {};
153 
154 TEST(KindOfTest, Bool) {
155  EXPECT_EQ(kBool, GMOCK_KIND_OF_(bool)); // NOLINT
156 }
157 
158 TEST(KindOfTest, Integer) {
159  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(char)); // NOLINT
160  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(signed char)); // NOLINT
161  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned char)); // NOLINT
162  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(short)); // NOLINT
163  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned short)); // NOLINT
164  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(int)); // NOLINT
165  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned int)); // NOLINT
166  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(long)); // NOLINT
167  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long)); // NOLINT
168  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(wchar_t)); // NOLINT
169  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(Int64)); // NOLINT
171  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(size_t)); // NOLINT
172 #if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN
173  // ssize_t is not defined on Windows and possibly some other OSes.
174  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(ssize_t)); // NOLINT
175 #endif
176 }
177 
178 TEST(KindOfTest, FloatingPoint) {
179  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(float)); // NOLINT
180  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(double)); // NOLINT
181  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(long double)); // NOLINT
182 }
183 
184 TEST(KindOfTest, Other) {
185  EXPECT_EQ(kOther, GMOCK_KIND_OF_(void*)); // NOLINT
186  EXPECT_EQ(kOther, GMOCK_KIND_OF_(char**)); // NOLINT
187  EXPECT_EQ(kOther, GMOCK_KIND_OF_(Base)); // NOLINT
188 }
189 
190 // Tests LosslessArithmeticConvertible<T, U>.
191 
192 TEST(LosslessArithmeticConvertibleTest, BoolToBool) {
194 }
195 
196 TEST(LosslessArithmeticConvertibleTest, BoolToInteger) {
199  EXPECT_TRUE(
201 }
202 
203 TEST(LosslessArithmeticConvertibleTest, BoolToFloatingPoint) {
206 }
207 
208 TEST(LosslessArithmeticConvertibleTest, IntegerToBool) {
211 }
212 
213 TEST(LosslessArithmeticConvertibleTest, IntegerToInteger) {
214  // Unsigned => larger signed is fine.
216 
217  // Unsigned => larger unsigned is fine.
218  EXPECT_TRUE(
220 
221  // Signed => unsigned is not fine.
223  EXPECT_FALSE((LosslessArithmeticConvertible<
224  signed char, unsigned int>::value)); // NOLINT
225 
226  // Same size and same signedness: fine too.
227  EXPECT_TRUE((LosslessArithmeticConvertible<
228  unsigned char, unsigned char>::value));
231  EXPECT_TRUE((LosslessArithmeticConvertible<
232  unsigned long, unsigned long>::value)); // NOLINT
233 
234  // Same size, different signedness: not fine.
235  EXPECT_FALSE((LosslessArithmeticConvertible<
236  unsigned char, signed char>::value));
239 
240  // Larger size => smaller size is not fine.
244 }
245 
246 TEST(LosslessArithmeticConvertibleTest, IntegerToFloatingPoint) {
247  // Integers cannot be losslessly converted to floating-points, as
248  // the format of the latter is implementation-defined.
251  EXPECT_FALSE((LosslessArithmeticConvertible<
252  short, long double>::value)); // NOLINT
253 }
254 
255 TEST(LosslessArithmeticConvertibleTest, FloatingPointToBool) {
258 }
259 
260 TEST(LosslessArithmeticConvertibleTest, FloatingPointToInteger) {
264 }
265 
266 TEST(LosslessArithmeticConvertibleTest, FloatingPointToFloatingPoint) {
267  // Smaller size => larger size is fine.
271 
272  // Same size: fine.
275 
276  // Larger size => smaller size is not fine.
279  if (sizeof(double) == sizeof(long double)) { // NOLINT
281  // In some implementations (e.g. MSVC), double and long double
282  // have the same size.
284  } else {
286  }
287 }
288 
289 // Tests the TupleMatches() template function.
290 
291 TEST(TupleMatchesTest, WorksForSize0) {
292  tuple<> matchers;
293  tuple<> values;
294 
295  EXPECT_TRUE(TupleMatches(matchers, values));
296 }
297 
298 TEST(TupleMatchesTest, WorksForSize1) {
299  tuple<Matcher<int> > matchers(Eq(1));
300  tuple<int> values1(1),
301  values2(2);
302 
303  EXPECT_TRUE(TupleMatches(matchers, values1));
304  EXPECT_FALSE(TupleMatches(matchers, values2));
305 }
306 
307 TEST(TupleMatchesTest, WorksForSize2) {
308  tuple<Matcher<int>, Matcher<char> > matchers(Eq(1), Eq('a'));
309  tuple<int, char> values1(1, 'a'),
310  values2(1, 'b'),
311  values3(2, 'a'),
312  values4(2, 'b');
313 
314  EXPECT_TRUE(TupleMatches(matchers, values1));
315  EXPECT_FALSE(TupleMatches(matchers, values2));
316  EXPECT_FALSE(TupleMatches(matchers, values3));
317  EXPECT_FALSE(TupleMatches(matchers, values4));
318 }
319 
320 TEST(TupleMatchesTest, WorksForSize5) {
321  tuple<Matcher<int>, Matcher<char>, Matcher<bool>, Matcher<long>, // NOLINT
322  Matcher<string> >
323  matchers(Eq(1), Eq('a'), Eq(true), Eq(2L), Eq("hi"));
324  tuple<int, char, bool, long, string> // NOLINT
325  values1(1, 'a', true, 2L, "hi"),
326  values2(1, 'a', true, 2L, "hello"),
327  values3(2, 'a', true, 2L, "hi");
328 
329  EXPECT_TRUE(TupleMatches(matchers, values1));
330  EXPECT_FALSE(TupleMatches(matchers, values2));
331  EXPECT_FALSE(TupleMatches(matchers, values3));
332 }
333 
334 // Tests that Assert(true, ...) succeeds.
335 TEST(AssertTest, SucceedsOnTrue) {
336  Assert(true, __FILE__, __LINE__, "This should succeed.");
337  Assert(true, __FILE__, __LINE__); // This should succeed too.
338 }
339 
340 // Tests that Assert(false, ...) generates a fatal failure.
341 TEST(AssertTest, FailsFatallyOnFalse) {
343  Assert(false, __FILE__, __LINE__, "This should fail.");
344  }, "");
345 
347  Assert(false, __FILE__, __LINE__);
348  }, "");
349 }
350 
351 // Tests that Expect(true, ...) succeeds.
352 TEST(ExpectTest, SucceedsOnTrue) {
353  Expect(true, __FILE__, __LINE__, "This should succeed.");
354  Expect(true, __FILE__, __LINE__); // This should succeed too.
355 }
356 
357 // Tests that Expect(false, ...) generates a non-fatal failure.
358 TEST(ExpectTest, FailsNonfatallyOnFalse) {
359  EXPECT_NONFATAL_FAILURE({ // NOLINT
360  Expect(false, __FILE__, __LINE__, "This should fail.");
361  }, "This should fail");
362 
363  EXPECT_NONFATAL_FAILURE({ // NOLINT
364  Expect(false, __FILE__, __LINE__);
365  }, "Expectation failed");
366 }
367 
368 // Tests LogIsVisible().
369 
370 class LogIsVisibleTest : public ::testing::Test {
371  protected:
372  virtual void SetUp() {
373  original_verbose_ = GMOCK_FLAG(verbose);
374  }
375 
376  virtual void TearDown() { GMOCK_FLAG(verbose) = original_verbose_; }
377 
379 };
380 
381 TEST_F(LogIsVisibleTest, AlwaysReturnsTrueIfVerbosityIsInfo) {
382  GMOCK_FLAG(verbose) = kInfoVerbosity;
385 }
386 
387 TEST_F(LogIsVisibleTest, AlwaysReturnsFalseIfVerbosityIsError) {
388  GMOCK_FLAG(verbose) = kErrorVerbosity;
391 }
392 
393 TEST_F(LogIsVisibleTest, WorksWhenVerbosityIsWarning) {
394  GMOCK_FLAG(verbose) = kWarningVerbosity;
397 }
398 
399 #if GTEST_HAS_STREAM_REDIRECTION
400 
401 // Tests the Log() function.
402 
403 // Verifies that Log() behaves correctly for the given verbosity level
404 // and log severity.
405 void TestLogWithSeverity(const string& verbosity, LogSeverity severity,
406  bool should_print) {
407  const string old_flag = GMOCK_FLAG(verbose);
408  GMOCK_FLAG(verbose) = verbosity;
409  CaptureStdout();
410  Log(severity, "Test log.\n", 0);
411  if (should_print) {
412  EXPECT_THAT(GetCapturedStdout().c_str(),
414  severity == kWarning ?
415  "^\nGMOCK WARNING:\nTest log\\.\nStack trace:\n" :
416  "^\nTest log\\.\nStack trace:\n"));
417  } else {
418  EXPECT_STREQ("", GetCapturedStdout().c_str());
419  }
420  GMOCK_FLAG(verbose) = old_flag;
421 }
422 
423 // Tests that when the stack_frames_to_skip parameter is negative,
424 // Log() doesn't include the stack trace in the output.
425 TEST(LogTest, NoStackTraceWhenStackFramesToSkipIsNegative) {
426  const string saved_flag = GMOCK_FLAG(verbose);
427  GMOCK_FLAG(verbose) = kInfoVerbosity;
428  CaptureStdout();
429  Log(kInfo, "Test log.\n", -1);
430  EXPECT_STREQ("\nTest log.\n", GetCapturedStdout().c_str());
431  GMOCK_FLAG(verbose) = saved_flag;
432 }
433 
434 struct MockStackTraceGetter : testing::internal::OsStackTraceGetterInterface {
435  virtual string CurrentStackTrace(int max_depth, int skip_count) {
436  return (testing::Message() << max_depth << "::" << skip_count << "\n")
437  .GetString();
438  }
439  virtual void UponLeavingGTest() {}
440 };
441 
442 // Tests that in opt mode, a positive stack_frames_to_skip argument is
443 // treated as 0.
444 TEST(LogTest, NoSkippingStackFrameInOptMode) {
445  MockStackTraceGetter* mock_os_stack_trace_getter = new MockStackTraceGetter;
446  GetUnitTestImpl()->set_os_stack_trace_getter(mock_os_stack_trace_getter);
447 
448  CaptureStdout();
449  Log(kWarning, "Test log.\n", 100);
450  const string log = GetCapturedStdout();
451 
452  string expected_trace =
453  (testing::Message() << GTEST_FLAG(stack_trace_depth) << "::").GetString();
454  string expected_message =
455  "\nGMOCK WARNING:\n"
456  "Test log.\n"
457  "Stack trace:\n" +
458  expected_trace;
459  EXPECT_THAT(log, HasSubstr(expected_message));
460  int skip_count = atoi(log.substr(expected_message.size()).c_str());
461 
462 # if defined(NDEBUG)
463  // In opt mode, no stack frame should be skipped.
464  const int expected_skip_count = 0;
465 # else
466  // In dbg mode, the stack frames should be skipped.
467  const int expected_skip_count = 100;
468 # endif
469 
470  // Note that each inner implementation layer will +1 the number to remove
471  // itself from the trace. This means that the value is a little higher than
472  // expected, but close enough.
473  EXPECT_THAT(skip_count,
474  AllOf(Ge(expected_skip_count), Le(expected_skip_count + 10)));
475 
476  // Restores the default OS stack trace getter.
478 }
479 
480 // Tests that all logs are printed when the value of the
481 // --gmock_verbose flag is "info".
482 TEST(LogTest, AllLogsArePrintedWhenVerbosityIsInfo) {
483  TestLogWithSeverity(kInfoVerbosity, kInfo, true);
484  TestLogWithSeverity(kInfoVerbosity, kWarning, true);
485 }
486 
487 // Tests that only warnings are printed when the value of the
488 // --gmock_verbose flag is "warning".
489 TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsWarning) {
490  TestLogWithSeverity(kWarningVerbosity, kInfo, false);
491  TestLogWithSeverity(kWarningVerbosity, kWarning, true);
492 }
493 
494 // Tests that no logs are printed when the value of the
495 // --gmock_verbose flag is "error".
496 TEST(LogTest, NoLogsArePrintedWhenVerbosityIsError) {
497  TestLogWithSeverity(kErrorVerbosity, kInfo, false);
498  TestLogWithSeverity(kErrorVerbosity, kWarning, false);
499 }
500 
501 // Tests that only warnings are printed when the value of the
502 // --gmock_verbose flag is invalid.
503 TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsInvalid) {
504  TestLogWithSeverity("invalid", kInfo, false);
505  TestLogWithSeverity("invalid", kWarning, true);
506 }
507 
508 #endif // GTEST_HAS_STREAM_REDIRECTION
509 
510 TEST(TypeTraitsTest, true_type) {
512 }
513 
514 TEST(TypeTraitsTest, false_type) {
516 }
517 
518 TEST(TypeTraitsTest, is_reference) {
522 }
523 
524 TEST(TypeTraitsTest, is_pointer) {
528 }
529 
530 TEST(TypeTraitsTest, type_equals) {
535 }
536 
537 TEST(TypeTraitsTest, remove_reference) {
538  EXPECT_TRUE((type_equals<char, remove_reference<char&>::type>::value));
539  EXPECT_TRUE((type_equals<const int,
541  EXPECT_TRUE((type_equals<int, remove_reference<int>::type>::value));
542  EXPECT_TRUE((type_equals<double*, remove_reference<double*>::type>::value));
543 }
544 
545 #if GTEST_HAS_STREAM_REDIRECTION
546 
547 // Verifies that Log() behaves correctly for the given verbosity level
548 // and log severity.
549 std::string GrabOutput(void(*logger)(), const char* verbosity) {
550  const string saved_flag = GMOCK_FLAG(verbose);
551  GMOCK_FLAG(verbose) = verbosity;
552  CaptureStdout();
553  logger();
554  GMOCK_FLAG(verbose) = saved_flag;
555  return GetCapturedStdout();
556 }
557 
558 class DummyMock {
559  public:
560  MOCK_METHOD0(TestMethod, void());
561  MOCK_METHOD1(TestMethodArg, void(int dummy));
562 };
563 
564 void ExpectCallLogger() {
565  DummyMock mock;
566  EXPECT_CALL(mock, TestMethod());
567  mock.TestMethod();
568 };
569 
570 // Verifies that EXPECT_CALL logs if the --gmock_verbose flag is set to "info".
571 TEST(ExpectCallTest, LogsWhenVerbosityIsInfo) {
572  EXPECT_THAT(std::string(GrabOutput(ExpectCallLogger, kInfoVerbosity)),
573  HasSubstr("EXPECT_CALL(mock, TestMethod())"));
574 }
575 
576 // Verifies that EXPECT_CALL doesn't log
577 // if the --gmock_verbose flag is set to "warning".
578 TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsWarning) {
579  EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kWarningVerbosity).c_str());
580 }
581 
582 // Verifies that EXPECT_CALL doesn't log
583 // if the --gmock_verbose flag is set to "error".
584 TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsError) {
585  EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kErrorVerbosity).c_str());
586 }
587 
588 void OnCallLogger() {
589  DummyMock mock;
590  ON_CALL(mock, TestMethod());
591 };
592 
593 // Verifies that ON_CALL logs if the --gmock_verbose flag is set to "info".
594 TEST(OnCallTest, LogsWhenVerbosityIsInfo) {
595  EXPECT_THAT(std::string(GrabOutput(OnCallLogger, kInfoVerbosity)),
596  HasSubstr("ON_CALL(mock, TestMethod())"));
597 }
598 
599 // Verifies that ON_CALL doesn't log
600 // if the --gmock_verbose flag is set to "warning".
601 TEST(OnCallTest, DoesNotLogWhenVerbosityIsWarning) {
602  EXPECT_STREQ("", GrabOutput(OnCallLogger, kWarningVerbosity).c_str());
603 }
604 
605 // Verifies that ON_CALL doesn't log if
606 // the --gmock_verbose flag is set to "error".
607 TEST(OnCallTest, DoesNotLogWhenVerbosityIsError) {
608  EXPECT_STREQ("", GrabOutput(OnCallLogger, kErrorVerbosity).c_str());
609 }
610 
611 void OnCallAnyArgumentLogger() {
612  DummyMock mock;
613  ON_CALL(mock, TestMethodArg(_));
614 }
615 
616 // Verifies that ON_CALL prints provided _ argument.
617 TEST(OnCallTest, LogsAnythingArgument) {
618  EXPECT_THAT(std::string(GrabOutput(OnCallAnyArgumentLogger, kInfoVerbosity)),
619  HasSubstr("ON_CALL(mock, TestMethodArg(_)"));
620 }
621 
622 #endif // GTEST_HAS_STREAM_REDIRECTION
623 
624 // Tests StlContainerView.
625 
626 TEST(StlContainerViewTest, WorksForStlContainer) {
627  StaticAssertTypeEq<std::vector<int>,
628  StlContainerView<std::vector<int> >::type>();
629  StaticAssertTypeEq<const std::vector<double>&,
630  StlContainerView<std::vector<double> >::const_reference>();
631 
632  typedef std::vector<char> Chars;
633  Chars v1;
634  const Chars& v2(StlContainerView<Chars>::ConstReference(v1));
635  EXPECT_EQ(&v1, &v2);
636 
637  v1.push_back('a');
638  Chars v3 = StlContainerView<Chars>::Copy(v1);
639  EXPECT_THAT(v3, Eq(v3));
640 }
641 
642 TEST(StlContainerViewTest, WorksForStaticNativeArray) {
643  StaticAssertTypeEq<NativeArray<int>,
645  StaticAssertTypeEq<NativeArray<double>,
647  StaticAssertTypeEq<NativeArray<char[3]>,
649 
650  StaticAssertTypeEq<const NativeArray<int>,
651  StlContainerView<int[2]>::const_reference>();
652 
653  int a1[3] = { 0, 1, 2 };
654  NativeArray<int> a2 = StlContainerView<int[3]>::ConstReference(a1);
655  EXPECT_EQ(3U, a2.size());
656  EXPECT_EQ(a1, a2.begin());
657 
658  const NativeArray<int> a3 = StlContainerView<int[3]>::Copy(a1);
659  ASSERT_EQ(3U, a3.size());
660  EXPECT_EQ(0, a3.begin()[0]);
661  EXPECT_EQ(1, a3.begin()[1]);
662  EXPECT_EQ(2, a3.begin()[2]);
663 
664  // Makes sure a1 and a3 aren't aliases.
665  a1[0] = 3;
666  EXPECT_EQ(0, a3.begin()[0]);
667 }
668 
669 TEST(StlContainerViewTest, WorksForDynamicNativeArray) {
670  StaticAssertTypeEq<NativeArray<int>,
671  StlContainerView<tuple<const int*, size_t> >::type>();
672  StaticAssertTypeEq<NativeArray<double>,
673  StlContainerView<tuple<linked_ptr<double>, int> >::type>();
674 
675  StaticAssertTypeEq<const NativeArray<int>,
676  StlContainerView<tuple<const int*, int> >::const_reference>();
677 
678  int a1[3] = { 0, 1, 2 };
679  const int* const p1 = a1;
680  NativeArray<int> a2 = StlContainerView<tuple<const int*, int> >::
681  ConstReference(make_tuple(p1, 3));
682  EXPECT_EQ(3U, a2.size());
683  EXPECT_EQ(a1, a2.begin());
684 
685  const NativeArray<int> a3 = StlContainerView<tuple<int*, size_t> >::
686  Copy(make_tuple(static_cast<int*>(a1), 3));
687  ASSERT_EQ(3U, a3.size());
688  EXPECT_EQ(0, a3.begin()[0]);
689  EXPECT_EQ(1, a3.begin()[1]);
690  EXPECT_EQ(2, a3.begin()[2]);
691 
692  // Makes sure a1 and a3 aren't aliases.
693  a1[0] = 3;
694  EXPECT_EQ(0, a3.begin()[0]);
695 }
696 
697 } // namespace
698 } // namespace internal
699 } // namespace testing
#define GTEST_FLAG(name)
Definition: gtest-port.h:2504
class UnitTestImpl * GetUnitTestImpl()
int verbosity
Definition: upload.py:59
#define TEST(test_case_name, test_name)
Definition: gtest.h:2187
GTEST_API_ string ConvertIdentifierNameToWords(const char *id_name)
string original_verbose_
#define ASSERT_EQ(val1, val2)
Definition: gtest.h:1956
internal::EqMatcher< T > Eq(T x)
const char kErrorVerbosity[]
PskType type
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
#define GTEST_INTENTIONAL_CONST_COND_POP_()
Definition: gtest-port.h:899
PolymorphicMatcher< internal::MatchesRegexMatcher > ContainsRegex(const internal::RE *regex)
TypeWithSize< 8 >::UInt UInt64
Definition: gtest-port.h:2497
bool TupleMatches(const MatcherTuple &matcher_tuple, const ValueTuple &value_tuple)
tuple make_tuple()
Definition: gtest-tuple.h:675
bool_constant< true > true_type
Definition: gtest-port.h:2210
#define EXPECT_STREQ(s1, s2)
Definition: gtest.h:1995
void set_os_stack_trace_getter(OsStackTraceGetterInterface *getter)
Definition: gtest.cc:4907
internal::LeMatcher< Rhs > Le(Rhs x)
void Expect(bool condition, const char *file, int line, const string &msg)
const char kWarningVerbosity[]
PolymorphicMatcher< internal::HasSubstrMatcher< internal::string > > HasSubstr(const internal::string &substring)
#define GMOCK_FLAG(name)
Definition: gmock-port.h:70
GTEST_API_ void Log(LogSeverity severity, const string &message, int stack_frames_to_skip)
void dummy()
AtomicCounter< T, DeterministicAtomic > Base
static const char *const value
Definition: Conv.cpp:50
GTEST_API_ bool LogIsVisible(LogSeverity severity)
StrictConjunction< T< As >... > AllOf
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
#define EXPECT_DEATH_IF_SUPPORTED(statement, regex)
#define EXPECT_THAT(value, matcher)
#define ON_CALL(obj, call)
void Assert(bool condition, const char *file, int line)
#define MOCK_METHOD1(m,...)
const char * string
Definition: Conv.cpp:212
#define EXPECT_NONFATAL_FAILURE(statement, substr)
Definition: gtest-spi.h:204
const Pointer::element_type * GetRawPointer(const Pointer &p)
bool_constant< false > false_type
Definition: gtest-port.h:2209
#define EXPECT_CALL(obj, call)
std::string GetCapturedStdout()
const internal::AnythingMatcher _
#define GMOCK_KIND_OF_(type)
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
internal::GeMatcher< Rhs > Ge(Rhs x)
#define GTEST_INTENTIONAL_CONST_COND_PUSH_()
Definition: gtest-port.h:897
std::vector< int > values(1'000)
#define TEST_F(test_fixture, test_name)
Definition: gtest.h:2216
#define MOCK_METHOD0(m,...)