Home | History | Annotate | Download | only in update_manager 
      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:
     47   explicit DeleterMarker(bool* marker) : marker_(marker) { *marker_ = false; }
     48 
     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<>
     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 
     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 
     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 
     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 
    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 
    112 TEST(UmBoxedValueTest, StringToString) {
    113   EXPECT_EQ("Hej Verden!",
    114             BoxedValue(new string("Hej Verden!")).ToString());
    115 }
    116 
    117 TEST(UmBoxedValueTest, IntToString) {
    118   EXPECT_EQ("42", BoxedValue(new int(42)).ToString());
    119 }
    120 
    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 
    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 
    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 
    139 TEST(UmBoxedValueTest, BoolToString) {
    140   EXPECT_EQ("false", BoxedValue(new bool(false)).ToString());
    141   EXPECT_EQ("true", BoxedValue(new bool(true)).ToString());
    142 }
    143 
    144 TEST(UmBoxedValueTest, DoubleToString) {
    145   EXPECT_EQ("1.501", BoxedValue(new double(1.501)).ToString());
    146 }
    147 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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