From: Marcin Niesluchowski Date: Wed, 17 Dec 2014 10:42:55 +0000 (+0100) Subject: Add dbus incoming message wrapper class X-Git-Tag: security-manager_5.5_testing~122^2~20 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=55ca44d9e9ee127d78b78bfe058397675f3144f1;p=platform%2Fcore%2Ftest%2Fsecurity-tests.git Add dbus incoming message wrapper class Change-Id: I1f476b1c44605458e1168c60bf3c4e6b04462be5 --- diff --git a/tests/common/CMakeLists.txt b/tests/common/CMakeLists.txt index aaa7811..7db2584 100644 --- a/tests/common/CMakeLists.txt +++ b/tests/common/CMakeLists.txt @@ -15,6 +15,7 @@ SET(COMMON_TARGET_TEST_SOURCES ${PROJECT_SOURCE_DIR}/tests/common/access_provider.cpp ${PROJECT_SOURCE_DIR}/tests/common/smack_access.cpp ${PROJECT_SOURCE_DIR}/tests/common/dbus_access.cpp + ${PROJECT_SOURCE_DIR}/tests/common/dbus_message_in.cpp ${PROJECT_SOURCE_DIR}/tests/common/dbus_message_out.cpp ${PROJECT_SOURCE_DIR}/tests/common/memory.cpp ${PROJECT_SOURCE_DIR}/tests/common/db_sqlite.cpp diff --git a/tests/common/dbus_message_in.cpp b/tests/common/dbus_message_in.cpp new file mode 100644 index 0000000..c04533b --- /dev/null +++ b/tests/common/dbus_message_in.cpp @@ -0,0 +1,180 @@ +/* + * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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. + */ +/* + * @file dbus_message_in.cpp + * @author Marcin Niesluchowski (m.niesluchow@samsung.com) + * @version 1.0 + * @brief DBus incoming message wrapper class source file + */ + +#include + +#include + +namespace DBus +{ + +MessageIn::MessageIn(DBusMessage *message, bool ref) + : m_message(message) +{ + RUNNER_ASSERT(m_message != nullptr); + if (ref) + dbus_message_ref(m_message); +} + +MessageIn::MessageIn(MessageIn &&other) + : m_message(other.m_message) +{ + other.m_message = nullptr; +} + +MessageIn::~MessageIn() +{ + if (m_message != nullptr) + dbus_message_unref(m_message); +} + +int MessageIn::getType() +{ + return dbus_message_get_type(m_message); +} + +bool MessageIn::isMethodCall(const std::string &interface, const std::string &method) +{ + dbus_bool_t ret = dbus_message_is_method_call(m_message, + interface.c_str(), + method.c_str()); + return ret == TRUE; +} + +bool MessageIn::isSignal(const std::string &interface, const std::string &signalName) +{ + dbus_bool_t ret = dbus_message_is_signal(m_message, + interface.c_str(), + signalName.c_str()); + return ret == TRUE; +} + +bool MessageIn::isError(const std::string &errorName) +{ + dbus_bool_t ret = dbus_message_is_error(m_message, + errorName.c_str()); + return ret == TRUE; +} + +MessageIn::Iterator MessageIn::iterInit() +{ + return Iterator(this->m_message); +} + +MessageIn::Iterator::Iterator(DBusMessage* message) +{ + dbus_message_iter_init(message, &m_iterator); +} + +MessageIn::Iterator::Iterator(DBusMessageIter *iteratorOver) +{ + dbus_message_iter_recurse(iteratorOver, &m_iterator); +} + +bool MessageIn::Iterator::next() +{ + return dbus_message_iter_next(&m_iterator) != FALSE; +} + +void MessageIn::Iterator::expectNext() +{ + RUNNER_ASSERT_MSG(next(), "No next argument in message"); +} + +int MessageIn::Iterator::getArgType() +{ + return dbus_message_iter_get_arg_type(&m_iterator); +} + +void MessageIn::Iterator::expectArgType(int argType) +{ + int argTypeActual = getArgType(); + RUNNER_ASSERT_MSG(argTypeActual == argType, "Wrong argument type in message" + << " Actual: " << argTypeActual + << " Expected: " << argType); +} + +void MessageIn::Iterator::expectArgTypeValid() +{ + RUNNER_ASSERT_MSG(getArgType() != DBUS_TYPE_INVALID, "Invalid argument type in message"); +} + +char MessageIn::Iterator::getArgChar() +{ + return getArg(); +} + +bool MessageIn::Iterator::getArgBool() +{ + dbus_bool_t value; + dbus_message_iter_get_basic(&m_iterator, &value); + return value != FALSE; +} + +int16_t MessageIn::Iterator::getArgInt16() +{ + return getArg(); +} + +uint16_t MessageIn::Iterator::getArgUint16() +{ + return getArg(); +} + +int32_t MessageIn::Iterator::getArgInt32() +{ + return getArg(); +} + +uint32_t MessageIn::Iterator::getArgUint32() +{ + return getArg(); +} + +int64_t MessageIn::Iterator::getArgInt64() +{ + return getArg(); +} + +uint64_t MessageIn::Iterator::getArgUint64() +{ + return getArg(); +} + +double MessageIn::Iterator::getArgDouble() +{ + return getArg(); +} + +std::string MessageIn::Iterator::getArgString() +{ + char *value; + dbus_message_iter_get_basic(&m_iterator, &value); + return std::string(value); +} + +MessageIn::Iterator MessageIn::Iterator::recurse() +{ + return Iterator(&(this->m_iterator)); +} + +} // namespace DBus diff --git a/tests/common/dbus_message_in.h b/tests/common/dbus_message_in.h new file mode 100644 index 0000000..e0a0dc7 --- /dev/null +++ b/tests/common/dbus_message_in.h @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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. + */ +/* + * @file dbus_message_in.h + * @author Marcin Niesluchowski (m.niesluchow@samsung.com) + * @version 1.0 + * @brief DBus incoming message wrapper class header + */ + +#ifndef COMMON_DBUS_MESSAGE_IN_H +#define COMMON_DBUS_MESSAGE_IN_H + +#include + +#include +#include + +namespace DBus +{ + +class MessageIn +{ +public: + MessageIn(DBusMessage *message, bool ref = false); + MessageIn(const MessageIn &other) = delete; + MessageIn(MessageIn &&other); + ~MessageIn(); + + MessageIn& operator=(const MessageIn &other) = delete; + + int getType(); + bool isMethodCall(const std::string &interface, const std::string &method); + bool isSignal(const std::string &interface, const std::string &signalName); + bool isError(const std::string &errorName); + + class Iterator + { + public: + friend class MessageIn; + + bool next(); + void expectNext(); + int getArgType(); + void expectArgType(int argType); + void expectArgTypeValid(); + char getArgChar(); + bool getArgBool(); + int16_t getArgInt16(); + uint16_t getArgUint16(); + int32_t getArgInt32(); + uint32_t getArgUint32(); + int64_t getArgInt64(); + uint64_t getArgUint64(); + double getArgDouble(); + std::string getArgString(); + Iterator recurse(); + + private: + template + T getArg() { + T value; + dbus_message_iter_get_basic(&m_iterator, &value); + return value; + } + + // sub constructor + Iterator(DBusMessageIter *iteratorOver); + // message constructor + Iterator(DBusMessage *message); + DBusMessageIter m_iterator; + }; + + Iterator iterInit(); + +private: + DBusMessage *m_message; +}; + +} // namespace DBus + +#endif // COMMON_DBUS_MESSAGE_IN_H