1 /* 2 * Copyright (c) 2021 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 "ecmascript/ecma_string-inl.h" 17 #include "common_interfaces/objects/string/base_string_impl.h" 18 #include "ecmascript/object_factory.h" 19 #include "ecmascript/tests/ecma_test_common.h" 20 21 using namespace panda::ecmascript; 22 23 namespace panda::test { 24 class BaseStringTest : public BaseTestWithScope<false> { 25 public: SetUpTestCase()26 static void SetUpTestCase() 27 { 28 GTEST_LOG_(INFO) << "SetUpTestCase"; 29 uint8_t arrayU8[] = {12, 34, 77, 127, 99, 1}; 30 uint16_t arrayU16Comp[] = {1, 4, 37, 91, 127, 1}; 31 uint16_t arrayU16NotComp[] = {72, 43, 337, 961, 1317, 65535}; 32 EXPECT_TRUE(BaseString::CanBeCompressed(arrayU8, sizeof(arrayU8) / sizeof(arrayU8[0]))); 33 EXPECT_TRUE(BaseString::CanBeCompressed(arrayU16Comp, sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]))); 34 EXPECT_FALSE(BaseString::CanBeCompressed(arrayU16NotComp, sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]))); 35 } 36 LoadBarrier()37 auto LoadBarrier() 38 { 39 return [this](const void *obj, size_t offset) { return Barriers::GetTaggedObject(thread, obj, offset); }; 40 } LoadTBarrier()41 auto LoadTBarrier() 42 { 43 return [this](const void *obj, size_t offset) { return Barriers::GetTaggedObject<>(thread, obj, offset); }; 44 } 45 }; 46 47 /* 48 * @tc.name: CanBeCompressed 49 * @tc.desc: Check whether the bool returned through calling CanBeCompressed function is within expectations. 50 * @tc.type: FUNC 51 * @tc.require: 52 */ HWTEST_F_L0(BaseStringTest,CanBeCompressed)53 HWTEST_F_L0(BaseStringTest, CanBeCompressed) 54 { 55 uint8_t arrayU8[] = {12, 34, 77, 127, 99, 1}; 56 uint16_t arrayU16Comp[] = {1, 4, 37, 91, 127, 1}; 57 uint16_t arrayU16NotComp[] = {72, 43, 337, 961, 1317, 65535}; 58 EXPECT_TRUE(BaseString::CanBeCompressed(arrayU8, sizeof(arrayU8) / sizeof(arrayU8[0]))); 59 EXPECT_TRUE(BaseString::CanBeCompressed(arrayU16Comp, sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]))); 60 EXPECT_FALSE(BaseString::CanBeCompressed(arrayU16NotComp, sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]))); 61 } 62 63 /* 64 * @tc.name: CreateEmptyString 65 * @tc.desc: Check whether the EcmaString created through calling CreateEmptyString function is within expectations. 66 * @tc.type: FUNC 67 * @tc.require: 68 */ HWTEST_F_L0(BaseStringTest,CreateEmptyString)69 HWTEST_F_L0(BaseStringTest, CreateEmptyString) 70 { 71 JSHandle<EcmaString> handleEcmaStrEmpty(thread, EcmaStringAccessor::CreateEmptyString(instance)); 72 EXPECT_EQ(handleEcmaStrEmpty->ToBaseString()->GetLength(), 0U); 73 EXPECT_TRUE(handleEcmaStrEmpty->ToBaseString()->IsUtf8()); 74 EXPECT_FALSE(handleEcmaStrEmpty->ToBaseString()->IsUtf16()); 75 } 76 77 /* 78 * @tc.name: CreateLineString 79 * @tc.desc: Check whether the EcmaString created through calling CreateLineString function is within expectations. 80 * @tc.type: FUNC 81 * @tc.require: 82 */ HWTEST_F_L0(BaseStringTest,CreateLineString)83 HWTEST_F_L0(BaseStringTest, CreateLineString) 84 { 85 // CreateLineString( , true, ). 86 size_t sizeAllocComp = 5; 87 JSHandle<EcmaString> handleEcmaStrAllocComp( 88 thread, EcmaStringAccessor::CreateLineString(instance, sizeAllocComp, true)); 89 EXPECT_EQ(handleEcmaStrAllocComp->ToBaseString()->GetLength(), sizeAllocComp); 90 EXPECT_TRUE(handleEcmaStrAllocComp->ToBaseString()->IsUtf8()); 91 EXPECT_FALSE(handleEcmaStrAllocComp->ToBaseString()->IsUtf16()); 92 93 // CreateLineString( , false, ). 94 size_t sizeAllocNotComp = 5; 95 JSHandle<EcmaString> handleEcmaStrAllocNotComp(thread, 96 EcmaStringAccessor::CreateLineString( 97 instance, sizeAllocNotComp, false)); 98 EXPECT_EQ(handleEcmaStrAllocNotComp->ToBaseString()->GetLength(), sizeAllocNotComp); 99 EXPECT_FALSE(handleEcmaStrAllocNotComp->ToBaseString()->IsUtf8()); 100 EXPECT_TRUE(handleEcmaStrAllocNotComp->ToBaseString()->IsUtf16()); 101 } 102 103 /* 104 * @tc.name: CreateFromUtf8 105 * @tc.desc: Check whether the EcmaString created through calling CreateFromUtf8 function is within expectations. 106 * @tc.type: FUNC 107 * @tc.require: 108 */ HWTEST_F_L0(BaseStringTest,CreateFromUtf8)109 HWTEST_F_L0(BaseStringTest, CreateFromUtf8) 110 { 111 uint8_t arrayU8[] = {"xyz123!@#"}; 112 size_t lengthEcmaStrU8 = sizeof(arrayU8) - 1; 113 JSHandle<EcmaString> handleEcmaStrU8(thread, 114 EcmaStringAccessor::CreateFromUtf8( 115 instance, &arrayU8[0], lengthEcmaStrU8, true)); 116 for (uint32_t i = 0; i < lengthEcmaStrU8; i++) { 117 EXPECT_EQ(arrayU8[i], handleEcmaStrU8->ToBaseString()->At(LoadTBarrier(), i)); 118 } 119 EXPECT_EQ(handleEcmaStrU8->ToBaseString()->GetLength(), lengthEcmaStrU8); 120 EXPECT_TRUE(handleEcmaStrU8->ToBaseString()->IsUtf8()); 121 EXPECT_FALSE(handleEcmaStrU8->ToBaseString()->IsUtf16()); 122 } 123 124 /* 125 * @tc.name: CreateFromUtf16 126 * @tc.desc: Check whether the EcmaString created through calling CreateFromUtf16 function is within expectations. 127 * @tc.type: FUNC 128 * @tc.require: 129 */ HWTEST_F_L0(BaseStringTest,CreateFromUtf16)130 HWTEST_F_L0(BaseStringTest, CreateFromUtf16) 131 { 132 // CreateFromUtf16( , , , true). 133 uint16_t arrayU16Comp[] = {1, 23, 45, 67, 127}; 134 size_t lengthEcmaStrU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]); 135 JSHandle<EcmaString> handleEcmaStrU16Comp(thread, 136 EcmaStringAccessor::CreateFromUtf16( 137 instance, &arrayU16Comp[0], lengthEcmaStrU16Comp, true)); 138 EXPECT_EQ(handleEcmaStrU16Comp->ToBaseString()->GetLength(), lengthEcmaStrU16Comp); 139 EXPECT_TRUE(handleEcmaStrU16Comp->ToBaseString()->IsUtf8()); 140 EXPECT_FALSE(handleEcmaStrU16Comp->ToBaseString()->IsUtf16()); 141 142 // CreateFromUtf16( , , , false). 143 uint16_t arrayU16NotComp[] = {127, 33, 128, 12, 256, 11100, 65535}; 144 size_t lengthEcmaStrU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]); 145 JSHandle<EcmaString> handleEcmaStrU16NotComp(thread, 146 EcmaStringAccessor::CreateFromUtf16( 147 instance, &arrayU16NotComp[0], lengthEcmaStrU16NotComp, 148 false)); 149 EXPECT_EQ(handleEcmaStrU16NotComp->ToBaseString()->GetLength(), lengthEcmaStrU16NotComp); 150 EXPECT_FALSE(handleEcmaStrU16NotComp->ToBaseString()->IsUtf8()); 151 EXPECT_TRUE(handleEcmaStrU16NotComp->ToBaseString()->IsUtf16()); 152 } 153 154 /* 155 * @tc.name: ObjectSize 156 * @tc.desc: Check whether the value returned through calling ObjectSize function is within expectations. 157 * @tc.type: FUNC 158 * @tc.require: 159 */ HWTEST_F_L0(BaseStringTest,ObjectSize)160 HWTEST_F_L0(BaseStringTest, ObjectSize) 161 { 162 JSHandle<EcmaString> handleEcmaStrEmpty(thread, EcmaStringAccessor::CreateEmptyString(instance)); 163 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrEmpty).ObjectSize(), BaseString::SIZE + 0); 164 165 size_t lengthEcmaStrAllocComp = 5; 166 JSHandle<EcmaString> handleEcmaStrAllocComp(thread, 167 EcmaStringAccessor::CreateLineString( 168 instance, lengthEcmaStrAllocComp, true)); 169 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrAllocComp).ObjectSize(), 170 BaseString::SIZE + sizeof(uint8_t) * lengthEcmaStrAllocComp); 171 172 size_t lengthEcmaStrAllocNotComp = 5; 173 JSHandle<EcmaString> handleEcmaStrAllocNotComp(thread, 174 EcmaStringAccessor::CreateLineString( 175 instance, lengthEcmaStrAllocNotComp, false)); 176 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrAllocNotComp).ObjectSize(), 177 BaseString::SIZE + sizeof(uint16_t) * lengthEcmaStrAllocNotComp); 178 179 uint8_t arrayU8[] = {"abcde"}; 180 size_t lengthEcmaStrU8 = sizeof(arrayU8) - 1; 181 JSHandle<EcmaString> handleEcmaStrU8(thread, 182 EcmaStringAccessor::CreateFromUtf8( 183 instance, &arrayU8[0], lengthEcmaStrU8, true)); 184 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU8).ObjectSize(), 185 BaseString::SIZE + sizeof(uint8_t) * lengthEcmaStrU8); 186 187 // ObjectSize(). EcmaString made by CreateFromUtf16( , , , true). 188 uint16_t arrayU16Comp[] = {1, 23, 45, 67, 127}; 189 size_t lengthEcmaStrU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]); 190 JSHandle<EcmaString> handleEcmaStrU16Comp(thread, 191 EcmaStringAccessor::CreateFromUtf16( 192 instance, &arrayU16Comp[0], lengthEcmaStrU16Comp, true)); 193 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU16Comp).ObjectSize(), 194 BaseString::SIZE + sizeof(uint8_t) * lengthEcmaStrU16Comp); 195 196 // ObjectSize(). EcmaString made by CreateFromUtf16( , , , false). 197 uint16_t arrayU16NotComp[] = {127, 128, 256, 11100, 65535}; 198 size_t lengthEcmaStrU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]); 199 JSHandle<EcmaString> handleEcmaStrU16NotComp(thread, 200 EcmaStringAccessor::CreateFromUtf16( 201 instance, &arrayU16NotComp[0], lengthEcmaStrU16NotComp, 202 false)); 203 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU16NotComp).ObjectSize(), 204 BaseString::SIZE + sizeof(uint16_t) * lengthEcmaStrU16NotComp); 205 } 206 207 /* 208 * @tc.name: Compare_001 209 * @tc.desc: Check whether the value returned through calling Compare function between EcmaStrings made by 210 * CreateFromUtf8() is within expectations. 211 * @tc.type: FUNC 212 * @tc.require: 213 */ HWTEST_F_L0(BaseStringTest,Compare_001)214 HWTEST_F_L0(BaseStringTest, Compare_001) 215 { 216 // Compare(). Between EcmaStrings made by CreateFromUtf8(). 217 uint8_t arrayU8No1[3] = {1, 23}; 218 uint8_t arrayU8No2[4] = {1, 23, 49}; 219 uint8_t arrayU8No3[6] = {1, 23, 45, 97, 127}; 220 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1; 221 uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1; 222 uint32_t lengthEcmaStrU8No3 = sizeof(arrayU8No3) - 1; 223 JSHandle<EcmaString> handleEcmaStrU8No1(thread, 224 EcmaStringAccessor::CreateFromUtf8( 225 instance, &arrayU8No1[0], lengthEcmaStrU8No1, true)); 226 JSHandle<EcmaString> handleEcmaStrU8No2(thread, 227 EcmaStringAccessor::CreateFromUtf8( 228 instance, &arrayU8No2[0], lengthEcmaStrU8No2, true)); 229 JSHandle<EcmaString> handleEcmaStrU8No3(thread, 230 EcmaStringAccessor::CreateFromUtf8( 231 instance, &arrayU8No3[0], lengthEcmaStrU8No3, true)); 232 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No1, handleEcmaStrU8No2), -1); 233 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No2, handleEcmaStrU8No1), 1); 234 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No2, handleEcmaStrU8No3), 49 - 45); 235 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No3, handleEcmaStrU8No2), 45 - 49); 236 } 237 238 /* 239 * @tc.name: Compare_002 240 * @tc.desc: Check whether the value returned through calling Compare function between EcmaStrings made by 241 * CreateFromUtf16( , , , true) is within expectations. 242 * @tc.type: FUNC 243 * @tc.require: 244 */ HWTEST_F_L0(BaseStringTest,Compare_002)245 HWTEST_F_L0(BaseStringTest, Compare_002) 246 { 247 // Compare(). Between EcmaStrings made by CreateFromUtf16( , , , true). 248 uint16_t arrayU16CompNo1[] = {1, 23}; 249 uint16_t arrayU16CompNo2[] = {1, 23, 49}; 250 uint16_t arrayU16CompNo3[] = {1, 23, 45, 97, 127}; 251 uint32_t lengthEcmaStrU16CompNo1 = sizeof(arrayU16CompNo1) / sizeof(arrayU16CompNo1[0]); 252 uint32_t lengthEcmaStrU16CompNo2 = sizeof(arrayU16CompNo2) / sizeof(arrayU16CompNo2[0]); 253 uint32_t lengthEcmaStrU16CompNo3 = sizeof(arrayU16CompNo3) / sizeof(arrayU16CompNo3[0]); 254 JSHandle<EcmaString> handleEcmaStrU16CompNo1(thread, 255 EcmaStringAccessor::CreateFromUtf16( 256 instance, &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1, true)); 257 JSHandle<EcmaString> handleEcmaStrU16CompNo2(thread, 258 EcmaStringAccessor::CreateFromUtf16( 259 instance, &arrayU16CompNo2[0], lengthEcmaStrU16CompNo2, true)); 260 JSHandle<EcmaString> handleEcmaStrU16CompNo3(thread, 261 EcmaStringAccessor::CreateFromUtf16( 262 instance, &arrayU16CompNo3[0], lengthEcmaStrU16CompNo3, true)); 263 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16CompNo1, handleEcmaStrU16CompNo2), -1); 264 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16CompNo2, handleEcmaStrU16CompNo1), 1); 265 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16CompNo2, handleEcmaStrU16CompNo3), 49 - 45); 266 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16CompNo3, handleEcmaStrU16CompNo2), 45 - 49); 267 } 268 269 /* 270 * @tc.name: Compare_003 271 * @tc.desc: Check whether the value returned through calling Compare function between EcmaString made by 272 * CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , true) made by CreateFromUtf16( , , , true) is 273 * within expectations. 274 * @tc.type: FUNC 275 * @tc.require: 276 */ HWTEST_F_L0(BaseStringTest,Compare_003)277 HWTEST_F_L0(BaseStringTest, Compare_003) 278 { 279 // Compare(). EcmaString made by CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , true). 280 uint8_t arrayU8No1[3] = {1, 23}; 281 uint8_t arrayU8No2[4] = {1, 23, 49}; 282 uint16_t arrayU16CompNo1[] = {1, 23}; 283 uint16_t arrayU16CompNo2[] = {1, 23, 49}; 284 uint16_t arrayU16CompNo3[] = {1, 23, 45, 97, 127}; 285 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1; 286 uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1; 287 uint32_t lengthEcmaStrU16CompNo1 = sizeof(arrayU16CompNo1) / sizeof(arrayU16CompNo1[0]); 288 uint32_t lengthEcmaStrU16CompNo2 = sizeof(arrayU16CompNo2) / sizeof(arrayU16CompNo2[0]); 289 uint32_t lengthEcmaStrU16CompNo3 = sizeof(arrayU16CompNo3) / sizeof(arrayU16CompNo3[0]); 290 JSHandle<EcmaString> handleEcmaStrU8No1(thread, 291 EcmaStringAccessor::CreateFromUtf8( 292 instance, &arrayU8No1[0], lengthEcmaStrU8No1, true)); 293 JSHandle<EcmaString> handleEcmaStrU8No2(thread, 294 EcmaStringAccessor::CreateFromUtf8( 295 instance, &arrayU8No2[0], lengthEcmaStrU8No2, true)); 296 JSHandle<EcmaString> handleEcmaStrU16CompNo1(thread, 297 EcmaStringAccessor::CreateFromUtf16( 298 instance, &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1, true)); 299 JSHandle<EcmaString> handleEcmaStrU16CompNo2(thread, 300 EcmaStringAccessor::CreateFromUtf16( 301 instance, &arrayU16CompNo2[0], lengthEcmaStrU16CompNo2, true)); 302 JSHandle<EcmaString> handleEcmaStrU16CompNo3(thread, 303 EcmaStringAccessor::CreateFromUtf16( 304 instance, &arrayU16CompNo3[0], lengthEcmaStrU16CompNo3, true)); 305 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No1, handleEcmaStrU16CompNo1), 0); 306 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16CompNo1, handleEcmaStrU8No1), 0); 307 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No1, handleEcmaStrU16CompNo2), -1); 308 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16CompNo2, handleEcmaStrU8No1), 1); 309 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No2, handleEcmaStrU16CompNo3), 49 - 45); 310 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16CompNo3, handleEcmaStrU8No2), 45 - 49); 311 } 312 313 /* 314 * @tc.name: Compare_004 315 * @tc.desc: Check whether the value returned through calling Compare function between EcmaStrings made by 316 * CreateFromUtf16( , , , false) is within expectations. 317 * @tc.type: FUNC 318 * @tc.require: 319 */ HWTEST_F_L0(BaseStringTest,Compare_004)320 HWTEST_F_L0(BaseStringTest, Compare_004) 321 { 322 // Compare(). Between EcmaStrings made by CreateFromUtf16( , , , false). 323 uint16_t arrayU16NotCompNo1[] = {1, 23}; 324 uint16_t arrayU16NotCompNo2[] = {1, 23, 49}; 325 uint16_t arrayU16NotCompNo3[] = {1, 23, 456, 6789, 65535, 127}; 326 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]); 327 uint32_t lengthEcmaStrU16NotCompNo2 = sizeof(arrayU16NotCompNo2) / sizeof(arrayU16NotCompNo2[0]); 328 uint32_t lengthEcmaStrU16NotCompNo3 = sizeof(arrayU16NotCompNo3) / sizeof(arrayU16NotCompNo3[0]); 329 JSHandle<EcmaString> handleEcmaStrU16NotCompNo1(thread, 330 EcmaStringAccessor::CreateFromUtf16( 331 instance, &arrayU16NotCompNo1[0], 332 lengthEcmaStrU16NotCompNo1, true)); 333 JSHandle<EcmaString> handleEcmaStrU16NotCompNo2(thread, 334 EcmaStringAccessor::CreateFromUtf16( 335 instance, &arrayU16NotCompNo2[0], 336 lengthEcmaStrU16NotCompNo2, true)); 337 JSHandle<EcmaString> handleEcmaStrU16NotCompNo3(thread, 338 EcmaStringAccessor::CreateFromUtf16( 339 instance, &arrayU16NotCompNo3[0], 340 lengthEcmaStrU16NotCompNo3, false)); 341 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo1, handleEcmaStrU16NotCompNo2), -1); 342 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo2, handleEcmaStrU16NotCompNo1), 1); 343 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo2, handleEcmaStrU16NotCompNo3), 344 49 - 456); 345 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo3, handleEcmaStrU16NotCompNo2), 346 456 - 49); 347 } 348 349 /* 350 * @tc.name: Compare_005 351 * @tc.desc: Check whether the value returned through calling Compare function between EcmaString made by 352 * CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false) is within expectations. 353 * @tc.type: FUNC 354 * @tc.require: 355 */ HWTEST_F_L0(BaseStringTest,Compare_005)356 HWTEST_F_L0(BaseStringTest, Compare_005) 357 { 358 // Compare(). EcmaString made by CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false). 359 uint8_t arrayU8No1[3] = {1, 23}; 360 uint8_t arrayU8No2[4] = {1, 23, 49}; 361 uint16_t arrayU16NotCompNo1[] = {1, 23}; 362 uint16_t arrayU16NotCompNo2[] = {1, 23, 49}; 363 uint16_t arrayU16NotCompNo3[] = {1, 23, 456, 6789, 65535, 127}; 364 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1; 365 uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1; 366 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]); 367 uint32_t lengthEcmaStrU16NotCompNo2 = sizeof(arrayU16NotCompNo2) / sizeof(arrayU16NotCompNo2[0]); 368 uint32_t lengthEcmaStrU16NotCompNo3 = sizeof(arrayU16NotCompNo3) / sizeof(arrayU16NotCompNo3[0]); 369 JSHandle<EcmaString> handleEcmaStrU8No1(thread, 370 EcmaStringAccessor::CreateFromUtf8( 371 instance, &arrayU8No1[0], lengthEcmaStrU8No1, true)); 372 JSHandle<EcmaString> handleEcmaStrU8No2(thread, 373 EcmaStringAccessor::CreateFromUtf8( 374 instance, &arrayU8No2[0], lengthEcmaStrU8No2, true)); 375 JSHandle<EcmaString> handleEcmaStrU16NotCompNo1(thread, 376 EcmaStringAccessor::CreateFromUtf16( 377 instance, &arrayU16NotCompNo1[0], 378 lengthEcmaStrU16NotCompNo1, true)); 379 JSHandle<EcmaString> handleEcmaStrU16NotCompNo2(thread, 380 EcmaStringAccessor::CreateFromUtf16( 381 instance, &arrayU16NotCompNo2[0], 382 lengthEcmaStrU16NotCompNo2, true)); 383 JSHandle<EcmaString> handleEcmaStrU16NotCompNo3(thread, 384 EcmaStringAccessor::CreateFromUtf16( 385 instance, &arrayU16NotCompNo3[0], 386 lengthEcmaStrU16NotCompNo3, false)); 387 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No1, handleEcmaStrU16NotCompNo1), 0); 388 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo1, handleEcmaStrU8No1), 0); 389 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No1, handleEcmaStrU16NotCompNo2), -1); 390 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo2, handleEcmaStrU8No1), 1); 391 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No2, handleEcmaStrU16NotCompNo3), 49 - 456); 392 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo3, handleEcmaStrU8No2), 456 - 49); 393 } 394 395 /* 396 * @tc.name: Compare_006 397 * @tc.desc: Check whether the value returned through calling Compare function between EcmaString made by 398 * CreateFromUtf16( , , , true) and EcmaString made by CreateFromUtf16( , , , false) is within expectations. 399 * @tc.type: FUNC 400 * @tc.require: 401 */ HWTEST_F_L0(BaseStringTest,Compare_006)402 HWTEST_F_L0(BaseStringTest, Compare_006) 403 { 404 // Compare(). EcmaString made by CreateFromUtf16( , , , true) and EcmaString made by 405 // CreateFromUtf16( , , , false). 406 uint16_t arrayU16CompNo1[] = {1, 23}; 407 uint16_t arrayU16CompNo2[] = {1, 23, 49}; 408 uint16_t arrayU16NotCompNo1[] = {1, 23}; 409 uint16_t arrayU16NotCompNo2[] = {1, 23, 49}; 410 uint16_t arrayU16NotCompNo3[] = {1, 23, 456, 6789, 65535, 127}; 411 uint32_t lengthEcmaStrU16CompNo1 = sizeof(arrayU16CompNo1) / sizeof(arrayU16CompNo1[0]); 412 uint32_t lengthEcmaStrU16CompNo2 = sizeof(arrayU16CompNo2) / sizeof(arrayU16CompNo2[0]); 413 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]); 414 uint32_t lengthEcmaStrU16NotCompNo2 = sizeof(arrayU16NotCompNo2) / sizeof(arrayU16NotCompNo2[0]); 415 uint32_t lengthEcmaStrU16NotCompNo3 = sizeof(arrayU16NotCompNo3) / sizeof(arrayU16NotCompNo3[0]); 416 JSHandle<EcmaString> handleEcmaStrU16CompNo1(thread, 417 EcmaStringAccessor::CreateFromUtf16( 418 instance, &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1, true)); 419 JSHandle<EcmaString> handleEcmaStrU16CompNo2(thread, 420 EcmaStringAccessor::CreateFromUtf16( 421 instance, &arrayU16CompNo2[0], lengthEcmaStrU16CompNo2, true)); 422 JSHandle<EcmaString> handleEcmaStrU16NotCompNo1(thread, 423 EcmaStringAccessor::CreateFromUtf16( 424 instance, &arrayU16NotCompNo1[0], 425 lengthEcmaStrU16NotCompNo1, true)); 426 JSHandle<EcmaString> handleEcmaStrU16NotCompNo2(thread, 427 EcmaStringAccessor::CreateFromUtf16( 428 instance, &arrayU16NotCompNo2[0], 429 lengthEcmaStrU16NotCompNo2, true)); 430 JSHandle<EcmaString> handleEcmaStrU16NotCompNo3(thread, 431 EcmaStringAccessor::CreateFromUtf16( 432 instance, &arrayU16NotCompNo3[0], 433 lengthEcmaStrU16NotCompNo3, false)); 434 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16CompNo1, handleEcmaStrU16NotCompNo1), 0); 435 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo1, handleEcmaStrU16CompNo1), 0); 436 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16CompNo1, handleEcmaStrU16NotCompNo2), -1); 437 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo2, handleEcmaStrU16CompNo1), 1); 438 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16CompNo2, handleEcmaStrU16NotCompNo3), 49 - 456); 439 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo3, handleEcmaStrU16CompNo2), 456 - 49); 440 } 441 442 /* 443 * @tc.name: Concat_001 444 * @tc.desc: Check whether the EcmaString returned through calling Concat function between EcmaString made by 445 * CreateFromUtf8() and EcmaString made by CreateFromUtf8() is within expectations. 446 * @tc.type: FUNC 447 * @tc.require: 448 */ HWTEST_F_L0(BaseStringTest,Concat_001)449 HWTEST_F_L0(BaseStringTest, Concat_001) 450 { 451 // Concat(). EcmaString made by CreateFromUtf8() and EcmaString made by CreateFromUtf8(). 452 uint8_t arrayFrontU8[] = {"abcdef"}; 453 uint8_t arrayBackU8[] = {"ABCDEF"}; 454 uint32_t lengthEcmaStrFrontU8 = sizeof(arrayFrontU8) - 1; 455 uint32_t lengthEcmaStrBackU8 = sizeof(arrayBackU8) - 1; 456 JSHandle<EcmaString> handleEcmaStrFrontU8(thread, 457 EcmaStringAccessor::CreateFromUtf8( 458 instance, &arrayFrontU8[0], lengthEcmaStrFrontU8, true)); 459 JSHandle<EcmaString> handleEcmaStrBackU8(thread, 460 EcmaStringAccessor::CreateFromUtf8( 461 instance, &arrayBackU8[0], lengthEcmaStrBackU8, true)); 462 JSHandle<EcmaString> handleEcmaStrConcatU8(thread, 463 EcmaStringAccessor::Concat( 464 instance, handleEcmaStrFrontU8, handleEcmaStrBackU8)); 465 EXPECT_TRUE(handleEcmaStrConcatU8->ToBaseString()->IsUtf8()); 466 for (uint32_t i = 0; i < lengthEcmaStrFrontU8; i++) { 467 EXPECT_EQ(handleEcmaStrConcatU8->ToBaseString()->At(LoadTBarrier(), i), arrayFrontU8[i]); 468 } 469 for (uint32_t i = 0; i < lengthEcmaStrBackU8; i++) { 470 EXPECT_EQ(handleEcmaStrConcatU8->ToBaseString()->At(LoadTBarrier(), i + lengthEcmaStrFrontU8), 471 arrayBackU8[i]); 472 } 473 EXPECT_EQ(handleEcmaStrConcatU8->ToBaseString()->GetLength(), lengthEcmaStrFrontU8 + lengthEcmaStrBackU8); 474 } 475 476 /* 477 * @tc.name: Concat_002 478 * @tc.desc: Check whether the EcmaString returned through calling Concat function between EcmaString made by 479 * CreateFromUtf16( , , , false) and EcmaString made by CreateFromUtf16( , , , false) is within expectations. 480 * @tc.type: FUNC 481 * @tc.require: 482 */ HWTEST_F_L0(BaseStringTest,Concat_002)483 HWTEST_F_L0(BaseStringTest, Concat_002) 484 { 485 // Concat(). EcmaString made by CreateFromUtf16( , , , false) and EcmaString made by 486 // CreateFromUtf16( , , , false). 487 uint16_t arrayFrontU16NotComp[] = {128, 129, 256, 11100, 65535, 100}; 488 uint16_t arrayBackU16NotComp[] = {88, 768, 1, 270, 345, 333}; 489 uint32_t lengthEcmaStrFrontU16NotComp = sizeof(arrayFrontU16NotComp) / sizeof(arrayFrontU16NotComp[0]); 490 uint32_t lengthEcmaStrBackU16NotComp = sizeof(arrayBackU16NotComp) / sizeof(arrayBackU16NotComp[0]); 491 JSHandle<EcmaString> handleEcmaStrFrontU16NotComp(thread, 492 EcmaStringAccessor::CreateFromUtf16( 493 instance, &arrayFrontU16NotComp[0], 494 lengthEcmaStrFrontU16NotComp, false)); 495 JSHandle<EcmaString> handleEcmaStrBackU16NotComp(thread, 496 EcmaStringAccessor::CreateFromUtf16( 497 instance, &arrayBackU16NotComp[0], 498 lengthEcmaStrBackU16NotComp, false)); 499 JSHandle<EcmaString> handleEcmaStrConcatU16NotComp(thread, 500 EcmaStringAccessor::Concat( 501 instance, handleEcmaStrFrontU16NotComp, 502 handleEcmaStrBackU16NotComp)); 503 EXPECT_TRUE(handleEcmaStrConcatU16NotComp->ToBaseString()->IsUtf16()); 504 for (uint32_t i = 0; i < lengthEcmaStrFrontU16NotComp; i++) { 505 EXPECT_EQ(handleEcmaStrConcatU16NotComp->ToBaseString()->At(LoadTBarrier(), i), arrayFrontU16NotComp[i]); 506 } 507 for (uint32_t i = 0; i < lengthEcmaStrBackU16NotComp; i++) { 508 EXPECT_EQ( 509 handleEcmaStrConcatU16NotComp->ToBaseString()->At(LoadTBarrier(), i + lengthEcmaStrFrontU16NotComp), 510 arrayBackU16NotComp[i]); 511 } 512 EXPECT_EQ(handleEcmaStrConcatU16NotComp->ToBaseString()->GetLength(), 513 lengthEcmaStrFrontU16NotComp + lengthEcmaStrBackU16NotComp); 514 } 515 516 /* 517 * @tc.name: Concat_003 518 * @tc.desc: Check whether the EcmaString returned through calling Concat function between EcmaString made by 519 * CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false) is within expectations. 520 * @tc.type: FUNC 521 * @tc.require: 522 */ HWTEST_F_L0(BaseStringTest,Concat_003)523 HWTEST_F_L0(BaseStringTest, Concat_003) 524 { 525 // Concat(). EcmaString made by CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false). 526 uint8_t arrayFrontU8[] = {"abcdef"}; 527 uint16_t arrayBackU16NotComp[] = {88, 768, 1, 270, 345, 333}; 528 uint32_t lengthEcmaStrFrontU8 = sizeof(arrayFrontU8) - 1; 529 uint32_t lengthEcmaStrBackU16NotComp = sizeof(arrayBackU16NotComp) / sizeof(arrayBackU16NotComp[0]); 530 JSHandle<EcmaString> handleEcmaStrFrontU8(thread, 531 EcmaStringAccessor::CreateFromUtf8( 532 instance, &arrayFrontU8[0], lengthEcmaStrFrontU8, true)); 533 JSHandle<EcmaString> handleEcmaStrBackU16NotComp(thread, 534 EcmaStringAccessor::CreateFromUtf16( 535 instance, &arrayBackU16NotComp[0], 536 lengthEcmaStrBackU16NotComp, false)); 537 JSHandle<EcmaString> handleEcmaStrConcatU8U16NotComp(thread, 538 EcmaStringAccessor::Concat( 539 instance, handleEcmaStrFrontU8, 540 handleEcmaStrBackU16NotComp)); 541 EXPECT_TRUE(handleEcmaStrConcatU8U16NotComp->ToBaseString()->IsUtf16()); 542 for (uint32_t i = 0; i < lengthEcmaStrFrontU8; i++) { 543 EXPECT_EQ(handleEcmaStrConcatU8U16NotComp->ToBaseString()->At(LoadTBarrier(), i), arrayFrontU8[i]); 544 } 545 for (uint32_t i = 0; i < lengthEcmaStrBackU16NotComp; i++) { 546 EXPECT_EQ(handleEcmaStrConcatU8U16NotComp->ToBaseString()->At(LoadTBarrier(), i + lengthEcmaStrFrontU8), 547 arrayBackU16NotComp[i]); 548 } 549 EXPECT_EQ(handleEcmaStrConcatU8U16NotComp->ToBaseString()->GetLength(), 550 lengthEcmaStrFrontU8 + lengthEcmaStrBackU16NotComp); 551 } 552 553 /* 554 * @tc.name: FastSubString_001 555 * @tc.desc: Check whether the EcmaString returned through calling FastSubString function from EcmaString made by 556 * CreateFromUtf8() is within expectations. 557 * @tc.type: FUNC 558 * @tc.require: 559 */ HWTEST_F_L0(BaseStringTest,FastSubString_001)560 HWTEST_F_L0(BaseStringTest, FastSubString_001) 561 { 562 // FastSubString(). From EcmaString made by CreateFromUtf8(). 563 uint8_t arrayU8[6] = {3, 7, 19, 54, 99}; 564 uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1; 565 JSHandle<EcmaString> handleEcmaStrU8(thread, 566 EcmaStringAccessor::CreateFromUtf8( 567 instance, &arrayU8[0], lengthEcmaStrU8, true)); 568 uint32_t indexStartSubU8 = 2; 569 uint32_t lengthSubU8 = 2; 570 JSHandle<EcmaString> handleEcmaStrSubU8(thread, 571 EcmaStringAccessor::FastSubString( 572 instance, handleEcmaStrU8, indexStartSubU8, lengthSubU8)); 573 for (uint32_t i = 0; i < lengthSubU8; i++) { 574 EXPECT_EQ(handleEcmaStrSubU8->ToBaseString()->At(LoadTBarrier(), i), 575 handleEcmaStrU8->ToBaseString()->At(LoadTBarrier(), i + indexStartSubU8)); 576 } 577 EXPECT_EQ(handleEcmaStrSubU8->ToBaseString()->GetLength(), lengthSubU8); 578 } 579 580 /* 581 * @tc.name: FastSubString_002 582 * @tc.desc: Check whether the EcmaString returned through calling FastSubString function from EcmaString made by 583 * CreateFromUtf16( , , , true) is within expectations. 584 * @tc.type: FUNC 585 * @tc.require: 586 */ HWTEST_F_L0(BaseStringTest,FastSubString_002)587 HWTEST_F_L0(BaseStringTest, FastSubString_002) 588 { 589 // FastSubString(). From EcmaString made by CreateFromUtf16( , , , true). 590 uint16_t arrayU16Comp[] = {1, 12, 34, 56, 127}; 591 uint32_t lengthEcmaStrU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]); 592 JSHandle<EcmaString> handleEcmaStrU16Comp(thread, 593 EcmaStringAccessor::CreateFromUtf16( 594 instance, &arrayU16Comp[0], lengthEcmaStrU16Comp, true)); 595 uint32_t indexStartSubU16Comp = 0; 596 uint32_t lengthSubU16Comp = 2; 597 JSHandle<EcmaString> handleEcmaStrSubU16Comp(thread, 598 EcmaStringAccessor::FastSubString( 599 instance, handleEcmaStrU16Comp, indexStartSubU16Comp, 600 lengthSubU16Comp)); 601 for (uint32_t i = 0; i < lengthSubU16Comp; i++) { 602 EXPECT_EQ(handleEcmaStrSubU16Comp->ToBaseString()->At(LoadTBarrier(), i), 603 handleEcmaStrU16Comp->ToBaseString()->At(LoadTBarrier(), i + indexStartSubU16Comp)); 604 } 605 EXPECT_EQ(handleEcmaStrSubU16Comp->ToBaseString()->GetLength(), lengthSubU16Comp); 606 } 607 608 /* 609 * @tc.name: FastSubString_003 610 * @tc.desc: Check whether the EcmaString returned through calling FastSubString function from EcmaString made by 611 * CreateFromUtf16( , , , false) is within expectations. 612 * @tc.type: FUNC 613 * @tc.require: 614 */ HWTEST_F_L0(BaseStringTest,FastSubString_003)615 HWTEST_F_L0(BaseStringTest, FastSubString_003) 616 { 617 // FastSubString(). From EcmaString made by CreateFromUtf16( , , , false). 618 uint16_t arrayU16NotComp[] = {19, 54, 256, 11100, 65535}; 619 uint32_t lengthEcmaStrU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]); 620 JSHandle<EcmaString> handleEcmaStrU16NotComp(thread, 621 EcmaStringAccessor::CreateFromUtf16( 622 instance, &arrayU16NotComp[0], lengthEcmaStrU16NotComp, 623 false)); 624 uint32_t indexStartSubU16NotComp = 0; 625 uint32_t lengthSubU16NotComp = 2; 626 JSHandle<EcmaString> handleEcmaStrSubU16NotComp(thread, 627 EcmaStringAccessor::FastSubString( 628 instance, handleEcmaStrU16NotComp, indexStartSubU16NotComp, 629 lengthSubU16NotComp)); 630 for (uint32_t i = 0; i < lengthSubU16NotComp; i++) { 631 EXPECT_EQ(handleEcmaStrSubU16NotComp->ToBaseString()->At(LoadTBarrier(), i), 632 handleEcmaStrU16NotComp->ToBaseString()->At(LoadTBarrier(), i + indexStartSubU16NotComp)); 633 } 634 EXPECT_EQ(handleEcmaStrSubU16NotComp->ToBaseString()->GetLength(), lengthSubU16NotComp); 635 } 636 637 /* 638 * @tc.name: FastSubString_004 639 * @tc.desc: Check whether the EcmaString returned through calling FastSubString function from EcmaString 640 * @tc.type: FUNC 641 * @tc.require: 642 */ HWTEST_F_L0(BaseStringTest,FastSubString_004)643 HWTEST_F_L0(BaseStringTest, FastSubString_004) 644 { 645 ObjectFactory* factory = instance->GetFactory(); 646 { 647 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("整数integer"); 648 JSHandle<EcmaString> tmpString = factory->NewFromASCII("integer"); 649 EXPECT_TRUE(sourceString->ToBaseString()->IsUtf16()); 650 EcmaString* res = EcmaStringAccessor::FastSubString(instance, sourceString, 2, 7); 651 EXPECT_TRUE(res->ToBaseString()->IsUtf8()); 652 EXPECT_TRUE(BaseString::StringsAreEqual(LoadTBarrier(), res->ToBaseString(), tmpString->ToBaseString())); 653 } 654 { 655 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("整数integer"); 656 JSHandle<EcmaString> tmpString = factory->NewFromUtf8("整数"); 657 EXPECT_TRUE(sourceString->ToBaseString()->IsUtf16()); 658 EcmaString* res = EcmaStringAccessor::FastSubString(instance, sourceString, 0, 2); 659 EXPECT_TRUE(res->ToBaseString()->IsUtf16()); 660 EXPECT_TRUE(BaseString::StringsAreEqual(LoadTBarrier(), res->ToBaseString(), tmpString->ToBaseString())); 661 } 662 { 663 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("整数integer"); 664 JSHandle<EcmaString> tmpString = factory->NewFromUtf8("数intege"); 665 EXPECT_TRUE(sourceString->ToBaseString()->IsUtf16()); 666 EcmaString* res = EcmaStringAccessor::FastSubString(instance, sourceString, 1, 7); 667 EXPECT_TRUE(res->ToBaseString()->IsUtf16()); 668 EXPECT_TRUE(BaseString::StringsAreEqual(LoadTBarrier(), res->ToBaseString(), tmpString->ToBaseString())); 669 } 670 { 671 JSHandle<EcmaString> sourceString = factory->NewFromASCII("integer123"); 672 JSHandle<EcmaString> tmpString = factory->NewFromASCII("integer"); 673 EXPECT_TRUE(sourceString->ToBaseString()->IsUtf8()); 674 EcmaString* res = EcmaStringAccessor::FastSubString(instance, sourceString, 0, 7); 675 EXPECT_TRUE(res->ToBaseString()->IsUtf8()); 676 EXPECT_TRUE(BaseString::StringsAreEqual(LoadTBarrier(), res->ToBaseString(), tmpString->ToBaseString())); 677 } 678 } 679 680 /* 681 * @tc.name: WriteData_001 682 * @tc.desc: Check whether the target EcmaString made by CreateLineString( , true, ) changed through calling 683 * WriteData 684 * function with a source EcmaString made by CreateFromUtf8() is within expectations. 685 * @tc.type: FUNC 686 * @tc.require: 687 */ HWTEST_F_L0(BaseStringTest,WriteData_001)688 HWTEST_F_L0(BaseStringTest, WriteData_001) 689 { 690 // WriteData(). From EcmaString made by CreateFromUtf8() to EcmaString made by CreateLineString( , true, ). 691 uint8_t arrayU8WriteFrom[6] = {1, 12, 34, 56, 127}; 692 uint32_t lengthEcmaStrU8WriteFrom = sizeof(arrayU8WriteFrom) - 1; 693 JSHandle<EcmaString> handleEcmaStrU8WriteFrom(thread, 694 EcmaStringAccessor::CreateFromUtf8( 695 instance, &arrayU8WriteFrom[0], lengthEcmaStrU8WriteFrom, 696 true)); 697 size_t sizeEcmaStrU8WriteTo = 5; 698 JSHandle<EcmaString> handleEcmaStrAllocTrueWriteTo(thread, 699 EcmaStringAccessor::CreateLineString( 700 instance, sizeEcmaStrU8WriteTo, true)); 701 uint32_t indexStartWriteFromArrayU8 = 2; 702 uint32_t lengthWriteFromArrayU8 = 2; 703 handleEcmaStrAllocTrueWriteTo->ToBaseString()->WriteData( 704 LoadTBarrier(), handleEcmaStrU8WriteFrom->ToBaseString(), indexStartWriteFromArrayU8, sizeEcmaStrU8WriteTo, 705 lengthWriteFromArrayU8); 706 for (uint32_t i = 0; i < lengthWriteFromArrayU8; i++) { 707 EXPECT_EQ(handleEcmaStrAllocTrueWriteTo->ToBaseString()->At(LoadTBarrier(), i + indexStartWriteFromArrayU8), 708 handleEcmaStrU8WriteFrom->ToBaseString()->At(LoadTBarrier(), i)); 709 } 710 } 711 712 /* 713 * @tc.name: WriteData_002 714 * @tc.desc: Check whether the target EcmaString made by CreateLineString( , true, ) changed through calling 715 * WriteData 716 * function from a source char is within expectations. 717 * @tc.type: FUNC 718 * @tc.require: 719 */ HWTEST_F_L0(BaseStringTest,WriteData_002)720 HWTEST_F_L0(BaseStringTest, WriteData_002) 721 { 722 // WriteData(). From char to EcmaString made by CreateLineString( , true, ). 723 char u8Write = 'a'; 724 size_t sizeEcmaStrU8WriteTo = 5; 725 JSHandle<EcmaString> handleEcmaStrAllocTrueWriteTo(thread, 726 EcmaStringAccessor::CreateLineString( 727 instance, sizeEcmaStrU8WriteTo, true)); 728 uint32_t indexAtWriteFromU8 = 4; 729 handleEcmaStrAllocTrueWriteTo->ToBaseString()->WriteData(indexAtWriteFromU8, u8Write); 730 EXPECT_EQ(handleEcmaStrAllocTrueWriteTo->ToBaseString()->At(LoadTBarrier(), indexAtWriteFromU8), u8Write); 731 } 732 733 /* 734 * @tc.name: WriteData_003 735 * @tc.desc: Check whether the target EcmaString made by CreateLineString( , false, ) changed through calling 736 * WriteData function with a source EcmaString made by CreateFromUtf16( , , , false) is within expectations. 737 * @tc.type: FUNC 738 * @tc.require: 739 */ HWTEST_F_L0(BaseStringTest,WriteData_003)740 HWTEST_F_L0(BaseStringTest, WriteData_003) 741 { 742 /* WriteData(). From EcmaString made by CreateFromUtf16( , , , false) to EcmaStringU16 made by 743 * CreateLineString( , false, ). 744 */ 745 uint16_t arrayU16WriteFrom[10] = {67, 777, 1999, 1, 45, 66, 23456, 65535, 127, 333}; 746 uint32_t lengthEcmaStrU16WriteFrom = sizeof(arrayU16WriteFrom) / sizeof(arrayU16WriteFrom[0]); 747 JSHandle<EcmaString> handleEcmaStrU16WriteFrom(thread, 748 EcmaStringAccessor::CreateFromUtf16( 749 instance, &arrayU16WriteFrom[0], lengthEcmaStrU16WriteFrom, 750 false)); 751 size_t sizeEcmaStrU16WriteTo = 10; 752 JSHandle<EcmaString> handleEcmaStrU16WriteTo(thread, 753 EcmaStringAccessor::CreateLineString( 754 instance, sizeEcmaStrU16WriteTo, false)); 755 uint32_t indexStartWriteFromArrayU16 = 3; 756 uint32_t numBytesWriteFromArrayU16 = 2 * 3; 757 handleEcmaStrU16WriteTo->ToBaseString()->WriteData(LoadTBarrier(), handleEcmaStrU16WriteFrom->ToBaseString(), 758 indexStartWriteFromArrayU16, sizeEcmaStrU16WriteTo, 759 numBytesWriteFromArrayU16); 760 for (uint32_t i = 0; i < (numBytesWriteFromArrayU16 / 2); i++) { 761 EXPECT_EQ(handleEcmaStrU16WriteTo->ToBaseString()->At(LoadTBarrier(), i + indexStartWriteFromArrayU16), 762 handleEcmaStrU16WriteFrom->ToBaseString()->At(LoadTBarrier(), i)); 763 } 764 } 765 766 /* 767 * @tc.name: WriteData_004 768 * @tc.desc: Check whether the target EcmaString made by CreateLineString( , false, ) changed through calling 769 * WriteData function with a source EcmaString made by CreateFromUtf8() is within expectations. 770 * @tc.type: FUNC 771 * @tc.require: 772 */ HWTEST_F_L0(BaseStringTest,WriteData_004)773 HWTEST_F_L0(BaseStringTest, WriteData_004) 774 { 775 // WriteData(). From EcmaString made by CreateFromUtf8() to EcmaString made by CreateLineString( , false, ). 776 uint8_t arrayU8WriteFrom[6] = {1, 12, 34, 56, 127}; 777 uint32_t lengthEcmaStrU8WriteFrom = sizeof(arrayU8WriteFrom) - 1; 778 JSHandle<EcmaString> handleEcmaStrU8WriteFrom(thread, 779 EcmaStringAccessor::CreateFromUtf8( 780 instance, &arrayU8WriteFrom[0], lengthEcmaStrU8WriteFrom, 781 true)); 782 size_t sizeEcmaStrU16WriteTo = 10; 783 JSHandle<EcmaString> handleEcmaStrU16WriteTo(thread, 784 EcmaStringAccessor::CreateLineString( 785 instance, sizeEcmaStrU16WriteTo, false)); 786 uint32_t indexStartWriteFromU8ToU16 = 1; 787 uint32_t numBytesWriteFromU8ToU16 = 4; 788 handleEcmaStrU16WriteTo->ToBaseString()->WriteData(LoadTBarrier(), handleEcmaStrU8WriteFrom->ToBaseString(), 789 indexStartWriteFromU8ToU16, sizeEcmaStrU16WriteTo, 790 numBytesWriteFromU8ToU16); 791 for (uint32_t i = 0; i < numBytesWriteFromU8ToU16; i++) { 792 EXPECT_EQ(handleEcmaStrU16WriteTo->ToBaseString()->At(LoadTBarrier(), i + indexStartWriteFromU8ToU16), 793 handleEcmaStrU8WriteFrom->ToBaseString()->At(LoadTBarrier(), i)); 794 } 795 } 796 797 /* 798 * @tc.name: WriteData_005 799 * @tc.desc: Check whether the target EcmaString made by CreateLineString( , false, ) changed through calling 800 * WriteData function with a source char is within expectations. 801 * @tc.type: FUNC 802 * @tc.require: 803 */ HWTEST_F_L0(BaseStringTest,WriteData_005)804 HWTEST_F_L0(BaseStringTest, WriteData_005) 805 { 806 // WriteData(). From char to EcmaString made by CreateLineString( , false, ). 807 size_t sizeEcmaStrU16WriteTo = 10; 808 JSHandle<EcmaString> handleEcmaStrU16WriteTo(thread, 809 EcmaStringAccessor::CreateLineString( 810 instance, sizeEcmaStrU16WriteTo, false)); 811 char u8Write = 'a'; 812 uint32_t indexAt = 4; 813 handleEcmaStrU16WriteTo->ToBaseString()->WriteData(indexAt, u8Write); 814 EXPECT_EQ(handleEcmaStrU16WriteTo->ToBaseString()->At(LoadTBarrier(), indexAt), u8Write); 815 } 816 817 /* 818 * @tc.name: GetUtf8Length 819 * @tc.desc: Check whether the value returned through calling GetUtf8Length function is within expectations. 820 * @tc.type: FUNC 821 * @tc.require: 822 */ HWTEST_F_L0(BaseStringTest,GetUtf8Length)823 HWTEST_F_L0(BaseStringTest, GetUtf8Length) 824 { 825 uint8_t arrayU8[6] = {3, 7, 19, 54, 99}; 826 uint16_t arrayU16Comp[] = {1, 12, 34, 56, 127}; 827 uint16_t arrayU16NotComp[] = {19, 54, 256, 11100, 65535}; 828 uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1; 829 uint32_t lengthEcmaStrU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]); 830 uint32_t lengthEcmaStrU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]); 831 JSHandle<EcmaString> handleEcmaStrU8(thread, 832 EcmaStringAccessor::CreateFromUtf8( 833 instance, &arrayU8[0], lengthEcmaStrU8, true)); 834 JSHandle<EcmaString> handleEcmaStrU16Comp(thread, 835 EcmaStringAccessor::CreateFromUtf16( 836 instance, &arrayU16Comp[0], lengthEcmaStrU16Comp, true)); 837 JSHandle<EcmaString> handleEcmaStrU16NotComp(thread, 838 EcmaStringAccessor::CreateFromUtf16( 839 instance, &arrayU16NotComp[0], lengthEcmaStrU16NotComp, 840 false)); 841 EXPECT_EQ(handleEcmaStrU8->ToBaseString()->GetUtf8Length(LoadTBarrier()), lengthEcmaStrU8 + 1); 842 EXPECT_EQ(handleEcmaStrU16Comp->ToBaseString()->GetUtf8Length(LoadTBarrier()), lengthEcmaStrU16Comp + 1); 843 EXPECT_EQ(handleEcmaStrU16NotComp->ToBaseString()->GetUtf8Length(LoadTBarrier()), 844 2 * lengthEcmaStrU16NotComp + 1); 845 } 846 847 /* 848 * @tc.name: GetDataUtf8 849 * @tc.desc: Check whether the pointer returned through calling GetDataUtf8 function is within expectations. 850 * @tc.type: FUNC 851 * @tc.require: 852 */ HWTEST_F_L0(BaseStringTest,GetDataUtf8)853 HWTEST_F_L0(BaseStringTest, GetDataUtf8) 854 { 855 // From EcmaString made by CreateFromUtf8(). 856 uint8_t arrayU8[] = {"abcde"}; 857 uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1; 858 JSHandle<EcmaString> handleEcmaStrU8(thread, 859 EcmaStringAccessor::CreateFromUtf8( 860 instance, &arrayU8[0], lengthEcmaStrU8, true)); 861 for (uint32_t i = 0; i < lengthEcmaStrU8; i++) { 862 EXPECT_EQ(*(handleEcmaStrU8->ToBaseString()->GetDataUtf8() + i), arrayU8[i]); 863 } 864 865 // From EcmaString made by CreateFromUtf16( , , , true). 866 uint16_t arrayU16Comp[] = {3, 1, 34, 123, 127, 111, 42, 3, 20, 10}; 867 uint32_t lengthEcmaStrU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]); 868 JSHandle<EcmaString> handleEcmaStrU16Comp(thread, 869 EcmaStringAccessor::CreateFromUtf16( 870 instance, &arrayU16Comp[0], lengthEcmaStrU16Comp, true)); 871 for (uint32_t i = 0; i < sizeof(arrayU16Comp) / arrayU16Comp[0]; i++) { 872 EXPECT_EQ(*(handleEcmaStrU16Comp->ToBaseString()->GetDataUtf8() + i), arrayU16Comp[i]); 873 } 874 } 875 876 /* 877 * @tc.name: GetDataUtf16 878 * @tc.desc: Check whether the pointer returned through calling GetDataUtf16 function is within expectations. 879 * @tc.type: FUNC 880 * @tc.require: 881 */ HWTEST_F_L0(BaseStringTest,GetDataUtf16)882 HWTEST_F_L0(BaseStringTest, GetDataUtf16) 883 { 884 // From EcmaString made by CreateFromUtf16( , , , false). 885 uint16_t arrayU16NotComp[] = {67, 777, 1999, 1, 45, 66, 23456, 65535, 127, 333}; 886 uint32_t lengthEcmaStrU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]); 887 JSHandle<EcmaString> handleEcmaStrU16NotComp(thread, 888 EcmaStringAccessor::CreateFromUtf16( 889 instance, &arrayU16NotComp[0], lengthEcmaStrU16NotComp, 890 false)); 891 for (uint32_t i = 0; i < lengthEcmaStrU16NotComp; i++) { 892 EXPECT_EQ(*(handleEcmaStrU16NotComp->ToBaseString()->GetDataUtf16() + i), arrayU16NotComp[i]); 893 } 894 } 895 896 /* 897 * @tc.name: CopyDataRegionUtf8 898 * @tc.desc: Check whether the returned value and the changed array through a source EcmaString's calling 899 * CopyDataRegionUtf8 function are within expectations. 900 * @tc.type: FUNC 901 * @tc.require: 902 */ HWTEST_F_L0(BaseStringTest,CopyDataRegionUtf8)903 HWTEST_F_L0(BaseStringTest, CopyDataRegionUtf8) 904 { 905 // CopyDataRegionUtf8(). From EcmaString made by CreateFromUtf8(). 906 uint8_t arrayU8CopyFrom[6] = {1, 12, 34, 56, 127}; 907 uint32_t lengthEcmaStrU8CopyFrom = sizeof(arrayU8CopyFrom) - 1; 908 JSHandle<EcmaString> handleEcmaStrU8CopyFrom(thread, 909 EcmaStringAccessor::CreateFromUtf8( 910 instance, &arrayU8CopyFrom[0], lengthEcmaStrU8CopyFrom, true)); 911 const size_t lengthArrayU8Target = 7; 912 uint8_t defaultByteForU8CopyTo = 1; 913 uint8_t arrayU8CopyTo[lengthArrayU8Target]; 914 int checkResUtf8 = memset_s(&arrayU8CopyTo[0], lengthArrayU8Target, defaultByteForU8CopyTo, 915 lengthArrayU8Target); 916 EXPECT_TRUE(checkResUtf8 == 0); 917 918 size_t indexStartFromArrayU8 = 2; 919 size_t lengthCopyToEcmaStrU8 = 3; 920 size_t lengthReturnU8 = handleEcmaStrU8CopyFrom->ToBaseString()->CopyDataRegionUtf8( 921 LoadTBarrier(), arrayU8CopyTo, indexStartFromArrayU8, lengthCopyToEcmaStrU8, lengthArrayU8Target); 922 923 EXPECT_EQ(lengthReturnU8, lengthCopyToEcmaStrU8); 924 for (uint32_t i = 0; i < lengthCopyToEcmaStrU8; i++) { 925 EXPECT_EQ(arrayU8CopyTo[i], 926 handleEcmaStrU8CopyFrom->ToBaseString()->At(LoadTBarrier(), i + indexStartFromArrayU8)); 927 } 928 for (uint32_t i = lengthCopyToEcmaStrU8; i < lengthArrayU8Target; i++) { 929 EXPECT_EQ(arrayU8CopyTo[i], defaultByteForU8CopyTo); 930 } 931 932 // CopyDataRegionUtf8(). From EcmaString made by CreateFromUtf16( , , , true). 933 uint16_t arrayU16CompCopyFrom[] = {1, 12, 34, 56, 127}; 934 uint32_t lengthEcmaStrU16CompCopyFrom = sizeof(arrayU16CompCopyFrom) / sizeof(arrayU16CompCopyFrom[0]); 935 JSHandle<EcmaString> handleEcmaStrU16CompCopyFrom(thread, 936 EcmaStringAccessor::CreateFromUtf16( 937 instance, &arrayU16CompCopyFrom[0], 938 lengthEcmaStrU16CompCopyFrom, true)); 939 const size_t lengthArrayU16Target = 8; 940 uint8_t defaultByteForU16CompCopyTo = 1; 941 uint8_t arrayU16CompCopyTo[lengthArrayU16Target]; 942 int checkResUtf16 = memset_s(&arrayU16CompCopyTo[0], lengthArrayU16Target, defaultByteForU16CompCopyTo, 943 lengthArrayU16Target); 944 EXPECT_TRUE(checkResUtf16 == 0); 945 946 size_t indexStartFromArrayU16Comp = 2; 947 size_t lengthCopyToEcmaStrU16Comp = 3; 948 size_t lengthReturnU16Comp = handleEcmaStrU16CompCopyFrom->ToBaseString()->CopyDataRegionUtf8( 949 LoadTBarrier(), &arrayU16CompCopyTo[0], indexStartFromArrayU16Comp, lengthCopyToEcmaStrU16Comp, 950 lengthArrayU16Target); 951 952 EXPECT_EQ(lengthReturnU16Comp, lengthCopyToEcmaStrU16Comp); 953 for (uint32_t i = 0; i < lengthReturnU16Comp; i++) { 954 EXPECT_EQ(arrayU16CompCopyTo[i], 955 handleEcmaStrU16CompCopyFrom->ToBaseString()->At(LoadTBarrier(), i + indexStartFromArrayU16Comp)); 956 } 957 for (uint32_t i = lengthReturnU16Comp; i < lengthArrayU16Target; i++) { 958 EXPECT_EQ(arrayU16CompCopyTo[i], defaultByteForU16CompCopyTo); 959 } 960 } 961 962 /* 963 * @tc.name: CopyDataUtf16 964 * @tc.desc: Check whether the returned value and the changed array through a source EcmaString's calling 965 * CopyDataUtf16 function are within expectations. 966 * @tc.type: FUNC 967 * @tc.require: 968 */ HWTEST_F_L0(BaseStringTest,CopyDataUtf16)969 HWTEST_F_L0(BaseStringTest, CopyDataUtf16) 970 { 971 // CopyDataUtf16(). From EcmaString made by CreateFromUtf16( , , , false). 972 uint16_t arrayU16NotCompCopyFrom[10] = {67, 777, 1999, 1, 45, 66, 23456, 65535, 127, 333}; 973 uint32_t lengthEcmaStrU16NotCompCopyFrom = sizeof(arrayU16NotCompCopyFrom) / sizeof(arrayU16NotCompCopyFrom[0]); 974 JSHandle<EcmaString> handleEcmaStrU16NotCompCopyFrom(thread, 975 EcmaStringAccessor::CreateFromUtf16( 976 instance, &arrayU16NotCompCopyFrom[0], 977 lengthEcmaStrU16NotCompCopyFrom, false)); 978 const size_t lengthArrayU16Target = 13; 979 uint16_t arrayU16NotCompCopyTo[lengthArrayU16Target]; 980 uint8_t defaultOneByteValueOfArrayU16NotCompCopyTo = 244; 981 int checkResUtf16 = memset_s(&arrayU16NotCompCopyTo[0], sizeof(uint16_t) * lengthArrayU16Target, 982 defaultOneByteValueOfArrayU16NotCompCopyTo, 983 sizeof(uint16_t) * lengthArrayU16Target); 984 EXPECT_TRUE(checkResUtf16 == 0); 985 986 size_t lengthReturnU16NotComp = handleEcmaStrU16NotCompCopyFrom->ToBaseString()->CopyDataUtf16( 987 LoadTBarrier(), &arrayU16NotCompCopyTo[0], lengthArrayU16Target); 988 989 EXPECT_EQ(lengthReturnU16NotComp, lengthEcmaStrU16NotCompCopyFrom); 990 for (uint32_t i = 0; i < lengthReturnU16NotComp; i++) { 991 EXPECT_EQ(arrayU16NotCompCopyTo[i], handleEcmaStrU16NotCompCopyFrom->ToBaseString()->At(LoadTBarrier(), i)); 992 } 993 for (uint32_t i = lengthReturnU16NotComp; i < lengthArrayU16Target; i++) { 994 EXPECT_EQ(arrayU16NotCompCopyTo[i], 995 ((uint16_t)defaultOneByteValueOfArrayU16NotCompCopyTo) * (1 + (1 << 8))); 996 } 997 } 998 999 /* 1000 * @tc.name: StringsAreEqual_001 1001 * @tc.desc: Check whether the bool returned through calling StringsAreEqual function with two EcmaStrings made by 1002 * CreateFromUtf8() is within expectations. 1003 * @tc.type: FUNC 1004 * @tc.require: 1005 */ HWTEST_F_L0(BaseStringTest,StringsAreEqual_001)1006 HWTEST_F_L0(BaseStringTest, StringsAreEqual_001) 1007 { 1008 // StringsAreEqual(). 1009 uint8_t arrayU8No1[4] = {45, 92, 78}; 1010 uint8_t arrayU8No2[4] = {45, 92, 78}; 1011 uint8_t arrayU8No3[5] = {45, 92, 78, 1}; 1012 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1; 1013 uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1; 1014 uint32_t lengthEcmaStrU8No3 = sizeof(arrayU8No3) - 1; 1015 JSHandle<EcmaString> handleEcmaStrU8No1(thread, 1016 EcmaStringAccessor::CreateFromUtf8( 1017 instance, &arrayU8No1[0], lengthEcmaStrU8No1, true)); 1018 JSHandle<EcmaString> handleEcmaStrU8No2(thread, 1019 EcmaStringAccessor::CreateFromUtf8( 1020 instance, &arrayU8No2[0], lengthEcmaStrU8No2, true)); 1021 JSHandle<EcmaString> handleEcmaStrU8No3(thread, 1022 EcmaStringAccessor::CreateFromUtf8( 1023 instance, &arrayU8No3[0], lengthEcmaStrU8No3, true)); 1024 EXPECT_TRUE(BaseString::StringsAreEqual(LoadTBarrier(), handleEcmaStrU8No1->ToBaseString(), 1025 handleEcmaStrU8No2->ToBaseString())); 1026 EXPECT_FALSE(BaseString::StringsAreEqual(LoadTBarrier(), handleEcmaStrU8No1->ToBaseString(), 1027 handleEcmaStrU8No3->ToBaseString())); 1028 EXPECT_FALSE(BaseString::StringsAreEqual(LoadTBarrier(), handleEcmaStrU8No3->ToBaseString(), 1029 handleEcmaStrU8No1->ToBaseString())); 1030 } 1031 1032 /* 1033 * @tc.name: StringsAreEqual_002 1034 * @tc.desc: Check whether the bool returned through calling StringsAreEqual function with a EcmaString made by 1035 * CreateFromUtf8() and a EcmaString made by CreateFromUtf16(, , , true) is within expectations. 1036 * @tc.type: FUNC 1037 * @tc.require: 1038 */ HWTEST_F_L0(BaseStringTest,StringsAreEqual_002)1039 HWTEST_F_L0(BaseStringTest, StringsAreEqual_002) 1040 { 1041 // StringsAreEqual(). 1042 uint8_t arrayU8No1[4] = {45, 92, 78}; 1043 uint16_t arrayU16CompNo2[] = {45, 92, 78}; 1044 uint16_t arrayU16CompNo3[] = {45, 92, 78, 1}; 1045 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1; 1046 uint32_t lengthEcmaStrU16CompNo2 = sizeof(arrayU16CompNo2) / sizeof(arrayU16CompNo2[0]); 1047 uint32_t lengthEcmaStrU16CompNo3 = sizeof(arrayU16CompNo3) / sizeof(arrayU16CompNo3[0]); 1048 JSHandle<EcmaString> handleEcmaStrU8No1(thread, 1049 EcmaStringAccessor::CreateFromUtf8( 1050 instance, &arrayU8No1[0], lengthEcmaStrU8No1, true)); 1051 JSHandle<EcmaString> handleEcmaStrU16CompNo2(thread, 1052 EcmaStringAccessor::CreateFromUtf16( 1053 instance, &arrayU16CompNo2[0], lengthEcmaStrU16CompNo2, true)); 1054 JSHandle<EcmaString> handleEcmaStrU16CompNo3(thread, 1055 EcmaStringAccessor::CreateFromUtf16( 1056 instance, &arrayU16CompNo3[0], lengthEcmaStrU16CompNo3, true)); 1057 EXPECT_TRUE(BaseString::StringsAreEqual(LoadTBarrier(), handleEcmaStrU8No1->ToBaseString(), 1058 handleEcmaStrU16CompNo2->ToBaseString())); 1059 EXPECT_FALSE(BaseString::StringsAreEqual(LoadTBarrier(), handleEcmaStrU8No1->ToBaseString(), 1060 handleEcmaStrU16CompNo3->ToBaseString())); 1061 } 1062 1063 /* 1064 * @tc.name: StringsAreEqual_003 1065 * @tc.desc: Check whether the bool returned through calling StringsAreEqual function with two EcmaStrings made by 1066 * CreateFromUtf16(, , , true) is within expectations. 1067 * @tc.type: FUNC 1068 * @tc.require: 1069 */ HWTEST_F_L0(BaseStringTest,StringsAreEqual_003)1070 HWTEST_F_L0(BaseStringTest, StringsAreEqual_003) 1071 { 1072 // StringsAreEqual(). 1073 uint16_t arrayU16CompNo1[] = {45, 92, 78}; 1074 uint16_t arrayU16CompNo2[] = {45, 92, 78}; 1075 uint16_t arrayU16CompNo3[] = {45, 92, 78, 1}; 1076 uint32_t lengthEcmaStrU16CompNo1 = sizeof(arrayU16CompNo1) / sizeof(arrayU16CompNo1[0]); 1077 uint32_t lengthEcmaStrU16CompNo2 = sizeof(arrayU16CompNo2) / sizeof(arrayU16CompNo2[0]); 1078 uint32_t lengthEcmaStrU16CompNo3 = sizeof(arrayU16CompNo3) / sizeof(arrayU16CompNo3[0]); 1079 JSHandle<EcmaString> handleEcmaStrU16CompNo1(thread, 1080 EcmaStringAccessor::CreateFromUtf16( 1081 instance, &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1, true)); 1082 JSHandle<EcmaString> handleEcmaStrU16CompNo2(thread, 1083 EcmaStringAccessor::CreateFromUtf16( 1084 instance, &arrayU16CompNo2[0], lengthEcmaStrU16CompNo2, true)); 1085 JSHandle<EcmaString> handleEcmaStrU16CompNo3(thread, 1086 EcmaStringAccessor::CreateFromUtf16( 1087 instance, &arrayU16CompNo3[0], lengthEcmaStrU16CompNo3, true)); 1088 EXPECT_TRUE(BaseString::StringsAreEqual(LoadTBarrier(), handleEcmaStrU16CompNo1->ToBaseString(), 1089 handleEcmaStrU16CompNo2->ToBaseString())); 1090 EXPECT_FALSE(BaseString::StringsAreEqual(LoadTBarrier(), handleEcmaStrU16CompNo1->ToBaseString(), 1091 handleEcmaStrU16CompNo3->ToBaseString())); 1092 EXPECT_FALSE(BaseString::StringsAreEqual(LoadTBarrier(), handleEcmaStrU16CompNo3->ToBaseString(), 1093 handleEcmaStrU16CompNo1->ToBaseString())); 1094 } 1095 1096 /* 1097 * @tc.name: StringsAreEqual_004 1098 * @tc.desc: Check whether the bool returned through calling StringsAreEqual function with a EcmaString made by 1099 * CreateFromUtf8() and a EcmaString made by CreateFromUtf16(, , , false) is within expectations. 1100 * @tc.type: FUNC 1101 * @tc.require: 1102 */ HWTEST_F_L0(BaseStringTest,StringsAreEqual_004)1103 HWTEST_F_L0(BaseStringTest, StringsAreEqual_004) 1104 { 1105 // StringsAreEqual(). 1106 uint8_t arrayU8No1[4] = {45, 92, 78}; 1107 uint16_t arrayU16NotCompNo1[] = {45, 92, 78}; 1108 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1; 1109 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]); 1110 JSHandle<EcmaString> handleEcmaStrU8No1(thread, 1111 EcmaStringAccessor::CreateFromUtf8( 1112 instance, &arrayU8No1[0], lengthEcmaStrU8No1, true)); 1113 JSHandle<EcmaString> handleEcmaStrU16NotCompNo1(thread, 1114 EcmaStringAccessor::CreateFromUtf16( 1115 instance, &arrayU16NotCompNo1[0], 1116 lengthEcmaStrU16NotCompNo1, true)); 1117 EXPECT_TRUE(BaseString::StringsAreEqual(LoadTBarrier(), handleEcmaStrU8No1->ToBaseString(), 1118 handleEcmaStrU16NotCompNo1->ToBaseString())); 1119 EXPECT_TRUE(BaseString::StringsAreEqual(LoadTBarrier(), handleEcmaStrU16NotCompNo1->ToBaseString(), 1120 handleEcmaStrU8No1->ToBaseString())); 1121 } 1122 1123 /* 1124 * @tc.name: StringsAreEqual_005 1125 * @tc.desc: Check whether the bool returned through calling StringsAreEqual function with a EcmaString made by 1126 * CreateFromUtf16(, , , true) and a EcmaString made by CreateFromUtf16(, , , false) is within expectations. 1127 * @tc.type: FUNC 1128 * @tc.require: 1129 */ HWTEST_F_L0(BaseStringTest,StringsAreEqual_005)1130 HWTEST_F_L0(BaseStringTest, StringsAreEqual_005) 1131 { 1132 // StringsAreEqual(). 1133 uint16_t arrayU16CompNo1[] = {45, 92, 78}; 1134 uint16_t arrayU16NotCompNo1[] = {45, 92, 78}; 1135 uint32_t lengthEcmaStrU16CompNo1 = sizeof(arrayU16CompNo1) / sizeof(arrayU16CompNo1[0]); 1136 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]); 1137 JSHandle<EcmaString> handleEcmaStrU16CompNo1(thread, 1138 EcmaStringAccessor::CreateFromUtf16( 1139 instance, &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1, true)); 1140 JSHandle<EcmaString> handleEcmaStrU16NotCompNo1(thread, 1141 EcmaStringAccessor::CreateFromUtf16( 1142 instance, &arrayU16NotCompNo1[0], 1143 lengthEcmaStrU16NotCompNo1, true)); 1144 EXPECT_TRUE(BaseString::StringsAreEqual(LoadTBarrier(), handleEcmaStrU16CompNo1->ToBaseString(), 1145 handleEcmaStrU16NotCompNo1->ToBaseString())); 1146 EXPECT_TRUE(BaseString::StringsAreEqual(LoadTBarrier(), handleEcmaStrU16NotCompNo1->ToBaseString(), 1147 handleEcmaStrU16CompNo1->ToBaseString())); 1148 } 1149 1150 /* 1151 * @tc.name: StringsAreEqual_006 1152 * @tc.desc: Check whether the bool returned through calling StringsAreEqual function with two EcmaStrings made by 1153 * CreateFromUtf16(, , , false) is within expectations. 1154 * @tc.type: FUNC 1155 * @tc.require: 1156 */ HWTEST_F_L0(BaseStringTest,StringsAreEqual_006)1157 HWTEST_F_L0(BaseStringTest, StringsAreEqual_006) 1158 { 1159 // StringsAreEqual(). 1160 uint16_t arrayU16NotCompNo1[] = {234, 345, 127, 2345, 65535, 5}; 1161 uint16_t arrayU16NotCompNo2[] = {234, 345, 127, 2345, 65535, 5}; 1162 uint16_t arrayU16NotCompNo3[] = {1, 234, 345, 127, 2345, 65535, 5}; 1163 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]); 1164 uint32_t lengthEcmaStrU16NotCompNo2 = sizeof(arrayU16NotCompNo2) / sizeof(arrayU16NotCompNo2[0]); 1165 uint32_t lengthEcmaStrU16NotCompNo3 = sizeof(arrayU16NotCompNo3) / sizeof(arrayU16NotCompNo3[0]); 1166 JSHandle<EcmaString> handleEcmaStrU16NotCompNo1(thread, 1167 EcmaStringAccessor::CreateFromUtf16( 1168 instance, &arrayU16NotCompNo1[0], 1169 lengthEcmaStrU16NotCompNo1, false)); 1170 JSHandle<EcmaString> handleEcmaStrU16NotCompNo2(thread, 1171 EcmaStringAccessor::CreateFromUtf16( 1172 instance, &arrayU16NotCompNo2[0], 1173 lengthEcmaStrU16NotCompNo2, false)); 1174 JSHandle<EcmaString> handleEcmaStrU16NotCompNo3(thread, 1175 EcmaStringAccessor::CreateFromUtf16( 1176 instance, &arrayU16NotCompNo3[0], 1177 lengthEcmaStrU16NotCompNo3, false)); 1178 EXPECT_TRUE(BaseString::StringsAreEqual(LoadTBarrier(), handleEcmaStrU16NotCompNo1->ToBaseString(), 1179 handleEcmaStrU16NotCompNo2->ToBaseString())); 1180 EXPECT_FALSE(BaseString::StringsAreEqual(LoadTBarrier(), handleEcmaStrU16NotCompNo1->ToBaseString(), 1181 handleEcmaStrU16NotCompNo3->ToBaseString())); 1182 EXPECT_FALSE(BaseString::StringsAreEqual(LoadTBarrier(), handleEcmaStrU16NotCompNo3->ToBaseString(), 1183 handleEcmaStrU16NotCompNo1->ToBaseString())); 1184 } 1185 1186 /* 1187 * @tc.name: StringsAreEqualUtf8_001 1188 * @tc.desc: Check whether the bool returned through calling StringIsEqualUint8Data function with an EcmaString made 1189 * by CreateFromUtf8() and an Array(uint8_t) is within expectations. 1190 * @tc.type: FUNC 1191 * @tc.require: 1192 */ HWTEST_F_L0(BaseStringTest,StringsAreEqualUtf8_001)1193 HWTEST_F_L0(BaseStringTest, StringsAreEqualUtf8_001) 1194 { 1195 // StringIsEqualUint8Data(). EcmaString made by CreateFromUtf8(), Array:U8. 1196 uint8_t arrayU8No1[4] = {45, 92, 78}; 1197 uint8_t arrayU8No2[5] = {45, 92, 78, 24}; 1198 uint8_t arrayU8No3[3] = {45, 92}; 1199 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1; 1200 uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1; 1201 uint32_t lengthEcmaStrU8No3 = sizeof(arrayU8No3) - 1; 1202 JSHandle<EcmaString> handleEcmaStrU8No1(thread, 1203 EcmaStringAccessor::CreateFromUtf8( 1204 instance, &arrayU8No1[0], lengthEcmaStrU8No1, true)); 1205 JSHandle<EcmaString> handleEcmaStrU8No2(thread, 1206 EcmaStringAccessor::CreateFromUtf8( 1207 instance, &arrayU8No2[0], lengthEcmaStrU8No2, true)); 1208 JSHandle<EcmaString> handleEcmaStrU8No3(thread, 1209 EcmaStringAccessor::CreateFromUtf8( 1210 instance, &arrayU8No3[0], lengthEcmaStrU8No3, true)); 1211 EXPECT_TRUE(BaseString::StringIsEqualUint8Data(LoadTBarrier(), handleEcmaStrU8No1->ToBaseString(), 1212 &arrayU8No1[0], lengthEcmaStrU8No1, true)); 1213 EXPECT_FALSE(BaseString::StringIsEqualUint8Data(LoadTBarrier(), handleEcmaStrU8No1->ToBaseString(), 1214 &arrayU8No1[0], lengthEcmaStrU8No1, false)); 1215 EXPECT_FALSE(BaseString::StringIsEqualUint8Data(LoadTBarrier(), handleEcmaStrU8No2->ToBaseString(), 1216 &arrayU8No1[0], lengthEcmaStrU8No1, true)); 1217 EXPECT_FALSE(BaseString::StringIsEqualUint8Data(LoadTBarrier(), handleEcmaStrU8No3->ToBaseString(), 1218 &arrayU8No1[0], lengthEcmaStrU8No1, true)); 1219 } 1220 1221 /* 1222 * @tc.name: StringsAreEqualUtf8_002 1223 * @tc.desc: Check whether the bool returned through calling StringIsEqualUint8Data function with an EcmaString made 1224 * by CreateFromUtf16( , , , true) and an Array(uint8_t) is within expectations. 1225 * @tc.type: FUNC 1226 * @tc.require: 1227 */ HWTEST_F_L0(BaseStringTest,StringsAreEqualUtf8_002)1228 HWTEST_F_L0(BaseStringTest, StringsAreEqualUtf8_002) 1229 { 1230 // StringIsEqualUint8Data(). EcmaString made by CreateFromUtf16( , , , true), Array:U8. 1231 uint8_t arrayU8No1[4] = {45, 92, 78}; 1232 uint16_t arrayU16CompNo1[] = {45, 92, 78}; 1233 uint16_t arrayU16CompNo2[] = {45, 92, 78, 24}; 1234 uint16_t arrayU16CompNo3[] = {45, 92}; 1235 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1; 1236 uint32_t lengthEcmaStrU16CompNo1 = sizeof(arrayU16CompNo1) / sizeof(arrayU16CompNo1[0]); 1237 uint32_t lengthEcmaStrU16CompNo2 = sizeof(arrayU16CompNo2) / sizeof(arrayU16CompNo2[0]); 1238 uint32_t lengthEcmaStrU16CompNo3 = sizeof(arrayU16CompNo3) / sizeof(arrayU16CompNo3[0]); 1239 JSHandle<EcmaString> handleEcmaStrU16CompNo1(thread, 1240 EcmaStringAccessor::CreateFromUtf16( 1241 instance, &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1, true)); 1242 JSHandle<EcmaString> handleEcmaStrU16CompNo2(thread, 1243 EcmaStringAccessor::CreateFromUtf16( 1244 instance, &arrayU16CompNo2[0], lengthEcmaStrU16CompNo2, true)); 1245 JSHandle<EcmaString> handleEcmaStrU16CompNo3(thread, 1246 EcmaStringAccessor::CreateFromUtf16( 1247 instance, &arrayU16CompNo3[0], lengthEcmaStrU16CompNo3, true)); 1248 EXPECT_TRUE(BaseString::StringIsEqualUint8Data(LoadTBarrier(), handleEcmaStrU16CompNo1->ToBaseString(), 1249 &arrayU8No1[0], lengthEcmaStrU8No1, true)); 1250 EXPECT_FALSE(BaseString::StringIsEqualUint8Data(LoadTBarrier(), handleEcmaStrU16CompNo1->ToBaseString(), 1251 &arrayU8No1[0], lengthEcmaStrU8No1, false)); 1252 EXPECT_FALSE(BaseString::StringIsEqualUint8Data(LoadTBarrier(), handleEcmaStrU16CompNo2->ToBaseString(), 1253 &arrayU8No1[0], lengthEcmaStrU8No1, true)); 1254 EXPECT_FALSE(BaseString::StringIsEqualUint8Data(LoadTBarrier(), handleEcmaStrU16CompNo3->ToBaseString(), 1255 &arrayU8No1[0], lengthEcmaStrU8No1, true)); 1256 } 1257 1258 /* 1259 * @tc.name: StringsAreEqualUtf8_003 1260 * @tc.desc: Check whether the bool returned through calling StringIsEqualUint8Data function with an EcmaString made 1261 * by CreateFromUtf16( , , , false) and an Array(uint8_t) is within expectations. 1262 * @tc.type: FUNC 1263 * @tc.require: 1264 */ HWTEST_F_L0(BaseStringTest,StringsAreEqualUtf8_003)1265 HWTEST_F_L0(BaseStringTest, StringsAreEqualUtf8_003) 1266 { 1267 // StringIsEqualUint8Data(). EcmaString made by CreateFromUtf16( , , , false), Array:U8. 1268 EcmaTestCommon::StringIsEqualCommonCase(thread, instance, EcmaStringAccessor::StringIsEqualUint8Data); 1269 } 1270 1271 /* 1272 * @tc.name: StringsAreEqualUtf16_001 1273 * @tc.desc: Check whether the bool returned through calling StringsAreEqualUtf16 function with an EcmaString made 1274 * by CreateFromUtf8() and an Array(uint16_t) is within expectations. 1275 * @tc.type: FUNC 1276 * @tc.require: 1277 */ HWTEST_F_L0(BaseStringTest,StringsAreEqualUtf16_001)1278 HWTEST_F_L0(BaseStringTest, StringsAreEqualUtf16_001) 1279 { 1280 // StringsAreEqualUtf16(). EcmaString made by CreateFromUtf8, Array:U16(1-127). 1281 uint8_t arrayU8No1[4] = {45, 92, 78}; 1282 uint8_t arrayU8No2[5] = {45, 92, 78, 24}; 1283 uint8_t arrayU8No3[3] = {45, 92}; 1284 uint16_t arrayU16NotCompNo1[] = {45, 92, 78}; 1285 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1; 1286 uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1; 1287 uint32_t lengthEcmaStrU8No3 = sizeof(arrayU8No3) - 1; 1288 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]); 1289 JSHandle<EcmaString> handleEcmaStrU8No1(thread, 1290 EcmaStringAccessor::CreateFromUtf8( 1291 instance, &arrayU8No1[0], lengthEcmaStrU8No1, true)); 1292 JSHandle<EcmaString> handleEcmaStrU8No2(thread, 1293 EcmaStringAccessor::CreateFromUtf8( 1294 instance, &arrayU8No2[0], lengthEcmaStrU8No2, true)); 1295 JSHandle<EcmaString> handleEcmaStrU8No3(thread, 1296 EcmaStringAccessor::CreateFromUtf8( 1297 instance, &arrayU8No3[0], lengthEcmaStrU8No3, true)); 1298 EXPECT_TRUE(BaseString::StringsAreEqualUtf16(LoadTBarrier(), handleEcmaStrU8No1->ToBaseString(), 1299 &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1)); 1300 EXPECT_FALSE(BaseString::StringsAreEqualUtf16(LoadTBarrier(), handleEcmaStrU8No2->ToBaseString(), 1301 &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1)); 1302 EXPECT_FALSE(BaseString::StringsAreEqualUtf16(LoadTBarrier(), handleEcmaStrU8No3->ToBaseString(), 1303 &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1)); 1304 } 1305 1306 /* 1307 * @tc.name: StringsAreEqualUtf16_002 1308 * @tc.desc: Check whether the bool returned through calling StringsAreEqualUtf16 function with an EcmaString made 1309 * by CreateFromUtf16( , , , true) and an Array(uint16_t) is within expectations. 1310 * @tc.type: FUNC 1311 * @tc.require: 1312 */ HWTEST_F_L0(BaseStringTest,StringsAreEqualUtf16_002)1313 HWTEST_F_L0(BaseStringTest, StringsAreEqualUtf16_002) 1314 { 1315 // StringsAreEqualUtf16(). EcmaString made by CreateFromUtf16( , , , true), Array:U16(1-127). 1316 uint16_t arrayU16CompNo1[] = {45, 92, 78}; 1317 uint16_t arrayU16CompNo2[] = {45, 92, 78, 24}; 1318 uint16_t arrayU16CompNo3[] = {45, 92}; 1319 uint16_t arrayU16CompNo4[] = {25645, 25692, 25678}; // 25645 % 256 == 45... 1320 uint32_t lengthEcmaStrU16CompNo1 = sizeof(arrayU16CompNo1) / sizeof(arrayU16CompNo1[0]); 1321 uint32_t lengthEcmaStrU16CompNo2 = sizeof(arrayU16CompNo2) / sizeof(arrayU16CompNo2[0]); 1322 uint32_t lengthEcmaStrU16CompNo3 = sizeof(arrayU16CompNo3) / sizeof(arrayU16CompNo3[0]); 1323 uint32_t lengthEcmaStrU16CompNo4 = sizeof(arrayU16CompNo4) / sizeof(arrayU16CompNo4[0]); 1324 JSHandle<EcmaString> handleEcmaStrU16CompNo1(thread, 1325 EcmaStringAccessor::CreateFromUtf16( 1326 instance, &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1, true)); 1327 JSHandle<EcmaString> handleEcmaStrU16CompNo2(thread, 1328 EcmaStringAccessor::CreateFromUtf16( 1329 instance, &arrayU16CompNo2[0], lengthEcmaStrU16CompNo2, true)); 1330 JSHandle<EcmaString> handleEcmaStrU16CompNo3(thread, 1331 EcmaStringAccessor::CreateFromUtf16( 1332 instance, &arrayU16CompNo3[0], lengthEcmaStrU16CompNo3, true)); 1333 JSHandle<EcmaString> handleEcmaStrU16CompNo4(thread, 1334 EcmaStringAccessor::CreateFromUtf16( 1335 instance, &arrayU16CompNo4[0], lengthEcmaStrU16CompNo4, true)); 1336 EXPECT_TRUE(BaseString::StringsAreEqualUtf16(LoadTBarrier(), handleEcmaStrU16CompNo1->ToBaseString(), 1337 &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1)); 1338 EXPECT_FALSE(BaseString::StringsAreEqualUtf16(LoadTBarrier(), handleEcmaStrU16CompNo2->ToBaseString(), 1339 &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1)); 1340 EXPECT_FALSE(BaseString::StringsAreEqualUtf16(LoadTBarrier(), handleEcmaStrU16CompNo3->ToBaseString(), 1341 &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1)); 1342 EXPECT_TRUE(BaseString::StringsAreEqualUtf16(LoadTBarrier(), handleEcmaStrU16CompNo4->ToBaseString(), 1343 &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1)); 1344 } 1345 1346 /* 1347 * @tc.name: StringsAreEqualUtf16_003 1348 * @tc.desc: Check whether the bool returned through calling StringsAreEqualUtf16 function with an EcmaString made 1349 * by CreateFromUtf16( , , , false) and an Array(uint16_t) is within expectations. 1350 * @tc.type: FUNC 1351 * @tc.require: 1352 */ HWTEST_F_L0(BaseStringTest,StringsAreEqualUtf16_003)1353 HWTEST_F_L0(BaseStringTest, StringsAreEqualUtf16_003) 1354 { 1355 uint16_t arrayU16NotCompNo1[] = {25645, 25692, 25678}; 1356 uint16_t arrayU16NotCompNo2[] = {25645, 25692, 78}; // 25645 % 256 == 45... 1357 uint16_t arrayU16NotCompNo3[] = {25645, 25692, 25678, 65535}; 1358 uint16_t arrayU16NotCompNo4[] = {25645, 25692}; 1359 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]); 1360 uint32_t lengthEcmaStrU16NotCompNo2 = sizeof(arrayU16NotCompNo2) / sizeof(arrayU16NotCompNo2[0]); 1361 uint32_t lengthEcmaStrU16NotCompNo3 = sizeof(arrayU16NotCompNo3) / sizeof(arrayU16NotCompNo3[0]); 1362 uint32_t lengthEcmaStrU16NotCompNo4 = sizeof(arrayU16NotCompNo4) / sizeof(arrayU16NotCompNo4[0]); 1363 JSHandle<EcmaString> handleEcmaStrU16NotCompNo1(thread, 1364 EcmaStringAccessor::CreateFromUtf16( 1365 instance, &arrayU16NotCompNo1[0], 1366 lengthEcmaStrU16NotCompNo1, false)); 1367 JSHandle<EcmaString> handleEcmaStrU16NotCompNo2(thread, 1368 EcmaStringAccessor::CreateFromUtf16( 1369 instance, &arrayU16NotCompNo2[0], 1370 lengthEcmaStrU16NotCompNo2, false)); 1371 JSHandle<EcmaString> handleEcmaStrU16NotCompNo3(thread, 1372 EcmaStringAccessor::CreateFromUtf16( 1373 instance, &arrayU16NotCompNo3[0], 1374 lengthEcmaStrU16NotCompNo3, false)); 1375 JSHandle<EcmaString> handleEcmaStrU16NotCompNo4(thread, 1376 EcmaStringAccessor::CreateFromUtf16( 1377 instance, &arrayU16NotCompNo4[0], 1378 lengthEcmaStrU16NotCompNo4, false)); 1379 EXPECT_TRUE(BaseString::StringsAreEqualUtf16(LoadTBarrier(), handleEcmaStrU16NotCompNo1->ToBaseString(), 1380 &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1)); 1381 EXPECT_FALSE(BaseString::StringsAreEqualUtf16(LoadTBarrier(), handleEcmaStrU16NotCompNo1->ToBaseString(), 1382 &arrayU16NotCompNo2[0], lengthEcmaStrU16NotCompNo2)); 1383 EXPECT_FALSE(BaseString::StringsAreEqualUtf16(LoadTBarrier(), handleEcmaStrU16NotCompNo2->ToBaseString(), 1384 &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1)); 1385 EXPECT_FALSE(BaseString::StringsAreEqualUtf16(LoadTBarrier(), handleEcmaStrU16NotCompNo3->ToBaseString(), 1386 &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1)); 1387 EXPECT_FALSE(BaseString::StringsAreEqualUtf16(LoadTBarrier(), handleEcmaStrU16NotCompNo4->ToBaseString(), 1388 &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1)); 1389 } 1390 1391 /* 1392 * @tc.name: ComputeHashcodeUtf8 1393 * @tc.desc: Check whether the value returned through calling ComputeHashcodeUtf8 function with an Array(uint8_t) is 1394 * within expectations. 1395 * @tc.type: FUNC 1396 * @tc.require: 1397 */ HWTEST_F_L0(BaseStringTest,ComputeHashcodeUtf8)1398 HWTEST_F_L0(BaseStringTest, ComputeHashcodeUtf8) 1399 { 1400 uint8_t arrayU8[] = {"abc"}; 1401 uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1; 1402 uint32_t hashExpect = 0; 1403 for (uint32_t i = 0; i < lengthEcmaStrU8; i++) { 1404 hashExpect = hashExpect * 31 + arrayU8[i]; 1405 } 1406 EXPECT_EQ(BaseString::ComputeHashcodeUtf8(&arrayU8[0], lengthEcmaStrU8, true), hashExpect); 1407 } 1408 1409 /* 1410 * @tc.name: ComputeHashcodeUtf16 1411 * @tc.desc: Check whether the value returned through calling ComputeHashcodeUtf16 function with an Array(uint16_t) 1412 * is within expectations. 1413 * @tc.type: FUNC 1414 * @tc.require: 1415 */ HWTEST_F_L0(BaseStringTest,ComputeHashcodeUtf16)1416 HWTEST_F_L0(BaseStringTest, ComputeHashcodeUtf16) 1417 { 1418 uint16_t arrayU16[] = {199, 1, 256, 65535, 777}; 1419 uint32_t lengthEcmaStrU16 = sizeof(arrayU16) / sizeof(arrayU16[0]); 1420 uint32_t hashExpect = 0; 1421 for (uint32_t i = 0; i < lengthEcmaStrU16; i++) { 1422 hashExpect = hashExpect * 31 + arrayU16[i]; 1423 } 1424 EXPECT_EQ(BaseString::ComputeHashcodeUtf16(&arrayU16[0], lengthEcmaStrU16), hashExpect); 1425 } 1426 1427 /* 1428 * @tc.name: GetHashcode_001 1429 * @tc.desc: Check whether the value returned through an EcmaString made by CreateFromUtf8() calling GetHashcode 1430 * function is within expectations. 1431 * @tc.type: FUNC 1432 * @tc.require: 1433 */ HWTEST_F_L0(BaseStringTest,GetHashcode_001)1434 HWTEST_F_L0(BaseStringTest, GetHashcode_001) 1435 { 1436 // GetHashcode(). EcmaString made by CreateFromUtf8(). 1437 uint8_t arrayU8[] = {"abc"}; 1438 uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1; 1439 JSHandle<EcmaString> handleEcmaStrU8(thread, 1440 EcmaStringAccessor::CreateFromUtf8( 1441 instance, &arrayU8[0], lengthEcmaStrU8, true)); 1442 uint32_t hashExpect = 0; 1443 for (uint32_t i = 0; i < lengthEcmaStrU8; i++) { 1444 hashExpect = hashExpect * 31 + arrayU8[i]; 1445 } 1446 EXPECT_EQ(handleEcmaStrU8->ToBaseString()->GetHashcode(LoadTBarrier()), hashExpect); 1447 } 1448 1449 /* 1450 * @tc.name: GetHashcode_002 1451 * @tc.desc: Check whether the value returned through an EcmaString made by CreateFromUtf16( , , , true) calling 1452 * GetHashcode function is within expectations. 1453 * @tc.type: FUNC 1454 * @tc.require: 1455 */ HWTEST_F_L0(BaseStringTest,GetHashcode_002)1456 HWTEST_F_L0(BaseStringTest, GetHashcode_002) 1457 { 1458 // GetHashcode(). EcmaString made by CreateFromUtf16( , , , true). 1459 uint16_t arrayU16Comp[] = {45, 92, 78, 24}; 1460 uint32_t lengthEcmaStrU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]); 1461 JSHandle<EcmaString> handleEcmaStrU16Comp(thread, 1462 EcmaStringAccessor::CreateFromUtf16( 1463 instance, &arrayU16Comp[0], lengthEcmaStrU16Comp, true)); 1464 uint32_t hashExpect = 0; 1465 for (uint32_t i = 0; i < lengthEcmaStrU16Comp; i++) { 1466 hashExpect = hashExpect * 31 + arrayU16Comp[i]; 1467 } 1468 EXPECT_EQ(handleEcmaStrU16Comp->ToBaseString()->GetHashcode(LoadTBarrier()), hashExpect); 1469 } 1470 1471 /* 1472 * @tc.name: GetHashcode_003 1473 * @tc.desc: Check whether the value returned through an EcmaString made by CreateFromUtf16( , , , false) calling 1474 * GetHashcode function is within expectations. 1475 * @tc.type: FUNC 1476 * @tc.require: 1477 */ HWTEST_F_L0(BaseStringTest,GetHashcode_003)1478 HWTEST_F_L0(BaseStringTest, GetHashcode_003) 1479 { 1480 // GetHashcode(). EcmaString made by CreateFromUtf16( , , , false). 1481 uint16_t arrayU16NotComp[] = {199, 1, 256, 65535, 777}; 1482 uint32_t lengthEcmaStrU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]); 1483 JSHandle<EcmaString> handleEcmaStrU16NotComp(thread, 1484 EcmaStringAccessor::CreateFromUtf16( 1485 instance, &arrayU16NotComp[0], lengthEcmaStrU16NotComp, 1486 false)); 1487 uint32_t hashExpect = 0; 1488 for (uint32_t i = 0; i < lengthEcmaStrU16NotComp; i++) { 1489 hashExpect = hashExpect * 31 + arrayU16NotComp[i]; 1490 } 1491 EXPECT_EQ(handleEcmaStrU16NotComp->ToBaseString()->GetHashcode(LoadTBarrier()), hashExpect); 1492 } 1493 1494 /* 1495 * @tc.name: GetHashcode_004 1496 * @tc.desc: Check whether the value returned through an EcmaString made by CreateEmptyString() calling GetHashcode 1497 * function is within expectations. 1498 * @tc.type: FUNC 1499 * @tc.require: 1500 */ HWTEST_F_L0(BaseStringTest,GetHashcode_004)1501 HWTEST_F_L0(BaseStringTest, GetHashcode_004) 1502 { 1503 // GetHashcode(). EcmaString made by CreateEmptyString(). 1504 JSHandle<EcmaString> handleEcmaStrEmpty(thread, EcmaStringAccessor::CreateEmptyString(instance)); 1505 EXPECT_EQ(handleEcmaStrEmpty->ToBaseString()->GetHashcode(LoadTBarrier()), 0U); 1506 } 1507 1508 /* 1509 * @tc.name: GetHashcode_005 1510 * @tc.desc: Check whether the value returned through an EcmaString made by CreateLineString(, true/false, ) calling 1511 * GetHashcode function is within expectations. 1512 * @tc.type: FUNC 1513 * @tc.require: 1514 */ HWTEST_F_L0(BaseStringTest,GetHashcode_005)1515 HWTEST_F_L0(BaseStringTest, GetHashcode_005) 1516 { 1517 // GetHashcode(). EcmaString made by CreateLineString(). 1518 size_t sizeAlloc = 5; 1519 JSHandle<EcmaString> handleEcmaStrAllocComp( 1520 thread, EcmaStringAccessor::CreateLineString(instance, sizeAlloc, true)); 1521 JSHandle<EcmaString> handleEcmaStrAllocNotComp( 1522 thread, EcmaStringAccessor::CreateLineString(instance, sizeAlloc, false)); 1523 EXPECT_EQ(handleEcmaStrAllocComp->ToBaseString()->GetMixHashcode(), 0U); 1524 EXPECT_EQ(handleEcmaStrAllocNotComp->ToBaseString()->GetMixHashcode(), 0U); 1525 } 1526 1527 /* 1528 * @tc.name: SetIsInternString 1529 * @tc.desc: Call SetIsInternString function, check whether the bool returned through calling IsInternString 1530 * function is within expectations. 1531 * @tc.type: FUNC 1532 * @tc.require: 1533 */ HWTEST_F_L0(BaseStringTest,SetIsInternString)1534 HWTEST_F_L0(BaseStringTest, SetIsInternString) 1535 { 1536 uint8_t arrayU8[] = {"abc"}; 1537 uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1; 1538 JSHandle<EcmaString> handleEcmaStrU8(thread, 1539 EcmaStringAccessor::CreateFromUtf8( 1540 instance, &arrayU8[0], lengthEcmaStrU8, true)); 1541 EXPECT_FALSE(handleEcmaStrU8->ToBaseString()->IsInternString()); 1542 handleEcmaStrU8->ToBaseString()->SetIsInternString(); 1543 EXPECT_TRUE(handleEcmaStrU8->ToBaseString()->IsInternString()); 1544 1545 uint16_t arrayU16Comp[] = {97, 98, 99}; 1546 uint32_t lengthEcmaStrU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]); 1547 JSHandle<EcmaString> handleEcmaStrU16Comp(thread, 1548 EcmaStringAccessor::CreateFromUtf16( 1549 instance, &arrayU16Comp[0], lengthEcmaStrU16Comp, true)); 1550 EXPECT_FALSE(handleEcmaStrU16Comp->ToBaseString()->IsInternString()); 1551 handleEcmaStrU16Comp->ToBaseString()->SetIsInternString(); 1552 EXPECT_TRUE(handleEcmaStrU16Comp->ToBaseString()->IsInternString()); 1553 1554 uint16_t arrayU16NotComp[] = {97, 98, 99}; 1555 uint32_t lengthEcmaStrU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]); 1556 JSHandle<EcmaString> handleEcmaStrU16NotComp(thread, 1557 EcmaStringAccessor::CreateFromUtf16( 1558 instance, &arrayU16NotComp[0], lengthEcmaStrU16NotComp, true)); 1559 EXPECT_FALSE(handleEcmaStrU16NotComp->ToBaseString()->IsInternString()); 1560 handleEcmaStrU16NotComp->ToBaseString()->SetIsInternString(); 1561 EXPECT_TRUE(handleEcmaStrU16NotComp->ToBaseString()->IsInternString()); 1562 } 1563 1564 /* 1565 * @tc.name: EqualToSplicedString 1566 * @tc.desc: Tests whether the source string is equal to the concatenated string. 1567 * is within expectations. 1568 * @tc.type: FUNC 1569 * @tc.require: 1570 */ HWTEST_F_L0(BaseStringTest,EqualToSplicedString)1571 HWTEST_F_L0(BaseStringTest, EqualToSplicedString) 1572 { 1573 ObjectFactory* factory = instance->GetFactory(); 1574 { 1575 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("Start开始"); 1576 JSHandle<EcmaString> firstString = factory->NewFromASCII("Start"); 1577 JSHandle<EcmaString> secondString = factory->NewFromUtf8("开始"); 1578 EXPECT_TRUE(sourceString->ToBaseString()->IsUtf16()); 1579 EXPECT_TRUE(firstString->ToBaseString()->IsUtf8()); 1580 EXPECT_TRUE(secondString->ToBaseString()->IsUtf16()); 1581 bool result = sourceString->ToBaseString()->EqualToSplicedString( 1582 LoadTBarrier(), firstString->ToBaseString(), secondString->ToBaseString()); 1583 EXPECT_TRUE(result); 1584 } 1585 1586 { 1587 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("Start开始"); 1588 JSHandle<EcmaString> firstString = factory->NewFromASCII("Start"); 1589 JSHandle<EcmaString> secondString = factory->NewFromASCII("start"); 1590 EXPECT_TRUE(sourceString->ToBaseString()->IsUtf16()); 1591 EXPECT_TRUE(firstString->ToBaseString()->IsUtf8()); 1592 EXPECT_TRUE(secondString->ToBaseString()->IsUtf8()); 1593 bool result = sourceString->ToBaseString()->EqualToSplicedString( 1594 LoadTBarrier(), firstString->ToBaseString(), secondString->ToBaseString()); 1595 EXPECT_TRUE(!result); 1596 } 1597 1598 { 1599 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("Start开始"); 1600 JSHandle<EcmaString> firstString = factory->NewFromUtf8("Start开"); 1601 JSHandle<EcmaString> secondString = factory->NewFromUtf8("始"); 1602 EXPECT_TRUE(sourceString->ToBaseString()->IsUtf16()); 1603 EXPECT_TRUE(firstString->ToBaseString()->IsUtf16()); 1604 EXPECT_TRUE(secondString->ToBaseString()->IsUtf16()); 1605 bool result = sourceString->ToBaseString()->EqualToSplicedString( 1606 LoadTBarrier(), firstString->ToBaseString(), secondString->ToBaseString()); 1607 EXPECT_TRUE(result); 1608 } 1609 1610 { 1611 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("Startstart"); 1612 JSHandle<EcmaString> firstString = factory->NewFromASCII("Start"); 1613 JSHandle<EcmaString> secondString = factory->NewFromASCII("start"); 1614 EXPECT_TRUE(sourceString->ToBaseString()->IsUtf8()); 1615 EXPECT_TRUE(firstString->ToBaseString()->IsUtf8()); 1616 EXPECT_TRUE(secondString->ToBaseString()->IsUtf8()); 1617 bool result = sourceString->ToBaseString()->EqualToSplicedString( 1618 LoadTBarrier(), firstString->ToBaseString(), secondString->ToBaseString()); 1619 EXPECT_TRUE(result); 1620 } 1621 1622 { 1623 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("Startstart"); 1624 JSHandle<EcmaString> firstString = factory->NewFromASCII("Start"); 1625 JSHandle<EcmaString> secondString = factory->NewFromUtf8("开始"); 1626 EXPECT_TRUE(sourceString->ToBaseString()->IsUtf8()); 1627 EXPECT_TRUE(firstString->ToBaseString()->IsUtf8()); 1628 EXPECT_TRUE(secondString->ToBaseString()->IsUtf16()); 1629 bool result = sourceString->ToBaseString()->EqualToSplicedString( 1630 LoadTBarrier(), firstString->ToBaseString(), secondString->ToBaseString()); 1631 EXPECT_TRUE(!result); 1632 } 1633 1634 { 1635 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("Startstat"); 1636 JSHandle<EcmaString> firstString = factory->NewFromASCII("Start"); 1637 JSHandle<EcmaString> secondString = factory->NewFromASCII("start"); 1638 EXPECT_TRUE(sourceString->ToBaseString()->IsUtf8()); 1639 EXPECT_TRUE(firstString->ToBaseString()->IsUtf8()); 1640 EXPECT_TRUE(secondString->ToBaseString()->IsUtf8()); 1641 bool result = sourceString->ToBaseString()->EqualToSplicedString( 1642 LoadTBarrier(), firstString->ToBaseString(), secondString->ToBaseString()); 1643 EXPECT_TRUE(!result); 1644 } 1645 1646 { 1647 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("Start开始"); 1648 JSHandle<EcmaString> firstString = factory->NewFromUtf8("Stat开"); 1649 JSHandle<EcmaString> secondString = factory->NewFromUtf8("始"); 1650 EXPECT_TRUE(sourceString->ToBaseString()->IsUtf16()); 1651 EXPECT_TRUE(firstString->ToBaseString()->IsUtf16()); 1652 EXPECT_TRUE(secondString->ToBaseString()->IsUtf16()); 1653 bool result = sourceString->ToBaseString()->EqualToSplicedString( 1654 LoadTBarrier(), firstString->ToBaseString(), secondString->ToBaseString()); 1655 EXPECT_TRUE(!result); 1656 } 1657 1658 { 1659 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("Start开始"); 1660 JSHandle<EcmaString> firstString = factory->NewFromASCII("Stat"); 1661 JSHandle<EcmaString> secondString = factory->NewFromUtf8("开始"); 1662 EXPECT_TRUE(sourceString->ToBaseString()->IsUtf16()); 1663 EXPECT_TRUE(firstString->ToBaseString()->IsUtf8()); 1664 EXPECT_TRUE(secondString->ToBaseString()->IsUtf16()); 1665 bool result = sourceString->ToBaseString()->EqualToSplicedString( 1666 LoadTBarrier(), firstString->ToBaseString(), secondString->ToBaseString()); 1667 EXPECT_TRUE(!result); 1668 } 1669 } 1670 HWTEST_F_L0(BaseStringTest,ConvertToString001)1671 HWTEST_F_L0(BaseStringTest, ConvertToString001) 1672 { 1673 ObjectFactory* factory = thread->GetEcmaVM()->GetFactory(); 1674 JSHandle<EcmaString> testString = factory->NewFromASCII("bar2bazJavaScriptbaz"); 1675 CString str = ConvertToString(thread, *testString, StringConvertedUsage::LOGICOPERATION, false); 1676 EXPECT_EQ(str, CString("bar2bazJavaScriptbaz")); 1677 } 1678 HWTEST_F_L0(BaseStringTest,ConvertToString002)1679 HWTEST_F_L0(BaseStringTest, ConvertToString002) 1680 { 1681 CString str = ConvertToString(thread, nullptr, StringConvertedUsage::LOGICOPERATION, false); 1682 EXPECT_EQ(str, CString("")); 1683 } 1684 HWTEST_F_L0(BaseStringTest,ConvertToString003)1685 HWTEST_F_L0(BaseStringTest, ConvertToString003) 1686 { 1687 ObjectFactory* factory = thread->GetEcmaVM()->GetFactory(); 1688 JSHandle<EcmaString> testString = factory->NewFromASCII("test"); 1689 CString str = ConvertToString(thread, *testString); 1690 EXPECT_EQ(str, CString("test")); 1691 } 1692 1693 /* 1694 * @tc.name: ComputeHashcodeUtf8Nullptr 1695 * @tc.desc: Check whether the value returned through calling ComputeHashcodeUtf8 function with an Array(uint8_t) is 1696 * within expectations for nullptr. 1697 * @tc.type: FUNC 1698 * @tc.require: 1699 */ HWTEST_F_L0(BaseStringTest,ComputeHashcodeUtf8Nullptr)1700 HWTEST_F_L0(BaseStringTest, ComputeHashcodeUtf8Nullptr) 1701 { 1702 EXPECT_EQ(BaseString::ComputeHashcodeUtf8(nullptr, 0, true), 0); 1703 } 1704 1705 /* 1706 * @tc.name: ComputeHashcodeUtf16Nullptr 1707 * @tc.desc: Check whether the value returned through calling ComputeHashcodeUtf16 function with an Array(uint16_t) 1708 * is within expectations for nullptr. 1709 * @tc.type: FUNC 1710 * @tc.require: 1711 */ HWTEST_F_L0(BaseStringTest,ComputeHashcodeUtf16Nullptr)1712 HWTEST_F_L0(BaseStringTest, ComputeHashcodeUtf16Nullptr) 1713 { 1714 EXPECT_EQ(BaseString::ComputeHashcodeUtf16(nullptr, 0), 0); 1715 } 1716 } // namespace panda::test 1717