diff --git a/frameworks/kits/content/cpp/src/ohos/aafwk/content/want_params.cpp b/frameworks/kits/content/cpp/src/ohos/aafwk/content/want_params.cpp
index 2002fe80a666b54468ce666796dbb67b7aff8101..6a72e0d9d6af892d605550db1fbaa6e3ef71f984 100755
--- a/frameworks/kits/content/cpp/src/ohos/aafwk/content/want_params.cpp
+++ b/frameworks/kits/content/cpp/src/ohos/aafwk/content/want_params.cpp
@@ -716,11 +716,17 @@ bool WantParams::WriteArrayToParcelBool(Parcel &parcel, IArray *ao) const
     }
 
     std::vector<int8_t> array;
+    std::vector<int32_t> intArray;
     FillArray<int8_t, Boolean, IBoolean>(ao, array);
     if (!parcel.WriteInt32(VALUE_TYPE_BOOLEANARRAY)) {
         return false;
     }
-    return parcel.WriteInt8Vector(array);
+
+    for (std::vector<int8_t>::size_type i = 0; i < array.size(); i++) {
+        APP_LOGI("%{public}s bool of array: %{public}d", __func__, array[i]);
+        intArray.push_back(array[i]);
+    }
+    return parcel.WriteInt32Vector(intArray);
 }
 
 bool WantParams::WriteArrayToParcelByte(Parcel &parcel, IArray *ao) const
@@ -848,8 +854,10 @@ bool WantParams::WriteArrayToParcel(Parcel &parcel, IArray *ao) const
 
 bool WantParams::ReadFromParcelArrayString(Parcel &parcel, sptr<IArray> &ao)
 {
+    APP_LOGI("%{public}s called.", __func__);
     std::vector<std::u16string> value;
     if (!parcel.ReadString16Vector(&value)) {
+        APP_LOGI("%{public}s read string of array fail.", __func__);
         return false;
     }
 
@@ -858,61 +866,104 @@ bool WantParams::ReadFromParcelArrayString(Parcel &parcel, sptr<IArray> &ao)
     if (ao != nullptr) {
         for (std::vector<std::u16string>::size_type i = 0; i < size; i++) {
             ao->Set(i, String::Box(Str16ToStr8(value[i])));
+            std::string strValue(Str16ToStr8(value[i]));
+            APP_LOGI("%{public}s string of array: %{public}s", __func__, strValue.c_str());
         }
         return true;
+    } else {
+        APP_LOGI("%{public}s create string of array fail.", __func__);
     }
     return false;
 }
 
 bool WantParams::ReadFromParcelArrayBool(Parcel &parcel, sptr<IArray> &ao)
 {
-    std::vector<int8_t> value;
-    if (!parcel.ReadInt8Vector(&value)) {
+    APP_LOGI("%{public}s called.", __func__);
+    std::vector<int32_t> value;
+    std::vector<int8_t> boolValue;
+    if (!parcel.ReadInt32Vector(&value)) {
+        APP_LOGI("%{public}s read bool of array fail.", __func__);
         return false;
     }
-    return SetArray<int8_t, Boolean>(g_IID_IBoolean, value, ao);
+
+    std::vector<int32_t>::size_type size = value.size();
+    for (std::vector<int32_t>::size_type i = 0; i < size; i++) {
+        APP_LOGI("%{public}s bool of array: %{public}d", __func__, value[i]);
+        boolValue.push_back(value[i]);
+    }    
+    return SetArray<int8_t, Boolean>(g_IID_IBoolean, boolValue, ao);
 }
 
 bool WantParams::ReadFromParcelArrayByte(Parcel &parcel, sptr<IArray> &ao)
 {
+    APP_LOGI("%{public}s called.", __func__);
     std::vector<int8_t> value;
     if (!parcel.ReadInt8Vector(&value)) {
+        APP_LOGI("%{public}s read byte of array fail.", __func__);
         return false;
     }
+
+    std::vector<int8_t>::size_type size = value.size();
+    for (std::vector<int8_t>::size_type i = 0; i < size; i++) {
+        APP_LOGI("%{public}s byte of array: %{public}d", __func__, value[i]);
+    }    
     return SetArray<int8_t, Byte>(g_IID_IByte, value, ao);
 }
 
 bool WantParams::ReadFromParcelArrayChar(Parcel &parcel, sptr<IArray> &ao)
 {
+    APP_LOGI("%{public}s called.", __func__);
     std::vector<int32_t> value;
     if (!parcel.ReadInt32Vector(&value)) {
+        APP_LOGI("%{public}s char bool of array fail.", __func__);
         return false;
     }
+
+    std::vector<int32_t>::size_type size = value.size();
+    for (std::vector<int32_t>::size_type i = 0; i < size; i++) {
+        APP_LOGI("%{public}s char of array: %{public}d", __func__, value[i]);
+    }    
     return SetArray<int32_t, Char>(g_IID_IChar, value, ao);
 }
 
 bool WantParams::ReadFromParcelArrayShort(Parcel &parcel, sptr<IArray> &ao)
 {
+    APP_LOGI("%{public}s called.", __func__);
     std::vector<short> value;
     if (!parcel.ReadInt16Vector(&value)) {
+        APP_LOGI("%{public}s read short of array fail.", __func__);
         return false;
     }
+
+    std::vector<short>::size_type size = value.size();
+    for (std::vector<short>::size_type i = 0; i < size; i++) {
+        APP_LOGI("%{public}s short of array: %{public}d", __func__, value[i]);
+    }     
     return SetArray<short, Short>(g_IID_IShort, value, ao);
 }
 
 bool WantParams::ReadFromParcelArrayInt(Parcel &parcel, sptr<IArray> &ao)
 {
+    APP_LOGI("%{public}s called.", __func__);
     std::vector<int> value;
     if (!parcel.ReadInt32Vector(&value)) {
+        APP_LOGI("%{public}s read int of array fail.", __func__);
         return false;
     }
+
+    std::vector<int>::size_type size = value.size();
+    for (std::vector<int>::size_type i = 0; i < size; i++) {
+        APP_LOGI("%{public}s int of array: %{public}d", __func__, value[i]);
+    }    
     return SetArray<int, Integer>(g_IID_IInteger, value, ao);
 }
 
 bool WantParams::ReadFromParcelArrayLong(Parcel &parcel, sptr<IArray> &ao)
 {
+    APP_LOGI("%{public}s called.", __func__);
     std::vector<int64_t> value;
     if (!parcel.ReadInt64Vector(&value)) {
+        APP_LOGI("%{public}s read long of array fail.", __func__);
         return false;
     }
 
@@ -923,6 +974,7 @@ bool WantParams::ReadFromParcelArrayLong(Parcel &parcel, sptr<IArray> &ao)
 
         for (size_t i=0; i<value.size(); i++) {
             strList.push_back(std::to_string(value[i]));
+            APP_LOGI("%{public}s long of array: %{public}s", __func__, std::to_string(value[i]).c_str());
         }
         return SetArray<std::string, String>(g_IID_IString, strList, ao);
     #endif 
@@ -930,19 +982,33 @@ bool WantParams::ReadFromParcelArrayLong(Parcel &parcel, sptr<IArray> &ao)
 
 bool WantParams::ReadFromParcelArrayFloat(Parcel &parcel, sptr<IArray> &ao)
 {
+    APP_LOGI("%{public}s called.", __func__);
     std::vector<float> value;
     if (!parcel.ReadFloatVector(&value)) {
+        APP_LOGI("%{public}s read float of array fail.", __func__);
         return false;
     }
+
+    std::vector<float>::size_type size = value.size();
+    for (std::vector<float>::size_type i = 0; i < size; i++) {
+        APP_LOGI("%{public}s float of array: %{public}f", __func__, value[i]);
+    }      
     return SetArray<float, Float>(g_IID_IFloat, value, ao);
 }
 
 bool WantParams::ReadFromParcelArrayDouble(Parcel &parcel, sptr<IArray> &ao)
 {
+    APP_LOGI("%{public}s called.", __func__);
     std::vector<double> value;
     if (!parcel.ReadDoubleVector(&value)) {
+        APP_LOGI("%{public}s read double of array fail.", __func__);
         return false;
     }
+
+    std::vector<double>::size_type size = value.size();
+    for (std::vector<double>::size_type i = 0; i < size; i++) {
+        APP_LOGI("%{public}s double of array: %{public}f", __func__, value[i]);
+    }     
     return SetArray<double, Double>(g_IID_IDouble, value, ao);
 }
 
@@ -951,24 +1017,34 @@ bool WantParams::ReadArrayToParcel(Parcel &parcel, int type, sptr<IArray> &ao)
     switch (type) {
         case VALUE_TYPE_STRINGARRAY:
         case VALUE_TYPE_CHARSEQUENCEARRAY:
+            APP_LOGI("%{public}s type=VALUE_TYPE_STRINGARRAY|VALUE_TYPE_CHARSEQUENCEARRAY.", __func__);
             return ReadFromParcelArrayString(parcel, ao);
         case VALUE_TYPE_BOOLEANARRAY:
+            APP_LOGI("%{public}s type=VALUE_TYPE_BOOLEANARRAY.", __func__);
             return ReadFromParcelArrayBool(parcel, ao);
         case VALUE_TYPE_BYTEARRAY:
+            APP_LOGI("%{public}s type=VALUE_TYPE_BYTEARRAY.", __func__);
             return ReadFromParcelArrayByte(parcel, ao);
         case VALUE_TYPE_CHARARRAY:
+            APP_LOGI("%{public}s type=VALUE_TYPE_CHARARRAY.", __func__);
             return ReadFromParcelArrayChar(parcel, ao);
         case VALUE_TYPE_SHORTARRAY:
+            APP_LOGI("%{public}s type=VALUE_TYPE_SHORTARRAY.", __func__);
             return ReadFromParcelArrayShort(parcel, ao);
         case VALUE_TYPE_INTARRAY:
+            APP_LOGI("%{public}s type=VALUE_TYPE_INTARRAY.", __func__);
             return ReadFromParcelArrayInt(parcel, ao);
         case VALUE_TYPE_LONGARRAY:
+            APP_LOGI("%{public}s type=VALUE_TYPE_LONGARRAY.", __func__);
             return ReadFromParcelArrayLong(parcel, ao);
         case VALUE_TYPE_FLOATARRAY:
+            APP_LOGI("%{public}s type=VALUE_TYPE_FLOATARRAY.", __func__);
             return ReadFromParcelArrayFloat(parcel, ao);
         case VALUE_TYPE_DOUBLEARRAY:
+            APP_LOGI("%{public}s type=VALUE_TYPE_DOUBLEARRAY.", __func__);
             return ReadFromParcelArrayDouble(parcel, ao);
         default:
+            APP_LOGI("%{public}s type=UNKNOWN, nothing to do.", __func__);
             break;
     }
 
@@ -978,79 +1054,116 @@ bool WantParams::ReadArrayToParcel(Parcel &parcel, int type, sptr<IArray> &ao)
 bool WantParams::ReadFromParcelString(Parcel &parcel, const std::string &key)
 {
     std::u16string value = parcel.ReadString16();
+    std::string strValue(Str16ToStr8(value));
+    APP_LOGI("%{public}s key=%{public}s, value=%{public}s.", __func__, key.c_str(), strValue.c_str());
     sptr<IInterface> intf = String::Box(Str16ToStr8(value));
     if (intf) {
+        APP_LOGI("%{public}s insert param: key=%{public}s, value=%{public}s.", 
+            __func__, key.c_str(), strValue.c_str());
         SetParam(key, intf);
+    } else {
+        APP_LOGI("%{public}s insert param fail, intf=nullptr: key=%{public}s, value=%{public}s.", 
+            __func__, key.c_str(), strValue.c_str());
     }
     return true;
 }
 
 bool WantParams::ReadFromParcelBool(Parcel &parcel, const std::string &key)
 {
+    APP_LOGI("%{public}s key=%{public}s.", __func__, key.c_str());
     int8_t value;
     if (parcel.ReadInt8(value)) {
+        APP_LOGI("%{public}s key=%{public}s, value=%{public}d", __func__, key.c_str(), (int)value);
         sptr<IInterface> intf = Boolean::Box(value);
         if (intf) {
             SetParam(key, intf);
+            APP_LOGI("%{public}s insert param: key=%{public}s, value=%{public}d", __func__, key.c_str(), (int)value);
+        } else {
+            APP_LOGI("%{public}s insert param fail: key=%{public}s", __func__, key.c_str());
         }
         return true;
     } else {
+        APP_LOGI("%{public}s read data fail: key=%{public}s", __func__, key.c_str());
         return false;
     }
 }
 
 bool WantParams::ReadFromParcelInt8(Parcel &parcel, const std::string &key)
 {
+    APP_LOGI("%{public}s key=%{public}s.", __func__, key.c_str());
     int8_t value;
     if (parcel.ReadInt8(value)) {
+        APP_LOGI("%{public}s key=%{public}s, value=%{public}d", __func__, key.c_str(), (int)value);
         sptr<IInterface> intf = Byte::Box(value);
         if (intf) {
             SetParam(key, intf);
+            APP_LOGI("%{public}s insert param: key=%{public}s, value=%{public}d", __func__, key.c_str(), (int)value);
+        } else {
+            APP_LOGI("%{public}s insert param fail: key=%{public}s", __func__, key.c_str());
         }
         return true;
     } else {
+        APP_LOGI("%{public}s read data fail: key=%{public}s", __func__, key.c_str());
         return false;
     }
 }
 
 bool WantParams::ReadFromParcelChar(Parcel &parcel, const std::string &key)
 {
+    APP_LOGI("%{public}s key=%{public}s.", __func__, key.c_str());
     int32_t value;
     if (parcel.ReadInt32(value)) {
+        APP_LOGI("%{public}s key=%{public}s, value=%{public}d", __func__, key.c_str(), (int)value);
         sptr<IInterface> intf = Char::Box(value);
         if (intf) {
             SetParam(key, intf);
+            APP_LOGI("%{public}s insert param: key=%{public}s, value=%{public}d", __func__, key.c_str(), (int)value);
+        } else {
+            APP_LOGI("%{public}s insert param fail: key=%{public}s", __func__, key.c_str());
         }
         return true;
     } else {
+        APP_LOGI("%{public}s read data fail: key=%{public}s", __func__, key.c_str());
         return false;
     }
 }
 
 bool WantParams::ReadFromParcelShort(Parcel &parcel, const std::string &key)
 {
+    APP_LOGI("%{public}s key=%{public}s.", __func__, key.c_str());
     short value;
     if (parcel.ReadInt16(value)) {
+        APP_LOGI("%{public}s key=%{public}s, value=%{public}d", __func__, key.c_str(), (int)value);
         sptr<IInterface> intf = Short::Box(value);
         if (intf) {
             SetParam(key, intf);
+            APP_LOGI("%{public}s insert param: key=%{public}s, value=%{public}d", __func__, key.c_str(), (int)value);
+        } else {
+            APP_LOGI("%{public}s insert param fail: key=%{public}s", __func__, key.c_str());
         }
         return true;
     } else {
+        APP_LOGI("%{public}s read data fail: key=%{public}s", __func__, key.c_str());
         return false;
     }
 }
 
 bool WantParams::ReadFromParcelInt(Parcel &parcel, const std::string &key)
 {
+    APP_LOGI("%{public}s key=%{public}s.", __func__, key.c_str());
     int value;
     if (parcel.ReadInt32(value)) {
+        APP_LOGI("%{public}s key=%{public}s, value=%{public}d", __func__, key.c_str(), (int)value);
         sptr<IInterface> intf = Integer::Box(value);
         if (intf) {
             SetParam(key, intf);
+            APP_LOGI("%{public}s insert param: key=%{public}s, value=%{public}d", __func__, key.c_str(), (int)value);
+        } else {
+            APP_LOGI("%{public}s insert param fail: key=%{public}s", __func__, key.c_str());
         }
         return true;
     } else {
+        APP_LOGI("%{public}s read data fail: key=%{public}s", __func__, key.c_str());
         return false;
     }
 }
@@ -1065,8 +1178,11 @@ bool WantParams::ReadFromParcelWantParamWrapper(Parcel &parcel, const std::strin
 }
 bool WantParams::ReadFromParcelLong(Parcel &parcel, const std::string &key)
 {
+    APP_LOGI("%{public}s key=%{public}s.", __func__, key.c_str());
     int64_t value;
     if (parcel.ReadInt64(value)) {
+        std::string strValue(std::to_string(value));
+        APP_LOGI("%{public}s key=%{public}s, value=%{public}s", __func__, key.c_str(), strValue.c_str());
         #ifdef WANT_PARAM_USE_LONG
             sptr<IInterface> intf = Long::Box(value);
         #else
@@ -1074,37 +1190,54 @@ bool WantParams::ReadFromParcelLong(Parcel &parcel, const std::string &key)
         #endif    
         if (intf) {
             SetParam(key, intf);
+            APP_LOGI("%{public}s insert param: key=%{public}s, value=%{public}s", __func__, 
+                key.c_str(), strValue.c_str());
+        } else {
+            APP_LOGI("%{public}s insert param fail: key=%{public}s", __func__, key.c_str());
         }
         return true;
     } else {
+        APP_LOGI("%{public}s read data fail: key=%{public}s", __func__, key.c_str());
         return false;
     }
 }
 
 bool WantParams::ReadFromParcelFloat(Parcel &parcel, const std::string &key)
 {
+    APP_LOGI("%{public}s key=%{public}s.", __func__, key.c_str());
     float value;
     if (parcel.ReadFloat(value)) {
+        APP_LOGI("%{public}s key=%{public}s, value=%{public}f", __func__, key.c_str(), value);
         sptr<IInterface> intf = Float::Box(value);
         if (intf) {
             SetParam(key, intf);
+            APP_LOGI("%{public}s insert param:key=%{public}s, value=%{public}f", __func__, key.c_str(), value);
+        } else {
+            APP_LOGI("%{public}s insert param fail: key=%{public}s", __func__, key.c_str());
         }
         return true;
     } else {
+        APP_LOGI("%{public}s read data fail: key=%{public}s", __func__, key.c_str());
         return false;
     }
 }
 
 bool WantParams::ReadFromParcelDouble(Parcel &parcel, const std::string &key)
 {
+    APP_LOGI("%{public}s key=%{public}s.", __func__, key.c_str());
     double value;
     if (parcel.ReadDouble(value)) {
+        APP_LOGI("%{public}s key=%{public}s, value=%{public}f", __func__, key.c_str(), value);
         sptr<IInterface> intf = Double::Box(value);
         if (intf) {
             SetParam(key, intf);
+            APP_LOGI("%{public}s insert param:key=%{public}s, value=%{public}f", __func__, key.c_str(), value);
+        } else {
+            APP_LOGI("%{public}s insert param fail: key=%{public}s", __func__, key.c_str());
         }
         return true;
     } else {
+        APP_LOGI("%{public}s read data fail: key=%{public}s", __func__, key.c_str());
         return false;
     }
 }
@@ -1150,42 +1283,60 @@ bool WantParams::ReadFromParcelParam(Parcel &parcel, const std::string &key, int
     switch (type) {
         case VALUE_TYPE_CHARSEQUENCE:
         case VALUE_TYPE_STRING:
+            APP_LOGI("%{public}s type=VALUE_TYPE_STRING, key=%{public}s.", __func__, key.c_str());
             return ReadFromParcelString(parcel, key);
         case VALUE_TYPE_BOOLEAN:
+            APP_LOGI("%{public}s type=VALUE_TYPE_BOOLEAN, key=%{public}s.", __func__, key.c_str());
             return ReadFromParcelBool(parcel, key);
         case VALUE_TYPE_BYTE:
+            APP_LOGI("%{public}s type=VALUE_TYPE_BYTE, key=%{public}s.", __func__, key.c_str());
             return ReadFromParcelInt8(parcel, key);
         case VALUE_TYPE_CHAR:
+            APP_LOGI("%{public}s type=VALUE_TYPE_CHAR, key=%{public}s.", __func__, key.c_str());
             return ReadFromParcelChar(parcel, key);
         case VALUE_TYPE_SHORT:
+            APP_LOGI("%{public}s type=VALUE_TYPE_SHORT, key=%{public}s.", __func__, key.c_str());
             return ReadFromParcelShort(parcel, key);
         case VALUE_TYPE_INT:
+            APP_LOGI("%{public}s type=VALUE_TYPE_INT, key=%{public}s.", __func__, key.c_str());
             return ReadFromParcelInt(parcel, key);
         case VALUE_TYPE_LONG:
+            APP_LOGI("%{public}s type=VALUE_TYPE_LONG, key=%{public}s.", __func__, key.c_str());
             return ReadFromParcelLong(parcel, key);
         case VALUE_TYPE_FLOAT:
+            APP_LOGI("%{public}s type=VALUE_TYPE_FLOAT, key=%{public}s.", __func__, key.c_str());
             return ReadFromParcelFloat(parcel, key);
         case VALUE_TYPE_DOUBLE:
+            APP_LOGI("%{public}s type=VALUE_TYPE_DOUBLE, key=%{public}s.", __func__, key.c_str());
             return ReadFromParcelDouble(parcel, key);
         case VALUE_TYPE_NULL:
+            APP_LOGI("%{public}s type=VALUE_TYPE_NULL, key=%{public}s.", __func__, key.c_str());
             break;
         case VALUE_TYPE_PARCELABLE:
         case VALUE_TYPE_PARCELABLEARRAY:
         case VALUE_TYPE_SERIALIZABLE:
         case VALUE_TYPE_LIST:
+            APP_LOGI("%{public}s type=VALUE_TYPE_PARCELABLE|VALUE_TYPE_PARCELABLEARRAY|VALUE_TYPE_SERIALIZABLE|"
+                "VALUE_TYPE_LIST, key=%{public}s.", __func__, key.c_str());
             if (!ReadUnsupportedData(parcel, key, type)) {
                 return false;
             }
             break;
         default: {
             // handle array
+            APP_LOGI("%{public}s type=XXXXX_ARRAY_XXXX, key=%{public}s.", __func__, key.c_str());
             sptr<IArray> ao = nullptr;
             if (!ReadArrayToParcel(parcel, type, ao)) {
+                APP_LOGI("%{public}s read array fail.", __func__);
                 return false;
             }
             sptr<IInterface> intf = ao;
             if (intf) {
                 SetParam(key, intf);
+                APP_LOGI("%{public}s save data to param. key=%{public}s", __func__, key.c_str());
+            } else {
+                APP_LOGI("%{public}s save data to param fail, intf=nullptr. key=%{public}s", 
+                    __func__, key.c_str());
             }
             break;
         }
@@ -1196,19 +1347,24 @@ bool WantParams::ReadFromParcelParam(Parcel &parcel, const std::string &key, int
 bool WantParams::ReadFromParcel(Parcel &parcel)
 {
     int32_t size;
-
     if (!parcel.ReadInt32(size)) {
+        APP_LOGI("%{public}s read size fail.", __func__);
         return false;
     }
+    APP_LOGI("%{public}s size=%{public}d.", __func__, size);
 
     for (int32_t i = 0; i < size; i++) {
+        APP_LOGI("%{public}s get i=%{public}d", __func__, i);
         std::u16string key = parcel.ReadString16();
         int type;
         if (!parcel.ReadInt32(type)) {
+            APP_LOGI("%{public}s read type fail.", __func__);
             return false;
         }
+        APP_LOGI("%{public}s get i=%{public}d, type=%{public}d.", __func__, i, type);
 
         if (!ReadFromParcelParam(parcel, Str16ToStr8(key), type)) {
+            APP_LOGI("%{public}s get i=%{public}d fail.", __func__, i);
             return false;
         }
     }
@@ -1225,21 +1381,28 @@ WantParams *WantParams::Unmarshalling(Parcel &parcel)
 {
     int32_t bufferSize;
     if (!parcel.ReadInt32(bufferSize)) {
+        APP_LOGI("%{public}s read bufferSize fail.", __func__);
         return nullptr;
     }
+    APP_LOGI("%{public}s bufferSize=%{public}d.", __func__, bufferSize);
 
     // Corresponding to Parcel#writeByteArray() in Java.
     int32_t length;
     if (!parcel.ReadInt32(length)) {
+        APP_LOGI("%{public}s read length fail.", __func__);
         return nullptr;
     }
+    APP_LOGI("%{public}s length=%{public}d.", __func__, length);
+
     const uint8_t *dataInBytes = parcel.ReadUnpadBuffer(bufferSize);
     if (dataInBytes == nullptr) {
+        APP_LOGI("%{public}s read buffer fail.", __func__);
         return nullptr;
     }
 
     Parcel tempParcel;
     if (!tempParcel.WriteBuffer(dataInBytes, bufferSize)) {
+        APP_LOGI("%{public}s tempParcel.WriteBuffer fail.", __func__);
         return nullptr;
     }
 
diff --git a/frameworks/kits/content/cpp/test/BUILD.gn b/frameworks/kits/content/cpp/test/BUILD.gn
index d0883d273b3dffeb5b3fa02d1d776585e87e207d..7d0b245cd77b505421b2e40f068f3db036cf1fd2 100755
--- a/frameworks/kits/content/cpp/test/BUILD.gn
+++ b/frameworks/kits/content/cpp/test/BUILD.gn
@@ -23,6 +23,7 @@ config("module_private_config") {
     "//sdk/appexecfwk/appexecfwk_base/include",
     "//foundation/aafwk/standard/interfaces/innerkits/want/include",
     "//foundation/aafwk/standard/interfaces/innerkits/intent/include",
+    "//foundation/appexecfwk/standard/common/log/include",
   ]
 
   defines = [
@@ -269,6 +270,7 @@ ohos_unittest("want_params_test") {
 
   deps = [
     "//foundation/aafwk/standard/interfaces/innerkits/base:base",
+    "//foundation/appexecfwk/standard/common:libappexecfwk_common",
     "//third_party/googletest:gtest_main",
     "//utils/native/base:utils",
   ]
diff --git a/frameworks/kits/content/cpp/test/unittest/common/want_params_test.cpp b/frameworks/kits/content/cpp/test/unittest/common/want_params_test.cpp
index ce882da200d8884b243bf84197e59b3d085c93f6..ca729b28b94bf5bba260877ed6264af11ad791ac 100644
--- a/frameworks/kits/content/cpp/test/unittest/common/want_params_test.cpp
+++ b/frameworks/kits/content/cpp/test/unittest/common/want_params_test.cpp
@@ -135,7 +135,8 @@ HWTEST_F(WantParamsBaseTest, AaFwk_WantParams_Parcelable_0400, Function | Medium
     Parcel in;
     wantParamsIn_->Marshalling(in);
     std::shared_ptr<WantParams> wantParamsOut_(WantParams::Unmarshalling(in));
-    EXPECT_EQ(valueLong, Long::Unbox(ILong::Query(wantParamsOut_->GetParam(keyStr))));
+    std::string outString(String::Unbox(IString::Query(wantParamsOut_->GetParam(keyStr))));
+    EXPECT_STREQ(std::to_string(valueLong).c_str(), outString.c_str());
 }
 }
 }
\ No newline at end of file