| // 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. |
| |
| #include "chromeos-dbus-bindings/proxy_generator.h" |
| |
| #include <string> |
| #include <vector> |
| |
| #include <base/files/file_path.h> |
| #include <base/files/file_util.h> |
| #include <base/files/scoped_temp_dir.h> |
| #include <gtest/gtest.h> |
| |
| #include "chromeos-dbus-bindings/interface.h" |
| #include "chromeos-dbus-bindings/service_config.h" |
| #include "chromeos-dbus-bindings/test_utils.h" |
| |
| using std::string; |
| using std::vector; |
| using testing::Test; |
| |
| namespace chromeos_dbus_bindings { |
| |
| namespace { |
| |
| const char kDBusTypeArryOfObjects[] = "ao"; |
| const char kDBusTypeArryOfStrings[] = "as"; |
| const char kDBusTypeBool[] = "b"; |
| const char kDBusTypeByte[] = "y"; |
| const char kDBusTypeInt32[] = "i"; |
| const char kDBusTypeInt64[] = "x"; |
| const char kDBusTypeString[] = "s"; |
| |
| const char kExpectedContent[] = R"literal_string( |
| #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 "proxies.h" |
| |
| namespace org { |
| namespace chromium { |
| |
| // Mock object for TestInterfaceProxyInterface. |
| class TestInterfaceProxyMock : public TestInterfaceProxyInterface { |
| public: |
| TestInterfaceProxyMock() = default; |
| TestInterfaceProxyMock(const TestInterfaceProxyMock&) = delete; |
| TestInterfaceProxyMock& operator=(const TestInterfaceProxyMock&) = delete; |
| |
| MOCK_METHOD5(Elements, |
| bool(const std::string& /*in_space_walk*/, |
| const std::vector<dbus::ObjectPath>& /*in_ramblin_man*/, |
| std::string*, |
| brillo::ErrorPtr* /*error*/, |
| int /*timeout_ms*/)); |
| MOCK_METHOD5(ElementsAsync, |
| void(const std::string& /*in_space_walk*/, |
| const std::vector<dbus::ObjectPath>& /*in_ramblin_man*/, |
| base::OnceCallback<void(const std::string&)> /*success_callback*/, |
| base::OnceCallback<void(brillo::Error*)> /*error_callback*/, |
| int /*timeout_ms*/)); |
| MOCK_METHOD3(ReturnToPatagonia, |
| bool(int64_t*, |
| brillo::ErrorPtr* /*error*/, |
| int /*timeout_ms*/)); |
| MOCK_METHOD3(ReturnToPatagoniaAsync, |
| void(base::OnceCallback<void(int64_t)> /*success_callback*/, |
| base::OnceCallback<void(brillo::Error*)> /*error_callback*/, |
| int /*timeout_ms*/)); |
| MOCK_METHOD3(NiceWeatherForDucks, |
| bool(bool, |
| brillo::ErrorPtr* /*error*/, |
| int /*timeout_ms*/)); |
| MOCK_METHOD4(NiceWeatherForDucksAsync, |
| void(bool, |
| base::OnceCallback<void()> /*success_callback*/, |
| base::OnceCallback<void(brillo::Error*)> /*error_callback*/, |
| int /*timeout_ms*/)); |
| MOCK_METHOD2(ExperimentNumberSix, |
| bool(brillo::ErrorPtr* /*error*/, |
| int /*timeout_ms*/)); |
| MOCK_METHOD3(ExperimentNumberSixAsync, |
| void(base::OnceCallback<void()> /*success_callback*/, |
| base::OnceCallback<void(brillo::Error*)> /*error_callback*/, |
| int /*timeout_ms*/)); |
| bool AllTheWayUpToEleven(bool /*in_arg1*/, |
| bool /*in_arg2*/, |
| bool /*in_arg3*/, |
| bool /*in_arg4*/, |
| bool /*in_arg5*/, |
| bool /*in_arg6*/, |
| bool /*in_arg7*/, |
| bool /*in_arg8*/, |
| bool* /*out_arg9*/, |
| brillo::ErrorPtr* /*error*/, |
| int /*timeout_ms*/) override { |
| LOG(WARNING) << "AllTheWayUpToEleven(): gmock can't handle methods with 11 arguments. You can override this method in a subclass if you need to."; |
| return false; |
| } |
| void AllTheWayUpToElevenAsync(bool /*in_arg1*/, |
| bool /*in_arg2*/, |
| bool /*in_arg3*/, |
| bool /*in_arg4*/, |
| bool /*in_arg5*/, |
| bool /*in_arg6*/, |
| bool /*in_arg7*/, |
| bool /*in_arg8*/, |
| base::OnceCallback<void(bool /*arg9*/)> /*success_callback*/, |
| base::OnceCallback<void(brillo::Error*)> /*error_callback*/, |
| int /*timeout_ms*/) override { |
| LOG(WARNING) << "AllTheWayUpToElevenAsync(): gmock can't handle methods with 11 arguments. You can override this method in a subclass if you need to."; |
| } |
| void RegisterCloserSignalHandler( |
| base::RepeatingClosure signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) { |
| DoRegisterCloserSignalHandler(signal_callback, &on_connected_callback); |
| } |
| MOCK_METHOD2(DoRegisterCloserSignalHandler, |
| void(base::RepeatingClosure /*signal_callback*/, |
| dbus::ObjectProxy::OnConnectedCallback* /*on_connected_callback*/)); |
| void RegisterTheCurseOfKaZarSignalHandler( |
| const base::RepeatingCallback<void(const std::vector<std::string>&, |
| uint8_t)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) { |
| DoRegisterTheCurseOfKaZarSignalHandler(signal_callback, &on_connected_callback); |
| } |
| MOCK_METHOD2(DoRegisterTheCurseOfKaZarSignalHandler, |
| void(const base::RepeatingCallback<void(const std::vector<std::string>&, |
| uint8_t)>& /*signal_callback*/, |
| dbus::ObjectProxy::OnConnectedCallback* /*on_connected_callback*/)); |
| MOCK_CONST_METHOD0(GetObjectPath, const dbus::ObjectPath&()); |
| MOCK_CONST_METHOD0(GetObjectProxy, dbus::ObjectProxy*()); |
| }; |
| } // namespace chromium |
| } // namespace org |
| |
| namespace org { |
| namespace chromium { |
| |
| // Mock object for TestInterface2ProxyInterface. |
| class TestInterface2ProxyMock : public TestInterface2ProxyInterface { |
| public: |
| TestInterface2ProxyMock() = default; |
| TestInterface2ProxyMock(const TestInterface2ProxyMock&) = delete; |
| TestInterface2ProxyMock& operator=(const TestInterface2ProxyMock&) = delete; |
| |
| MOCK_METHOD4(GetPersonInfo, |
| bool(std::string* /*out_name*/, |
| int32_t* /*out_age*/, |
| brillo::ErrorPtr* /*error*/, |
| int /*timeout_ms*/)); |
| MOCK_METHOD3(GetPersonInfoAsync, |
| void(base::OnceCallback<void(const std::string& /*name*/, int32_t /*age*/)> /*success_callback*/, |
| base::OnceCallback<void(brillo::Error*)> /*error_callback*/, |
| int /*timeout_ms*/)); |
| MOCK_CONST_METHOD0(data, const std::string&()); |
| MOCK_CONST_METHOD0(name, const std::string&()); |
| MOCK_METHOD2(set_name, void(const std::string&, base::OnceCallback<bool>)); |
| MOCK_CONST_METHOD0(GetObjectPath, const dbus::ObjectPath&()); |
| MOCK_CONST_METHOD0(GetObjectProxy, dbus::ObjectProxy*()); |
| MOCK_METHOD1(SetPropertyChangedCallback, |
| void(const base::RepeatingCallback<void(TestInterface2ProxyInterface*, const std::string&)>&)); |
| }; |
| } // namespace chromium |
| } // namespace org |
| )literal_string"; |
| |
| } // namespace |
| |
| class ProxyGeneratorMockTest : public Test { |
| public: |
| void SetUp() override { ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); } |
| |
| protected: |
| base::FilePath CreateInputFile(const string& contents) { |
| base::FilePath path; |
| EXPECT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &path)); |
| int written = base::WriteFile(path, contents.c_str(), contents.size()); |
| EXPECT_EQ(contents.size(), static_cast<size_t>(written)); |
| return path; |
| } |
| |
| base::ScopedTempDir temp_dir_; |
| }; |
| |
| TEST_F(ProxyGeneratorMockTest, GenerateMocks) { |
| Interface interface; |
| interface.name = "org.chromium.TestInterface"; |
| interface.path = "/org/chromium/Test"; |
| interface.methods.emplace_back( |
| "Elements", |
| vector<Interface::Argument>{{"space_walk", kDBusTypeString}, |
| {"ramblin_man", kDBusTypeArryOfObjects}}, |
| vector<Interface::Argument>{{"", kDBusTypeString}}); |
| interface.methods.emplace_back( |
| "ReturnToPatagonia", vector<Interface::Argument>{}, |
| vector<Interface::Argument>{{"", kDBusTypeInt64}}); |
| interface.methods.emplace_back( |
| "NiceWeatherForDucks", vector<Interface::Argument>{{"", kDBusTypeBool}}, |
| vector<Interface::Argument>{}); |
| interface.methods.emplace_back("ExperimentNumberSix"); |
| // gmock can't handle more than 10 args. The generated method will also |
| // include the timeout and error arguments in the synchronous case, and two |
| // callbacks and the timeout in the asynchronous case. |
| interface.methods.emplace_back( |
| "AllTheWayUpToEleven", |
| vector<Interface::Argument>{{"arg1", kDBusTypeBool}, |
| {"arg2", kDBusTypeBool}, |
| {"arg3", kDBusTypeBool}, |
| {"arg4", kDBusTypeBool}, |
| {"arg5", kDBusTypeBool}, |
| {"arg6", kDBusTypeBool}, |
| {"arg7", kDBusTypeBool}, |
| {"arg8", kDBusTypeBool}}, |
| vector<Interface::Argument>{{"arg9", kDBusTypeBool}}); |
| interface.signals.emplace_back("Closer"); |
| interface.signals.emplace_back( |
| "TheCurseOfKaZar", |
| vector<Interface::Argument>{{"", kDBusTypeArryOfStrings}, |
| {"", kDBusTypeByte}}); |
| interface.methods.back().doc_string = "Comment line1\nline2"; |
| Interface interface2; |
| interface2.name = "org.chromium.TestInterface2"; |
| interface2.methods.emplace_back( |
| "GetPersonInfo", vector<Interface::Argument>{}, |
| vector<Interface::Argument>{{"name", kDBusTypeString}, |
| {"age", kDBusTypeInt32}}); |
| interface2.properties.emplace_back("Data", "s", "read"); |
| interface2.properties.emplace_back("Name", "s", "readwrite"); |
| vector<Interface> interfaces{interface, interface2}; |
| base::FilePath output_path = temp_dir_.GetPath().Append("output.h"); |
| base::FilePath proxy_path = temp_dir_.GetPath().Append("proxies.h"); |
| ServiceConfig config; |
| config.object_manager.name = "ObjectManager"; |
| ProxyGenerator gen; |
| EXPECT_TRUE( |
| gen.GenerateMocks(config, interfaces, output_path, proxy_path, false)); |
| string contents; |
| EXPECT_TRUE(base::ReadFileToString(output_path, &contents)); |
| // The header guards contain the (temporary) filename, so we search for |
| // the content we need within the string. |
| test_utils::EXPECT_TEXT_CONTAINED(kExpectedContent, contents); |
| } |
| |
| } // namespace chromeos_dbus_bindings |
