Roll usrcstplib -> r9048.
[chromium-blink-merge.git] / base / tuple_unittest.cc
blob8d620deb63984a2d6affda22e345d8613062af47
1 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "base/tuple.h"
7 #include "base/compiler_specific.h"
8 #include "testing/gtest/include/gtest/gtest.h"
10 namespace {
12 void DoAdd(int a, int b, int c, int* res) {
13 *res = a + b + c;
16 struct Addy {
17 Addy() { }
18 void DoAdd(int a, int b, int c, int d, int* res) {
19 *res = a + b + c + d;
23 struct Addz {
24 Addz() { }
25 void DoAdd(int a, int b, int c, int d, int e, int* res) {
26 *res = a + b + c + d + e;
30 } // namespace
32 TEST(TupleTest, Basic) {
33 Tuple0 t0 = MakeTuple();
34 ALLOW_UNUSED_LOCAL(t0);
35 Tuple1<int> t1(1);
36 Tuple2<int, const char*> t2 = MakeTuple(1, static_cast<const char*>("wee"));
37 Tuple3<int, int, int> t3(1, 2, 3);
38 Tuple4<int, int, int, int*> t4(1, 2, 3, &t1.a);
39 Tuple5<int, int, int, int, int*> t5(1, 2, 3, 4, &t4.a);
40 Tuple6<int, int, int, int, int, int*> t6(1, 2, 3, 4, 5, &t4.a);
42 EXPECT_EQ(1, t1.a);
43 EXPECT_EQ(1, t2.a);
44 EXPECT_EQ(1, t3.a);
45 EXPECT_EQ(2, t3.b);
46 EXPECT_EQ(3, t3.c);
47 EXPECT_EQ(1, t4.a);
48 EXPECT_EQ(2, t4.b);
49 EXPECT_EQ(3, t4.c);
50 EXPECT_EQ(1, t5.a);
51 EXPECT_EQ(2, t5.b);
52 EXPECT_EQ(3, t5.c);
53 EXPECT_EQ(4, t5.d);
54 EXPECT_EQ(1, t6.a);
55 EXPECT_EQ(2, t6.b);
56 EXPECT_EQ(3, t6.c);
57 EXPECT_EQ(4, t6.d);
58 EXPECT_EQ(5, t6.e);
60 EXPECT_EQ(1, t1.a);
61 DispatchToFunction(&DoAdd, t4);
62 EXPECT_EQ(6, t1.a);
64 int res = 0;
65 DispatchToFunction(&DoAdd, MakeTuple(9, 8, 7, &res));
66 EXPECT_EQ(24, res);
68 Addy addy;
69 EXPECT_EQ(1, t4.a);
70 DispatchToMethod(&addy, &Addy::DoAdd, t5);
71 EXPECT_EQ(10, t4.a);
73 Addz addz;
74 EXPECT_EQ(10, t4.a);
75 DispatchToMethod(&addz, &Addz::DoAdd, t6);
76 EXPECT_EQ(15, t4.a);
79 namespace {
81 struct CopyLogger {
82 CopyLogger() { ++TimesConstructed; }
83 CopyLogger(const CopyLogger& tocopy) { ++TimesConstructed; ++TimesCopied; }
84 ~CopyLogger() { }
86 static int TimesCopied;
87 static int TimesConstructed;
90 void SomeLoggerMethRef(const CopyLogger& logy, const CopyLogger* ptr, bool* b) {
91 *b = &logy == ptr;
94 void SomeLoggerMethCopy(CopyLogger logy, const CopyLogger* ptr, bool* b) {
95 *b = &logy == ptr;
98 int CopyLogger::TimesCopied = 0;
99 int CopyLogger::TimesConstructed = 0;
101 } // namespace
103 TEST(TupleTest, Copying) {
104 CopyLogger logger;
105 EXPECT_EQ(0, CopyLogger::TimesCopied);
106 EXPECT_EQ(1, CopyLogger::TimesConstructed);
108 bool res = false;
110 // Creating the tuple should copy the class to store internally in the tuple.
111 Tuple3<CopyLogger, CopyLogger*, bool*> tuple(logger, &logger, &res);
112 tuple.b = &tuple.a;
113 EXPECT_EQ(2, CopyLogger::TimesConstructed);
114 EXPECT_EQ(1, CopyLogger::TimesCopied);
116 // Our internal Logger and the one passed to the function should be the same.
117 res = false;
118 DispatchToFunction(&SomeLoggerMethRef, tuple);
119 EXPECT_TRUE(res);
120 EXPECT_EQ(2, CopyLogger::TimesConstructed);
121 EXPECT_EQ(1, CopyLogger::TimesCopied);
123 // Now they should be different, since the function call will make a copy.
124 res = false;
125 DispatchToFunction(&SomeLoggerMethCopy, tuple);
126 EXPECT_FALSE(res);
127 EXPECT_EQ(3, CopyLogger::TimesConstructed);
128 EXPECT_EQ(2, CopyLogger::TimesCopied);