1 /*
2  * Copyright (c) 2022-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 
16 #include "version_manager_test.h"
17 
18 #include "component_loader.h"
19 #include "version_manager.h"
20 
21 using namespace testing::ext;
22 
23 namespace OHOS {
24 namespace DistributedHardware {
SetUpTestCase(void)25 void VersionManagerTest::SetUpTestCase(void) {}
26 
TearDownTestCase(void)27 void VersionManagerTest::TearDownTestCase(void) {}
28 
SetUp()29 void VersionManagerTest::SetUp()
30 {
31     ComponentLoader::GetInstance().Init();
32 }
33 
TearDown()34 void VersionManagerTest::TearDown()
35 {
36     ComponentLoader::GetInstance().UnInit();
37 }
38 
39 namespace {
40 const std::string TEST_DEVICE_ID_1 = "bb536a637105409e904d4da83790a4a7";
41 const std::string TEST_DEVICE_ID_2 = "bb536a637105409e904d4da83790a4a8";
42 const std::string TEST_DEVICE_ID_3 = "bb536a637105409e904d4da83790a4a9";
43 const std::string TEST_DEVICE_ID_4 = "bb536a637105409e904d4da83790a4a0";
44 const std::string TEST_HANDLER_VERSION_1 = "1.0";
45 const std::string TEST_HANDLER_VERSION_2 = "3.0";
46 const std::string TEST_HANDLER_VERSION_3 = "5.0";
47 const std::string TEST_SOURCE_VERSION_1 = "2.2";
48 const std::string TEST_SOURCE_VERSION_2 = "2.0";
49 const std::string TEST_SOURCE_VERSION_3 = "6.0";
50 const std::string TEST_SINK_VERSION_1 = "2.4";
51 const std::string TEST_SINK_VERSION_2 = "2.0";
52 const std::string TEST_SINK_VERSION_3 = "2.0";
53 const std::string TEST_DH_VERSION = "3.1";
54 const std::string TEST_COMPONENT_NAME_1 = "distributed_camera";
55 const std::string TEST_COMPONENT_NAME_2 = "distributed_audio";
56 const std::string TEST_COMPONENT_NAME_3 = "distributed_mic";
57 }
58 
59 /**
60  * @tc.name: version_manager_test_002
61  * @tc.desc: Verify AddDHVersion function
62  * @tc.type: FUNC
63  * @tc.require: AR000GHSKN
64  */
65 HWTEST_F(VersionManagerTest, version_manager_test_002, TestSize.Level0)
66 {
67     DHVersion dhVersion;
68     CompVersion cVs1 { TEST_COMPONENT_NAME_1, DHType::CAMERA, TEST_HANDLER_VERSION_1, TEST_SOURCE_VERSION_1,
69         TEST_SINK_VERSION_1 };
70     CompVersion cVs2 { TEST_COMPONENT_NAME_2, DHType::AUDIO, TEST_HANDLER_VERSION_2, TEST_SOURCE_VERSION_2,
71         TEST_SINK_VERSION_2 };
72     CompVersion cVs3 { TEST_COMPONENT_NAME_3, DHType::SCREEN, TEST_HANDLER_VERSION_3, TEST_SOURCE_VERSION_3,
73         TEST_SINK_VERSION_3 };
74     dhVersion.uuid = TEST_DEVICE_ID_1;
75     dhVersion.dhVersion = TEST_DH_VERSION;
76     dhVersion.compVersions.insert(std::make_pair(cVs1.dhType, cVs1));
77     dhVersion.compVersions.insert(std::make_pair(cVs2.dhType, cVs2));
78     dhVersion.compVersions.insert(std::make_pair(cVs3.dhType, cVs3));
79     int32_t ret = VersionManager::GetInstance().AddDHVersion(dhVersion.uuid, dhVersion);
80     EXPECT_EQ(DH_FWK_SUCCESS, ret);
81     dhVersion.uuid = TEST_DEVICE_ID_2;
82     ret = VersionManager::GetInstance().AddDHVersion(dhVersion.uuid, dhVersion);
83     EXPECT_EQ(DH_FWK_SUCCESS, ret);
84 }
85 
86 /**
87  * @tc.name: version_manager_test_003
88  * @tc.desc: Verify GetLocalDeviceVersion function
89  * @tc.type: FUNC
90  * @tc.require: AR000GHSKN
91  */
92 HWTEST_F(VersionManagerTest, version_manager_test_003, TestSize.Level0)
93 {
94     std::string strVersion = VersionManager::GetInstance().GetLocalDeviceVersion();
95     EXPECT_EQ(DH_LOCAL_VERSION, strVersion);
96 }
97 
98 /**
99  * @tc.name: version_manager_test_004
100  * @tc.desc: Verify GetDHVersion function
101  * @tc.type: FUNC
102  * @tc.require: AR000GHSKN
103  */
104 HWTEST_F(VersionManagerTest, version_manager_test_004, TestSize.Level0)
105 {
106     DHVersion dhVersion;
107     int32_t ret = VersionManager::GetInstance().GetDHVersion(TEST_DEVICE_ID_2, dhVersion);
108     EXPECT_EQ(DH_FWK_SUCCESS, ret);
109     EXPECT_EQ(TEST_HANDLER_VERSION_2, dhVersion.compVersions[DHType::AUDIO].handlerVersion);
110     EXPECT_EQ(TEST_DH_VERSION, dhVersion.dhVersion);
111     ret = VersionManager::GetInstance().GetDHVersion(TEST_DEVICE_ID_3, dhVersion);
112     EXPECT_EQ(ERR_DH_FWK_VERSION_DEVICE_ID_NOT_EXIST, ret);
113 }
114 
115 /**
116  * @tc.name: version_manager_test_005
117  * @tc.desc: Verify RemoveDHVersion function
118  * @tc.type: FUNC
119  * @tc.require: AR000GHSKN
120  */
121 HWTEST_F(VersionManagerTest, version_manager_test_005, TestSize.Level0)
122 {
123     int32_t ret = VersionManager::GetInstance().RemoveDHVersion(TEST_DEVICE_ID_2);
124     EXPECT_EQ(DH_FWK_SUCCESS, ret);
125     ret = VersionManager::GetInstance().RemoveDHVersion(TEST_DEVICE_ID_4);
126     EXPECT_EQ(ERR_DH_FWK_VERSION_DEVICE_ID_NOT_EXIST, ret);
127     ret = VersionManager::GetInstance().RemoveDHVersion(TEST_DEVICE_ID_2);
128     EXPECT_EQ(ERR_DH_FWK_VERSION_DEVICE_ID_NOT_EXIST, ret);
129     ret = VersionManager::GetInstance().RemoveDHVersion(TEST_DEVICE_ID_1);
130     EXPECT_EQ(DH_FWK_SUCCESS, ret);
131 }
132 
133 /**
134  * @tc.name: version_manager_test_006
135  * @tc.desc: Verify GetCompVersion function
136  * @tc.type: FUNC
137  * @tc.require: AR000GHSKN
138  */
139 HWTEST_F(VersionManagerTest, version_manager_test_006, TestSize.Level0)
140 {
141     DHVersion dhVersion;
142     CompVersion cVs1 { TEST_COMPONENT_NAME_1, DHType::CAMERA, TEST_HANDLER_VERSION_1, TEST_SOURCE_VERSION_1,
143         TEST_SINK_VERSION_1 };
144     dhVersion.uuid = TEST_DEVICE_ID_1;
145     dhVersion.dhVersion = TEST_DH_VERSION;
146     dhVersion.compVersions.insert(std::make_pair(cVs1.dhType, cVs1));
147     int32_t ret = VersionManager::GetInstance().AddDHVersion(dhVersion.uuid, dhVersion);
148     EXPECT_EQ(DH_FWK_SUCCESS, ret);
149     ret = VersionManager::GetInstance().GetCompVersion(TEST_DEVICE_ID_1, DHType::CAMERA, cVs1);
150     EXPECT_EQ(DH_FWK_SUCCESS, ret);
151 }
152 
153 /**
154  * @tc.name: version_manager_test_007
155  * @tc.desc: Verify GetCompVersion function
156  * @tc.type: FUNC
157  * @tc.require: AR000GHSKN
158  */
159 HWTEST_F(VersionManagerTest, version_manager_test_007, TestSize.Level0)
160 {
161     DHVersion dhVersion;
162     CompVersion cVs1 { TEST_COMPONENT_NAME_1, DHType::CAMERA, TEST_HANDLER_VERSION_1, TEST_SOURCE_VERSION_1,
163         TEST_SINK_VERSION_1 };
164     dhVersion.uuid = TEST_DEVICE_ID_1;
165     dhVersion.dhVersion = TEST_DH_VERSION;
166     dhVersion.compVersions.insert(std::make_pair(cVs1.dhType, cVs1));
167     int32_t ret = VersionManager::GetInstance().AddDHVersion(dhVersion.uuid, dhVersion);
168     EXPECT_EQ(DH_FWK_SUCCESS, ret);
169     ret = VersionManager::GetInstance().GetCompVersion(TEST_DEVICE_ID_1, DHType::AUDIO, cVs1);
170     EXPECT_EQ(ERR_DH_FWK_TYPE_NOT_EXIST, ret);
171 }
172 
173 /**
174  * @tc.name: version_manager_test_008
175  * @tc.desc: Verify the Init function.
176  * @tc.type: FUNC
177  * @tc.require: AR000GHSKN
178  */
179 HWTEST_F(VersionManagerTest, version_manager_test_008, TestSize.Level0)
180 {
181     ComponentLoader::GetInstance().isLocalVersionInit_.store(false);
182     int32_t ret = VersionManager::GetInstance().Init();
183     EXPECT_EQ(ERR_DH_FWK_LOADER_GET_LOCAL_VERSION_FAIL, ret);
184 }
185 } // namespace DistributedHardware
186 } // namespace OHOS
187