Fix wrong error handling in bundle add

- A val can be 0-length string in Bundle::Add(key, val)
- Bundle::GetStringArray can take empty string as key paramenter
- Fix unittest code: handling invalid key (empty, wrong type, not exist)

Change-Id: I7bb2dfd7b0a658ee9fd6f9d417e7386204ef9512
Signed-off-by: jihoi kim <jihoi.kim@samsung.com>

diff --git a/src/bundle/bundle_cpp.cc b/src/bundle/bundle_cpp.cc
index 59701680bddffa27305798eca75c58b5384c236b..c8396c4a7283c8db9beb8ea24e8781ceb33a0978 100644 (file)
--- a/src/bundle/bundle_cpp.cc
+++ b/src/bundle/bundle_cpp.cc
@@ -333,7 +333,7 @@ std::vector<Bundle::KeyInfo> Bundle::GetKeys() {
 }
 
 int Bundle::Add(const std::string& key, const std::string& val) {
-  if (impl_->handle_ == nullptr || key.empty() || val.empty()) {
+  if (impl_->handle_ == nullptr || key.empty()) {
     LOGE("Add fail key(%s), val(%s), ret(%d)", key.c_str(), val.c_str(),
         BUNDLE_ERROR_INVALID_PARAMETER);
     return BUNDLE_ERROR_INVALID_PARAMETER;
@@ -432,7 +432,7 @@ std::string Bundle::GetString(const std::string& key) const {
 }
 
 std::vector<std::string> Bundle::GetStringArray(const std::string& key) const {
-  if (key.empty() || (impl_->handle_ == nullptr)) {
+  if (impl_->handle_ == nullptr) {
     set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
     return std::vector<std::string>();
   }

diff --git a/tests/bundle_unittests/src/test_bundle_cpp.cc b/tests/bundle_unittests/src/test_bundle_cpp.cc
index ad6987601a59fe4356d712110aa8f6c1a1362360..a399c2d68ea90a7baed5465441e06740f7092a90 100644 (file)
--- a/tests/bundle_unittests/src/test_bundle_cpp.cc
+++ b/tests/bundle_unittests/src/test_bundle_cpp.cc
@@ -86,47 +86,94 @@ TEST(Bundle, MoveAndAssign) {
 
 TEST(Bundle, AddStringGetString) {
   Bundle bundle;
-  bundle.Add("TestKey", "TestVal");
-
-  EXPECT_EQ(bundle.GetString("TestKey"), "TestVal");
+  auto ret = bundle.Add("TestKey1", "TestVal1");
+  EXPECT_EQ(ret, BUNDLE_ERROR_NONE);
+  ret = bundle.Add("TestKey2", "");
+  EXPECT_EQ(ret, BUNDLE_ERROR_NONE);
+  ret = bundle.Add("TestKey3", { "TestVal2", "TestVal3", "TestVal4" });
+  EXPECT_EQ(ret, BUNDLE_ERROR_NONE);
+  ret = bundle.Add("","TestVal5");
+  EXPECT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
+
+  EXPECT_EQ(bundle.GetString("TestKey1"), "TestVal1");
+  EXPECT_EQ(bundle.GetString("TestKey2"), "");
+  EXPECT_EQ(bundle.GetString("TestKey3"), "");
+  EXPECT_EQ(bundle.GetString("NotExist"), "");
+  EXPECT_EQ(bundle.GetString(""), "");
 }
 
 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);
+  std::vector<unsigned char> v1 = { 0, 1, 2, 3};
+  std::vector<unsigned char> v2 = {};
+
+  auto ret = bundle.Add("TestKey1", v1);
+  EXPECT_EQ(ret, BUNDLE_ERROR_NONE);
+  ret = bundle.Add("TestKey2", v2);
+  EXPECT_EQ(ret, BUNDLE_ERROR_NONE);
+  ret = bundle.Add("TestKey3", "TestVal1");
+  EXPECT_EQ(ret, BUNDLE_ERROR_NONE);
+
+  auto v3 = bundle.GetByte("TestKey1");
+  EXPECT_EQ(v3.size(), 4);
+  EXPECT_EQ(v3[0], 0);
+  EXPECT_EQ(v3[1], 1);
+  EXPECT_EQ(v3[2], 2);
+  EXPECT_EQ(v3[3], 3);
+
+  auto v4 = bundle.GetByte("TestKey2");
+  EXPECT_EQ(v4.size(), 0);
+  auto v5 = bundle.GetByte("TestKey3");
+  EXPECT_EQ(v5.size(), 0);
+  auto v6 = bundle.GetByte("NotExist");
+  EXPECT_EQ(v6.size(), 0);
+  auto v7 = bundle.GetByte("");
+  EXPECT_EQ(v7.size(), 0);
 }
 
 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");
+  auto ret = bundle.Add("TestKey1", { "TestVal1", "TestVal2", "TestVal3", "" });
+  EXPECT_EQ(ret, BUNDLE_ERROR_NONE);
+  ret = bundle.Add("TestKey2", "TestVal4");
+  EXPECT_EQ(ret, BUNDLE_ERROR_NONE);
+
+  auto v1 = bundle.GetStringArray("TestKey1");
+  EXPECT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
+
+  EXPECT_EQ(v1.size(), 4);
+  EXPECT_EQ(v1[0], "TestVal1");
+  EXPECT_EQ(v1[1], "TestVal2");
+  EXPECT_EQ(v1[2], "TestVal3");
+  EXPECT_EQ(v1[3], "");
+
+  auto v2 = bundle.GetStringArray("TestKey2");
+  EXPECT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
+  EXPECT_EQ(v2.size(), 0);
+
+  auto v3 = bundle.GetStringArray("NotExist");
+  EXPECT_EQ(get_last_result(), BUNDLE_ERROR_KEY_NOT_AVAILABLE);
+  EXPECT_EQ(v3.size(), 0);
+
+  auto v4 = bundle.GetStringArray("");
+  EXPECT_EQ(get_last_result(), BUNDLE_ERROR_KEY_NOT_AVAILABLE);
+  EXPECT_EQ(v4.size(), 0);
 }
 
 TEST(Bundle, ToRaw) {
   Bundle bundle;
-  bundle.Add("TestKey", "TestVal");
+  bundle.Add("TestKey1", "TestVal");
+  bundle.Add("TestKey2", "");
 
   auto base64_r = bundle.ToRaw();
   Bundle b2(std::move(base64_r));
-  EXPECT_EQ(bundle.GetString("TestKey"), "TestVal");
+  EXPECT_EQ(bundle.GetString("TestKey1"), "TestVal");
+  EXPECT_EQ(bundle.GetString("TestKey2"), "");
 
   auto r = bundle.ToRaw(false);
   Bundle b3(std::move(r), false);
-  EXPECT_EQ(bundle.GetString("TestKey"), "TestVal");
+  EXPECT_EQ(bundle.GetString("TestKey1"), "TestVal");
+  EXPECT_EQ(bundle.GetString("TestKey2"), "");
 }
 
 TEST(Bundle, GetCount) {