1/*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include <gtest/gtest.h>
17
18#define private public
19#define protected public
20#include "zchar_wrapper.h"
21#undef private
22#undef protected
23
24using namespace OHOS;
25using namespace OHOS::AAFwk;
26using testing::ext::TestSize;
27
28namespace OHOS {
29namespace AAFwk {
30class AAfWKZcharWrapperTest : public testing::Test {
31public:
32    static void SetUpTestCase() {};
33    static void TearDownTestCase() {};
34    void SetUp() {};
35    void TearDown() {};
36};
37
38/**
39 * @tc.number: ZcharWrapperTest_GetValue_001
40 * @tc.name: GetValue
41 * @tc.desc:
42 */
43HWTEST_F(AAfWKZcharWrapperTest, ZcharWrapperTest_GetValue_001, TestSize.Level1)
44{
45  zchar value = 0;
46  Char zcharValue(value);
47  ErrCode result = zcharValue.GetValue(value);
48  EXPECT_EQ(ERR_OK, result);
49}
50
51/**
52 * @tc.number: ZcharWrapperTest_Box_001
53 * @tc.name: Box
54 * @tc.desc:
55 */
56HWTEST_F(AAfWKZcharWrapperTest, ZcharWrapperTest_Box_001, TestSize.Level1)
57{
58  char value = 0;
59  Char charValue(value);
60  char result = charValue.Unbox(charValue.Box(value));
61  EXPECT_EQ(0, result);
62}
63
64/**
65 * @tc.number: ZcharWrapperTest_GetByteSize_001
66 * @tc.name: GetByteSize
67 * @tc.desc:
68 */
69HWTEST_F(AAfWKZcharWrapperTest, ZcharWrapperTest_GetByteSize_001, TestSize.Level1)
70{
71    zchar value = 0xD801;
72    Char zcharValue(value);
73    EXPECT_EQ(0, zcharValue.GetByteSize(value));
74}
75
76/**
77 * @tc.number: ZcharWrapperTest_GetByteSize_002
78 * @tc.name: GetByteSize
79 * @tc.desc:
80 */
81HWTEST_F(AAfWKZcharWrapperTest, ZcharWrapperTest_GetByteSize_002, TestSize.Level1)
82{
83    zchar value = 0x10FFFF + 1;
84    Char zcharValue(value);
85    EXPECT_EQ(0, zcharValue.GetByteSize(value));
86}
87
88/**
89 * @tc.number: ZcharWrapperTest_GetByteSize_003
90 * @tc.name: GetByteSize
91 * @tc.desc:
92 */
93HWTEST_F(AAfWKZcharWrapperTest, ZcharWrapperTest_GetByteSize_003, TestSize.Level1)
94{
95    zchar value = 0x00000800 - 1;
96    Char zcharValue(value);
97    EXPECT_EQ(2, zcharValue.GetByteSize(value));
98}
99
100/**
101 * @tc.number: ZcharWrapperTest_GetByteSize_004
102 * @tc.name: GetByteSize
103 * @tc.desc:
104 */
105HWTEST_F(AAfWKZcharWrapperTest, ZcharWrapperTest_GetByteSize_004, TestSize.Level1)
106{
107    zchar value = 0x00010000 - 1;
108    Char zcharValue(value);
109    EXPECT_EQ(3, zcharValue.GetByteSize(value));
110}
111
112/**
113 * @tc.number: ZcharWrapperTest_GetByteSize_005
114 * @tc.name: GetByteSize
115 * @tc.desc:
116 */
117HWTEST_F(AAfWKZcharWrapperTest, ZcharWrapperTest_GetByteSize_005, TestSize.Level1)
118{
119    zchar value = 0x00010000 + 1;
120    Char zcharValue(value);
121    EXPECT_EQ(4, zcharValue.GetByteSize(value));
122}
123
124/**
125 * @tc.number: ZcharWrapperTest_WriteUTF8Bytes_001
126 * @tc.name: WriteUTF8Bytes
127 * @tc.desc:
128 */
129HWTEST_F(AAfWKZcharWrapperTest, ZcharWrapperTest_WriteUTF8Bytes_001, TestSize.Level1)
130{
131    zchar value = 0;
132    Char zcharValue(value);
133    char *dst = new char [4];
134    int32_t size = 4;
135    zcharValue.WriteUTF8Bytes(dst, value, size);
136    EXPECT_EQ(1, zcharValue.GetByteSize(value));
137}
138
139/**
140 * @tc.number: ZcharWrapperTest_WriteUTF8Bytes_002
141 * @tc.name: WriteUTF8Bytes
142 * @tc.desc:
143 */
144HWTEST_F(AAfWKZcharWrapperTest, ZcharWrapperTest_WriteUTF8Bytes_002, TestSize.Level1)
145{
146    zchar value = 0;
147    Char zcharValue(value);
148    char *dst = new char [4];
149    int32_t size = 3;
150    zcharValue.WriteUTF8Bytes(dst, value, size);
151    EXPECT_EQ(1, zcharValue.GetByteSize(value));
152}
153
154/**
155 * @tc.number: ZcharWrapperTest_WriteUTF8Bytes_003
156 * @tc.name: WriteUTF8Bytes
157 * @tc.desc:
158 */
159HWTEST_F(AAfWKZcharWrapperTest, ZcharWrapperTest_WriteUTF8Bytes_003, TestSize.Level1)
160{
161    zchar value = 0;
162    Char zcharValue(value);
163    char *dst = new char [4];
164    int32_t size = 2;
165    zcharValue.WriteUTF8Bytes(dst, value, size);
166    EXPECT_EQ(1, zcharValue.GetByteSize(value));
167}
168
169/**
170 * @tc.number: ZcharWrapperTest_GetChar_001
171 * @tc.name: GetChar
172 * @tc.desc:
173 */
174HWTEST_F(AAfWKZcharWrapperTest, ZcharWrapperTest_GetChar_001, TestSize.Level1)
175{
176    zchar value = 0;
177    Char zcharValue(value);
178    std::string str = "";
179    int32_t index = 2;
180    EXPECT_EQ(Char::INVALID_CHAR, zcharValue.GetChar(str, index));
181}
182
183/**
184 * @tc.number: ZcharWrapperTest_GetChar_002
185 * @tc.name: GetChar
186 * @tc.desc:
187 */
188HWTEST_F(AAfWKZcharWrapperTest, ZcharWrapperTest_GetChar_002, TestSize.Level1)
189{
190    zchar value = 0;
191    Char zcharValue(value);
192    std::string str = "string";
193    int32_t index = -1;
194    EXPECT_EQ(Char::INVALID_CHAR, zcharValue.GetChar(str, index));
195}
196
197/**
198 * @tc.number: ZcharWrapperTest_GetChar_003
199 * @tc.name: GetChar
200 * @tc.desc:
201 */
202HWTEST_F(AAfWKZcharWrapperTest, ZcharWrapperTest_GetChar_003, TestSize.Level1)
203{
204    zchar value = 0;
205    Char zcharValue(value);
206    std::string str = "string";
207    int32_t index = 10;
208    EXPECT_EQ(Char::INVALID_CHAR, zcharValue.GetChar(str, index));
209}
210
211/**
212 * @tc.number: ZcharWrapperTest_GetCharInternal_001
213 * @tc.name: GetCharInternal
214 * @tc.desc:
215 */
216HWTEST_F(AAfWKZcharWrapperTest, ZcharWrapperTest_GetCharInternal_001, TestSize.Level1)
217{
218    zchar value = 0;
219    Char zcharValue(value);
220    const char* str = u8"你好";
221    unsigned char* cur = reinterpret_cast<unsigned char*>(const_cast<char*>(str));
222    int32_t size = 0;
223    zcharValue.GetCharInternal(cur, size);
224    EXPECT_EQ(3, size);
225}
226}
227}