Build unittests in Brillo.
Many unittests do not pass for simple reasons that will be addressed
later. This CL includes all the changes to make the unittests build.
In particular, the generated DBus mocks, required to build several
unittests are now included here.
The dbus-constants.h files were moved to the system_api repo, so they
can be removed from here.
The unittest build is only enabled for Brillo targets, since non-Brillo
targets don't even build DBus.
Bug: 26955860
TEST=`mmma` on edison-eng (and aosp_arm-eng).
Change-Id: Ib38241f0a6eb99b1d60d72db6bcfd125d38e3fad
diff --git a/Android.mk b/Android.mk
index 9dbab17..8d453aa 100644
--- a/Android.mk
+++ b/Android.mk
@@ -682,6 +682,138 @@
LOCAL_SRC_FILES := $(ue_delta_generator_src_files)
include $(BUILD_EXECUTABLE)
+# TODO(deymo): Enable the unittest binaries in non-Brillo builds once the DBus
+# dependencies are removed or placed behind the USE_DBUS flag.
+ifdef BRILLO
+
+# test_http_server (type: executable)
+# ========================================================
+# Test HTTP Server.
+include $(CLEAR_VARS)
+LOCAL_MODULE := test_http_server
+ifdef BRILLO
+ LOCAL_MODULE_TAGS := eng
+endif
+LOCAL_MODULE_CLASS := EXECUTABLES
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CLANG := true
+LOCAL_CFLAGS := $(ue_common_cflags)
+LOCAL_CPPFLAGS := $(ue_common_cppflags)
+LOCAL_LDFLAGS := $(ue_common_ldflags)
+LOCAL_C_INCLUDES := $(ue_common_c_includes)
+LOCAL_SHARED_LIBRARIES := $(ue_common_shared_libraries)
+LOCAL_SRC_FILES := \
+ common/http_common.cc \
+ test_http_server.cc
+include $(BUILD_NATIVE_TEST)
+
+# update_engine_unittests (type: executable)
+# ========================================================
+# Main unittest file.
+include $(CLEAR_VARS)
+LOCAL_MODULE := update_engine_unittests
+ifdef BRILLO
+ LOCAL_MODULE_TAGS := eng
+endif
+LOCAL_MODULE_CLASS := EXECUTABLES
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CLANG := true
+LOCAL_CFLAGS := $(ue_common_cflags)
+LOCAL_CPPFLAGS := $(ue_common_cppflags)
+LOCAL_LDFLAGS := $(ue_common_ldflags)
+LOCAL_C_INCLUDES := \
+ $(ue_common_c_includes) \
+ $(ue_libupdate_engine_exported_c_includes)
+LOCAL_STATIC_LIBRARIES := \
+ libupdate_engine \
+ libpayload_generator \
+ libbrillo-test-helpers \
+ libgmock \
+ libgtest \
+ libchrome_test_helpers \
+ $(ue_libupdate_engine_exported_static_libraries:-host=) \
+ $(ue_libpayload_generator_exported_static_libraries:-host=)
+LOCAL_SHARED_LIBRARIES := \
+ $(ue_common_shared_libraries) \
+ $(ue_libupdate_engine_exported_shared_libraries:-host=) \
+ $(ue_libpayload_generator_exported_shared_libraries:-host=)
+LOCAL_SRC_FILES := \
+ common/action_pipe_unittest.cc \
+ common/action_processor_unittest.cc \
+ common/action_unittest.cc \
+ common/certificate_checker_unittest.cc \
+ common/cpu_limiter_unittest.cc \
+ common/fake_prefs.cc \
+ common/hash_calculator_unittest.cc \
+ common/http_fetcher_unittest.cc \
+ common/hwid_override_unittest.cc \
+ common/mock_http_fetcher.cc \
+ common/prefs_unittest.cc \
+ common/subprocess_unittest.cc \
+ common/terminator_unittest.cc \
+ common/test_utils.cc \
+ common/utils_unittest.cc \
+ common_service_unittest.cc \
+ connection_manager_unittest.cc \
+ fake_shill_proxy.cc \
+ fake_system_state.cc \
+ metrics_utils_unittest.cc \
+ omaha_request_action_unittest.cc \
+ omaha_request_params_unittest.cc \
+ omaha_response_handler_action_unittest.cc \
+ p2p_manager_unittest.cc \
+ payload_consumer/bzip_extent_writer_unittest.cc \
+ payload_consumer/delta_performer_integration_test.cc \
+ payload_consumer/delta_performer_unittest.cc \
+ payload_consumer/download_action_unittest.cc \
+ payload_consumer/extent_writer_unittest.cc \
+ payload_consumer/file_writer_unittest.cc \
+ payload_consumer/filesystem_verifier_action_unittest.cc \
+ payload_consumer/postinstall_runner_action_unittest.cc \
+ payload_consumer/xz_extent_writer_unittest.cc \
+ payload_generator/ab_generator_unittest.cc \
+ payload_generator/blob_file_writer_unittest.cc \
+ payload_generator/block_mapping_unittest.cc \
+ payload_generator/cycle_breaker_unittest.cc \
+ payload_generator/delta_diff_utils_unittest.cc \
+ payload_generator/ext2_filesystem_unittest.cc \
+ payload_generator/extent_ranges_unittest.cc \
+ payload_generator/extent_utils_unittest.cc \
+ payload_generator/fake_filesystem.cc \
+ payload_generator/full_update_generator_unittest.cc \
+ payload_generator/graph_utils_unittest.cc \
+ payload_generator/inplace_generator_unittest.cc \
+ payload_generator/payload_file_unittest.cc \
+ payload_generator/payload_generation_config_unittest.cc \
+ payload_generator/payload_signer_unittest.cc \
+ payload_generator/tarjan_unittest.cc \
+ payload_generator/topological_sort_unittest.cc \
+ payload_generator/zip_unittest.cc \
+ payload_state_unittest.cc \
+ update_attempter_unittest.cc \
+ update_manager/boxed_value_unittest.cc \
+ update_manager/chromeos_policy_unittest.cc \
+ update_manager/evaluation_context_unittest.cc \
+ update_manager/generic_variables_unittest.cc \
+ update_manager/prng_unittest.cc \
+ update_manager/real_config_provider_unittest.cc \
+ update_manager/real_device_policy_provider_unittest.cc \
+ update_manager/real_random_provider_unittest.cc \
+ update_manager/real_shill_provider_unittest.cc \
+ update_manager/real_system_provider_unittest.cc \
+ update_manager/real_time_provider_unittest.cc \
+ update_manager/real_updater_provider_unittest.cc \
+ update_manager/umtest_utils.cc \
+ update_manager/update_manager_unittest.cc \
+ update_manager/variable_unittest.cc \
+ testrunner.cc
+ifeq ($(local_use_libcros),1)
+LOCAL_SRC_FILES += \
+ chrome_browser_proxy_resolver_unittest.cc
+endif # local_use_libcros == 1
+include $(BUILD_NATIVE_TEST)
+endif # BRILLO
+
# Weave schema files
# ========================================================
include $(CLEAR_VARS)
diff --git a/chrome_browser_proxy_resolver_unittest.cc b/chrome_browser_proxy_resolver_unittest.cc
index 7a4de3d..bb5193e 100644
--- a/chrome_browser_proxy_resolver_unittest.cc
+++ b/chrome_browser_proxy_resolver_unittest.cc
@@ -109,14 +109,14 @@
namespace {
void CheckResponseResolved(const deque<string>& proxies,
void* /* pirv_data */) {
- EXPECT_EQ(2, proxies.size());
+ EXPECT_EQ(2U, proxies.size());
EXPECT_EQ("socks5://192.168.52.83:5555", proxies[0]);
EXPECT_EQ(kNoProxy, proxies[1]);
MessageLoop::current()->BreakLoop();
}
void CheckResponseNoReply(const deque<string>& proxies, void* /* pirv_data */) {
- EXPECT_EQ(1, proxies.size());
+ EXPECT_EQ(1U, proxies.size());
EXPECT_EQ(kNoProxy, proxies[0]);
MessageLoop::current()->BreakLoop();
}
diff --git a/common/http_common.cc b/common/http_common.cc
index 7d98889..d07ced3 100644
--- a/common/http_common.cc
+++ b/common/http_common.cc
@@ -18,6 +18,8 @@
#include "update_engine/common/http_common.h"
+#include <cstdlib>
+
#include <base/macros.h>
namespace chromeos_update_engine {
diff --git a/common/http_common.h b/common/http_common.h
index 041cad5..6d444ed 100644
--- a/common/http_common.h
+++ b/common/http_common.h
@@ -20,8 +20,6 @@
#ifndef UPDATE_ENGINE_COMMON_HTTP_COMMON_H_
#define UPDATE_ENGINE_COMMON_HTTP_COMMON_H_
-#include <cstdlib>
-
namespace chromeos_update_engine {
// Enumeration type for HTTP response codes.
diff --git a/common/http_fetcher_unittest.cc b/common/http_fetcher_unittest.cc
index 17e360e..91f85db 100644
--- a/common/http_fetcher_unittest.cc
+++ b/common/http_fetcher_unittest.cc
@@ -650,7 +650,7 @@
this->loop_.Run();
// verify the data we get back
- ASSERT_EQ(kBigLength, delegate.data.size());
+ ASSERT_EQ(kBigLength, static_cast<int>(delegate.data.size()));
for (int i = 0; i < kBigLength; i += 10) {
// Assert so that we don't flood the screen w/ EXPECT errors on failure.
ASSERT_EQ(delegate.data.substr(i, 10), "abcdefghij");
@@ -831,7 +831,7 @@
MessageLoop::current()->Run();
if (expected_successful) {
// verify the data we get back
- ASSERT_EQ(kMediumLength, delegate.data.size());
+ ASSERT_EQ(static_cast<size_t>(kMediumLength), delegate.data.size());
for (int i = 0; i < kMediumLength; i += 10) {
// Assert so that we don't flood the screen w/ EXPECT errors on failure.
ASSERT_EQ(delegate.data.substr(i, 10), "abcdefghij");
@@ -929,7 +929,7 @@
delegate.fetcher_.reset(fetcher_in);
MultiRangeHttpFetcher* multi_fetcher =
- dynamic_cast<MultiRangeHttpFetcher*>(fetcher_in);
+ static_cast<MultiRangeHttpFetcher*>(fetcher_in);
ASSERT_TRUE(multi_fetcher);
multi_fetcher->ClearRanges();
for (vector<pair<off_t, off_t>>::const_iterator it = ranges.begin(),
diff --git a/common/hwid_override_unittest.cc b/common/hwid_override_unittest.cc
index fff64bc..26ef30a 100644
--- a/common/hwid_override_unittest.cc
+++ b/common/hwid_override_unittest.cc
@@ -48,7 +48,7 @@
keyval += ("=" + expected_hwid);
ASSERT_EQ(base::WriteFile(tempdir_.path().Append("etc/lsb-release"),
keyval.c_str(), keyval.length()),
- keyval.length());
+ static_cast<int>(keyval.length()));
EXPECT_EQ(expected_hwid, HwidOverride::Read(tempdir_.path()));
}
@@ -56,7 +56,7 @@
std::string keyval("SOMETHING_ELSE=UNINTERESTING");
ASSERT_EQ(base::WriteFile(tempdir_.path().Append("etc/lsb-release"),
keyval.c_str(), keyval.length()),
- keyval.length());
+ static_cast<int>(keyval.length()));
EXPECT_EQ(std::string(), HwidOverride::Read(tempdir_.path()));
}
diff --git a/common/prefs_unittest.cc b/common/prefs_unittest.cc
index 967c411..d94623a 100644
--- a/common/prefs_unittest.cc
+++ b/common/prefs_unittest.cc
@@ -144,18 +144,18 @@
TEST_F(PrefsTest, GetInt64Max) {
ASSERT_TRUE(SetValue(kKey, base::StringPrintf(
- "%" PRIi64, std::numeric_limits<uint64_t>::max())));
+ "%" PRIi64, std::numeric_limits<int64_t>::max())));
int64_t value;
EXPECT_TRUE(prefs_.GetInt64(kKey, &value));
- EXPECT_EQ(std::numeric_limits<uint64_t>::max(), value);
+ EXPECT_EQ(std::numeric_limits<int64_t>::max(), value);
}
TEST_F(PrefsTest, GetInt64Min) {
ASSERT_TRUE(SetValue(kKey, base::StringPrintf(
- "%" PRIi64, std::numeric_limits<uint64_t>::min())));
+ "%" PRIi64, std::numeric_limits<int64_t>::min())));
int64_t value;
EXPECT_TRUE(prefs_.GetInt64(kKey, &value));
- EXPECT_EQ(std::numeric_limits<uint64_t>::min(), value);
+ EXPECT_EQ(std::numeric_limits<int64_t>::min(), value);
}
TEST_F(PrefsTest, GetInt64Negative) {
diff --git a/common/subprocess_unittest.cc b/common/subprocess_unittest.cc
index b37dc91..467fca8 100644
--- a/common/subprocess_unittest.cc
+++ b/common/subprocess_unittest.cc
@@ -179,7 +179,7 @@
cmd.push_back("./test_http_server");
cmd.push_back(temp_file_name);
uint32_t tag = Subprocess::Get().Exec(cmd, base::Bind(&CallbackBad));
- EXPECT_NE(0, tag);
+ EXPECT_NE(0U, tag);
*spawned = true;
printf("test http server spawned\n");
// Wait for server to be up and running
diff --git a/common/utils_unittest.cc b/common/utils_unittest.cc
index fde89e8..6c4e5af 100644
--- a/common/utils_unittest.cc
+++ b/common/utils_unittest.cc
@@ -181,11 +181,11 @@
}
TEST(UtilsTest, FuzzIntTest) {
- static const unsigned int kRanges[] = { 0, 1, 2, 20 };
- for (unsigned int range : kRanges) {
+ static const uint32_t kRanges[] = { 0, 1, 2, 20 };
+ for (uint32_t range : kRanges) {
const int kValue = 50;
for (int tries = 0; tries < 100; ++tries) {
- int value = utils::FuzzInt(kValue, range);
+ uint32_t value = utils::FuzzInt(kValue, range);
EXPECT_GE(value, kValue - range / 2);
EXPECT_LE(value, kValue + range - range / 2);
}
@@ -493,7 +493,7 @@
EXPECT_TRUE(store.LoadFromString("PAYLOAD_MINOR_VERSION=123\n"));
EXPECT_TRUE(utils::GetMinorVersion(store, &minor_version));
- EXPECT_EQ(minor_version, 123);
+ EXPECT_EQ(123U, minor_version);
}
static bool BoolMacroTestHelper() {
diff --git a/include/debugd/dbus-constants.h b/include/debugd/dbus-constants.h
deleted file mode 100644
index 3427a99..0000000
--- a/include/debugd/dbus-constants.h
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2015 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef SYSTEM_API_DBUS_DEBUGD_DBUS_CONSTANTS_H_
-#define SYSTEM_API_DBUS_DEBUGD_DBUS_CONSTANTS_H_
-
-namespace debugd {
-const char kDebugdInterface[] = "org.chromium.debugd";
-const char kDebugdServicePath[] = "/org/chromium/debugd";
-const char kDebugdServiceName[] = "org.chromium.debugd";
-
-// Methods.
-const char kDumpDebugLogs[] = "DumpDebugLogs";
-const char kGetDebugLogs[] = "GetDebugLogs";
-const char kGetInterfaces[] = "GetInterfaces";
-const char kGetModemStatus[] = "GetModemStatus";
-const char kGetNetworkStatus[] = "GetNetworkStatus";
-const char kGetPerfOutput[] = "GetPerfOutput";
-const char kGetRandomPerfOutput[] = "GetRandomPerfOutput";
-const char kGetRichPerfData[] = "GetRichPerfData";
-const char kGetRoutes[] = "GetRoutes";
-const char kGetWiMaxStatus[] = "GetWiMaxStatus";
-const char kSetDebugMode[] = "SetDebugMode";
-const char kSystraceStart[] = "SystraceStart";
-const char kSystraceStop[] = "SystraceStop";
-const char kSystraceStatus[] = "SystraceStatus";
-const char kGetLog[] = "GetLog";
-const char kGetAllLogs[] = "GetAllLogs";
-const char kGetUserLogFiles[] = "GetUserLogFiles";
-const char kGetFeedbackLogs[] = "GetFeedbackLogs";
-const char kTestICMP[] = "TestICMP";
-const char kTestICMPWithOptions[] = "TestICMPWithOptions";
-const char kLogKernelTaskStates[] = "LogKernelTaskStates";
-const char kUploadCrashes[] = "UploadCrashes";
-const char kRemoveRootfsVerification[] = "RemoveRootfsVerification";
-const char kEnableChromeRemoteDebugging[] = "EnableChromeRemoteDebugging";
-const char kEnableBootFromUsb[] = "EnableBootFromUsb";
-const char kConfigureSshServer[] = "ConfigureSshServer";
-const char kSetUserPassword[] = "SetUserPassword";
-const char kEnableChromeDevFeatures[] = "EnableChromeDevFeatures";
-const char kQueryDevFeatures[] = "QueryDevFeatures";
-
-// Values.
-enum DevFeatureFlag {
- DEV_FEATURES_DISABLED = 1 << 0,
- DEV_FEATURE_ROOTFS_VERIFICATION_REMOVED = 1 << 1,
- DEV_FEATURE_BOOT_FROM_USB_ENABLED = 1 << 2,
- DEV_FEATURE_SSH_SERVER_CONFIGURED = 1 << 3,
- DEV_FEATURE_DEV_MODE_ROOT_PASSWORD_SET = 1 << 4,
- DEV_FEATURE_SYSTEM_ROOT_PASSWORD_SET = 1 << 5,
- DEV_FEATURE_CHROME_REMOTE_DEBUGGING_ENABLED = 1 << 6,
-};
-} // namespace debugd
-
-#endif // SYSTEM_API_DBUS_DEBUGD_DBUS_CONSTANTS_H_
diff --git a/include/libcros/dbus-proxy-mocks.h b/include/libcros/dbus-proxy-mocks.h
new file mode 100644
index 0000000..97f614f
--- /dev/null
+++ b/include/libcros/dbus-proxy-mocks.h
@@ -0,0 +1,69 @@
+// Automatic generation of D-Bus interface mock proxies for:
+// - org.chromium.LibCrosServiceInterface
+// - org.chromium.UpdateEngineLibcrosProxyResolvedInterface
+#ifndef ____CHROMEOS_DBUS_BINDING___UPDATE_ENGINE_INCLUDE_LIBCROS_DBUS_PROXY_MOCKS_H
+#define ____CHROMEOS_DBUS_BINDING___UPDATE_ENGINE_INCLUDE_LIBCROS_DBUS_PROXY_MOCKS_H
+#include <string>
+#include <vector>
+
+#include <base/callback_forward.h>
+#include <base/logging.h>
+#include <base/macros.h>
+#include <brillo/any.h>
+#include <brillo/errors/error.h>
+#include <brillo/variant_dictionary.h>
+#include <gmock/gmock.h>
+
+#include "libcros/dbus-proxies.h"
+
+namespace org {
+namespace chromium {
+
+// Mock object for LibCrosServiceInterfaceProxyInterface.
+class LibCrosServiceInterfaceProxyMock : public LibCrosServiceInterfaceProxyInterface {
+ public:
+ LibCrosServiceInterfaceProxyMock() = default;
+
+ MOCK_METHOD5(ResolveNetworkProxy,
+ bool(const std::string& /*in_source_url*/,
+ const std::string& /*in_signal_interface*/,
+ const std::string& /*in_signal_name*/,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD6(ResolveNetworkProxyAsync,
+ void(const std::string& /*in_source_url*/,
+ const std::string& /*in_signal_interface*/,
+ const std::string& /*in_signal_name*/,
+ const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_CONST_METHOD0(GetObjectPath, const dbus::ObjectPath&());
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(LibCrosServiceInterfaceProxyMock);
+};
+} // namespace chromium
+} // namespace org
+
+namespace org {
+namespace chromium {
+
+// Mock object for UpdateEngineLibcrosProxyResolvedInterfaceProxyInterface.
+class UpdateEngineLibcrosProxyResolvedInterfaceProxyMock : public UpdateEngineLibcrosProxyResolvedInterfaceProxyInterface {
+ public:
+ UpdateEngineLibcrosProxyResolvedInterfaceProxyMock() = default;
+
+ MOCK_METHOD2(RegisterProxyResolvedSignalHandler,
+ void(const base::Callback<void(const std::string&,
+ const std::string&,
+ const std::string&)>& /*signal_callback*/,
+ dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+ MOCK_CONST_METHOD0(GetObjectPath, const dbus::ObjectPath&());
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(UpdateEngineLibcrosProxyResolvedInterfaceProxyMock);
+};
+} // namespace chromium
+} // namespace org
+
+#endif // ____CHROMEOS_DBUS_BINDING___UPDATE_ENGINE_INCLUDE_LIBCROS_DBUS_PROXY_MOCKS_H
diff --git a/include/power_manager/dbus-constants.h b/include/power_manager/dbus-constants.h
deleted file mode 100644
index fa42cb1..0000000
--- a/include/power_manager/dbus-constants.h
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright 2015 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef SYSTEM_API_DBUS_POWER_MANAGER_DBUS_CONSTANTS_H_
-#define SYSTEM_API_DBUS_POWER_MANAGER_DBUS_CONSTANTS_H_
-
-namespace power_manager {
-// powerd
-const char kPowerManagerInterface[] = "org.chromium.PowerManager";
-const char kPowerManagerServicePath[] = "/org/chromium/PowerManager";
-const char kPowerManagerServiceName[] = "org.chromium.PowerManager";
-// Methods exposed by powerd.
-const char kDecreaseScreenBrightnessMethod[] = "DecreaseScreenBrightness";
-const char kIncreaseScreenBrightnessMethod[] = "IncreaseScreenBrightness";
-const char kGetScreenBrightnessPercentMethod[] = "GetScreenBrightnessPercent";
-const char kSetScreenBrightnessPercentMethod[] = "SetScreenBrightnessPercent";
-const char kDecreaseKeyboardBrightnessMethod[] = "DecreaseKeyboardBrightness";
-const char kIncreaseKeyboardBrightnessMethod[] = "IncreaseKeyboardBrightness";
-const char kRequestRestartMethod[] = "RequestRestart";
-const char kRequestShutdownMethod[] = "RequestShutdown";
-const char kRequestSuspendMethod[] = "RequestSuspend";
-const char kGetPowerSupplyPropertiesMethod[] = "GetPowerSupplyProperties";
-const char kHandleUserActivityMethod[] = "HandleUserActivity";
-const char kHandleVideoActivityMethod[] = "HandleVideoActivity";
-const char kSetIsProjectingMethod[] = "SetIsProjecting";
-const char kSetPolicyMethod[] = "SetPolicy";
-const char kSetPowerSourceMethod[] = "SetPowerSource";
-const char kRegisterSuspendDelayMethod[] = "RegisterSuspendDelay";
-const char kUnregisterSuspendDelayMethod[] = "UnregisterSuspendDelay";
-const char kHandleSuspendReadinessMethod[] = "HandleSuspendReadiness";
-const char kRegisterDarkSuspendDelayMethod[] = "RegisterDarkSuspendDelay";
-const char kUnregisterDarkSuspendDelayMethod[] = "UnregisterDarkSuspendDelay";
-const char kHandleDarkSuspendReadinessMethod[] = "HandleDarkSuspendReadiness";
-const char kHandlePowerButtonAcknowledgmentMethod[] =
- "HandlePowerButtonAcknowledgment";
-const char kRecordDarkResumeWakeReasonMethod[] = "RecordDarkResumeWakeReason";
-// Signals emitted by powerd.
-const char kBrightnessChangedSignal[] = "BrightnessChanged";
-const char kKeyboardBrightnessChangedSignal[] = "KeyboardBrightnessChanged";
-const char kPeripheralBatteryStatusSignal[] = "PeripheralBatteryStatus";
-const char kPowerSupplyPollSignal[] = "PowerSupplyPoll";
-const char kSuspendImminentSignal[] = "SuspendImminent";
-const char kDarkSuspendImminentSignal[] = "DarkSuspendImminent";
-const char kSuspendDoneSignal[] = "SuspendDone";
-const char kInputEventSignal[] = "InputEvent";
-const char kIdleActionImminentSignal[] = "IdleActionImminent";
-const char kIdleActionDeferredSignal[] = "IdleActionDeferred";
-// Values
-const int kBrightnessTransitionGradual = 1;
-const int kBrightnessTransitionInstant = 2;
-enum UserActivityType {
- USER_ACTIVITY_OTHER = 0,
- USER_ACTIVITY_BRIGHTNESS_UP_KEY_PRESS = 1,
- USER_ACTIVITY_BRIGHTNESS_DOWN_KEY_PRESS = 2,
- USER_ACTIVITY_VOLUME_UP_KEY_PRESS = 3,
- USER_ACTIVITY_VOLUME_DOWN_KEY_PRESS = 4,
- USER_ACTIVITY_VOLUME_MUTE_KEY_PRESS = 5,
-};
-enum RequestRestartReason {
- REQUEST_RESTART_FOR_USER = 0,
- REQUEST_RESTART_FOR_UPDATE = 1,
-};
-} // namespace power_manager
-
-#endif // SYSTEM_API_DBUS_POWER_MANAGER_DBUS_CONSTANTS_H_
diff --git a/include/shill/dbus-proxy-mocks.h b/include/shill/dbus-proxy-mocks.h
new file mode 100644
index 0000000..e5d52f7
--- /dev/null
+++ b/include/shill/dbus-proxy-mocks.h
@@ -0,0 +1,549 @@
+// Automatic generation of D-Bus interface mock proxies for:
+// - org.chromium.flimflam.Manager
+// - org.chromium.flimflam.Service
+#ifndef ____CHROMEOS_DBUS_BINDING___UPDATE_ENGINE_INCLUDE_SHILL_DBUS_PROXY_MOCKS_H
+#define ____CHROMEOS_DBUS_BINDING___UPDATE_ENGINE_INCLUDE_SHILL_DBUS_PROXY_MOCKS_H
+#include <string>
+#include <vector>
+
+#include <base/callback_forward.h>
+#include <base/logging.h>
+#include <base/macros.h>
+#include <brillo/any.h>
+#include <brillo/errors/error.h>
+#include <brillo/variant_dictionary.h>
+#include <gmock/gmock.h>
+
+#include "shill/dbus-proxies.h"
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Mock object for ManagerProxyInterface.
+class ManagerProxyMock : public ManagerProxyInterface {
+ public:
+ ManagerProxyMock() = default;
+
+ MOCK_METHOD3(GetProperties,
+ bool(brillo::VariantDictionary*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(GetPropertiesAsync,
+ void(const base::Callback<void(const brillo::VariantDictionary&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(SetProperty,
+ bool(const std::string&,
+ const brillo::Any&,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD5(SetPropertyAsync,
+ void(const std::string&,
+ const brillo::Any&,
+ const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(GetState,
+ bool(std::string*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(GetStateAsync,
+ void(const base::Callback<void(const std::string&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(CreateProfile,
+ bool(const std::string&,
+ dbus::ObjectPath*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(CreateProfileAsync,
+ void(const std::string&,
+ const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(RemoveProfile,
+ bool(const std::string&,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(RemoveProfileAsync,
+ void(const std::string&,
+ const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(PushProfile,
+ bool(const std::string&,
+ dbus::ObjectPath*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(PushProfileAsync,
+ void(const std::string&,
+ const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD5(InsertUserProfile,
+ bool(const std::string&,
+ const std::string&,
+ dbus::ObjectPath*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD5(InsertUserProfileAsync,
+ void(const std::string&,
+ const std::string&,
+ const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(PopProfile,
+ bool(const std::string&,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(PopProfileAsync,
+ void(const std::string&,
+ const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD2(PopAnyProfile,
+ bool(brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(PopAnyProfileAsync,
+ void(const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD2(PopAllUserProfiles,
+ bool(brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(PopAllUserProfilesAsync,
+ void(const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD2(RecheckPortal,
+ bool(brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(RecheckPortalAsync,
+ void(const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(RequestScan,
+ bool(const std::string&,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(RequestScanAsync,
+ void(const std::string&,
+ const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(EnableTechnology,
+ bool(const std::string&,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(EnableTechnologyAsync,
+ void(const std::string&,
+ const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(DisableTechnology,
+ bool(const std::string&,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(DisableTechnologyAsync,
+ void(const std::string&,
+ const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(GetService,
+ bool(const brillo::VariantDictionary&,
+ dbus::ObjectPath*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(GetServiceAsync,
+ void(const brillo::VariantDictionary&,
+ const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(GetWifiService,
+ bool(const brillo::VariantDictionary&,
+ dbus::ObjectPath*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(GetWifiServiceAsync,
+ void(const brillo::VariantDictionary&,
+ const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(ConfigureService,
+ bool(const brillo::VariantDictionary&,
+ dbus::ObjectPath*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(ConfigureServiceAsync,
+ void(const brillo::VariantDictionary&,
+ const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD5(ConfigureServiceForProfile,
+ bool(const dbus::ObjectPath&,
+ const brillo::VariantDictionary&,
+ dbus::ObjectPath*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD5(ConfigureServiceForProfileAsync,
+ void(const dbus::ObjectPath&,
+ const brillo::VariantDictionary&,
+ const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(FindMatchingService,
+ bool(const brillo::VariantDictionary&,
+ dbus::ObjectPath*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(FindMatchingServiceAsync,
+ void(const brillo::VariantDictionary&,
+ const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(GetVPNService,
+ bool(const brillo::VariantDictionary&,
+ dbus::ObjectPath*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(GetVPNServiceAsync,
+ void(const brillo::VariantDictionary&,
+ const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(GetDebugLevel,
+ bool(int32_t*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(GetDebugLevelAsync,
+ void(const base::Callback<void(int32_t)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(SetDebugLevel,
+ bool(int32_t,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(SetDebugLevelAsync,
+ void(int32_t,
+ const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(GetServiceOrder,
+ bool(std::string*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(GetServiceOrderAsync,
+ void(const base::Callback<void(const std::string&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(SetServiceOrder,
+ bool(const std::string&,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(SetServiceOrderAsync,
+ void(const std::string&,
+ const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(GetDebugTags,
+ bool(std::string*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(GetDebugTagsAsync,
+ void(const base::Callback<void(const std::string&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(SetDebugTags,
+ bool(const std::string&,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(SetDebugTagsAsync,
+ void(const std::string&,
+ const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(ListDebugTags,
+ bool(std::string*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(ListDebugTagsAsync,
+ void(const base::Callback<void(const std::string&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(GetNetworksForGeolocation,
+ bool(brillo::VariantDictionary*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(GetNetworksForGeolocationAsync,
+ void(const base::Callback<void(const brillo::VariantDictionary&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD10(VerifyDestination,
+ bool(const std::string& /*in_certificate*/,
+ const std::string& /*in_public_key*/,
+ const std::string& /*in_nonce*/,
+ const std::string& /*in_signed_data*/,
+ const std::string& /*in_destination_udn*/,
+ const std::string& /*in_hotspot_ssid*/,
+ const std::string& /*in_hotspot_bssid*/,
+ bool*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD10(VerifyDestinationAsync,
+ void(const std::string& /*in_certificate*/,
+ const std::string& /*in_public_key*/,
+ const std::string& /*in_nonce*/,
+ const std::string& /*in_signed_data*/,
+ const std::string& /*in_destination_udn*/,
+ const std::string& /*in_hotspot_ssid*/,
+ const std::string& /*in_hotspot_bssid*/,
+ const base::Callback<void(bool)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ bool VerifyAndEncryptCredentials(const std::string& /*in_certificate*/,
+ const std::string& /*in_public_key*/,
+ const std::string& /*in_nonce*/,
+ const std::string& /*in_signed_data*/,
+ const std::string& /*in_destination_udn*/,
+ const std::string& /*in_hotspot_ssid*/,
+ const std::string& /*in_hotspot_bssid*/,
+ const dbus::ObjectPath& /*in_network*/,
+ std::string*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/) override {
+ LOG(WARNING) << "VerifyAndEncryptCredentials(): gmock can't handle methods with 11 arguments. You can override this method in a subclass if you need to.";
+ return false;
+ }
+ void VerifyAndEncryptCredentialsAsync(const std::string& /*in_certificate*/,
+ const std::string& /*in_public_key*/,
+ const std::string& /*in_nonce*/,
+ const std::string& /*in_signed_data*/,
+ const std::string& /*in_destination_udn*/,
+ const std::string& /*in_hotspot_ssid*/,
+ const std::string& /*in_hotspot_bssid*/,
+ const dbus::ObjectPath& /*in_network*/,
+ const base::Callback<void(const std::string&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/) override {
+ LOG(WARNING) << "VerifyAndEncryptCredentialsAsync(): gmock can't handle methods with 11 arguments. You can override this method in a subclass if you need to.";
+ }
+ bool VerifyAndEncryptData(const std::string& /*in_certificate*/,
+ const std::string& /*in_public_key*/,
+ const std::string& /*in_nonce*/,
+ const std::string& /*in_signed_data*/,
+ const std::string& /*in_destination_udn*/,
+ const std::string& /*in_hotspot_ssid*/,
+ const std::string& /*in_hotspot_bssid*/,
+ const std::string& /*in_data*/,
+ std::string*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/) override {
+ LOG(WARNING) << "VerifyAndEncryptData(): gmock can't handle methods with 11 arguments. You can override this method in a subclass if you need to.";
+ return false;
+ }
+ void VerifyAndEncryptDataAsync(const std::string& /*in_certificate*/,
+ const std::string& /*in_public_key*/,
+ const std::string& /*in_nonce*/,
+ const std::string& /*in_signed_data*/,
+ const std::string& /*in_destination_udn*/,
+ const std::string& /*in_hotspot_ssid*/,
+ const std::string& /*in_hotspot_bssid*/,
+ const std::string& /*in_data*/,
+ const base::Callback<void(const std::string&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/) override {
+ LOG(WARNING) << "VerifyAndEncryptDataAsync(): gmock can't handle methods with 11 arguments. You can override this method in a subclass if you need to.";
+ }
+ MOCK_METHOD2(ConnectToBestServices,
+ bool(brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(ConnectToBestServicesAsync,
+ void(const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD2(CreateConnectivityReport,
+ bool(brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(CreateConnectivityReportAsync,
+ void(const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(ClaimInterface,
+ bool(const std::string& /*in_claimer_name*/,
+ const std::string& /*in_interface_name*/,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD5(ClaimInterfaceAsync,
+ void(const std::string& /*in_claimer_name*/,
+ const std::string& /*in_interface_name*/,
+ const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(ReleaseInterface,
+ bool(const std::string& /*in_claimer_name*/,
+ const std::string& /*in_interface_name*/,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD5(ReleaseInterfaceAsync,
+ void(const std::string& /*in_claimer_name*/,
+ const std::string& /*in_interface_name*/,
+ const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(SetSchedScan,
+ bool(bool,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(SetSchedScanAsync,
+ void(bool,
+ const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(SetupApModeInterface,
+ bool(std::string* /*out_interface_name*/,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(SetupApModeInterfaceAsync,
+ void(const base::Callback<void(const std::string& /*interface_name*/)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(SetupStationModeInterface,
+ bool(std::string* /*out_interface_name*/,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(SetupStationModeInterfaceAsync,
+ void(const base::Callback<void(const std::string& /*interface_name*/)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD2(RegisterPropertyChangedSignalHandler,
+ void(const base::Callback<void(const std::string&,
+ const brillo::Any&)>& /*signal_callback*/,
+ dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+ MOCK_METHOD2(RegisterStateChangedSignalHandler,
+ void(const base::Callback<void(const std::string&)>& /*signal_callback*/,
+ dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+ MOCK_CONST_METHOD0(GetObjectPath, const dbus::ObjectPath&());
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(ManagerProxyMock);
+};
+} // namespace flimflam
+} // namespace chromium
+} // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Mock object for ServiceProxyInterface.
+class ServiceProxyMock : public ServiceProxyInterface {
+ public:
+ ServiceProxyMock() = default;
+
+ MOCK_METHOD3(GetProperties,
+ bool(brillo::VariantDictionary*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(GetPropertiesAsync,
+ void(const base::Callback<void(const brillo::VariantDictionary&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(SetProperty,
+ bool(const std::string&,
+ const brillo::Any&,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD5(SetPropertyAsync,
+ void(const std::string&,
+ const brillo::Any&,
+ const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(SetProperties,
+ bool(const brillo::VariantDictionary&,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(SetPropertiesAsync,
+ void(const brillo::VariantDictionary&,
+ const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(ClearProperty,
+ bool(const std::string&,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(ClearPropertyAsync,
+ void(const std::string&,
+ const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(ClearProperties,
+ bool(const std::vector<std::string>&,
+ std::vector<bool>*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(ClearPropertiesAsync,
+ void(const std::vector<std::string>&,
+ const base::Callback<void(const std::vector<bool>&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD2(Connect,
+ bool(brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(ConnectAsync,
+ void(const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD2(Disconnect,
+ bool(brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(DisconnectAsync,
+ void(const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD2(Remove,
+ bool(brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(RemoveAsync,
+ void(const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(ActivateCellularModem,
+ bool(const std::string&,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD4(ActivateCellularModemAsync,
+ void(const std::string&,
+ const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD2(CompleteCellularActivation,
+ bool(brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(CompleteCellularActivationAsync,
+ void(const base::Callback<void()>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(GetLoadableProfileEntries,
+ bool(std::map<dbus::ObjectPath, std::string>*,
+ brillo::ErrorPtr* /*error*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD3(GetLoadableProfileEntriesAsync,
+ void(const base::Callback<void(const std::map<dbus::ObjectPath, std::string>&)>& /*success_callback*/,
+ const base::Callback<void(brillo::Error*)>& /*error_callback*/,
+ int /*timeout_ms*/));
+ MOCK_METHOD2(RegisterPropertyChangedSignalHandler,
+ void(const base::Callback<void(const std::string&,
+ const brillo::Any&)>& /*signal_callback*/,
+ dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+ MOCK_CONST_METHOD0(GetObjectPath, const dbus::ObjectPath&());
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(ServiceProxyMock);
+};
+} // namespace flimflam
+} // namespace chromium
+} // namespace org
+
+#endif // ____CHROMEOS_DBUS_BINDING___UPDATE_ENGINE_INCLUDE_SHILL_DBUS_PROXY_MOCKS_H
diff --git a/include/update_engine/dbus-constants.h b/include/update_engine/dbus-constants.h
deleted file mode 100644
index 94e35f1..0000000
--- a/include/update_engine/dbus-constants.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2015 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef SYSTEM_API_DBUS_UPDATE_ENGINE_DBUS_CONSTANTS_H_
-#define SYSTEM_API_DBUS_UPDATE_ENGINE_DBUS_CONSTANTS_H_
-
-namespace update_engine {
-const char kUpdateEngineInterface[] = "org.chromium.UpdateEngineInterface";
-const char kUpdateEngineServicePath[] = "/org/chromium/UpdateEngine";
-const char kUpdateEngineServiceName[] = "org.chromium.UpdateEngine";
-
-// Generic UpdateEngine D-Bus error.
-static const char* const kUpdateEngineServiceErrorFailed =
- "org.chromium.UpdateEngine.Error.Failed";
-
-// Methods.
-const char kAttemptUpdate[] = "AttemptUpdate";
-const char kGetStatus[] = "GetStatus";
-const char kRebootIfNeeded[] = "RebootIfNeeded";
-const char kSetChannel[] = "SetChannel";
-const char kGetChannel[] = "GetChannel";
-const char kAttemptRollback[] = "AttemptRollback";
-const char kCanRollback[] = "CanRollback";
-
-// Signals.
-const char kStatusUpdate[] = "StatusUpdate";
-
-// Flags used in the AttemptUpdateWithFlags() D-Bus method.
-typedef enum {
- kAttemptUpdateFlagNonInteractive = (1<<0)
-} AttemptUpdateFlags;
-
-// Operations contained in StatusUpdate signals.
-const char kUpdateStatusIdle[] = "UPDATE_STATUS_IDLE";
-const char kUpdateStatusCheckingForUpdate[] =
- "UPDATE_STATUS_CHECKING_FOR_UPDATE";
-const char kUpdateStatusUpdateAvailable[] = "UPDATE_STATUS_UPDATE_AVAILABLE";
-const char kUpdateStatusDownloading[] = "UPDATE_STATUS_DOWNLOADING";
-const char kUpdateStatusVerifying[] = "UPDATE_STATUS_VERIFYING";
-const char kUpdateStatusFinalizing[] = "UPDATE_STATUS_FINALIZING";
-const char kUpdateStatusUpdatedNeedReboot[] =
- "UPDATE_STATUS_UPDATED_NEED_REBOOT";
-const char kUpdateStatusReportingErrorEvent[] =
- "UPDATE_STATUS_REPORTING_ERROR_EVENT";
-const char kUpdateStatusAttemptingRollback[] =
- "UPDATE_STATUS_ATTEMPTING_ROLLBACK";
-const char kUpdateStatusDisabled[] = "UPDATE_STATUS_DISABLED";
-} // namespace update_engine
-
-#endif // SYSTEM_API_DBUS_UPDATE_ENGINE_DBUS_CONSTANTS_H_
diff --git a/include/update_includes.sh b/include/update_includes.sh
new file mode 100755
index 0000000..6008d59
--- /dev/null
+++ b/include/update_includes.sh
@@ -0,0 +1,79 @@
+#!/bin/bash
+
+#
+# Copyright (C) 2016 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.
+#
+
+DBUS_GENERATOR=$(which dbus-binding-generator)
+MY_DIR=$(dirname "$0")
+
+if [[ -z "${ANDROID_HOST_OUT}" ]]; then
+ echo "You must run envsetup.sh and lunch first." >&2
+ exit 1
+fi
+
+if [[ -z "${DBUS_GENERATOR}" ]]; then
+ echo "DBus bindings generator not found." >&2
+ exit 1
+fi
+
+set -e
+
+# generate <kind> <dir> <xml> [xml ...]
+# Generate a DBus proxy and/or proxy mock in the passed |dir| for the provided
+# |xml| service files.
+# The parameter |kind| determines whether it should generate the mock only
+# (mock), the proxy only (proxy) or both (both).
+generate() {
+ local kind="$1"
+ local dir="$2"
+ local xmls=("${@:3}")
+
+ mkdir -p "${MY_DIR}/${dir}"
+ local outdir=$(realpath "${MY_DIR}/${dir}")
+ local proxyh="${outdir}/dbus-proxies.h"
+ local mockh="${outdir}/dbus-proxy-mocks.h"
+
+ ${DBUS_GENERATOR} "${xmls[@]}" --mock="${mockh}" --proxy="${proxyh}"
+
+ # Fix the include path to the dbus-proxies.h to include ${dir}.
+ sed "s,include \"dbus-proxies.h\",include \"${dir}/dbus-proxies.h\"," \
+ -i "${mockh}"
+
+ # Fix the header guards to be independent from the checkout location.
+ local guard=$(realpath "${MY_DIR}/../.." | tr '[:lower:]/ ' '[:upper:]__')
+ for header in "${mockh}" "${proxyh}"; do
+ sed "s,___CHROMEOS_DBUS_BINDING__${guard},___CHROMEOS_DBUS_BINDING__," \
+ -i "${header}"
+ done
+
+ # Remove the files not requested.
+ if [[ "${kind}" == "mock" ]]; then
+ rm -f "${proxyh}"
+ elif [[ "${kind}" == "proxy" ]]; then
+ rm -f "${mockh}"
+ fi
+}
+
+UE_DIR=$(realpath "${MY_DIR}/..")
+SHILL_DIR=$(realpath "${UE_DIR}/../connectivity/shill")
+
+generate mock "libcros" \
+ "${UE_DIR}/dbus_bindings/org.chromium.LibCrosService.dbus-xml"
+
+generate mock "shill" \
+ "${SHILL_DIR}"/dbus_bindings/org.chromium.flimflam.{Manager,Service}.dbus-xml
+
+echo "Done."
diff --git a/omaha_request_action_unittest.cc b/omaha_request_action_unittest.cc
index 81a7378..3f455f3 100644
--- a/omaha_request_action_unittest.cc
+++ b/omaha_request_action_unittest.cc
@@ -1524,7 +1524,7 @@
metrics::DownloadErrorCode::kUnset,
nullptr,
&post_data));
- EXPECT_EQ(post_data.size(), 0);
+ EXPECT_EQ(0U, post_data.size());
}
TEST_F(OmahaRequestActionTest, BackInTimePingTest) {
diff --git a/omaha_response_handler_action_unittest.cc b/omaha_response_handler_action_unittest.cc
index b996d38..4917162 100644
--- a/omaha_response_handler_action_unittest.cc
+++ b/omaha_response_handler_action_unittest.cc
@@ -154,14 +154,15 @@
EXPECT_TRUE(DoTest(in, test_deadline_file, &install_plan));
EXPECT_EQ(in.payload_urls[0], install_plan.download_url);
EXPECT_EQ(in.hash, install_plan.payload_hash);
- EXPECT_EQ(1, install_plan.target_slot);
+ EXPECT_EQ(1U, install_plan.target_slot);
string deadline;
EXPECT_TRUE(utils::ReadFile(test_deadline_file, &deadline));
EXPECT_EQ("20101020", deadline);
struct stat deadline_stat;
EXPECT_EQ(0, stat(test_deadline_file.c_str(), &deadline_stat));
- EXPECT_EQ(S_IFREG | S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH,
- deadline_stat.st_mode);
+ EXPECT_EQ(
+ static_cast<mode_t>(S_IFREG | S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH),
+ deadline_stat.st_mode);
EXPECT_EQ(in.version, install_plan.version);
}
{
@@ -179,7 +180,7 @@
EXPECT_TRUE(DoTest(in, test_deadline_file, &install_plan));
EXPECT_EQ(in.payload_urls[0], install_plan.download_url);
EXPECT_EQ(in.hash, install_plan.payload_hash);
- EXPECT_EQ(0, install_plan.target_slot);
+ EXPECT_EQ(0U, install_plan.target_slot);
string deadline;
EXPECT_TRUE(utils::ReadFile(test_deadline_file, &deadline) &&
deadline.empty());
@@ -200,7 +201,7 @@
EXPECT_TRUE(DoTest(in, test_deadline_file, &install_plan));
EXPECT_EQ(in.payload_urls[0], install_plan.download_url);
EXPECT_EQ(in.hash, install_plan.payload_hash);
- EXPECT_EQ(1, install_plan.target_slot);
+ EXPECT_EQ(1U, install_plan.target_slot);
string deadline;
EXPECT_TRUE(utils::ReadFile(test_deadline_file, &deadline));
EXPECT_EQ("some-deadline", deadline);
diff --git a/payload_consumer/delta_performer_integration_test.cc b/payload_consumer/delta_performer_integration_test.cc
index 9b7854b..f0aea95 100644
--- a/payload_consumer/delta_performer_integration_test.cc
+++ b/payload_consumer/delta_performer_integration_test.cc
@@ -58,7 +58,7 @@
extern const char* kUnittestPrivateKey2Path;
extern const char* kUnittestPublicKey2Path;
-static const int kDefaultKernelSize = 4096; // Something small for a test
+static const uint32_t kDefaultKernelSize = 4096; // Something small for a test
static const uint8_t kNewData[] = {'T', 'h', 'i', 's', ' ', 'i', 's', ' ',
'n', 'e', 'w', ' ', 'd', 'a', 't', 'a', '.'};
@@ -124,7 +124,7 @@
static void CompareFilesByBlock(const string& a_file, const string& b_file,
size_t image_size) {
- EXPECT_EQ(0, image_size % kBlockSize);
+ EXPECT_EQ(0U, image_size % kBlockSize);
brillo::Blob a_data, b_data;
EXPECT_TRUE(utils::ReadFile(a_file, &a_data)) << "file failed: " << a_file;
@@ -133,7 +133,7 @@
EXPECT_GE(a_data.size(), image_size);
EXPECT_GE(b_data.size(), image_size);
for (size_t i = 0; i < image_size; i += kBlockSize) {
- EXPECT_EQ(0, i % kBlockSize);
+ EXPECT_EQ(0U, i % kBlockSize);
brillo::Blob a_sub(&a_data[i], &a_data[i + kBlockSize]);
brillo::Blob b_sub(&b_data[i], &b_data[i + kBlockSize]);
EXPECT_TRUE(a_sub == b_sub) << "Block " << (i/kBlockSize) << " differs";
@@ -350,7 +350,7 @@
hardtocompress.size()));
brillo::Blob zeros(16 * 1024, 0);
- EXPECT_EQ(zeros.size(),
+ EXPECT_EQ(static_cast<int>(zeros.size()),
base::WriteFile(base::FilePath(base::StringPrintf(
"%s/move-to-sparse", a_mnt.c_str())),
reinterpret_cast<const char*>(zeros.data()),
@@ -416,7 +416,7 @@
16 * 1024));
brillo::Blob zeros(16 * 1024, 0);
- EXPECT_EQ(zeros.size(),
+ EXPECT_EQ(static_cast<int>(zeros.size()),
base::WriteFile(base::FilePath(base::StringPrintf(
"%s/move-from-sparse", b_mnt.c_str())),
reinterpret_cast<const char*>(zeros.data()),
@@ -614,7 +614,7 @@
else
EXPECT_EQ(1, sigs_message.signatures_size());
const Signatures_Signature& signature = sigs_message.signatures(0);
- EXPECT_EQ(1, signature.version());
+ EXPECT_EQ(1U, signature.version());
uint64_t expected_sig_data_length = 0;
vector<string> key_paths{kUnittestPrivateKeyPath};
@@ -880,7 +880,7 @@
updated_kernel_partition.begin()));
const auto& partitions = state->install_plan.partitions;
- EXPECT_EQ(2, partitions.size());
+ EXPECT_EQ(2U, partitions.size());
EXPECT_EQ(kLegacyPartitionNameRoot, partitions[0].name);
EXPECT_EQ(kLegacyPartitionNameKernel, partitions[1].name);
diff --git a/payload_consumer/delta_performer_unittest.cc b/payload_consumer/delta_performer_unittest.cc
index dabe138..98a378b 100644
--- a/payload_consumer/delta_performer_unittest.cc
+++ b/payload_consumer/delta_performer_unittest.cc
@@ -16,6 +16,7 @@
#include "update_engine/payload_consumer/delta_performer.h"
+#include <endian.h>
#include <inttypes.h>
#include <string>
@@ -649,7 +650,7 @@
EXPECT_EQ(kBrilloMajorPayloadVersion, performer_.GetMajorVersion());
uint64_t manifest_offset;
EXPECT_TRUE(performer_.GetManifestOffset(&manifest_offset));
- EXPECT_EQ(24, manifest_offset); // 4 + 8 + 8 + 4
+ EXPECT_EQ(24U, manifest_offset); // 4 + 8 + 8 + 4
EXPECT_EQ(manifest_offset + manifest_size, performer_.GetMetadataSize());
EXPECT_EQ(metadata_signature_size, performer_.metadata_signature_size_);
}
diff --git a/payload_consumer/download_action_unittest.cc b/payload_consumer/download_action_unittest.cc
index 979776f..51d3c3a 100644
--- a/payload_consumer/download_action_unittest.cc
+++ b/payload_consumer/download_action_unittest.cc
@@ -532,8 +532,10 @@
// Check the p2p file and its content matches what was sent.
string file_id = download_action_->p2p_file_id();
EXPECT_NE("", file_id);
- EXPECT_EQ(data_.length(), p2p_manager_->FileGetSize(file_id));
- EXPECT_EQ(data_.length(), p2p_manager_->FileGetExpectedSize(file_id));
+ EXPECT_EQ(static_cast<int>(data_.length()),
+ p2p_manager_->FileGetSize(file_id));
+ EXPECT_EQ(static_cast<int>(data_.length()),
+ p2p_manager_->FileGetExpectedSize(file_id));
string p2p_file_contents;
EXPECT_TRUE(ReadFileToString(p2p_manager_->FileGetPath(file_id),
&p2p_file_contents));
@@ -580,8 +582,10 @@
// DownloadAction should convey the same file_id and the file should
// have the expected size.
EXPECT_EQ(download_action_->p2p_file_id(), file_id);
- EXPECT_EQ(p2p_manager_->FileGetSize(file_id), data_.length());
- EXPECT_EQ(p2p_manager_->FileGetExpectedSize(file_id), data_.length());
+ EXPECT_EQ(static_cast<ssize_t>(data_.length()),
+ p2p_manager_->FileGetSize(file_id));
+ EXPECT_EQ(static_cast<ssize_t>(data_.length()),
+ p2p_manager_->FileGetExpectedSize(file_id));
string p2p_file_contents;
// Check that the first 1000 bytes wasn't touched and that we
// appended the remaining as appropriate.
@@ -611,14 +615,14 @@
1000), 1000);
// Check that the file is there.
- EXPECT_EQ(p2p_manager_->FileGetSize(file_id), 1000);
- EXPECT_EQ(p2p_manager_->CountSharedFiles(), 1);
+ EXPECT_EQ(1000, p2p_manager_->FileGetSize(file_id));
+ EXPECT_EQ(1, p2p_manager_->CountSharedFiles());
StartDownload(false); // use_p2p_to_share
// DownloadAction should have deleted the p2p file. Check that it's gone.
- EXPECT_EQ(p2p_manager_->FileGetSize(file_id), -1);
- EXPECT_EQ(p2p_manager_->CountSharedFiles(), 0);
+ EXPECT_EQ(-1, p2p_manager_->FileGetSize(file_id));
+ EXPECT_EQ(0, p2p_manager_->CountSharedFiles());
}
} // namespace chromeos_update_engine
diff --git a/payload_consumer/filesystem_verifier_action_unittest.cc b/payload_consumer/filesystem_verifier_action_unittest.cc
index 10daaa8..cdf7fc0 100644
--- a/payload_consumer/filesystem_verifier_action_unittest.cc
+++ b/payload_consumer/filesystem_verifier_action_unittest.cc
@@ -120,7 +120,7 @@
// failures and whether or not they are due to the test setup or an inherent
// issue with the chroot environment, library versions we use, etc.
TEST_F(FilesystemVerifierActionTest, DISABLED_RunAsRootSimpleTest) {
- ASSERT_EQ(0, getuid());
+ ASSERT_EQ(0U, getuid());
bool test = DoTest(false, false, VerifierMode::kComputeSourceHash);
EXPECT_TRUE(test);
if (!test)
@@ -309,18 +309,18 @@
}
TEST_F(FilesystemVerifierActionTest, RunAsRootVerifyHashTest) {
- ASSERT_EQ(0, getuid());
+ ASSERT_EQ(0U, getuid());
EXPECT_TRUE(DoTest(false, false, VerifierMode::kVerifyTargetHash));
EXPECT_TRUE(DoTest(false, false, VerifierMode::kComputeSourceHash));
}
TEST_F(FilesystemVerifierActionTest, RunAsRootVerifyHashFailTest) {
- ASSERT_EQ(0, getuid());
+ ASSERT_EQ(0U, getuid());
EXPECT_TRUE(DoTest(false, true, VerifierMode::kVerifyTargetHash));
}
TEST_F(FilesystemVerifierActionTest, RunAsRootTerminateEarlyTest) {
- ASSERT_EQ(0, getuid());
+ ASSERT_EQ(0U, getuid());
EXPECT_TRUE(DoTest(true, false, VerifierMode::kVerifyTargetHash));
// TerminateEarlyTest may leak some null callbacks from the Stream class.
while (loop_.RunOnce(false)) {}
@@ -366,13 +366,13 @@
loop_.Run();
install_plan = collector_action.object();
- ASSERT_EQ(2, install_plan.partitions.size());
+ ASSERT_EQ(2U, install_plan.partitions.size());
// When computing the size of the rootfs on legacy delta updates we use the
// size of the filesystem, but when updating the kernel we use the whole
// partition.
- EXPECT_EQ(10 * 1024 * 1024, install_plan.partitions[0].source_size);
+ EXPECT_EQ(10U << 20, install_plan.partitions[0].source_size);
EXPECT_EQ(kLegacyPartitionNameRoot, install_plan.partitions[0].name);
- EXPECT_EQ(20 * 1024 * 1024, install_plan.partitions[1].source_size);
+ EXPECT_EQ(20U << 20, install_plan.partitions[1].source_size);
EXPECT_EQ(kLegacyPartitionNameKernel, install_plan.partitions[1].name);
}
diff --git a/payload_consumer/postinstall_runner_action_unittest.cc b/payload_consumer/postinstall_runner_action_unittest.cc
index beed4f1..c4c68b1 100644
--- a/payload_consumer/postinstall_runner_action_unittest.cc
+++ b/payload_consumer/postinstall_runner_action_unittest.cc
@@ -121,8 +121,8 @@
bool do_losetup,
int err_code,
bool powerwash_required) {
- ASSERT_EQ(0, getuid()) << "Run me as root. Ideally don't run other tests "
- << "as root, tho.";
+ ASSERT_EQ(0U, getuid()) << "Run me as root. Ideally don't run other tests "
+ << "as root, tho.";
// True if the post-install action is expected to succeed.
bool should_succeed = do_losetup && !err_code;
@@ -251,7 +251,7 @@
// Death tests don't seem to be working on Hardy
TEST_F(PostinstallRunnerActionTest, DISABLED_RunAsRootDeathTest) {
- ASSERT_EQ(0, getuid());
+ ASSERT_EQ(0U, getuid());
PostinstallRunnerAction runner_action(&fake_boot_control_);
ASSERT_DEATH({ runner_action.TerminateProcessing(); },
"postinstall_runner_action.h:.*] Check failed");
diff --git a/payload_generator/ab_generator_unittest.cc b/payload_generator/ab_generator_unittest.cc
index 632fc64..b505a8f 100644
--- a/payload_generator/ab_generator_unittest.cc
+++ b/payload_generator/ab_generator_unittest.cc
@@ -21,6 +21,7 @@
#include <sys/types.h>
#include <string>
+#include <random>
#include <vector>
#include <gtest/gtest.h>
@@ -128,7 +129,7 @@
InstallOperation_Type expected_type =
compressible ? InstallOperation::REPLACE_BZ : InstallOperation::REPLACE;
- ASSERT_EQ(2, result_ops.size());
+ ASSERT_EQ(2U, result_ops.size());
EXPECT_EQ("SplitTestOp:0", result_ops[0].name);
InstallOperation first_op = result_ops[0].op;
@@ -156,7 +157,7 @@
first_op.data_length(),
first_op.data_offset(),
&bytes_read));
- ASSERT_EQ(bytes_read, first_op.data_length());
+ ASSERT_EQ(bytes_read, static_cast<ssize_t>(first_op.data_length()));
EXPECT_EQ(first_expected_blob, first_data_blob);
EXPECT_EQ("SplitTestOp:1", result_ops[1].name);
@@ -184,7 +185,7 @@
second_op.data_length(),
second_op.data_offset(),
&bytes_read));
- ASSERT_EQ(bytes_read, second_op.data_length());
+ ASSERT_EQ(bytes_read, static_cast<ssize_t>(second_op.data_length()));
EXPECT_EQ(second_expected_blob, second_data_blob);
// Check relative layout of data blobs.
@@ -193,7 +194,7 @@
EXPECT_EQ(second_op.data_offset() + second_op.data_length(), data_file_size);
// If we split a REPLACE into multiple ones, ensure reuse of preexisting blob.
if (!compressible && orig_type == InstallOperation::REPLACE) {
- EXPECT_EQ(0, first_op.data_offset());
+ EXPECT_EQ(0U, first_op.data_offset());
}
}
@@ -293,7 +294,7 @@
// Check the result.
InstallOperation_Type expected_op_type =
compressible ? InstallOperation::REPLACE_BZ : InstallOperation::REPLACE;
- EXPECT_EQ(1, aops.size());
+ EXPECT_EQ(1U, aops.size());
InstallOperation new_op = aops[0].op;
EXPECT_EQ(expected_op_type, new_op.type());
EXPECT_FALSE(new_op.has_src_length());
@@ -320,7 +321,7 @@
new_op.data_length(),
new_op.data_offset(),
&bytes_read));
- ASSERT_EQ(new_op.data_length(), bytes_read);
+ ASSERT_EQ(static_cast<ssize_t>(new_op.data_length()), bytes_read);
EXPECT_EQ(expected_blob, new_op_blob);
}
@@ -343,47 +344,47 @@
aop.name = "SplitSourceCopyTestOp";
vector<AnnotatedOperation> result_ops;
EXPECT_TRUE(ABGenerator::SplitSourceCopy(aop, &result_ops));
- EXPECT_EQ(result_ops.size(), 3);
+ EXPECT_EQ(3U, result_ops.size());
EXPECT_EQ("SplitSourceCopyTestOp:0", result_ops[0].name);
InstallOperation first_op = result_ops[0].op;
EXPECT_EQ(InstallOperation::SOURCE_COPY, first_op.type());
EXPECT_EQ(kBlockSize * 2, first_op.src_length());
EXPECT_EQ(1, first_op.src_extents().size());
- EXPECT_EQ(2, first_op.src_extents(0).start_block());
- EXPECT_EQ(2, first_op.src_extents(0).num_blocks());
+ EXPECT_EQ(2U, first_op.src_extents(0).start_block());
+ EXPECT_EQ(2U, first_op.src_extents(0).num_blocks());
EXPECT_EQ(kBlockSize * 2, first_op.dst_length());
EXPECT_EQ(1, first_op.dst_extents().size());
- EXPECT_EQ(10, first_op.dst_extents(0).start_block());
- EXPECT_EQ(2, first_op.dst_extents(0).num_blocks());
+ EXPECT_EQ(10U, first_op.dst_extents(0).start_block());
+ EXPECT_EQ(2U, first_op.dst_extents(0).num_blocks());
EXPECT_EQ("SplitSourceCopyTestOp:1", result_ops[1].name);
InstallOperation second_op = result_ops[1].op;
EXPECT_EQ(InstallOperation::SOURCE_COPY, second_op.type());
EXPECT_EQ(kBlockSize * 3, second_op.src_length());
EXPECT_EQ(3, second_op.src_extents().size());
- EXPECT_EQ(4, second_op.src_extents(0).start_block());
- EXPECT_EQ(1, second_op.src_extents(0).num_blocks());
- EXPECT_EQ(6, second_op.src_extents(1).start_block());
- EXPECT_EQ(1, second_op.src_extents(1).num_blocks());
- EXPECT_EQ(8, second_op.src_extents(2).start_block());
- EXPECT_EQ(1, second_op.src_extents(2).num_blocks());
+ EXPECT_EQ(4U, second_op.src_extents(0).start_block());
+ EXPECT_EQ(1U, second_op.src_extents(0).num_blocks());
+ EXPECT_EQ(6U, second_op.src_extents(1).start_block());
+ EXPECT_EQ(1U, second_op.src_extents(1).num_blocks());
+ EXPECT_EQ(8U, second_op.src_extents(2).start_block());
+ EXPECT_EQ(1U, second_op.src_extents(2).num_blocks());
EXPECT_EQ(kBlockSize * 3, second_op.dst_length());
EXPECT_EQ(1, second_op.dst_extents().size());
- EXPECT_EQ(14, second_op.dst_extents(0).start_block());
- EXPECT_EQ(3, second_op.dst_extents(0).num_blocks());
+ EXPECT_EQ(14U, second_op.dst_extents(0).start_block());
+ EXPECT_EQ(3U, second_op.dst_extents(0).num_blocks());
EXPECT_EQ("SplitSourceCopyTestOp:2", result_ops[2].name);
InstallOperation third_op = result_ops[2].op;
EXPECT_EQ(InstallOperation::SOURCE_COPY, third_op.type());
EXPECT_EQ(kBlockSize * 3, third_op.src_length());
EXPECT_EQ(1, third_op.src_extents().size());
- EXPECT_EQ(9, third_op.src_extents(0).start_block());
- EXPECT_EQ(3, third_op.src_extents(0).num_blocks());
+ EXPECT_EQ(9U, third_op.src_extents(0).start_block());
+ EXPECT_EQ(3U, third_op.src_extents(0).num_blocks());
EXPECT_EQ(kBlockSize * 3, third_op.dst_length());
EXPECT_EQ(1, third_op.dst_extents().size());
- EXPECT_EQ(18, third_op.dst_extents(0).start_block());
- EXPECT_EQ(3, third_op.dst_extents(0).num_blocks());
+ EXPECT_EQ(18U, third_op.dst_extents(0).start_block());
+ EXPECT_EQ(3U, third_op.dst_extents(0).num_blocks());
}
TEST_F(ABGeneratorTest, SplitReplaceTest) {
@@ -429,7 +430,7 @@
aops.push_back(third_aop);
ABGenerator::SortOperationsByDestination(&aops);
- EXPECT_EQ(aops.size(), 3);
+ EXPECT_EQ(3U, aops.size());
EXPECT_EQ(third_aop.name, aops[0].name);
EXPECT_EQ(first_aop.name, aops[1].name);
EXPECT_EQ(second_aop.name, aops[2].name);
@@ -475,7 +476,7 @@
BlobFileWriter blob_file(0, nullptr);
EXPECT_TRUE(ABGenerator::MergeOperations(&aops, 5, "", &blob_file));
- EXPECT_EQ(aops.size(), 1);
+ EXPECT_EQ(1U, aops.size());
InstallOperation first_result_op = aops[0].op;
EXPECT_EQ(InstallOperation::SOURCE_COPY, first_result_op.type());
EXPECT_EQ(kBlockSize * 5, first_result_op.src_length());
@@ -548,7 +549,7 @@
EXPECT_TRUE(ABGenerator::MergeOperations(&aops, 4, "", &blob_file));
// No operations were merged, the number of ops is the same.
- EXPECT_EQ(aops.size(), 4);
+ EXPECT_EQ(4U, aops.size());
}
TEST_F(ABGeneratorTest, AddSourceHashTest) {
diff --git a/payload_generator/block_mapping_unittest.cc b/payload_generator/block_mapping_unittest.cc
index 18e48c4..4d09710 100644
--- a/payload_generator/block_mapping_unittest.cc
+++ b/payload_generator/block_mapping_unittest.cc
@@ -97,7 +97,7 @@
EXPECT_FALSE(ublock.block_data.empty());
// The block was loaded from disk only 4 times, and after that the counter
// is not updated anymore.
- EXPECT_EQ(4, ublock.times_read);
+ EXPECT_EQ(4U, ublock.times_read);
}
}
}
diff --git a/payload_generator/cycle_breaker_unittest.cc b/payload_generator/cycle_breaker_unittest.cc
index 4053cf3..e92bc30 100644
--- a/payload_generator/cycle_breaker_unittest.cc
+++ b/payload_generator/cycle_breaker_unittest.cc
@@ -91,7 +91,7 @@
utils::SetContainsKey(broken_edges, make_pair(n_e, n_c)));
EXPECT_TRUE(utils::SetContainsKey(broken_edges, make_pair(n_g, n_h)) ||
utils::SetContainsKey(broken_edges, make_pair(n_h, n_g)));
- EXPECT_EQ(3, broken_edges.size());
+ EXPECT_EQ(3U, broken_edges.size());
}
namespace {
@@ -127,7 +127,7 @@
// the algorithm to cut cycles (t) instead, since they are closer to the
// root, and that can massively speed up cycle cutting.
TEST(CycleBreakerTest, AggressiveCutTest) {
- int counter = 0;
+ size_t counter = 0;
const int kNodesPerGroup = 4;
const int kGroups = 33;
@@ -176,7 +176,7 @@
}
TEST(CycleBreakerTest, WeightTest) {
- int counter = 0;
+ size_t counter = 0;
const Vertex::Index n_a = counter++;
const Vertex::Index n_b = counter++;
const Vertex::Index n_c = counter++;
@@ -225,7 +225,7 @@
}
TEST(CycleBreakerTest, UnblockGraphTest) {
- int counter = 0;
+ size_t counter = 0;
const Vertex::Index n_a = counter++;
const Vertex::Index n_b = counter++;
const Vertex::Index n_c = counter++;
@@ -253,7 +253,7 @@
}
TEST(CycleBreakerTest, SkipOpsTest) {
- int counter = 0;
+ size_t counter = 0;
const Vertex::Index n_a = counter++;
const Vertex::Index n_b = counter++;
const Vertex::Index n_c = counter++;
@@ -272,7 +272,7 @@
set<Edge> broken_edges;
breaker.BreakCycles(graph, &broken_edges);
- EXPECT_EQ(2, breaker.skipped_ops());
+ EXPECT_EQ(2U, breaker.skipped_ops());
}
} // namespace chromeos_update_engine
diff --git a/payload_generator/delta_diff_utils_unittest.cc b/payload_generator/delta_diff_utils_unittest.cc
index 4dc5981..72349d8 100644
--- a/payload_generator/delta_diff_utils_unittest.cc
+++ b/payload_generator/delta_diff_utils_unittest.cc
@@ -17,6 +17,7 @@
#include "update_engine/payload_generator/delta_diff_utils.h"
#include <algorithm>
+#include <random>
#include <string>
#include <vector>
@@ -193,7 +194,7 @@
EXPECT_EQ(kBlockSize, op.dst_length());
EXPECT_EQ(BlocksInExtents(op.src_extents()),
BlocksInExtents(op.dst_extents()));
- EXPECT_EQ(1, BlocksInExtents(op.dst_extents()));
+ EXPECT_EQ(1U, BlocksInExtents(op.dst_extents()));
}
TEST_F(DeltaDiffUtilsTest, MoveWithSameBlock) {
@@ -263,7 +264,7 @@
EXPECT_EQ(num_blocks * kBlockSize, op.src_length());
EXPECT_EQ(num_blocks * kBlockSize, op.dst_length());
- EXPECT_EQ(old_extents.size(), op.src_extents_size());
+ EXPECT_EQ(old_extents.size(), static_cast<size_t>(op.src_extents_size()));
for (int i = 0; i < op.src_extents_size(); i++) {
EXPECT_EQ(old_extents[i].start_block(), op.src_extents(i).start_block())
<< "i == " << i;
@@ -271,7 +272,7 @@
<< "i == " << i;
}
- EXPECT_EQ(new_extents.size(), op.dst_extents_size());
+ EXPECT_EQ(new_extents.size(), static_cast<size_t>(op.dst_extents_size()));
for (int i = 0; i < op.dst_extents_size(); i++) {
EXPECT_EQ(new_extents[i].start_block(), op.dst_extents(i).start_block())
<< "i == " << i;
@@ -318,7 +319,7 @@
EXPECT_EQ(kBlockSize, op.dst_length());
EXPECT_EQ(BlocksInExtents(op.src_extents()),
BlocksInExtents(op.dst_extents()));
- EXPECT_EQ(1, BlocksInExtents(op.dst_extents()));
+ EXPECT_EQ(1U, BlocksInExtents(op.dst_extents()));
}
TEST_F(DeltaDiffUtilsTest, BsdiffNotAllowedTest) {
@@ -432,7 +433,7 @@
EXPECT_FALSE(op.has_src_length());
EXPECT_EQ(1, op.dst_extents_size());
EXPECT_EQ(data_to_test.size(), op.dst_length());
- EXPECT_EQ(1, BlocksInExtents(op.dst_extents()));
+ EXPECT_EQ(1U, BlocksInExtents(op.dst_extents()));
}
}
@@ -552,8 +553,8 @@
EXPECT_TRUE(RunDeltaMovedAndZeroBlocks(-1, // chunk_blocks
false)); // src_ops_allowed
- EXPECT_EQ(0, old_visited_blocks_.blocks());
- EXPECT_EQ(0, new_visited_blocks_.blocks());
+ EXPECT_EQ(0U, old_visited_blocks_.blocks());
+ EXPECT_EQ(0U, new_visited_blocks_.blocks());
EXPECT_EQ(0, blob_size_);
EXPECT_TRUE(aops_.empty());
}
@@ -662,7 +663,7 @@
// source extents should cover only the first copy of the source file since
// we prefer to re-read files (maybe cached) instead of continue reading the
// rest of the partition.
- EXPECT_EQ(1, aops_.size());
+ EXPECT_EQ(1U, aops_.size());
const AnnotatedOperation& aop = aops_[0];
EXPECT_EQ(InstallOperation::SOURCE_COPY, aop.op.type());
EXPECT_EQ(5, aop.op.src_extents_size());
@@ -759,7 +760,7 @@
EXPECT_EQ(permutation.size(), new_visited_blocks_.blocks());
// There should be only one SOURCE_COPY, with a complicate list of extents.
- EXPECT_EQ(1, aops_.size());
+ EXPECT_EQ(1U, aops_.size());
const AnnotatedOperation& aop = aops_[0];
EXPECT_EQ(InstallOperation::SOURCE_COPY, aop.op.type());
vector<Extent> aop_src_extents;
diff --git a/payload_generator/ext2_filesystem_unittest.cc b/payload_generator/ext2_filesystem_unittest.cc
index df8b98f..1362027 100644
--- a/payload_generator/ext2_filesystem_unittest.cc
+++ b/payload_generator/ext2_filesystem_unittest.cc
@@ -52,7 +52,7 @@
// Checks that all the blocks in |extents| are in the range [0, total_blocks).
void ExpectBlocksInRange(const vector<Extent>& extents, uint64_t total_blocks) {
for (const Extent& extent : extents) {
- EXPECT_LE(0, extent.start_block());
+ EXPECT_LE(0U, extent.start_block());
EXPECT_LE(extent.start_block() + extent.num_blocks(), total_blocks);
}
}
@@ -103,7 +103,7 @@
map_files[file.name] = file;
ExpectBlocksInRange(file.extents, fs->GetBlockCount());
}
- EXPECT_EQ(2, map_files["/"].file_stat.st_ino);
+ EXPECT_EQ(2U, map_files["/"].file_stat.st_ino);
EXPECT_FALSE(map_files["<free-space>"].extents.empty());
}
@@ -169,7 +169,7 @@
// Small symlinks don't actually have data blocks.
EXPECT_TRUE(map_files["/link-short_symlink"].extents.empty());
- EXPECT_EQ(1, BlocksInExtents(map_files["/link-long_symlink"].extents));
+ EXPECT_EQ(1U, BlocksInExtents(map_files["/link-long_symlink"].extents));
// Hard-links report the same list of blocks.
EXPECT_EQ(map_files["/link-hard-regular-16k"].extents,
@@ -179,13 +179,14 @@
// The number of blocks in these files doesn't depend on the
// block size.
EXPECT_TRUE(map_files["/empty-file"].extents.empty());
- EXPECT_EQ(1, BlocksInExtents(map_files["/regular-small"].extents));
- EXPECT_EQ(1, BlocksInExtents(map_files["/regular-with_net_cap"].extents));
+ EXPECT_EQ(1U, BlocksInExtents(map_files["/regular-small"].extents));
+ EXPECT_EQ(1U, BlocksInExtents(map_files["/regular-with_net_cap"].extents));
EXPECT_TRUE(map_files["/sparse_empty-10k"].extents.empty());
EXPECT_TRUE(map_files["/sparse_empty-2blocks"].extents.empty());
- EXPECT_EQ(1, BlocksInExtents(map_files["/sparse-16k-last_block"].extents));
- EXPECT_EQ(1, BlocksInExtents(map_files["/sparse-16k-first_block"].extents));
- EXPECT_EQ(2, BlocksInExtents(map_files["/sparse-16k-holes"].extents));
+ EXPECT_EQ(1U, BlocksInExtents(map_files["/sparse-16k-last_block"].extents));
+ EXPECT_EQ(1U,
+ BlocksInExtents(map_files["/sparse-16k-first_block"].extents));
+ EXPECT_EQ(2U, BlocksInExtents(map_files["/sparse-16k-holes"].extents));
}
}
diff --git a/payload_generator/extent_ranges_unittest.cc b/payload_generator/extent_ranges_unittest.cc
index 8b39040..3705bac 100644
--- a/payload_generator/extent_ranges_unittest.cc
+++ b/payload_generator/extent_ranges_unittest.cc
@@ -250,7 +250,7 @@
ranges.SubtractExtents(vector<Extent>(1, ExtentForRange(20, 10)));
*rep_field.Mutable(0) = ExtentForRange(50, 10);
ranges.SubtractRepeatedExtents(rep_field);
- EXPECT_EQ(40, ranges.blocks());
+ EXPECT_EQ(40U, ranges.blocks());
for (int i = 0; i < 2; i++) {
vector<Extent> expected(2);
diff --git a/payload_generator/extent_utils_unittest.cc b/payload_generator/extent_utils_unittest.cc
index 62c8ff1..d470e7b 100644
--- a/payload_generator/extent_utils_unittest.cc
+++ b/payload_generator/extent_utils_unittest.cc
@@ -34,43 +34,43 @@
TEST(ExtentUtilsTest, AppendSparseToExtentsTest) {
vector<Extent> extents;
- EXPECT_EQ(0, extents.size());
+ EXPECT_EQ(0U, extents.size());
AppendBlockToExtents(&extents, kSparseHole);
- EXPECT_EQ(1, extents.size());
+ EXPECT_EQ(1U, extents.size());
AppendBlockToExtents(&extents, 0);
- EXPECT_EQ(2, extents.size());
+ EXPECT_EQ(2U, extents.size());
AppendBlockToExtents(&extents, kSparseHole);
AppendBlockToExtents(&extents, kSparseHole);
- ASSERT_EQ(3, extents.size());
+ ASSERT_EQ(3U, extents.size());
EXPECT_EQ(kSparseHole, extents[0].start_block());
- EXPECT_EQ(1, extents[0].num_blocks());
- EXPECT_EQ(0, extents[1].start_block());
- EXPECT_EQ(1, extents[1].num_blocks());
+ EXPECT_EQ(1U, extents[0].num_blocks());
+ EXPECT_EQ(0U, extents[1].start_block());
+ EXPECT_EQ(1U, extents[1].num_blocks());
EXPECT_EQ(kSparseHole, extents[2].start_block());
- EXPECT_EQ(2, extents[2].num_blocks());
+ EXPECT_EQ(2U, extents[2].num_blocks());
}
TEST(ExtentUtilsTest, BlocksInExtentsTest) {
{
vector<Extent> extents;
- EXPECT_EQ(0, BlocksInExtents(extents));
+ EXPECT_EQ(0U, BlocksInExtents(extents));
extents.push_back(ExtentForRange(0, 1));
- EXPECT_EQ(1, BlocksInExtents(extents));
+ EXPECT_EQ(1U, BlocksInExtents(extents));
extents.push_back(ExtentForRange(23, 55));
- EXPECT_EQ(56, BlocksInExtents(extents));
+ EXPECT_EQ(56U, BlocksInExtents(extents));
extents.push_back(ExtentForRange(1, 2));
- EXPECT_EQ(58, BlocksInExtents(extents));
+ EXPECT_EQ(58U, BlocksInExtents(extents));
}
{
google::protobuf::RepeatedPtrField<Extent> extents;
- EXPECT_EQ(0, BlocksInExtents(extents));
+ EXPECT_EQ(0U, BlocksInExtents(extents));
*extents.Add() = ExtentForRange(0, 1);
- EXPECT_EQ(1, BlocksInExtents(extents));
+ EXPECT_EQ(1U, BlocksInExtents(extents));
*extents.Add() = ExtentForRange(23, 55);
- EXPECT_EQ(56, BlocksInExtents(extents));
+ EXPECT_EQ(56U, BlocksInExtents(extents));
*extents.Add() = ExtentForRange(1, 2);
- EXPECT_EQ(58, BlocksInExtents(extents));
+ EXPECT_EQ(58U, BlocksInExtents(extents));
}
}
@@ -96,11 +96,11 @@
// Make sure it works when there's just one extent.
vector<Extent> extents;
NormalizeExtents(&extents);
- EXPECT_EQ(0, extents.size());
+ EXPECT_EQ(0U, extents.size());
extents = { ExtentForRange(0, 3) };
NormalizeExtents(&extents);
- EXPECT_EQ(1, extents.size());
+ EXPECT_EQ(1U, extents.size());
EXPECT_EQ(ExtentForRange(0, 3), extents[0]);
}
@@ -114,7 +114,7 @@
ExtentForRange(14, 2)
};
NormalizeExtents(&extents);
- EXPECT_EQ(3, extents.size());
+ EXPECT_EQ(3U, extents.size());
EXPECT_EQ(ExtentForRange(0, 6), extents[0]);
EXPECT_EQ(ExtentForRange(8, 4), extents[1]);
EXPECT_EQ(ExtentForRange(13, 3), extents[2]);
diff --git a/payload_generator/fake_filesystem.cc b/payload_generator/fake_filesystem.cc
index 3a6458d..c765286 100644
--- a/payload_generator/fake_filesystem.cc
+++ b/payload_generator/fake_filesystem.cc
@@ -44,7 +44,7 @@
file.name = filename;
file.extents = extents;
for (const Extent& extent : extents) {
- EXPECT_LE(0, extent.start_block());
+ EXPECT_LE(0U, extent.start_block());
EXPECT_LE(extent.start_block() + extent.num_blocks(), block_count_);
}
files_.push_back(file);
diff --git a/payload_generator/full_update_generator_unittest.cc b/payload_generator/full_update_generator_unittest.cc
index d46346d..7871338 100644
--- a/payload_generator/full_update_generator_unittest.cc
+++ b/payload_generator/full_update_generator_unittest.cc
@@ -86,7 +86,7 @@
EXPECT_EQ(new_part_chunks, aops.size());
for (off_t i = 0; i < new_part_chunks; ++i) {
EXPECT_EQ(1, aops[i].op.dst_extents_size());
- EXPECT_EQ(i * config_.hard_chunk_size / config_.block_size,
+ EXPECT_EQ(static_cast<uint64_t>(i * config_.hard_chunk_size / config_.block_size),
aops[i].op.dst_extents(0).start_block()) << "i = " << i;
EXPECT_EQ(config_.hard_chunk_size / config_.block_size,
aops[i].op.dst_extents(0).num_blocks());
@@ -112,7 +112,7 @@
blob_file_.get(),
&aops));
// new_part has one chunk and a half.
- EXPECT_EQ(2, aops.size());
+ EXPECT_EQ(2U, aops.size());
EXPECT_EQ(config_.hard_chunk_size / config_.block_size,
BlocksInExtents(aops[0].op.dst_extents()));
EXPECT_EQ((new_part.size() - config_.hard_chunk_size) / config_.block_size,
@@ -134,7 +134,7 @@
&aops));
// new_part has less than one chunk.
- EXPECT_EQ(1, aops.size());
+ EXPECT_EQ(1U, aops.size());
EXPECT_EQ(new_part.size() / config_.block_size,
BlocksInExtents(aops[0].op.dst_extents()));
}
diff --git a/payload_generator/graph_utils_unittest.cc b/payload_generator/graph_utils_unittest.cc
index 7d3dbe3..dddf815 100644
--- a/payload_generator/graph_utils_unittest.cc
+++ b/payload_generator/graph_utils_unittest.cc
@@ -39,21 +39,21 @@
vector<Extent>& extents = graph[0].out_edges[1].extents;
- EXPECT_EQ(0, extents.size());
+ EXPECT_EQ(0U, extents.size());
AppendBlockToExtents(&extents, 0);
- EXPECT_EQ(1, extents.size());
+ EXPECT_EQ(1U, extents.size());
AppendBlockToExtents(&extents, 1);
AppendBlockToExtents(&extents, 2);
- EXPECT_EQ(1, extents.size());
+ EXPECT_EQ(1U, extents.size());
AppendBlockToExtents(&extents, 4);
- EXPECT_EQ(2, extents.size());
- EXPECT_EQ(0, extents[0].start_block());
- EXPECT_EQ(3, extents[0].num_blocks());
- EXPECT_EQ(4, extents[1].start_block());
- EXPECT_EQ(1, extents[1].num_blocks());
+ EXPECT_EQ(2U, extents.size());
+ EXPECT_EQ(0U, extents[0].start_block());
+ EXPECT_EQ(3U, extents[0].num_blocks());
+ EXPECT_EQ(4U, extents[1].start_block());
+ EXPECT_EQ(1U, extents[1].num_blocks());
- EXPECT_EQ(4, graph_utils::EdgeWeight(graph, make_pair(0, 1)));
+ EXPECT_EQ(4U, graph_utils::EdgeWeight(graph, make_pair(0, 1)));
}
@@ -61,35 +61,35 @@
Graph graph(3);
graph_utils::AddReadBeforeDep(&graph[0], 1, 3);
- EXPECT_EQ(1, graph[0].out_edges.size());
+ EXPECT_EQ(1U, graph[0].out_edges.size());
{
Extent& extent = graph[0].out_edges[1].extents[0];
- EXPECT_EQ(3, extent.start_block());
- EXPECT_EQ(1, extent.num_blocks());
+ EXPECT_EQ(3U, extent.start_block());
+ EXPECT_EQ(1U, extent.num_blocks());
}
graph_utils::AddReadBeforeDep(&graph[0], 1, 4);
- EXPECT_EQ(1, graph[0].out_edges.size());
+ EXPECT_EQ(1U, graph[0].out_edges.size());
{
Extent& extent = graph[0].out_edges[1].extents[0];
- EXPECT_EQ(3, extent.start_block());
- EXPECT_EQ(2, extent.num_blocks());
+ EXPECT_EQ(3U, extent.start_block());
+ EXPECT_EQ(2U, extent.num_blocks());
}
graph_utils::AddReadBeforeDepExtents(&graph[2], 1,
vector<Extent>(1, ExtentForRange(5, 2)));
- EXPECT_EQ(1, graph[2].out_edges.size());
+ EXPECT_EQ(1U, graph[2].out_edges.size());
{
Extent& extent = graph[2].out_edges[1].extents[0];
- EXPECT_EQ(5, extent.start_block());
- EXPECT_EQ(2, extent.num_blocks());
+ EXPECT_EQ(5U, extent.start_block());
+ EXPECT_EQ(2U, extent.num_blocks());
}
// Change most recent edge from read-before to write-before
graph[2].out_edges[1].write_extents.swap(graph[2].out_edges[1].extents);
graph_utils::DropWriteBeforeDeps(&graph[2].out_edges);
- EXPECT_EQ(0, graph[2].out_edges.size());
+ EXPECT_EQ(0U, graph[2].out_edges.size());
- EXPECT_EQ(1, graph[0].out_edges.size());
+ EXPECT_EQ(1U, graph[0].out_edges.size());
graph_utils::DropIncomingEdgesTo(&graph, 1);
- EXPECT_EQ(0, graph[0].out_edges.size());
+ EXPECT_EQ(0U, graph[0].out_edges.size());
}
} // namespace chromeos_update_engine
diff --git a/payload_generator/inplace_generator_unittest.cc b/payload_generator/inplace_generator_unittest.cc
index 9932ef9..cde4bfc 100644
--- a/payload_generator/inplace_generator_unittest.cc
+++ b/payload_generator/inplace_generator_unittest.cc
@@ -153,20 +153,20 @@
InplaceGenerator::SubstituteBlocks(&vertex, remove_blocks, replace_blocks);
EXPECT_EQ(7, op.src_extents_size());
- EXPECT_EQ(11, op.src_extents(0).start_block());
- EXPECT_EQ(1, op.src_extents(0).num_blocks());
- EXPECT_EQ(13, op.src_extents(1).start_block());
- EXPECT_EQ(1, op.src_extents(1).num_blocks());
- EXPECT_EQ(6, op.src_extents(2).start_block());
- EXPECT_EQ(1, op.src_extents(2).num_blocks());
+ EXPECT_EQ(11U, op.src_extents(0).start_block());
+ EXPECT_EQ(1U, op.src_extents(0).num_blocks());
+ EXPECT_EQ(13U, op.src_extents(1).start_block());
+ EXPECT_EQ(1U, op.src_extents(1).num_blocks());
+ EXPECT_EQ(6U, op.src_extents(2).start_block());
+ EXPECT_EQ(1U, op.src_extents(2).num_blocks());
EXPECT_EQ(kSparseHole, op.src_extents(3).start_block());
- EXPECT_EQ(4, op.src_extents(3).num_blocks());
- EXPECT_EQ(10, op.src_extents(4).start_block());
- EXPECT_EQ(1, op.src_extents(4).num_blocks());
- EXPECT_EQ(14, op.src_extents(5).start_block());
- EXPECT_EQ(1, op.src_extents(5).num_blocks());
- EXPECT_EQ(8, op.src_extents(6).start_block());
- EXPECT_EQ(2, op.src_extents(6).num_blocks());
+ EXPECT_EQ(4U, op.src_extents(3).num_blocks());
+ EXPECT_EQ(10U, op.src_extents(4).start_block());
+ EXPECT_EQ(1U, op.src_extents(4).num_blocks());
+ EXPECT_EQ(14U, op.src_extents(5).start_block());
+ EXPECT_EQ(1U, op.src_extents(5).num_blocks());
+ EXPECT_EQ(8U, op.src_extents(6).start_block());
+ EXPECT_EQ(2U, op.src_extents(6).num_blocks());
}
TEST_F(InplaceGeneratorTest, CutEdgesTest) {
@@ -229,58 +229,58 @@
set<Edge> cut_edges;
cycle_breaker.BreakCycles(graph, &cut_edges);
- EXPECT_EQ(1, cut_edges.size());
+ EXPECT_EQ(1U, cut_edges.size());
EXPECT_TRUE(cut_edges.end() != cut_edges.find(
std::pair<Vertex::Index, Vertex::Index>(1, 0)));
vector<CutEdgeVertexes> cuts;
EXPECT_TRUE(InplaceGenerator::CutEdges(&graph, cut_edges, &cuts));
- EXPECT_EQ(3, graph.size());
+ EXPECT_EQ(3U, graph.size());
// Check new node in graph:
EXPECT_EQ(InstallOperation::MOVE, graph.back().aop.op.type());
EXPECT_EQ(2, graph.back().aop.op.src_extents_size());
EXPECT_EQ(1, graph.back().aop.op.dst_extents_size());
EXPECT_EQ(kTempBlockStart, graph.back().aop.op.dst_extents(0).start_block());
- EXPECT_EQ(2, graph.back().aop.op.dst_extents(0).num_blocks());
+ EXPECT_EQ(2U, graph.back().aop.op.dst_extents(0).num_blocks());
EXPECT_TRUE(graph.back().out_edges.empty());
// Check that old node reads from new blocks
EXPECT_EQ(2, graph[0].aop.op.src_extents_size());
EXPECT_EQ(kTempBlockStart, graph[0].aop.op.src_extents(0).start_block());
- EXPECT_EQ(2, graph[0].aop.op.src_extents(0).num_blocks());
- EXPECT_EQ(7, graph[0].aop.op.src_extents(1).start_block());
- EXPECT_EQ(1, graph[0].aop.op.src_extents(1).num_blocks());
+ EXPECT_EQ(2U, graph[0].aop.op.src_extents(0).num_blocks());
+ EXPECT_EQ(7U, graph[0].aop.op.src_extents(1).start_block());
+ EXPECT_EQ(1U, graph[0].aop.op.src_extents(1).num_blocks());
// And that the old dst extents haven't changed
EXPECT_EQ(2, graph[0].aop.op.dst_extents_size());
- EXPECT_EQ(1, graph[0].aop.op.dst_extents(0).start_block());
- EXPECT_EQ(2, graph[0].aop.op.dst_extents(0).num_blocks());
- EXPECT_EQ(4, graph[0].aop.op.dst_extents(1).start_block());
- EXPECT_EQ(1, graph[0].aop.op.dst_extents(1).num_blocks());
+ EXPECT_EQ(1U, graph[0].aop.op.dst_extents(0).start_block());
+ EXPECT_EQ(2U, graph[0].aop.op.dst_extents(0).num_blocks());
+ EXPECT_EQ(4U, graph[0].aop.op.dst_extents(1).start_block());
+ EXPECT_EQ(1U, graph[0].aop.op.dst_extents(1).num_blocks());
// Ensure it only depends on the next node and the new temp node
- EXPECT_EQ(2, graph[0].out_edges.size());
+ EXPECT_EQ(2U, graph[0].out_edges.size());
EXPECT_TRUE(graph[0].out_edges.end() != graph[0].out_edges.find(1));
EXPECT_TRUE(graph[0].out_edges.end() != graph[0].out_edges.find(graph.size() -
1));
// Check second node has unchanged extents
EXPECT_EQ(2, graph[1].aop.op.src_extents_size());
- EXPECT_EQ(1, graph[1].aop.op.src_extents(0).start_block());
- EXPECT_EQ(2, graph[1].aop.op.src_extents(0).num_blocks());
- EXPECT_EQ(4, graph[1].aop.op.src_extents(1).start_block());
- EXPECT_EQ(1, graph[1].aop.op.src_extents(1).num_blocks());
+ EXPECT_EQ(1U, graph[1].aop.op.src_extents(0).start_block());
+ EXPECT_EQ(2U, graph[1].aop.op.src_extents(0).num_blocks());
+ EXPECT_EQ(4U, graph[1].aop.op.src_extents(1).start_block());
+ EXPECT_EQ(1U, graph[1].aop.op.src_extents(1).num_blocks());
EXPECT_EQ(2, graph[1].aop.op.dst_extents_size());
- EXPECT_EQ(3, graph[1].aop.op.dst_extents(0).start_block());
- EXPECT_EQ(1, graph[1].aop.op.dst_extents(0).num_blocks());
- EXPECT_EQ(5, graph[1].aop.op.dst_extents(1).start_block());
- EXPECT_EQ(2, graph[1].aop.op.dst_extents(1).num_blocks());
+ EXPECT_EQ(3U, graph[1].aop.op.dst_extents(0).start_block());
+ EXPECT_EQ(1U, graph[1].aop.op.dst_extents(0).num_blocks());
+ EXPECT_EQ(5U, graph[1].aop.op.dst_extents(1).start_block());
+ EXPECT_EQ(2U, graph[1].aop.op.dst_extents(1).num_blocks());
// Ensure it only depends on the next node
- EXPECT_EQ(1, graph[1].out_edges.size());
+ EXPECT_EQ(1U, graph[1].out_edges.size());
EXPECT_TRUE(graph[1].out_edges.end() != graph[1].out_edges.find(2));
}
@@ -384,8 +384,8 @@
EXPECT_FALSE(graph[6].valid);
EXPECT_FALSE(graph[7].valid);
EXPECT_EQ(1, graph[1].aop.op.src_extents_size());
- EXPECT_EQ(2, graph[1].aop.op.src_extents(0).start_block());
- EXPECT_EQ(1, graph[1].aop.op.src_extents(0).num_blocks());
+ EXPECT_EQ(2U, graph[1].aop.op.src_extents(0).start_block());
+ EXPECT_EQ(1U, graph[1].aop.op.src_extents(0).num_blocks());
EXPECT_EQ(InstallOperation::REPLACE_BZ, graph[5].aop.op.type());
}
@@ -547,7 +547,7 @@
InstallOperation::MOVE);
expected_graph[10].out_edges[4] = EdgeWithReadDep(VectOfExt(60, 9));
- EXPECT_EQ(12, graph.size());
+ EXPECT_EQ(12U, graph.size());
EXPECT_FALSE(graph.back().valid);
for (Graph::size_type i = 0; i < graph.size() - 1; i++) {
EXPECT_TRUE(graph[i].out_edges == expected_graph[i].out_edges);
@@ -563,11 +563,11 @@
Vertex vertex;
InplaceGenerator::CreateScratchNode(12, 34, &vertex);
EXPECT_EQ(InstallOperation::REPLACE_BZ, vertex.aop.op.type());
- EXPECT_EQ(0, vertex.aop.op.data_offset());
- EXPECT_EQ(0, vertex.aop.op.data_length());
+ EXPECT_EQ(0U, vertex.aop.op.data_offset());
+ EXPECT_EQ(0U, vertex.aop.op.data_length());
EXPECT_EQ(1, vertex.aop.op.dst_extents_size());
- EXPECT_EQ(12, vertex.aop.op.dst_extents(0).start_block());
- EXPECT_EQ(34, vertex.aop.op.dst_extents(0).num_blocks());
+ EXPECT_EQ(12U, vertex.aop.op.dst_extents(0).start_block());
+ EXPECT_EQ(34U, vertex.aop.op.dst_extents(0).num_blocks());
}
TEST_F(InplaceGeneratorTest, ApplyMapTest) {
@@ -635,16 +635,18 @@
if (aop.op.type() != InstallOperation::MOVE)
continue;
for (const Extent& extent : aop.op.src_extents()) {
- EXPECT_NE(0, extent.start_block()) << "On src extents for aop: " << aop;
+ EXPECT_NE(0U, extent.start_block())
+ << "On src extents for aop: " << aop;
}
for (const Extent& extent : aop.op.dst_extents()) {
- EXPECT_NE(0, extent.start_block()) << "On dst extents for aop: " << aop;
+ EXPECT_NE(0U, extent.start_block())
+ << "On dst extents for aop: " << aop;
}
}
// If there's extra space in the partition, it should not use a new full
// operation for it.
- EXPECT_EQ(part_blocks == num_blocks ? 2 : 1, full_ops);
+ EXPECT_EQ(part_blocks == num_blocks ? 2U : 1U, full_ops);
if (HasNonfatalFailure()) {
LOG(INFO) << "Result operation list:";
diff --git a/payload_generator/payload_file_unittest.cc b/payload_generator/payload_file_unittest.cc
index 4d18adf..e8e7e14 100644
--- a/payload_generator/payload_file_unittest.cc
+++ b/payload_generator/payload_file_unittest.cc
@@ -80,15 +80,15 @@
// Kernel blobs should appear at the end.
EXPECT_EQ("bcdakernel", new_data);
- EXPECT_EQ(2, part0_aops.size());
- EXPECT_EQ(0, part0_aops[0].op.data_offset());
- EXPECT_EQ(3, part0_aops[0].op.data_length());
- EXPECT_EQ(3, part0_aops[1].op.data_offset());
- EXPECT_EQ(1, part0_aops[1].op.data_length());
+ EXPECT_EQ(2U, part0_aops.size());
+ EXPECT_EQ(0U, part0_aops[0].op.data_offset());
+ EXPECT_EQ(3U, part0_aops[0].op.data_length());
+ EXPECT_EQ(3U, part0_aops[1].op.data_offset());
+ EXPECT_EQ(1U, part0_aops[1].op.data_length());
- EXPECT_EQ(1, part1_aops.size());
- EXPECT_EQ(4, part1_aops[0].op.data_offset());
- EXPECT_EQ(6, part1_aops[0].op.data_length());
+ EXPECT_EQ(1U, part1_aops.size());
+ EXPECT_EQ(4U, part1_aops[0].op.data_offset());
+ EXPECT_EQ(6U, part1_aops[0].op.data_length());
}
} // namespace chromeos_update_engine
diff --git a/payload_generator/payload_signer_unittest.cc b/payload_generator/payload_signer_unittest.cc
index eadbc59..ebdd280 100644
--- a/payload_generator/payload_signer_unittest.cc
+++ b/payload_generator/payload_signer_unittest.cc
@@ -103,7 +103,7 @@
std::begin(kDataToSign) + strlen(kDataToSign));
uint64_t length = 0;
EXPECT_TRUE(PayloadSigner::SignatureBlobLength(private_keys, &length));
- EXPECT_GT(length, 0);
+ EXPECT_GT(length, 0U);
brillo::Blob hash_blob;
EXPECT_TRUE(HashCalculator::RawHashOfBytes(data_blob.data(),
data_blob.size(),
@@ -170,7 +170,7 @@
signature_blob.size()));
EXPECT_EQ(1, signatures.signatures_size());
const Signatures_Signature& signature = signatures.signatures(0);
- EXPECT_EQ(1, signature.version());
+ EXPECT_EQ(1U, signature.version());
const string sig_data = signature.data();
ASSERT_EQ(arraysize(kDataSignature), sig_data.size());
for (size_t i = 0; i < arraysize(kDataSignature); i++) {
diff --git a/payload_generator/tarjan_unittest.cc b/payload_generator/tarjan_unittest.cc
index e40a7ff..c29cbdc 100644
--- a/payload_generator/tarjan_unittest.cc
+++ b/payload_generator/tarjan_unittest.cc
@@ -65,7 +65,7 @@
vector<Vertex::Index> vertex_indexes;
tarjan.Execute(i, &graph, &vertex_indexes);
- EXPECT_EQ(5, vertex_indexes.size());
+ EXPECT_EQ(5U, vertex_indexes.size());
EXPECT_TRUE(utils::VectorContainsValue(vertex_indexes, n_a));
EXPECT_TRUE(utils::VectorContainsValue(vertex_indexes, n_b));
EXPECT_TRUE(utils::VectorContainsValue(vertex_indexes, n_c));
@@ -77,7 +77,7 @@
vector<Vertex::Index> vertex_indexes;
tarjan.Execute(n_f, &graph, &vertex_indexes);
- EXPECT_EQ(1, vertex_indexes.size());
+ EXPECT_EQ(1U, vertex_indexes.size());
EXPECT_TRUE(utils::VectorContainsValue(vertex_indexes, n_f));
}
@@ -85,7 +85,7 @@
vector<Vertex::Index> vertex_indexes;
tarjan.Execute(i, &graph, &vertex_indexes);
- EXPECT_EQ(2, vertex_indexes.size());
+ EXPECT_EQ(2U, vertex_indexes.size());
EXPECT_TRUE(utils::VectorContainsValue(vertex_indexes, n_g));
EXPECT_TRUE(utils::VectorContainsValue(vertex_indexes, n_h));
}
diff --git a/payload_generator/zip_unittest.cc b/payload_generator/zip_unittest.cc
index 49b08b0..0c95a8f 100644
--- a/payload_generator/zip_unittest.cc
+++ b/payload_generator/zip_unittest.cc
@@ -74,7 +74,7 @@
brillo::Blob out;
EXPECT_TRUE(this->ZipCompressString(in, &out));
EXPECT_LT(out.size(), in.size());
- EXPECT_GT(out.size(), 0);
+ EXPECT_GT(out.size(), 0U);
brillo::Blob decompressed;
EXPECT_TRUE(this->ZipDecompress(out, &decompressed));
EXPECT_EQ(in.size(), decompressed.size());
@@ -105,10 +105,10 @@
string in;
brillo::Blob out;
EXPECT_TRUE(this->ZipDecompressString(in, &out));
- EXPECT_EQ(0, out.size());
+ EXPECT_EQ(0U, out.size());
EXPECT_TRUE(this->ZipCompressString(in, &out));
- EXPECT_EQ(0, out.size());
+ EXPECT_EQ(0U, out.size());
}
} // namespace chromeos_update_engine
diff --git a/payload_state_unittest.cc b/payload_state_unittest.cc
index 4490637..b671722 100644
--- a/payload_state_unittest.cc
+++ b/payload_state_unittest.cc
@@ -139,8 +139,8 @@
"Disable Payload Backoff = 0\n";
EXPECT_EQ(expected_response_sign, stored_response_sign);
EXPECT_EQ("", payload_state.GetCurrentUrl());
- EXPECT_EQ(0, payload_state.GetUrlFailureCount());
- EXPECT_EQ(0, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(0U, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(0U, payload_state.GetUrlSwitchCount());
EXPECT_EQ(1, payload_state.GetNumResponsesSeen());
}
@@ -191,8 +191,8 @@
"Disable Payload Backoff = 0\n";
EXPECT_EQ(expected_response_sign, stored_response_sign);
EXPECT_EQ("https://single.url.test", payload_state.GetCurrentUrl());
- EXPECT_EQ(0, payload_state.GetUrlFailureCount());
- EXPECT_EQ(0, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(0U, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(0U, payload_state.GetUrlSwitchCount());
EXPECT_EQ(1, payload_state.GetNumResponsesSeen());
}
@@ -242,8 +242,8 @@
"Disable Payload Backoff = 0\n";
EXPECT_EQ(expected_response_sign, stored_response_sign);
EXPECT_EQ("http://multiple.url.test", payload_state.GetCurrentUrl());
- EXPECT_EQ(0, payload_state.GetUrlFailureCount());
- EXPECT_EQ(0, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(0U, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(0U, payload_state.GetUrlSwitchCount());
EXPECT_EQ(1, payload_state.GetNumResponsesSeen());
}
@@ -298,7 +298,7 @@
EXPECT_EQ("https://test", payload_state.GetCurrentUrl());
// Verify that we switched URLs three times
- EXPECT_EQ(3, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(3U, payload_state.GetUrlSwitchCount());
}
TEST(PayloadStateTest, NewResponseResetsPayloadState) {
@@ -321,7 +321,7 @@
ErrorCode error = ErrorCode::kDownloadMetadataSignatureMismatch;
payload_state.UpdateFailed(error);
EXPECT_EQ("https://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(1, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(1U, payload_state.GetUrlSwitchCount());
// Now, slightly change the response and set it again.
SetupPayloadStateWith2Urls("Hash8225", true, &payload_state, &response);
@@ -330,7 +330,7 @@
// Fake an error again.
payload_state.UpdateFailed(error);
EXPECT_EQ("https://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(1, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(1U, payload_state.GetUrlSwitchCount());
// Return a third different response.
SetupPayloadStateWith2Urls("Hash9999", true, &payload_state, &response);
@@ -338,15 +338,15 @@
// Make sure the url index was reset to 0 because of the new response.
EXPECT_EQ("http://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(0, payload_state.GetUrlFailureCount());
- EXPECT_EQ(0, payload_state.GetUrlSwitchCount());
- EXPECT_EQ(0,
+ EXPECT_EQ(0U, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(0U, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(0U,
payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer));
- EXPECT_EQ(0,
+ EXPECT_EQ(0U,
payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer));
- EXPECT_EQ(0, payload_state.GetCurrentBytesDownloaded(
- kDownloadSourceHttpsServer));
- EXPECT_EQ(0,
+ EXPECT_EQ(
+ 0U, payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpsServer));
+ EXPECT_EQ(0U,
payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpsServer));
}
@@ -412,24 +412,24 @@
EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
EXPECT_EQ(0, payload_state.GetFullPayloadAttemptNumber());
EXPECT_EQ("https://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(0, payload_state.GetUrlFailureCount());
- EXPECT_EQ(1, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(0U, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(1U, payload_state.GetUrlSwitchCount());
// This should advance the failure count only.
payload_state.UpdateFailed(ErrorCode::kDownloadTransferError);
EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
EXPECT_EQ(0, payload_state.GetFullPayloadAttemptNumber());
EXPECT_EQ("https://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(1, payload_state.GetUrlFailureCount());
- EXPECT_EQ(1, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(1U, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(1U, payload_state.GetUrlSwitchCount());
// This should advance the failure count only.
payload_state.UpdateFailed(ErrorCode::kDownloadTransferError);
EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
EXPECT_EQ(0, payload_state.GetFullPayloadAttemptNumber());
EXPECT_EQ("https://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(2, payload_state.GetUrlFailureCount());
- EXPECT_EQ(1, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(2U, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(1U, payload_state.GetUrlSwitchCount());
// This should advance the URL index as we've reached the
// max failure count and reset the failure count for the new URL index.
@@ -439,8 +439,8 @@
EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber());
EXPECT_EQ(1, payload_state.GetFullPayloadAttemptNumber());
EXPECT_EQ("http://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(0, payload_state.GetUrlFailureCount());
- EXPECT_EQ(2, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(0U, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(2U, payload_state.GetUrlSwitchCount());
EXPECT_TRUE(payload_state.ShouldBackoffDownload());
// This should advance the URL index.
@@ -448,8 +448,8 @@
EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber());
EXPECT_EQ(1, payload_state.GetFullPayloadAttemptNumber());
EXPECT_EQ("https://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(0, payload_state.GetUrlFailureCount());
- EXPECT_EQ(3, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(0U, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(3U, payload_state.GetUrlSwitchCount());
EXPECT_TRUE(payload_state.ShouldBackoffDownload());
// This should advance the URL index and payload attempt number due to
@@ -458,8 +458,8 @@
EXPECT_EQ(2, payload_state.GetPayloadAttemptNumber());
EXPECT_EQ(2, payload_state.GetFullPayloadAttemptNumber());
EXPECT_EQ("http://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(0, payload_state.GetUrlFailureCount());
- EXPECT_EQ(4, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(0U, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(4U, payload_state.GetUrlSwitchCount());
EXPECT_TRUE(payload_state.ShouldBackoffDownload());
// This HTTP error code should only increase the failure count.
@@ -468,8 +468,8 @@
EXPECT_EQ(2, payload_state.GetPayloadAttemptNumber());
EXPECT_EQ(2, payload_state.GetFullPayloadAttemptNumber());
EXPECT_EQ("http://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(1, payload_state.GetUrlFailureCount());
- EXPECT_EQ(4, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(1U, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(4U, payload_state.GetUrlSwitchCount());
EXPECT_TRUE(payload_state.ShouldBackoffDownload());
// And that failure count should be reset when we download some bytes
@@ -478,8 +478,8 @@
EXPECT_EQ(2, payload_state.GetPayloadAttemptNumber());
EXPECT_EQ(2, payload_state.GetFullPayloadAttemptNumber());
EXPECT_EQ("http://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(0, payload_state.GetUrlFailureCount());
- EXPECT_EQ(4, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(0U, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(4U, payload_state.GetUrlSwitchCount());
EXPECT_TRUE(payload_state.ShouldBackoffDownload());
// Now, slightly change the response and set it again.
@@ -490,8 +490,8 @@
EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
EXPECT_EQ(0, payload_state.GetFullPayloadAttemptNumber());
EXPECT_EQ("http://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(0, payload_state.GetUrlFailureCount());
- EXPECT_EQ(0, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(0U, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(0U, payload_state.GetUrlSwitchCount());
EXPECT_FALSE(payload_state.ShouldBackoffDownload());
}
@@ -532,8 +532,8 @@
EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber());
EXPECT_EQ(1, payload_state.GetFullPayloadAttemptNumber());
EXPECT_EQ("http://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(0, payload_state.GetUrlFailureCount());
- EXPECT_EQ(0, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(0U, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(0U, payload_state.GetUrlSwitchCount());
}
TEST(PayloadStateTest, PayloadAttemptNumberIncreasesOnSuccessfulDeltaDownload) {
@@ -572,8 +572,8 @@
EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber());
EXPECT_EQ(0, payload_state.GetFullPayloadAttemptNumber());
EXPECT_EQ("http://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(0, payload_state.GetUrlFailureCount());
- EXPECT_EQ(0, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(0U, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(0U, payload_state.GetUrlSwitchCount());
}
TEST(PayloadStateTest, SetResponseResetsInvalidUrlIndex) {
@@ -592,8 +592,8 @@
EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber());
EXPECT_EQ(1, payload_state.GetFullPayloadAttemptNumber());
EXPECT_EQ("https://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(1, payload_state.GetUrlFailureCount());
- EXPECT_EQ(1, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(1U, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(1U, payload_state.GetUrlSwitchCount());
// Now, simulate a corrupted url index on persisted store which gets
// loaded when update_engine restarts. Using a different prefs object
@@ -625,8 +625,8 @@
EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
EXPECT_EQ(0, payload_state.GetFullPayloadAttemptNumber());
EXPECT_EQ("http://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(0, payload_state.GetUrlFailureCount());
- EXPECT_EQ(0, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(0U, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(0U, payload_state.GetUrlSwitchCount());
}
TEST(PayloadStateTest, NoBackoffInteractiveChecks) {
@@ -780,8 +780,8 @@
response.disable_payload_backoff = true;
PayloadState payload_state;
FakeSystemState fake_system_state;
- int https_total = 0;
- int http_total = 0;
+ uint64_t https_total = 0;
+ uint64_t http_total = 0;
EXPECT_TRUE(payload_state.Initialize(&fake_system_state));
SetupPayloadStateWith2Urls("Hash3286", true, &payload_state, &response);
@@ -789,7 +789,7 @@
// Simulate a previous attempt with in order to set an initial non-zero value
// for the total bytes downloaded for HTTP.
- int prev_chunk = 323456789;
+ uint64_t prev_chunk = 323456789;
http_total += prev_chunk;
payload_state.DownloadProgress(prev_chunk);
@@ -805,7 +805,7 @@
EXPECT_EQ(2, payload_state.GetNumResponsesSeen());
// First, simulate successful download of a few bytes over HTTP.
- int first_chunk = 5000000;
+ uint64_t first_chunk = 5000000;
http_total += first_chunk;
payload_state.DownloadProgress(first_chunk);
// Test that first all progress is made on HTTP and none on HTTPS.
@@ -813,7 +813,7 @@
payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer));
EXPECT_EQ(http_total,
payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer));
- EXPECT_EQ(0, payload_state.GetCurrentBytesDownloaded(
+ EXPECT_EQ(0U, payload_state.GetCurrentBytesDownloaded(
kDownloadSourceHttpsServer));
EXPECT_EQ(https_total,
payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpsServer));
@@ -823,7 +823,7 @@
payload_state.UpdateFailed(error);
// Test that no new progress is made on HTTP and new progress is on HTTPS.
- int second_chunk = 23456789;
+ uint64_t second_chunk = 23456789;
https_total += second_chunk;
payload_state.DownloadProgress(second_chunk);
EXPECT_EQ(first_chunk,
@@ -837,8 +837,8 @@
// Simulate error to go back to http.
payload_state.UpdateFailed(error);
- int third_chunk = 32345678;
- int http_chunk = first_chunk + third_chunk;
+ uint64_t third_chunk = 32345678;
+ uint64_t http_chunk = first_chunk + third_chunk;
http_total += third_chunk;
payload_state.DownloadProgress(third_chunk);
@@ -856,7 +856,7 @@
// then do 42MB worth of progress
payload_state.UpdateFailed(error);
payload_state.SetUsingP2PForDownloading(true);
- int p2p_total = 42 * 1000 * 1000;
+ uint64_t p2p_total = 42 * 1000 * 1000;
payload_state.DownloadProgress(p2p_total);
EXPECT_EQ(p2p_total,
@@ -886,13 +886,13 @@
payload_state.UpdateSucceeded();
// Make sure the metrics are reset after a successful update.
- EXPECT_EQ(0,
+ EXPECT_EQ(0U,
payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer));
- EXPECT_EQ(0,
+ EXPECT_EQ(0U,
payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer));
- EXPECT_EQ(0, payload_state.GetCurrentBytesDownloaded(
+ EXPECT_EQ(0U, payload_state.GetCurrentBytesDownloaded(
kDownloadSourceHttpsServer));
- EXPECT_EQ(0,
+ EXPECT_EQ(0U,
payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpsServer));
EXPECT_EQ(0, payload_state.GetNumResponsesSeen());
}
@@ -906,7 +906,7 @@
SetupPayloadStateWith2Urls("Hash3286", true, &payload_state, &response);
// Simulate progress in order to mark HTTP as one of the sources used.
- int num_bytes = 42 * 1000 * 1000;
+ uint64_t num_bytes = 42 * 1000 * 1000;
payload_state.DownloadProgress(num_bytes);
// Check that this was done via HTTP.
@@ -936,20 +936,20 @@
// Set the first response.
SetupPayloadStateWith2Urls("Hash5823", true, &payload_state, &response);
- int num_bytes = 10000;
+ uint64_t num_bytes = 10000;
payload_state.DownloadProgress(num_bytes);
EXPECT_EQ(num_bytes,
payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer));
EXPECT_EQ(num_bytes,
payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer));
- EXPECT_EQ(0, payload_state.GetCurrentBytesDownloaded(
+ EXPECT_EQ(0U, payload_state.GetCurrentBytesDownloaded(
kDownloadSourceHttpsServer));
- EXPECT_EQ(0,
+ EXPECT_EQ(0U,
payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpsServer));
payload_state.UpdateRestarted();
// Make sure the current bytes downloaded is reset, but not the total bytes.
- EXPECT_EQ(0,
+ EXPECT_EQ(0U,
payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer));
EXPECT_EQ(num_bytes,
payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer));
@@ -966,21 +966,21 @@
EXPECT_TRUE(payload_state.Initialize(&fake_system_state));
payload_state.UpdateRestarted();
- EXPECT_EQ(0, payload_state.GetNumReboots());
+ EXPECT_EQ(0U, payload_state.GetNumReboots());
fake_system_state.set_system_rebooted(true);
payload_state.UpdateResumed();
// Num reboots should be incremented because system rebooted detected.
- EXPECT_EQ(1, payload_state.GetNumReboots());
+ EXPECT_EQ(1U, payload_state.GetNumReboots());
fake_system_state.set_system_rebooted(false);
payload_state.UpdateResumed();
// Num reboots should now be 1 as reboot was not detected.
- EXPECT_EQ(1, payload_state.GetNumReboots());
+ EXPECT_EQ(1U, payload_state.GetNumReboots());
// Restart the update again to verify we set the num of reboots back to 0.
payload_state.UpdateRestarted();
- EXPECT_EQ(0, payload_state.GetNumReboots());
+ EXPECT_EQ(0U, payload_state.GetNumReboots());
}
TEST(PayloadStateTest, RollbackVersion) {
@@ -1267,7 +1267,7 @@
// Check that we still skip the HTTP URL and use only the HTTPS url.
EXPECT_EQ("https://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(0, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(0U, payload_state.GetUrlSwitchCount());
// Now, slightly change the response and set it again.
SetupPayloadStateWith2Urls("Hash2399", false, &payload_state, &response);
@@ -1290,14 +1290,14 @@
// Check that we use the HTTP URL now and the failure count is reset.
EXPECT_EQ("http://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(0, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(0U, payload_state.GetUrlFailureCount());
// Fake a failure and see if we're moving over to the HTTPS url and update
// the URL switch count properly.
payload_state.UpdateFailed(error);
EXPECT_EQ("https://test", payload_state.GetCurrentUrl());
- EXPECT_EQ(1, payload_state.GetUrlSwitchCount());
- EXPECT_EQ(0, payload_state.GetUrlFailureCount());
+ EXPECT_EQ(1U, payload_state.GetUrlSwitchCount());
+ EXPECT_EQ(0U, payload_state.GetUrlFailureCount());
}
TEST(PayloadStateTest, PayloadTypeMetricWhenTypeIsDelta) {
diff --git a/update_attempter_unittest.cc b/update_attempter_unittest.cc
index e77b571..a0977b1 100644
--- a/update_attempter_unittest.cc
+++ b/update_attempter_unittest.cc
@@ -254,7 +254,7 @@
attempter_.ActionCompleted(nullptr, &action, ErrorCode::kSuccess);
EXPECT_EQ(500, attempter_.http_response_code());
EXPECT_EQ(UpdateStatus::IDLE, attempter_.status());
- EXPECT_EQ(234, attempter_.server_dictated_poll_interval_);
+ EXPECT_EQ(234U, attempter_.server_dictated_poll_interval_);
ASSERT_TRUE(attempter_.error_event_.get() == nullptr);
}
@@ -429,9 +429,10 @@
}
EXPECT_EQ(attempter_.response_handler_action_.get(),
attempter_.actions_[1].get());
- DownloadAction* download_action =
- dynamic_cast<DownloadAction*>(attempter_.actions_[4].get());
- ASSERT_NE(nullptr, download_action);
+ AbstractAction* action_4 = attempter_.actions_[4].get();
+ ASSERT_NE(nullptr, action_4);
+ ASSERT_EQ(DownloadAction::StaticType(), action_4->Type());
+ DownloadAction* download_action = static_cast<DownloadAction*>(action_4);
EXPECT_EQ(&attempter_, download_action->delegate());
EXPECT_EQ(UpdateStatus::CHECKING_FOR_UPDATE, attempter_.status());
loop_.BreakLoop();
@@ -501,10 +502,13 @@
EXPECT_EQ(kRollbackActionTypes[i], attempter_.actions_[i]->Type());
}
EXPECT_EQ(UpdateStatus::ATTEMPTING_ROLLBACK, attempter_.status());
+ AbstractAction* action_0 = attempter_.actions_[0].get();
+ ASSERT_NE(nullptr, action_0);
+ ASSERT_EQ(InstallPlanAction::StaticType(), action_0->Type());
InstallPlanAction* install_plan_action =
- dynamic_cast<InstallPlanAction*>(attempter_.actions_[0].get());
+ static_cast<InstallPlanAction*>(action_0);
InstallPlan* install_plan = install_plan_action->install_plan();
- EXPECT_EQ(0, install_plan->partitions.size());
+ EXPECT_EQ(0U, install_plan->partitions.size());
EXPECT_EQ(install_plan->powerwash_required, true);
loop_.BreakLoop();
}
diff --git a/update_engine.gyp b/update_engine.gyp
index c6250af..07e6f6c 100644
--- a/update_engine.gyp
+++ b/update_engine.gyp
@@ -450,8 +450,8 @@
{
'target_name': 'test_http_server',
'type': 'executable',
- 'dependencies': ['libupdate_engine'],
'sources': [
+ 'common/http_common.cc',
'test_http_server.cc',
],
},
diff --git a/update_manager/update_manager_unittest.cc b/update_manager/update_manager_unittest.cc
index 4cc738d..03f1610 100644
--- a/update_manager/update_manager_unittest.cc
+++ b/update_manager/update_manager_unittest.cc
@@ -253,9 +253,9 @@
umut_->AsyncPolicyRequest(callback, &Policy::UpdateCheckAllowed);
// The callback should wait until we run the main loop for it to be executed.
- EXPECT_EQ(0, calls.size());
+ EXPECT_EQ(0U, calls.size());
MessageLoopRunMaxIterations(MessageLoop::current(), 100);
- EXPECT_EQ(1, calls.size());
+ EXPECT_EQ(1U, calls.size());
}
TEST_F(UmUpdateManagerTest, AsyncPolicyRequestTimeoutDoesNotFire) {
@@ -273,14 +273,14 @@
// to the default.
MessageLoopRunMaxIterations(MessageLoop::current(), 100);
EXPECT_EQ(1, num_called);
- ASSERT_EQ(1, calls.size());
+ ASSERT_EQ(1U, calls.size());
EXPECT_EQ(EvalStatus::kSucceeded, calls[0].first);
// Wait for the timeout to expire, run the main loop again, ensure that
// nothing happened.
test_clock_.Advance(TimeDelta::FromSeconds(2));
MessageLoopRunMaxIterations(MessageLoop::current(), 10);
EXPECT_EQ(1, num_called);
- EXPECT_EQ(1, calls.size());
+ EXPECT_EQ(1U, calls.size());
}
TEST_F(UmUpdateManagerTest, AsyncPolicyRequestTimesOut) {
@@ -301,7 +301,7 @@
// was not invoked.
MessageLoopRunMaxIterations(MessageLoop::current(), 100);
EXPECT_EQ(1, num_called);
- EXPECT_EQ(0, calls.size());
+ EXPECT_EQ(0U, calls.size());
// Wait for the expiration timeout to expire, run the main loop again,
// ensure that reevaluation occurred but callback was not invoked (i.e.
// default policy was not consulted).
@@ -310,7 +310,7 @@
TimeDelta::FromSeconds(2));
MessageLoopRunMaxIterations(MessageLoop::current(), 10);
EXPECT_EQ(2, num_called);
- EXPECT_EQ(0, calls.size());
+ EXPECT_EQ(0U, calls.size());
// Wait for reevaluation due to delay to happen, ensure that it occurs and
// that the callback is invoked.
test_clock_.Advance(TimeDelta::FromSeconds(2));
@@ -318,7 +318,7 @@
TimeDelta::FromSeconds(2));
MessageLoopRunMaxIterations(MessageLoop::current(), 10);
EXPECT_EQ(3, num_called);
- ASSERT_EQ(1, calls.size());
+ ASSERT_EQ(1U, calls.size());
EXPECT_EQ(EvalStatus::kSucceeded, calls[0].first);
}
diff --git a/update_manager/variable_unittest.cc b/update_manager/variable_unittest.cc
index 13cceb1..144002a 100644
--- a/update_manager/variable_unittest.cc
+++ b/update_manager/variable_unittest.cc
@@ -99,13 +99,13 @@
DefaultVariable<int> var("var", kVariableModeAsync);
BaseVariableObserver observer;
var.AddObserver(&observer);
- EXPECT_EQ(var.observer_list_.size(), 1);
+ EXPECT_EQ(1U, var.observer_list_.size());
var.AddObserver(&observer);
- EXPECT_EQ(var.observer_list_.size(), 1);
+ EXPECT_EQ(1U, var.observer_list_.size());
var.RemoveObserver(&observer);
- EXPECT_EQ(var.observer_list_.size(), 0);
+ EXPECT_EQ(0U, var.observer_list_.size());
var.RemoveObserver(&observer);
- EXPECT_EQ(var.observer_list_.size(), 0);
+ EXPECT_EQ(0U, var.observer_list_.size());
}
TEST_F(UmBaseVariableTest, NotifyValueChangedTest) {
@@ -114,10 +114,10 @@
var.AddObserver(&observer1);
// Simulate a value change on the variable's implementation.
var.NotifyValueChanged();
- ASSERT_EQ(0, observer1.calls_.size());
+ ASSERT_EQ(0U, observer1.calls_.size());
MessageLoopRunMaxIterations(MessageLoop::current(), 100);
- ASSERT_EQ(1, observer1.calls_.size());
+ ASSERT_EQ(1U, observer1.calls_.size());
// Check that the observer is called with the right argument.
EXPECT_EQ(&var, observer1.calls_[0]);
@@ -127,8 +127,8 @@
MessageLoopRunMaxIterations(MessageLoop::current(), 100);
// Check that all the observers are called.
- EXPECT_EQ(2, observer1.calls_.size());
- EXPECT_EQ(1, observer2.calls_.size());
+ EXPECT_EQ(2U, observer1.calls_.size());
+ EXPECT_EQ(1U, observer2.calls_.size());
var.RemoveObserver(&observer1);
var.RemoveObserver(&observer2);