| // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "base/tuple.h" | |
| #include <gtest/gtest.h> | |
| #include "base/compiler_specific.h" | |
| namespace base { | |
| namespace { | |
| void DoAdd(int a, int b, int c, int* res) { | |
| *res = a + b + c; | |
| } | |
| struct Addy { | |
| Addy() { } | |
| void DoAdd(int a, int b, int c, int d, int* res) { | |
| *res = a + b + c + d; | |
| } | |
| }; | |
| struct Addz { | |
| Addz() { } | |
| void DoAdd(int a, int b, int c, int d, int e, int* res) { | |
| *res = a + b + c + d + e; | |
| } | |
| }; | |
| } // namespace | |
| TEST(TupleTest, Basic) { | |
| std::tuple<> t0 = std::make_tuple(); | |
| ALLOW_UNUSED_LOCAL(t0); | |
| std::tuple<int> t1(1); | |
| std::tuple<int, const char*> t2 = | |
| std::make_tuple(1, static_cast<const char*>("wee")); | |
| ALLOW_UNUSED_LOCAL(t2); | |
| std::tuple<int, int, int> t3(1, 2, 3); | |
| std::tuple<int, int, int, int*> t4(1, 2, 3, &std::get<0>(t1)); | |
| std::tuple<int, int, int, int, int*> t5(1, 2, 3, 4, &std::get<0>(t4)); | |
| std::tuple<int, int, int, int, int, int*> t6(1, 2, 3, 4, 5, &std::get<0>(t4)); | |
| EXPECT_EQ(1, std::get<0>(t1)); | |
| DispatchToFunction(&DoAdd, t4); | |
| EXPECT_EQ(6, std::get<0>(t1)); | |
| int res = 0; | |
| DispatchToFunction(&DoAdd, std::make_tuple(9, 8, 7, &res)); | |
| EXPECT_EQ(24, res); | |
| Addy addy; | |
| EXPECT_EQ(1, std::get<0>(t4)); | |
| DispatchToMethod(&addy, &Addy::DoAdd, t5); | |
| EXPECT_EQ(10, std::get<0>(t4)); | |
| Addz addz; | |
| EXPECT_EQ(10, std::get<0>(t4)); | |
| DispatchToMethod(&addz, &Addz::DoAdd, t6); | |
| EXPECT_EQ(15, std::get<0>(t4)); | |
| } | |
| namespace { | |
| struct CopyLogger { | |
| CopyLogger() { ++TimesConstructed; } | |
| CopyLogger(const CopyLogger& tocopy) { ++TimesConstructed; ++TimesCopied; } | |
| ~CopyLogger() { } | |
| static int TimesCopied; | |
| static int TimesConstructed; | |
| }; | |
| void SomeLoggerMethRef(const CopyLogger& logy, const CopyLogger* ptr, bool* b) { | |
| *b = &logy == ptr; | |
| } | |
| void SomeLoggerMethCopy(CopyLogger logy, const CopyLogger* ptr, bool* b) { | |
| *b = &logy == ptr; | |
| } | |
| int CopyLogger::TimesCopied = 0; | |
| int CopyLogger::TimesConstructed = 0; | |
| } // namespace | |
| TEST(TupleTest, Copying) { | |
| CopyLogger logger; | |
| EXPECT_EQ(0, CopyLogger::TimesCopied); | |
| EXPECT_EQ(1, CopyLogger::TimesConstructed); | |
| bool res = false; | |
| // Creating the tuple should copy the class to store internally in the tuple. | |
| std::tuple<CopyLogger, CopyLogger*, bool*> tuple(logger, &logger, &res); | |
| std::get<1>(tuple) = &std::get<0>(tuple); | |
| EXPECT_EQ(2, CopyLogger::TimesConstructed); | |
| EXPECT_EQ(1, CopyLogger::TimesCopied); | |
| // Our internal Logger and the one passed to the function should be the same. | |
| res = false; | |
| DispatchToFunction(&SomeLoggerMethRef, tuple); | |
| EXPECT_TRUE(res); | |
| EXPECT_EQ(2, CopyLogger::TimesConstructed); | |
| EXPECT_EQ(1, CopyLogger::TimesCopied); | |
| // Now they should be different, since the function call will make a copy. | |
| res = false; | |
| DispatchToFunction(&SomeLoggerMethCopy, tuple); | |
| EXPECT_FALSE(res); | |
| EXPECT_EQ(3, CopyLogger::TimesConstructed); | |
| EXPECT_EQ(2, CopyLogger::TimesCopied); | |
| } | |
| TEST(TupleTest, Get) { | |
| int i = 1; | |
| int j = 2; | |
| std::tuple<int, int&, int&&> t(3, i, std::move(j)); | |
| EXPECT_TRUE((std::is_same<int&, decltype(base::get<0>(t))>::value)); | |
| EXPECT_EQ(3, base::get<0>(t)); | |
| EXPECT_TRUE((std::is_same<int&, decltype(base::get<1>(t))>::value)); | |
| EXPECT_EQ(1, base::get<1>(t)); | |
| EXPECT_TRUE((std::is_same<int&, decltype(base::get<2>(t))>::value)); | |
| EXPECT_EQ(2, base::get<2>(t)); | |
| EXPECT_TRUE((std::is_same<int&&, | |
| decltype(base::get<0>(std::move(t)))>::value)); | |
| EXPECT_EQ(3, base::get<0>(std::move(t))); | |
| EXPECT_TRUE((std::is_same<int&, | |
| decltype(base::get<1>(std::move(t)))>::value)); | |
| EXPECT_EQ(1, base::get<1>(std::move(t))); | |
| EXPECT_TRUE((std::is_same<int&&, | |
| decltype(base::get<2>(std::move(t)))>::value)); | |
| EXPECT_EQ(2, base::get<2>(std::move(t))); | |
| } | |
| } // namespace base |