1 //
2 // Copyright (C) 2014 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //      http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 
17 #include "update_engine/update_manager/boxed_value.h"
18 
19 #include <gtest/gtest.h>
20 #include <list>
21 #include <map>
22 #include <set>
23 #include <string>
24 #include <utility>
25 
26 #include <base/strings/stringprintf.h>
27 #include <base/time/time.h>
28 
29 #include "update_engine/update_manager/shill_provider.h"
30 #include "update_engine/update_manager/umtest_utils.h"
31 #include "update_engine/update_manager/updater_provider.h"
32 
33 using base::Time;
34 using base::TimeDelta;
35 using chromeos_update_engine::ConnectionTethering;
36 using chromeos_update_engine::ConnectionType;
37 using std::list;
38 using std::map;
39 using std::set;
40 using std::string;
41 
42 namespace chromeos_update_manager {
43 
44 // The DeleterMarker flags a bool variable when the class is destroyed.
45 class DeleterMarker {
46  public:
DeleterMarker(bool * marker)47   explicit DeleterMarker(bool* marker) : marker_(marker) { *marker_ = false; }
48 
~DeleterMarker()49   ~DeleterMarker() { *marker_ = true; }
50 
51  private:
52   friend string BoxedValue::ValuePrinter<DeleterMarker>(const void *);
53 
54   // Pointer to the bool marker.
55   bool* marker_;
56 };
57 
58 template<>
ValuePrinter(const void * value)59 string BoxedValue::ValuePrinter<DeleterMarker>(const void *value) {
60   const DeleterMarker* val = reinterpret_cast<const DeleterMarker*>(value);
61   return base::StringPrintf("DeleterMarker:%s",
62                             *val->marker_ ? "true" : "false");
63 }
64 
TEST(UmBoxedValueTest,Deleted)65 TEST(UmBoxedValueTest, Deleted) {
66   bool marker = true;
67   const DeleterMarker* deleter_marker = new DeleterMarker(&marker);
68 
69   EXPECT_FALSE(marker);
70   BoxedValue* box = new BoxedValue(deleter_marker);
71   EXPECT_FALSE(marker);
72   delete box;
73   EXPECT_TRUE(marker);
74 }
75 
TEST(UmBoxedValueTest,MoveConstructor)76 TEST(UmBoxedValueTest, MoveConstructor) {
77   bool marker = true;
78   const DeleterMarker* deleter_marker = new DeleterMarker(&marker);
79 
80   BoxedValue* box = new BoxedValue(deleter_marker);
81   BoxedValue* new_box = new BoxedValue(std::move(*box));
82   // box is now undefined but valid.
83   delete box;
84   EXPECT_FALSE(marker);
85   // The deleter_marker gets deleted at this point.
86   delete new_box;
87   EXPECT_TRUE(marker);
88 }
89 
TEST(UmBoxedValueTest,MixedList)90 TEST(UmBoxedValueTest, MixedList) {
91   list<BoxedValue> lst;
92   // This is mostly a compile test.
93   lst.emplace_back(new const int{42});
94   lst.emplace_back(new const string("Hello world!"));
95   bool marker;
96   lst.emplace_back(new const DeleterMarker(&marker));
97   EXPECT_FALSE(marker);
98   lst.clear();
99   EXPECT_TRUE(marker);
100 }
101 
TEST(UmBoxedValueTest,MixedMap)102 TEST(UmBoxedValueTest, MixedMap) {
103   map<int, BoxedValue> m;
104   m.emplace(42, BoxedValue(new const string("Hola mundo!")));
105 
106   auto it = m.find(42);
107   ASSERT_NE(it, m.end());
108   EXPECT_NE(nullptr, it->second.value());
109   EXPECT_EQ(nullptr, m[33].value());
110 }
111 
TEST(UmBoxedValueTest,StringToString)112 TEST(UmBoxedValueTest, StringToString) {
113   EXPECT_EQ("Hej Verden!",
114             BoxedValue(new string("Hej Verden!")).ToString());
115 }
116 
TEST(UmBoxedValueTest,IntToString)117 TEST(UmBoxedValueTest, IntToString) {
118   EXPECT_EQ("42", BoxedValue(new int(42)).ToString());
119 }
120 
TEST(UmBoxedValueTest,Int64ToString)121 TEST(UmBoxedValueTest, Int64ToString) {
122   // -123456789012345 doesn't fit in 32-bit integers.
123   EXPECT_EQ("-123456789012345", BoxedValue(
124       new int64_t(-123456789012345LL)).ToString());
125 }
126 
TEST(UmBoxedValueTest,UnsignedIntToString)127 TEST(UmBoxedValueTest, UnsignedIntToString) {
128   // 4294967295 is the biggest possible 32-bit unsigned integer.
129   EXPECT_EQ("4294967295",
130             BoxedValue(new unsigned int(4294967295U)).ToString());  // NOLINT
131 }
132 
TEST(UmBoxedValueTest,UnsignedInt64ToString)133 TEST(UmBoxedValueTest, UnsignedInt64ToString) {
134   // 18446744073709551615 is the biggest possible 64-bit unsigned integer.
135   EXPECT_EQ("18446744073709551615", BoxedValue(
136       new uint64_t(18446744073709551615ULL)).ToString());
137 }
138 
TEST(UmBoxedValueTest,BoolToString)139 TEST(UmBoxedValueTest, BoolToString) {
140   EXPECT_EQ("false", BoxedValue(new bool(false)).ToString());
141   EXPECT_EQ("true", BoxedValue(new bool(true)).ToString());
142 }
143 
TEST(UmBoxedValueTest,DoubleToString)144 TEST(UmBoxedValueTest, DoubleToString) {
145   EXPECT_EQ("1.501", BoxedValue(new double(1.501)).ToString());
146 }
147 
TEST(UmBoxedValueTest,TimeToString)148 TEST(UmBoxedValueTest, TimeToString) {
149   // Tue Apr 29 22:30:55 UTC 2014 is 1398810655 seconds since the Unix Epoch.
150   EXPECT_EQ("4/29/2014 22:30:55 GMT",
151             BoxedValue(new Time(Time::FromTimeT(1398810655))).ToString());
152 }
153 
TEST(UmBoxedValueTest,TimeDeltaToString)154 TEST(UmBoxedValueTest, TimeDeltaToString) {
155   // 12345 seconds is 3 hours, 25 minutes and 45 seconds.
156   EXPECT_EQ("3h25m45s",
157             BoxedValue(new TimeDelta(TimeDelta::FromSeconds(12345)))
158             .ToString());
159 }
160 
TEST(UmBoxedValueTest,ConnectionTypeToString)161 TEST(UmBoxedValueTest, ConnectionTypeToString) {
162   EXPECT_EQ("ethernet",
163             BoxedValue(new ConnectionType(ConnectionType::kEthernet))
164             .ToString());
165   EXPECT_EQ("wifi",
166             BoxedValue(new ConnectionType(ConnectionType::kWifi)).ToString());
167   EXPECT_EQ("wimax",
168             BoxedValue(new ConnectionType(ConnectionType::kWimax)).ToString());
169   EXPECT_EQ("bluetooth",
170             BoxedValue(new ConnectionType(ConnectionType::kBluetooth))
171             .ToString());
172   EXPECT_EQ("cellular",
173             BoxedValue(new ConnectionType(ConnectionType::kCellular))
174             .ToString());
175   EXPECT_EQ("Unknown",
176             BoxedValue(new ConnectionType(ConnectionType::kUnknown))
177             .ToString());
178 }
179 
TEST(UmBoxedValueTest,ConnectionTetheringToString)180 TEST(UmBoxedValueTest, ConnectionTetheringToString) {
181   EXPECT_EQ("Not Detected",
182             BoxedValue(new ConnectionTethering(
183                 ConnectionTethering::kNotDetected)).ToString());
184   EXPECT_EQ("Suspected",
185             BoxedValue(new ConnectionTethering(ConnectionTethering::kSuspected))
186             .ToString());
187   EXPECT_EQ("Confirmed",
188             BoxedValue(new ConnectionTethering(ConnectionTethering::kConfirmed))
189             .ToString());
190   EXPECT_EQ("Unknown",
191             BoxedValue(new ConnectionTethering(ConnectionTethering::kUnknown))
192             .ToString());
193 }
194 
TEST(UmBoxedValueTest,SetConnectionTypeToString)195 TEST(UmBoxedValueTest, SetConnectionTypeToString) {
196   set<ConnectionType>* set1 = new set<ConnectionType>;
197   set1->insert(ConnectionType::kWimax);
198   set1->insert(ConnectionType::kEthernet);
199   EXPECT_EQ("ethernet,wimax", BoxedValue(set1).ToString());
200 
201   set<ConnectionType>* set2 = new set<ConnectionType>;
202   set2->insert(ConnectionType::kWifi);
203   EXPECT_EQ("wifi", BoxedValue(set2).ToString());
204 }
205 
TEST(UmBoxedValueTest,StageToString)206 TEST(UmBoxedValueTest, StageToString) {
207   EXPECT_EQ("Idle",
208             BoxedValue(new Stage(Stage::kIdle)).ToString());
209   EXPECT_EQ("Checking For Update",
210             BoxedValue(new Stage(Stage::kCheckingForUpdate)).ToString());
211   EXPECT_EQ("Update Available",
212             BoxedValue(new Stage(Stage::kUpdateAvailable)).ToString());
213   EXPECT_EQ("Downloading",
214             BoxedValue(new Stage(Stage::kDownloading)).ToString());
215   EXPECT_EQ("Verifying",
216             BoxedValue(new Stage(Stage::kVerifying)).ToString());
217   EXPECT_EQ("Finalizing",
218             BoxedValue(new Stage(Stage::kFinalizing)).ToString());
219   EXPECT_EQ("Updated, Need Reboot",
220             BoxedValue(new Stage(Stage::kUpdatedNeedReboot)).ToString());
221   EXPECT_EQ("Reporting Error Event",
222             BoxedValue(new Stage(Stage::kReportingErrorEvent)).ToString());
223   EXPECT_EQ("Attempting Rollback",
224             BoxedValue(new Stage(Stage::kAttemptingRollback)).ToString());
225 }
226 
TEST(UmBoxedValueTest,DeleterMarkerToString)227 TEST(UmBoxedValueTest, DeleterMarkerToString) {
228   bool marker = false;
229   BoxedValue value = BoxedValue(new DeleterMarker(&marker));
230   EXPECT_EQ("DeleterMarker:false", value.ToString());
231   marker = true;
232   EXPECT_EQ("DeleterMarker:true", value.ToString());
233 }
234 
TEST(UmBoxedValueTest,UpdateRestrictionsToString)235 TEST(UmBoxedValueTest, UpdateRestrictionsToString) {
236   EXPECT_EQ(
237       "None",
238       BoxedValue(new UpdateRestrictions(UpdateRestrictions::kNone)).ToString());
239   EXPECT_EQ("Flags: RestrictDownloading",
240             BoxedValue(new UpdateRestrictions(
241                            UpdateRestrictions::kRestrictDownloading))
242                 .ToString());
243 }
244 
245 }  // namespace chromeos_update_manager
246