diff --git a/ecmascript/tests/BUILD.gn b/ecmascript/tests/BUILD.gn old mode 100644 new mode 100755 index d87cbea2d3bbb9866ef4ae3609f73e332e8a7f9a..4d16b3c2b4539c0d18155a4c688e657af3b20af1 --- a/ecmascript/tests/BUILD.gn +++ b/ecmascript/tests/BUILD.gn @@ -83,6 +83,28 @@ host_unittest_action("DumpTest") { ] } +host_unittest_action("EcmaStringTest") { + module_out_path = module_output_path + + sources = [ + # test file + "ecma_string_test.cpp", + ] + + configs = [ + "//ark/js_runtime:ecma_test_config", + "//ark/js_runtime:ark_jsruntime_public_config", # should add before + # arkruntime_public_config + "//ark/js_runtime:ark_jsruntime_config", + "$ark_root/runtime:arkruntime_public_config", + ] + + deps = [ + "$ark_root/libpandabase:libarkbase", + sdk_libc_secshared_dep, + ] +} + host_unittest_action("GlueRegsTest") { module_out_path = module_output_path @@ -685,6 +707,7 @@ group("unittest") { ":BuiltinsTest", ":DumpTest", ":GcTest", + ":EcmaStringTest", ":GlueRegsTest", ":HugeObjectTest", ":JsArrayTest", @@ -722,6 +745,7 @@ group("host_unittest") { ":AssertScopeTestAction(${host_toolchain})", ":BuiltinsTestAction(${host_toolchain})", ":DumpTestAction(${host_toolchain})", + ":EcmaStringTestAction(${host_toolchain})", ":GcTestAction(${host_toolchain})", ":GlueRegsTestAction(${host_toolchain})", ":HugeObjectTestAction(${host_toolchain})", diff --git a/ecmascript/tests/ecma_string_test.cpp b/ecmascript/tests/ecma_string_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..3d5c6e2a3a047d2bf6253970ee115fb350356812 --- /dev/null +++ b/ecmascript/tests/ecma_string_test.cpp @@ -0,0 +1,1051 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + #include "ecmascript/tests/test_helper.h" + #include "ecmascript/ecma_string-inl.h" + + using namespace panda::ecmascript; + + namespace panda::test{ +class EcmaStringTest : public testing::Test{ +public: + static void SetUpTestCase() + { + GTEST_LOG_(INFO) << "SetUpTestCase"; + } + + static void TesrDownTestCase() + { + GTEST_LOG_(INFO) << "TearDownCase"; + } + + void SetUp() override + { + TestHelper::CreateEcmaVMWithScope(instance, thread, scope); + } + + void TearDown() override + { + TestHelper::DestroyEcmaVMWithScope(instance, scope); + } + PandaVM *instance {nullptr}; + ecmascript::EcmaHandleScope *scope {nullptr}; + JSThread *thread {nullptr}; +}; + +HWTEST_F_L0(EcmaStringTest, SetCompressedStringsEnabled) +{ + EXPECT_TRUE(EcmaString::GetCompressedStringsEnabled()); + EcmaString::SetCompressedStringsEnabled(false); + EXPECT_FALSE(EcmaString::GetCompressedStringsEnabled()); + EcmaString::SetCompressedStringsEnabled(true); + EXPECT_TRUE(EcmaString::GetCompressedStringsEnabled()); +} + +HWTEST_F_L0(EcmaStringTest, CanBeCompressed) +{ + uint8_t arrayU8[7] = {12, 34, 77, 127, 99, 1}; + uint16_t arrayU16Comp[] = {1, 4, 37, 91, 127, 1}; + uint16_t arrayU16NotComp[] = {72, 43, 337, 961, 1317, 65535}; + EXPECT_TRUE(EcmaString::CanBeCompressed(arrayU8)); + EXPECT_TRUE(EcmaString::CanBeCompressed(arrayU16Comp, sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]))); + EXPECT_FALSE(EcmaString::CanBeCompressed(arrayU16NotComp, sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]))); + + EcmaString::SetCompressedStringsEnabled(false); // Set compressedStringsEnabled false. + EXPECT_FALSE(EcmaString::CanBeCompressed(arrayU16NotComp, sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]))); + /* Set compressedStringsEnabled default, because it is a static boolean that some other functions rely on.The foll- + * owing HWTEST_F_L0 will come to an unexpected result if we do not set it default in the end of this HWTEST_F_L0. + */ + EcmaString::SetCompressedStringsEnabled(true); // Set compressedStringsEnabled true(default). +} + +HWTEST_F_L0(EcmaStringTest, CreateEmptyString) +{ + EcmaVM *ecmaVMPtr = EcmaVM::Cast(instance); + + EcmaString *ecmaStrEmptyPtr = EcmaString::CreateEmptyString(ecmaVMPtr); + EXPECT_EQ(ecmaStrEmptyPtr->GetLength(), 0); + EXPECT_TRUE(ecmaStrEmptyPtr->IsUtf8()); + EXPECT_FALSE(ecmaStrEmptyPtr->IsUtf16()); + + EcmaString::SetCompressedStringsEnabled(false); // Set compressedStringsEnabled false. + EcmaString *ecmaStrEmptyNotCompPtr = EcmaString::CreateEmptyString(ecmaVMPtr); + EXPECT_EQ(ecmaStrEmptyNotCompPtr->GetLength(), 0); + EXPECT_TRUE(ecmaStrEmptyNotCompPtr->IsUtf16()); + EcmaString::SetCompressedStringsEnabled(true); // Set compressedStringsEnabled true(default). +} + +HWTEST_F_L0(EcmaStringTest, AllocStringObject) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + + // AllocStringObject( , true, ). + size_t sizeAllocComp = 5; + EcmaString *ecmaStrAllocCompPtr = EcmaString::AllocStringObject(sizeAllocComp, true, ecmaVMPtr); + for(int i = 0; i < sizeAllocComp; i++){ + EXPECT_EQ(ecmaStrAllocCompPtr->At(i), 0); + } + EXPECT_EQ(ecmaStrAllocCompPtr->GetLength(), sizeAllocComp); + EXPECT_TRUE(ecmaStrAllocCompPtr->IsUtf8()); + EXPECT_FALSE(ecmaStrAllocCompPtr->IsUtf16()); + + // AllocStringObject( , false, ). + size_t sizeAllocNotComp = 5; + EcmaString *ecmaStrAllocNotCompPtr = EcmaString::AllocStringObject(sizeAllocNotComp, false, ecmaVMPtr); + for(int i = 0; i < sizeAllocNotComp; i++){ + EXPECT_EQ(ecmaStrAllocNotCompPtr->At(i), 0); + } + EXPECT_EQ(ecmaStrAllocNotCompPtr->GetLength(), sizeAllocNotComp); + EXPECT_FALSE(ecmaStrAllocNotCompPtr->IsUtf8()); + EXPECT_TRUE(ecmaStrAllocNotCompPtr->IsUtf16()); + EcmaString::SetCompressedStringsEnabled(false); // Set compressedStringsEnabled false. + EXPECT_TRUE(ecmaStrAllocNotCompPtr->IsUtf16()); + EcmaString::SetCompressedStringsEnabled(true); // Set compressedStringsEnabled true(default). +} + +HWTEST_F_L0(EcmaStringTest, CreateFromUtf8) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + uint8_t arrayU8[] = {"xyz123!@#"}; + size_t lengthArrayU8 = sizeof(arrayU8) - 1; + EcmaString *ecmaStrU8Ptr = EcmaString::CreateFromUtf8(&arrayU8[0], lengthArrayU8, ecmaVMPtr, true); + for(int i = 0; i < 5; i++){ + EXPECT_EQ(arrayU8[i], ecmaStrU8Ptr->At(i)); + } + EXPECT_EQ(ecmaStrU8Ptr->GetLength(), lengthArrayU8); + EXPECT_TRUE(ecmaStrU8Ptr->IsUtf8()); + EXPECT_FALSE(ecmaStrU8Ptr->IsUtf16()); +} + +HWTEST_F_L0(EcmaStringTest, CreateFromUtf16) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + + // CreateFromUtf16( , , , true). + uint16_t arrayU16Comp[] = {1, 23, 45, 67, 127}; + size_t lengthArrayU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]); + EcmaString *ecmaStrU16CompPtr = EcmaString::CreateFromUtf16(&arrayU16Comp[0], lengthArrayU16Comp, ecmaVMPtr, + true); + EXPECT_EQ(ecmaStrU16CompPtr->GetLength(), lengthArrayU16Comp); + EXPECT_TRUE(ecmaStrU16CompPtr->IsUtf8()); + EXPECT_FALSE(ecmaStrU16CompPtr->IsUtf16()); + + // CreateFromUtf16( , , , false). + uint16_t arrayU16NotComp[] = {127, 33, 128, 12, 256, 11100, 65535}; + size_t lengthArrayU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]); + EcmaString *ecmaStrU16NotCompPtr = EcmaString::CreateFromUtf16(&arrayU16NotComp[0], lengthArrayU16NotComp, + ecmaVMPtr, false); + EXPECT_EQ(ecmaStrU16NotCompPtr->GetLength(), lengthArrayU16NotComp); + EXPECT_FALSE(ecmaStrU16NotCompPtr->IsUtf8()); + EXPECT_TRUE(ecmaStrU16NotCompPtr->IsUtf16()); + EcmaString::SetCompressedStringsEnabled(false); // Set compressedStringsEnabled false. + EXPECT_TRUE(ecmaStrU16NotCompPtr->IsUtf16()); + EcmaString::SetCompressedStringsEnabled(true); // Set compressedStringsEnabled true(default). +} + +HWTEST_F_L0(EcmaStringTest, ComputeSizeUtf8) +{ + for(uint32_t i = 0; i < 0x40000000U; i++){ + uint32_t length = i; + EXPECT_EQ(EcmaString::ComputeSizeUtf8(length), length + sizeof(EcmaString)); + i += 3332; + } +} + +HWTEST_F_L0(EcmaStringTest, ComputeDataSizeUtf16) +{ + for(uint32_t i = 0; i < 0x40000000U; i++){ + uint32_t length = i; + EXPECT_EQ(EcmaString::ComputeDataSizeUtf16(length), 2 * length); + i += 3332; + } +} + +HWTEST_F_L0(EcmaStringTest, ComputeSizeUtf16) +{ + for(uint32_t i = 0; i < 0x40000000U; i++){ + uint32_t length = i; + EXPECT_EQ(EcmaString::ComputeSizeUtf16(length), 2 * length + sizeof(EcmaString)); + i += 3332; + } +} + +HWTEST_F_L0(EcmaStringTest, ObjectSize) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + + EcmaString *ecmaStrEmptyPtr = EcmaString::CreateEmptyString(ecmaVMPtr); + EXPECT_EQ(ecmaStrEmptyPtr->ObjectSize(), sizeof(EcmaString) + 0); + + size_t lengthArrayAllocComp = 5; + EcmaString *ecmaStrAllocCompPtr = EcmaString::AllocStringObject(lengthArrayAllocComp, true, ecmaVMPtr); + EXPECT_EQ(ecmaStrAllocCompPtr->ObjectSize(), sizeof(EcmaString) + sizeof(uint8_t) * lengthArrayAllocComp); + + size_t lengthArrayAllocNotComp = 5; + EcmaString *ecmaStrAllocNotCompPtr = EcmaString::AllocStringObject(lengthArrayAllocNotComp, false, ecmaVMPtr); + EXPECT_EQ(ecmaStrAllocNotCompPtr->ObjectSize(), sizeof(EcmaString) + sizeof(uint16_t) * lengthArrayAllocNotComp); + + uint8_t arrayU8[] = {"abcde"}; + size_t lengthArrayU8 = sizeof(arrayU8)-1; + EcmaString *ecmaStrU8Ptr = EcmaString::CreateFromUtf8(&arrayU8[0], lengthArrayU8, ecmaVMPtr, true); + EXPECT_EQ(ecmaStrU8Ptr->ObjectSize(), sizeof(EcmaString) + sizeof(uint8_t) * lengthArrayU8); + + // ObjectSize(). EcmaString made by CreateFromUtf16( , , , true). + uint16_t arrayU16Comp[] = {1, 23, 45, 67, 127}; + size_t lengthArrayU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]); + EcmaString *ecmaStrU16CompPtr = EcmaString::CreateFromUtf16(&arrayU16Comp[0], lengthArrayU16Comp, ecmaVMPtr, + true); + EXPECT_EQ(ecmaStrU16CompPtr->ObjectSize(), sizeof(EcmaString) + sizeof(uint8_t) * lengthArrayU16Comp); + + // ObjectSize(). EcmaString made by CreateFromUtf16( , , , false). + uint16_t arrayU16NotComp[] = {127, 128, 256, 11100, 65535}; + size_t lengthArrayU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]); + EcmaString *ecmaStrU16NotCompPtr = EcmaString::CreateFromUtf16(&arrayU16NotComp[0], lengthArrayU16NotComp, + ecmaVMPtr, false); + EXPECT_EQ(ecmaStrU16NotCompPtr->ObjectSize(), sizeof(EcmaString) + sizeof(uint16_t) * lengthArrayU16NotComp); +} + +HWTEST_F_L0(EcmaStringTest, Compare) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + + // Compare(). Between EcmaString made by CreateFromUtf8(). + uint8_t arrayU8_1[3] = {1, 23}; + uint8_t arrayU8_2[4] = {1, 23, 49}; + uint8_t arrayU8_3[6] = {1, 23, 45, 97, 127}; + uint32_t lengthArrayU8_1 = sizeof(arrayU8_1)-1; + uint32_t lengthArrayU8_2 = sizeof(arrayU8_2)-1; + uint32_t lengthArrayU8_3 = sizeof(arrayU8_3)-1; + EcmaString *ecmaStrU8Ptr_1 = EcmaString::CreateFromUtf8(&arrayU8_1[0], lengthArrayU8_1, ecmaVMPtr, true); + EcmaString *ecmaStrU8Ptr_2 = EcmaString::CreateFromUtf8(&arrayU8_2[0], lengthArrayU8_2, ecmaVMPtr, true); + EcmaString *ecmaStrU8Ptr_3 = EcmaString::CreateFromUtf8(&arrayU8_3[0], lengthArrayU8_3, ecmaVMPtr, true); + EXPECT_EQ(ecmaStrU8Ptr_1->Compare(ecmaStrU8Ptr_2), -1); + EXPECT_EQ(ecmaStrU8Ptr_2->Compare(ecmaStrU8Ptr_1), 1); + EXPECT_EQ(ecmaStrU8Ptr_2->Compare(ecmaStrU8Ptr_3), 49 - 45); + EXPECT_EQ(ecmaStrU8Ptr_3->Compare(ecmaStrU8Ptr_2), 45 - 49); + + // Compare(). Between EcmaString made by CreateFromUtf16( , , , true). + uint16_t arrayU16Comp_1[] = {1, 23}; + uint16_t arrayU16Comp_2[] = {1, 23, 49}; + uint16_t arrayU16Comp_3[] = {1, 23, 45, 97, 127}; + uint32_t lengthArrayU16Comp_1 = sizeof(arrayU16Comp_1) / sizeof(arrayU16Comp_1[0]); + uint32_t lengthArrayU16Comp_2 = sizeof(arrayU16Comp_2) / sizeof(arrayU16Comp_2[0]); + uint32_t lengthArrayU16Comp_3 = sizeof(arrayU16Comp_3) / sizeof(arrayU16Comp_3[0]); + EcmaString *ecmaStrU16CompPtr_1 = EcmaString::CreateFromUtf16(&arrayU16Comp_1[0], lengthArrayU16Comp_1, ecmaVMPtr, + true); + EcmaString *ecmaStrU16CompPtr_2 = EcmaString::CreateFromUtf16(&arrayU16Comp_2[0], lengthArrayU16Comp_2, ecmaVMPtr, + true); + EcmaString *ecmaStrU16CompPtr_3 = EcmaString::CreateFromUtf16(&arrayU16Comp_3[0], lengthArrayU16Comp_3, ecmaVMPtr, + true); + EXPECT_EQ(ecmaStrU16CompPtr_1->Compare(ecmaStrU16CompPtr_2), -1); + EXPECT_EQ(ecmaStrU16CompPtr_2->Compare(ecmaStrU16CompPtr_1), 1); + EXPECT_EQ(ecmaStrU16CompPtr_2->Compare(ecmaStrU16CompPtr_3), 49 - 45); + EXPECT_EQ(ecmaStrU16CompPtr_3->Compare(ecmaStrU16CompPtr_2), 45 - 49); + + // Compare(). EcmaString made by CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , true). + EXPECT_EQ(ecmaStrU8Ptr_1->Compare(ecmaStrU16CompPtr_1), 0); + EXPECT_EQ(ecmaStrU16CompPtr_1->Compare(ecmaStrU8Ptr_1), 0); + EXPECT_EQ(ecmaStrU8Ptr_1->Compare(ecmaStrU16CompPtr_2), -1); + EXPECT_EQ(ecmaStrU16CompPtr_2->Compare(ecmaStrU8Ptr_1), 1); + EXPECT_EQ(ecmaStrU8Ptr_2->Compare(ecmaStrU16CompPtr_3), 49 - 45); + EXPECT_EQ(ecmaStrU16CompPtr_3->Compare(ecmaStrU8Ptr_2), 45 - 49); + + // Compare(). Between EcmaString made by CreateFromUtf16( , , , false). + uint16_t arrayU16NotComp_1[] = {1, 23}; + uint16_t arrayU16NotComp_2[] = {1, 23, 49}; + uint16_t arrayU16NotComp_3[] = {1, 23, 456, 6789, 65535, 127}; + uint32_t lengthArrayU16NotComp_1 = sizeof(arrayU16NotComp_1) / sizeof(arrayU16NotComp_1[0]); + uint32_t lengthArrayU16NotComp_2 = sizeof(arrayU16NotComp_2) / sizeof(arrayU16NotComp_2[0]); + uint32_t lengthArrayU16NotComp_3 = sizeof(arrayU16NotComp_3) / sizeof(arrayU16NotComp_3[0]); + EcmaString *ecmaStrU16NotCompPtr_1 = EcmaString::CreateFromUtf16(&arrayU16NotComp_1[0], lengthArrayU16NotComp_1, + ecmaVMPtr, false); + EcmaString *ecmaStrU16NotCompPtr_2 = EcmaString::CreateFromUtf16(&arrayU16NotComp_2[0], lengthArrayU16NotComp_2, + ecmaVMPtr, false); + EcmaString *ecmaStrU16NotCompPtr_3 = EcmaString::CreateFromUtf16(&arrayU16NotComp_3[0], lengthArrayU16NotComp_3, + ecmaVMPtr, false); + EXPECT_EQ(ecmaStrU16NotCompPtr_1->Compare(ecmaStrU16NotCompPtr_2), -1); + EXPECT_EQ(ecmaStrU16NotCompPtr_2->Compare(ecmaStrU16NotCompPtr_1), 1); + EXPECT_EQ(ecmaStrU16NotCompPtr_2->Compare(ecmaStrU16NotCompPtr_3), 49 - 456); + EXPECT_EQ(ecmaStrU16NotCompPtr_3->Compare(ecmaStrU16NotCompPtr_2), 456 - 49); + + // Compare(). EcmaString made by CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false). + EXPECT_EQ(ecmaStrU8Ptr_1->Compare(ecmaStrU16NotCompPtr_1), 0); + EXPECT_EQ(ecmaStrU16NotCompPtr_1->Compare(ecmaStrU8Ptr_1), 0); + EXPECT_EQ(ecmaStrU8Ptr_1->Compare(ecmaStrU16NotCompPtr_2), -1); + EXPECT_EQ(ecmaStrU16NotCompPtr_2->Compare(ecmaStrU8Ptr_1), 1); + EXPECT_EQ(ecmaStrU8Ptr_2->Compare(ecmaStrU16NotCompPtr_3), 49 - 456); + EXPECT_EQ(ecmaStrU16NotCompPtr_3->Compare(ecmaStrU8Ptr_2), 456 - 49); + + // Compare(). EcmaString made by CreateFromUtf16( , , , true) and EcmaString made by CreateFromUtf16( , , , false). + EXPECT_EQ(ecmaStrU16CompPtr_1->Compare(ecmaStrU16NotCompPtr_1), 0); + EXPECT_EQ(ecmaStrU16NotCompPtr_1->Compare(ecmaStrU16CompPtr_1), 0); + EXPECT_EQ(ecmaStrU16CompPtr_1->Compare(ecmaStrU16NotCompPtr_2), -1); + EXPECT_EQ(ecmaStrU16NotCompPtr_2->Compare(ecmaStrU16CompPtr_1), 1); + EXPECT_EQ(ecmaStrU16CompPtr_2->Compare(ecmaStrU16NotCompPtr_3), 49 - 456); + EXPECT_EQ(ecmaStrU16NotCompPtr_3->Compare(ecmaStrU16CompPtr_2), 456 - 49); +} + +HWTEST_F_L0(EcmaStringTest, Concat) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + + // Concat(). EcmaString made by CreateFromUtf8() and EcmaString made by CreateFromUtf8(). + uint8_t arrayFrontU8[] = {"abcdef"}; + uint8_t arrayBackU8[] = {"ABCDEF"}; + uint32_t lengthEcmaStrFrontU8 = sizeof(arrayFrontU8) - 1; + uint32_t lengthEcmaStrBackU8 = sizeof(arrayBackU8) - 1; + EcmaString *ecmaStrFrontU8Ptr = EcmaString::CreateFromUtf8(&arrayFrontU8[0], lengthEcmaStrFrontU8, ecmaVMPtr, + true); + EcmaString *ecmaStrBackU8Ptr = EcmaString::CreateFromUtf8(&arrayBackU8[0], lengthEcmaStrBackU8, ecmaVMPtr, true); + JSHandle handle_ecmaStrFrontU8Ptr(thread, ecmaStrFrontU8Ptr); + JSHandle handle_ecmaStrBackU8Ptr(thread, ecmaStrBackU8Ptr); + EcmaString *ecmaStrConcatU8Ptr = EcmaString::Concat(handle_ecmaStrFrontU8Ptr, handle_ecmaStrBackU8Ptr, ecmaVMPtr); + EXPECT_TRUE(ecmaStrConcatU8Ptr->IsUtf8()); + for(int i = 0; i < lengthEcmaStrFrontU8; i++){ + EXPECT_EQ(ecmaStrConcatU8Ptr->At(i), arrayFrontU8[i]); + } + for(int i = 0; i < lengthEcmaStrBackU8; i++){ + EXPECT_EQ(ecmaStrConcatU8Ptr->At(i + lengthEcmaStrFrontU8), arrayBackU8[i]); + } + EXPECT_EQ(ecmaStrConcatU8Ptr->GetLength(), lengthEcmaStrFrontU8 + lengthEcmaStrBackU8); + + // Concat(). EcmaString made by CreateFromUtf16( , , , false) and EcmaString made by CreateFromUtf16( , , , false). + uint16_t arrayFrontU16NotComp[] = {128, 129, 256, 11100, 65535, 100}; + uint16_t arrayBackU16NotComp[] = {88, 768, 1, 270, 345, 333}; + uint32_t lengthArrayFrontU16NotComp = sizeof(arrayFrontU16NotComp) / sizeof(arrayFrontU16NotComp[0]); + uint32_t lengthArrayBackU16NotComp = sizeof(arrayBackU16NotComp) / sizeof(arrayBackU16NotComp[0]); + EcmaString *ecmaStrFrontU16NotCompPtr = EcmaString::CreateFromUtf16(&arrayFrontU16NotComp[0], + lengthArrayFrontU16NotComp, ecmaVMPtr, false); + EcmaString *ecmaStrBackU16NotCompPtr = EcmaString::CreateFromUtf16(&arrayBackU16NotComp[0], + lengthArrayBackU16NotComp, ecmaVMPtr, false); + JSHandle handle_ecmaStrFrontU16NotCompPtr(thread, ecmaStrFrontU16NotCompPtr); + JSHandle handle_ecmaStrBackU16NotCompPtr(thread, ecmaStrBackU16NotCompPtr); + EcmaString *ecmaStrConcatU16NotCompPtr = EcmaString::Concat(handle_ecmaStrFrontU16NotCompPtr, + handle_ecmaStrBackU16NotCompPtr, ecmaVMPtr); + EXPECT_TRUE(ecmaStrConcatU16NotCompPtr->IsUtf16()); + for(int i = 0; i < lengthArrayFrontU16NotComp; i++){ + EXPECT_EQ(ecmaStrConcatU16NotCompPtr->At(i), arrayFrontU16NotComp[i]); + } + for(int i = 0; i < lengthArrayBackU16NotComp; i++){ + EXPECT_EQ(ecmaStrConcatU16NotCompPtr->At(i + lengthArrayFrontU16NotComp), arrayBackU16NotComp[i]); + } + EXPECT_EQ(ecmaStrConcatU16NotCompPtr->GetLength(), lengthArrayFrontU16NotComp + lengthArrayBackU16NotComp); + + /* Concat() after SetCompressedStringsEnabled(false). EcmaString made by CreateFromUtf16( , , , false) and + * EcmaString made by CreateFromUtf16( , , , false). + */ + EcmaString::SetCompressedStringsEnabled(false); // Set compressedStringsEnabled false. + EcmaString *ecmaStrConcatU16NotCompAfterSetFalsePtr = EcmaString::Concat(handle_ecmaStrFrontU16NotCompPtr, + handle_ecmaStrBackU16NotCompPtr, ecmaVMPtr); + EXPECT_TRUE(ecmaStrConcatU16NotCompAfterSetFalsePtr->IsUtf16()); + for(int i = 0; i < lengthArrayFrontU16NotComp; i++){ + EXPECT_EQ(ecmaStrConcatU16NotCompAfterSetFalsePtr->At(i), arrayFrontU16NotComp[i]); + } + for(int i = 0; i < lengthArrayBackU16NotComp; i++){ + EXPECT_EQ(ecmaStrConcatU16NotCompAfterSetFalsePtr->At(i + lengthArrayFrontU16NotComp), arrayBackU16NotComp[i]); + } + EXPECT_EQ(ecmaStrConcatU16NotCompAfterSetFalsePtr->GetLength(), + lengthArrayFrontU16NotComp + lengthArrayBackU16NotComp); + EcmaString::SetCompressedStringsEnabled(true); // Set compressedStringsEnabled true(default). + + // Concat(). EcmaString made by CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false). + EcmaString *ecmaStrConcatU8U16NotCompPtr = EcmaString::Concat(handle_ecmaStrFrontU8Ptr, + handle_ecmaStrBackU16NotCompPtr, ecmaVMPtr); + EXPECT_TRUE(ecmaStrConcatU8U16NotCompPtr->IsUtf16()); + for(int i = 0; i < lengthEcmaStrFrontU8; i++){ + EXPECT_EQ(ecmaStrConcatU8U16NotCompPtr->At(i), arrayFrontU8[i]); + } + for(int i = 0; i < lengthArrayBackU16NotComp; i++){ + EXPECT_EQ(ecmaStrConcatU8U16NotCompPtr->At(i + lengthEcmaStrFrontU8), arrayBackU16NotComp[i]); + } + EXPECT_EQ(ecmaStrConcatU8U16NotCompPtr->GetLength(), lengthEcmaStrFrontU8 + lengthArrayBackU16NotComp); +} + +HWTEST_F_L0(EcmaStringTest, FastSubString) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + uint8_t arrayU8[6] = {3, 7, 19, 54, 99}; + uint16_t arrayU16Comp[] = {1, 12, 34, 56, 127}; + uint16_t arrayU16NotComp[] = {19, 54, 256, 11100, 65535}; + uint32_t lengthArrayU8 = sizeof(arrayU8) - 1; + uint32_t lengthArrayU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]); + uint32_t lengthArrayU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]); + EcmaString *ecmaStrU8Ptr = EcmaString::CreateFromUtf8(&arrayU8[0], lengthArrayU8, ecmaVMPtr, true); + EcmaString *ecmaStrU16CompPtr = EcmaString::CreateFromUtf16(&arrayU16Comp[0], lengthArrayU16Comp, ecmaVMPtr, true); + EcmaString *ecmaStrU16NotCompPtr = EcmaString::CreateFromUtf16(&arrayU16NotComp[0], lengthArrayU16NotComp, + ecmaVMPtr, false); + JSHandle handle_ecmaStrU8Ptr(thread, ecmaStrU8Ptr); + JSHandle handle_ecmaStrU16CompPtr(thread, ecmaStrU16CompPtr); + JSHandle handle_ecmaStrU16NotCompPtr(thread, ecmaStrU16NotCompPtr); + uint32_t indexStartSubU8 = 2; + uint32_t lengthSubU8 = 2; + uint32_t indexStartSubU16Comp = 0; + uint32_t lengthSubU16Comp = 2; + uint32_t indexStartSubU16NotComp = 0; + uint32_t lengthSubU16NotComp = 2; + + // FastSubString(). From EcmaString made by CreateFromUtf8(). + EcmaString *ecmaStrSubU8Ptr = EcmaString::FastSubString(handle_ecmaStrU8Ptr, indexStartSubU8, lengthSubU8, + ecmaVMPtr); + for(int i = 0; i < lengthSubU8; i++){ + EXPECT_EQ(ecmaStrSubU8Ptr->At(i), ecmaStrU8Ptr->At(i + indexStartSubU8)); + } + EXPECT_EQ(ecmaStrSubU8Ptr->GetLength(), lengthSubU8); + + // FastSubString(). From EcmaString made by CreateFromUtf16( , , , true). + EcmaString *ecmaStrSubU16CompPtr = EcmaString::FastSubString(handle_ecmaStrU16CompPtr, indexStartSubU16Comp, + lengthSubU16Comp, ecmaVMPtr); + for(int i = 0; i < lengthSubU16Comp; i++){ + EXPECT_EQ(ecmaStrSubU16CompPtr->At(i), ecmaStrU16CompPtr->At(i + indexStartSubU16Comp)); + } + EXPECT_EQ(ecmaStrSubU16CompPtr->GetLength(), lengthSubU16Comp); + + // FastSubString(). From EcmaString made by CreateFromUtf16( , , , false). + EcmaString *ecmaStrSubU16NotCompPtr = EcmaString::FastSubString(handle_ecmaStrU16NotCompPtr, + indexStartSubU16NotComp, lengthSubU16NotComp, ecmaVMPtr); + for(int i = 0; i < lengthSubU16NotComp; i++){ + EXPECT_EQ(ecmaStrSubU16NotCompPtr->At(i), ecmaStrU16NotCompPtr->At(i + indexStartSubU16NotComp)); + } + EXPECT_EQ(ecmaStrSubU16NotCompPtr->GetLength(), lengthSubU16NotComp); +} + +HWTEST_F_L0(EcmaStringTest, WriteData) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + + // WriteData(). From EcmaString made by CreateFromUtf8() to EcmaString made by AllocStringObject( , true, ). + uint8_t arrayU8WriteFrom[6] = {1, 12, 34, 56, 127}; + uint32_t lengthArrayU8WriteFrom = sizeof(arrayU8WriteFrom) - 1; + EcmaString *ecmaStrU8WriteFromPtr = EcmaString::CreateFromUtf8(&arrayU8WriteFrom[0], lengthArrayU8WriteFrom, + ecmaVMPtr, true); + size_t sizeEcmaStrU8WriteTo = 5; + EcmaString *ecmaStrAllocTrueWriteToPtr = EcmaString::AllocStringObject(sizeEcmaStrU8WriteTo, true, ecmaVMPtr); + uint32_t indexStartWriteFromArrayU8 = 2; + uint32_t lengthWriteFromArrayU8 = 2; + ecmaStrAllocTrueWriteToPtr->WriteData(ecmaStrU8WriteFromPtr, indexStartWriteFromArrayU8, sizeEcmaStrU8WriteTo, + lengthWriteFromArrayU8); + for(int i = 0; i < lengthWriteFromArrayU8; i++){ + EXPECT_EQ(ecmaStrAllocTrueWriteToPtr->At(i + indexStartWriteFromArrayU8), ecmaStrU8WriteFromPtr->At(i)); + } + + // WriteData(). From char to EcmaString made by AllocStringObject( , true, ). + char u8Write = 'a'; + uint32_t indexAtWriteFromU8 = 4; + ecmaStrAllocTrueWriteToPtr->WriteData(u8Write, indexAtWriteFromU8); + EXPECT_EQ(ecmaStrAllocTrueWriteToPtr->At(indexAtWriteFromU8), u8Write); + + /* WriteData(). From EcmaString made by CreateFromUtf16( , , , false) to EcmaStringU16 made by + * AllocStringObject( , false, ). + */ + uint16_t arrayU16WriteFrom[10] = {67, 777, 1999, 1, 45, 66, 23456, 65535, 127, 333}; + uint32_t lengthArrayU16WriteFrom = sizeof(arrayU16WriteFrom) / sizeof(arrayU16WriteFrom[0]); + EcmaString *ptrEcmaStrU16WriteFrom = EcmaString::CreateFromUtf16(&arrayU16WriteFrom[0], lengthArrayU16WriteFrom, + ecmaVMPtr, false); + size_t sizeEcmaStrU16WriteTo = 10; + EcmaString *ptrEcmaStrU16WriteTo = EcmaString::AllocStringObject(sizeEcmaStrU16WriteTo, false, ecmaVMPtr); + uint32_t indexStartWriteFromArrayU16 = 3; + uint32_t numBytesWriteFromArrayU16 = 2 * 3; + ptrEcmaStrU16WriteTo->WriteData(ptrEcmaStrU16WriteFrom, indexStartWriteFromArrayU16, sizeEcmaStrU16WriteTo, + numBytesWriteFromArrayU16); + for(int i = 0; i < (numBytesWriteFromArrayU16 / 2); i++){ + EXPECT_EQ(ptrEcmaStrU16WriteTo->At(i + indexStartWriteFromArrayU16), ptrEcmaStrU16WriteFrom->At(i)); + } + + // WriteData(). From EcmaString made by CreateFromUtf8() to EcmaString made by AllocStringObject( , false, ). + uint32_t indexStartWriteFromU8ToU16 = 1; + uint32_t numBytesWriteFromU8ToU16 = 4; + ptrEcmaStrU16WriteTo->WriteData(ecmaStrU8WriteFromPtr, indexStartWriteFromU8ToU16, sizeEcmaStrU16WriteTo, + numBytesWriteFromU8ToU16); + for(int i = 0; i < numBytesWriteFromU8ToU16; i++){ + EXPECT_EQ(ptrEcmaStrU16WriteTo->At(i + indexStartWriteFromU8ToU16), ecmaStrU8WriteFromPtr->At(i)); + } + + //WriteData(). From char to EcmaString made by AllocStringObject( , false, ). + ptrEcmaStrU16WriteTo->WriteData(u8Write, indexAtWriteFromU8); + EXPECT_EQ(ptrEcmaStrU16WriteTo->At(indexAtWriteFromU8), u8Write); +} + +HWTEST_F_L0(EcmaStringTest, GetUtf8Length) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + uint8_t arrayU8[6] = {3, 7, 19, 54, 99}; + uint16_t arrayU16Comp[] = {1, 12, 34, 56, 127}; + uint16_t arrayU16NotComp[] = {19, 54, 256, 11100, 65535}; + uint32_t lengthArrayU8 = sizeof(arrayU8) - 1; + uint32_t lengthArrayU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]); + uint32_t lengthArrayU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]); + EcmaString *ecmaStrU8Ptr = EcmaString::CreateFromUtf8(&arrayU8[0], lengthArrayU8, ecmaVMPtr, true); + EcmaString *ecmaStrU16CompPtr = EcmaString::CreateFromUtf16(&arrayU16Comp[0], lengthArrayU16Comp, ecmaVMPtr, true); + EcmaString *ecmaStrU16NotCompPtr = EcmaString::CreateFromUtf16(&arrayU16NotComp[0], lengthArrayU16NotComp, + ecmaVMPtr, false); + + EXPECT_EQ(ecmaStrU8Ptr->GetUtf8Length(), lengthArrayU8 + 1); + EXPECT_EQ(ecmaStrU16CompPtr->GetUtf8Length(), lengthArrayU16Comp + 1); + EXPECT_EQ(ecmaStrU16NotCompPtr->GetUtf8Length(), 2 * lengthArrayU16NotComp + 1); +} + +HWTEST_F_L0(EcmaStringTest, GetUtf16Length) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + uint8_t arrayU8[6] = {3, 7, 19, 54, 99}; + uint16_t arrayU16Comp[] = {1, 12, 34, 56, 127}; + uint16_t arrayU16NotComp[] = {19, 54, 256, 11100, 65535}; + uint32_t lengthArrayU8 = sizeof(arrayU8) - 1; + uint32_t lengthArrayU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]); + uint32_t lengthArrayU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]); + EcmaString *ecmaStrU8Ptr = EcmaString::CreateFromUtf8(&arrayU8[0], lengthArrayU8, ecmaVMPtr, true); + EcmaString *ecmaStrU16CompPtr = EcmaString::CreateFromUtf16(&arrayU16Comp[0], lengthArrayU16Comp, ecmaVMPtr, true); + EcmaString *ecmaStrU16NotCompPtr = EcmaString::CreateFromUtf16(&arrayU16NotComp[0], lengthArrayU16NotComp, + ecmaVMPtr, false); + + EXPECT_EQ(ecmaStrU8Ptr->GetUtf16Length(), lengthArrayU8); + EXPECT_EQ(ecmaStrU16CompPtr->GetUtf16Length(), lengthArrayU16Comp); + EXPECT_EQ(ecmaStrU16NotCompPtr->GetUtf16Length(), lengthArrayU16NotComp); +} + +HWTEST_F_L0(EcmaStringTest, GetDataUtf8) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + + // From EcmaString made by CreateFromUtf8(). + uint8_t arrayU8[] = {"abcde"}; + uint32_t lengthArrayU8 = sizeof(arrayU8) - 1; + EcmaString *ecmaStrU8Ptr = EcmaString::CreateFromUtf8(&arrayU8[0], lengthArrayU8, ecmaVMPtr, true); + const uint8_t *arrayU8FromEcmaStrU8Ptr = ecmaStrU8Ptr->GetDataUtf8(); + for(int i =0;i < lengthArrayU8;i++){ + EXPECT_EQ(*(arrayU8FromEcmaStrU8Ptr + i), arrayU8[i]); + } + + // From EcmaString made by CreateFromUtf16( , , , true). + uint16_t arrayU16Comp[] = {3, 1, 34, 123, 127, 111, 42, 3, 20, 10}; + uint32_t lengthArrayU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]); + EcmaString *ecmaStrU16CompPtr = EcmaString::CreateFromUtf16(&arrayU16Comp[0], lengthArrayU16Comp, ecmaVMPtr, true); + const uint8_t *arrayU8FromEcmaStrU16CompPtr = ecmaStrU16CompPtr->GetDataUtf8(); + for(int i = 0;i < sizeof(arrayU16Comp) / arrayU16Comp[0];i++){ + EXPECT_EQ(*(arrayU8FromEcmaStrU16CompPtr + i), arrayU16Comp[i]); + } +} + +HWTEST_F_L0(EcmaStringTest, GetDataUtf16) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + + // From EcmaString made by CreateFromUtf16( , , , false). + uint16_t arrayU16NotComp[] = {67, 777, 1999, 1, 45, 66, 23456, 65535, 127, 333}; + uint32_t lengthArrayU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]); + EcmaString *ecmaStrU16NotCompPtr = EcmaString::CreateFromUtf16(&arrayU16NotComp[0], lengthArrayU16NotComp, + ecmaVMPtr, false); + const uint16_t *arrayU16FromEcmaStrU16NotCompPtr = ecmaStrU16NotCompPtr->GetDataUtf16(); + for(int i = 0;i < lengthArrayU16NotComp;i++){ + EXPECT_EQ(*(arrayU16FromEcmaStrU16NotCompPtr + i), arrayU16NotComp[i]); + } +} + +HWTEST_F_L0(EcmaStringTest, CopyDataRegionUtf8) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + + // CopyDataRegionUtf8(). From EcmaString made by CreateFromUtf8(). + uint8_t arrayU8CopyFrom[6] = {1, 12, 34, 56, 127}; + uint32_t lengthArrayU8CopyFrom = sizeof(arrayU8CopyFrom) - 1; + EcmaString *ecmaStrU8PtrCopyFrom = EcmaString::CreateFromUtf8(&arrayU8CopyFrom[0], lengthArrayU8CopyFrom, + ecmaVMPtr, true); + const size_t lengthArrayU8CopyTo = 7; + uint8_t defaultByteForU8CopyTo = 1; + uint8_t arrayU8CopyTo[lengthArrayU8CopyTo]; + memset_s(&arrayU8CopyTo[0], lengthArrayU8CopyTo, defaultByteForU8CopyTo, lengthArrayU8CopyTo); + size_t indexStartFromArrayU8 = 2; + size_t lengthCopyToEcmaStrU8 = 3; + size_t lengthReturnU8 = ecmaStrU8PtrCopyFrom->CopyDataRegionUtf8(arrayU8CopyTo, indexStartFromArrayU8, + lengthCopyToEcmaStrU8, lengthArrayU8CopyTo); + + EXPECT_EQ(lengthReturnU8, lengthCopyToEcmaStrU8); + EXPECT_EQ(sizeof(arrayU8CopyTo), lengthArrayU8CopyTo); + for(int i = 0;i < lengthCopyToEcmaStrU8;i++){ + EXPECT_EQ(arrayU8CopyTo[i], ecmaStrU8PtrCopyFrom->At(i + indexStartFromArrayU8)); + } + for(int i = lengthCopyToEcmaStrU8;i < lengthArrayU8CopyTo;i++){ + EXPECT_EQ(arrayU8CopyTo[i], defaultByteForU8CopyTo); + } + + // CopyDataRegionUtf8(). From EcmaString made by CreateFromUtf16( , , , true). + uint16_t arrayU16CompCopyFrom[] = {1, 12, 34, 56, 127}; + uint32_t lengthArrayU16CompCopyFrom = sizeof(arrayU16CompCopyFrom) / sizeof(arrayU16CompCopyFrom[0]); + EcmaString *ecmaStrU16PtrCompCopyFrom = EcmaString::CreateFromUtf16(&arrayU16CompCopyFrom[0], + lengthArrayU16CompCopyFrom, ecmaVMPtr, true); + const size_t lengthArrayU16CompCopyTo = 8; + uint8_t defaultByteForU16CompCopyTo = 1; + uint8_t arrayU16CompCopyTo[lengthArrayU16CompCopyTo]; + memset_s(&arrayU16CompCopyTo[0], lengthArrayU16CompCopyTo, defaultByteForU16CompCopyTo, lengthArrayU16CompCopyTo); + size_t indexStartFromArrayU16Comp = 2; + size_t lengthCopyToEcmaStrU16Comp = 3; + size_t lengthReturnU16Comp = ecmaStrU16PtrCompCopyFrom->CopyDataRegionUtf8(&arrayU16CompCopyTo[0], + indexStartFromArrayU16Comp, lengthCopyToEcmaStrU16Comp, lengthArrayU16CompCopyTo); + + EXPECT_EQ(lengthReturnU16Comp, lengthCopyToEcmaStrU16Comp); + EXPECT_EQ(sizeof(arrayU16CompCopyTo) / sizeof(arrayU16CompCopyTo[0]), lengthArrayU16CompCopyTo); + for(int i = 0;i < lengthCopyToEcmaStrU16Comp;i++){ + EXPECT_EQ(arrayU16CompCopyTo[i], ecmaStrU16PtrCompCopyFrom->At(i + indexStartFromArrayU16Comp)); + } + for(int i = lengthCopyToEcmaStrU16Comp;i < lengthArrayU16CompCopyTo;i++){ + EXPECT_EQ(arrayU16CompCopyTo[i], defaultByteForU16CompCopyTo); + } +} + +HWTEST_F_L0(EcmaStringTest, CopyDataRegionUtf16) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + + // CopyDataRegionUtf16(). From EcmaString made by CreateFromUtf16( , , , false). + uint16_t arrayU16NotCompCopyFrom[10] = {67, 777, 1999, 1, 45, 66, 23456, 65535, 127, 333}; + uint32_t lengthArrayU16NotCompCopyFrom = sizeof(arrayU16NotCompCopyFrom) / sizeof(arrayU16NotCompCopyFrom[0]); + EcmaString *ptrEcmaStrU16NotCompCopyFrom = EcmaString::CreateFromUtf16(&arrayU16NotCompCopyFrom[0], + lengthArrayU16NotCompCopyFrom, ecmaVMPtr, false); + const size_t lengthOfArrayU16NotCompCopyTo = 13; + uint8_t defaultOneByteValueOfArrayU16NotCompCopyTo = 244; + uint16_t arrayU16NotCompCopyTo[lengthOfArrayU16NotCompCopyTo]; + memset_s(&arrayU16NotCompCopyTo[0], sizeof(uint16_t) * lengthOfArrayU16NotCompCopyTo, + defaultOneByteValueOfArrayU16NotCompCopyTo, sizeof(uint16_t) * lengthOfArrayU16NotCompCopyTo); + size_t startIndexFromArrayU16NotComp = 2; + size_t byteLengthCopyFromArrayU16NotComp = 3; + size_t lengthReturnU16NotComp = ptrEcmaStrU16NotCompCopyFrom->CopyDataRegionUtf16(&arrayU16NotCompCopyTo[0], + startIndexFromArrayU16NotComp, byteLengthCopyFromArrayU16NotComp, lengthOfArrayU16NotCompCopyTo); + + EXPECT_EQ(lengthReturnU16NotComp, byteLengthCopyFromArrayU16NotComp); + EXPECT_EQ(sizeof(arrayU16NotCompCopyTo) / sizeof(arrayU16NotCompCopyTo[0]), lengthOfArrayU16NotCompCopyTo); + for(int i = 0;i < byteLengthCopyFromArrayU16NotComp;i++){ + EXPECT_EQ(arrayU16NotCompCopyTo[i], ptrEcmaStrU16NotCompCopyFrom->At(i + startIndexFromArrayU16NotComp)); + } + for(int i = byteLengthCopyFromArrayU16NotComp;i < lengthOfArrayU16NotCompCopyTo;i++){ + EXPECT_EQ(arrayU16NotCompCopyTo[i], ((uint16_t)defaultOneByteValueOfArrayU16NotCompCopyTo) * (1 + (1 << 8))); + } +} + +HWTEST_F_L0(EcmaStringTest, IndexOf) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + + // IndexOf(). Find EcmaString made by CreateFromUtf8() From EcmaString made by CreateFromUtf8(). + uint8_t arrayU8From[7] = {23, 25, 1, 3, 39, 80}; + uint8_t arrayU8Target[4] = {1, 3, 39}; + uint32_t lengthArrayU8From = sizeof(arrayU8From)-1; + uint32_t lengthArrayU8Target = sizeof(arrayU8Target)-1; + EcmaString *ecmaStrU8FromPtr = EcmaString::CreateFromUtf8(&arrayU8From[0], lengthArrayU8From, ecmaVMPtr, true); + EcmaString *ecmaStrU8TargetPtr = EcmaString::CreateFromUtf8(&arrayU8Target[0], lengthArrayU8Target, ecmaVMPtr, + true); + int32_t posStart = 0; + EXPECT_EQ(ecmaStrU8FromPtr->IndexOf(ecmaStrU8TargetPtr, posStart), 2); + EXPECT_EQ(ecmaStrU8TargetPtr->IndexOf(ecmaStrU8FromPtr, posStart), -1); + posStart = -1; + EXPECT_EQ(ecmaStrU8FromPtr->IndexOf(ecmaStrU8TargetPtr, posStart), 2); + posStart = 1; + EXPECT_EQ(ecmaStrU8FromPtr->IndexOf(ecmaStrU8TargetPtr, posStart), 2); + posStart = 2; + EXPECT_EQ(ecmaStrU8FromPtr->IndexOf(ecmaStrU8TargetPtr, posStart), 2); + posStart = 3; + EXPECT_EQ(ecmaStrU8FromPtr->IndexOf(ecmaStrU8TargetPtr, posStart), -1); + + // IndexOf(). Find EcmaString made by CreateFromUtf8() From EcmaString made by CreateFromUtf16( , , , false). + uint16_t arrayU16NotCompFrom_1[] = {67, 65535, 127, 777, 1453, 44, 1, 3, 39, 80, 333}; + uint32_t lengthArrayU16NotCompFrom_1 = sizeof(arrayU16NotCompFrom_1) / sizeof(arrayU16NotCompFrom_1[0]); + EcmaString *ecmaStrU16NotCompFromPtr_1 = EcmaString::CreateFromUtf16(&arrayU16NotCompFrom_1[0], + lengthArrayU16NotCompFrom_1, ecmaVMPtr, false); + posStart = 0; + EXPECT_EQ(ecmaStrU16NotCompFromPtr_1->IndexOf(ecmaStrU8TargetPtr, posStart), 6); + EXPECT_EQ(ecmaStrU8TargetPtr->IndexOf(ecmaStrU16NotCompFromPtr_1, posStart), -1); + posStart = -1; + EXPECT_EQ(ecmaStrU16NotCompFromPtr_1->IndexOf(ecmaStrU8TargetPtr, posStart), 6); + posStart = 1; + EXPECT_EQ(ecmaStrU16NotCompFromPtr_1->IndexOf(ecmaStrU8TargetPtr, posStart), 6); + posStart = 6; + EXPECT_EQ(ecmaStrU16NotCompFromPtr_1->IndexOf(ecmaStrU8TargetPtr, posStart), 6); + posStart = 7; + EXPECT_EQ(ecmaStrU16NotCompFromPtr_1->IndexOf(ecmaStrU8TargetPtr, posStart), -1); + + /* IndexOf(). Find EcmaString made by CreateFromUtf16( , , , false) From EcmaString made by + * CreateFromUtf16( , , , false). + */ + uint16_t arrayU16NotCompTarget_1[] = {1453, 44}; + uint32_t lengthArrayU16NotCompTarget_1 = sizeof(arrayU16NotCompTarget_1) / sizeof(arrayU16NotCompTarget_1[0]); + EcmaString *arrayU16NotCompTargetPtr_1 = EcmaString::CreateFromUtf16(&arrayU16NotCompTarget_1[0], + lengthArrayU16NotCompTarget_1, ecmaVMPtr, false); + posStart = 0; + EXPECT_EQ(ecmaStrU16NotCompFromPtr_1->IndexOf(arrayU16NotCompTargetPtr_1, posStart), 4); + EXPECT_EQ(arrayU16NotCompTargetPtr_1->IndexOf(ecmaStrU16NotCompFromPtr_1, posStart), -1); + posStart = -1; + EXPECT_EQ(ecmaStrU16NotCompFromPtr_1->IndexOf(arrayU16NotCompTargetPtr_1, posStart), 4); + posStart = 1; + EXPECT_EQ(ecmaStrU16NotCompFromPtr_1->IndexOf(arrayU16NotCompTargetPtr_1, posStart), 4); + posStart = 4; + EXPECT_EQ(ecmaStrU16NotCompFromPtr_1->IndexOf(arrayU16NotCompTargetPtr_1, posStart), 4); + posStart = 5; + EXPECT_EQ(ecmaStrU16NotCompFromPtr_1->IndexOf(arrayU16NotCompTargetPtr_1, posStart), -1); + + // IndexOf(). Find EcmaString made by CreateFromUtf16( , , , false) From EcmaString made by CreateFromUtf8(). + uint16_t arrayU16NotCompTarget_2[] = {3, 39, 80}; + uint32_t lengthArrayU16NotCompTarget_2 = sizeof(arrayU16NotCompTarget_2) / sizeof(arrayU16NotCompTarget_2[0]); + EcmaString *arrayU16NotCompTargetPtr_2 = EcmaString::CreateFromUtf16(&arrayU16NotCompTarget_2[0], + lengthArrayU16NotCompTarget_2, ecmaVMPtr, false); + posStart = 0; + EXPECT_EQ(ecmaStrU8FromPtr->IndexOf(arrayU16NotCompTargetPtr_2, posStart), 3); + EXPECT_EQ(arrayU16NotCompTargetPtr_2->IndexOf(ecmaStrU8FromPtr, posStart), -1); + posStart = -1; + EXPECT_EQ(ecmaStrU8FromPtr->IndexOf(arrayU16NotCompTargetPtr_2, posStart), 3); + posStart = 1; + EXPECT_EQ(ecmaStrU8FromPtr->IndexOf(arrayU16NotCompTargetPtr_2, posStart), 3); + posStart = 3; + EXPECT_EQ(ecmaStrU8FromPtr->IndexOf(arrayU16NotCompTargetPtr_2, posStart), 3); + posStart = 4; + EXPECT_EQ(ecmaStrU8FromPtr->IndexOf(arrayU16NotCompTargetPtr_2, posStart), -1); +} + +HWTEST_F_L0(EcmaStringTest, StringsAreEqual) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + + // StringsAreEqual(). + uint8_t arrayU8_1[4] = {45, 92, 78}; + uint8_t arrayU8_2[4] = {45, 92, 78}; + uint8_t arrayU8_3[5] = {45, 92, 78, 1}; + uint16_t arrayU16Comp_1[] = {45, 92, 78}; + uint16_t arrayU16Comp_2[] = {45, 92, 78}; + uint16_t arrayU16Comp_3[] = {45, 92, 78, 1}; + uint16_t arrayU16NotComp_1[] = {45, 92, 78}; + uint16_t arrayU16NotComp_2[] = {45, 92, 78}; + uint16_t arrayU16NotComp_3[] = {45, 92, 78, 1}; + uint32_t lengthArrayU8_1 = sizeof(arrayU8_1) - 1; + uint32_t lengthArrayU8_2 = sizeof(arrayU8_2) - 1; + uint32_t lengthArrayU8_3 = sizeof(arrayU8_3) - 1; + uint32_t lengthArrayU16Comp_1 = sizeof(arrayU16Comp_1) / sizeof(arrayU16Comp_1[0]); + uint32_t lengthArrayU16Comp_2 = sizeof(arrayU16Comp_2) / sizeof(arrayU16Comp_2[0]); + uint32_t lengthArrayU16Comp_3 = sizeof(arrayU16Comp_3) / sizeof(arrayU16Comp_3[0]); + uint32_t lengthArrayU16NotComp_1 = sizeof(arrayU16NotComp_1) / sizeof(arrayU16NotComp_1[0]); + uint32_t lengthArrayU16NotComp_2 = sizeof(arrayU16NotComp_2) / sizeof(arrayU16NotComp_2[0]); + uint32_t lengthArrayU16NotComp_3 = sizeof(arrayU16NotComp_3) / sizeof(arrayU16NotComp_3[0]); + EcmaString *ecmaStrU8Ptr_1 = EcmaString::CreateFromUtf8(&arrayU8_1[0], lengthArrayU8_1, ecmaVMPtr, true); + EcmaString *ecmaStrU8Ptr_2 = EcmaString::CreateFromUtf8(&arrayU8_2[0], lengthArrayU8_2, ecmaVMPtr, true); + EcmaString *ecmaStrU8Ptr_3 = EcmaString::CreateFromUtf8(&arrayU8_3[0], lengthArrayU8_3, ecmaVMPtr, true); + EcmaString *ecmaStrU16CompPtr_1 = EcmaString::CreateFromUtf16(&arrayU16Comp_1[0], lengthArrayU16Comp_1, ecmaVMPtr, + true); + EcmaString *ecmaStrU16CompPtr_2 = EcmaString::CreateFromUtf16(&arrayU16Comp_2[0], lengthArrayU16Comp_2, ecmaVMPtr, + true); + EcmaString *ecmaStrU16CompPtr_3 = EcmaString::CreateFromUtf16(&arrayU16Comp_3[0], lengthArrayU16Comp_3, ecmaVMPtr, + true); + EcmaString *ecmaStrU16NotCompPtr_1 = EcmaString::CreateFromUtf16(&arrayU16NotComp_1[0], lengthArrayU16NotComp_1, + ecmaVMPtr, false); + EcmaString *ecmaStrU16NotCompPtr_2 = EcmaString::CreateFromUtf16(&arrayU16NotComp_2[0], lengthArrayU16NotComp_2, + ecmaVMPtr, false); + EcmaString *ecmaStrU16NotCompPtr_3 = EcmaString::CreateFromUtf16(&arrayU16NotComp_3[0], lengthArrayU16NotComp_3, + ecmaVMPtr, false); + + /* StringsAreEqual(). EcmaString made by CreateFromUtf8() and EcmaString made by + * CreateFromUtf8(). + */ + EXPECT_TRUE(EcmaString::StringsAreEqual(ecmaStrU8Ptr_1, ecmaStrU8Ptr_2)); + EXPECT_FALSE(EcmaString::StringsAreEqual(ecmaStrU8Ptr_1, ecmaStrU8Ptr_3)); + EXPECT_FALSE(EcmaString::StringsAreEqual(ecmaStrU8Ptr_3, ecmaStrU8Ptr_1)); + + /* StringsAreEqual(). EcmaString made by CreateFromUtf8() and EcmaString made by + * CreateFromUtf16( , , , true). + */ + EXPECT_TRUE(EcmaString::StringsAreEqual(ecmaStrU8Ptr_1, ecmaStrU16CompPtr_2)); + EXPECT_FALSE(EcmaString::StringsAreEqual(ecmaStrU8Ptr_1, ecmaStrU16CompPtr_3)); + + /* StringsAreEqual(). EcmaString made by CreateFromUtf16( , , , true) and EcmaString made by + * CreateFromUtf16( , , , true). + */ + EXPECT_TRUE(EcmaString::StringsAreEqual(ecmaStrU16CompPtr_1, ecmaStrU16CompPtr_2)); + EXPECT_FALSE(EcmaString::StringsAreEqual(ecmaStrU16CompPtr_1, ecmaStrU16CompPtr_3)); + EXPECT_FALSE(EcmaString::StringsAreEqual(ecmaStrU16CompPtr_3, ecmaStrU16CompPtr_1)); + + /* StringsAreEqual(). EcmaString made by CreateFromUtf8() and EcmaString made by + * CreateFromUtf16( , , , false). + */ + EXPECT_FALSE(EcmaString::StringsAreEqual(ecmaStrU8Ptr_1, ecmaStrU16NotCompPtr_1)); + EXPECT_FALSE(EcmaString::StringsAreEqual(ecmaStrU16NotCompPtr_1, ecmaStrU8Ptr_1)); + + /* StringsAreEqual(). EcmaString made by CreateFromUtf16( , , , true) and EcmaString made by + * CreateFromUtf16( , , , false). + */ + EXPECT_FALSE(EcmaString::StringsAreEqual(ecmaStrU16CompPtr_1, ecmaStrU16NotCompPtr_1)); + EXPECT_FALSE(EcmaString::StringsAreEqual(ecmaStrU16NotCompPtr_1, ecmaStrU16CompPtr_1)); + + /* StringsAreEqual(). EcmaString made by CreateFromUtf16( , , , false) and EcmaString made by + * CreateFromUtf16( , , , false). + */ + EXPECT_TRUE(EcmaString::StringsAreEqual(ecmaStrU16NotCompPtr_1, ecmaStrU16NotCompPtr_2)); + EXPECT_FALSE(EcmaString::StringsAreEqual(ecmaStrU16NotCompPtr_1, ecmaStrU16NotCompPtr_3)); + EXPECT_FALSE(EcmaString::StringsAreEqual(ecmaStrU16NotCompPtr_3, ecmaStrU16NotCompPtr_1)); + + // StringsAreEqual(). Complements for EcmaString made by CreateFromUtf16( , , , false)(0-65535). + uint16_t arrayU16NotComp_4[] = {234, 345, 127, 2345, 65535, 5}; + uint16_t arrayU16NotComp_5[] = {234, 345, 127, 2345, 65535, 5}; + uint16_t arrayU16NotComp_6[] = {1, 234, 345, 127, 2345, 65535, 5}; + uint32_t lengthArrayU16NotComp_4 = sizeof(arrayU16NotComp_4) / sizeof(arrayU16NotComp_4[0]); + uint32_t lengthArrayU16NotComp_5 = sizeof(arrayU16NotComp_5) / sizeof(arrayU16NotComp_5[0]); + uint32_t lengthArrayU16NotComp_6 = sizeof(arrayU16NotComp_6) / sizeof(arrayU16NotComp_6[0]); + EcmaString *ecmaStrU16NotCompPtr_4 = EcmaString::CreateFromUtf16(&arrayU16NotComp_4[0], lengthArrayU16NotComp_4, + ecmaVMPtr, false); + EcmaString *ecmaStrU16NotCompPtr_5 = EcmaString::CreateFromUtf16(&arrayU16NotComp_5[0], lengthArrayU16NotComp_5, + ecmaVMPtr, false); + EcmaString *ecmaStrU16NotCompPtr_6 = EcmaString::CreateFromUtf16(&arrayU16NotComp_6[0], lengthArrayU16NotComp_6, + ecmaVMPtr, false); + EXPECT_TRUE(EcmaString::StringsAreEqual(ecmaStrU16NotCompPtr_4, ecmaStrU16NotCompPtr_5)); + EXPECT_FALSE(EcmaString::StringsAreEqual(ecmaStrU16NotCompPtr_4, ecmaStrU16NotCompPtr_6)); + EXPECT_FALSE(EcmaString::StringsAreEqual(ecmaStrU16NotCompPtr_6, ecmaStrU16NotCompPtr_4)); +} + +HWTEST_F_L0(EcmaStringTest, StringsAreEqualUtf8) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + + // StringsAreEqualUtf8(). + uint8_t arrayU8_1[4] = {45, 92, 78}; + uint8_t arrayU8_2[5] = {45, 92, 78, 24}; + uint8_t arrayU8_3[3] = {45, 92}; + uint16_t arrayU16Comp_1[] = {45, 92, 78}; + uint16_t arrayU16Comp_2[] = {45, 92, 78, 24}; + uint16_t arrayU16Comp_3[] = {45, 92}; + uint16_t arrayU16Comp_4[] = {25645, 25692, 25678}; + uint16_t arrayU16NotComp_1[] = {45, 92, 78}; + uint16_t arrayU16NotComp_2[] = {45, 92, 78, 24}; + uint16_t arrayU16NotComp_3[] = {45, 92}; + uint16_t arrayU16NotComp_4[] = {25645, 25692, 25678}; + uint32_t lengthArrayU8_1 = sizeof(arrayU8_1) - 1; + uint32_t lengthArrayU8_2 = sizeof(arrayU8_2) - 1; + uint32_t lengthArrayU8_3 = sizeof(arrayU8_3) - 1; + uint32_t lengthArrayU16Comp_1 = sizeof(arrayU16Comp_1) / sizeof(arrayU16Comp_1[0]); + uint32_t lengthArrayU16Comp_2 = sizeof(arrayU16Comp_2) / sizeof(arrayU16Comp_2[0]); + uint32_t lengthArrayU16Comp_3 = sizeof(arrayU16Comp_3) / sizeof(arrayU16Comp_3[0]); + uint32_t lengthArrayU16Comp_4 = sizeof(arrayU16Comp_4) / sizeof(arrayU16Comp_4[0]); + uint32_t lengthArrayU16NotComp_1 = sizeof(arrayU16NotComp_1) / sizeof(arrayU16NotComp_1[0]); + uint32_t lengthArrayU16NotComp_2 = sizeof(arrayU16NotComp_2) / sizeof(arrayU16NotComp_2[0]); + uint32_t lengthArrayU16NotComp_3 = sizeof(arrayU16NotComp_3) / sizeof(arrayU16NotComp_3[0]); + uint32_t lengthArrayU16NotComp_4 = sizeof(arrayU16NotComp_4) / sizeof(arrayU16NotComp_4[0]); + EcmaString *ecmaStrU8Ptr_1 = EcmaString::CreateFromUtf8(&arrayU8_1[0], lengthArrayU8_1, ecmaVMPtr, true); + EcmaString *ecmaStrU8Ptr_2 = EcmaString::CreateFromUtf8(&arrayU8_2[0], lengthArrayU8_2, ecmaVMPtr, true); + EcmaString *ecmaStrU8Ptr_3 = EcmaString::CreateFromUtf8(&arrayU8_3[0], lengthArrayU8_3, ecmaVMPtr, true); + EcmaString *ecmaStrU16CompPtr_1 = EcmaString::CreateFromUtf16(&arrayU16Comp_1[0], lengthArrayU16Comp_1, ecmaVMPtr, + true); + EcmaString *ecmaStrU16CompPtr_2 = EcmaString::CreateFromUtf16(&arrayU16Comp_2[0], lengthArrayU16Comp_2, ecmaVMPtr, + true); + EcmaString *ecmaStrU16CompPtr_3 = EcmaString::CreateFromUtf16(&arrayU16Comp_3[0], lengthArrayU16Comp_3, ecmaVMPtr, + true); + EcmaString *ecmaStrU16CompPtr_4 = EcmaString::CreateFromUtf16(&arrayU16Comp_4[0], lengthArrayU16Comp_4, ecmaVMPtr, + true); + EcmaString *ecmaStrU16NotCompPtr_1 = EcmaString::CreateFromUtf16(&arrayU16NotComp_1[0], lengthArrayU16NotComp_1, + ecmaVMPtr, false); + EcmaString *ecmaStrU16NotCompPtr_2 = EcmaString::CreateFromUtf16(&arrayU16NotComp_2[0], lengthArrayU16NotComp_2, + ecmaVMPtr, false); + EcmaString *ecmaStrU16NotCompPtr_3 = EcmaString::CreateFromUtf16(&arrayU16NotComp_3[0], lengthArrayU16NotComp_3, + ecmaVMPtr, false); + EcmaString *ecmaStrU16NotCompPtr_4 = EcmaString::CreateFromUtf16(&arrayU16NotComp_4[0], lengthArrayU16NotComp_4, + ecmaVMPtr, false); + + // StringsAreEqualUtf8(). EcmaString made by CreateFromUtf8(), Array:U8. + EXPECT_TRUE(EcmaString::StringsAreEqualUtf8(ecmaStrU8Ptr_1, &arrayU8_1[0], lengthArrayU8_1, true)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf8(ecmaStrU8Ptr_1, &arrayU8_1[0], lengthArrayU8_1, false)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf8(ecmaStrU8Ptr_2, &arrayU8_1[0], lengthArrayU8_1, true)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf8(ecmaStrU8Ptr_3, &arrayU8_1[0], lengthArrayU8_1, true)); + + // StringsAreEqualUtf8(). EcmaString made by CreateFromUtf16( , , , true), Array:U8. + EXPECT_TRUE(EcmaString::StringsAreEqualUtf8(ecmaStrU16CompPtr_1, &arrayU8_1[0], lengthArrayU8_1, true)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf8(ecmaStrU16CompPtr_1, &arrayU8_1[0], lengthArrayU8_1, false)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf8(ecmaStrU16CompPtr_2, &arrayU8_1[0], lengthArrayU8_1, true)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf8(ecmaStrU16CompPtr_3, &arrayU8_1[0], lengthArrayU8_1, true)); + + // StringsAreEqualUtf8(). EcmaString made by CreateFromUtf16( , , , true), Array:U8. + EXPECT_TRUE(EcmaString::StringsAreEqualUtf8(ecmaStrU16CompPtr_4, &arrayU8_1[0], lengthArrayU8_1, true)); + + // StringsAreEqualUtf8(). EcmaString made by CreateFromUtf16( , , , false), Array:U8. + EXPECT_TRUE(EcmaString::StringsAreEqualUtf8(ecmaStrU16NotCompPtr_1, &arrayU8_1[0], lengthArrayU8_1, false)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf8(ecmaStrU16NotCompPtr_1, &arrayU8_1[0], lengthArrayU8_1, true)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf8(ecmaStrU16NotCompPtr_2, &arrayU8_1[0], lengthArrayU8_1, false)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf8(ecmaStrU16NotCompPtr_3, &arrayU8_1[0], lengthArrayU8_1, false)); + + // StringsAreEqualUtf8(). EcmaString made by CreateFromUtf16( , , , true), Array:U8. + EXPECT_FALSE(EcmaString::StringsAreEqualUtf8(ecmaStrU16NotCompPtr_4, &arrayU8_1[0], lengthArrayU8_1, false)); +} + +HWTEST_F_L0(EcmaStringTest, StringsAreEqualUtf16) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + + // StringsAreEqualUtf16(). + uint8_t arrayU8_1[4] = {45, 92, 78}; + uint8_t arrayU8_2[5] = {45, 92, 78, 24}; + uint8_t arrayU8_3[3] = {45, 92}; + uint16_t arrayU16Comp_1[] = {45, 92, 78}; + uint16_t arrayU16Comp_2[] = {45, 92, 78, 24}; + uint16_t arrayU16Comp_3[] = {45, 92}; + uint16_t arrayU16Comp_4[] = {25645, 25692, 25678}; //25645 = 256L + 45, 25692 = 256M + 92, 25678 = 256N + 78. + uint16_t arrayU16NotComp_1[] = {45, 92, 78}; + uint16_t arrayU16NotComp_2[] = {45, 92, 78, 24}; + uint16_t arrayU16NotComp_3[] = {45, 92}; + uint16_t arrayU16NotComp_4[] = {25645, 25692, 25678}; //25645 = 256L + 45, 25692 = 256M + 92, 25678 = 256N + 78. + uint16_t arrayU16NotComp_5[] = {25645, 25692, 25678, 65535}; + uint16_t arrayU16NotComp_6[] = {25645, 25692}; + uint32_t lengthArrayU8_1 = sizeof(arrayU8_1) - 1; + uint32_t lengthArrayU8_2 = sizeof(arrayU8_2) - 1; + uint32_t lengthArrayU8_3 = sizeof(arrayU8_3) - 1; + uint32_t lengthArrayU16Comp_1 = sizeof(arrayU16Comp_1) / sizeof(arrayU16Comp_1[0]); + uint32_t lengthArrayU16Comp_2 = sizeof(arrayU16Comp_2) / sizeof(arrayU16Comp_2[0]); + uint32_t lengthArrayU16Comp_3 = sizeof(arrayU16Comp_3) / sizeof(arrayU16Comp_3[0]); + uint32_t lengthArrayU16Comp_4 = sizeof(arrayU16Comp_4) / sizeof(arrayU16Comp_4[0]); + uint32_t lengthArrayU16NotComp_1 = sizeof(arrayU16NotComp_1) / sizeof(arrayU16NotComp_1[0]); + uint32_t lengthArrayU16NotComp_2 = sizeof(arrayU16NotComp_2) / sizeof(arrayU16NotComp_2[0]); + uint32_t lengthArrayU16NotComp_3 = sizeof(arrayU16NotComp_3) / sizeof(arrayU16NotComp_3[0]); + uint32_t lengthArrayU16NotComp_4 = sizeof(arrayU16NotComp_4) / sizeof(arrayU16NotComp_4[0]); + uint32_t lengthArrayU16NotComp_5 = sizeof(arrayU16NotComp_5) / sizeof(arrayU16NotComp_5[0]); + uint32_t lengthArrayU16NotComp_6 = sizeof(arrayU16NotComp_6) / sizeof(arrayU16NotComp_6[0]); + EcmaString *ecmaStrU8Ptr_1 = EcmaString::CreateFromUtf8(&arrayU8_1[0], lengthArrayU8_1, ecmaVMPtr, true); + EcmaString *ecmaStrU8Ptr_2 = EcmaString::CreateFromUtf8(&arrayU8_2[0], lengthArrayU8_2, ecmaVMPtr, true); + EcmaString *ecmaStrU8Ptr_3 = EcmaString::CreateFromUtf8(&arrayU8_3[0], lengthArrayU8_3, ecmaVMPtr, true); + EcmaString *ecmaStrU16CompPtr_1 = EcmaString::CreateFromUtf16(&arrayU16Comp_1[0], lengthArrayU16Comp_1, ecmaVMPtr, + true); + EcmaString *ecmaStrU16CompPtr_2 = EcmaString::CreateFromUtf16(&arrayU16Comp_2[0], lengthArrayU16Comp_2, ecmaVMPtr, + true); + EcmaString *ecmaStrU16CompPtr_3 = EcmaString::CreateFromUtf16(&arrayU16Comp_3[0], lengthArrayU16Comp_3, ecmaVMPtr, + true); + EcmaString *ecmaStrU16CompPtr_4 = EcmaString::CreateFromUtf16(&arrayU16Comp_4[0], lengthArrayU16Comp_4, ecmaVMPtr, + true); + EcmaString *ecmaStrU16NotCompPtr_1 = EcmaString::CreateFromUtf16(&arrayU16NotComp_1[0], lengthArrayU16NotComp_1, + ecmaVMPtr, false); + EcmaString *ecmaStrU16NotCompPtr_2 = EcmaString::CreateFromUtf16(&arrayU16NotComp_2[0], lengthArrayU16NotComp_2, + ecmaVMPtr, false); + EcmaString *ecmaStrU16NotCompPtr_3 = EcmaString::CreateFromUtf16(&arrayU16NotComp_3[0], lengthArrayU16NotComp_3, + ecmaVMPtr, false); + EcmaString *ecmaStrU16NotCompPtr_4 = EcmaString::CreateFromUtf16(&arrayU16NotComp_4[0], lengthArrayU16NotComp_4, + ecmaVMPtr, false); + EcmaString *ecmaStrU16NotCompPtr_5 = EcmaString::CreateFromUtf16(&arrayU16NotComp_5[0], lengthArrayU16NotComp_5, + ecmaVMPtr, false); + EcmaString *ecmaStrU16NotCompPtr_6 = EcmaString::CreateFromUtf16(&arrayU16NotComp_6[0], lengthArrayU16NotComp_6, + ecmaVMPtr, false); + + // StringsAreEqualUtf16(). EcmaString made by CreateFromUtf8, Array:U16(1-127). + EXPECT_TRUE(EcmaString::StringsAreEqualUtf16(ecmaStrU8Ptr_1, &arrayU16NotComp_1[0], lengthArrayU16NotComp_1)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf16(ecmaStrU8Ptr_2, &arrayU16NotComp_1[0], lengthArrayU16NotComp_1)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf16(ecmaStrU8Ptr_3, &arrayU16NotComp_1[0], lengthArrayU16NotComp_1)); + + // StringsAreEqualUtf16(). EcmaString made by CreateFromUtf16( , , , true), Array:U16(1-127). + EXPECT_TRUE(EcmaString::StringsAreEqualUtf16(ecmaStrU16CompPtr_1, &arrayU16NotComp_1[0], lengthArrayU16NotComp_1)); + EXPECT_TRUE(EcmaString::StringsAreEqualUtf16(ecmaStrU16CompPtr_4, &arrayU16NotComp_1[0], lengthArrayU16NotComp_1)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf16(ecmaStrU16CompPtr_2, &arrayU16NotComp_1[0], + lengthArrayU16NotComp_1)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf16(ecmaStrU16CompPtr_3, &arrayU16NotComp_1[0], + lengthArrayU16NotComp_1)); + + // StringsAreEqualUtf16(). EcmaString made by CreateFromUtf16( , , , false), Array:U16(1-127). + EXPECT_TRUE(EcmaString::StringsAreEqualUtf16(ecmaStrU16NotCompPtr_1, &arrayU16NotComp_1[0], + lengthArrayU16NotComp_1)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf16(ecmaStrU16NotCompPtr_2, &arrayU16NotComp_1[0], + lengthArrayU16NotComp_1)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf16(ecmaStrU16NotCompPtr_3, &arrayU16NotComp_1[0], + lengthArrayU16NotComp_1)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf16(ecmaStrU16NotCompPtr_4, &arrayU16NotComp_1[0], + lengthArrayU16NotComp_1)); + + // StringsAreEqualUtf16(). EcmaString made by CreateFromUtf16( , , , false), Array:U16(0-65535). + EXPECT_TRUE(EcmaString::StringsAreEqualUtf16(ecmaStrU16NotCompPtr_4, &arrayU16NotComp_4[0], + lengthArrayU16NotComp_4)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf16(ecmaStrU16NotCompPtr_5, &arrayU16NotComp_4[0], + lengthArrayU16NotComp_4)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf16(ecmaStrU16NotCompPtr_6, &arrayU16NotComp_4[0], + lengthArrayU16NotComp_4)); + EXPECT_FALSE(EcmaString::StringsAreEqualUtf16(ecmaStrU16NotCompPtr_1, &arrayU16NotComp_4[0], + lengthArrayU16NotComp_4)); +} + +HWTEST_F_L0(EcmaStringTest, ComputeHashcodeUtf8) +{ + // ComputeHashcodeUtf8(). Array:U8. + uint8_t arrayU8[] = {"abc"}; + uint32_t lengthArrayU8 = sizeof(arrayU8) - 1; + uint32_t hashExpect = 0; + for(uint32_t i = 0; i < lengthArrayU8; i++){ + hashExpect = hashExpect * 31 + arrayU8[i]; + } + EXPECT_EQ(EcmaString::ComputeHashcodeUtf8(&arrayU8[0], lengthArrayU8), static_cast(hashExpect)); +} + +HWTEST_F_L0(EcmaStringTest, ComputeHashcodeUtf16) +{ + // ComputeHashcodeUtf16(). Array:U16. + uint16_t arrayU16[] = {199, 1, 256, 65535, 777}; + uint32_t lengthArrayU16 = sizeof(arrayU16) / sizeof(arrayU16[0]); + uint32_t hashExpect = 0; + for(uint32_t i = 0; i < lengthArrayU16; i++){ + hashExpect = hashExpect * 31 + arrayU16[i]; + } + EXPECT_EQ(EcmaString::ComputeHashcodeUtf16(&arrayU16[0], lengthArrayU16), static_cast(hashExpect)); +} + +HWTEST_F_L0(EcmaStringTest, GetHashcode) +{ + EcmaVM* ecmaVMPtr = EcmaVM::Cast(instance); + + // GetHashcode(). EcmaString made by CreateFromUtf8(). + uint8_t arrayU8[] = {"abc"}; + uint32_t lengthArrayU8 = sizeof(arrayU8) - 1; + EcmaString *ecmaStrU8Ptr = EcmaString::CreateFromUtf8(&arrayU8[0], lengthArrayU8, ecmaVMPtr, true); + uint32_t hashExpect = 0; + for(uint32_t i = 0; i < lengthArrayU8; i++){ + hashExpect = hashExpect * 31 + arrayU8[i]; + } + EXPECT_EQ(ecmaStrU8Ptr->GetHashcode(), static_cast(hashExpect)); + + // GetHashcode(). EcmaString made by CreateFromUtf16( , , , true). + uint16_t arrayU16Comp[] = {45, 92, 78, 24}; + uint32_t lengthArrayU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]); + EcmaString *ecmaStrU16CompPtr = EcmaString::CreateFromUtf16(&arrayU16Comp[0], lengthArrayU16Comp, ecmaVMPtr, true); + hashExpect = 0; + for(uint32_t i = 0; i < lengthArrayU16Comp; i++){ + hashExpect = hashExpect * 31 + arrayU16Comp[i]; + } + EXPECT_EQ(ecmaStrU16CompPtr->GetHashcode(), static_cast(hashExpect)); + + // GetHashcode(). EcmaString made by CreateFromUtf16( , , , false). + uint16_t arrayU16NotComp[] = {199, 1, 256, 65535, 777}; + uint32_t lengthArrayU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]); + EcmaString *ecmaStrU16NotCompPtr = EcmaString::CreateFromUtf16(&arrayU16NotComp[0], lengthArrayU16NotComp, + ecmaVMPtr, false); + hashExpect = 0; + for(uint32_t i = 0; i < lengthArrayU16NotComp; i++){ + hashExpect = hashExpect * 31 + arrayU16NotComp[i]; + } + EXPECT_EQ(ecmaStrU16NotCompPtr->GetHashcode(), static_cast(hashExpect)); + EcmaString::SetCompressedStringsEnabled(false); // Set compressedStringsEnabled false. + EXPECT_EQ(ecmaStrU16NotCompPtr->GetHashcode(), static_cast(hashExpect)); + EcmaString::SetCompressedStringsEnabled(true); // Set compressedStringsEnabled true(default). + + // GetHashcode(). EcmaString made by CreateEmptyString(). + EcmaString *ecmaStrEmptyPtr = EcmaString::CreateEmptyString(ecmaVMPtr); + EXPECT_EQ(ecmaStrEmptyPtr->GetHashcode(), 0); + EcmaString::SetCompressedStringsEnabled(false); // Set compressedStringsEnabled false. + EcmaString *ecmaStrNotCompEmptyPtr = EcmaString::CreateEmptyString(ecmaVMPtr); + EXPECT_EQ(ecmaStrNotCompEmptyPtr->GetHashcode(), 0); + EcmaString::SetCompressedStringsEnabled(true); // Set compressedStringsEnabled true(default). + + // GetHashcode(). EcmaString made by AllocStringObject(). + size_t sizeAlloc = 5; + EcmaString *ecmaStrAllocCompPtr = EcmaString::AllocStringObject(sizeAlloc, true, ecmaVMPtr); + EcmaString *ecmaStrAllocNotCompPtr = EcmaString::AllocStringObject(sizeAlloc, false, ecmaVMPtr); + EXPECT_EQ(ecmaStrAllocCompPtr->GetHashcode(), 0); + EXPECT_EQ(ecmaStrAllocNotCompPtr->GetHashcode(), 0); + EcmaString::SetCompressedStringsEnabled(false); // Set compressedStringsEnabled false. + EXPECT_EQ(ecmaStrAllocNotCompPtr->GetHashcode(), 0); + EcmaString::SetCompressedStringsEnabled(true); // Set compressedStringsEnabled true(default). +} +} \ No newline at end of file