X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftesting%2Fgmock%2Ftest%2Fgmock-generated-matchers_test.cc;h=0e9f77f5ebc4f8823fa86c0f737922382769c40e;hb=4a1a0bdd01eef90b0826a0e761d3379d3715c10f;hp=4b7e6e058f7f61f25dc02ade8ff986b64d0f45f5;hpb=b1be5ca53587d23e7aeb77b26861fdc0a181ffd8;p=platform%2Fframework%2Fweb%2Fcrosswalk.git diff --git a/src/testing/gmock/test/gmock-generated-matchers_test.cc b/src/testing/gmock/test/gmock-generated-matchers_test.cc index 4b7e6e0..0e9f77f 100644 --- a/src/testing/gmock/test/gmock-generated-matchers_test.cc +++ b/src/testing/gmock/test/gmock-generated-matchers_test.cc @@ -53,9 +53,9 @@ using std::pair; using std::set; using std::stringstream; using std::vector; -using std::tr1::get; -using std::tr1::make_tuple; -using std::tr1::tuple; +using testing::get; +using testing::make_tuple; +using testing::tuple; using testing::_; using testing::Args; using testing::Contains; @@ -64,6 +64,7 @@ using testing::ElementsAreArray; using testing::Eq; using testing::Ge; using testing::Gt; +using testing::Le; using testing::Lt; using testing::MakeMatcher; using testing::Matcher; @@ -284,9 +285,6 @@ Matcher GreaterThan(int n) { // Tests for ElementsAre(). -// Evaluates to the number of elements in 'array'. -#define GMOCK_ARRAY_SIZE_(array) (sizeof(array)/sizeof(array[0])) - TEST(ElementsAreTest, CanDescribeExpectingNoElement) { Matcher&> m = ElementsAre(); EXPECT_EQ("is empty", Describe(m)); @@ -336,7 +334,7 @@ TEST(ElementsAreTest, ExplainsNonTrivialMatch) { ElementsAre(GreaterThan(1), 0, GreaterThan(2)); const int a[] = { 10, 0, 100 }; - vector test_vector(a, a + GMOCK_ARRAY_SIZE_(a)); + vector test_vector(a, a + GTEST_ARRAY_SIZE_(a)); EXPECT_EQ("whose element #0 matches, which is 9 more than 1,\n" "and whose element #2 matches, which is 98 more than 2", Explain(m, test_vector)); @@ -421,7 +419,7 @@ TEST(ElementsAreTest, MatchesThreeElementsMixedMatchers) { TEST(ElementsAreTest, MatchesTenElementVector) { const int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; - vector test_vector(a, a + GMOCK_ARRAY_SIZE_(a)); + vector test_vector(a, a + GTEST_ARRAY_SIZE_(a)); EXPECT_THAT(test_vector, // The element list can contain values and/or matchers @@ -464,7 +462,7 @@ TEST(ElementsAreTest, WorksForNestedContainer) { }; vector > nested; - for (size_t i = 0; i < GMOCK_ARRAY_SIZE_(strings); i++) { + for (size_t i = 0; i < GTEST_ARRAY_SIZE_(strings); i++) { nested.push_back(list(strings[i], strings[i] + strlen(strings[i]))); } @@ -476,7 +474,7 @@ TEST(ElementsAreTest, WorksForNestedContainer) { TEST(ElementsAreTest, WorksWithByRefElementMatchers) { int a[] = { 0, 1, 2 }; - vector v(a, a + GMOCK_ARRAY_SIZE_(a)); + vector v(a, a + GTEST_ARRAY_SIZE_(a)); EXPECT_THAT(v, ElementsAre(Ref(v[0]), Ref(v[1]), Ref(v[2]))); EXPECT_THAT(v, Not(ElementsAre(Ref(v[0]), Ref(v[1]), Ref(a[2])))); @@ -484,7 +482,7 @@ TEST(ElementsAreTest, WorksWithByRefElementMatchers) { TEST(ElementsAreTest, WorksWithContainerPointerUsingPointee) { int a[] = { 0, 1, 2 }; - vector v(a, a + GMOCK_ARRAY_SIZE_(a)); + vector v(a, a + GTEST_ARRAY_SIZE_(a)); EXPECT_THAT(&v, Pointee(ElementsAre(0, 1, _))); EXPECT_THAT(&v, Not(Pointee(ElementsAre(0, _, 3)))); @@ -509,7 +507,7 @@ class NativeArrayPassedAsPointerAndSize { TEST(ElementsAreTest, WorksWithNativeArrayPassedAsPointerAndSize) { int array[] = { 0, 1 }; - ::std::tr1::tuple array_as_tuple(array, 2); + ::testing::tuple array_as_tuple(array, 2); EXPECT_THAT(array_as_tuple, ElementsAre(0, 1)); EXPECT_THAT(array_as_tuple, Not(ElementsAre(0))); @@ -563,8 +561,8 @@ TEST(ElementsAreTest, MakesCopyOfArguments) { int x = 1; int y = 2; // This should make a copy of x and y. - ::testing::internal::ElementsAreMatcher2 polymorphic_matcher = - ElementsAre(x, y); + ::testing::internal::ElementsAreMatcher > + polymorphic_matcher = ElementsAre(x, y); // Changing x and y now shouldn't affect the meaning of the above matcher. x = y = 0; const int array1[] = { 1, 2 }; @@ -573,6 +571,7 @@ TEST(ElementsAreTest, MakesCopyOfArguments) { EXPECT_THAT(array2, Not(polymorphic_matcher)); } + // Tests for ElementsAreArray(). Since ElementsAreArray() shares most // of the implementation with ElementsAre(), we don't test it as // thoroughly here. @@ -580,7 +579,7 @@ TEST(ElementsAreTest, MakesCopyOfArguments) { TEST(ElementsAreArrayTest, CanBeCreatedWithValueArray) { const int a[] = { 1, 2, 3 }; - vector test_vector(a, a + GMOCK_ARRAY_SIZE_(a)); + vector test_vector(a, a + GTEST_ARRAY_SIZE_(a)); EXPECT_THAT(test_vector, ElementsAreArray(a)); test_vector[2] = 0; @@ -590,18 +589,18 @@ TEST(ElementsAreArrayTest, CanBeCreatedWithValueArray) { TEST(ElementsAreArrayTest, CanBeCreatedWithArraySize) { const char* a[] = { "one", "two", "three" }; - vector test_vector(a, a + GMOCK_ARRAY_SIZE_(a)); - EXPECT_THAT(test_vector, ElementsAreArray(a, GMOCK_ARRAY_SIZE_(a))); + vector test_vector(a, a + GTEST_ARRAY_SIZE_(a)); + EXPECT_THAT(test_vector, ElementsAreArray(a, GTEST_ARRAY_SIZE_(a))); const char** p = a; test_vector[0] = "1"; - EXPECT_THAT(test_vector, Not(ElementsAreArray(p, GMOCK_ARRAY_SIZE_(a)))); + EXPECT_THAT(test_vector, Not(ElementsAreArray(p, GTEST_ARRAY_SIZE_(a)))); } TEST(ElementsAreArrayTest, CanBeCreatedWithoutArraySize) { const char* a[] = { "one", "two", "three" }; - vector test_vector(a, a + GMOCK_ARRAY_SIZE_(a)); + vector test_vector(a, a + GTEST_ARRAY_SIZE_(a)); EXPECT_THAT(test_vector, ElementsAreArray(a)); test_vector[0] = "1"; @@ -624,19 +623,57 @@ TEST(ElementsAreArrayTest, CanBeCreatedWithMatcherArray) { TEST(ElementsAreArrayTest, CanBeCreatedWithVector) { const int a[] = { 1, 2, 3 }; - vector test_vector(a, a + GMOCK_ARRAY_SIZE_(a)); - const vector expected(a, a + GMOCK_ARRAY_SIZE_(a)); + vector test_vector(a, a + GTEST_ARRAY_SIZE_(a)); + const vector expected(a, a + GTEST_ARRAY_SIZE_(a)); EXPECT_THAT(test_vector, ElementsAreArray(expected)); test_vector.push_back(4); EXPECT_THAT(test_vector, Not(ElementsAreArray(expected))); } +#if GTEST_HAS_STD_INITIALIZER_LIST_ + +TEST(ElementsAreArrayTest, TakesInitializerList) { + const int a[5] = { 1, 2, 3, 4, 5 }; + EXPECT_THAT(a, ElementsAreArray({ 1, 2, 3, 4, 5 })); + EXPECT_THAT(a, Not(ElementsAreArray({ 1, 2, 3, 5, 4 }))); + EXPECT_THAT(a, Not(ElementsAreArray({ 1, 2, 3, 4, 6 }))); +} + +TEST(ElementsAreArrayTest, TakesInitializerListOfCStrings) { + const string a[5] = { "a", "b", "c", "d", "e" }; + EXPECT_THAT(a, ElementsAreArray({ "a", "b", "c", "d", "e" })); + EXPECT_THAT(a, Not(ElementsAreArray({ "a", "b", "c", "e", "d" }))); + EXPECT_THAT(a, Not(ElementsAreArray({ "a", "b", "c", "d", "ef" }))); +} + +TEST(ElementsAreArrayTest, TakesInitializerListOfSameTypedMatchers) { + const int a[5] = { 1, 2, 3, 4, 5 }; + EXPECT_THAT(a, ElementsAreArray( + { Eq(1), Eq(2), Eq(3), Eq(4), Eq(5) })); + EXPECT_THAT(a, Not(ElementsAreArray( + { Eq(1), Eq(2), Eq(3), Eq(4), Eq(6) }))); +} + +TEST(ElementsAreArrayTest, + TakesInitializerListOfDifferentTypedMatchers) { + const int a[5] = { 1, 2, 3, 4, 5 }; + // The compiler cannot infer the type of the initializer list if its + // elements have different types. We must explicitly specify the + // unified element type in this case. + EXPECT_THAT(a, ElementsAreArray >( + { Eq(1), Ne(-2), Ge(3), Le(4), Eq(5) })); + EXPECT_THAT(a, Not(ElementsAreArray >( + { Eq(1), Ne(-2), Ge(3), Le(4), Eq(6) }))); +} + +#endif // GTEST_HAS_STD_INITIALIZER_LIST_ + TEST(ElementsAreArrayTest, CanBeCreatedWithMatcherVector) { const int a[] = { 1, 2, 3 }; const Matcher kMatchers[] = { Eq(1), Eq(2), Eq(3) }; - vector test_vector(a, a + GMOCK_ARRAY_SIZE_(a)); + vector test_vector(a, a + GTEST_ARRAY_SIZE_(a)); const vector > expected( - kMatchers, kMatchers + GMOCK_ARRAY_SIZE_(kMatchers)); + kMatchers, kMatchers + GTEST_ARRAY_SIZE_(kMatchers)); EXPECT_THAT(test_vector, ElementsAreArray(expected)); test_vector.push_back(4); EXPECT_THAT(test_vector, Not(ElementsAreArray(expected))); @@ -644,11 +681,11 @@ TEST(ElementsAreArrayTest, CanBeCreatedWithMatcherVector) { TEST(ElementsAreArrayTest, CanBeCreatedWithIteratorRange) { const int a[] = { 1, 2, 3 }; - const vector test_vector(a, a + GMOCK_ARRAY_SIZE_(a)); - const vector expected(a, a + GMOCK_ARRAY_SIZE_(a)); + const vector test_vector(a, a + GTEST_ARRAY_SIZE_(a)); + const vector expected(a, a + GTEST_ARRAY_SIZE_(a)); EXPECT_THAT(test_vector, ElementsAreArray(expected.begin(), expected.end())); // Pointers are iterators, too. - EXPECT_THAT(test_vector, ElementsAreArray(a, a + GMOCK_ARRAY_SIZE_(a))); + EXPECT_THAT(test_vector, ElementsAreArray(a, a + GTEST_ARRAY_SIZE_(a))); // The empty range of NULL pointers should also be okay. int* const null_int = NULL; EXPECT_THAT(test_vector, Not(ElementsAreArray(null_int, null_int))); @@ -668,8 +705,8 @@ TEST(ElementsAreArrayTest, WorksWithNativeArray) { TEST(ElementsAreArrayTest, SourceLifeSpan) { const int a[] = { 1, 2, 3 }; - vector test_vector(a, a + GMOCK_ARRAY_SIZE_(a)); - vector expect(a, a + GMOCK_ARRAY_SIZE_(a)); + vector test_vector(a, a + GTEST_ARRAY_SIZE_(a)); + vector expect(a, a + GTEST_ARRAY_SIZE_(a)); ElementsAreArrayMatcher matcher_maker = ElementsAreArray(expect.begin(), expect.end()); EXPECT_THAT(test_vector, matcher_maker); @@ -1039,6 +1076,19 @@ TEST(MatcherPnMacroTest, TypesAreCorrect) { EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8, '9'); EqualsSumOfMatcherP10 a10 = EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8, 9, '0'); + + // Avoid "unused variable" warnings. + (void)a0; + (void)a1; + (void)a2; + (void)a3; + (void)a4; + (void)a5; + (void)a6; + (void)a7; + (void)a8; + (void)a9; + (void)a10; } // Tests that matcher-typed parameters can be used in Value() inside a