1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "scene_persistence.h"
17 #include "session/host/include/scene_session.h"
18 #include "session.h"
19 #include <gtest/gtest.h>
20 #include "session_info.h"
21 #include "ws_common.h"
22 
23 using namespace testing;
24 using namespace testing::ext;
25 
26 namespace OHOS {
27 namespace Rosen {
28 class ScenePersistenceTest : public testing::Test {
29 public:
30     static void SetUpTestCase();
31     static void TearDownTestCase();
32     void SetUp() override;
33     void TearDown() override;
34 private:
35     std::shared_ptr<Media::PixelMap> mPixelMap = std::make_shared<Media::PixelMap>();
36 };
37 
38 constexpr const char* UNDERLINE_SEPARATOR = "_";
39 constexpr const char* IMAGE_SUFFIX = ".jpg";
40 
41 static sptr<ScenePersistence> scenePersistence = new ScenePersistence("testBundleName", 1423);
42 
SetUpTestCase()43 void ScenePersistenceTest::SetUpTestCase()
44 {
45 }
46 
TearDownTestCase()47 void ScenePersistenceTest::TearDownTestCase()
48 {
49 }
50 
SetUp()51 void ScenePersistenceTest::SetUp()
52 {
53 }
54 
TearDown()55 void ScenePersistenceTest::TearDown()
56 {
57 }
58 
59 namespace {
60 /**
61  * @tc.name: CreateSnapshotDir
62  * @tc.desc: test function : CreateSnapshotDir
63  * @tc.type: FUNC
64  */
HWTEST_F(ScenePersistenceTest, CreateSnapshotDir, Function | SmallTest | Level1)65 HWTEST_F(ScenePersistenceTest, CreateSnapshotDir, Function | SmallTest | Level1)
66 {
67     std::string directory = "0/Storage";
68     ASSERT_NE(nullptr, scenePersistence);
69     bool result = scenePersistence->CreateSnapshotDir(directory);
70     ASSERT_EQ(result, false);
71 }
72 
73 /**
74  * @tc.name: CreateUpdatedIconDir
75  * @tc.desc: test function : CreateUpdatedIconDir
76  * @tc.type: FUNC
77  */
HWTEST_F(ScenePersistenceTest, CreateUpdatedIconDir, Function | SmallTest | Level1)78 HWTEST_F(ScenePersistenceTest, CreateUpdatedIconDir, Function | SmallTest | Level1)
79 {
80     std::string directory = "0/Storage";
81     ASSERT_NE(nullptr, scenePersistence);
82     bool result = scenePersistence->CreateUpdatedIconDir(directory);
83     ASSERT_EQ(result, false);
84 }
85 
86 /**
87  * @tc.name: SaveSnapshot
88  * @tc.desc: test function : SaveSnapshot
89  * @tc.type: FUNC
90  */
HWTEST_F(ScenePersistenceTest, SaveSnapshot, Function | SmallTest | Level1)91 HWTEST_F(ScenePersistenceTest, SaveSnapshot, Function | SmallTest | Level1)
92 {
93     std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
94     std::string directory = "0/Storage";
95     std::string bundleName = "testBundleName";
96 
97     SessionInfo info;
98     info.abilityName_ = bundleName;
99     info.bundleName_ = bundleName;
100     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(info, nullptr);
101 
102     int32_t persistentId = 1423;
103     ASSERT_NE(nullptr, scenePersistence);
104     scenePersistence->SaveSnapshot(pixelMap);
105 
106     sptr<Session> session = new Session(info);
107     ASSERT_NE(nullptr, session);
108     scenePersistence->snapshotPath_ = "/data/1.png";
109 
110     scenePersistence->SaveSnapshot(mPixelMap);
111     uint32_t fileID = static_cast<uint32_t>(persistentId) & 0x3fffffff;
112     std::string test = ScenePersistence::snapshotDirectory_ +
113         bundleName + UNDERLINE_SEPARATOR + std::to_string(fileID) + IMAGE_SUFFIX;
114     std::pair<uint32_t, uint32_t> sizeResult = scenePersistence->GetSnapshotSize();
115     EXPECT_EQ(sizeResult.first, 0);
116     EXPECT_EQ(sizeResult.second, 0);
117 }
118 
119 /**
120  * @tc.name: RenameSnapshotFromOldPersistentId
121  * @tc.desc: test function : RenameSnapshotFromOldPersistentId
122  * @tc.type: FUNC
123  */
HWTEST_F(ScenePersistenceTest, RenameSnapshotFromOldPersistentId, Function | SmallTest | Level3)124 HWTEST_F(ScenePersistenceTest, RenameSnapshotFromOldPersistentId, Function | SmallTest | Level3)
125 {
126     int ret = 0;
127     int32_t persistentId = 1424;
128     std::string bundleName = "testBundleName";
129     sptr<ScenePersistence> scenePersistence2 = new ScenePersistence(bundleName, persistentId);
130     scenePersistence2->RenameSnapshotFromOldPersistentId(persistentId);
131     ASSERT_EQ(ret, 0);
132 
133     sptr<ScenePersistence> scenePersistence3 = new ScenePersistence(bundleName, persistentId);
134     ASSERT_NE(nullptr, scenePersistence3);
135     scenePersistence3->snapshotPath_ = "/data/1.png";
136     scenePersistence3->RenameSnapshotFromOldPersistentId(persistentId);
137 }
138 
139 /**
140  * @tc.name: SaveUpdatedIcon
141  * @tc.desc: test function : SaveUpdatedIcon
142  * @tc.type: FUNC
143  */
HWTEST_F(ScenePersistenceTest, SaveUpdatedIcon, Function | SmallTest | Level1)144 HWTEST_F(ScenePersistenceTest, SaveUpdatedIcon, Function | SmallTest | Level1)
145 {
146     std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
147     std::string directory = "0/Storage";
148     std::string bundleName = "testBundleName";
149     ASSERT_NE(nullptr, scenePersistence);
150     scenePersistence->SaveUpdatedIcon(pixelMap);
151     SessionInfo info;
152     info.bundleName_ = "bundleName";
153     sptr<Session> session = new Session(info);
154     ASSERT_NE(nullptr, session);
155     scenePersistence->SaveUpdatedIcon(mPixelMap);
156     std::string result(scenePersistence->GetUpdatedIconPath());
157     std::string test = ScenePersistence::updatedIconDirectory_ + bundleName + IMAGE_SUFFIX;
158     EXPECT_NE(result.compare(test), 0);
159 }
160 
161 /**
162  * @tc.name: SaveUpdatedIcon02
163  * @tc.desc: test function : SaveUpdatedIcon02
164  * @tc.type: FUNC
165  */
HWTEST_F(ScenePersistenceTest, SaveUpdatedIcon02, Function | SmallTest | Level1)166 HWTEST_F(ScenePersistenceTest, SaveUpdatedIcon02, Function | SmallTest | Level1)
167 {
168     std::string directory = "0/Storage";
169     std::string bundleName = "testBundleName";
170     ASSERT_NE(nullptr, scenePersistence);
171     scenePersistence->snapshotPath_ = "/data/1.png";
172     ASSERT_NE(nullptr, mPixelMap);
173     scenePersistence->SaveUpdatedIcon(mPixelMap);
174     std::string result(scenePersistence->GetUpdatedIconPath());
175     std::string test = ScenePersistence::updatedIconDirectory_ + bundleName + IMAGE_SUFFIX;
176     EXPECT_EQ(result.compare(test), 1);
177 }
178 
179 /**
180  * @tc.name: IsSnapshotExisted
181  * @tc.desc: test function : IsSnapshotExisted
182  * @tc.type: FUNC
183  */
HWTEST_F(ScenePersistenceTest, IsSnapshotExisted, Function | SmallTest | Level1)184 HWTEST_F(ScenePersistenceTest, IsSnapshotExisted, Function | SmallTest | Level1)
185 {
186     std::string bundleName = "testBundleName";
187     int32_t persistentId = 1423;
188     sptr<ScenePersistence> scenePersistence = new ScenePersistence(bundleName, persistentId);
189     ASSERT_NE(nullptr, scenePersistence);
190     bool result = scenePersistence->IsSnapshotExisted();
191     ASSERT_EQ(result, false);
192 }
193 
194 /**
195  * @tc.name: GetLocalSnapshotPixelMap
196  * @tc.desc: test function : get local snapshot pixelmap
197  * @tc.type: FUNC
198  */
HWTEST_F(ScenePersistenceTest, GetLocalSnapshotPixelMap, Function | SmallTest | Level1)199 HWTEST_F(ScenePersistenceTest, GetLocalSnapshotPixelMap, Function | SmallTest | Level1)
200 {
201     SessionInfo info;
202     info.abilityName_ = "GetPixelMap";
203     info.bundleName_ = "GetPixelMap1";
204     sptr<Session> session = new Session(info);
205     ASSERT_NE(nullptr, session);
206     auto abilityInfo = session->GetSessionInfo();
207     auto persistentId = abilityInfo.persistentId_;
208     ScenePersistence::CreateSnapshotDir("storage");
209     sptr<ScenePersistence> scenePersistence =
210         new ScenePersistence(abilityInfo.bundleName_, persistentId);
211     ASSERT_NE(nullptr, scenePersistence);
212     auto result = scenePersistence->GetLocalSnapshotPixelMap(0.5, 0.5);
213     EXPECT_EQ(result, nullptr);
214 
215     bool result2 = scenePersistence->IsSnapshotExisted();
216     EXPECT_EQ(result2, false);
217 
218     // create pixelMap
219     const uint32_t colors[1] = { 0x6f0000ff };
220     constexpr uint32_t COMMON_SIZE = 1;
221     uint32_t colorsLength = sizeof(colors) / sizeof(colors[0]);
222     const int32_t offset = 0;
223     Media::InitializationOptions opts;
224     opts.size.width = COMMON_SIZE;
225     opts.size.height = COMMON_SIZE;
226     opts.pixelFormat = Media::PixelFormat::RGBA_8888;
227     opts.alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
228     int32_t stride = opts.size.width;
229     std::shared_ptr<Media::PixelMap> pixelMap1 = Media::PixelMap::Create(colors, colorsLength, offset, stride, opts);
230 
231     scenePersistence->SaveSnapshot(pixelMap1);
232     int maxScenePersistencePollNum = 100;
233     scenePersistence->snapshotPath_ = "/data/1.png";
234     for (int i = 0; i < maxScenePersistencePollNum; i++) {
235         result = scenePersistence->GetLocalSnapshotPixelMap(0.8, 0.2);
236         result2 = scenePersistence->IsSnapshotExisted();
237     }
238     EXPECT_NE(result, nullptr);
239     ASSERT_EQ(result2, true);
240 
241     result = scenePersistence->GetLocalSnapshotPixelMap(0.0, 0.2);
242     EXPECT_NE(result, nullptr);
243 }
244 
245 /**
246  * @tc.name: IsSavingSnapshot
247  * @tc.desc: test function : IsSavingSnapshot
248  * @tc.type: FUNC
249  */
HWTEST_F(ScenePersistenceTest, IsSavingSnapshot, Function | SmallTest | Level1)250 HWTEST_F(ScenePersistenceTest, IsSavingSnapshot, Function | SmallTest | Level1)
251 {
252     std::string bundleName = "testBundleName";
253     int32_t persistentId = 1423;
254     sptr<ScenePersistence> scenePersistence = new ScenePersistence(bundleName, persistentId);
255     ASSERT_NE(nullptr, scenePersistence);
256     bool result = scenePersistence->IsSavingSnapshot();
257     ASSERT_EQ(result, false);
258 }
259 
260 /**
261  * @tc.name: GetSnapshotFilePath
262  * @tc.desc: test function : GetSnapshotFilePath
263  * @tc.type: FUNC
264  */
HWTEST_F(ScenePersistenceTest, GetSnapshotFilePath, Function | SmallTest | Level1)265 HWTEST_F(ScenePersistenceTest, GetSnapshotFilePath, Function | SmallTest | Level1)
266 {
267     std::string bundleName = "testBundleName";
268     int32_t persistentId = 1423;
269     sptr<ScenePersistence> scenePersistence = new ScenePersistence(bundleName, persistentId);
270     ASSERT_NE(nullptr, scenePersistence);
271     scenePersistence->RenameSnapshotFromOldPersistentId(0);
272     auto result = scenePersistence->GetSnapshotFilePath();
273     ASSERT_EQ(result, scenePersistence->snapshotPath_);
274 }
275 
276 /**
277  * @tc.name: HasSnapshot
278  * @tc.desc: test function: HasSnapshot
279  * @tc.type: FUNC
280  */
HWTEST_F(ScenePersistenceTest, HasSnapshot, Function | SmallTest | Level1)281 HWTEST_F(ScenePersistenceTest, HasSnapshot, Function | SmallTest | Level1)
282 {
283     std::string bundleName = "testBundleName";
284     int32_t persistentId = 1423;
285     sptr<ScenePersistence> scenePersistence = new ScenePersistence(bundleName, persistentId);
286     ASSERT_NE(nullptr, scenePersistence);
287     scenePersistence->SetHasSnapshot(true);
288     ASSERT_EQ(scenePersistence->HasSnapshot(), true);
289     scenePersistence->SetHasSnapshot(false);
290     ASSERT_EQ(scenePersistence->HasSnapshot(), false);
291 }
292 }
293 }
294 }