1 /* 2 * Copyright (c) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "test.h" 17 18 #include "napi/native_api.h" 19 #include "napi/native_node_api.h" 20 21 #include "js_convertxml.h" 22 #include "js_xml.h" 23 #include "utils/log.h" 24 25 using namespace OHOS::Xml; 26 27 /* @tc.name: ConvertXmlTest001 28 * @tc.desc: Convert the xml object containing only declaration items to a js object. 29 * @tc.type: FUNC 30 */ 31 HWTEST_F(NativeEngineTest, ConvertXmlTest001, testing::ext::TestSize.Level0) 32 { 33 size_t size = 1024; 34 void* pBuffer = nullptr; 35 napi_value arrayBuffer = nullptr; 36 napi_env env = (napi_env)engine_; 37 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer); 38 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8"); 39 xmlSerializer.SetDeclaration(); 40 41 Options op; 42 ConvertXml *convertXml = new ConvertXml(); 43 std::string xmlStr(reinterpret_cast<char*>(pBuffer)); 44 napi_value jsObj = convertXml->Convert(env, xmlStr); 45 46 // Do not set start tag '<' 47 napi_value declarationObj = nullptr; 48 napi_value declarationProp = nullptr; 49 napi_value versionVal = nullptr; 50 napi_value encodingVal = nullptr; 51 napi_get_named_property(env, jsObj, op.declaration.c_str(), &declarationObj); 52 napi_get_named_property(env, declarationObj, op.attributes.c_str(), &declarationProp); 53 napi_get_named_property(env, declarationProp, "version", &versionVal); 54 napi_get_named_property(env, declarationProp, "encoding", &encodingVal); 55 56 std::string verisonStr; 57 std::string encodingStr; 58 convertXml->DealNapiStrValue(env, versionVal, verisonStr); 59 convertXml->DealNapiStrValue(env, encodingVal, encodingStr); 60 EXPECT_STREQ(verisonStr.c_str(), "1.0"); 61 EXPECT_STREQ(encodingStr.c_str(), "utf-8"); 62 } 63 64 /* @tc.name: ConvertXmlTest002 65 * @tc.desc: Convert the xml object containing an empty element to a js object. 66 * @tc.type: FUNC 67 */ 68 HWTEST_F(NativeEngineTest, ConvertXmlTest002, testing::ext::TestSize.Level0) 69 { 70 size_t size = 1024; 71 void* pBuffer = nullptr; 72 napi_value arrayBuffer = nullptr; 73 napi_env env = (napi_env)engine_; 74 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer); 75 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8"); 76 xmlSerializer.StartElement("note1"); 77 xmlSerializer.EndElement(); 78 79 Options op; 80 ConvertXml *convertXml = new ConvertXml(); 81 std::string xmlStr(reinterpret_cast<char*>(pBuffer)); 82 napi_value jsObj = convertXml->Convert(env, xmlStr); 83 84 napi_value element = nullptr; 85 napi_value elements = nullptr; 86 napi_value nameVal = nullptr; 87 napi_value typeVal = nullptr; 88 napi_get_named_property(env, jsObj, op.elements.c_str(), &elements); 89 napi_get_element(env, elements, 0, &element); 90 napi_get_named_property(env, element, op.name.c_str(), &nameVal); 91 napi_get_named_property(env, element, op.type.c_str(), &typeVal); 92 93 std::string nameStr; 94 std::string typeStr; 95 convertXml->DealNapiStrValue(env, nameVal, nameStr); 96 convertXml->DealNapiStrValue(env, typeVal, typeStr); 97 EXPECT_STREQ(nameStr.c_str(), "note1"); 98 EXPECT_STREQ(typeStr.c_str(), "element"); 99 } 100 101 /* @tc.name: ConvertXmlTest003 102 * @tc.desc: Convert the xml object containing attributes to a js object. 103 * @tc.type: FUNC 104 */ 105 HWTEST_F(NativeEngineTest, ConvertXmlTest003, testing::ext::TestSize.Level0) 106 { 107 size_t size = 1024; 108 void* pBuffer = nullptr; 109 napi_value arrayBuffer = nullptr; 110 napi_env env = (napi_env)engine_; 111 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer); 112 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8"); 113 xmlSerializer.StartElement("note1"); 114 xmlSerializer.SetAttributes("colour", "red"); 115 xmlSerializer.SetAttributes("shape", "circle"); 116 xmlSerializer.EndElement(); 117 118 Options op; 119 ConvertXml *convertXml = new ConvertXml(); 120 std::string xmlStr(reinterpret_cast<char*>(pBuffer)); 121 napi_value jsObj = convertXml->Convert(env, xmlStr); 122 123 napi_value elements = nullptr; 124 napi_value element = nullptr; 125 napi_value attributes = nullptr; 126 napi_value colour = nullptr; 127 napi_value shape = nullptr; 128 napi_get_named_property(env, jsObj, op.elements.c_str(), &elements); 129 napi_get_element(env, elements, 0, &element); 130 napi_get_named_property(env, element, op.attributes.c_str(), &attributes); 131 napi_get_named_property(env, attributes, "colour", &colour); 132 napi_get_named_property(env, attributes, "shape", &shape); 133 134 std::string colourStr; 135 std::string shapeStr; 136 convertXml->DealNapiStrValue(env, colour, colourStr); 137 convertXml->DealNapiStrValue(env, shape, shapeStr); 138 EXPECT_STREQ(colourStr.c_str(), "red"); 139 EXPECT_STREQ(shapeStr.c_str(), "circle"); 140 } 141 142 /* @tc.name: ConvertXmlTest004 143 * @tc.desc: Convert the xml object containing comment to a js object. 144 * @tc.type: FUNC 145 */ 146 HWTEST_F(NativeEngineTest, ConvertXmlTest004, testing::ext::TestSize.Level0) 147 { 148 size_t size = 1024; 149 void* pBuffer = nullptr; 150 napi_value arrayBuffer = nullptr; 151 napi_env env = (napi_env)engine_; 152 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer); 153 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8"); 154 xmlSerializer.SetComment("This is a comment"); 155 xmlSerializer.StartElement("note1"); 156 xmlSerializer.EndElement(); 157 158 Options op; 159 ConvertXml *convertXml = new ConvertXml(); 160 std::string xmlStr(reinterpret_cast<char*>(pBuffer)); 161 napi_value jsObj = convertXml->Convert(env, xmlStr); 162 163 napi_value elements = nullptr; 164 napi_value element = nullptr; 165 napi_value commentType = nullptr; 166 napi_value commentText = nullptr; 167 EXPECT_EQ(napi_get_named_property(env, jsObj, op.elements.c_str(), &elements), napi_status::napi_ok); 168 EXPECT_EQ(napi_get_element(env, elements, 0, &element), napi_status::napi_ok); 169 EXPECT_EQ(napi_get_named_property(env, element, op.type.c_str(), &commentType), napi_status::napi_ok); 170 EXPECT_EQ(napi_get_named_property(env, element, op.comment.c_str(), &commentText), napi_status::napi_ok); 171 172 std::string commentTypeStr; 173 std::string commentTextStr; 174 convertXml->DealNapiStrValue(env, commentType, commentTypeStr); 175 convertXml->DealNapiStrValue(env, commentText, commentTextStr); 176 EXPECT_STREQ(commentTypeStr.c_str(), "comment"); 177 EXPECT_STREQ(commentTextStr.c_str(), "This is a comment"); 178 } 179 180 /* @tc.name: ConvertXmlTest005 181 * @tc.desc: Convert the xml object containing cdata to a js object. 182 * @tc.type: FUNC 183 */ 184 HWTEST_F(NativeEngineTest, ConvertXmlTest005, testing::ext::TestSize.Level0) 185 { 186 size_t size = 1024; 187 void* pBuffer = nullptr; 188 napi_value arrayBuffer = nullptr; 189 napi_env env = (napi_env)engine_; 190 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer); 191 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8"); 192 xmlSerializer.SetCData("function foo() {}"); 193 xmlSerializer.StartElement("note1"); 194 xmlSerializer.EndElement(); 195 196 Options op; 197 ConvertXml *convertXml = new ConvertXml(); 198 std::string xmlStr(reinterpret_cast<char*>(pBuffer)); 199 napi_value jsObj = convertXml->Convert(env, xmlStr); 200 201 napi_value elements = nullptr; 202 napi_value element = nullptr; 203 napi_value cdataType = nullptr; 204 napi_value cdataText = nullptr; 205 EXPECT_EQ(napi_get_named_property(env, jsObj, op.elements.c_str(), &elements), napi_status::napi_ok); 206 EXPECT_EQ(napi_get_element(env, elements, 0, &element), napi_status::napi_ok); 207 EXPECT_EQ(napi_get_named_property(env, element, op.type.c_str(), &cdataType), napi_status::napi_ok); 208 EXPECT_EQ(napi_get_named_property(env, element, op.cdata.c_str(), &cdataText), napi_status::napi_ok); 209 210 std::string cdataTypeStr; 211 std::string cdataTextStr; 212 convertXml->DealNapiStrValue(env, cdataType, cdataTypeStr); 213 convertXml->DealNapiStrValue(env, cdataText, cdataTextStr); 214 EXPECT_STREQ(cdataTypeStr.c_str(), "cdata"); 215 EXPECT_STREQ(cdataTextStr.c_str(), "function foo() {}"); 216 } 217 218 /* @tc.name: ConvertXmlTest006 219 * @tc.desc: Convert the xml object containing doctype to a js object. 220 * @tc.type: FUNC 221 */ 222 HWTEST_F(NativeEngineTest, ConvertXmlTest006, testing::ext::TestSize.Level0) 223 { 224 size_t size = 1024; 225 void* pBuffer = nullptr; 226 napi_value arrayBuffer = nullptr; 227 napi_env env = (napi_env)engine_; 228 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer); 229 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8"); 230 xmlSerializer.SetDocType("root SYSTEM \"http://www.test.org/test.dtd\""); 231 xmlSerializer.StartElement("note1"); 232 xmlSerializer.EndElement(); 233 234 Options op; 235 ConvertXml *convertXml = new ConvertXml(); 236 std::string xmlStr(reinterpret_cast<char*>(pBuffer)); 237 napi_value jsObj = convertXml->Convert(env, xmlStr); 238 239 napi_value elements = nullptr; 240 napi_value element = nullptr; 241 napi_value docType = nullptr; 242 napi_value docText = nullptr; 243 EXPECT_EQ(napi_get_named_property(env, jsObj, op.elements.c_str(), &elements), napi_status::napi_ok); 244 EXPECT_EQ(napi_get_element(env, elements, 0, &element), napi_status::napi_ok); 245 EXPECT_EQ(napi_get_named_property(env, element, op.type.c_str(), &docType), napi_status::napi_ok); 246 EXPECT_EQ(napi_get_named_property(env, element, op.doctype.c_str(), &docText), napi_status::napi_ok); 247 248 std::string docTypeStr; 249 std::string docStr; 250 convertXml->DealNapiStrValue(env, docType, docTypeStr); 251 convertXml->DealNapiStrValue(env, docText, docStr); 252 EXPECT_STREQ(docTypeStr.c_str(), "doctype"); 253 EXPECT_STREQ(docStr.c_str(), "root"); 254 } 255 256 /* @tc.name: ConstructorTest001 257 * @tc.desc: Convert the xml object containing doctype to a js object. 258 * @tc.type: FUNC 259 */ 260 HWTEST_F(NativeEngineTest, ConstructorTest001, testing::ext::TestSize.Level0) 261 { 262 napi_env env = (napi_env)engine_; 263 OHOS::Xml::ConvertXml convertXml = OHOS::Xml::ConvertXml(); 264 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"; 265 std::string str2 = "<note importance=\"high\" logged=\"true\"><todo>Play</todo></note>"; 266 std::string strXml = str1 + str2; 267 napi_valuetype valuetype = napi_undefined; 268 269 napi_typeof(env, convertXml.Convert(env, strXml), &valuetype); 270 bool isObj = valuetype == napi_valuetype::napi_object; 271 ASSERT_TRUE(isObj); 272 } 273 274 /* @tc.name: ConstructorTest002 275 * @tc.desc: Convert the xml object containing doctype to a js object. 276 * @tc.type: FUNC 277 */ 278 HWTEST_F(NativeEngineTest, ConstructorTest002, testing::ext::TestSize.Level0) 279 { 280 napi_env env = (napi_env)engine_; 281 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"; 282 std::string str2 = "<note importance=\"high\" logged=\"true\"><todo>Play</todo></note>"; 283 std::string strXml = str1 + str2; 284 napi_value object = nullptr; 285 const char* utf8Name = "_declaration"; 286 napi_create_object(env, &object); 287 bool isHas = false; 288 OHOS::Xml::ConvertXml convertXml = OHOS::Xml::ConvertXml(); 289 290 object = convertXml.Convert(env, strXml); 291 napi_has_named_property(env, object, utf8Name, &isHas); 292 ASSERT_TRUE(isHas); 293 } 294 295 /* @tc.name: ConstructorTest003 296 * @tc.desc: Convert the xml object containing doctype to a js object. 297 * @tc.type: FUNC 298 */ 299 HWTEST_F(NativeEngineTest, ConstructorTest003, testing::ext::TestSize.Level0) 300 { 301 napi_env env = (napi_env)engine_; 302 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"; 303 std::string str2 = "<note importance=\"high\" logged=\"true\"><todo>Play</todo></note>"; 304 std::string strXml = str1 + str2; 305 napi_value object = nullptr; 306 const char* utf8Name = "_declaration"; 307 napi_create_object(env, &object); 308 bool isHas = false; 309 OHOS::Xml::ConvertXml convertXml = OHOS::Xml::ConvertXml(); 310 311 object = convertXml.Convert(env, strXml); 312 napi_has_named_property(env, object, utf8Name, &isHas); 313 ASSERT_TRUE(isHas); 314 } 315 316 /* @tc.name: ConvertTest001 317 * @tc.desc: Convert the xml object containing doctype to a js object. 318 * @tc.type: FUNC 319 */ 320 HWTEST_F(NativeEngineTest, ConvertTest001, testing::ext::TestSize.Level0) 321 { 322 napi_env env = (napi_env)engine_; 323 OHOS::Xml::ConvertXml convertXml = OHOS::Xml::ConvertXml(); 324 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><note importance=\"high\" logged=\"true\"> "; 325 std::string str2 = "<title>Happy</title> <todo>Work</todo> <todo>Play</todo></note>"; 326 std::string strXml = str1 + str2; 327 napi_valuetype valuetype = napi_undefined; 328 329 napi_typeof(env, convertXml.Convert(env, strXml), &valuetype); 330 bool isObj = valuetype == napi_valuetype::napi_object; 331 ASSERT_TRUE(isObj); 332 } 333 334 /* @tc.name: ConvertTest002 335 * @tc.desc: Convert the xml object containing doctype to a js object. 336 * @tc.type: FUNC 337 */ 338 HWTEST_F(NativeEngineTest, ConvertTest002, testing::ext::TestSize.Level0) 339 { 340 napi_env env = (napi_env)engine_; 341 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><note importance=\"high\" logged=\"true\"> "; 342 std::string str2 = "<title>Happy</title> <todo>Work</todo> <todo>Play</todo></note>"; 343 std::string strXml = str1 + str2; 344 napi_value object = nullptr; 345 const char* utf8Name = "_declaration"; 346 napi_create_object(env, &object); 347 bool isHas = false; 348 OHOS::Xml::ConvertXml convertXml = OHOS::Xml::ConvertXml(); 349 350 object = convertXml.Convert(env, strXml); 351 napi_has_named_property(env, object, utf8Name, &isHas); 352 ASSERT_TRUE(isHas); 353 } 354 355 /* @tc.name: ConvertTest003 356 * @tc.desc: Convert the xml object containing doctype to a js object. 357 * @tc.type: FUNC 358 */ 359 HWTEST_F(NativeEngineTest, ConvertTest003, testing::ext::TestSize.Level0) 360 { 361 napi_env env = (napi_env)engine_; 362 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><note importance=\"high\" logged=\"true\"> "; 363 std::string str2 = "<title>Happy</title> <todo>Work</todo> <todo>Play</todo></note>"; 364 std::string strXml = str1 + str2; 365 napi_value object = nullptr; 366 const char* utf8Name = "_elements"; 367 napi_create_object(env, &object); 368 bool isHas = false; 369 OHOS::Xml::ConvertXml convertXml = OHOS::Xml::ConvertXml(); 370 371 object = convertXml.Convert(env, strXml); 372 napi_has_named_property(env, object, utf8Name, &isHas); 373 ASSERT_TRUE(isHas); 374 } 375