1 /*
2 * Copyright (c) 2024 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 #define LOG_TAG "RdbBigIntTest"
16 #include "raw_data_parser.h"
17
18 #include <gtest/gtest.h>
19
20 #include "value_object.h"
21 using namespace testing::ext;
22 using namespace OHOS::NativeRdb;
23 namespace Test {
24 class RawDataParserTest : public testing::Test {
25 public:
26 static void SetUpTestCase(void);
27 static void TearDownTestCase(void);
28 void SetUp();
29 void TearDown();
30 };
SetUpTestCase(void)31 void RawDataParserTest::SetUpTestCase(void)
32 {
33 }
34
TearDownTestCase(void)35 void RawDataParserTest::TearDownTestCase(void)
36 {
37 }
38
SetUp(void)39 void RawDataParserTest::SetUp(void)
40 {
41 }
42
TearDown(void)43 void RawDataParserTest::TearDown(void)
44 {
45 }
46
47 /**
48 * @tc.name: BigInt_Parser
49 * @tc.desc: test insert bigint to rdb store
50 * @tc.type: FUNC
51 */
52 HWTEST_F(RawDataParserTest, BigInt_Parser, TestSize.Level1)
53 {
54 std::vector<uint64_t> u64Val(2 + rand() % 100, 0);
55 for (int i = 0; i < u64Val.size(); ++i) {
56 uint64_t high = uint64_t(rand());
57 uint64_t low = uint64_t(rand());
58 u64Val[i] = (high << 32) | low;
59 }
60 BigInteger value1 = BigInteger(0, std::vector<uint64_t>(u64Val));
61 auto rawData = RawDataParser::PackageRawData(value1);
62 for (size_t i = 0; i < sizeof(uintptr_t); ++i) {
63 std::vector<uint8_t> noAlign(rawData.size() + i, 0);
64 noAlign.insert(noAlign.begin() + i, rawData.begin(), rawData.end());
65 BigInteger parsedValue1;
66 RawDataParser::ParserRawData(noAlign.data() + i, noAlign.size() - i, parsedValue1);
67 ASSERT_TRUE(value1 == parsedValue1);
68 }
69 }
70 /**
71 * @tc.name: Float32_Parser
72 * @tc.desc: test insert bigint to rdb store
73 * @tc.type: FUNC
74 */
75 HWTEST_F(RawDataParserTest, Float32_Parser, TestSize.Level1)
76 {
77 std::vector<float> floats(15, 9.65);
78 auto rawData = RawDataParser::PackageRawData(floats);
79 for (size_t i = 0; i < sizeof(uintptr_t); ++i) {
80 std::vector<uint8_t> noAlign(rawData.size() + i, 0);
81 noAlign.insert(noAlign.begin() + i, rawData.begin(), rawData.end());
82 std::vector<float> parsedFloats;
83 RawDataParser::ParserRawData(noAlign.data() + i, noAlign.size() - i, parsedFloats);
84 ASSERT_TRUE(floats.size() == parsedFloats.size());
85 }
86 }
87 /**
88 * @tc.name: Asset_Parser
89 * @tc.desc: test insert bigint to rdb store
90 * @tc.type: FUNC
91 */
92 HWTEST_F(RawDataParserTest, Asset_Parser, TestSize.Level1)
93 {
94 ValueObject::Asset asset;
95 asset.id = "100";
96 asset.name = "IMG_1690.png";
97 asset.uri = "file://data/args/header/IMG_1690.png";
98 asset.createTime = "2024-07-05 20:37.982158265 +8:00";
99 asset.modifyTime = "2024-07-05 20:37.982158265 +8:00";
100 asset.size = "4194304";
101 asset.hash = "2024-07-05 20:37.982158265 +8:00_4194304";
102 asset.path = "photos/header/IMG_1690.png";
103 auto rawData = RawDataParser::PackageRawData(asset);
104 for (size_t i = 0; i < sizeof(uintptr_t); ++i) {
105 std::vector<uint8_t> noAlign(rawData.size() + i, 0);
106 noAlign.insert(noAlign.begin() + i, rawData.begin(), rawData.end());
107 ValueObject::Asset parsedAsset;
108 RawDataParser::ParserRawData(noAlign.data() + i, noAlign.size() - i, parsedAsset);
109 ASSERT_TRUE(parsedAsset.id == asset.id);
110 ASSERT_TRUE(parsedAsset.name == asset.name);
111 ASSERT_TRUE(parsedAsset.uri == asset.uri);
112 ASSERT_TRUE(parsedAsset.createTime == asset.createTime);
113 ASSERT_TRUE(parsedAsset.modifyTime == asset.modifyTime);
114 ASSERT_TRUE(parsedAsset.size == asset.size);
115 ASSERT_TRUE(parsedAsset.hash == asset.hash);
116 ASSERT_TRUE(parsedAsset.path == asset.path);
117 }
118 }
119 /**
120 * @tc.name: Assets_Parser
121 * @tc.desc: test insert bigint to rdb store
122 * @tc.type: FUNC
123 */
124 HWTEST_F(RawDataParserTest, Assets_Parser, TestSize.Level1)
125 {
126 ValueObject::Assets assets(1);
127 assets[0].id = "100";
128 assets[0].name = "IMG_1690.png";
129 assets[0].uri = "file://data/args/header/IMG_1690.png";
130 assets[0].createTime = "2024-07-05 20:37.982158265 +8:00";
131 assets[0].modifyTime = "2024-07-05 20:37.982158265 +8:00";
132 assets[0].size = "4194304";
133 assets[0].hash = "2024-07-05 20:37.982158265 +8:00_4194304";
134 assets[0].path = "photos/header/IMG_1690.png";
135 auto rawData = RawDataParser::PackageRawData(assets);
136 for (size_t i = 0; i < sizeof(uintptr_t); ++i) {
137 std::vector<uint8_t> noAlign(rawData.size() + i, 0);
138 noAlign.insert(noAlign.begin() + i, rawData.begin(), rawData.end());
139 ValueObject::Assets parsedAssets;
140 RawDataParser::ParserRawData(noAlign.data() + i, noAlign.size() - i, parsedAssets);
141 ASSERT_TRUE(parsedAssets[0].id == assets[0].id);
142 ASSERT_TRUE(parsedAssets[0].name == assets[0].name);
143 ASSERT_TRUE(parsedAssets[0].uri == assets[0].uri);
144 ASSERT_TRUE(parsedAssets[0].createTime == assets[0].createTime);
145 ASSERT_TRUE(parsedAssets[0].modifyTime == assets[0].modifyTime);
146 ASSERT_TRUE(parsedAssets[0].size == assets[0].size);
147 ASSERT_TRUE(parsedAssets[0].hash == assets[0].hash);
148 ASSERT_TRUE(parsedAssets[0].path == assets[0].path);
149 }
150 }
151 } // namespace Test
152
