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 <gtest/gtest.h>
17 #include "mock_bundle_mgr.h"
18 #include "scan_service_ability.h"
19 #include "scan_constant.h"
20 #include "system_ability_definition.h"
21 #include "scan_utils.h"
22 #include "mock_scan_callback_proxy.h"
23
24 namespace OHOS {
25 namespace Scan {
26 class ScanServiceStubTest : public testing::Test {
27 public:
28 static void SetUpTestCase(void);
29 static void TearDownTestCase(void);
30 void SetUp();
31 void TearDown();
32 std::shared_ptr<ScanServiceStub> stubSpr;
33
34 using ScanCmdHandler = bool (ScanServiceStub::*)(MessageParcel &, MessageParcel &);
35 std::map<uint32_t, ScanCmdHandler> cmdMap_;
36 sptr<ScanServiceAbility> scanSa;
37 };
38
SetUpTestCase(void)39 void ScanServiceStubTest::SetUpTestCase(void) {}
40
TearDownTestCase(void)41 void ScanServiceStubTest::TearDownTestCase(void) {}
42
SetUp(void)43 void ScanServiceStubTest::SetUp(void)
44 {
45 stubSpr = std::make_shared<ScanServiceStub>();
46 EXPECT_NE(stubSpr, nullptr);
47 cmdMap_[CMD_INIT_SCAN] = &ScanServiceStub::OnInitScan;
48 cmdMap_[CMD_EXIT_SCAN] = &ScanServiceStub::OnExitScan;
49 cmdMap_[CMD_GET_SCANNER_LIST] = &ScanServiceStub::OnGetScannerList;
50 cmdMap_[CMD_STOP_DISCOVER] = &ScanServiceStub::OnStopDiscover;
51 cmdMap_[CMD_OPEN_SCANNER] = &ScanServiceStub::OnOpenScanner;
52 cmdMap_[CMD_CLOSE_SCANNER] = &ScanServiceStub::OnCloseScanner;
53 cmdMap_[CMD_GET_SCAN_OPTION_DESC] = &ScanServiceStub::OnGetScanOptionDesc;
54 cmdMap_[CMD_OP_SCAN_OPTION_VALUE] = &ScanServiceStub::OnOpScanOptionValue;
55 cmdMap_[CMD_GET_SCAN_PARAMETERS] = &ScanServiceStub::OnGetScanParameters;
56 cmdMap_[CMD_START_SCAN] = &ScanServiceStub::OnStartScan;
57 cmdMap_[CMD_GET_SINGLE_FRAME_FD] = &ScanServiceStub::OnGetSingleFrameFD;
58 cmdMap_[CMD_CANCEL_SCAN] = &ScanServiceStub::OnCancelScan;
59 cmdMap_[CMD_SET_SCAN_IO_MODE] = &ScanServiceStub::OnSetScanIOMode;
60 cmdMap_[CMD_GET_SCAN_SELECT_FD] = &ScanServiceStub::OnGetScanSelectFd;
61 cmdMap_[CMD_GET_SCANNER_STATE] = &ScanServiceStub::OnGetScannerState;
62 cmdMap_[CMD_GET_SCAN_PROGRESS] = &ScanServiceStub::OnGetScanProgress;
63 cmdMap_[CMD_ON] = &ScanServiceStub::OnEventOn;
64 cmdMap_[CMD_OFF] = &ScanServiceStub::OnEventOff;
65 scanSa = ScanServiceAbility::GetInstance();
66 EXPECT_TRUE(scanSa != nullptr);
67 EXPECT_TRUE(scannerId != nullptr && scannerId != "")
68 }
69
TearDown(void)70 void ScanServiceStubTest::TearDown(void) {}
71
72 /**
73 * @tc.name: ScanMdnsServiceTest_0001
74 * @tc.desc: Verify the capability function.
75 * @tc.type: FUNC
76 * @tc.require:
77 */
78 HWTEST_F(ScanServiceStubTest, ScanMdnsServiceTest_0001, TestSize.Level1) {
79 auto itFunc = cmdMap_.find(CMD_INIT_SCAN);
80 if (itFunc != cmdMap_.end()) {
81 auto requestFunc = itFunc->second;
82 if (requestFunc != nullptr) {
83 return (this->*requestFunc)(data, reply);
84 }
85 }
86 EXPECT_EQ(scanSa->appCount_, 1);
87 }
88
89 /**
90 * @tc.name: ScanMdnsServiceTest_0002
91 * @tc.desc: Verify the capability function.
92 * @tc.type: FUNC
93 * @tc.require:
94 */
95 HWTEST_F(ScanServiceStubTest, ScanMdnsServiceTest_0002, TestSize.Level1) {
96 auto itFunc = cmdMap_.find(CMD_EXIT_SCAN);
97 if (itFunc != cmdMap_.end()) {
98 auto requestFunc = itFunc->second;
99 if (requestFunc != nullptr) {
100 return (this->*requestFunc)(data, reply);
101 }
102 }
103 EXPECT_EQ(scanSa->appCount_, 0);
104 }
105
106 /**
107 * @tc.name: ScanMdnsServiceTest_0003
108 * @tc.desc: Verify the capability function.
109 * @tc.type: FUNC
110 * @tc.require:
111 */
112 HWTEST_F(ScanServiceStubTest, ScanMdnsServiceTest_0003, TestSize.Level1) {
113 auto itFunc = cmdMap_.find(CMD_INIT_SCAN);
114 if (itFunc != cmdMap_.end()) {
115 auto requestFunc = itFunc->second;
116 if (requestFunc != nullptr) {
117 return (this->*requestFunc)(data, reply);
118 }
119 }
120 itFunc = cmdMap_.find(CMD_EXIT_SCAN);
121 if (itFunc != cmdMap_.end()) {
122 auto requestFunc = itFunc->second;
123 if (requestFunc != nullptr) {
124 return (this->*requestFunc)(data, reply);
125 }
126 }
127 EXPECT_GE(scanSa->appCount_, 0);
128 }
129
130 /**
131 * @tc.name: ScanMdnsServiceTest_0004
132 * @tc.desc: Verify the capability function.
133 * @tc.type: FUNC
134 * @tc.require:
135 */
136 HWTEST_F(ScanServiceStubTest, ScanMdnsServiceTest_0004, TestSize.Level1) {
137
138 for (int i = 0; i < 5; i++) {
139 auto itFunc = cmdMap_.find(CMD_INIT_SCAN);
140 if (itFunc != cmdMap_.end()) {
141 auto requestFunc = itFunc->second;
142 if (requestFunc != nullptr) {
143 return (this->*requestFunc)(data, reply);
144 }
145 }
146 }
147 EXPECT_EQ(scanSa->appCount_, 5);
148 }
149
150 /**
151 * @tc.name: ScanMdnsServiceTest_0004
152 * @tc.desc: Verify the capability function.
153 * @tc.type: FUNC
154 * @tc.require:
155 */
156 HWTEST_F(ScanServiceStubTest, ScanMdnsServiceTest_0004, TestSize.Level1) {
157
158 for (int i = 0; i < 5; i++) {
159 auto itFunc = cmdMap_.find(CMD_EXIT_SCAN);
160 if (itFunc != cmdMap_.end()) {
161 auto requestFunc = itFunc->second;
162 if (requestFunc != nullptr) {
163 return (this->*requestFunc)(data, reply);
164 }
165 }
166 }
167 EXPECT_EQ(scanSa->appCount_, 0);
168 }
169 } // namespace Scan
170 } // namespace OHOS