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 <benchmark/benchmark.h> 17 #include "accessibility_ui_test_ability.h" 18 #include "accessible_ability_listener.h" 19 #include "ffrt_inner.h" 20 21 using namespace OHOS::Accessibility; 22 23 namespace { 24 class AccessibleAbilityListenerImpl : public AccessibleAbilityListener { 25 public: 26 AccessibleAbilityListenerImpl() = default; 27 ~AccessibleAbilityListenerImpl() = default; 28 OnAbilityConnected()29 void OnAbilityConnected() override 30 { 31 complete_.set_value(); 32 } 33 OnAbilityDisconnected()34 void OnAbilityDisconnected() override 35 { 36 complete_.set_value(); 37 } 38 OnAccessibilityEvent(const AccessibilityEventInfo & eventInfo)39 void OnAccessibilityEvent(const AccessibilityEventInfo &eventInfo) override {} 40 OnKeyPressEvent(const std::shared_ptr<OHOS::MMI::KeyEvent> & keyEvent)41 bool OnKeyPressEvent(const std::shared_ptr<OHOS::MMI::KeyEvent> &keyEvent) override 42 { 43 return false; 44 } 45 SetCompletePromise(ffrt::promise<void> & promise)46 void SetCompletePromise(ffrt::promise<void> &promise) 47 { 48 complete_ = std::move(promise); 49 } 50 51 private: 52 ffrt::promise<void> complete_; 53 }; 54 55 class AccessibleAbilityClientTest : public benchmark::Fixture { 56 public: AccessibleAbilityClientTest()57 AccessibleAbilityClientTest() 58 { 59 Iterations(iterations); 60 Repetitions(repetitions); 61 ReportAggregatesOnly(); 62 } 63 64 ~AccessibleAbilityClientTest() override = default; 65 66 void SetUp(const ::benchmark::State &state) override; 67 void TearDown(const ::benchmark::State &state) override; 68 69 protected: 70 const int32_t repetitions = 3; 71 const int32_t iterations = 1000; 72 std::shared_ptr<AccessibleAbilityListenerImpl> listener_ = nullptr; 73 }; 74 SetUp(const::benchmark::State & state)75 void AccessibleAbilityClientTest::SetUp(const ::benchmark::State &state) 76 { 77 listener_ = std::make_shared<AccessibleAbilityListenerImpl>(); 78 AccessibilityUITestAbility::GetInstance()->RegisterAbilityListener(listener_); 79 80 // Connect 81 ffrt::promise<void> connected; 82 ffrt::future syncFuture = connected.get_future(); 83 listener_->SetCompletePromise(connected); 84 AccessibilityUITestAbility::GetInstance()->Connect(); 85 syncFuture.wait(); 86 } 87 TearDown(const::benchmark::State & state)88 void AccessibleAbilityClientTest::TearDown(const ::benchmark::State &state) 89 { 90 // Disconnect 91 ffrt::promise<void> disconnect; 92 ffrt::future syncFuture = disconnect.get_future(); 93 listener_->SetCompletePromise(disconnect); 94 AccessibilityUITestAbility::GetInstance()->Disconnect(); 95 syncFuture.wait(); 96 } 97 98 /** 99 * @tc.name: GetRootTestCase 100 * @tc.desc: Testcase for testing 'GetRoot' function. 101 * @tc.type: FUNC 102 * @tc.require: Issue Number. Set ace command first before test. 103 */ BENCHMARK_F(AccessibleAbilityClientTest,GetRootTestCase)104 BENCHMARK_F(AccessibleAbilityClientTest, GetRootTestCase)( 105 benchmark::State &state) 106 { 107 while (state.KeepRunning()) { 108 AccessibilityElementInfo elementInfo; 109 int32_t result = AccessibilityUITestAbility::GetInstance()->GetRoot(elementInfo); 110 if (result != 0) { 111 state.SkipWithError("GetRoot failed. Maybe there is no command to set ace"); 112 } 113 } 114 } 115 116 /** 117 * @tc.name: GetWindowsTestCase 118 * @tc.desc: Testcase for testing 'GetWindows' function. 119 * @tc.type: FUNC 120 * @tc.require: Issue Number 121 */ BENCHMARK_F(AccessibleAbilityClientTest,GetWindowsTestCase)122 BENCHMARK_F(AccessibleAbilityClientTest, GetWindowsTestCase)( 123 benchmark::State &state) 124 { 125 while (state.KeepRunning()) { 126 std::vector<AccessibilityWindowInfo> windows; 127 int32_t result = AccessibilityUITestAbility::GetInstance()->GetWindows(windows); 128 if (result != 0) { 129 state.SkipWithError("GetWindows failed."); 130 } 131 } 132 } 133 134 /** 135 * @tc.name: GetWindowTestCase 136 * @tc.desc: Testcase for testing 'GetWindow' function. 137 * @tc.type: FUNC 138 * @tc.require: Issue Number 139 */ BENCHMARK_F(AccessibleAbilityClientTest,GetWindowTestCase)140 BENCHMARK_F(AccessibleAbilityClientTest, GetWindowTestCase)( 141 benchmark::State &state) 142 { 143 while (state.KeepRunning()) { 144 int32_t windowId = 0; 145 AccessibilityWindowInfo windowInfo; 146 AccessibilityUITestAbility::GetInstance()->GetWindow(windowId, windowInfo); 147 } 148 } 149 150 /** 151 * @tc.name: InjectGestureTestCase 152 * @tc.desc: Testcase for testing 'InjectGesture' function. 153 * @tc.type: FUNC 154 * @tc.require: Issue Number 155 */ BENCHMARK_F(AccessibleAbilityClientTest,InjectGestureTestCase)156 BENCHMARK_F(AccessibleAbilityClientTest, InjectGestureTestCase)( 157 benchmark::State &state) 158 { 159 while (state.KeepRunning()) { 160 std::shared_ptr<AccessibilityGestureInjectPath> gesturePath = 161 std::make_shared<AccessibilityGestureInjectPath>(); 162 int64_t durationTime = 20; 163 gesturePath->SetDurationTime(durationTime); 164 AccessibilityGesturePosition position = {200.0f, 200.0f}; 165 gesturePath->AddPosition(position); 166 int32_t result = AccessibilityUITestAbility::GetInstance()->InjectGesture(gesturePath); 167 if (result != 0) { 168 state.SkipWithError("InjectGesture failed."); 169 } 170 } 171 } 172 } 173 174 BENCHMARK_MAIN();