You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
293 lines
10 KiB
293 lines
10 KiB
//
|
|
// Copyright (C) 2014 The Android Open Source Project
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
|
|
#include "update_engine/update_manager/boxed_value.h"
|
|
|
|
#include <gtest/gtest.h>
|
|
#include <list>
|
|
#include <map>
|
|
#include <set>
|
|
#include <string>
|
|
#include <utility>
|
|
|
|
#include <base/strings/stringprintf.h>
|
|
#include <base/time/time.h>
|
|
|
|
#include "update_engine/update_manager/rollback_prefs.h"
|
|
#include "update_engine/update_manager/shill_provider.h"
|
|
#include "update_engine/update_manager/umtest_utils.h"
|
|
#include "update_engine/update_manager/updater_provider.h"
|
|
#include "update_engine/update_manager/weekly_time.h"
|
|
|
|
using base::Time;
|
|
using base::TimeDelta;
|
|
using chromeos_update_engine::ConnectionTethering;
|
|
using chromeos_update_engine::ConnectionType;
|
|
using std::list;
|
|
using std::map;
|
|
using std::set;
|
|
using std::string;
|
|
|
|
namespace chromeos_update_manager {
|
|
|
|
// The DeleterMarker flags a bool variable when the class is destroyed.
|
|
class DeleterMarker {
|
|
public:
|
|
explicit DeleterMarker(bool* marker) : marker_(marker) { *marker_ = false; }
|
|
|
|
~DeleterMarker() { *marker_ = true; }
|
|
|
|
private:
|
|
friend string BoxedValue::ValuePrinter<DeleterMarker>(const void*);
|
|
|
|
// Pointer to the bool marker.
|
|
bool* marker_;
|
|
};
|
|
|
|
template <>
|
|
string BoxedValue::ValuePrinter<DeleterMarker>(const void* value) {
|
|
const DeleterMarker* val = reinterpret_cast<const DeleterMarker*>(value);
|
|
return base::StringPrintf("DeleterMarker:%s",
|
|
*val->marker_ ? "true" : "false");
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, Deleted) {
|
|
bool marker = true;
|
|
const DeleterMarker* deleter_marker = new DeleterMarker(&marker);
|
|
|
|
EXPECT_FALSE(marker);
|
|
BoxedValue* box = new BoxedValue(deleter_marker);
|
|
EXPECT_FALSE(marker);
|
|
delete box;
|
|
EXPECT_TRUE(marker);
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, MoveConstructor) {
|
|
bool marker = true;
|
|
const DeleterMarker* deleter_marker = new DeleterMarker(&marker);
|
|
|
|
BoxedValue* box = new BoxedValue(deleter_marker);
|
|
BoxedValue* new_box = new BoxedValue(std::move(*box));
|
|
// box is now undefined but valid.
|
|
delete box;
|
|
EXPECT_FALSE(marker);
|
|
// The deleter_marker gets deleted at this point.
|
|
delete new_box;
|
|
EXPECT_TRUE(marker);
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, MixedList) {
|
|
list<BoxedValue> lst;
|
|
// This is mostly a compile test.
|
|
lst.emplace_back(new const int{42});
|
|
lst.emplace_back(new const string("Hello world!"));
|
|
bool marker;
|
|
lst.emplace_back(new const DeleterMarker(&marker));
|
|
EXPECT_FALSE(marker);
|
|
lst.clear();
|
|
EXPECT_TRUE(marker);
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, MixedMap) {
|
|
map<int, BoxedValue> m;
|
|
m.emplace(42, BoxedValue(new const string("Hola mundo!")));
|
|
|
|
auto it = m.find(42);
|
|
ASSERT_NE(it, m.end());
|
|
EXPECT_NE(nullptr, it->second.value());
|
|
EXPECT_EQ(nullptr, m[33].value());
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, StringToString) {
|
|
EXPECT_EQ("Hej Verden!", BoxedValue(new string("Hej Verden!")).ToString());
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, IntToString) {
|
|
EXPECT_EQ("42", BoxedValue(new int(42)).ToString());
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, Int64ToString) {
|
|
// -123456789012345 doesn't fit in 32-bit integers.
|
|
EXPECT_EQ("-123456789012345",
|
|
BoxedValue(new int64_t(-123456789012345LL)).ToString());
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, UnsignedIntToString) {
|
|
// 4294967295 is the biggest possible 32-bit unsigned integer.
|
|
EXPECT_EQ("4294967295",
|
|
BoxedValue(new unsigned int(4294967295U)).ToString()); // NOLINT
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, UnsignedInt64ToString) {
|
|
// 18446744073709551615 is the biggest possible 64-bit unsigned integer.
|
|
EXPECT_EQ("18446744073709551615",
|
|
BoxedValue(new uint64_t(18446744073709551615ULL)).ToString());
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, BoolToString) {
|
|
EXPECT_EQ("false", BoxedValue(new bool(false)).ToString());
|
|
EXPECT_EQ("true", BoxedValue(new bool(true)).ToString());
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, DoubleToString) {
|
|
EXPECT_EQ("1.501", BoxedValue(new double(1.501)).ToString());
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, TimeToString) {
|
|
// Tue Apr 29 22:30:55 UTC 2014 is 1398810655 seconds since the Unix Epoch.
|
|
EXPECT_EQ("4/29/2014 22:30:55 GMT",
|
|
BoxedValue(new Time(Time::FromTimeT(1398810655))).ToString());
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, TimeDeltaToString) {
|
|
// 12345 seconds is 3 hours, 25 minutes and 45 seconds.
|
|
EXPECT_EQ(
|
|
"3h25m45s",
|
|
BoxedValue(new TimeDelta(TimeDelta::FromSeconds(12345))).ToString());
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, ConnectionTypeToString) {
|
|
EXPECT_EQ(
|
|
"Disconnected",
|
|
BoxedValue(new ConnectionType(ConnectionType::kDisconnected)).ToString());
|
|
EXPECT_EQ(
|
|
"ethernet",
|
|
BoxedValue(new ConnectionType(ConnectionType::kEthernet)).ToString());
|
|
EXPECT_EQ("wifi",
|
|
BoxedValue(new ConnectionType(ConnectionType::kWifi)).ToString());
|
|
EXPECT_EQ(
|
|
"cellular",
|
|
BoxedValue(new ConnectionType(ConnectionType::kCellular)).ToString());
|
|
EXPECT_EQ(
|
|
"Unknown",
|
|
BoxedValue(new ConnectionType(ConnectionType::kUnknown)).ToString());
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, ConnectionTetheringToString) {
|
|
EXPECT_EQ(
|
|
"Not Detected",
|
|
BoxedValue(new ConnectionTethering(ConnectionTethering::kNotDetected))
|
|
.ToString());
|
|
EXPECT_EQ("Suspected",
|
|
BoxedValue(new ConnectionTethering(ConnectionTethering::kSuspected))
|
|
.ToString());
|
|
EXPECT_EQ("Confirmed",
|
|
BoxedValue(new ConnectionTethering(ConnectionTethering::kConfirmed))
|
|
.ToString());
|
|
EXPECT_EQ("Unknown",
|
|
BoxedValue(new ConnectionTethering(ConnectionTethering::kUnknown))
|
|
.ToString());
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, RollbackToTargetVersionToString) {
|
|
EXPECT_EQ("Unspecified",
|
|
BoxedValue(new RollbackToTargetVersion(
|
|
RollbackToTargetVersion::kUnspecified))
|
|
.ToString());
|
|
EXPECT_EQ("Disabled",
|
|
BoxedValue(
|
|
new RollbackToTargetVersion(RollbackToTargetVersion::kDisabled))
|
|
.ToString());
|
|
EXPECT_EQ("Rollback and powerwash",
|
|
BoxedValue(new RollbackToTargetVersion(
|
|
RollbackToTargetVersion::kRollbackAndPowerwash))
|
|
.ToString());
|
|
EXPECT_EQ(
|
|
"Rollback and restore if possible",
|
|
BoxedValue(new RollbackToTargetVersion(
|
|
RollbackToTargetVersion::kRollbackAndRestoreIfPossible))
|
|
.ToString());
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, SetConnectionTypeToString) {
|
|
set<ConnectionType>* set1 = new set<ConnectionType>;
|
|
set1->insert(ConnectionType::kCellular);
|
|
set1->insert(ConnectionType::kEthernet);
|
|
EXPECT_EQ("ethernet,cellular", BoxedValue(set1).ToString());
|
|
|
|
set<ConnectionType>* set2 = new set<ConnectionType>;
|
|
set2->insert(ConnectionType::kWifi);
|
|
EXPECT_EQ("wifi", BoxedValue(set2).ToString());
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, StageToString) {
|
|
EXPECT_EQ("Idle", BoxedValue(new Stage(Stage::kIdle)).ToString());
|
|
EXPECT_EQ("Checking For Update",
|
|
BoxedValue(new Stage(Stage::kCheckingForUpdate)).ToString());
|
|
EXPECT_EQ("Update Available",
|
|
BoxedValue(new Stage(Stage::kUpdateAvailable)).ToString());
|
|
EXPECT_EQ("Downloading",
|
|
BoxedValue(new Stage(Stage::kDownloading)).ToString());
|
|
EXPECT_EQ("Verifying", BoxedValue(new Stage(Stage::kVerifying)).ToString());
|
|
EXPECT_EQ("Finalizing", BoxedValue(new Stage(Stage::kFinalizing)).ToString());
|
|
EXPECT_EQ("Updated, Need Reboot",
|
|
BoxedValue(new Stage(Stage::kUpdatedNeedReboot)).ToString());
|
|
EXPECT_EQ("Reporting Error Event",
|
|
BoxedValue(new Stage(Stage::kReportingErrorEvent)).ToString());
|
|
EXPECT_EQ("Attempting Rollback",
|
|
BoxedValue(new Stage(Stage::kAttemptingRollback)).ToString());
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, DeleterMarkerToString) {
|
|
bool marker = false;
|
|
BoxedValue value = BoxedValue(new DeleterMarker(&marker));
|
|
EXPECT_EQ("DeleterMarker:false", value.ToString());
|
|
marker = true;
|
|
EXPECT_EQ("DeleterMarker:true", value.ToString());
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, UpdateRestrictionsToString) {
|
|
EXPECT_EQ(
|
|
"None",
|
|
BoxedValue(new UpdateRestrictions(UpdateRestrictions::kNone)).ToString());
|
|
EXPECT_EQ("Flags: RestrictDownloading",
|
|
BoxedValue(new UpdateRestrictions(
|
|
UpdateRestrictions::kRestrictDownloading))
|
|
.ToString());
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, WeeklyTimeIntervalToString) {
|
|
EXPECT_EQ("Start: day_of_week=2 time=100\nEnd: day_of_week=4 time=200",
|
|
BoxedValue(new WeeklyTimeInterval(
|
|
WeeklyTime(2, TimeDelta::FromMinutes(100)),
|
|
WeeklyTime(4, TimeDelta::FromMinutes(200))))
|
|
.ToString());
|
|
EXPECT_EQ("Start: day_of_week=1 time=10\nEnd: day_of_week=1 time=20",
|
|
BoxedValue(new WeeklyTimeInterval(
|
|
WeeklyTime(1, TimeDelta::FromMinutes(10)),
|
|
WeeklyTime(1, TimeDelta::FromMinutes(20))))
|
|
.ToString());
|
|
}
|
|
|
|
TEST(UmBoxedValueTest, WeeklyTimeIntervalVectorToString) {
|
|
WeeklyTimeIntervalVector intervals;
|
|
intervals.emplace_back(WeeklyTime(5, TimeDelta::FromMinutes(10)),
|
|
WeeklyTime(1, TimeDelta::FromMinutes(30)));
|
|
EXPECT_EQ(
|
|
"Disallowed intervals:\nStart: day_of_week=5 time=10\nEnd: "
|
|
"day_of_week=1 time=30\n",
|
|
BoxedValue(new WeeklyTimeIntervalVector(intervals)).ToString());
|
|
intervals.emplace_back(WeeklyTime(1, TimeDelta::FromMinutes(5)),
|
|
WeeklyTime(6, TimeDelta::FromMinutes(1000)));
|
|
EXPECT_EQ(
|
|
"Disallowed intervals:\nStart: day_of_week=5 time=10\nEnd: "
|
|
"day_of_week=1 time=30\nStart: day_of_week=1 time=5\nEnd: day_of_week=6 "
|
|
"time=1000\n",
|
|
BoxedValue(new WeeklyTimeIntervalVector(intervals)).ToString());
|
|
}
|
|
|
|
} // namespace chromeos_update_manager
|