OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2014 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. | |
4 | |
5 #include <vector> | |
6 | |
7 #include "base/scoped_nullable_generic.h" | |
8 #include "testing/gtest/include/gtest/gtest.h" | |
9 | |
10 namespace base { | |
11 | |
12 namespace { | |
13 | |
14 struct IntTraits { | |
15 IntTraits(std::vector<int>* freed) : freed_ints(freed) {} | |
16 | |
17 static int NullValue() { | |
18 return -1; | |
19 } | |
20 void Free(int value) { | |
21 freed_ints->push_back(value); | |
22 } | |
23 | |
24 std::vector<int>* freed_ints; | |
25 }; | |
26 | |
27 typedef ScopedNullableGeneric<int, IntTraits> ScopedInt; | |
28 | |
29 } // namespace | |
30 | |
31 TEST(ScopedGenericHandleTest, ScopedGenericHandle) { | |
32 std::vector<int> values_freed; | |
33 IntTraits traits(&values_freed); | |
34 | |
35 // Null case, delete should not be called. | |
36 { | |
37 ScopedInt a(IntTraits::NullValue(), traits); | |
38 } | |
39 EXPECT_TRUE(values_freed.empty()); | |
40 | |
41 // Simple deleting case. | |
42 static const int kFirst = 0; | |
43 { | |
44 ScopedInt a(kFirst, traits); | |
45 } | |
46 ASSERT_EQ(1u, values_freed.size()); | |
47 ASSERT_EQ(kFirst, values_freed[0]); | |
48 values_freed.clear(); | |
49 | |
50 // Release should return the right value and leave the object empty. | |
51 { | |
52 ScopedInt a(kFirst, traits); | |
53 EXPECT_EQ(kFirst, a.release()); | |
54 | |
55 ScopedInt b(IntTraits::NullValue(), traits); | |
56 EXPECT_EQ(IntTraits::NullValue(), b.release()); | |
57 } | |
58 ASSERT_TRUE(values_freed.empty()); | |
59 | |
60 // Reset should free the old value, then the new one should go away when | |
61 // it goes out of scope. | |
62 static const int kSecond = 1; | |
63 { | |
64 ScopedInt b(kFirst, traits); | |
65 b.reset(kSecond); | |
66 ASSERT_EQ(1u, values_freed.size()); | |
67 ASSERT_EQ(kFirst, values_freed[0]); | |
68 } | |
69 ASSERT_EQ(2u, values_freed.size()); | |
70 ASSERT_EQ(kSecond, values_freed[1]); | |
71 values_freed.clear(); | |
72 | |
73 // Swap. | |
74 { | |
75 ScopedInt a(kFirst, traits); | |
76 ScopedInt b(kSecond, traits); | |
77 a.swap(b); | |
78 EXPECT_TRUE(values_freed.empty()); // Nothing should be freed. | |
79 EXPECT_EQ(kSecond, a.get()); | |
80 EXPECT_EQ(kFirst, b.get()); | |
81 } | |
82 // Values should be deleted in the opposite order. | |
83 ASSERT_EQ(2u, values_freed.size()); | |
84 EXPECT_EQ(kFirst, values_freed[0]); | |
85 EXPECT_EQ(kSecond, values_freed[1]); | |
86 values_freed.clear(); | |
87 | |
88 // Pass. | |
89 { | |
90 ScopedInt a(kFirst, traits); | |
91 ScopedInt b(a.Pass()); | |
92 EXPECT_TRUE(values_freed.empty()); // Nothing should be freed. | |
93 ASSERT_EQ(IntTraits::NullValue(), a.get()); | |
94 ASSERT_EQ(kFirst, b.get()); | |
95 } | |
96 ASSERT_EQ(1u, values_freed.size()); | |
97 ASSERT_EQ(kFirst, values_freed[0]); | |
98 } | |
99 | |
100 TEST(ScopedGenericHandleTest, Operators) { | |
101 std::vector<int> values_freed; | |
102 IntTraits traits(&values_freed); | |
103 | |
104 static const int kFirst = 0; | |
105 static const int kSecond = 1; | |
106 { | |
107 ScopedInt a(kFirst, traits); | |
108 EXPECT_TRUE(a == kFirst); | |
109 EXPECT_FALSE(a != kFirst); | |
110 EXPECT_FALSE(a == kSecond); | |
111 EXPECT_TRUE(a != kSecond); | |
112 | |
113 EXPECT_TRUE(kFirst == a); | |
114 EXPECT_FALSE(kFirst != a); | |
115 EXPECT_FALSE(kSecond == a); | |
116 EXPECT_TRUE(kSecond != a); | |
117 } | |
118 | |
119 // Testable. | |
viettrungluu
2014/03/10 17:35:56
This comment no longer really makes sense.
| |
120 { | |
121 ScopedInt a(kFirst, traits); | |
122 if (!a.is_valid()) { | |
viettrungluu
2014/03/10 17:35:56
Probably just EXPECT_TRUE(a.is_valid()); (etc., be
| |
123 EXPECT_FALSE(true); | |
124 } | |
125 a.reset(); | |
126 if (a.is_valid()) { | |
127 EXPECT_FALSE(true); | |
128 } | |
129 } | |
130 } | |
131 | |
132 // Cheesy manual "no compile" test for manually validating changes. | |
133 #if 0 | |
134 TEST(ScopedGenericHandleTest, NoCompile) { | |
135 // Assignment shouldn't work. | |
136 /*{ | |
137 ScopedInt a(kFirst, traits); | |
138 ScopedInt b(a); | |
139 }*/ | |
140 | |
141 // Comparison shouldn't work. | |
142 /*{ | |
143 ScopedInt a(kFirst, traits); | |
144 ScopedInt b(kFirst, traits); | |
145 if (a == b) { | |
146 } | |
147 }*/ | |
148 | |
149 // Implicit conversion to bool shouldn't work. | |
150 /*{ | |
151 ScopedInt a(kFirst, traits); | |
152 bool result = a; | |
153 }*/ | |
154 } | |
155 #endif | |
156 | |
157 } // namespace base | |
OLD | NEW |