1 /*
2  * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved.
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 #include <limits>
16 #include <memory>
17 #include <vector>
18 #include <gtest/gtest.h>
19 
20 #include "base_message.h"
21 #include "example.pb.h"
22 #include "example.pbencoder.h"
23 
24 namespace OHOS {
25 namespace Developtools {
26 namespace Profiler {
27 using namespace testing::ext;
28 
29 constexpr uint32_t SIZE_BUFFER = 1024 * 1024;
30 static uint8_t g_buf[SIZE_BUFFER] = {0};
31 static uint32_t g_writePos = 0;
32 
GetMemory(RandomWriteCtx* ctx, uint32_t size, uint8_t** memory, uint32_t* offset)33 bool GetMemory(RandomWriteCtx* ctx, uint32_t size, uint8_t** memory, uint32_t* offset)
34 {
35     if (g_writePos + size > sizeof(g_buf)) {
36         return false;
37     }
38 
39     *memory = &g_buf[g_writePos];
40     *offset = g_writePos;
41     return true;
42 }
43 
Seek(RandomWriteCtx* ctx, uint32_t offset)44 bool Seek(RandomWriteCtx* ctx, uint32_t offset)
45 {
46     if (offset >= sizeof(g_buf)) {
47         return false;
48     }
49 
50     g_writePos = offset;
51     return true;
52 }
53 
54 static RandomWriteCtx g_writeCtx = {GetMemory, Seek};
55 
56 class BaseMessageUnittest : public ::testing::Test {
57 public:
SetUpTestCase()58     static void SetUpTestCase() {};
TearDownTestCase()59     static void TearDownTestCase() {};
60 
SetUp()61     void SetUp()
62     {
63         g_writePos = 0;
64     }
TearDown()65     void TearDown() {};
66 };
67 
HWTEST_F(BaseMessageUnittest, Size, TestSize.Level1)68 HWTEST_F(BaseMessageUnittest, Size, TestSize.Level1)
69 {
70     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
71     g_writeCtx.seek(&g_writeCtx, 0);
72     msgOpt.set_vint_int32(1);
73     msgOpt.set_vint_int64(1);
74     msgOpt.set_vint_uint32(1);
75     msgOpt.set_vint_uint64(1);
76     msgOpt.set_vint_sint32(1);
77     msgOpt.set_vint_sint64(1);
78     msgOpt.set_vint_bool(true);
79     msgOpt.set_vint_enum(ProtoEncoder::NUM::ONE);
80     ASSERT_EQ(g_writePos, (uint32_t)msgOpt.Size());
81 
82     const std::string str = "this is test.";
83     msgOpt.set_len_string(str);
84     msgOpt.set_len_bytes(str.data(), str.size());
85     ASSERT_EQ(g_writePos, (uint32_t)msgOpt.Size());
86 
87     ProtoEncoder::SubMessage* msgSub = msgOpt.mutable_len_sub();
88     ASSERT_TRUE(msgSub != nullptr);
89     msgSub->set_vint_int32(1);
90     msgSub->set_vint_int64(1);
91     msgSub->set_vint_uint32(1);
92     msgSub->set_vint_uint64(1);
93     // has not backfill the length of subMessage
94     ASSERT_GT(g_writePos, (uint32_t)msgOpt.Size());
95 
96     msgOpt.set_i64_fixed64(1);
97     msgOpt.set_i64_sfixed64(1);
98     msgOpt.set_i64_double(1);
99     ASSERT_EQ(g_writePos, (uint32_t)msgOpt.Size());
100 }
101 
HWTEST_F(BaseMessageUnittest, SetVarintInt32, TestSize.Level1)102 HWTEST_F(BaseMessageUnittest, SetVarintInt32, TestSize.Level1)
103 {
104     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
105     ExampleMessage msgProtobuf;
106 
107     g_writeCtx.seek(&g_writeCtx, 0);
108     msgOpt.set_vint_int32(0);
109     printf("set_vint_int32(0):\n");
110     for (uint32_t i = 0; i < g_writePos; i++) {
111         printf("%02X ", g_buf[i]);
112     }
113     printf("\n");
114     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
115     ASSERT_EQ(msgProtobuf.vint_int32(), 0);
116 
117     // min
118     g_writeCtx.seek(&g_writeCtx, 0);
119     msgOpt.set_vint_int32(std::numeric_limits<int32_t>::min());
120     printf("set_vint_int32(%" PRId32 "):\n", std::numeric_limits<int32_t>::min());
121     for (uint32_t i = 0; i < g_writePos; i++) {
122         printf("%02X ", g_buf[i]);
123     }
124     printf("\n");
125     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
126     ASSERT_EQ(msgProtobuf.vint_int32(), std::numeric_limits<int32_t>::min());
127 
128     // max
129     g_writeCtx.seek(&g_writeCtx, 0);
130     msgOpt.set_vint_int32(std::numeric_limits<int32_t>::max());
131     printf("set_vint_int32(%" PRId32 "):\n", std::numeric_limits<int32_t>::max());
132     for (uint32_t i = 0; i < g_writePos; i++) {
133         printf("%02X ", g_buf[i]);
134     }
135     printf("\n");
136 
137     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
138     ASSERT_EQ(msgProtobuf.vint_int32(), std::numeric_limits<int32_t>::max());
139 }
140 
HWTEST_F(BaseMessageUnittest, SetVarintInt64, TestSize.Level1)141 HWTEST_F(BaseMessageUnittest, SetVarintInt64, TestSize.Level1)
142 {
143     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
144     ExampleMessage msgProtobuf;
145 
146     g_writeCtx.seek(&g_writeCtx, 0);
147     msgOpt.set_vint_int64(0);
148     printf("set_vint_int64(0):\n");
149     for (uint32_t i = 0; i < g_writePos; i++) {
150         printf("%02X ", g_buf[i]);
151     }
152     printf("\n");
153     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
154     ASSERT_EQ(msgProtobuf.vint_int64(), 0);
155 
156     // min
157     g_writeCtx.seek(&g_writeCtx, 0);
158     msgOpt.set_vint_int64(std::numeric_limits<int64_t>::min());
159     printf("set_vint_int64(%" PRId64 "):\n", std::numeric_limits<int64_t>::max());
160     for (uint32_t i = 0; i < g_writePos; i++) {
161         printf("%02X ", g_buf[i]);
162     }
163     printf("\n");
164     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
165     ASSERT_EQ(msgProtobuf.vint_int64(), std::numeric_limits<int64_t>::min());
166 
167     // max
168     g_writeCtx.seek(&g_writeCtx, 0);
169     msgOpt.set_vint_int64(std::numeric_limits<int64_t>::max());
170     printf("set_vint_int64(%" PRId64 "):\n", std::numeric_limits<int64_t>::max());
171     for (uint32_t i = 0; i < g_writePos; i++) {
172         printf("%02X ", g_buf[i]);
173     }
174     printf("\n");
175 
176     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
177     ASSERT_EQ(msgProtobuf.vint_int64(), std::numeric_limits<int64_t>::max());
178 }
179 
HWTEST_F(BaseMessageUnittest, SetVarintUint32, TestSize.Level1)180 HWTEST_F(BaseMessageUnittest, SetVarintUint32, TestSize.Level1)
181 {
182     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
183     ExampleMessage msgProtobuf;
184 
185     g_writeCtx.seek(&g_writeCtx, 0);
186     msgOpt.set_vint_uint32(0);
187     printf("set_vint_uint32(0):\n");
188     for (uint32_t i = 0; i < g_writePos; i++) {
189         printf("%02X ", g_buf[i]);
190     }
191     printf("\n");
192     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
193     ASSERT_EQ(msgProtobuf.vint_uint32(), (uint32_t)0);
194 
195     // min
196     g_writeCtx.seek(&g_writeCtx, 0);
197     msgOpt.set_vint_uint32(std::numeric_limits<uint32_t>::min());
198     printf("set_vint_uint32(%" PRIu32 "):\n", std::numeric_limits<uint32_t>::min());
199     for (uint32_t i = 0; i < g_writePos; i++) {
200         printf("%02X ", g_buf[i]);
201     }
202     printf("\n");
203     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
204     ASSERT_EQ(msgProtobuf.vint_uint32(), std::numeric_limits<uint32_t>::min());
205 
206     // max
207     g_writeCtx.seek(&g_writeCtx, 0);
208     msgOpt.set_vint_uint32(std::numeric_limits<uint32_t>::max());
209     printf("set_vint_uint32(%" PRIu32 "):\n", std::numeric_limits<uint32_t>::max());
210     for (uint32_t i = 0; i < g_writePos; i++) {
211         printf("%02X ", g_buf[i]);
212     }
213     printf("\n");
214 
215     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
216     ASSERT_EQ(msgProtobuf.vint_uint32(), std::numeric_limits<uint32_t>::max());
217 }
218 
HWTEST_F(BaseMessageUnittest, SetVarintUint64, TestSize.Level1)219 HWTEST_F(BaseMessageUnittest, SetVarintUint64, TestSize.Level1)
220 {
221     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
222     ExampleMessage msgProtobuf;
223 
224     g_writeCtx.seek(&g_writeCtx, 0);
225     msgOpt.set_vint_uint64(0);
226     printf("set_vint_uint64(0):\n");
227     for (uint32_t i = 0; i < g_writePos; i++) {
228         printf("%02X ", g_buf[i]);
229     }
230     printf("\n");
231     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
232     ASSERT_EQ(msgProtobuf.vint_uint64(), (uint64_t)0);
233 
234     // min
235     g_writeCtx.seek(&g_writeCtx, 0);
236     msgOpt.set_vint_uint64(std::numeric_limits<uint64_t>::min());
237     printf("set_vint_uint64(%" PRIu64 "):\n", std::numeric_limits<uint64_t>::min());
238     for (uint32_t i = 0; i < g_writePos; i++) {
239         printf("%02X ", g_buf[i]);
240     }
241     printf("\n");
242     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
243     ASSERT_EQ(msgProtobuf.vint_uint64(), std::numeric_limits<uint64_t>::min());
244 
245     // max
246     g_writeCtx.seek(&g_writeCtx, 0);
247     msgOpt.set_vint_uint64(std::numeric_limits<uint64_t>::max());
248     printf("set_vint_uint64(%" PRIu64 "):\n", std::numeric_limits<uint64_t>::max());
249     for (uint32_t i = 0; i < g_writePos; i++) {
250         printf("%02X ", g_buf[i]);
251     }
252     printf("\n");
253 
254     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
255     ASSERT_EQ(msgProtobuf.vint_uint64(), std::numeric_limits<uint64_t>::max());
256 }
257 
HWTEST_F(BaseMessageUnittest, SetVarintSint32, TestSize.Level1)258 HWTEST_F(BaseMessageUnittest, SetVarintSint32, TestSize.Level1)
259 {
260     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
261     ExampleMessage msgProtobuf;
262 
263     g_writeCtx.seek(&g_writeCtx, 0);
264     msgOpt.set_vint_sint32(0);
265     printf("set_vint_sint32(0):\n");
266     for (uint32_t i = 0; i < g_writePos; i++) {
267         printf("%02X ", g_buf[i]);
268     }
269     printf("\n");
270     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
271     ASSERT_EQ(msgProtobuf.vint_sint32(), (int32_t)0);
272 
273     // min
274     g_writeCtx.seek(&g_writeCtx, 0);
275     msgOpt.set_vint_sint32(std::numeric_limits<int32_t>::min());
276     printf("set_vint_sint32(%" PRId32 "):\n", std::numeric_limits<int32_t>::min());
277     for (uint32_t i = 0; i < g_writePos; i++) {
278         printf("%02X ", g_buf[i]);
279     }
280     printf("\n");
281     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
282     ASSERT_EQ(msgProtobuf.vint_sint32(), std::numeric_limits<int32_t>::min());
283 
284     // max
285     g_writeCtx.seek(&g_writeCtx, 0);
286     msgOpt.set_vint_sint32(std::numeric_limits<int32_t>::max());
287     printf("set_vint_sint32(%" PRId32 "):\n", std::numeric_limits<int32_t>::max());
288     for (uint32_t i = 0; i < g_writePos; i++) {
289         printf("%02X ", g_buf[i]);
290     }
291     printf("\n");
292 
293     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
294     ASSERT_EQ(msgProtobuf.vint_sint32(), std::numeric_limits<int32_t>::max());
295 }
296 
HWTEST_F(BaseMessageUnittest, SetVarintSint64, TestSize.Level1)297 HWTEST_F(BaseMessageUnittest, SetVarintSint64, TestSize.Level1)
298 {
299     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
300     ExampleMessage msgProtobuf;
301 
302     g_writeCtx.seek(&g_writeCtx, 0);
303     msgOpt.set_vint_sint64(0);
304     printf("set_vint_sint64(0):\n");
305     for (uint32_t i = 0; i < g_writePos; i++) {
306         printf("%02X ", g_buf[i]);
307     }
308     printf("\n");
309     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
310     ASSERT_EQ(msgProtobuf.vint_sint64(), (int64_t)0);
311 
312     // min
313     g_writeCtx.seek(&g_writeCtx, 0);
314     msgOpt.set_vint_sint64(std::numeric_limits<int64_t>::min());
315     printf("set_vint_sint64(%" PRId64 "):\n", std::numeric_limits<int64_t>::min());
316     for (uint32_t i = 0; i < g_writePos; i++) {
317         printf("%02X ", g_buf[i]);
318     }
319     printf("\n");
320     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
321     ASSERT_EQ(msgProtobuf.vint_sint64(), std::numeric_limits<int64_t>::min());
322 
323     // max
324     g_writeCtx.seek(&g_writeCtx, 0);
325     msgOpt.set_vint_sint64(std::numeric_limits<int64_t>::max());
326     printf("set_vint_sint64(%" PRId64 "):\n", std::numeric_limits<int64_t>::max());
327     for (uint32_t i = 0; i < g_writePos; i++) {
328         printf("%02X ", g_buf[i]);
329     }
330     printf("\n");
331 
332     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
333     ASSERT_EQ(msgProtobuf.vint_sint64(), std::numeric_limits<int64_t>::max());
334 }
335 
HWTEST_F(BaseMessageUnittest, SetVarintBool, TestSize.Level1)336 HWTEST_F(BaseMessageUnittest, SetVarintBool, TestSize.Level1)
337 {
338     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
339     ExampleMessage msgProtobuf;
340 
341     // min
342     g_writeCtx.seek(&g_writeCtx, 0);
343     msgOpt.set_vint_bool(std::numeric_limits<bool>::min());
344     printf("set_vint_bool(%d):\n", std::numeric_limits<bool>::min());
345     for (uint32_t i = 0; i < g_writePos; i++) {
346         printf("%02X ", g_buf[i]);
347     }
348     printf("\n");
349     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
350     ASSERT_EQ(msgProtobuf.vint_bool(), std::numeric_limits<bool>::min());
351 
352     // max
353     g_writeCtx.seek(&g_writeCtx, 0);
354     msgOpt.set_vint_bool(std::numeric_limits<int64_t>::max());
355     printf("set_vint_bool(%d):\n", std::numeric_limits<bool>::max());
356     for (uint32_t i = 0; i < g_writePos; i++) {
357         printf("%02X ", g_buf[i]);
358     }
359     printf("\n");
360 
361     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
362     ASSERT_EQ(msgProtobuf.vint_bool(), std::numeric_limits<bool>::max());
363 }
364 
HWTEST_F(BaseMessageUnittest, SetVarintEnum, TestSize.Level1)365 HWTEST_F(BaseMessageUnittest, SetVarintEnum, TestSize.Level1)
366 {
367     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
368     ExampleMessage msgProtobuf;
369 
370     // min
371     g_writeCtx.seek(&g_writeCtx, 0);
372     msgOpt.set_vint_enum(ProtoEncoder::NUM::ZERO);
373     printf("set_vint_enum(%d):\n", static_cast<int>(ProtoEncoder::NUM::ZERO));
374     for (uint32_t i = 0; i < g_writePos; i++) {
375         printf("%02X ", g_buf[i]);
376     }
377     printf("\n");
378     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
379     ASSERT_EQ(msgProtobuf.vint_enum(), static_cast<int>(ProtoEncoder::NUM::ZERO));
380 
381     // max
382     g_writeCtx.seek(&g_writeCtx, 0);
383     msgOpt.set_vint_enum(ProtoEncoder::NUM::FOUR);
384     printf("set_vint_enum(%d):\n", static_cast<int>(ProtoEncoder::NUM::FOUR));
385     for (uint32_t i = 0; i < g_writePos; i++) {
386         printf("%02X ", g_buf[i]);
387     }
388     printf("\n");
389 
390     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
391     ASSERT_EQ(msgProtobuf.vint_enum(), static_cast<int>(ProtoEncoder::NUM::FOUR));
392 }
393 
HWTEST_F(BaseMessageUnittest, SetFixed64, TestSize.Level1)394 HWTEST_F(BaseMessageUnittest, SetFixed64, TestSize.Level1)
395 {
396     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
397     ExampleMessage msgProtobuf;
398 
399     g_writeCtx.seek(&g_writeCtx, 0);
400     msgOpt.set_i64_fixed64(0);
401     printf("set_i64_fixed64(0):\n");
402     for (uint32_t i = 0; i < g_writePos; i++) {
403         printf("%02X ", g_buf[i]);
404     }
405     printf("\n");
406     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
407     ASSERT_EQ(msgProtobuf.i64_fixed64(), (uint64_t)0);
408 
409     // min
410     g_writeCtx.seek(&g_writeCtx, 0);
411     msgOpt.set_i64_fixed64(std::numeric_limits<uint64_t>::min());
412     printf("set_i64_fixed64(%" PRIu64 "):\n", std::numeric_limits<uint64_t>::min());
413     for (uint32_t i = 0; i < g_writePos; i++) {
414         printf("%02X ", g_buf[i]);
415     }
416     printf("\n");
417     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
418     ASSERT_EQ(msgProtobuf.i64_fixed64(), std::numeric_limits<uint64_t>::min());
419 
420     // max
421     g_writeCtx.seek(&g_writeCtx, 0);
422     msgOpt.set_i64_fixed64(std::numeric_limits<uint64_t>::max());
423     printf("set_i64_fixed64(%" PRIu64 "):\n", std::numeric_limits<uint64_t>::max());
424     for (uint32_t i = 0; i < g_writePos; i++) {
425         printf("%02X ", g_buf[i]);
426     }
427     printf("\n");
428 
429     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
430     ASSERT_EQ(msgProtobuf.i64_fixed64(), std::numeric_limits<uint64_t>::max());
431 }
432 
HWTEST_F(BaseMessageUnittest, SetSfixed64, TestSize.Level1)433 HWTEST_F(BaseMessageUnittest, SetSfixed64, TestSize.Level1)
434 {
435     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
436     ExampleMessage msgProtobuf;
437 
438     g_writeCtx.seek(&g_writeCtx, 0);
439     msgOpt.set_i64_sfixed64(0);
440     printf("set_i64_sfixed64(0):\n");
441     for (uint32_t i = 0; i < g_writePos; i++) {
442         printf("%02X ", g_buf[i]);
443     }
444     printf("\n");
445     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
446     ASSERT_EQ(msgProtobuf.i64_sfixed64(), (int64_t)0);
447 
448     // min
449     g_writeCtx.seek(&g_writeCtx, 0);
450     msgOpt.set_i64_sfixed64(std::numeric_limits<int64_t>::min());
451     printf("set_i64_sfixed64(%" PRId64 "):\n", std::numeric_limits<int64_t>::min());
452     for (uint32_t i = 0; i < g_writePos; i++) {
453         printf("%02X ", g_buf[i]);
454     }
455     printf("\n");
456     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
457     ASSERT_EQ(msgProtobuf.i64_sfixed64(), std::numeric_limits<int64_t>::min());
458 
459     // max
460     g_writeCtx.seek(&g_writeCtx, 0);
461     msgOpt.set_i64_sfixed64(std::numeric_limits<int64_t>::max());
462     printf("set_i64_sfixed64(%" PRId64 "):\n", std::numeric_limits<int64_t>::max());
463     for (uint32_t i = 0; i < g_writePos; i++) {
464         printf("%02X ", g_buf[i]);
465     }
466     printf("\n");
467 
468     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
469     ASSERT_EQ(msgProtobuf.i64_sfixed64(), std::numeric_limits<int64_t>::max());
470 }
471 
HWTEST_F(BaseMessageUnittest, SetDouble, TestSize.Level1)472 HWTEST_F(BaseMessageUnittest, SetDouble, TestSize.Level1)
473 {
474     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
475     ExampleMessage msgProtobuf;
476 
477     g_writeCtx.seek(&g_writeCtx, 0);
478     msgOpt.set_i64_double(0);
479     printf("set_i64_double(0):\n");
480     for (uint32_t i = 0; i < g_writePos; i++) {
481         printf("%02X ", g_buf[i]);
482     }
483     printf("\n");
484     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
485     ASSERT_EQ(msgProtobuf.i64_double(), (double)0);
486 
487     // min
488     g_writeCtx.seek(&g_writeCtx, 0);
489     msgOpt.set_i64_double(std::numeric_limits<double>::min());
490     printf("set_i64_double(%e):\n", std::numeric_limits<double>::min());
491     for (uint32_t i = 0; i < g_writePos; i++) {
492         printf("%02X ", g_buf[i]);
493     }
494     printf("\n");
495     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
496     ASSERT_EQ(msgProtobuf.i64_double(), std::numeric_limits<double>::min());
497 
498     // max
499     g_writeCtx.seek(&g_writeCtx, 0);
500     msgOpt.set_i64_double(std::numeric_limits<double>::max());
501     printf("set_i64_double(%e):\n", std::numeric_limits<double>::max());
502     for (uint32_t i = 0; i < g_writePos; i++) {
503         printf("%02X ", g_buf[i]);
504     }
505     printf("\n");
506 
507     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
508     ASSERT_EQ(msgProtobuf.i64_double(), std::numeric_limits<double>::max());
509 }
510 
HWTEST_F(BaseMessageUnittest, SetFixed32, TestSize.Level1)511 HWTEST_F(BaseMessageUnittest, SetFixed32, TestSize.Level1)
512 {
513     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
514     ExampleMessage msgProtobuf;
515 
516     g_writeCtx.seek(&g_writeCtx, 0);
517     msgOpt.set_i32_fixed32(0);
518     printf("set_i32_fixed32(0):\n");
519     for (uint32_t i = 0; i < g_writePos; i++) {
520         printf("%02X ", g_buf[i]);
521     }
522     printf("\n");
523     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
524     ASSERT_EQ(msgProtobuf.i32_fixed32(), (uint32_t)0);
525 
526     // min
527     g_writeCtx.seek(&g_writeCtx, 0);
528     msgOpt.set_i32_fixed32(std::numeric_limits<uint32_t>::min());
529     printf("set_i32_fixed32(%" PRIu32 "):\n", std::numeric_limits<uint32_t>::min());
530     for (uint32_t i = 0; i < g_writePos; i++) {
531         printf("%02X ", g_buf[i]);
532     }
533     printf("\n");
534     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
535     ASSERT_EQ(msgProtobuf.i32_fixed32(), std::numeric_limits<uint32_t>::min());
536 
537     // max
538     g_writeCtx.seek(&g_writeCtx, 0);
539     msgOpt.set_i32_fixed32(std::numeric_limits<uint32_t>::max());
540     printf("set_i32_fixed32(%" PRIu32 "):\n", std::numeric_limits<uint32_t>::max());
541     for (uint32_t i = 0; i < g_writePos; i++) {
542         printf("%02X ", g_buf[i]);
543     }
544     printf("\n");
545 
546     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
547     ASSERT_EQ(msgProtobuf.i32_fixed32(), std::numeric_limits<uint32_t>::max());
548 }
549 
HWTEST_F(BaseMessageUnittest, SetSfixed32, TestSize.Level1)550 HWTEST_F(BaseMessageUnittest, SetSfixed32, TestSize.Level1)
551 {
552     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
553     ExampleMessage msgProtobuf;
554 
555     g_writeCtx.seek(&g_writeCtx, 0);
556     msgOpt.set_i32_sfixed32(0);
557     printf("set_i32_sfixed32(0):\n");
558     for (uint32_t i = 0; i < g_writePos; i++) {
559         printf("%02X ", g_buf[i]);
560     }
561     printf("\n");
562     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
563     ASSERT_EQ(msgProtobuf.i32_sfixed32(), (int32_t)0);
564 
565     // min
566     g_writeCtx.seek(&g_writeCtx, 0);
567     msgOpt.set_i32_sfixed32(std::numeric_limits<int32_t>::min());
568     printf("set_i32_sfixed32(%" PRId32 "):\n", std::numeric_limits<int32_t>::min());
569     for (uint32_t i = 0; i < g_writePos; i++) {
570         printf("%02X ", g_buf[i]);
571     }
572     printf("\n");
573     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
574     ASSERT_EQ(msgProtobuf.i32_sfixed32(), std::numeric_limits<int32_t>::min());
575 
576     // max
577     g_writeCtx.seek(&g_writeCtx, 0);
578     msgOpt.set_i32_sfixed32(std::numeric_limits<int32_t>::max());
579     printf("set_i32_sfixed32(%" PRId32 "):\n", std::numeric_limits<int32_t>::max());
580     for (uint32_t i = 0; i < g_writePos; i++) {
581         printf("%02X ", g_buf[i]);
582     }
583     printf("\n");
584 
585     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
586     ASSERT_EQ(msgProtobuf.i32_sfixed32(), std::numeric_limits<int32_t>::max());
587 }
588 
HWTEST_F(BaseMessageUnittest, SetFloat, TestSize.Level1)589 HWTEST_F(BaseMessageUnittest, SetFloat, TestSize.Level1)
590 {
591     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
592     ExampleMessage msgProtobuf;
593 
594     g_writeCtx.seek(&g_writeCtx, 0);
595     msgOpt.set_i32_float(0);
596     printf("set_i32_float(0):\n");
597     for (uint32_t i = 0; i < g_writePos; i++) {
598         printf("%02X ", g_buf[i]);
599     }
600     printf("\n");
601     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
602     ASSERT_EQ(msgProtobuf.i32_float(), (float)0);
603 
604     // min
605     g_writeCtx.seek(&g_writeCtx, 0);
606     msgOpt.set_i32_float(std::numeric_limits<float>::min());
607     printf("set_i32_float(%e):\n", std::numeric_limits<float>::min());
608     for (uint32_t i = 0; i < g_writePos; i++) {
609         printf("%02X ", g_buf[i]);
610     }
611     printf("\n");
612     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
613     ASSERT_EQ(msgProtobuf.i32_float(), std::numeric_limits<float>::min());
614 
615     // max
616     g_writeCtx.seek(&g_writeCtx, 0);
617     msgOpt.set_i32_float(std::numeric_limits<float>::max());
618     printf("set_i32_float(%e):\n", std::numeric_limits<float>::max());
619     for (uint32_t i = 0; i < g_writePos; i++) {
620         printf("%02X ", g_buf[i]);
621     }
622     printf("\n");
623 
624     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
625     ASSERT_EQ(msgProtobuf.i32_float(), std::numeric_limits<float>::max());
626 }
627 
HWTEST_F(BaseMessageUnittest, SetString, TestSize.Level1)628 HWTEST_F(BaseMessageUnittest, SetString, TestSize.Level1)
629 {
630     const std::string emptyStr = "";
631     const std::string str = "this is test.";
632     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
633     ExampleMessage msgProtobuf;
634 
635     g_writeCtx.seek(&g_writeCtx, 0);
636     msgOpt.set_len_string(emptyStr);
637     printf("set_len_string(empty string):\n");
638     for (uint32_t i = 0; i < g_writePos; i++) {
639         printf("%02X ", g_buf[i]);
640     }
641     printf("\n");
642     // data of g_buf should is "AA 01 00"
643     const int32_t emptyStrFieldLen = 3;
644     ASSERT_EQ(msgOpt.Size(), emptyStrFieldLen);
645     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
646     ASSERT_EQ(msgProtobuf.len_string(), emptyStr);
647 
648     g_writeCtx.seek(&g_writeCtx, 0);
649     msgOpt.set_len_string(str);
650     printf("set_len_string(string: %s):\n", str.c_str());
651     for (uint32_t i = 0; i < g_writePos; i++) {
652         printf("%02X ", g_buf[i]);
653     }
654     printf("\n");
655     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
656     ASSERT_EQ(msgProtobuf.len_string(), str);
657 
658     g_writeCtx.seek(&g_writeCtx, 0);
659     msgOpt.set_len_string(str.c_str());
660     printf("set_len_string(char*: %s):\n", str.c_str());
661     for (uint32_t i = 0; i < g_writePos; i++) {
662         printf("%02X ", g_buf[i]);
663     }
664     printf("\n");
665 
666     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
667     ASSERT_EQ(msgProtobuf.len_string(), str);
668 }
669 
HWTEST_F(BaseMessageUnittest, SetSubMessage, TestSize.Level1)670 HWTEST_F(BaseMessageUnittest, SetSubMessage, TestSize.Level1)
671 {
672     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
673     ExampleMessage msgProtobuf;
674 
675     // empty
676     g_writeCtx.seek(&g_writeCtx, 0);
677     ProtoEncoder::SubMessage* subMsgOpt = msgOpt.mutable_len_sub();
678     ASSERT_TRUE(subMsgOpt != nullptr);
679     msgOpt.set_vint_int32(std::numeric_limits<int32_t>::min());
680     printf("mutable_len_sub: nothing:\n");
681     for (uint32_t i = 0; i < g_writePos; i++) {
682         printf("%02X ", g_buf[i]);
683     }
684     printf("\n");
685 
686     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
687     ASSERT_TRUE(msgProtobuf.has_len_sub());
688 
689     // min
690     g_writeCtx.seek(&g_writeCtx, 0);
691     subMsgOpt = msgOpt.mutable_len_sub();
692     ASSERT_TRUE(subMsgOpt != nullptr);
693     subMsgOpt->set_vint_int32(std::numeric_limits<int32_t>::min());
694     subMsgOpt->set_vint_int64(std::numeric_limits<int64_t>::min());
695     subMsgOpt->set_vint_uint32(std::numeric_limits<uint32_t>::min());
696     subMsgOpt->set_vint_uint64(std::numeric_limits<uint64_t>::min());
697 
698     msgOpt.set_vint_int32(std::numeric_limits<int32_t>::min());
699     printf("mutable_len_sub: min:\n");
700     for (uint32_t i = 0; i < g_writePos; i++) {
701         printf("%02X ", g_buf[i]);
702     }
703     printf("\n");
704 
705     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
706     ASSERT_TRUE(msgProtobuf.has_len_sub());
707     SubMessage subMsgProtobuf = msgProtobuf.len_sub();
708     ASSERT_EQ(subMsgProtobuf.vint_int32(), std::numeric_limits<int32_t>::min());
709     ASSERT_EQ(subMsgProtobuf.vint_int64(), std::numeric_limits<int64_t>::min());
710     ASSERT_EQ(subMsgProtobuf.vint_uint32(), std::numeric_limits<uint32_t>::min());
711     ASSERT_EQ(subMsgProtobuf.vint_uint64(), std::numeric_limits<uint64_t>::min());
712 
713     // max
714     g_writeCtx.seek(&g_writeCtx, 0);
715     subMsgOpt = msgOpt.mutable_len_sub();
716     ASSERT_TRUE(subMsgOpt != nullptr);
717     subMsgOpt->set_vint_int32(std::numeric_limits<int32_t>::max());
718     subMsgOpt->set_vint_int64(std::numeric_limits<int64_t>::max());
719     subMsgOpt->set_vint_uint32(std::numeric_limits<uint32_t>::max());
720     subMsgOpt->set_vint_uint64(std::numeric_limits<uint64_t>::max());
721 
722     msgOpt.set_vint_int32(std::numeric_limits<int32_t>::min());
723     printf("mutable_len_sub: max:\n");
724     for (uint32_t i = 0; i < g_writePos; i++) {
725         printf("%02X ", g_buf[i]);
726     }
727     printf("\n");
728 
729     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
730     ASSERT_TRUE(msgProtobuf.has_len_sub());
731     subMsgProtobuf = msgProtobuf.len_sub();
732     ASSERT_EQ(subMsgProtobuf.vint_int32(), std::numeric_limits<int32_t>::max());
733     ASSERT_EQ(subMsgProtobuf.vint_int64(), std::numeric_limits<int64_t>::max());
734     ASSERT_EQ(subMsgProtobuf.vint_uint32(), std::numeric_limits<uint32_t>::max());
735     ASSERT_EQ(subMsgProtobuf.vint_uint64(), std::numeric_limits<uint64_t>::max());
736 }
737 
HWTEST_F(BaseMessageUnittest, SetOneOf, TestSize.Level1)738 HWTEST_F(BaseMessageUnittest, SetOneOf, TestSize.Level1)
739 {
740     const std::string str = "this is test.";
741     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
742     ExampleMessage msgProtobuf;
743 
744     // oneof_fixed64
745     g_writeCtx.seek(&g_writeCtx, 0);
746     msgOpt.set_oneof_fixed64(std::numeric_limits<uint64_t>::max());
747     printf("set_oneof_fixed64(%" PRIu64"):\n", std::numeric_limits<uint64_t>::max());
748     for (uint32_t i = 0; i < g_writePos; i++) {
749         printf("%02X ", g_buf[i]);
750     }
751     printf("\n");
752 
753     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
754     ASSERT_EQ(msgProtobuf.oneof_fixed64(), std::numeric_limits<uint64_t>::max());
755 
756     // oneof_sub
757     ProtoEncoder::SubMessage* subMsgOpt = msgOpt.mutable_oneof_sub();
758     ASSERT_TRUE(subMsgOpt != nullptr);
759     subMsgOpt->set_vint_int32(std::numeric_limits<int32_t>::max());
760     subMsgOpt->set_vint_int64(std::numeric_limits<int64_t>::max());
761     subMsgOpt->set_vint_uint32(std::numeric_limits<uint32_t>::max());
762     subMsgOpt->set_vint_uint64(std::numeric_limits<uint64_t>::max());
763     msgOpt.set_i32_fixed32(0);
764     printf("mutable_oneof_sub: max:\n");
765     for (uint32_t i = 0; i < g_writePos; i++) {
766         printf("%02X ", g_buf[i]);
767     }
768     printf("\n");
769 
770     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
771     ASSERT_TRUE(msgProtobuf.has_oneof_sub());
772     SubMessage subMsgProtobuf = msgProtobuf.oneof_sub();
773     ASSERT_EQ(subMsgProtobuf.vint_int32(), std::numeric_limits<int32_t>::max());
774     ASSERT_EQ(subMsgProtobuf.vint_int64(), std::numeric_limits<int64_t>::max());
775     ASSERT_EQ(subMsgProtobuf.vint_uint32(), std::numeric_limits<uint32_t>::max());
776     ASSERT_EQ(subMsgProtobuf.vint_uint64(), std::numeric_limits<uint64_t>::max());
777 
778     // oneof_string
779     msgOpt.set_oneof_string(str);
780     printf("set_oneof_string(%s):\n", str.c_str());
781     for (uint32_t i = 0; i < g_writePos; i++) {
782         printf("%02X ", g_buf[i]);
783     }
784     printf("\n");
785 
786     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
787     ASSERT_EQ(msgProtobuf.oneof_string(), str);
788 
789     // last one wins
790     ASSERT_NE(msgProtobuf.oneof_fixed64(), std::numeric_limits<uint64_t>::max());
791     ASSERT_FALSE(msgProtobuf.has_oneof_sub());
792 }
793 
HWTEST_F(BaseMessageUnittest, SetRepeatedPackedVarintSigned, TestSize.Level1)794 HWTEST_F(BaseMessageUnittest, SetRepeatedPackedVarintSigned, TestSize.Level1)
795 {
796     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
797     ExampleMessage msgProtobuf;
798     const int32_t array[] = {0, 1,
799                             std::numeric_limits<int32_t>::min(),
800                             std::numeric_limits<int32_t>::max()};
801     std::vector<int32_t> vec;
802     vec.emplace_back(0);
803     vec.emplace_back(1);
804     vec.emplace_back(std::numeric_limits<int32_t>::min());
805     vec.emplace_back(std::numeric_limits<int32_t>::max());
806 
807     // vector
808     g_writeCtx.seek(&g_writeCtx, 0);
809     msgOpt.add_len_repeated_packed_signed_vint(vec);
810     printf("add_len_repeated_packed_signed_vint(vector):\n");
811     for (uint32_t i = 0; i < g_writePos; i++) {
812         printf("%02X ", g_buf[i]);
813     }
814     printf("\n");
815 
816     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
817     int count = msgProtobuf.len_repeated_packed_signed_vint_size();
818     ASSERT_EQ(count, static_cast<int>(vec.size()));
819     for (int i = 0; i < count; i++) {
820         ASSERT_EQ(msgProtobuf.len_repeated_packed_signed_vint(i), vec[i]);
821     }
822 
823     // array
824     msgOpt.add_len_repeated_packed_signed_vint(array, sizeof(array) / sizeof(array[0]));
825     printf("add_len_repeated_packed_signed_vint(array):\n");
826     for (uint32_t i = 0; i < g_writePos; i++) {
827         printf("%02X ", g_buf[i]);
828     }
829     printf("\n");
830 
831     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
832     int countAll = msgProtobuf.len_repeated_packed_signed_vint_size();
833     ASSERT_EQ(countAll, static_cast<int>(vec.size() + sizeof(array) / sizeof(array[0])));
834     for (int i = 0; i < count; i++) {
835         ASSERT_EQ(msgProtobuf.len_repeated_packed_signed_vint(i), vec[i]);
836     }
837     for (int i = count; i < countAll; i++) {
838         ASSERT_EQ(msgProtobuf.len_repeated_packed_signed_vint(i), array[i - count]);
839     }
840 }
841 
HWTEST_F(BaseMessageUnittest, SetRepeatedPackedVarintUnsigned, TestSize.Level1)842 HWTEST_F(BaseMessageUnittest, SetRepeatedPackedVarintUnsigned, TestSize.Level1)
843 {
844     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
845     ExampleMessage msgProtobuf;
846     const uint32_t array[] = {0, 1,
847                             std::numeric_limits<uint32_t>::min(),
848                             std::numeric_limits<uint32_t>::max()};
849     std::vector<uint32_t> vec;
850     vec.emplace_back(0);
851     vec.emplace_back(1);
852     vec.emplace_back(std::numeric_limits<uint32_t>::min());
853     vec.emplace_back(std::numeric_limits<uint32_t>::max());
854 
855     // vector
856     g_writeCtx.seek(&g_writeCtx, 0);
857     msgOpt.add_len_repeated_packed_unsigned_vint(vec);
858     printf("add_len_repeated_packed_unsigned_vint(vec):\n");
859     for (uint32_t i = 0; i < g_writePos; i++) {
860         printf("%02X ", g_buf[i]);
861     }
862     printf("\n");
863 
864     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
865     int count = msgProtobuf.len_repeated_packed_unsigned_vint_size();
866     ASSERT_EQ(count, static_cast<int>(vec.size()));
867     for (int i = 0; i < count; i++) {
868         ASSERT_EQ(msgProtobuf.len_repeated_packed_unsigned_vint(i), vec[i]);
869     }
870 
871     // array
872     msgOpt.add_len_repeated_packed_unsigned_vint(array, sizeof(array) / sizeof(array[0]));
873     printf("add_len_repeated_packed_unsigned_vint(array):\n");
874     for (uint32_t i = 0; i < g_writePos; i++) {
875         printf("%02X ", g_buf[i]);
876     }
877     printf("\n");
878 
879     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
880     int countAll = msgProtobuf.len_repeated_packed_unsigned_vint_size();
881     ASSERT_EQ(countAll, static_cast<int>(vec.size() + sizeof(array) / sizeof(array[0])));
882     for (int i = 0; i < count; i++) {
883         ASSERT_EQ(msgProtobuf.len_repeated_packed_unsigned_vint(i), vec[i]);
884     }
885     for (int i = count; i < countAll; i++) {
886         ASSERT_EQ(msgProtobuf.len_repeated_packed_unsigned_vint(i), array[i - count]);
887     }
888 }
889 
HWTEST_F(BaseMessageUnittest, SetRepeatedPackedFixed64, TestSize.Level1)890 HWTEST_F(BaseMessageUnittest, SetRepeatedPackedFixed64, TestSize.Level1)
891 {
892     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
893     ExampleMessage msgProtobuf;
894     const uint64_t array[] = {0, 1,
895                             std::numeric_limits<uint64_t>::min(),
896                             std::numeric_limits<uint64_t>::max()};
897     std::vector<uint64_t> vec;
898     vec.emplace_back(0);
899     vec.emplace_back(1);
900     vec.emplace_back(std::numeric_limits<uint64_t>::min());
901     vec.emplace_back(std::numeric_limits<uint64_t>::max());
902 
903     // vector
904     g_writeCtx.seek(&g_writeCtx, 0);
905     msgOpt.add_len_repeated_packed_fixed(vec);
906     printf("add_len_repeated_packed_fixed(vec):\n");
907     for (uint32_t i = 0; i < g_writePos; i++) {
908         printf("%02X ", g_buf[i]);
909     }
910     printf("\n");
911 
912     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
913     int count = msgProtobuf.len_repeated_packed_fixed_size();
914     ASSERT_EQ(count, static_cast<int>(vec.size()));
915     for (int i = 0; i < count; i++) {
916         ASSERT_EQ(msgProtobuf.len_repeated_packed_fixed(i), vec[i]);
917     }
918 
919     // array
920     msgOpt.add_len_repeated_packed_fixed(array, sizeof(array) / sizeof(array[0]));
921     printf("add_len_repeated_packed_fixed(array):\n");
922     for (uint32_t i = 0; i < g_writePos; i++) {
923         printf("%02X ", g_buf[i]);
924     }
925     printf("\n");
926 
927     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
928     int countAll = msgProtobuf.len_repeated_packed_fixed_size();
929     ASSERT_EQ(countAll, static_cast<int>(vec.size() + sizeof(array) / sizeof(array[0])));
930     for (int i = 0; i < count; i++) {
931         ASSERT_EQ(msgProtobuf.len_repeated_packed_fixed(i), vec[i]);
932     }
933     for (int i = count; i < countAll; i++) {
934         ASSERT_EQ(msgProtobuf.len_repeated_packed_fixed(i), array[i - count]);
935     }
936 }
937 
938 static const char BYTES_DATA[] = {0x00, 0x01, 0x02, 0xFD, 0xFE, 0xFF};
939 
HWTEST_F(BaseMessageUnittest, SetBytes, TestSize.Level1)940 HWTEST_F(BaseMessageUnittest, SetBytes, TestSize.Level1)
941 {
942     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
943     ExampleMessage msgProtobuf;
944 
945     g_writeCtx.seek(&g_writeCtx, 0);
946     msgOpt.set_len_bytes(BYTES_DATA, sizeof(BYTES_DATA));
947     printf("set_len_bytes(void*, size_t):\n");
948     for (uint32_t i = 0; i < g_writePos; i++) {
949         printf("%02X ", g_buf[i]);
950     }
951     printf("\n");
952 
953     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
954     ASSERT_EQ(msgProtobuf.len_bytes(), std::string(&BYTES_DATA[0], sizeof(BYTES_DATA)));
955 }
956 
HWTEST_F(BaseMessageUnittest, SetBytesCallback, TestSize.Level1)957 HWTEST_F(BaseMessageUnittest, SetBytesCallback, TestSize.Level1)
958 {
959     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
960     ExampleMessage msgProtobuf;
961 
962     // bytes stram
963     g_writeCtx.seek(&g_writeCtx, 0);
964     msgOpt.set_len_bytes(
965         [](RandomWriteCtx* ctx) -> int32_t {
966             uint8_t* memory = nullptr;
967             uint32_t offset = 0;
968             if (ctx->getMemory(ctx, sizeof(BYTES_DATA), &memory, &offset)) {
969                 if (memcpy_s(memory, sizeof(BYTES_DATA), BYTES_DATA, sizeof(BYTES_DATA)) == EOK) {
970                     ctx->seek(ctx, offset + sizeof(BYTES_DATA));
971                     return sizeof(BYTES_DATA);
972                 }
973             }
974             return 0;
975         });
976     printf("set_len_bytes(CallbackFunc(bytes)):\n");
977     for (uint32_t i = 0; i < g_writePos; i++) {
978         printf("%02X ", g_buf[i]);
979     }
980     printf("\n");
981 
982     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
983     ASSERT_EQ(msgProtobuf.len_bytes(), std::string(&BYTES_DATA[0], sizeof(BYTES_DATA)));
984 
985     // protobufOpt message
986     g_writeCtx.seek(&g_writeCtx, 0);
987     msgOpt.set_len_bytes(
988         [](RandomWriteCtx* ctx) -> int32_t {
989             ProtoEncoder::SubMessage subMsg(ctx);
990             subMsg.set_vint_int32(std::numeric_limits<int32_t>::max());
991             subMsg.set_vint_int64(std::numeric_limits<int64_t>::max());
992             subMsg.set_vint_uint32(std::numeric_limits<uint32_t>::max());
993             subMsg.set_vint_uint64(std::numeric_limits<uint64_t>::max());
994             return subMsg.Finish();
995         });
996     printf("set_len_bytes(CallbackFunc(message)):\n");
997     for (uint32_t i = 0; i < g_writePos; i++) {
998         printf("%02X ", g_buf[i]);
999     }
1000     printf("\n");
1001 
1002     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
1003     auto& bytes = msgProtobuf.len_bytes();
1004     SubMessage subMsgProtobuf;
1005     ASSERT_TRUE(subMsgProtobuf.ParseFromArray(bytes.data(), bytes.size()));
1006     ASSERT_EQ(subMsgProtobuf.vint_int32(), std::numeric_limits<int32_t>::max());
1007     ASSERT_EQ(subMsgProtobuf.vint_int64(), std::numeric_limits<int64_t>::max());
1008     ASSERT_EQ(subMsgProtobuf.vint_uint32(), std::numeric_limits<uint32_t>::max());
1009     ASSERT_EQ(subMsgProtobuf.vint_uint64(), std::numeric_limits<uint64_t>::max());
1010 }
1011 
HWTEST_F(BaseMessageUnittest, AddBytes, TestSize.Level1)1012 HWTEST_F(BaseMessageUnittest, AddBytes, TestSize.Level1)
1013 {
1014     const char data[] = {0x00, 0x01, 0x02, 0xFD, 0xFE, 0xFF};
1015     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
1016     ExampleMessage msgProtobuf;
1017 
1018     // bytes stram
1019     g_writeCtx.seek(&g_writeCtx, 0);
1020     RandomWriteCtx* writeCtx = msgOpt.startAdd_len_bytes();
1021     uint8_t* memory = nullptr;
1022     uint32_t offset = 0;
1023     if (writeCtx->getMemory(writeCtx, sizeof(data), &memory, &offset)) {
1024         if (memcpy_s(memory, sizeof(data), data, sizeof(data)) != EOK) {
1025             writeCtx->seek(writeCtx, offset + sizeof(data));
1026         }
1027     }
1028     msgOpt.finishAdd_len_bytes(sizeof(data));
1029     printf("Add_LEN_bytes(Customize(bytes)):\n");
1030     for (uint32_t i = 0; i < g_writePos; i++) {
1031         printf("%02X ", g_buf[i]);
1032     }
1033     printf("\n");
1034 
1035     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
1036     ASSERT_EQ(msgProtobuf.len_bytes(), std::string(&data[0], sizeof(data)));
1037 
1038     // protobufOpt message
1039     g_writeCtx.seek(&g_writeCtx, 0);
1040     writeCtx = msgOpt.startAdd_len_bytes();
1041     ProtoEncoder::SubMessage subMsg(writeCtx);
1042     subMsg.set_vint_int32(std::numeric_limits<int32_t>::max());
1043     subMsg.set_vint_int64(std::numeric_limits<int64_t>::max());
1044     subMsg.set_vint_uint32(std::numeric_limits<uint32_t>::max());
1045     subMsg.set_vint_uint64(std::numeric_limits<uint64_t>::max());
1046     msgOpt.finishAdd_len_bytes(subMsg.Finish());
1047     printf("Add_LEN_bytes(Customize(message)):\n");
1048     for (uint32_t i = 0; i < g_writePos; i++) {
1049         printf("%02X ", g_buf[i]);
1050     }
1051     printf("\n");
1052 
1053     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
1054     auto& bytes = msgProtobuf.len_bytes();
1055     SubMessage subMsgProtobuf;
1056     ASSERT_TRUE(subMsgProtobuf.ParseFromArray(bytes.data(), bytes.size()));
1057     ASSERT_EQ(subMsgProtobuf.vint_int32(), std::numeric_limits<int32_t>::max());
1058     ASSERT_EQ(subMsgProtobuf.vint_int64(), std::numeric_limits<int64_t>::max());
1059     ASSERT_EQ(subMsgProtobuf.vint_uint32(), std::numeric_limits<uint32_t>::max());
1060     ASSERT_EQ(subMsgProtobuf.vint_uint64(), std::numeric_limits<uint64_t>::max());
1061 }
1062 
HWTEST_F(BaseMessageUnittest, SetAll, TestSize.Level1)1063 HWTEST_F(BaseMessageUnittest, SetAll, TestSize.Level1)
1064 {
1065     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
1066     ExampleMessage msgProtobuf;
1067 
1068     g_writeCtx.seek(&g_writeCtx, 0);
1069     msgOpt.set_vint_int32(1);
1070     msgOpt.set_vint_int64(1);
1071     msgOpt.set_vint_uint32(1);
1072     msgOpt.set_vint_uint64(1);
1073     msgOpt.set_vint_sint32(1);
1074     msgOpt.set_vint_sint64(1);
1075     msgOpt.set_vint_bool(true);
1076     msgOpt.set_vint_enum(ProtoEncoder::NUM::ONE);
1077     msgOpt.set_i64_fixed64(1);
1078     msgOpt.set_i64_sfixed64(1);
1079     msgOpt.set_i64_double(1);
1080 
1081     const std::string str = "this is test.";
1082     msgOpt.set_len_string(str);
1083     msgOpt.set_len_bytes(BYTES_DATA, sizeof(BYTES_DATA));
1084 
1085     ProtoEncoder::SubMessage* msgSub = msgOpt.mutable_len_sub();
1086     ASSERT_TRUE(msgSub != nullptr);
1087     msgSub->set_vint_int32(1);
1088     msgSub->set_vint_int64(1);
1089     msgSub->set_vint_uint32(1);
1090     msgSub->set_vint_uint64(1);
1091 
1092     const int32_t arraySigned[] = {0, 1,
1093                             std::numeric_limits<int32_t>::min(),
1094                             std::numeric_limits<int32_t>::max()};
1095     std::vector<int32_t> vecSigned;
1096     vecSigned.emplace_back(0);
1097     vecSigned.emplace_back(1);
1098     vecSigned.emplace_back(std::numeric_limits<int32_t>::min());
1099     vecSigned.emplace_back(std::numeric_limits<int32_t>::max());
1100     msgOpt.add_len_repeated_packed_signed_vint(vecSigned);
1101     msgOpt.add_len_repeated_packed_signed_vint(arraySigned, sizeof(arraySigned) / sizeof(arraySigned[0]));
1102 
1103     const uint32_t arrayUnsigned[] = {0, 1,
1104                             std::numeric_limits<uint32_t>::min(),
1105                             std::numeric_limits<uint32_t>::max()};
1106     std::vector<uint32_t> vecUnsigned;
1107     vecUnsigned.emplace_back(0);
1108     vecUnsigned.emplace_back(1);
1109     vecUnsigned.emplace_back(std::numeric_limits<uint32_t>::min());
1110     vecUnsigned.emplace_back(std::numeric_limits<uint32_t>::max());
1111     msgOpt.add_len_repeated_packed_unsigned_vint(vecUnsigned);
1112     msgOpt.add_len_repeated_packed_unsigned_vint(arrayUnsigned, sizeof(arrayUnsigned) / sizeof(arrayUnsigned[0]));
1113 
1114     const uint64_t arrayFixed[] = {0, 1,
1115                             std::numeric_limits<uint64_t>::min(),
1116                             std::numeric_limits<uint64_t>::max()};
1117     std::vector<uint64_t> vecFixed;
1118     vecFixed.emplace_back(0);
1119     vecFixed.emplace_back(1);
1120     vecFixed.emplace_back(std::numeric_limits<uint64_t>::min());
1121     vecFixed.emplace_back(std::numeric_limits<uint64_t>::max());
1122     msgOpt.add_len_repeated_packed_fixed(vecFixed);
1123     msgOpt.add_len_repeated_packed_fixed(arrayFixed, sizeof(arrayFixed) / sizeof(arrayFixed[0]));
1124 
1125     msgOpt.set_i32_fixed32(1);
1126     msgOpt.set_i32_sfixed32(1);
1127     msgOpt.set_i32_float(1);
1128 
1129     msgOpt.set_oneof_fixed64(1);
1130     msgOpt.set_oneof_string(str);
1131     msgSub = msgOpt.mutable_oneof_sub();
1132     ASSERT_TRUE(msgSub != nullptr);
1133     msgSub->set_vint_int32(1);
1134     msgSub->set_vint_int64(1);
1135     msgSub->set_vint_uint32(1);
1136     msgSub->set_vint_uint64(1);
1137 
1138     ASSERT_EQ((uint32_t)msgOpt.Finish(), g_writePos);
1139     printf("SetAll size(%" PRIu32 "):\n", g_writePos);
1140     for (uint32_t i = 0; i < g_writePos; i++) {
1141         printf("%02X ", g_buf[i]);
1142     }
1143     printf("\n");
1144 
1145     // check result by protobuf
1146     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
1147 
1148     ASSERT_EQ(msgProtobuf.vint_int32(), (int32_t)1);
1149     ASSERT_EQ(msgProtobuf.vint_int64(), (int64_t)1);
1150     ASSERT_EQ(msgProtobuf.vint_uint32(), (uint32_t)1);
1151     ASSERT_EQ(msgProtobuf.vint_uint64(), (uint64_t)1);
1152     ASSERT_EQ(msgProtobuf.vint_sint32(), (int32_t)1);
1153     ASSERT_EQ(msgProtobuf.vint_sint64(), (int64_t)1);
1154     ASSERT_EQ(msgProtobuf.vint_sint32(), (int32_t)1);
1155     ASSERT_TRUE(msgProtobuf.vint_bool());
1156     ASSERT_EQ(msgProtobuf.vint_enum(), NUM::ONE);
1157 
1158     ASSERT_EQ(msgProtobuf.i64_fixed64(), (uint64_t)1);
1159     ASSERT_EQ(msgProtobuf.i64_sfixed64(), (int64_t)1);
1160     ASSERT_EQ(msgProtobuf.i64_double(), (double)1);
1161 
1162     ASSERT_EQ(msgProtobuf.len_string(), str);
1163     ASSERT_EQ(msgProtobuf.len_bytes(), std::string(&BYTES_DATA[0], sizeof(BYTES_DATA)));
1164 
1165     ASSERT_TRUE(msgProtobuf.has_len_sub());
1166     SubMessage subMsgProtobuf = msgProtobuf.len_sub();
1167     ASSERT_EQ(subMsgProtobuf.vint_int32(), (int32_t)1);
1168     ASSERT_EQ(subMsgProtobuf.vint_int64(), (int64_t)1);
1169     ASSERT_EQ(subMsgProtobuf.vint_uint32(), (uint32_t)1);
1170     ASSERT_EQ(subMsgProtobuf.vint_uint64(), (uint64_t)1);
1171 
1172     int countAll = msgProtobuf.len_repeated_packed_signed_vint_size();
1173     ASSERT_EQ(countAll, static_cast<int>(vecSigned.size() + sizeof(arraySigned) / sizeof(arraySigned[0])));
1174     for (size_t i = 0; i < vecSigned.size(); i++) {
1175         ASSERT_EQ(msgProtobuf.len_repeated_packed_signed_vint(i), vecSigned[i]);
1176     }
1177     for (size_t i = vecSigned.size(); i < static_cast<size_t>(countAll); i++) {
1178         ASSERT_EQ(msgProtobuf.len_repeated_packed_signed_vint(i), arraySigned[i - vecSigned.size()]);
1179     }
1180 
1181     countAll = msgProtobuf.len_repeated_packed_unsigned_vint_size();
1182     ASSERT_EQ(countAll, static_cast<int>(vecUnsigned.size() + sizeof(arrayUnsigned) / sizeof(arrayUnsigned[0])));
1183     for (size_t i = 0; i < vecUnsigned.size(); i++) {
1184         ASSERT_EQ(msgProtobuf.len_repeated_packed_unsigned_vint(i), vecUnsigned[i]);
1185     }
1186     for (size_t i = vecUnsigned.size(); i < static_cast<size_t>(countAll); i++) {
1187         ASSERT_EQ(msgProtobuf.len_repeated_packed_unsigned_vint(i), arrayUnsigned[i - vecUnsigned.size()]);
1188     }
1189 
1190     countAll = msgProtobuf.len_repeated_packed_fixed_size();
1191     ASSERT_EQ(countAll, static_cast<int>(vecFixed.size() + sizeof(arrayFixed) / sizeof(arrayFixed[0])));
1192     for (size_t i = 0; i < vecFixed.size(); i++) {
1193         ASSERT_EQ(msgProtobuf.len_repeated_packed_fixed(i), vecFixed[i]);
1194     }
1195     for (size_t i = vecFixed.size(); i < static_cast<size_t>(countAll); i++) {
1196         ASSERT_EQ(msgProtobuf.len_repeated_packed_fixed(i), arrayFixed[i - vecFixed.size()]);
1197     }
1198 
1199     ASSERT_EQ(msgProtobuf.i32_fixed32(), (uint32_t)1);
1200     ASSERT_EQ(msgProtobuf.i32_sfixed32(), (int32_t)1);
1201     ASSERT_EQ(msgProtobuf.i32_float(), (float)1);
1202 
1203     // last one wins
1204     ASSERT_NE(msgProtobuf.oneof_fixed64(), (uint64_t)1);
1205     ASSERT_NE(msgProtobuf.oneof_string(), str);
1206     ASSERT_TRUE(msgProtobuf.has_oneof_sub());
1207     subMsgProtobuf = msgProtobuf.oneof_sub();
1208     ASSERT_EQ(subMsgProtobuf.vint_int32(), (int32_t)1);
1209     ASSERT_EQ(subMsgProtobuf.vint_int64(), (int64_t)1);
1210     ASSERT_EQ(subMsgProtobuf.vint_uint32(), (uint32_t)1);
1211     ASSERT_EQ(subMsgProtobuf.vint_uint64(), (uint64_t)1);
1212 }
1213 
HWTEST_F(BaseMessageUnittest, SubMessageLen0, TestSize.Level1)1214 HWTEST_F(BaseMessageUnittest, SubMessageLen0, TestSize.Level1)
1215 {
1216     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
1217     ExampleMessage msgProtobuf;
1218 
1219     // empty
1220     g_writeCtx.seek(&g_writeCtx, 0);
1221     ProtoEncoder::SubMessage* subMsgOpt = msgOpt.mutable_len_sub();
1222     ASSERT_TRUE(subMsgOpt != nullptr);
1223     msgOpt.set_vint_int32(std::numeric_limits<int32_t>::min());
1224     printf("sub message length is 0:\n");
1225     for (uint32_t i = 0; i < g_writePos; i++) {
1226         printf("%02X ", g_buf[i]);
1227     }
1228     printf("\n");
1229 
1230     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
1231     ASSERT_TRUE(msgProtobuf.has_len_sub());
1232 
1233     g_writeCtx.seek(&g_writeCtx, 0);
1234     int subMsgOptRepeatedCount = 0;
1235     ProtoEncoder::SubMessage* subMsgOptRepeated = msgOpt.add_repeated_len_sub();
1236     ASSERT_TRUE(subMsgOptRepeated != nullptr);
1237     subMsgOptRepeatedCount++;
1238     msgOpt.set_vint_int32(std::numeric_limits<int32_t>::min());
1239     printf("repeated sub message length is 0:\n");
1240     for (uint32_t i = 0; i < g_writePos; i++) {
1241         printf("%02X ", g_buf[i]);
1242     }
1243     printf("\n");
1244 
1245     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
1246     ASSERT_EQ(msgProtobuf.repeated_len_sub_size(), subMsgOptRepeatedCount);
1247 
1248     subMsgOptRepeated = msgOpt.add_repeated_len_sub();
1249     ASSERT_TRUE(subMsgOptRepeated != nullptr);
1250     subMsgOptRepeatedCount++;
1251     subMsgOptRepeated->set_vint_int32(1);
1252     msgOpt.set_vint_int32(std::numeric_limits<int32_t>::min());
1253     printf("repeated sub message length > 0:\n");
1254     for (uint32_t i = 0; i < g_writePos; i++) {
1255         printf("%02X ", g_buf[i]);
1256     }
1257     printf("\n");
1258 
1259     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
1260     ASSERT_EQ(msgProtobuf.repeated_len_sub_size(), subMsgOptRepeatedCount);
1261 
1262     // set bytes by callback
1263     g_writeCtx.seek(&g_writeCtx, 0);
1264     msgOpt.set_len_bytes(
1265         [](RandomWriteCtx* randomWriteCtx) -> int32_t {
1266         return 0;
1267         });
1268     printf("set_len_bytes(CallbackFunc(len = 0)):\n");
1269     for (uint32_t i = 0; i < g_writePos; i++) {
1270         printf("%02X ", g_buf[i]);
1271     }
1272     printf("\n");
1273 
1274     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
1275     ASSERT_EQ(msgProtobuf.len_bytes(), std::string(""));
1276 
1277     // add bytes
1278     g_writeCtx.seek(&g_writeCtx, 0);
1279     msgOpt.startAdd_len_bytes();
1280     msgOpt.finishAdd_len_bytes(0);
1281     printf("Add_LEN_bytes(len = 0):\n");
1282     for (uint32_t i = 0; i < g_writePos; i++) {
1283         printf("%02X ", g_buf[i]);
1284     }
1285     printf("\n");
1286 
1287     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
1288     ASSERT_EQ(msgProtobuf.len_bytes(), std::string(""));
1289 }
1290 
HWTEST_F(BaseMessageUnittest, AutoFinishSubMessage, TestSize.Level1)1291 HWTEST_F(BaseMessageUnittest, AutoFinishSubMessage, TestSize.Level1)
1292 {
1293     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
1294 
1295     ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr);
1296     msgOpt.set_i32_fixed32(1);
1297     ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr);
1298     msgOpt.set_i64_fixed64(1);
1299     ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr);
1300     msgOpt.set_vint_uint32(1);
1301     ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr);
1302     msgOpt.set_vint_sint32(1);
1303     ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr);
1304     msgOpt.set_len_string("\n");
1305     ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr);
1306     ASSERT_TRUE(msgOpt.mutable_len_sub() != nullptr);
1307     ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr);
1308     ASSERT_TRUE(msgOpt.startAdd_len_bytes() != nullptr);
1309     msgOpt.finishAdd_len_bytes(0);
1310     ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr);
1311     msgOpt.set_len_bytes(
1312         [](RandomWriteCtx* randomWriteCtx) -> int32_t {
1313         return 0;
1314         });
1315     ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr);
1316     std::vector<int32_t> arraySint32(1, -1);
1317     msgOpt.add_len_repeated_packed_signed_vint(arraySint32);
1318     ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr);
1319     std::vector<uint32_t> arrayUint32(1, 1);
1320     msgOpt.add_len_repeated_packed_unsigned_vint(arrayUint32);
1321     ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr);
1322     std::vector<uint64_t> arrayfint64(1, 1);
1323     msgOpt.add_len_repeated_packed_fixed(arrayfint64);
1324 
1325     ExampleMessage msgProtobuf;
1326     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
1327     ASSERT_GT(msgProtobuf.repeated_example_size(), 0);
1328 }
1329 
HWTEST_F(BaseMessageUnittest, WriteFailedDrop, TestSize.Level1)1330 HWTEST_F(BaseMessageUnittest, WriteFailedDrop, TestSize.Level1)
1331 {
1332     RandomWriteCtx writeCtx = {
1333         [](RandomWriteCtx*, uint32_t, uint8_t**, uint32_t*) -> bool { return false; },
1334         [](RandomWriteCtx*, uint32_t) -> bool { return false; }
1335         };
1336 
1337     std::unique_ptr<ProtoEncoder::ExampleMessage> msgOpt =
1338         std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx);
1339     msgOpt->set_i32_fixed32(1);
1340     ASSERT_EQ(msgOpt->Finish(), (int32_t)-1);
1341 
1342     msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx);
1343     msgOpt->set_i64_fixed64(1);
1344     ASSERT_EQ(msgOpt->Finish(), (int32_t)-1);
1345 
1346     msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx);
1347     msgOpt->set_vint_uint32(1);
1348     ASSERT_EQ(msgOpt->Finish(), (int32_t)-1);
1349 
1350     msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx);
1351     msgOpt->set_vint_sint32(1);
1352     ASSERT_EQ(msgOpt->Finish(), (int32_t)-1);
1353 
1354     msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx);
1355     msgOpt->set_len_string("\n");
1356     ASSERT_EQ(msgOpt->Finish(), (int32_t)-1);
1357 
1358     msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx);
1359     ASSERT_TRUE(msgOpt->mutable_len_sub() != nullptr);
1360     ASSERT_EQ(msgOpt->Finish(), (int32_t)-1);
1361 
1362     msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx);
1363     ASSERT_TRUE(msgOpt->startAdd_len_bytes() == nullptr);
1364     ASSERT_EQ(msgOpt->Finish(), (int32_t)-1);
1365 
1366     msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx);
1367     msgOpt->set_len_bytes(
1368         [](RandomWriteCtx* randomWriteCtx) -> int32_t {
1369         return 0;
1370         });
1371     ASSERT_EQ(msgOpt->Finish(), (int32_t)-1);
1372 
1373     std::vector<int32_t> arraySint32(1, -1);
1374     msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx);
1375     msgOpt->add_len_repeated_packed_signed_vint(arraySint32);
1376     ASSERT_EQ(msgOpt->Finish(), (int32_t)-1);
1377 
1378     std::vector<uint32_t> arrayUint32(1, 1);
1379     msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx);
1380     msgOpt->add_len_repeated_packed_unsigned_vint(arrayUint32);
1381     ASSERT_EQ(msgOpt->Finish(), (int32_t)-1);
1382 
1383     msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx);
1384     std::vector<uint64_t> arrayfint64(1, 1);
1385     msgOpt->add_len_repeated_packed_fixed(arrayfint64);
1386     ASSERT_EQ(msgOpt->Finish(), (int32_t)-1);
1387 }
1388 
HWTEST_F(BaseMessageUnittest, NoWrite, TestSize.Level1)1389 HWTEST_F(BaseMessageUnittest, NoWrite, TestSize.Level1)
1390 {
1391     ProtoEncoder::ExampleMessage msgOpt(nullptr);
1392 
1393     msgOpt.set_i32_fixed32(1);
1394     msgOpt.set_i64_fixed64(1);
1395     msgOpt.set_vint_uint32(1);
1396     msgOpt.set_vint_sint32(1);
1397     msgOpt.set_len_string("\n");
1398     ASSERT_TRUE(msgOpt.startAdd_len_bytes() == nullptr);
1399     msgOpt.set_len_bytes(nullptr);
1400     msgOpt.set_len_bytes(
1401         [](RandomWriteCtx* randomWriteCtx) -> int32_t {
1402         return 0;
1403         });
1404 
1405     // arrayCount is 0
1406     msgOpt.add_len_repeated_packed_signed_vint(nullptr, 0);
1407     msgOpt.add_len_repeated_packed_unsigned_vint(nullptr, 0);
1408     msgOpt.add_len_repeated_packed_fixed(nullptr, 0);
1409     std::vector<int32_t> arraySint32(1, -1);
1410     msgOpt.add_len_repeated_packed_signed_vint(arraySint32);
1411     std::vector<uint32_t> arrayUint32(1, 1);
1412     msgOpt.add_len_repeated_packed_unsigned_vint(arrayUint32);
1413     std::vector<uint64_t> arrayfint64(1, 1);
1414     msgOpt.add_len_repeated_packed_fixed(arrayfint64);
1415     ASSERT_EQ(msgOpt.Finish(), (int32_t)-1);
1416 }
1417 
HWTEST_F(BaseMessageUnittest, SubMessageAlwaysAvailabe, TestSize.Level1)1418 HWTEST_F(BaseMessageUnittest, SubMessageAlwaysAvailabe, TestSize.Level1)
1419 {
1420     ProtoEncoder::ExampleMessage msgOpt(nullptr);
1421 
1422     ProtoEncoder::SubMessage* subMsgOpt = msgOpt.mutable_len_sub();
1423     ASSERT_TRUE(subMsgOpt != nullptr);
1424     subMsgOpt->set_vint_int32(1);
1425     subMsgOpt->set_vint_int64(1);
1426     subMsgOpt->set_vint_uint32(1);
1427     subMsgOpt->set_vint_uint64(1);
1428     ASSERT_EQ(subMsgOpt->Finish(), (int32_t)-1);
1429 
1430     ProtoEncoder::ExampleMessage* nested1 = msgOpt.add_repeated_example();
1431     ASSERT_TRUE(nested1 != nullptr);
1432     ProtoEncoder::ExampleMessage* nested2 = nested1->add_repeated_example();
1433     ASSERT_TRUE(nested2 != nullptr);
1434     ProtoEncoder::ExampleMessage* nested3 = nested2->add_repeated_example();
1435     ASSERT_TRUE(nested3 != nullptr);
1436 
1437     ASSERT_EQ(nested3->Finish(), (int32_t)-1);
1438     ASSERT_EQ(nested2->Finish(), (int32_t)-1);
1439     ASSERT_EQ(nested1->Finish(), (int32_t)-1);
1440 
1441     msgOpt.set_vint_int32(1);
1442     ASSERT_EQ(msgOpt.Finish(), (int32_t)-1);
1443 }
1444 
HWTEST_F(BaseMessageUnittest, MessagePool, TestSize.Level1)1445 HWTEST_F(BaseMessageUnittest, MessagePool, TestSize.Level1)
1446 {
1447     ProtoEncoder::MessagePool  msgStack;
1448     ProtoEncoder::BaseMessage* pMsg = msgStack.Get();
1449     ASSERT_TRUE(pMsg != nullptr);
1450 
1451     msgStack.Reset(0);
1452     pMsg = msgStack.Get();
1453     ASSERT_TRUE(pMsg != nullptr);
1454 
1455     const uint32_t testRepeat = 1000;
1456     const uint32_t testDepth = 5;
1457     msgStack.Reset(testDepth);
1458     for (uint32_t i = 0; i < testRepeat; i++) {
1459         pMsg = msgStack.Get();
1460         ASSERT_TRUE(pMsg != nullptr);
1461         msgStack.Release();
1462     }
1463 
1464     for (uint32_t i = 0; i < testRepeat; i++) {
1465         for (uint32_t j = 0; j < testDepth; j++) {
1466             pMsg = msgStack.Get();
1467             ASSERT_TRUE(pMsg != nullptr);
1468         }
1469         for (uint32_t j = 0; j < testDepth; j++) {
1470             msgStack.Release();
1471         }
1472     }
1473 
1474     for (uint32_t i = 0; i < testRepeat; i++) {
1475         pMsg = msgStack.Get();
1476         ASSERT_TRUE(pMsg != nullptr);
1477     }
1478     for (uint32_t i = 0; i < testRepeat; i++) {
1479         msgStack.Release();
1480     }
1481 
1482     msgStack.Reset(1);
1483     for (uint32_t i = 0; i < testDepth; i++) {
1484         pMsg = msgStack.Get();
1485         ASSERT_TRUE(pMsg != nullptr);
1486     }
1487     ProtoEncoder::ExampleMessage* pExampleMsg = static_cast<ProtoEncoder::ExampleMessage*>(pMsg);
1488     g_writeCtx.seek(&g_writeCtx, 0);
1489     pExampleMsg->Reset(&g_writeCtx);
1490     pExampleMsg->set_vint_int32(1);
1491     ExampleMessage msgProtobuf;
1492     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
1493     ASSERT_EQ(msgProtobuf.vint_int32(), (int32_t)1);
1494 
1495     msgStack.Reset(1);
1496     ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx, &msgStack);
1497     g_writeCtx.seek(&g_writeCtx, 0);
1498     ProtoEncoder::SubMessage* subMsgOpt = msgOpt.mutable_len_sub();
1499     ASSERT_TRUE(subMsgOpt != nullptr);
1500     msgOpt.set_vint_int32(1);
1501     ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos));
1502     ASSERT_TRUE(msgProtobuf.has_len_sub());
1503     ASSERT_EQ(msgProtobuf.vint_int32(), (int32_t)1);
1504 }
1505 
1506 // reference from https://perfetto.dev/docs/design-docs/protozero
1507 // For the full code of the benchmark see /src/protozero/test/protozero_benchmark.cc
1508 const int TEST_TIMES = 1000 * 100;
1509 uint64_t g_fakeInputSimple[] = {0x12345678,
1510                                 0x90ABCDEF,
1511                                 0x11111111,
1512                                 0xFFFFFFFF,
1513                                 0x6666666666666666ULL,
1514                                 0x6666666666666666ULL,
1515                                 0x6666666666666666ULL,
1516                                 0x0066666666666666ULL};
1517 
HWTEST_F(BaseMessageUnittest, ProtobufferSimple, TestSize.Level1)1518 HWTEST_F(BaseMessageUnittest, ProtobufferSimple, TestSize.Level1)
1519 {
1520     for (int count = 0; count < TEST_TIMES; count++) {
1521         int index = 0;
1522         ExampleMessage msgProtobuf;
1523 
1524         msgProtobuf.set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++]));
1525         msgProtobuf.set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++]));
1526         msgProtobuf.set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++]));
1527         msgProtobuf.set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++]));
1528         msgProtobuf.set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++]));
1529 
1530         ASSERT_TRUE(msgProtobuf.SerializeToArray(&g_buf[0], SIZE_BUFFER) > 0);
1531     }
1532     printf("%d times\n", TEST_TIMES);
1533 }
1534 
HWTEST_F(BaseMessageUnittest, ProtoEncoderSimple, TestSize.Level1)1535 HWTEST_F(BaseMessageUnittest, ProtoEncoderSimple, TestSize.Level1)
1536 {
1537     for (int count = 0; count < TEST_TIMES; count++) {
1538         int index = 0;
1539         g_writeCtx.seek(&g_writeCtx, 0);
1540 
1541         ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
1542 
1543         msgOpt.set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++]));
1544         msgOpt.set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++]));
1545         msgOpt.set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++]));
1546         msgOpt.set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++]));
1547         msgOpt.set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++]));
1548 
1549         ASSERT_TRUE(msgOpt.Finish() > 0);
1550     }
1551     printf("%d times\n", TEST_TIMES);
1552 }
1553 
HWTEST_F(BaseMessageUnittest, ProtobufferNested, TestSize.Level1)1554 HWTEST_F(BaseMessageUnittest, ProtobufferNested, TestSize.Level1)
1555 {
1556     for (int count = 0; count < TEST_TIMES; count++) {
1557         int index = 0;
1558         ExampleMessage msgProtobuf;
1559 
1560         msgProtobuf.set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++]));
1561         msgProtobuf.set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++]));
1562         msgProtobuf.set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++]));
1563         msgProtobuf.set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++]));
1564         msgProtobuf.set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++]));
1565         // fisrt nested
1566         ExampleMessage* nested1 = msgProtobuf.add_repeated_example();
1567         ASSERT_TRUE(nested1 != nullptr);
1568         index = 0;
1569         nested1->set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++]));
1570         nested1->set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++]));
1571         nested1->set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++]));
1572         nested1->set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++]));
1573         nested1->set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++]));
1574         // second nested
1575         ExampleMessage* nested2 = nested1->add_repeated_example();
1576         ASSERT_TRUE(nested2 != nullptr);
1577         index = 0;
1578         nested2->set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++]));
1579         nested2->set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++]));
1580         nested2->set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++]));
1581         nested2->set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++]));
1582         nested2->set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++]));
1583         // third nested
1584         ExampleMessage* nested3 = nested2->add_repeated_example();
1585         ASSERT_TRUE(nested3 != nullptr);
1586         index = 0;
1587         nested3->set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++]));
1588         nested3->set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++]));
1589         nested3->set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++]));
1590         nested3->set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++]));
1591         nested3->set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++]));
1592 
1593         ASSERT_TRUE(msgProtobuf.SerializeToArray(&g_buf[0], SIZE_BUFFER) > 0);
1594     }
1595     printf("%d times\n", TEST_TIMES);
1596 }
1597 
HWTEST_F(BaseMessageUnittest, ProtoEncoderNested, TestSize.Level1)1598 HWTEST_F(BaseMessageUnittest, ProtoEncoderNested, TestSize.Level1)
1599 {
1600     for (int count = 0; count < TEST_TIMES; count++) {
1601         int index = 0;
1602         g_writeCtx.seek(&g_writeCtx, 0);
1603 
1604         ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx);
1605 
1606         msgOpt.set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++]));
1607         msgOpt.set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++]));
1608         msgOpt.set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++]));
1609         msgOpt.set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++]));
1610         msgOpt.set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++]));
1611         // fisrt nested
1612         ProtoEncoder::ExampleMessage* nested1 = msgOpt.add_repeated_example();
1613         ASSERT_TRUE(nested1 != nullptr);
1614         index = 0;
1615         nested1->set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++]));
1616         nested1->set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++]));
1617         nested1->set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++]));
1618         nested1->set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++]));
1619         nested1->set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++]));
1620         // second nested
1621         ProtoEncoder::ExampleMessage* nested2 = nested1->add_repeated_example();
1622         ASSERT_TRUE(nested2 != nullptr);
1623         index = 0;
1624         nested2->set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++]));
1625         nested2->set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++]));
1626         nested2->set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++]));
1627         nested2->set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++]));
1628         nested2->set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++]));
1629         // third nested
1630         ProtoEncoder::ExampleMessage* nested3 = nested2->add_repeated_example();
1631         ASSERT_TRUE(nested3 != nullptr);
1632         index = 0;
1633         nested3->set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++]));
1634         nested3->set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++]));
1635         nested3->set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++]));
1636         nested3->set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++]));
1637         nested3->set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++]));
1638 
1639         ASSERT_TRUE(msgOpt.Finish() > 0);
1640     }
1641     printf("%d times\n", TEST_TIMES);
1642 }
1643 } // namespace Profiler
1644 } // namespace Developtools
1645 } // namespace OHOS
1646