1 /*
2 * Copyright (c) 2025 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 #include <gtest/gtest.h>
16 #include "feature/param_update/param_manager.h"
17 #include "feature/param_update/param_common_event.h"
18 #include "feature/param_update/param_reader.h"
19 #include "feature/param_update/sign_tools.h"
20 #include "form_constants.h"
21
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace AppExecFwk {
26 namespace {
27 const std::string EVENT_INFO_TYPE = "type";
28 const std::string CFG_UPDATED_ACTION = "usual.event.DUE_SA_CFG_UPDATED";
29 const std::string PARAM_CONFIG_TYPE = "FormMgrConfig";
30 const std::string PARAM_PRESET_PATH = "/system/etc/FormMgrConfig/";
31 }
32
33 class FmsParamManagerTest : public testing::Test {
34 public:
35 void SetUp() override;
36 void TearDown() override;
37 ParamManager& paramManager = ParamManager::GetInstance();
38 ParamCommonEvent& paramCommonEvent = ParamCommonEvent::GetInstance();
39 ParamReader& paramReader = ParamReader::GetInstance();
40 };
41
SetUp()42 void FmsParamManagerTest::SetUp()
43 {}
44
TearDown()45 void FmsParamManagerTest::TearDown()
46 {}
47
48 /**
49 * @tc.name: fmsParamManager_001
50 * @tc.desc: test IsExemptLock function.
51 * @tc.type: FUNC
52 */
53 HWTEST_F(FmsParamManagerTest, fmsParamManager_001, TestSize.Level1)
54 {
55 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_001 start";
56 paramCommonEvent.SubscriberEvent();
57 paramManager.InitParam();
58 std::string paramStr = paramManager.GetParamStr();
59 std::string version = paramManager.GetParamVersion();
60 EXPECT_EQ(version.empty(), false);
61 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_001 end";
62 }
63
64 /**
65 * @tc.name: fmsParamManager_002
66 * @tc.desc: test IsExemptLock function.
67 * @tc.type: FUNC
68 */
69 HWTEST_F(FmsParamManagerTest, fmsParamManager_002, TestSize.Level1)
70 {
71 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_002 start";
72 paramCommonEvent.SubscriberEvent();
73 AAFwk::Want want;
74 paramCommonEvent.OnReceiveEvent(want);
75 std::string version = paramManager.GetParamVersion();
76 EXPECT_EQ(version.empty(), false);
77 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_002 end";
78 }
79
80 /**
81 * @tc.name: fmsParamManager_003
82 * @tc.desc: test IsExemptLock function.
83 * @tc.type: FUNC
84 */
85 HWTEST_F(FmsParamManagerTest, fmsParamManager_003, TestSize.Level1)
86 {
87 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_003 start";
88 AAFwk::Want want;
89 want.SetAction(CFG_UPDATED_ACTION);
90 paramCommonEvent.OnReceiveEvent(want);
91 std::string version = paramManager.GetParamVersion();
92 EXPECT_EQ(version.empty(), false);
93 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_003 end";
94 }
95
96 /**
97 * @tc.name: fmsParamManager_004
98 * @tc.desc: test IsExemptLock function.
99 * @tc.type: FUNC
100 */
101 HWTEST_F(FmsParamManagerTest, fmsParamManager_004, TestSize.Level1)
102 {
103 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_004 start";
104 AAFwk::Want want;
105 want.SetAction(CFG_UPDATED_ACTION);
106 want.SetParam(EVENT_INFO_TYPE, PARAM_CONFIG_TYPE);
107 paramCommonEvent.OnReceiveEvent(want);
108 std::string version = paramManager.GetParamVersion();
109 paramCommonEvent.UnSubscriberEvent();
110 EXPECT_EQ(version.empty(), false);
111 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_004 end";
112 }
113
114 /**
115 * @tc.name: fmsParamManager_005
116 * @tc.desc: test IsExemptLock function.
117 * @tc.type: FUNC
118 */
119 HWTEST_F(FmsParamManagerTest, fmsParamManager_005, TestSize.Level1)
120 {
121 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_005 start";
122 std::string path = "";
123 std::string presetVersion = paramReader.GetPathVersion(path);
124 EXPECT_EQ(presetVersion, Constants::FMC_DEFAULT_VERSION);
125 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_005 end";
126 }
127
128 /**
129 * @tc.name: fmsParamManager_006
130 * @tc.desc: test IsExemptLock function.
131 * @tc.type: FUNC
132 */
133 HWTEST_F(FmsParamManagerTest, fmsParamManager_006, TestSize.Level1)
134 {
135 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_006 start";
136 bool result = paramReader.VerifyCertSfFile();
137 std::string version = paramManager.GetParamVersion();
138 EXPECT_EQ(version.empty(), false);
139 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_006 end";
140 }
141
142 /**
143 * @tc.name: fmsParamManager_007
144 * @tc.desc: test IsExemptLock function.
145 * @tc.type: FUNC
146 */
147 HWTEST_F(FmsParamManagerTest, fmsParamManager_007, TestSize.Level1)
148 {
149 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_007 start";
150 std::string path = "";
151 bool result = paramReader.VerifyParamFile(path);
152 EXPECT_EQ(result, false);
153 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_007 end";
154 }
155
156 /**
157 * @tc.name: fmsParamManager_008
158 * @tc.desc: test IsExemptLock function.
159 * @tc.type: FUNC
160 */
161 HWTEST_F(FmsParamManagerTest, fmsParamManager_008, TestSize.Level1)
162 {
163 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_008 start";
164 std::string path = "";
165 std::string param = paramReader.GetParamInfoStr(path);
166 EXPECT_EQ(param.empty(), true);
167 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_008 end";
168 }
169
170 /**
171 * @tc.name: fmsParamManager_009
172 * @tc.desc: test IsExemptLock function.
173 * @tc.type: FUNC
174 */
175 HWTEST_F(FmsParamManagerTest, fmsParamManager_009, TestSize.Level1)
176 {
177 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_009 start";
178 std::string path = PARAM_PRESET_PATH + Constants::VERSION_FILE_NAME;
179 SignTools::CalcFileSha256Digest(path);
180 path = "";
181 std::tuple<int, std::string> ret = SignTools::CalcFileSha256Digest(path);
182 EXPECT_NE(std::get<0>(ret), 0);
183 GTEST_LOG_(INFO) << "FmsParamManagerTest fmsParamManager_009 end";
184 }
185 }
186 }