}
TEST_F(AppControlActionTest, SerializeDeserialize) {
- char* app_id = NULL;
-
Bundle b = AppControlActionTest::action->Serialize();
std::shared_ptr<AbstractAction> gen_action = ActionInflator::Create(b);
AppControlAction* gen_appcontrol_action =
static_cast<AppControlAction*>(gen_action.get());
+ char* app_id = nullptr;
app_control_get_app_id(gen_appcontrol_action->GetAppControl(), &app_id);
+ std::unique_ptr<char, decltype(std::free)*> ptr(app_id, std::free);
ASSERT_STREQ(app_id, AppControlActionTest::app_id);
-
- if (app_id)
- free(app_id);
}
TEST_F(AppControlActionTest, AppControl) {
app_control_h app_control;
const char* app_id = "new_appid";
- char* app_id_ = NULL;
app_control_create(&app_control);
app_control_set_app_id(app_control, app_id);
AppControlAction* gen_appcontrol_action =
static_cast<AppControlAction*>(gen_action.get());
+ char* app_id_ = nullptr;
app_control_get_app_id(gen_appcontrol_action->GetAppControl(), &app_id_);
+ std::unique_ptr<char, decltype(std::free)*> ptr(app_id_, std::free);
EXPECT_STREQ(app_id, app_id_);
-
- if (app_id_)
- free(app_id_);
}
#include "notification-ex/ex_bundle.h"
-class BUNDLE : public ::testing::Test {
- public:
- virtual void SetUp() {
- }
- virtual void TearDown() {
+using ::testing::AtLeast;
+using namespace notification;
+
+TEST(Bundle, CtorDtor) {
+ Bundle bundle;
+}
+
+TEST(Bundle, CopyCtor) {
+ Bundle bundle;
+ bundle.Add("TestKey", "TestVal");
+
+ Bundle b2(bundle);
+ EXPECT_EQ(b2.GetString("TestKey"), "TestVal");
+}
+
+TEST(Bundle, MoveCtor) {
+ Bundle bundle;
+ bundle.Add("TestKey", "TestVal");
+
+ Bundle b2(std::move(bundle));
+ EXPECT_EQ(b2.GetString("TestKey"), "TestVal");
+}
+
+TEST(Bundle, AddStringGetString) {
+ Bundle bundle;
+ bundle.Add("TestKey", "TestVal");
+
+ EXPECT_EQ(bundle.GetString("TestKey"), "TestVal");
+}
+
+TEST(Bundle, AddByteGetByte) {
+ Bundle bundle;
+ std::vector<unsigned char> v = { 0, 1, 2, 3};
+ bundle.Add("TestKey", v);
+ auto v2 = bundle.GetByte("TestKey");
+
+ EXPECT_EQ(v2.size(), 4);
+ EXPECT_EQ(v2[0], 0);
+ EXPECT_EQ(v2[1], 1);
+ EXPECT_EQ(v2[2], 2);
+ EXPECT_EQ(v2[3], 3);
+}
+
+TEST(Bundle, AddStringArrayGetStringArray) {
+ Bundle bundle;
+ bundle.Add("TestKey", { "TestVal1", "TestVal2", "TestVal3" });
+
+ auto v = bundle.GetStringArray("TestKey");
+
+ EXPECT_EQ(v.size(), 3);
+ EXPECT_EQ(v[0], "TestVal1");
+ EXPECT_EQ(v[1], "TestVal2");
+ EXPECT_EQ(v[2], "TestVal3");
+}
+
+TEST(Bundle, ToRaw) {
+ Bundle bundle;
+ bundle.Add("TestKey", "TestVal");
+
+ auto r = bundle.ToRaw();
+ Bundle b2(std::move(r));
+ EXPECT_EQ(bundle.GetString("TestKey"), "TestVal");
+}
+
+TEST(Bundle, GetCount) {
+ Bundle bundle;
+ bundle.Add("TestKey1", "TestVal1");
+ bundle.Add("TestKey2", "TestVal2");
+
+ EXPECT_EQ(bundle.GetCount(), 2);
+}
+
+TEST(Bundle, Remove) {
+ Bundle bundle;
+ int r = bundle.Add("TestKey1", "TestVal1");
+ EXPECT_EQ(r, 0);
+
+ r = bundle.Remove("TestKey1");
+ EXPECT_EQ(r, 0);
+
+ EXPECT_EQ(bundle.GetString("TestKey1"), "");
+}
+
+TEST(Bundle, GetKeys) {
+ Bundle bundle;
+ bundle.Add("TestKey1", "TestVal1");
+ bundle.Add("TestKey2", "TestVal2");
+ bundle.Add("TestKey3", "TestVal3");
+
+ auto v = bundle.GetKeys();
+
+ EXPECT_EQ(bundle.GetCount(), 3);
+
+ for (auto& i : v) {
+ EXPECT_EQ(i.GetType(), BUNDLE_TYPE_STR);
}
-};
+}
ButtonItem item("title");
Bundle b = item.Serialize();
shared_ptr<AbstractItem> gen_item = ItemInflator::Create(b);
- ASSERT_EQ(gen_item.get()->GetType(), item.GetType());
+ ASSERT_EQ(gen_item->GetType(), item.GetType());
- ButtonItem* gen_btn = static_cast<ButtonItem*>(gen_item.get());
+ auto gen_btn = std::static_pointer_cast<ButtonItem>(gen_item);
ASSERT_EQ(item.GetTitle(), gen_btn->GetTitle());
}
Bundle b = ChatMessageItemTest::item->Serialize();
std::shared_ptr<AbstractItem> gen_item = ItemInflator::Create(b);
- ChatMessageItem* gen_message = static_cast<ChatMessageItem*>(gen_item.get());
+ auto gen_message = std::static_pointer_cast<ChatMessageItem>(gen_item);
ASSERT_EQ(gen_message->GetNameItem().GetContents(), "name");
ASSERT_EQ(gen_message->GetTextItem().GetContents(), "text");
ASSERT_EQ(gen_message->GetDataItem().GetContents(), "data");
Bundle b = CheckBoxItemTest::item->Serialize();
std::shared_ptr<AbstractItem> gen_item = ItemInflator::Create(b);
- ASSERT_EQ(CheckBoxItemTest::item->GetType(), gen_item.get()->GetType());
+ ASSERT_EQ(CheckBoxItemTest::item->GetType(), gen_item->GetType());
- CheckBoxItem* gen_checkbox = static_cast<CheckBoxItem*>(gen_item.get());
+ auto gen_checkbox = std::static_pointer_cast<CheckBoxItem>(gen_item);
ASSERT_EQ(CheckBoxItemTest::item->GetTitle(), gen_checkbox->GetTitle());
}
EntryItem item("entry_id");
Bundle b = item.Serialize();
std::shared_ptr<AbstractItem> gen_item = ItemInflator::Create(b);
- ASSERT_EQ(gen_item.get()->GetType(), item.GetType());
+ ASSERT_EQ(gen_item->GetType(), item.GetType());
- EntryItem* gen_effect = static_cast<EntryItem*>(gen_item.get());
+ auto gen_effect = std::static_pointer_cast<EntryItem>(gen_item);
ASSERT_EQ(item.GetId(), gen_effect->GetId());
}
Bundle b = item.Serialize();
shared_ptr<AbstractItem> gen_item = ItemInflator::Create(b);
- ASSERT_EQ(gen_item.get()->GetType(), item.GetType());
+ ASSERT_EQ(gen_item->GetType(), item.GetType());
- GroupItem* gen_group = static_cast<GroupItem*>(gen_item.get());
+ auto gen_group = static_pointer_cast<GroupItem>(gen_item);
list<shared_ptr<AbstractItem>> gen_children_list = gen_group->GetChildren();
list<shared_ptr<AbstractItem>> origin_children_list = item.GetChildren();
list<shared_ptr<AbstractItem>>::iterator it = origin_children_list.begin();
for (auto& i : gen_children_list) {
- ASSERT_EQ(i.get()->GetType(), (*it).get()->GetType());
- if (i.get()->GetType() == AbstractItem::Button) {
+ ASSERT_EQ(i->GetType(), (*it)->GetType());
+ if (i->GetType() == AbstractItem::Button) {
ButtonItem* btn1 = static_cast<ButtonItem*>(i.get());
ButtonItem* btn2 = static_cast<ButtonItem*>((*it).get());
ASSERT_EQ(btn1->GetTitle(), btn2->GetTitle());
Bundle b = IconItemTest::item->Serialize();
std::shared_ptr<AbstractItem> gen_item = ItemInflator::Create(b);
- ASSERT_EQ(IconItemTest::item->GetType(), gen_item.get()->GetType());
+ ASSERT_EQ(IconItemTest::item->GetType(), gen_item->GetType());
- IconItem* gen_icon = static_cast<IconItem*>(gen_item.get());
+ auto gen_icon = std::static_pointer_cast<IconItem>(gen_item);
ASSERT_EQ(IconItemTest::item->GetImagePath(), gen_icon->GetImagePath());
}
Bundle b = IconTextItemTest::item->Serialize();
std::shared_ptr<AbstractItem> gen_item = ItemInflator::Create(b);
- IconTextItem* gen_icon = static_cast<IconTextItem*>(gen_item.get());
+ auto gen_icon = std::static_pointer_cast<IconTextItem>(gen_item);
ASSERT_EQ(IconTextItemTest::item->GetIconItem().GetImagePath(), gen_icon->GetIconItem().GetImagePath());
ASSERT_EQ(IconTextItemTest::item->GetTextItem().GetContents(), gen_icon->GetTextItem().GetContents());
}
Bundle b = ImageItemTest::item->Serialize();
std::shared_ptr<AbstractItem> gen_item = ItemInflator::Create(b);
- ASSERT_EQ(ImageItemTest::item->GetType(), gen_item.get()->GetType());
+ ASSERT_EQ(ImageItemTest::item->GetType(), gen_item->GetType());
- ImageItem* gen_image = static_cast<ImageItem*>(gen_item.get());
+ auto gen_image = std::static_pointer_cast<ImageItem>(gen_item);
ASSERT_EQ(ImageItemTest::item->GetImagePath(), gen_image->GetImagePath());
}
Bundle b = item.Serialize();
shared_ptr<AbstractItem> gen_item = ItemInflator::Create(b);
- ASSERT_EQ(gen_item.get()->GetType(), item.GetType());
+ ASSERT_EQ(gen_item->GetType(), item.GetType());
- InputSelectorItem* gen_input = static_cast<InputSelectorItem*>(gen_item.get());
+ auto gen_input = static_pointer_cast<InputSelectorItem>(gen_item);
list<string> l1 = item.GetContents();
list<string> l2 = gen_input->GetContents();
ProgressItem item(1.0, 10.0, 100.0);
Bundle b = item.Serialize();
shared_ptr<AbstractItem> gen_item = ItemInflator::Create(b);
- ASSERT_EQ(gen_item.get()->GetType(), item.GetType());
+ ASSERT_EQ(gen_item->GetType(), item.GetType());
- ProgressItem* gen_progress = static_cast<ProgressItem*>(gen_item.get());
+ auto gen_progress = std::static_pointer_cast<ProgressItem>(gen_item);
ASSERT_EQ(item.GetCurrent(), gen_progress->GetCurrent());
ASSERT_EQ(item.GetMin(), gen_progress->GetMin());
ASSERT_EQ(item.GetMax(), gen_progress->GetMax());
TextItem item("text_id", "contents");
Bundle b = item.Serialize();
std::shared_ptr<AbstractItem> gen_item = ItemInflator::Create(b);
- ASSERT_EQ(gen_item.get()->GetType(), item.GetType());
+ ASSERT_EQ(gen_item->GetType(), item.GetType());
- TextItem* gen_text = static_cast<TextItem*>(gen_item.get());
+ auto gen_text = std::static_pointer_cast<TextItem>(gen_item);
ASSERT_EQ(item.GetContents(), gen_text->GetContents());
}
Bundle b = TimeItemTest::item->Serialize();
std::shared_ptr<AbstractItem> gen_item = ItemInflator::Create(b);
- ASSERT_EQ(TimeItemTest::item->GetType(), gen_item.get()->GetType());
+ ASSERT_EQ(TimeItemTest::item->GetType(), gen_item->GetType());
- TimeItem* gen_time = static_cast<TimeItem*>(gen_item.get());
+ auto gen_time = std::static_pointer_cast<TimeItem>(gen_item);
ASSERT_EQ(item->GetTime(), gen_time->GetTime());
}
std::shared_ptr<AbstractAction> gen_action = ActionInflator::Create(b);
ASSERT_EQ(gen_action->GetType(), AbstractAction::Visibility);
- VisibilityAction* gen_visibility_action =
- static_cast<VisibilityAction*>(gen_action.get());
+ auto gen_visibility_action =
+ std::static_pointer_cast<VisibilityAction>(gen_action);
EXPECT_NE(gen_visibility_action, nullptr);
ASSERT_EQ(gen_visibility_action->IsLocal(), true);
ASSERT_EQ(gen_visibility_action->GetExtra(), VisibilityActionTest::extra);
std::shared_ptr<AbstractAction> gen_action = ActionInflator::Create(b);
ASSERT_EQ(gen_action->GetType(), AbstractAction::Visibility);
- VisibilityAction* gen_visibility_action =
- static_cast<VisibilityAction*>(gen_action.get());
+ auto gen_visibility_action =
+ std::static_pointer_cast<VisibilityAction>(gen_action);
EXPECT_NE(gen_visibility_action, nullptr);
ASSERT_EQ(gen_visibility_action->IsLocal(), true);
ASSERT_EQ(gen_visibility_action->GetExtra(), VisibilityActionTest::extra);