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