* Copyright (c) 2024 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 "gtest/gtest.h"
#include "gtest/hwext/gtest-ext.h"
#include "gtest/hwext/gtest-tag.h"
#include "unicode/unistr.h"
#include "base/utils/utf_helper.h"
using namespace testing;
using namespace testing::ext;
namespace OHOS::Ace::UtfUtils {
class UtfHelperTestNg : public Test {
void SetUp() override
{
index = 0;
}
public:
size_t index;
};
* @tc.name: DecodeUTF16_001
* @tc.desc: Test utf_helper DecodeUTF16
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, DecodeUTF16_001, TestSize.Level1)
{
uint16_t utf16[1] = { 0x0041 };
size_t len = sizeof(utf16) / sizeof(utf16[0]);
EXPECT_EQ(DecodeUTF16(utf16, len, &index), 0x0041);
EXPECT_EQ(index, 0);
}
* @tc.name: DecodeUTF16_002
* @tc.desc: Test utf_helper DecodeUTF16
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, DecodeUTF16_002, TestSize.Level1)
{
uint16_t utf16[2] = { 0xD83D, 0xDE00 };
size_t len = sizeof(utf16) / sizeof(utf16[0]);
EXPECT_EQ(DecodeUTF16(utf16, len, &index), 0x1F600);
EXPECT_EQ(index, 1);
}
* @tc.name: DecodeUTF16_003
* @tc.desc: Test utf_helper DecodeUTF16
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, DecodeUTF16_003, TestSize.Level1)
{
uint16_t utf16[3] = { 0xD83D, 0xDC00 - 1, 0xDE00 };
size_t len = sizeof(utf16) / sizeof(utf16[0]);
EXPECT_EQ(DecodeUTF16(utf16, len, &index), 0xD83D);
EXPECT_EQ(index, 0);
}
* @tc.name: DecodeUTF16_004
* @tc.desc: Test utf_helper DecodeUTF16
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, DecodeUTF16_004, TestSize.Level1)
{
uint16_t utf16[1] = { 0xD83D };
size_t len = sizeof(utf16) / sizeof(utf16[0]);
EXPECT_EQ(DecodeUTF16(utf16, len, &index), 0xD83D);
EXPECT_EQ(index, 0);
}
* @tc.name: DecodeUTF16_005
* @tc.desc: Test utf_helper DecodeUTF16
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, DecodeUTF16_005, TestSize.Level1)
{
uint16_t utf16[2] = { 0x0041, 0xDC00 };
size_t len = sizeof(utf16) / sizeof(utf16[0]);
EXPECT_EQ(DecodeUTF16(utf16, len, &index), 0x0041);
EXPECT_EQ(index, 0);
}
* @tc.name: HandleAndDecodeInvalidUTF16_001
* @tc.desc: Test utf_helper HandleAndDecodeInvalidUTF16
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, HandleAndDecodeInvalidUTF16_001, TestSize.Level1)
{
uint16_t utf16[2] = { 0xDE00, 0xD83D };
size_t len = sizeof(utf16) / sizeof(utf16[0]);
EXPECT_EQ(HandleAndDecodeInvalidUTF16(utf16, len, &index), 0xFFFD);
EXPECT_EQ(index, 0);
}
* @tc.name: HandleAndDecodeInvalidUTF16_002
* @tc.desc: Test utf_helper HandleAndDecodeInvalidUTF16
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, HandleAndDecodeInvalidUTF16_002, TestSize.Level1)
{
uint16_t utf16[1] = { 0x4100 };
size_t len = sizeof(utf16) / sizeof(utf16[0]);
EXPECT_EQ(HandleAndDecodeInvalidUTF16(utf16, len, &index), 0x4100);
EXPECT_EQ(index, 0);
}
* @tc.name: HandleAndDecodeInvalidUTF16_003
* @tc.desc: Test utf_helper HandleAndDecodeInvalidUTF16
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, HandleAndDecodeInvalidUTF16_003, TestSize.Level1)
{
uint16_t utf16[1] = { 0xDBFF - 1 };
size_t len = sizeof(utf16) / sizeof(utf16[0]);
EXPECT_EQ(HandleAndDecodeInvalidUTF16(utf16, len, &index), 0xFFFD);
EXPECT_EQ(index, 0);
}
* @tc.name: HandleAndDecodeInvalidUTF16_004
* @tc.desc: Test utf_helper HandleAndDecodeInvalidUTF16
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, HandleAndDecodeInvalidUTF16_004, TestSize.Level1)
{
uint16_t utf16[2] = { 0xDBFF - 1, 0xDBFF - 1 };
size_t len = sizeof(utf16) / sizeof(utf16[0]);
EXPECT_EQ(HandleAndDecodeInvalidUTF16(utf16, len, &index), 0xFFFD);
EXPECT_EQ(index, 0);
}
* @tc.name: HandleAndDecodeInvalidUTF16_005
* @tc.desc: Test utf_helper HandleAndDecodeInvalidUTF16
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, HandleAndDecodeInvalidUTF16_005, TestSize.Level1)
{
uint16_t first = 0xDBFF - 1;
uint16_t second = 0xDC00 + 1;
uint16_t utf16[2] = { first, second };
size_t len = sizeof(utf16) / sizeof(utf16[0]);
uint32_t res = ((first - 0xD800) << 10) + (second - 0xDC00) + 0x10000;
EXPECT_EQ(HandleAndDecodeInvalidUTF16(utf16, len, &index), res);
EXPECT_EQ(index, 1);
}
* @tc.name: HandleInvalidUTF16_001
* @tc.desc: Test utf_helper HandleInvalidUTF16
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, HandleInvalidUTF16_001, TestSize.Level1)
{
uint16_t* utf16 = nullptr;
HandleInvalidUTF16(utf16, 0, 0);
ASSERT_EQ(utf16, nullptr);
}
* @tc.name: RepalceUnpairedSurrogates_001
* @tc.desc: Test utf_helper RepalceUnpairedSurrogates
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, RepalceUnpairedSurrogates_001, TestSize.Level1)
{
uint16_t utf16[1] = { 0xDC00 + 1 };
size_t len = sizeof(utf16) / sizeof(utf16[0]);
HandleInvalidUTF16(utf16, len, 0);
EXPECT_EQ(utf16[0], 0xFFFD);
}
* @tc.name: RepalceUnpairedSurrogates_002
* @tc.desc: Test utf_helper RepalceUnpairedSurrogates
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, RepalceUnpairedSurrogates_002, TestSize.Level1)
{
uint16_t utf16[1] = { 0xD800 - 1 };
size_t len = sizeof(utf16) / sizeof(utf16[0]);
HandleInvalidUTF16(utf16, len, 0);
EXPECT_EQ(utf16[0], 0xD800 - 1);
}
* @tc.name: RepalceUnpairedSurrogates_003
* @tc.desc: Test utf_helper RepalceUnpairedSurrogates
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, RepalceUnpairedSurrogates_003, TestSize.Level1)
{
uint16_t utf16[1] = { 0xDC00 - 1 };
size_t len = sizeof(utf16) / sizeof(utf16[0]);
HandleInvalidUTF16(utf16, len, 0);
EXPECT_EQ(utf16[0], 0xFFFD);
}
* @tc.name: RepalceUnpairedSurrogates_004
* @tc.desc: Test utf_helper RepalceUnpairedSurrogates
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, RepalceUnpairedSurrogates_004, TestSize.Level1)
{
uint16_t utf16[2] = { 0xDC00 - 1, 0xDC00 - 1 };
size_t len = sizeof(utf16) / sizeof(utf16[0]);
HandleInvalidUTF16(utf16, len, 0);
EXPECT_EQ(utf16[0], 0xFFFD);
EXPECT_EQ(utf16[1], 0xFFFD);
}
* @tc.name: RepalceUnpairedSurrogates_005
* @tc.desc: Test utf_helper RepalceUnpairedSurrogates
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, RepalceUnpairedSurrogates_005, TestSize.Level1)
{
uint16_t utf16[2] = { 0xDC00 - 1, 0xDC00 + 1 };
size_t len = sizeof(utf16) / sizeof(utf16[0]);
HandleInvalidUTF16(utf16, len, 0);
EXPECT_EQ(utf16[0], 0xDC00 - 1);
EXPECT_EQ(utf16[1], 0xDC00 + 1);
}
* @tc.name: UTF8Length_001
* @tc.desc: Test utf_helper UTF8Length
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, UTF8Length_001, TestSize.Level1)
{
uint32_t codepoint = 0xfffff;
uint8_t utf8[3] = { 0xd8 + 1, 0xdc - 1, 0xd8 + 1 };
size_t len = sizeof(utf8) / sizeof(utf8[0]);
size_t indexOfUtf8 = 0;
EXPECT_EQ(EncodeUTF8(codepoint, utf8, len, indexOfUtf8 - 1), 4);
}
* @tc.name: UTF8Length_002
* @tc.desc: Test utf_helper UTF8Length
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, UTF8Length_002, TestSize.Level1)
{
uint32_t codepoint = 0x7f + 1;
uint8_t utf8[1] = { 0xd8 + 1 };
size_t len = sizeof(utf8) / sizeof(utf8[0]);
size_t indexOfUtf8 = 0;
EXPECT_EQ(EncodeUTF8(codepoint, utf8, len, indexOfUtf8 - 1), 2);
}
* @tc.name: EncodeUTF8_001
* @tc.desc: Test utf_helper EncodeUTF8
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, EncodeUTF8_001, TestSize.Level1)
{
uint32_t codepoint = 0xffff;
uint8_t utf8[2] = { 0xd8 + 1, 0xdc - 1 };
size_t len = sizeof(utf8) / sizeof(utf8[0]);
size_t indexOfUtf8 = 0;
EXPECT_EQ(EncodeUTF8(codepoint, utf8, len, indexOfUtf8), 0);
}
* @tc.name: EncodeUTF8_002
* @tc.desc: Test utf_helper EncodeUTF8
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, EncodeUTF8_002, TestSize.Level1)
{
uint32_t codepoint = 0xfffff;
uint8_t utf8[3] = { 0xd8 + 1, 0xdc - 1, 0xd8 + 1 };
size_t len = sizeof(utf8) / sizeof(utf8[0]);
size_t indexOfUtf8 = 0;
EXPECT_EQ(EncodeUTF8(codepoint, utf8, len, indexOfUtf8 - 1), 4);
}
* @tc.name: Utf16ToUtf8Size001
* @tc.desc: Test utf_helper Utf16ToUtf8Size with nullptr
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size001, TestSize.Level1)
{
uint16_t* utf16 = nullptr;
EXPECT_EQ(Utf16ToUtf8Size(utf16, 0), 1);
}
* @tc.name: Utf16ToUtf8Size002
* @tc.desc: Test utf_helper Utf16ToUtf8Size wtih empty array
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size002, TestSize.Level1)
{
uint16_t utf16[] = {};
EXPECT_EQ(Utf16ToUtf8Size(utf16, 0), 1);
}
* @tc.name: Utf16ToUtf8Size003
* @tc.desc: Test utf_helper Utf16ToUtf8Size with zero and length 0
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size003, TestSize.Level1)
{
uint16_t utf16[] = { 0 };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 0), 1);
}
* @tc.name: Utf16ToUtf8Size004
* @tc.desc: Test utf_helper Utf16ToUtf8Size with single zero 1
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size004, TestSize.Level1)
{
uint16_t utf16[] = { 0 };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 1), 1);
}
* @tc.name: Utf16ToUtf8Size005
* @tc.desc: Test utf_helper Utf16ToUtf8Size with single Ascii
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size005, TestSize.Level1)
{
uint16_t utf16[] = { 0x41 };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 1), 2);
}
* @tc.name: Utf16ToUtf8Size006
* @tc.desc: Test utf_helper Utf16ToUtf8Size with single two bytes
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size006, TestSize.Level1)
{
uint16_t utf16[] = { 0x80 };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 1), 3);
}
* @tc.name: Utf16ToUtf8Size007
* @tc.desc: Test utf_helper Utf16ToUtf8Size with single three bytes
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size007, TestSize.Level1)
{
uint16_t utf16[] = { 0x800 };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 1), 4);
}
* @tc.name: Utf16ToUtf8Size008
* @tc.desc: Test utf_helper Utf16ToUtf8Size with high surrogate min
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size008, TestSize.Level1)
{
uint16_t utf16[] = { 0xD800 };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 1), 4);
}
* @tc.name: Utf16ToUtf8Size009
* @tc.desc: Test utf_helper Utf16ToUtf8Size with num in range high surrogate min and low surrogate max
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size009, TestSize.Level1)
{
uint16_t utf16[] = { 0xDC00 };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 1), 4);
}
* @tc.name: Utf16ToUtf8Size010
* @tc.desc: Test utf_helper Utf16ToUtf8Size with low surrogate max
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size010, TestSize.Level1)
{
uint16_t utf16[] = { 0xDFFF };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 1), 4);
}
* @tc.name: Utf16ToUtf8Size011
* @tc.desc: Test utf_helper Utf16ToUtf8Size with valid surrogate pair
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size011, TestSize.Level1)
{
uint16_t utf16[] = { 0xD800, 0xDC00 };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 2), 5);
}
* @tc.name: Utf16ToUtf8Size012
* @tc.desc: Test utf_helper Utf16ToUtf8Size with high surrogate followed by nonsurrogate
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size012, TestSize.Level1)
{
uint16_t utf16[] = { 0xD800, 0x1234 };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 2), 7);
}
* @tc.name: Utf16ToUtf8Size013
* @tc.desc: Test utf_helper Utf16ToUtf8Size with high surrogate at end
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size013, TestSize.Level1)
{
uint16_t utf16[] = { 0xD800, 0xD800 };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 2), 7);
}
* @tc.name: Utf16ToUtf8Size014
* @tc.desc: Test utf_helper Utf16ToUtf8Size with mixed characters with zero
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size014, TestSize.Level1)
{
uint16_t utf16[] = { 0x41, 0, 0x80, 0x800, 0xD800, 0xDC00 };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 6), 11);
}
* @tc.name: Utf16ToUtf8Size015
* @tc.desc: Test utf_helper Utf16ToUtf8Size with multiple valid surrogate pairs
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size015, TestSize.Level1)
{
uint16_t utf16[] = { 0xD800, 0xDC00, 0xD801, 0xDC01 };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 4), 9);
}
* @tc.name: Utf16ToUtf8Size016
* @tc.desc: Test utf_helper Utf16ToUtf8Size with max two bytes
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size016, TestSize.Level1)
{
uint16_t utf16[] = { 0x7FF };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 1), 3);
}
* @tc.name: Utf16ToUtf8Size017
* @tc.desc: Test utf_helper Utf16ToUtf8Size with min three bytes
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size017, TestSize.Level1)
{
uint16_t utf16[] = { 0x800 };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 1), 4);
}
* @tc.name: Utf16ToUtf8Size018
* @tc.desc: Test utf_helper Utf16ToUtf8Size with nonsurrogate three bytes
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size018, TestSize.Level1)
{
uint16_t utf16[] = { 0xD7FF };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 1), 4);
}
* @tc.name: Utf16ToUtf8Size019
* @tc.desc: Test utf_helper Utf16ToUtf8Size with low surrogate after
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size019, TestSize.Level1)
{
uint16_t utf16[] = { 0xE000 };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 1), 4);
}
* @tc.name: Utf16ToUtf8Size020
* @tc.desc: Test utf_helper Utf16ToUtf8Size with multiple zeros
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, Utf16ToUtf8Size020, TestSize.Level1)
{
uint16_t utf16[] = { 0, 0, 0 };
EXPECT_EQ(Utf16ToUtf8Size(utf16, 3), 1);
}
* @tc.name: ConvertRegionUtf16ToUtf8_001
* @tc.desc: Test utf_helper ConvertRegionUtf16ToUtf8 with invalid input 1
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, ConvertRegionUtf16ToUtf8_001, TestSize.Level1)
{
uint8_t output[4] = { 0 };
size_t result = ConvertRegionUtf16ToUtf8(nullptr, output, 2, 4, 0);
EXPECT_EQ(result, 0);
}
* @tc.name: ConvertRegionUtf16ToUtf8_002
* @tc.desc: Test utf_helper ConvertRegionUtf16ToUtf8 with invalid input 2
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, ConvertRegionUtf16ToUtf8_002, TestSize.Level1)
{
size_t result = ConvertRegionUtf16ToUtf8(reinterpret_cast<const uint16_t*>("A"), nullptr, 1, 4, 0);
EXPECT_EQ(result, 0);
}
* @tc.name: ConvertRegionUtf16ToUtf8_003
* @tc.desc: Test utf_helper ConvertRegionUtf16ToUtf8 with invalid input 3
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, ConvertRegionUtf16ToUtf8_003, TestSize.Level1)
{
uint8_t output[4] = { 0 };
size_t result = ConvertRegionUtf16ToUtf8(reinterpret_cast<const uint16_t*>("A"), output, 1, 0, 0);
EXPECT_EQ(result, 0);
}
* @tc.name: ConvertRegionUtf16ToUtf8_004
* @tc.desc: Test utf_helper ConvertRegionUtf16ToUtf8 with ASCII characters: 'a', 'b' and 'c'
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, ConvertRegionUtf16ToUtf8_004, TestSize.Level1)
{
const uint16_t input[] = { 0x0041, 0x0042, 0x0043 };
std::array<uint8_t, 3> output = { 0 };
size_t result = ConvertRegionUtf16ToUtf8(input, output.data(), 3, 3, 0);
EXPECT_EQ(result, 3);
EXPECT_EQ(output[0], 0x41);
EXPECT_EQ(output[1], 0x42);
EXPECT_EQ(output[2], 0x43);
}
* @tc.name: ConvertRegionUtf16ToUtf8_005
* @tc.desc: Test utf_helper ConvertRegionUtf16ToUtf8 with surrogate pair (smiling face)
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, ConvertRegionUtf16ToUtf8_005, TestSize.Level1)
{
const uint16_t input[] = { 0xD83D, 0xDE00 };
std::array<uint8_t, 4> output = { 0 };
size_t result = ConvertRegionUtf16ToUtf8(input, output.data(), 2, 4, 0);
EXPECT_EQ(result, 4);
EXPECT_EQ(output[0], 0xF0);
EXPECT_EQ(output[1], 0x9F);
EXPECT_EQ(output[2], 0x98);
EXPECT_EQ(output[3], 0x80);
}
* @tc.name: ConvertRegionUtf16ToUtf8_006
* @tc.desc: Test utf_helper ConvertRegionUtf16ToUtf8 start position
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, ConvertRegionUtf16ToUtf8_006, TestSize.Level1)
{
const uint16_t input[] = { 0x0041, 0xD83D, 0xDE00, 0x0042 };
std::array<uint8_t, 5> output = { 0 };
size_t result = ConvertRegionUtf16ToUtf8(input, output.data(), 3, 5, 1);
EXPECT_EQ(result, 5);
EXPECT_EQ(output[0], 0xF0);
EXPECT_EQ(output[1], 0x9F);
EXPECT_EQ(output[2], 0x98);
EXPECT_EQ(output[3], 0x80);
EXPECT_EQ(output[4], 0x42);
}
* @tc.name: ConvertRegionUtf16ToUtf8_007
* @tc.desc: Test utf_helper ConvertRegionUtf16ToUtf8 with empty region
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, ConvertRegionUtf16ToUtf8_007, TestSize.Level1)
{
const uint16_t input[] = { 0x0041 };
std::array<uint8_t, 1> output = { 0 };
size_t result = ConvertRegionUtf16ToUtf8(input, output.data(), 0, 1, 0);
EXPECT_EQ(result, 0);
}
* @tc.name: ConvertRegionUtf16ToUtf8_008
* @tc.desc: Test utf_helper ConvertRegionUtf16ToUtf8 start beyond end
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, ConvertRegionUtf16ToUtf8_008, TestSize.Level1)
{
const uint16_t input[] = { 0x0041 };
std::array<uint8_t, 1> output = { 0 };
size_t result = ConvertRegionUtf16ToUtf8(input, output.data(), 1, 0, 0);
EXPECT_EQ(result, 0);
}
* @tc.name: IsIndexInPairedSurrogates001
* @tc.desc: Test utf_helper IsIndexInPairedSurrogates with empty string
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, IsIndexInPairedSurrogates001, TestSize.Level1)
{
std::u16string empty;
EXPECT_FALSE(IsIndexInPairedSurrogates(0, empty));
EXPECT_FALSE(IsIndexInPairedSurrogates(-1, empty));
EXPECT_FALSE(IsIndexInPairedSurrogates(1, empty));
}
* @tc.name: IsIndexInPairedSurrogates002
* @tc.desc: Test utf_helper IsIndexInPairedSurrogates with index zero or outOfRange
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, IsIndexInPairedSurrogates002, TestSize.Level1)
{
std::u16string str = {u'a', 0xD800, 0xDC00};
EXPECT_FALSE(IsIndexInPairedSurrogates(0, str));
EXPECT_FALSE(IsIndexInPairedSurrogates(3, str));
}
* @tc.name: IsIndexInPairedSurrogates003
* @tc.desc: Test utf_helper IsIndexInPairedSurrogates with valid surrogate pair
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, IsIndexInPairedSurrogates003, TestSize.Level1)
{
std::u16string str1 = {0xD800, 0xDC00};
EXPECT_TRUE(IsIndexInPairedSurrogates(1, str1));
std::u16string str2 = {0xDBFF, 0xDFFF};
EXPECT_TRUE(IsIndexInPairedSurrogates(1, str2));
}
* @tc.name: IsIndexInPairedSurrogates004
* @tc.desc: Test utf_helper IsIndexInPairedSurrogates with invalid surrogate pair
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, IsIndexInPairedSurrogates004, TestSize.Level1)
{
std::u16string str1 = {0xD800, u'a'};
EXPECT_FALSE(IsIndexInPairedSurrogates(1, str1));
std::u16string str2 = {u'a', 0xDC00};
EXPECT_FALSE(IsIndexInPairedSurrogates(1, str2));
std::u16string str3 = {0xD800};
EXPECT_FALSE(IsIndexInPairedSurrogates(1, str3));
}
* @tc.name: IsIndexInPairedSurrogates005
* @tc.desc: Test utf_helper IsIndexInPairedSurrogates with multiple surrogate pairs
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, IsIndexInPairedSurrogates005, TestSize.Level1)
{
std::u16string str = {0xD800, 0xDC00, 0xDBFF, 0xDFFF};
EXPECT_TRUE(IsIndexInPairedSurrogates(1, str));
EXPECT_TRUE(IsIndexInPairedSurrogates(3, str));
EXPECT_FALSE(IsIndexInPairedSurrogates(2, str));
}
* @tc.name: IsIndexInPairedSurrogates006
* @tc.desc: Test utf_helper IsIndexInPairedSurrogates with mixed characters
* @tc.type: FUNC
*/
HWTEST_F(UtfHelperTestNg, IsIndexInPairedSurrogates006, TestSize.Level1)
{
std::u16string str = {u'A', 0xD800, 0xDC00, u'B'};
EXPECT_FALSE(IsIndexInPairedSurrogates(0, str));
EXPECT_FALSE(IsIndexInPairedSurrogates(1, str));
EXPECT_TRUE(IsIndexInPairedSurrogates(2, str));
EXPECT_FALSE(IsIndexInPairedSurrogates(3, str));
}
}