| // 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 |