From 0bdf9f7316a2a2d5677e82115ce7746a881a47be Mon Sep 17 00:00:00 2001 From: Ben Chan Date: Mon, 16 Sep 2019 12:59:12 -0700 Subject: libbrillo: migrate to generalized MOCK_METHOD() macro This CL replaces the uses of MOCK_METHOD*() and MOCK_CONST_METHOD*() macros in unit tests with the generalized MOCK_METHOD() macro, which is now the recommended way to define mocked methods with gmock. In particular, MOCK_METHOD() supports annotating a mocked method with specifiers such as 'override'. One minor change is that argument names are omitted in the argument list provided to MOCK_METHOD() in order to prevent clang-format from formatting code like `Foo* foo` into `Foo * foo`. BUG=None TEST=Run unit tests. Change-Id: Ifcae4d820406d56654d68dceea99f0521e2ba134 Reviewed-on: https://chromium-review.googlesource.com/1807266 Tested-by: Ben Chan Commit-Ready: ChromeOS CL Exonerator Bot Legacy-Commit-Queue: Commit Bot Reviewed-by: Eric Caruso Cr-Mirrored-From: https://chromium.googlesource.com/chromiumos/platform2 Cr-Mirrored-Commit: 74aed1c0ae0cfc3e32323a7a5514afb52f2ff38d --- brillo/dbus/async_event_sequencer_test.cc | 2 +- brillo/dbus/dbus_signal_handler_test.cc | 12 +-- brillo/dbus/exported_property_set_test.cc | 3 +- brillo/dbus/mock_dbus_object.h | 6 +- brillo/dbus/mock_exported_object_manager.h | 20 ++--- brillo/http/http_proxy_test.cc | 4 +- brillo/http/mock_connection.h | 27 ++++--- brillo/http/mock_curl_api.h | 89 ++++++++++++++------- brillo/http/mock_transport.h | 47 ++++++----- brillo/message_loops/mock_message_loop.h | 23 +++--- brillo/minijail/mock_minijail.h | 80 +++++++++---------- brillo/process_mock.h | 46 +++++------ brillo/streams/file_stream_test.cc | 31 ++++---- brillo/streams/memory_containers_test.cc | 22 ++++-- brillo/streams/memory_stream_test.cc | 16 ++-- brillo/streams/mock_stream.h | 113 ++++++++++++++++---------- brillo/streams/stream_test.cc | 57 ++++++++----- brillo/udev/mock_udev.h | 27 ++++--- brillo/udev/mock_udev_device.h | 63 +++++++++------ brillo/udev/mock_udev_enumerate.h | 35 ++++---- brillo/udev/mock_udev_list_entry.h | 12 +-- brillo/udev/mock_udev_monitor.h | 20 ++--- policy/mock_device_policy.h | 123 +++++++++++++++-------------- policy/mock_libpolicy.h | 8 +- 24 files changed, 515 insertions(+), 371 deletions(-) diff --git a/brillo/dbus/async_event_sequencer_test.cc b/brillo/dbus/async_event_sequencer_test.cc index 5f4c0e2..a3a21ba 100644 --- a/brillo/dbus/async_event_sequencer_test.cc +++ b/brillo/dbus/async_event_sequencer_test.cc @@ -22,7 +22,7 @@ const char kTestMethod2[] = "TestMethod2"; class AsyncEventSequencerTest : public ::testing::Test { public: - MOCK_METHOD1(HandleCompletion, void(bool all_succeeded)); + MOCK_METHOD(void, HandleCompletion, (bool)); void SetUp() { aec_ = new AsyncEventSequencer(); diff --git a/brillo/dbus/dbus_signal_handler_test.cc b/brillo/dbus/dbus_signal_handler_test.cc index d31c56a..a2b7a4c 100644 --- a/brillo/dbus/dbus_signal_handler_test.cc +++ b/brillo/dbus/dbus_signal_handler_test.cc @@ -80,7 +80,7 @@ TEST_F(DBusSignalHandlerTest, ConnectToSignal) { TEST_F(DBusSignalHandlerTest, CallSignal_3Args) { class SignalHandlerSink { public: - MOCK_METHOD3(Handler, void(int, int, double)); + MOCK_METHOD(void, Handler, (int, int, double)); } sink; EXPECT_CALL(sink, Handler(10, 20, 30.5)).Times(1); @@ -91,7 +91,7 @@ TEST_F(DBusSignalHandlerTest, CallSignal_2Args) { class SignalHandlerSink { public: // Take string both by reference and by value to make sure this works too. - MOCK_METHOD2(Handler, void(const std::string&, std::string)); + MOCK_METHOD(void, Handler, (const std::string&, std::string)); } sink; EXPECT_CALL(sink, Handler(std::string{"foo"}, std::string{"bar"})).Times(1); @@ -101,7 +101,7 @@ TEST_F(DBusSignalHandlerTest, CallSignal_2Args) { TEST_F(DBusSignalHandlerTest, CallSignal_NoArgs) { class SignalHandlerSink { public: - MOCK_METHOD0(Handler, void()); + MOCK_METHOD(void, Handler, ()); } sink; EXPECT_CALL(sink, Handler()).Times(1); @@ -111,7 +111,7 @@ TEST_F(DBusSignalHandlerTest, CallSignal_NoArgs) { TEST_F(DBusSignalHandlerTest, CallSignal_Error_TooManyArgs) { class SignalHandlerSink { public: - MOCK_METHOD0(Handler, void()); + MOCK_METHOD(void, Handler, ()); } sink; // Handler() expects no args, but we send an int. @@ -122,7 +122,7 @@ TEST_F(DBusSignalHandlerTest, CallSignal_Error_TooManyArgs) { TEST_F(DBusSignalHandlerTest, CallSignal_Error_TooFewArgs) { class SignalHandlerSink { public: - MOCK_METHOD2(Handler, void(std::string, bool)); + MOCK_METHOD(void, Handler, (std::string, bool)); } sink; // Handler() expects 2 args while we send it just one. @@ -133,7 +133,7 @@ TEST_F(DBusSignalHandlerTest, CallSignal_Error_TooFewArgs) { TEST_F(DBusSignalHandlerTest, CallSignal_Error_TypeMismatchArgs) { class SignalHandlerSink { public: - MOCK_METHOD2(Handler, void(std::string, bool)); + MOCK_METHOD(void, Handler, (std::string, bool)); } sink; // Handler() expects "sb" while we send it "ii". diff --git a/brillo/dbus/exported_property_set_test.cc b/brillo/dbus/exported_property_set_test.cc index 93aceb4..6f9dbd7 100644 --- a/brillo/dbus/exported_property_set_test.cc +++ b/brillo/dbus/exported_property_set_test.cc @@ -177,8 +177,7 @@ class PropertyValidatorObserver { base::Unretained(this))) {} virtual ~PropertyValidatorObserver() {} - MOCK_METHOD2_T(ValidateProperty, - bool(brillo::ErrorPtr* error, const T& value)); + MOCK_METHOD(bool, ValidateProperty, (brillo::ErrorPtr*, const T&)); const base::Callback& validate_property_callback() const { diff --git a/brillo/dbus/mock_dbus_object.h b/brillo/dbus/mock_dbus_object.h index 4bc1c2f..d65f9ab 100644 --- a/brillo/dbus/mock_dbus_object.h +++ b/brillo/dbus/mock_dbus_object.h @@ -22,8 +22,10 @@ class MockDBusObject : public DBusObject { : DBusObject(object_manager, bus, object_path) {} ~MockDBusObject() override = default; - MOCK_METHOD1(RegisterAsync, - void(const AsyncEventSequencer::CompletionAction&)); + MOCK_METHOD(void, + RegisterAsync, + (const AsyncEventSequencer::CompletionAction&), + (override)); }; // class MockDBusObject } // namespace dbus_utils diff --git a/brillo/dbus/mock_exported_object_manager.h b/brillo/dbus/mock_exported_object_manager.h index bf67996..02bb073 100644 --- a/brillo/dbus/mock_exported_object_manager.h +++ b/brillo/dbus/mock_exported_object_manager.h @@ -24,15 +24,17 @@ class MockExportedObjectManager : public ExportedObjectManager { using ExportedObjectManager::ExportedObjectManager; ~MockExportedObjectManager() override = default; - MOCK_METHOD1(RegisterAsync, - void(const CompletionAction& completion_callback)); - MOCK_METHOD3(ClaimInterface, - void(const ::dbus::ObjectPath& path, - const std::string& interface_name, - const ExportedPropertySet::PropertyWriter& writer)); - MOCK_METHOD2(ReleaseInterface, - void(const ::dbus::ObjectPath& path, - const std::string& interface_name)); + MOCK_METHOD(void, RegisterAsync, (const CompletionAction&), (override)); + MOCK_METHOD(void, + ClaimInterface, + (const ::dbus::ObjectPath&, + const std::string&, + const ExportedPropertySet::PropertyWriter&), + (override)); + MOCK_METHOD(void, + ReleaseInterface, + (const ::dbus::ObjectPath&, const std::string&), + (override)); }; } // namespace dbus_utils diff --git a/brillo/http/http_proxy_test.cc b/brillo/http/http_proxy_test.cc index a880003..d921a27 100644 --- a/brillo/http/http_proxy_test.cc +++ b/brillo/http/http_proxy_test.cc @@ -49,7 +49,9 @@ class HttpProxyTest : public testing::Test { return CreateDBusResponse(method_call).release(); } - MOCK_METHOD2(GetProxiesCallback, void(bool, const std::vector&)); + MOCK_METHOD(void, + GetProxiesCallback, + (bool, const std::vector&)); protected: HttpProxyTest() { diff --git a/brillo/http/mock_connection.h b/brillo/http/mock_connection.h index 0796a7e..1810824 100644 --- a/brillo/http/mock_connection.h +++ b/brillo/http/mock_connection.h @@ -19,17 +19,22 @@ class MockConnection : public Connection { public: using Connection::Connection; - MOCK_METHOD2(SendHeaders, bool(const HeaderList&, ErrorPtr*)); - MOCK_METHOD2(MockSetRequestData, bool(Stream*, ErrorPtr*)); - MOCK_METHOD1(MockSetResponseData, void(Stream*)); - MOCK_METHOD1(FinishRequest, bool(ErrorPtr*)); - MOCK_METHOD2(FinishRequestAsync, - RequestID(const SuccessCallback&, const ErrorCallback&)); - MOCK_CONST_METHOD0(GetResponseStatusCode, int()); - MOCK_CONST_METHOD0(GetResponseStatusText, std::string()); - MOCK_CONST_METHOD0(GetProtocolVersion, std::string()); - MOCK_CONST_METHOD1(GetResponseHeader, std::string(const std::string&)); - MOCK_CONST_METHOD1(MockExtractDataStream, Stream*(brillo::ErrorPtr*)); + MOCK_METHOD(bool, SendHeaders, (const HeaderList&, ErrorPtr*), (override)); + MOCK_METHOD(bool, MockSetRequestData, (Stream*, ErrorPtr*)); + MOCK_METHOD(void, MockSetResponseData, (Stream*)); + MOCK_METHOD(bool, FinishRequest, (ErrorPtr*), (override)); + MOCK_METHOD(RequestID, + FinishRequestAsync, + (const SuccessCallback&, const ErrorCallback&), + (override)); + MOCK_METHOD(int, GetResponseStatusCode, (), (const, override)); + MOCK_METHOD(std::string, GetResponseStatusText, (), (const, override)); + MOCK_METHOD(std::string, GetProtocolVersion, (), (const, override)); + MOCK_METHOD(std::string, + GetResponseHeader, + (const std::string&), + (const, override)); + MOCK_METHOD(Stream*, MockExtractDataStream, (brillo::ErrorPtr*), (const)); private: bool SetRequestData(StreamPtr stream, brillo::ErrorPtr* error) override { diff --git a/brillo/http/mock_curl_api.h b/brillo/http/mock_curl_api.h index 32b6e0d..daac8c2 100644 --- a/brillo/http/mock_curl_api.h +++ b/brillo/http/mock_curl_api.h @@ -20,34 +20,67 @@ class MockCurlInterface : public CurlInterface { public: MockCurlInterface() = default; - MOCK_METHOD0(EasyInit, CURL*()); - MOCK_METHOD1(EasyCleanup, void(CURL*)); - MOCK_METHOD3(EasySetOptInt, CURLcode(CURL*, CURLoption, int)); - MOCK_METHOD3(EasySetOptStr, CURLcode(CURL*, CURLoption, const std::string&)); - MOCK_METHOD3(EasySetOptPtr, CURLcode(CURL*, CURLoption, void*)); - MOCK_METHOD3(EasySetOptCallback, CURLcode(CURL*, CURLoption, intptr_t)); - MOCK_METHOD3(EasySetOptOffT, CURLcode(CURL*, CURLoption, curl_off_t)); - MOCK_METHOD1(EasyPerform, CURLcode(CURL*)); - MOCK_CONST_METHOD3(EasyGetInfoInt, CURLcode(CURL*, CURLINFO, int*)); - MOCK_CONST_METHOD3(EasyGetInfoDbl, CURLcode(CURL*, CURLINFO, double*)); - MOCK_CONST_METHOD3(EasyGetInfoStr, CURLcode(CURL*, CURLINFO, std::string*)); - MOCK_CONST_METHOD3(EasyGetInfoPtr, CURLcode(CURL*, CURLINFO, void**)); - MOCK_CONST_METHOD1(EasyStrError, std::string(CURLcode)); - MOCK_METHOD0(MultiInit, CURLM*()); - MOCK_METHOD1(MultiCleanup, CURLMcode(CURLM*)); - MOCK_METHOD2(MultiInfoRead, CURLMsg*(CURLM*, int*)); - MOCK_METHOD2(MultiAddHandle, CURLMcode(CURLM*, CURL*)); - MOCK_METHOD2(MultiRemoveHandle, CURLMcode(CURLM*, CURL*)); - MOCK_METHOD3(MultiSetSocketCallback, - CURLMcode(CURLM*, curl_socket_callback, void*)); - MOCK_METHOD3(MultiSetTimerCallback, - CURLMcode(CURLM*, curl_multi_timer_callback, void*)); - MOCK_METHOD3(MultiAssign, CURLMcode(CURLM*, curl_socket_t, void*)); - MOCK_METHOD4(MultiSocketAction, CURLMcode(CURLM*, curl_socket_t, int, int*)); - MOCK_CONST_METHOD1(MultiStrError, std::string(CURLMcode)); - MOCK_METHOD2(MultiPerform, CURLMcode(CURLM*, int*)); - MOCK_METHOD5(MultiWait, - CURLMcode(CURLM*, curl_waitfd[], unsigned int, int, int*)); + MOCK_METHOD(CURL*, EasyInit, (), (override)); + MOCK_METHOD(void, EasyCleanup, (CURL*), (override)); + MOCK_METHOD(CURLcode, EasySetOptInt, (CURL*, CURLoption, int), (override)); + MOCK_METHOD(CURLcode, + EasySetOptStr, + (CURL*, CURLoption, const std::string&), + (override)); + MOCK_METHOD(CURLcode, EasySetOptPtr, (CURL*, CURLoption, void*), (override)); + MOCK_METHOD(CURLcode, + EasySetOptCallback, + (CURL*, CURLoption, intptr_t), + (override)); + MOCK_METHOD(CURLcode, + EasySetOptOffT, + (CURL*, CURLoption, curl_off_t), + (override)); + MOCK_METHOD(CURLcode, EasyPerform, (CURL*), (override)); + MOCK_METHOD(CURLcode, + EasyGetInfoInt, + (CURL*, CURLINFO, int*), + (const, override)); + MOCK_METHOD(CURLcode, + EasyGetInfoDbl, + (CURL*, CURLINFO, double*), + (const, override)); + MOCK_METHOD(CURLcode, + EasyGetInfoStr, + (CURL*, CURLINFO, std::string*), + (const, override)); + MOCK_METHOD(CURLcode, + EasyGetInfoPtr, + (CURL*, CURLINFO, void**), + (const, override)); + MOCK_METHOD(std::string, EasyStrError, (CURLcode), (const, override)); + MOCK_METHOD(CURLM*, MultiInit, (), (override)); + MOCK_METHOD(CURLMcode, MultiCleanup, (CURLM*), (override)); + MOCK_METHOD(CURLMsg*, MultiInfoRead, (CURLM*, int*), (override)); + MOCK_METHOD(CURLMcode, MultiAddHandle, (CURLM*, CURL*), (override)); + MOCK_METHOD(CURLMcode, MultiRemoveHandle, (CURLM*, CURL*), (override)); + MOCK_METHOD(CURLMcode, + MultiSetSocketCallback, + (CURLM*, curl_socket_callback, void*), + (override)); + MOCK_METHOD(CURLMcode, + MultiSetTimerCallback, + (CURLM*, curl_multi_timer_callback, void*), + (override)); + MOCK_METHOD(CURLMcode, + MultiAssign, + (CURLM*, curl_socket_t, void*), + (override)); + MOCK_METHOD(CURLMcode, + MultiSocketAction, + (CURLM*, curl_socket_t, int, int*), + (override)); + MOCK_METHOD(std::string, MultiStrError, (CURLMcode), (const, override)); + MOCK_METHOD(CURLMcode, MultiPerform, (CURLM*, int*), (override)); + MOCK_METHOD(CURLMcode, + MultiWait, + (CURLM*, curl_waitfd[], unsigned int, int, int*), + (override)); private: DISALLOW_COPY_AND_ASSIGN(MockCurlInterface); diff --git a/brillo/http/mock_transport.h b/brillo/http/mock_transport.h index dfb02c7..a9f5d46 100644 --- a/brillo/http/mock_transport.h +++ b/brillo/http/mock_transport.h @@ -20,28 +20,35 @@ class MockTransport : public Transport { public: MockTransport() = default; - MOCK_METHOD6(CreateConnection, - std::shared_ptr(const std::string&, - const std::string&, - const HeaderList&, - const std::string&, - const std::string&, - brillo::ErrorPtr*)); - MOCK_METHOD2(RunCallbackAsync, - void(const base::Location&, const base::Closure&)); - MOCK_METHOD3(StartAsyncTransfer, RequestID(Connection*, - const SuccessCallback&, - const ErrorCallback&)); - MOCK_METHOD1(CancelRequest, bool(RequestID)); - MOCK_METHOD1(SetDefaultTimeout, void(base::TimeDelta)); - MOCK_METHOD1(SetLocalIpAddress, void(const std::string&)); - MOCK_METHOD0(UseDefaultCertificate, void()); - MOCK_METHOD1(UseCustomCertificate, void(Certificate)); - MOCK_METHOD3(ResolveHostToIp, - void(const std::string&, uint16_t, const std::string&)); + MOCK_METHOD(std::shared_ptr, + CreateConnection, + (const std::string&, + const std::string&, + const HeaderList&, + const std::string&, + const std::string&, + brillo::ErrorPtr*), + (override)); + MOCK_METHOD(void, + RunCallbackAsync, + (const base::Location&, const base::Closure&), + (override)); + MOCK_METHOD(RequestID, + StartAsyncTransfer, + (Connection*, const SuccessCallback&, const ErrorCallback&), + (override)); + MOCK_METHOD(bool, CancelRequest, (RequestID), (override)); + MOCK_METHOD(void, SetDefaultTimeout, (base::TimeDelta), (override)); + MOCK_METHOD(void, SetLocalIpAddress, (const std::string&), (override)); + MOCK_METHOD(void, UseDefaultCertificate, (), (override)); + MOCK_METHOD(void, UseCustomCertificate, (Certificate), (override)); + MOCK_METHOD(void, + ResolveHostToIp, + (const std::string&, uint16_t, const std::string&), + (override)); protected: - MOCK_METHOD0(ClearHost, void()); + MOCK_METHOD(void, ClearHost, (), (override)); private: DISALLOW_COPY_AND_ASSIGN(MockTransport); diff --git a/brillo/message_loops/mock_message_loop.h b/brillo/message_loops/mock_message_loop.h index 9f9a1e4..c84e585 100644 --- a/brillo/message_loops/mock_message_loop.h +++ b/brillo/message_loops/mock_message_loop.h @@ -57,20 +57,19 @@ class BRILLO_EXPORT MockMessageLoop : public MessageLoop { } ~MockMessageLoop() override = default; - MOCK_METHOD3(PostDelayedTask, - TaskId(const base::Location& from_here, - const base::Closure& task, - base::TimeDelta delay)); + MOCK_METHOD(TaskId, + PostDelayedTask, + (const base::Location&, const base::Closure&, base::TimeDelta), + (override)); using MessageLoop::PostDelayedTask; - MOCK_METHOD5(WatchFileDescriptor, - TaskId(const base::Location& from_here, - int fd, - WatchMode mode, - bool persistent, - const base::Closure& task)); + MOCK_METHOD( + TaskId, + WatchFileDescriptor, + (const base::Location&, int, WatchMode, bool, const base::Closure&), + (override)); using MessageLoop::WatchFileDescriptor; - MOCK_METHOD1(CancelTask, bool(TaskId task_id)); - MOCK_METHOD1(RunOnce, bool(bool may_block)); + MOCK_METHOD(bool, CancelTask, (TaskId), (override)); + MOCK_METHOD(bool, RunOnce, (bool), (override)); // Returns the actual FakeMessageLoop instance so default actions can be // override with other actions or call diff --git a/brillo/minijail/mock_minijail.h b/brillo/minijail/mock_minijail.h index 82b1efe..6c95405 100644 --- a/brillo/minijail/mock_minijail.h +++ b/brillo/minijail/mock_minijail.h @@ -19,48 +19,46 @@ class MockMinijail : public brillo::Minijail { MockMinijail() {} virtual ~MockMinijail() {} - MOCK_METHOD0(New, struct minijail*()); - MOCK_METHOD1(Destroy, void(struct minijail*)); + MOCK_METHOD(struct minijail*, New, (), (override)); + MOCK_METHOD(void, Destroy, (struct minijail*), (override)); - MOCK_METHOD3(DropRoot, - bool(struct minijail* jail, - const char* user, - const char* group)); - MOCK_METHOD2(UseSeccompFilter, void(struct minijail* jail, const char* path)); - MOCK_METHOD2(UseCapabilities, void(struct minijail* jail, uint64_t capmask)); - MOCK_METHOD1(ResetSignalMask, void(struct minijail* jail)); - MOCK_METHOD1(CloseOpenFds, void(struct minijail* jail)); - MOCK_METHOD3(PreserveFd, - void(struct minijail* jail, int parent_fd, int child_fd)); - MOCK_METHOD1(Enter, void(struct minijail* jail)); - MOCK_METHOD3(Run, - bool(struct minijail* jail, - std::vector args, - pid_t* pid)); - MOCK_METHOD3(RunSync, - bool(struct minijail* jail, - std::vector args, - int* status)); - MOCK_METHOD3(RunAndDestroy, - bool(struct minijail* jail, - std::vector args, - pid_t* pid)); - MOCK_METHOD3(RunSyncAndDestroy, - bool(struct minijail* jail, - std::vector args, - int* status)); - MOCK_METHOD4(RunPipeAndDestroy, - bool(struct minijail* jail, - std::vector args, - pid_t* pid, - int* stdin)); - MOCK_METHOD6(RunPipesAndDestroy, - bool(struct minijail* jail, - std::vector args, - pid_t* pid, - int* stdin, - int* stdout, - int* stderr)); + MOCK_METHOD(bool, + DropRoot, + (struct minijail*, const char*, const char*), + (override)); + MOCK_METHOD(void, + UseSeccompFilter, + (struct minijail*, const char*), + (override)); + MOCK_METHOD(void, UseCapabilities, (struct minijail*, uint64_t), (override)); + MOCK_METHOD(void, ResetSignalMask, (struct minijail*), (override)); + MOCK_METHOD(void, CloseOpenFds, (struct minijail*), (override)); + MOCK_METHOD(void, PreserveFd, (struct minijail*, int, int), (override)); + MOCK_METHOD(void, Enter, (struct minijail*), (override)); + MOCK_METHOD(bool, + Run, + (struct minijail*, std::vector, pid_t*), + (override)); + MOCK_METHOD(bool, + RunSync, + (struct minijail*, std::vector, int*), + (override)); + MOCK_METHOD(bool, + RunAndDestroy, + (struct minijail*, std::vector, pid_t*), + (override)); + MOCK_METHOD(bool, + RunSyncAndDestroy, + (struct minijail*, std::vector, int*), + (override)); + MOCK_METHOD(bool, + RunPipeAndDestroy, + (struct minijail*, std::vector, pid_t*, int*), + (override)); + MOCK_METHOD(bool, + RunPipesAndDestroy, + (struct minijail*, std::vector, pid_t*, int*, int*, int*), + (override)); private: DISALLOW_COPY_AND_ASSIGN(MockMinijail); diff --git a/brillo/process_mock.h b/brillo/process_mock.h index 92ffa0a..cc33681 100644 --- a/brillo/process_mock.h +++ b/brillo/process_mock.h @@ -19,29 +19,29 @@ class ProcessMock : public Process { ProcessMock() {} virtual ~ProcessMock() {} - MOCK_METHOD1(AddArg, void(const std::string& arg)); - MOCK_METHOD1(RedirectInput, void(const std::string& input_file)); - MOCK_METHOD1(RedirectOutput, void(const std::string& output_file)); - MOCK_METHOD2(RedirectUsingPipe, void(int child_fd, bool is_input)); - MOCK_METHOD2(BindFd, void(int parent_fd, int child_fd)); - MOCK_METHOD1(SetUid, void(uid_t)); - MOCK_METHOD1(SetGid, void(gid_t)); - MOCK_METHOD1(SetCapabilities, void(uint64_t capmask)); - MOCK_METHOD1(ApplySyscallFilter, void(const std::string& path)); - MOCK_METHOD0(EnterNewPidNamespace, void()); - MOCK_METHOD1(SetInheritParentSignalMask, void(bool)); - MOCK_METHOD1(SetPreExecCallback, void(const PreExecCallback&)); - MOCK_METHOD1(SetSearchPath, void(bool)); - MOCK_METHOD1(GetPipe, int(int child_fd)); - MOCK_METHOD0(Start, bool()); - MOCK_METHOD0(Wait, int()); - MOCK_METHOD0(Run, int()); - MOCK_METHOD0(pid, pid_t()); - MOCK_METHOD2(Kill, bool(int signal, int timeout)); - MOCK_METHOD1(Reset, void(pid_t)); - MOCK_METHOD1(ResetPidByFile, bool(const std::string& pid_file)); - MOCK_METHOD0(Release, pid_t()); - MOCK_METHOD1(SetCloseUnusedFileDescriptors, void(bool close_unused_fds)); + MOCK_METHOD(void, AddArg, (const std::string&), (override)); + MOCK_METHOD(void, RedirectInput, (const std::string&), (override)); + MOCK_METHOD(void, RedirectOutput, (const std::string&), (override)); + MOCK_METHOD(void, RedirectUsingPipe, (int, bool), (override)); + MOCK_METHOD(void, BindFd, (int, int), (override)); + MOCK_METHOD(void, SetUid, (uid_t), (override)); + MOCK_METHOD(void, SetGid, (gid_t), (override)); + MOCK_METHOD(void, SetCapabilities, (uint64_t), (override)); + MOCK_METHOD(void, ApplySyscallFilter, (const std::string&), (override)); + MOCK_METHOD(void, EnterNewPidNamespace, (), (override)); + MOCK_METHOD(void, SetInheritParentSignalMask, (bool), (override)); + MOCK_METHOD(void, SetPreExecCallback, (const PreExecCallback&), (override)); + MOCK_METHOD(void, SetSearchPath, (bool), (override)); + MOCK_METHOD(int, GetPipe, (int), (override)); + MOCK_METHOD(bool, Start, (), (override)); + MOCK_METHOD(int, Wait, (), (override)); + MOCK_METHOD(int, Run, (), (override)); + MOCK_METHOD(pid_t, pid, (), (override)); + MOCK_METHOD(bool, Kill, (int, int), (override)); + MOCK_METHOD(void, Reset, (pid_t), (override)); + MOCK_METHOD(bool, ResetPidByFile, (const std::string&), (override)); + MOCK_METHOD(pid_t, Release, (), (override)); + MOCK_METHOD(void, SetCloseUnusedFileDescriptors, (bool), (override)); }; } // namespace brillo diff --git a/brillo/streams/file_stream_test.cc b/brillo/streams/file_stream_test.cc index b386aef..593b1f7 100644 --- a/brillo/streams/file_stream_test.cc +++ b/brillo/streams/file_stream_test.cc @@ -132,20 +132,23 @@ void SetToTrue(bool* target, const Error* /* error */) { // A mock file descriptor wrapper to test low-level file API used by FileStream. class MockFileDescriptor : public FileStream::FileDescriptorInterface { public: - MOCK_CONST_METHOD0(IsOpen, bool()); - MOCK_METHOD2(Read, ssize_t(void*, size_t)); - MOCK_METHOD2(Write, ssize_t(const void*, size_t)); - MOCK_METHOD2(Seek, off64_t(off64_t, int)); - MOCK_CONST_METHOD0(GetFileMode, mode_t()); - MOCK_CONST_METHOD0(GetSize, uint64_t()); - MOCK_CONST_METHOD1(Truncate, int(off64_t)); - MOCK_METHOD0(Flush, int()); - MOCK_METHOD0(Close, int()); - MOCK_METHOD3(WaitForData, - bool(Stream::AccessMode, const DataCallback&, ErrorPtr*)); - MOCK_METHOD3(WaitForDataBlocking, - int(Stream::AccessMode, base::TimeDelta, Stream::AccessMode*)); - MOCK_METHOD0(CancelPendingAsyncOperations, void()); + MOCK_METHOD(bool, IsOpen, (), (const, override)); + MOCK_METHOD(ssize_t, Read, (void*, size_t), (override)); + MOCK_METHOD(ssize_t, Write, (const void*, size_t), (override)); + MOCK_METHOD(off64_t, Seek, (off64_t, int), (override)); + MOCK_METHOD(mode_t, GetFileMode, (), (const, override)); + MOCK_METHOD(uint64_t, GetSize, (), (const, override)); + MOCK_METHOD(int, Truncate, (off64_t), (const, override)); + MOCK_METHOD(int, Close, (), (override)); + MOCK_METHOD(bool, + WaitForData, + (Stream::AccessMode, const DataCallback&, ErrorPtr*), + (override)); + MOCK_METHOD(int, + WaitForDataBlocking, + (Stream::AccessMode, base::TimeDelta, Stream::AccessMode*), + (override)); + MOCK_METHOD(void, CancelPendingAsyncOperations, (), (override)); }; class FileStreamTest : public testing::Test { diff --git a/brillo/streams/memory_containers_test.cc b/brillo/streams/memory_containers_test.cc index 2f0bf38..8b56ade 100644 --- a/brillo/streams/memory_containers_test.cc +++ b/brillo/streams/memory_containers_test.cc @@ -26,14 +26,20 @@ class MockContiguousBuffer : public data_container::ContiguousBufferBase { public: MockContiguousBuffer() = default; - MOCK_METHOD2(Resize, bool(size_t, ErrorPtr*)); - MOCK_CONST_METHOD0(GetSize, size_t()); - MOCK_CONST_METHOD0(IsReadOnly, bool()); - - MOCK_CONST_METHOD2(GetReadOnlyBuffer, const void*(size_t, ErrorPtr*)); - MOCK_METHOD2(GetBuffer, void*(size_t, ErrorPtr*)); - - MOCK_CONST_METHOD3(CopyMemoryBlock, void(void*, const void*, size_t)); + MOCK_METHOD(bool, Resize, (size_t, ErrorPtr*), (override)); + MOCK_METHOD(size_t, GetSize, (), (const, override)); + MOCK_METHOD(bool, IsReadOnly, (), (const, override)); + + MOCK_METHOD(const void*, + GetReadOnlyBuffer, + (size_t, ErrorPtr*), + (const, override)); + MOCK_METHOD(void*, GetBuffer, (size_t, ErrorPtr*), (override)); + + MOCK_METHOD(void, + CopyMemoryBlock, + (void*, const void*, size_t), + (const, override)); private: DISALLOW_COPY_AND_ASSIGN(MockContiguousBuffer); diff --git a/brillo/streams/memory_stream_test.cc b/brillo/streams/memory_stream_test.cc index a9d1cfa..28a88fa 100644 --- a/brillo/streams/memory_stream_test.cc +++ b/brillo/streams/memory_stream_test.cc @@ -33,11 +33,17 @@ class MockMemoryContainer : public data_container::DataContainerInterface { public: MockMemoryContainer() = default; - MOCK_METHOD5(Read, bool(void*, size_t, size_t, size_t*, ErrorPtr*)); - MOCK_METHOD5(Write, bool(const void*, size_t, size_t, size_t*, ErrorPtr*)); - MOCK_METHOD2(Resize, bool(size_t, ErrorPtr*)); - MOCK_CONST_METHOD0(GetSize, size_t()); - MOCK_CONST_METHOD0(IsReadOnly, bool()); + MOCK_METHOD(bool, + Read, + (void*, size_t, size_t, size_t*, ErrorPtr*), + (override)); + MOCK_METHOD(bool, + Write, + (const void*, size_t, size_t, size_t*, ErrorPtr*), + (override)); + MOCK_METHOD(bool, Resize, (size_t, ErrorPtr*), (override)); + MOCK_METHOD(size_t, GetSize, (), (const, override)); + MOCK_METHOD(bool, IsReadOnly, (), (const, override)); private: DISALLOW_COPY_AND_ASSIGN(MockMemoryContainer); diff --git a/brillo/streams/mock_stream.h b/brillo/streams/mock_stream.h index 934912a..45f83ed 100644 --- a/brillo/streams/mock_stream.h +++ b/brillo/streams/mock_stream.h @@ -16,55 +16,82 @@ class MockStream : public Stream { public: MockStream() = default; - MOCK_CONST_METHOD0(IsOpen, bool()); - MOCK_CONST_METHOD0(CanRead, bool()); - MOCK_CONST_METHOD0(CanWrite, bool()); - MOCK_CONST_METHOD0(CanSeek, bool()); - MOCK_CONST_METHOD0(CanGetSize, bool()); + MOCK_METHOD(bool, IsOpen, (), (const, override)); + MOCK_METHOD(bool, CanRead, (), (const, override)); + MOCK_METHOD(bool, CanWrite, (), (const, override)); + MOCK_METHOD(bool, CanSeek, (), (const, override)); + MOCK_METHOD(bool, CanGetSize, (), (const, override)); - MOCK_CONST_METHOD0(GetSize, uint64_t()); - MOCK_METHOD2(SetSizeBlocking, bool(uint64_t, ErrorPtr*)); - MOCK_CONST_METHOD0(GetRemainingSize, uint64_t()); + MOCK_METHOD(uint64_t, GetSize, (), (const, override)); + MOCK_METHOD(bool, SetSizeBlocking, (uint64_t, ErrorPtr*), (override)); + MOCK_METHOD(uint64_t, GetRemainingSize, (), (const, override)); - MOCK_CONST_METHOD0(GetPosition, uint64_t()); - MOCK_METHOD4(Seek, bool(int64_t, Whence, uint64_t*, ErrorPtr*)); + MOCK_METHOD(uint64_t, GetPosition, (), (const, override)); + MOCK_METHOD(bool, Seek, (int64_t, Whence, uint64_t*, ErrorPtr*), (override)); - MOCK_METHOD5(ReadAsync, bool(void*, - size_t, - const base::Callback&, - const ErrorCallback&, - ErrorPtr*)); - MOCK_METHOD5(ReadAllAsync, bool(void*, - size_t, - const base::Closure&, - const ErrorCallback&, - ErrorPtr*)); - MOCK_METHOD5(ReadNonBlocking, bool(void*, size_t, size_t*, bool*, ErrorPtr*)); - MOCK_METHOD4(ReadBlocking, bool(void*, size_t, size_t*, ErrorPtr*)); - MOCK_METHOD3(ReadAllBlocking, bool(void*, size_t, ErrorPtr*)); + MOCK_METHOD(bool, + ReadAsync, + (void*, + size_t, + const base::Callback&, + const ErrorCallback&, + ErrorPtr*), + (override)); + MOCK_METHOD( + bool, + ReadAllAsync, + (void*, size_t, const base::Closure&, const ErrorCallback&, ErrorPtr*), + (override)); + MOCK_METHOD(bool, + ReadNonBlocking, + (void*, size_t, size_t*, bool*, ErrorPtr*), + (override)); + MOCK_METHOD(bool, + ReadBlocking, + (void*, size_t, size_t*, ErrorPtr*), + (override)); + MOCK_METHOD(bool, ReadAllBlocking, (void*, size_t, ErrorPtr*), (override)); - MOCK_METHOD5(WriteAsync, bool(const void*, - size_t, - const base::Callback&, - const ErrorCallback&, - ErrorPtr*)); - MOCK_METHOD5(WriteAllAsync, bool(const void*, - size_t, - const base::Closure&, - const ErrorCallback&, - ErrorPtr*)); - MOCK_METHOD4(WriteNonBlocking, bool(const void*, size_t, size_t*, ErrorPtr*)); - MOCK_METHOD4(WriteBlocking, bool(const void*, size_t, size_t*, ErrorPtr*)); - MOCK_METHOD3(WriteAllBlocking, bool(const void*, size_t, ErrorPtr*)); + MOCK_METHOD(bool, + WriteAsync, + (const void*, + size_t, + const base::Callback&, + const ErrorCallback&, + ErrorPtr*), + (override)); + MOCK_METHOD(bool, + WriteAllAsync, + (const void*, + size_t, + const base::Closure&, + const ErrorCallback&, + ErrorPtr*), + (override)); + MOCK_METHOD(bool, + WriteNonBlocking, + (const void*, size_t, size_t*, ErrorPtr*), + (override)); + MOCK_METHOD(bool, + WriteBlocking, + (const void*, size_t, size_t*, ErrorPtr*), + (override)); + MOCK_METHOD(bool, + WriteAllBlocking, + (const void*, size_t, ErrorPtr*), + (override)); - MOCK_METHOD1(FlushBlocking, bool(ErrorPtr*)); - MOCK_METHOD1(CloseBlocking, bool(ErrorPtr*)); + MOCK_METHOD(bool, FlushBlocking, (ErrorPtr*), (override)); + MOCK_METHOD(bool, CloseBlocking, (ErrorPtr*), (override)); - MOCK_METHOD3(WaitForData, bool(AccessMode, - const base::Callback&, - ErrorPtr*)); - MOCK_METHOD4(WaitForDataBlocking, - bool(AccessMode, base::TimeDelta, AccessMode*, ErrorPtr*)); + MOCK_METHOD(bool, + WaitForData, + (AccessMode, const base::Callback&, ErrorPtr*), + (override)); + MOCK_METHOD(bool, + WaitForDataBlocking, + (AccessMode, base::TimeDelta, AccessMode*, ErrorPtr*), + (override)); private: DISALLOW_COPY_AND_ASSIGN(MockStream); diff --git a/brillo/streams/stream_test.cc b/brillo/streams/stream_test.cc index ce7370a..8cb99a9 100644 --- a/brillo/streams/stream_test.cc +++ b/brillo/streams/stream_test.cc @@ -42,39 +42,48 @@ class MockStreamImpl : public Stream { public: MockStreamImpl() = default; - MOCK_CONST_METHOD0(IsOpen, bool()); - MOCK_CONST_METHOD0(CanRead, bool()); - MOCK_CONST_METHOD0(CanWrite, bool()); - MOCK_CONST_METHOD0(CanSeek, bool()); - MOCK_CONST_METHOD0(CanGetSize, bool()); + MOCK_METHOD(bool, IsOpen, (), (const, override)); + MOCK_METHOD(bool, CanRead, (), (const, override)); + MOCK_METHOD(bool, CanWrite, (), (const, override)); + MOCK_METHOD(bool, CanSeek, (), (const, override)); + MOCK_METHOD(bool, CanGetSize, (), (const, override)); - MOCK_CONST_METHOD0(GetSize, uint64_t()); - MOCK_METHOD2(SetSizeBlocking, bool(uint64_t, ErrorPtr*)); - MOCK_CONST_METHOD0(GetRemainingSize, uint64_t()); + MOCK_METHOD(uint64_t, GetSize, (), (const, override)); + MOCK_METHOD(bool, SetSizeBlocking, (uint64_t, ErrorPtr*), (override)); + MOCK_METHOD(uint64_t, GetRemainingSize, (), (const, override)); - MOCK_CONST_METHOD0(GetPosition, uint64_t()); - MOCK_METHOD4(Seek, bool(int64_t, Whence, uint64_t*, ErrorPtr*)); + MOCK_METHOD(uint64_t, GetPosition, (), (const, override)); + MOCK_METHOD(bool, Seek, (int64_t, Whence, uint64_t*, ErrorPtr*), (override)); // Omitted: ReadAsync // Omitted: ReadAllAsync - MOCK_METHOD5(ReadNonBlocking, bool(void*, size_t, size_t*, bool*, ErrorPtr*)); + MOCK_METHOD(bool, + ReadNonBlocking, + (void*, size_t, size_t*, bool*, ErrorPtr*), + (override)); // Omitted: ReadBlocking // Omitted: ReadAllBlocking // Omitted: WriteAsync // Omitted: WriteAllAsync - MOCK_METHOD4(WriteNonBlocking, bool(const void*, size_t, size_t*, ErrorPtr*)); + MOCK_METHOD(bool, + WriteNonBlocking, + (const void*, size_t, size_t*, ErrorPtr*), + (override)); // Omitted: WriteBlocking // Omitted: WriteAllBlocking - MOCK_METHOD1(FlushBlocking, bool(ErrorPtr*)); - MOCK_METHOD1(CloseBlocking, bool(ErrorPtr*)); + MOCK_METHOD(bool, FlushBlocking, (ErrorPtr*), (override)); + MOCK_METHOD(bool, CloseBlocking, (ErrorPtr*), (override)); - MOCK_METHOD3(WaitForData, bool(AccessMode, - const base::Callback&, - ErrorPtr*)); - MOCK_METHOD4(WaitForDataBlocking, - bool(AccessMode, base::TimeDelta, AccessMode*, ErrorPtr*)); + MOCK_METHOD(bool, + WaitForData, + (AccessMode, const base::Callback&, ErrorPtr*), + (override)); + MOCK_METHOD(bool, + WaitForDataBlocking, + (AccessMode, base::TimeDelta, AccessMode*, ErrorPtr*), + (override)); private: DISALLOW_COPY_AND_ASSIGN(MockStreamImpl); @@ -333,7 +342,10 @@ TEST(Stream, ReadBlocking) { TEST(Stream, ReadAllBlocking) { class MockReadBlocking : public MockStreamImpl { public: - MOCK_METHOD4(ReadBlocking, bool(void*, size_t, size_t*, ErrorPtr*)); + MOCK_METHOD(bool, + ReadBlocking, + (void*, size_t, size_t*, ErrorPtr*), + (override)); } stream_mock; char buf[1024]; @@ -471,7 +483,10 @@ TEST(Stream, WriteBlocking) { TEST(Stream, WriteAllBlocking) { class MockWritelocking : public MockStreamImpl { public: - MOCK_METHOD4(WriteBlocking, bool(const void*, size_t, size_t*, ErrorPtr*)); + MOCK_METHOD(bool, + WriteBlocking, + (const void*, size_t, size_t*, ErrorPtr*), + (override)); } stream_mock; char buf[1024]; diff --git a/brillo/udev/mock_udev.h b/brillo/udev/mock_udev.h index addd29c..8494bab 100644 --- a/brillo/udev/mock_udev.h +++ b/brillo/udev/mock_udev.h @@ -21,16 +21,23 @@ class BRILLO_EXPORT MockUdev : public Udev { MockUdev() : Udev(nullptr) {} ~MockUdev() override = default; - MOCK_METHOD1(CreateDeviceFromSysPath, - std::unique_ptr(const char* sys_path)); - MOCK_METHOD2(CreateDeviceFromDeviceNumber, - std::unique_ptr(char type, dev_t device_number)); - MOCK_METHOD2(CreateDeviceFromSubsystemSysName, - std::unique_ptr(const char* subsystem, - const char* sys_name)); - MOCK_METHOD0(CreateEnumerate, std::unique_ptr()); - MOCK_METHOD1(CreateMonitorFromNetlink, - std::unique_ptr(const char* name)); + MOCK_METHOD(std::unique_ptr, + CreateDeviceFromSysPath, + (const char*), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateDeviceFromDeviceNumber, + (char, dev_t), + (override)); + MOCK_METHOD(std::unique_ptr, + CreateDeviceFromSubsystemSysName, + (const char*, const char*), + (override)); + MOCK_METHOD(std::unique_ptr, CreateEnumerate, (), (override)); + MOCK_METHOD(std::unique_ptr, + CreateMonitorFromNetlink, + (const char*), + (override)); private: DISALLOW_COPY_AND_ASSIGN(MockUdev); diff --git a/brillo/udev/mock_udev_device.h b/brillo/udev/mock_udev_device.h index aa3b472..9e0c2ef 100644 --- a/brillo/udev/mock_udev_device.h +++ b/brillo/udev/mock_udev_device.h @@ -18,30 +18,45 @@ class BRILLO_EXPORT MockUdevDevice : public UdevDevice { MockUdevDevice() = default; ~MockUdevDevice() override = default; - MOCK_CONST_METHOD0(GetParent, std::unique_ptr()); - MOCK_CONST_METHOD2(GetParentWithSubsystemDeviceType, - std::unique_ptr(const char* subsystem, - const char* device_type)); - MOCK_CONST_METHOD0(IsInitialized, bool()); - MOCK_CONST_METHOD0(GetMicrosecondsSinceInitialized, uint64_t()); - MOCK_CONST_METHOD0(GetSequenceNumber, uint64_t()); - MOCK_CONST_METHOD0(GetDevicePath, const char*()); - MOCK_CONST_METHOD0(GetDeviceNode, const char*()); - MOCK_CONST_METHOD0(GetDeviceNumber, dev_t()); - MOCK_CONST_METHOD0(GetDeviceType, const char*()); - MOCK_CONST_METHOD0(GetDriver, const char*()); - MOCK_CONST_METHOD0(GetSubsystem, const char*()); - MOCK_CONST_METHOD0(GetSysPath, const char*()); - MOCK_CONST_METHOD0(GetSysName, const char*()); - MOCK_CONST_METHOD0(GetSysNumber, const char*()); - MOCK_CONST_METHOD0(GetAction, const char*()); - MOCK_CONST_METHOD0(GetDeviceLinksListEntry, std::unique_ptr()); - MOCK_CONST_METHOD0(GetPropertiesListEntry, std::unique_ptr()); - MOCK_CONST_METHOD1(GetPropertyValue, const char*(const char* key)); - MOCK_CONST_METHOD0(GetTagsListEntry, std::unique_ptr()); - MOCK_CONST_METHOD0(GetSysAttributeListEntry, - std::unique_ptr()); - MOCK_CONST_METHOD1(GetSysAttributeValue, const char*(const char* attribute)); + MOCK_METHOD(std::unique_ptr, GetParent, (), (const, override)); + MOCK_METHOD(std::unique_ptr, + GetParentWithSubsystemDeviceType, + (const char*, const char*), + (const, override)); + MOCK_METHOD(bool, IsInitialized, (), (const, override)); + MOCK_METHOD(uint64_t, GetMicrosecondsSinceInitialized, (), (const, override)); + MOCK_METHOD(uint64_t, GetSequenceNumber, (), (const, override)); + MOCK_METHOD(const char*, GetDevicePath, (), (const, override)); + MOCK_METHOD(const char*, GetDeviceNode, (), (const, override)); + MOCK_METHOD(dev_t, GetDeviceNumber, (), (const, override)); + MOCK_METHOD(const char*, GetDeviceType, (), (const, override)); + MOCK_METHOD(const char*, GetDriver, (), (const, override)); + MOCK_METHOD(const char*, GetSubsystem, (), (const, override)); + MOCK_METHOD(const char*, GetSysPath, (), (const, override)); + MOCK_METHOD(const char*, GetSysName, (), (const, override)); + MOCK_METHOD(const char*, GetSysNumber, (), (const, override)); + MOCK_METHOD(const char*, GetAction, (), (const, override)); + MOCK_METHOD(std::unique_ptr, + GetDeviceLinksListEntry, + (), + (const, override)); + MOCK_METHOD(std::unique_ptr, + GetPropertiesListEntry, + (), + (const, override)); + MOCK_METHOD(const char*, GetPropertyValue, (const char*), (const, override)); + MOCK_METHOD(std::unique_ptr, + GetTagsListEntry, + (), + (const, override)); + MOCK_METHOD(std::unique_ptr, + GetSysAttributeListEntry, + (), + (const, override)); + MOCK_METHOD(const char*, + GetSysAttributeValue, + (const char*), + (const, override)); private: DISALLOW_COPY_AND_ASSIGN(MockUdevDevice); diff --git a/brillo/udev/mock_udev_enumerate.h b/brillo/udev/mock_udev_enumerate.h index 4f47f6d..faf94fc 100644 --- a/brillo/udev/mock_udev_enumerate.h +++ b/brillo/udev/mock_udev_enumerate.h @@ -18,20 +18,27 @@ class BRILLO_EXPORT MockUdevEnumerate : public UdevEnumerate { MockUdevEnumerate() = default; ~MockUdevEnumerate() override = default; - MOCK_METHOD1(AddMatchSubsystem, bool(const char* subsystem)); - MOCK_METHOD1(AddNoMatchSubsystem, bool(const char* subsystem)); - MOCK_METHOD2(AddMatchSysAttribute, - bool(const char* attribute, const char* value)); - MOCK_METHOD2(AddNoMatchSysAttribute, - bool(const char* attribute, const char* value)); - MOCK_METHOD2(AddMatchProperty, bool(const char* property, const char* value)); - MOCK_METHOD1(AddMatchSysName, bool(const char* sys_name)); - MOCK_METHOD1(AddMatchTag, bool(const char* tag)); - MOCK_METHOD0(AddMatchIsInitialized, bool()); - MOCK_METHOD1(AddSysPath, bool(const char* sys_path)); - MOCK_METHOD0(ScanDevices, bool()); - MOCK_METHOD0(ScanSubsystems, bool()); - MOCK_CONST_METHOD0(GetListEntry, std::unique_ptr()); + MOCK_METHOD(bool, AddMatchSubsystem, (const char*), (override)); + MOCK_METHOD(bool, AddNoMatchSubsystem, (const char*), (override)); + MOCK_METHOD(bool, + AddMatchSysAttribute, + (const char*, const char*), + (override)); + MOCK_METHOD(bool, + AddNoMatchSysAttribute, + (const char*, const char*), + (override)); + MOCK_METHOD(bool, AddMatchProperty, (const char*, const char*), (override)); + MOCK_METHOD(bool, AddMatchSysName, (const char*), (override)); + MOCK_METHOD(bool, AddMatchTag, (const char*), (override)); + MOCK_METHOD(bool, AddMatchIsInitialized, (), (override)); + MOCK_METHOD(bool, AddSysPath, (const char*), (override)); + MOCK_METHOD(bool, ScanDevices, (), (override)); + MOCK_METHOD(bool, ScanSubsystems, (), (override)); + MOCK_METHOD(std::unique_ptr, + GetListEntry, + (), + (const, override)); private: DISALLOW_COPY_AND_ASSIGN(MockUdevEnumerate); diff --git a/brillo/udev/mock_udev_list_entry.h b/brillo/udev/mock_udev_list_entry.h index 0da1246..255b6e2 100644 --- a/brillo/udev/mock_udev_list_entry.h +++ b/brillo/udev/mock_udev_list_entry.h @@ -18,11 +18,13 @@ class BRILLO_EXPORT MockUdevListEntry : public UdevListEntry { MockUdevListEntry() = default; ~MockUdevListEntry() override = default; - MOCK_CONST_METHOD0(GetNext, std::unique_ptr()); - MOCK_CONST_METHOD1(GetByName, - std::unique_ptr(const char* name)); - MOCK_CONST_METHOD0(GetName, const char*()); - MOCK_CONST_METHOD0(GetValue, const char*()); + MOCK_METHOD(std::unique_ptr, GetNext, (), (const, override)); + MOCK_METHOD(std::unique_ptr, + GetByName, + (const char*), + (const, override)); + MOCK_METHOD(const char*, GetName, (), (const, override)); + MOCK_METHOD(const char*, GetValue, (), (const, override)); private: DISALLOW_COPY_AND_ASSIGN(MockUdevListEntry); diff --git a/brillo/udev/mock_udev_monitor.h b/brillo/udev/mock_udev_monitor.h index b955fb8..44e8560 100644 --- a/brillo/udev/mock_udev_monitor.h +++ b/brillo/udev/mock_udev_monitor.h @@ -18,15 +18,17 @@ class BRILLO_EXPORT MockUdevMonitor : public UdevMonitor { MockUdevMonitor() = default; ~MockUdevMonitor() override = default; - MOCK_METHOD0(EnableReceiving, bool()); - MOCK_METHOD1(SetReceiveBufferSize, bool(int size)); - MOCK_CONST_METHOD0(GetFileDescriptor, int()); - MOCK_METHOD0(ReceiveDevice, std::unique_ptr()); - MOCK_METHOD2(FilterAddMatchSubsystemDeviceType, - bool(const char* subsystem, const char* device_type)); - MOCK_METHOD1(FilterAddMatchTag, bool(const char* tag)); - MOCK_METHOD0(FilterUpdate, bool()); - MOCK_METHOD0(FilterRemove, bool()); + MOCK_METHOD(bool, EnableReceiving, (), (override)); + MOCK_METHOD(bool, SetReceiveBufferSize, (int), (override)); + MOCK_METHOD(int, GetFileDescriptor, (), (const, override)); + MOCK_METHOD(std::unique_ptr, ReceiveDevice, (), (override)); + MOCK_METHOD(bool, + FilterAddMatchSubsystemDeviceType, + (const char*, const char*), + (override)); + MOCK_METHOD(bool, FilterAddMatchTag, (const char*), (override)); + MOCK_METHOD(bool, FilterUpdate, (), (override)); + MOCK_METHOD(bool, FilterRemove, (), (override)); private: DISALLOW_COPY_AND_ASSIGN(MockUdevMonitor); diff --git a/policy/mock_device_policy.h b/policy/mock_device_policy.h index de68a00..5cd9ce8 100644 --- a/policy/mock_device_policy.h +++ b/policy/mock_device_policy.h @@ -52,65 +52,72 @@ class MockDevicePolicy : public DevicePolicy { } ~MockDevicePolicy() override = default; - MOCK_METHOD0(LoadPolicy, bool(void)); - MOCK_CONST_METHOD0(IsEnterpriseEnrolled, bool(void)); + MOCK_METHOD(bool, LoadPolicy, (), (override)); + MOCK_METHOD(bool, IsEnterpriseEnrolled, (), (const, override)); - MOCK_CONST_METHOD1(GetPolicyRefreshRate, - bool(int*)); // NOLINT(readability/function) - MOCK_CONST_METHOD1(GetUserWhitelist, bool(std::vector*)); - MOCK_CONST_METHOD1(GetGuestModeEnabled, - bool(bool*)); // NOLINT(readability/function) - MOCK_CONST_METHOD1(GetCameraEnabled, - bool(bool*)); // NOLINT(readability/function) - MOCK_CONST_METHOD1(GetShowUserNames, - bool(bool*)); // NOLINT(readability/function) - MOCK_CONST_METHOD1(GetDataRoamingEnabled, - bool(bool*)); // NOLINT(readability/function) - MOCK_CONST_METHOD1(GetAllowNewUsers, - bool(bool*)); // NOLINT(readability/function) - MOCK_CONST_METHOD1(GetMetricsEnabled, - bool(bool*)); // NOLINT(readability/function) - MOCK_CONST_METHOD1(GetReportVersionInfo, - bool(bool*)); // NOLINT(readability/function) - MOCK_CONST_METHOD1(GetReportActivityTimes, - bool(bool*)); // NOLINT(readability/function) - MOCK_CONST_METHOD1(GetReportBootMode, - bool(bool*)); // NOLINT(readability/function) - MOCK_CONST_METHOD1(GetEphemeralUsersEnabled, - bool(bool*)); // NOLINT(readability/function) - MOCK_CONST_METHOD1(GetReleaseChannel, bool(std::string*)); - MOCK_CONST_METHOD1(GetReleaseChannelDelegated, - bool(bool*)); // NOLINT(readability/function) - MOCK_CONST_METHOD1(GetUpdateDisabled, - bool(bool*)); // NOLINT(readability/function) - MOCK_CONST_METHOD1(GetTargetVersionPrefix, bool(std::string*)); - MOCK_CONST_METHOD1(GetRollbackToTargetVersion, bool(int*)); - MOCK_CONST_METHOD1(GetRollbackAllowedMilestones, bool(int*)); - MOCK_CONST_METHOD1(GetScatterFactorInSeconds, - bool(int64_t*)); // NOLINT(readability/function) - MOCK_CONST_METHOD1(GetAllowedConnectionTypesForUpdate, - bool(std::set*)); - MOCK_CONST_METHOD1(GetOpenNetworkConfiguration, bool(std::string*)); - MOCK_CONST_METHOD1(GetOwner, bool(std::string*)); - MOCK_CONST_METHOD1(GetHttpDownloadsEnabled, - bool(bool*)); // NOLINT(readability/function) - MOCK_CONST_METHOD1(GetAuP2PEnabled, - bool(bool*)); // NOLINT(readability/function) - MOCK_CONST_METHOD1(GetAllowKioskAppControlChromeVersion, - bool(bool*)); // NOLINT(readability/function) - MOCK_CONST_METHOD1(GetUsbDetachableWhitelist, - bool(std::vector*)); - MOCK_CONST_METHOD1(GetAutoLaunchedKioskAppId, bool(std::string*)); - MOCK_CONST_METHOD0(IsEnterpriseManaged, bool()); - MOCK_CONST_METHOD1(GetSecondFactorAuthenticationMode, bool(int*)); - MOCK_CONST_METHOD1(GetDisallowedTimeIntervals, - bool(std::vector*)); - MOCK_CONST_METHOD1(GetDeviceUpdateStagingSchedule, - bool(std::vector*)); - MOCK_CONST_METHOD1(GetDeviceQuickFixBuildToken, - bool(std::string*)); - MOCK_METHOD0(VerifyPolicyFiles, bool(void)); - MOCK_METHOD0(VerifyPolicySignature, bool(void)); + MOCK_METHOD(bool, GetPolicyRefreshRate, (int*), (const, override)); + MOCK_METHOD(bool, + GetUserWhitelist, + (std::vector*), + (const, override)); + MOCK_METHOD(bool, GetGuestModeEnabled, (bool*), (const, override)); + MOCK_METHOD(bool, GetCameraEnabled, (bool*), (const, override)); + MOCK_METHOD(bool, GetShowUserNames, (bool*), (const, override)); + MOCK_METHOD(bool, GetDataRoamingEnabled, (bool*), (const, override)); + MOCK_METHOD(bool, GetAllowNewUsers, (bool*), (const, override)); + MOCK_METHOD(bool, GetMetricsEnabled, (bool*), (const, override)); + MOCK_METHOD(bool, GetReportVersionInfo, (bool*), (const, override)); + MOCK_METHOD(bool, GetReportActivityTimes, (bool*), (const, override)); + MOCK_METHOD(bool, GetReportBootMode, (bool*), (const, override)); + MOCK_METHOD(bool, GetEphemeralUsersEnabled, (bool*), (const, override)); + MOCK_METHOD(bool, GetReleaseChannel, (std::string*), (const, override)); + MOCK_METHOD(bool, GetReleaseChannelDelegated, (bool*), (const, override)); + MOCK_METHOD(bool, GetUpdateDisabled, (bool*), (const, override)); + MOCK_METHOD(bool, GetTargetVersionPrefix, (std::string*), (const, override)); + MOCK_METHOD(bool, GetRollbackToTargetVersion, (int*), (const, override)); + MOCK_METHOD(bool, GetRollbackAllowedMilestones, (int*), (const, override)); + MOCK_METHOD(bool, GetScatterFactorInSeconds, (int64_t*), (const, override)); + MOCK_METHOD(bool, + GetAllowedConnectionTypesForUpdate, + (std::set*), + (const, override)); + MOCK_METHOD(bool, + GetOpenNetworkConfiguration, + (std::string*), + (const, override)); + MOCK_METHOD(bool, GetOwner, (std::string*), (const, override)); + MOCK_METHOD(bool, GetHttpDownloadsEnabled, (bool*), (const, override)); + MOCK_METHOD(bool, GetAuP2PEnabled, (bool*), (const, override)); + MOCK_METHOD(bool, + GetAllowKioskAppControlChromeVersion, + (bool*), + (const, override)); + MOCK_METHOD(bool, + GetUsbDetachableWhitelist, + (std::vector*), + (const, override)); + MOCK_METHOD(bool, + GetAutoLaunchedKioskAppId, + (std::string*), + (const, override)); + MOCK_METHOD(bool, IsEnterpriseManaged, (), (const, override)); + MOCK_METHOD(bool, + GetSecondFactorAuthenticationMode, + (int*), + (const, override)); + MOCK_METHOD(bool, + GetDisallowedTimeIntervals, + (std::vector*), + (const, override)); + MOCK_METHOD(bool, + GetDeviceUpdateStagingSchedule, + (std::vector*), + (const, override)); + MOCK_METHOD(bool, + GetDeviceQuickFixBuildToken, + (std::string*), + (const, override)); + MOCK_METHOD(bool, VerifyPolicySignature, (), (override)); }; } // namespace policy diff --git a/policy/mock_libpolicy.h b/policy/mock_libpolicy.h index a0f6920..a04af7b 100644 --- a/policy/mock_libpolicy.h +++ b/policy/mock_libpolicy.h @@ -20,10 +20,10 @@ class MockPolicyProvider : public PolicyProvider { MockPolicyProvider() = default; ~MockPolicyProvider() override = default; - MOCK_METHOD0(Reload, bool(void)); - MOCK_CONST_METHOD0(device_policy_is_loaded, bool(void)); - MOCK_CONST_METHOD0(GetDevicePolicy, const DevicePolicy&(void)); - MOCK_CONST_METHOD0(IsConsumerDevice, bool(void)); + MOCK_METHOD(bool, Reload, (), (override)); + MOCK_METHOD(bool, device_policy_is_loaded, (), (const, override)); + MOCK_METHOD(const DevicePolicy&, GetDevicePolicy, (), (const, override)); + MOCK_METHOD(bool, IsConsumerDevice, (), (const, override)); private: DISALLOW_COPY_AND_ASSIGN(MockPolicyProvider); -- cgit v1.2.3