1 /*
2 * Copyright (c) 2023 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 #define private public
18 #define protected public
19 #include "metadata/metadata_builder.h"
20 #include "metadata/metadata_dumper.h"
21 #include "metadata/metadata_reader.h"
22 #include "metadata/metadata_serializer.h"
23 #undef private
24 #undef protected
25
26 using namespace testing;
27 using namespace testing::ext;
28 using namespace OHOS::Idl;
29
30 namespace OHOS {
31 namespace idl {
32 class MetadataSerializerUnitTest : public testing::Test {
33 public:
MetadataSerializerUnitTest()34 MetadataSerializerUnitTest() {}
35
~MetadataSerializerUnitTest()36 virtual ~MetadataSerializerUnitTest() {}
37
38 static void SetUpTestCase();
39
40 static void TearDownTestCase();
41
42 void SetUp();
43
44 void TearDown();
45 };
46
SetUpTestCase()47 void MetadataSerializerUnitTest::SetUpTestCase() {}
48
TearDownTestCase()49 void MetadataSerializerUnitTest::TearDownTestCase() {}
50
SetUp()51 void MetadataSerializerUnitTest::SetUp() {}
52
TearDown()53 void MetadataSerializerUnitTest::TearDown() {}
54
55 /*
56 * @tc.name: MetadataSerializerUnitTest_0100
57 * @tc.desc: test SerializeMetaComponent in MetadataSerializerUnitTest.
58 * @tc.type: FUNC
59 * @tc.require: issue
60 */
61 HWTEST_F(MetadataSerializerUnitTest, MetadataSerializerUnitTest_0100, Function | MediumTest | Level1)
62 {
63 std::shared_ptr<MetadataSerializer> metadataSerializer = std::make_shared<MetadataSerializer>(nullptr);
64 ASSERT_NE(nullptr, metadataSerializer);
65
66 metadataSerializer->SerializeMetaComponent(nullptr);
67 }
68
69 /*
70 * @tc.name: MetadataSerializerUnitTest_0200
71 * @tc.desc: test SerializeMetaNamespace in MetadataSerializerUnitTest.
72 * @tc.type: FUNC
73 * @tc.require: issue
74 */
75 HWTEST_F(MetadataSerializerUnitTest, MetadataSerializerUnitTest_0200, Function | MediumTest | Level1)
76 {
77 std::shared_ptr<MetadataSerializer> metadataSerializer = std::make_shared<MetadataSerializer>(nullptr);
78 ASSERT_NE(nullptr, metadataSerializer);
79
80 metadataSerializer->SerializeMetaNamespace(nullptr);
81 }
82
83 /*
84 * @tc.name: MetadataSerializerUnitTest_0300
85 * @tc.desc: test SerializeMetaSequenceable in MetadataSerializerUnitTest.
86 * @tc.type: FUNC
87 * @tc.require: issue
88 */
89 HWTEST_F(MetadataSerializerUnitTest, MetadataSerializerUnitTest_0300, Function | MediumTest | Level1)
90 {
91 std::shared_ptr<MetadataSerializer> metadataSerializer = std::make_shared<MetadataSerializer>(nullptr);
92 ASSERT_NE(nullptr, metadataSerializer);
93
94 metadataSerializer->SerializeMetaSequenceable(nullptr);
95 }
96
97 /*
98 * @tc.name: MetadataSerializerUnitTest_0400
99 * @tc.desc: test SerializeMetaInterface in MetadataSerializerUnitTest.
100 * @tc.type: FUNC
101 * @tc.require: issue
102 */
103 HWTEST_F(MetadataSerializerUnitTest, MetadataSerializerUnitTest_0400, Function | MediumTest | Level1)
104 {
105 std::shared_ptr<MetadataSerializer> metadataSerializer = std::make_shared<MetadataSerializer>(nullptr);
106 ASSERT_NE(nullptr, metadataSerializer);
107
108 metadataSerializer->SerializeMetaInterface(nullptr);
109 }
110
111 /*
112 * @tc.name: MetadataSerializerUnitTest_0500
113 * @tc.desc: test SerializeMetaMethod in MetadataSerializerUnitTest.
114 * @tc.type: FUNC
115 * @tc.require: issue
116 */
117 HWTEST_F(MetadataSerializerUnitTest, MetadataSerializerUnitTest_0500, Function | MediumTest | Level1)
118 {
119 std::shared_ptr<MetadataSerializer> metadataSerializer = std::make_shared<MetadataSerializer>(nullptr);
120 ASSERT_NE(nullptr, metadataSerializer);
121
122 metadataSerializer->SerializeMetaMethod(nullptr);
123 }
124
125 /*
126 * @tc.name: MetadataSerializerUnitTest_0600
127 * @tc.desc: test SerializeMetaParameter in MetadataSerializerUnitTest.
128 * @tc.type: FUNC
129 * @tc.require: issue
130 */
131 HWTEST_F(MetadataSerializerUnitTest, MetadataSerializerUnitTest_0600, Function | MediumTest | Level1)
132 {
133 std::shared_ptr<MetadataSerializer> metadataSerializer = std::make_shared<MetadataSerializer>(nullptr);
134 ASSERT_NE(nullptr, metadataSerializer);
135
136 metadataSerializer->SerializeMetaParameter(nullptr);
137 }
138
139 /*
140 * @tc.name: MetadataSerializerUnitTest_0700
141 * @tc.desc: test SerializeMetaType in MetadataSerializerUnitTest.
142 * @tc.type: FUNC
143 * @tc.require: issue
144 */
145 HWTEST_F(MetadataSerializerUnitTest, MetadataSerializerUnitTest_0700, Function | MediumTest | Level1)
146 {
147 std::shared_ptr<MetadataSerializer> metadataSerializer = std::make_shared<MetadataSerializer>(nullptr);
148 ASSERT_NE(nullptr, metadataSerializer);
149
150 metadataSerializer->SerializeMetaType(nullptr);
151 }
152
153 /*
154 * @tc.name: MetadataSerializerUnitTest_0800
155 * @tc.desc: test Deserialize in MetadataSerializerUnitTest.
156 * @tc.type: FUNC
157 * @tc.require: issue
158 */
159 HWTEST_F(MetadataSerializerUnitTest, MetadataSerializerUnitTest_0800, Function | MediumTest | Level1)
160 {
161 std::shared_ptr<MetadataSerializer> metadataSerializer = std::make_shared<MetadataSerializer>(nullptr);
162 ASSERT_NE(nullptr, metadataSerializer);
163
164 metadataSerializer->Deserialize();
165 }
166
167 /*
168 * @tc.name: MetadataSerializerUnitTest_0900
169 * @tc.desc: test DeserializeMetaComponent in MetadataSerializerUnitTest.
170 * @tc.type: FUNC
171 * @tc.require: issue
172 */
173 HWTEST_F(MetadataSerializerUnitTest, MetadataSerializerUnitTest_0900, Function | MediumTest | Level1)
174 {
175 std::shared_ptr<MetadataSerializer> metadataSerializer = std::make_shared<MetadataSerializer>(nullptr);
176 ASSERT_NE(nullptr, metadataSerializer);
177
178 metadataSerializer->DeserializeMetaComponent(nullptr);
179 }
180
181 /*
182 * @tc.name: MetadataSerializerUnitTest_1000
183 * @tc.desc: test DeserializeMetaNamespace in MetadataSerializerUnitTest.
184 * @tc.type: FUNC
185 * @tc.require: issue
186 */
187 HWTEST_F(MetadataSerializerUnitTest, MetadataSerializerUnitTest_1000, Function | MediumTest | Level1)
188 {
189 std::shared_ptr<MetadataSerializer> metadataSerializer = std::make_shared<MetadataSerializer>(nullptr);
190 ASSERT_NE(nullptr, metadataSerializer);
191
192 metadataSerializer->DeserializeMetaNamespace(nullptr);
193 }
194
195 /*
196 * @tc.name: MetadataSerializerUnitTest_1100
197 * @tc.desc: test DeserializeMetaSequenceable in MetadataSerializerUnitTest.
198 * @tc.type: FUNC
199 * @tc.require: issue
200 */
201 HWTEST_F(MetadataSerializerUnitTest, MetadataSerializerUnitTest_1100, Function | MediumTest | Level1)
202 {
203 std::shared_ptr<MetadataSerializer> metadataSerializer = std::make_shared<MetadataSerializer>(nullptr);
204 ASSERT_NE(nullptr, metadataSerializer);
205
206 metadataSerializer->DeserializeMetaSequenceable(nullptr);
207 }
208
209 /*
210 * @tc.name: MetadataSerializerUnitTest_1200
211 * @tc.desc: test DeserializeMetaInterface in MetadataSerializerUnitTest.
212 * @tc.type: FUNC
213 * @tc.require: issue
214 */
215 HWTEST_F(MetadataSerializerUnitTest, MetadataSerializerUnitTest_1200, Function | MediumTest | Level1)
216 {
217 std::shared_ptr<MetadataSerializer> metadataSerializer = std::make_shared<MetadataSerializer>(nullptr);
218 ASSERT_NE(nullptr, metadataSerializer);
219
220 metadataSerializer->DeserializeMetaInterface(nullptr);
221 }
222
223 /*
224 * @tc.name: MetadataSerializerUnitTest_1300
225 * @tc.desc: test DeserializeMetaMethod in MetadataSerializerUnitTest.
226 * @tc.type: FUNC
227 * @tc.require: issue
228 */
229 HWTEST_F(MetadataSerializerUnitTest, MetadataSerializerUnitTest_1300, Function | MediumTest | Level1)
230 {
231 std::shared_ptr<MetadataSerializer> metadataSerializer = std::make_shared<MetadataSerializer>(nullptr);
232 ASSERT_NE(nullptr, metadataSerializer);
233
234 metadataSerializer->DeserializeMetaMethod(nullptr);
235 }
236
237
238 /*
239 * @tc.name: MetadataSerializerUnitTest_1400
240 * @tc.desc: test DeserializeMetaParameter in MetadataSerializerUnitTest.
241 * @tc.type: FUNC
242 * @tc.require: issue
243 */
244 HWTEST_F(MetadataSerializerUnitTest, MetadataSerializerUnitTest_1400, Function | MediumTest | Level1)
245 {
246 std::shared_ptr<MetadataSerializer> metadataSerializer = std::make_shared<MetadataSerializer>(nullptr);
247 ASSERT_NE(nullptr, metadataSerializer);
248
249 metadataSerializer->DeserializeMetaParameter(nullptr);
250 }
251
252 /*
253 * @tc.name: MetadataSerializerUnitTest_1500
254 * @tc.desc: test DeserializeMetaType in MetadataSerializerUnitTest.
255 * @tc.type: FUNC
256 * @tc.require: issue
257 */
258 HWTEST_F(MetadataSerializerUnitTest, MetadataSerializerUnitTest_1500, Function | MediumTest | Level1)
259 {
260 std::shared_ptr<MetadataSerializer> metadataSerializer = std::make_shared<MetadataSerializer>(nullptr);
261 ASSERT_NE(nullptr, metadataSerializer);
262
263 metadataSerializer->DeserializeMetaType(nullptr);
264 }
265 } // namespace idl
266 } // namespace OHOS
267