1 /*
2 * Copyright (c) 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 "cache_data.h"
17
18 #include <cerrno>
19
20 #include <gtest/gtest.h>
21 #include "platform/common/rs_system_properties.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Rosen {
28 class CacheDataTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 void SetUp() override;
33 void TearDown() override;
34 };
35
SetUpTestCase()36 void CacheDataTest::SetUpTestCase() {}
TearDownTestCase()37 void CacheDataTest::TearDownTestCase() {}
SetUp()38 void CacheDataTest::SetUp() {}
TearDown()39 void CacheDataTest::TearDown() {}
40
41 /**
42 * @tc.name: cachedata_init_test_001
43 * @tc.desc: Verify the initialization function of shader cache
44 * @tc.type: FUNC
45 * @tc.require:
46 * @tc.author:
47 */
48 HWTEST_F(CacheDataTest, cachedata_init_test_001, TestSize.Level1)
49 {
50 #ifdef ACE_ENABLE_GL
51 if (RSSystemProperties::IsUseVulkan()) {
52 GTEST_LOG_(INFO) << "vulkan enable! skip opengl test case";
53 return;
54 }
55 GTEST_LOG_(INFO) << "CacheDataTest cachedata_init_test_001 start";
56 /**
57 * @tc.steps: step1. initialize a cachedata
58 */
59 std::shared_ptr<CacheData> cacheData = std::make_shared<CacheData>(0, 0, 0, "TestDir");
60 /**
61 * @tc.steps: step2. test the result of initialization function
62 */
63 EXPECT_NE(nullptr, cacheData.get());
64 #endif
65 }
66
67 /**
68 * @tc.name: serialized_size_test_001
69 * @tc.desc: Verify the function that computes the file size after serialization
70 * @tc.type: FUNC
71 * @tc.require:
72 * @tc.author:
73 */
74 HWTEST_F(CacheDataTest, serialized_size_test_001, TestSize.Level1)
75 {
76 #ifdef ACE_ENABLE_GL
77 if (RSSystemProperties::IsUseVulkan()) {
78 GTEST_LOG_(INFO) << "vulkan enable! skip opengl test case";
79 return;
80 }
81 GTEST_LOG_(INFO) << "CacheDataTest serialized_size_test_001 start";
82 /**
83 * @tc.steps: step1. initialize a cachedata
84 */
85 std::shared_ptr<CacheData> cacheData = std::make_shared<CacheData>(0, 0, 0, "TestDir");
86 struct tempHeader {
87 size_t numShaders_;
88 };
89 /**
90 * @tc.steps: step2. tests the size computation
91 */
92 size_t serSize = cacheData->SerializedSize();
93 EXPECT_EQ(sizeof(tempHeader), serSize);
94 #endif
95 }
96
97 /**
98 * @tc.name: get_data_test_001
99 * @tc.desc: Verify the function that gets a k-v pair of data
100 * @tc.type: FUNC
101 * @tc.require:
102 * @tc.author:
103 */
104 HWTEST_F(CacheDataTest, get_data_test_001, TestSize.Level1)
105 {
106 #ifdef ACE_ENABLE_GL
107 if (RSSystemProperties::IsUseVulkan()) {
108 GTEST_LOG_(INFO) << "vulkan enable! skip opengl test case";
109 return;
110 }
111 GTEST_LOG_(INFO) << "CacheDataTest get_data_test_001 start";
112 /**
113 * @tc.steps: step1. initialize a cachedata
114 */
115 std::string testFileDir = "test file dir for cachedata";
116 std::shared_ptr<CacheData> cacheData = std::make_shared<CacheData>(0, 0, 0, testFileDir);
117 /**
118 * @tc.steps: step2. test the data grabbing function
119 */
120 auto [errorCode, sizeGet] = cacheData->Get(nullptr, 1, nullptr, 1);
121 EXPECT_EQ(0, sizeGet);
122 #endif
123 }
124
125 /**
126 * @tc.name: serialization_test_001
127 * @tc.desc: Verify the serialization function
128 * @tc.type: FUNC
129 * @tc.require:
130 * @tc.author:
131 */
132 HWTEST_F(CacheDataTest, serialization_test_001, TestSize.Level1)
133 {
134 #ifdef ACE_ENABLE_GL
135 if (RSSystemProperties::IsUseVulkan()) {
136 GTEST_LOG_(INFO) << "vulkan enable! skip opengl test case";
137 return;
138 }
139 GTEST_LOG_(INFO) << "CacheDataTest serialization_test_001 start";
140 /**
141 * @tc.steps: step1. initialize a cachedata
142 */
143 std::string testFileDir = "test file dir for cachedata";
144 std::shared_ptr<CacheData> cacheData = std::make_shared<CacheData>(0, 0, 0, testFileDir);
145 /**
146 * @tc.steps: step2. test the serialization function
147 */
148 uint8_t *tempBuffer = new uint8_t[sizeof(size_t)]();
149 int retSerialized = cacheData->Serialize(tempBuffer, sizeof(size_t));
150 EXPECT_NE(retSerialized, -EINVAL);
151 delete[] tempBuffer;
152 #endif
153 }
154
155 /**
156 * @tc.name: deserialization_test_001
157 * @tc.desc: Verify the deserialization function
158 * @tc.type: FUNC
159 * @tc.require:
160 * @tc.author:
161 */
162 HWTEST_F(CacheDataTest, deserialization_test_001, TestSize.Level1)
163 {
164 #ifdef ACE_ENABLE_GL
165 if (RSSystemProperties::IsUseVulkan()) {
166 GTEST_LOG_(INFO) << "vulkan enable! skip opengl test case";
167 return;
168 }
169 GTEST_LOG_(INFO) << "CacheDataTest deserialization_test_001 start";
170 /**
171 * @tc.steps: step1. initialize a cachedata
172 */
173 std::string testFileDir = "test file dir for cachedata";
174 std::shared_ptr<CacheData> cacheData = std::make_shared<CacheData>(0, 0, 0, testFileDir);
175 /**
176 * @tc.steps: step2. test the deserialization function
177 */
178 uint8_t *tempBuffer = new uint8_t[sizeof(size_t)]();
179 int retDeserialized = cacheData->DeSerialize(tempBuffer, sizeof(size_t));
180 EXPECT_NE(retDeserialized, -EINVAL);
181 delete[] tempBuffer;
182 #endif
183 }
184
185 /**
186 * @tc.name: write_data_test_001
187 * @tc.desc: Verify the rewrite and get function with overloaded data
188 * @tc.type: FUNC
189 * @tc.require:
190 * @tc.author:
191 */
192 HWTEST_F(CacheDataTest, write_data_test_001, TestSize.Level1)
193 {
194 #ifdef ACE_ENABLE_GL
195 if (RSSystemProperties::IsUseVulkan()) {
196 GTEST_LOG_(INFO) << "vulkan enable! skip opengl test case";
197 return;
198 }
199 GTEST_LOG_(INFO) << "CacheDataTest write_data_test_001 start";
200 /**
201 * @tc.steps: step1. initialize a cachedata
202 */
203 std::string testFileDir = "test file dir for cachedata";
204 std::shared_ptr<CacheData> cacheData = std::make_shared<CacheData>(2, 2, 4, testFileDir);
205 /**
206 * @tc.steps: step2. test the rewrite and get function
207 */
208 uint8_t *tempBuffer = new uint8_t[8]();
209 cacheData->Rewrite(tempBuffer, 8, tempBuffer, 8);
210 auto [errorCode, sizeGet] = cacheData->Get(tempBuffer, 8, tempBuffer, 8);
211 EXPECT_EQ(0, sizeGet);
212 delete[] tempBuffer;
213 #endif
214 }
215
216 /**
217 * @tc.name: clean_data_test_001
218 * @tc.desc: Verify the clean function
219 * @tc.type: FUNC
220 * @tc.require:
221 * @tc.author:
222 */
223 HWTEST_F(CacheDataTest, clean_data_test_001, TestSize.Level1)
224 {
225 #ifdef ACE_ENABLE_GL
226 if (RSSystemProperties::IsUseVulkan()) {
227 GTEST_LOG_(INFO) << "vulkan enable! skip opengl test case";
228 return;
229 }
230 GTEST_LOG_(INFO) << "CacheDataTest clean_data_test_001 start";
231 /**
232 * @tc.steps: step1. initialize a cachedata
233 */
234 std::string testFileDir = "test file dir for cachedata";
235 std::shared_ptr<CacheData> cacheData = std::make_shared<CacheData>(8, 8, 15, testFileDir);
236 /**
237 * @tc.steps: step2. test the clean function
238 */
239 uint8_t *tempBuffer = new uint8_t[4]();
240 const char *testKey1 = "Key1";
241 const char *testKey2 = "Key2";
242 const char *testKey3 = "Key3";
243 const char *testKey4 = "Key4";
244 const char *testValue = "aVal";
245 cacheData->Rewrite(testKey1, 4, testValue, 4);
246 cacheData->Rewrite(testKey2, 4, testValue, 4);
247 cacheData->Rewrite(testKey3, 4, testValue, 4);
248 cacheData->Rewrite(testKey4, 4, testValue, 4);
249 auto [errorCode, sizeGet] = cacheData->Get(testKey4, 4, tempBuffer, 4);
250 EXPECT_EQ(4, sizeGet);
251 delete[] tempBuffer;
252 #endif
253 }
254
255 /**
256 * @tc.name: clean_data_test_002
257 * @tc.desc: Verify a vain clean function
258 * @tc.type: FUNC
259 * @tc.require:
260 * @tc.author:
261 */
262 HWTEST_F(CacheDataTest, clean_data_test_002, TestSize.Level1)
263 {
264 #ifdef ACE_ENABLE_GL
265 if (RSSystemProperties::IsUseVulkan()) {
266 GTEST_LOG_(INFO) << "vulkan enable! skip opengl test case";
267 return;
268 }
269 GTEST_LOG_(INFO) << "CacheDataTest clean_data_test_002 start";
270 /**
271 * @tc.steps: step1. initialize a cachedata
272 */
273 std::string testFileDir = "test file dir for cachedata";
274 std::shared_ptr<CacheData> cacheData = std::make_shared<CacheData>(4, 4, 6, testFileDir);
275 /**
276 * @tc.steps: step2. test the clean function that skips a vain clean
277 */
278 uint8_t *tempBuffer = new uint8_t[4]();
279 const char *testKey1 = "Key1";
280 const char *testKey2 = "Key2";
281 const char *testValue = "aVal";
282 cacheData->Rewrite(testKey1, 4, testValue, 4);
283 cacheData->Rewrite(testKey2, 4, testValue, 4);
284 auto [errorCode, sizeGet] = cacheData->Get(testKey2, 4, tempBuffer, 4);
285 EXPECT_EQ(0, sizeGet);
286 delete[] tempBuffer;
287 #endif
288 }
289 } // namespace Rosen
290 } // namespace OHOS