diff --git a/barrierfree/BUILD.gn b/barrierfree/BUILD.gn index fc10957c93a9a727bf601d7f4ea1cb2b6abfc08e..446df6c4edf5d780f1ef0fbbe3337a986a456e52 100644 --- a/barrierfree/BUILD.gn +++ b/barrierfree/BUILD.gn @@ -24,6 +24,7 @@ group("barrierfree") { "accessibilityevent:ActsAccessibilityEventTest", "accessibilityextension:ActsAccessibilityExtensionTest", "accessibilityextensioncontext:ActsAccessibilityExtensionContextTest", + "accessibilityextensioncontextcaperrcode:ActsAccessibilityExtensionContextCapErrCodeTest", "accessibilitygestureevent:ActsAccessibilityGestureEventTest", "accessibilitysendaccessibilityevent:ActsAccessibilitySendAccessibilityEventTest", "accessibleabilitylist:ActsAccessibleAbilityListTest", diff --git a/barrierfree/accessibilityextensioncontext/entry/src/main/ets/AccessibilityExtAbility/ExtensionContextTest.ts b/barrierfree/accessibilityextensioncontext/entry/src/main/ets/AccessibilityExtAbility/ExtensionContextTest.ts index c30339336539a24e7134c6e080255c12975fd920..75ca9c5ebfcd12f8647ceab4cdc1ebeacb6407bd 100644 --- a/barrierfree/accessibilityextensioncontext/entry/src/main/ets/AccessibilityExtAbility/ExtensionContextTest.ts +++ b/barrierfree/accessibilityextensioncontext/entry/src/main/ets/AccessibilityExtAbility/ExtensionContextTest.ts @@ -137,7 +137,9 @@ export class ExtensionContextTest { break; case 'AccessibilityExtensionContextTest_getFocusElement_asyncCallback_3700': await this.setAccessibilityFocus(); - this.getFocusElementByTypeCallback(caseName, true, true); + setTimeout(async () => { + this.getFocusElementByTypeCallback(caseName, true, true); + }, 1000); break; case 'AccessibilityExtensionContextTest_getFocusElement_asyncCallback_3900': await this.clearAccessibilityFocus(); @@ -145,7 +147,9 @@ export class ExtensionContextTest { break; case 'AccessibilityExtensionContextTest_getFocusElement_asyncPromise_4100': await this.setAccessibilityFocus(); - this.getFocusElementByTypePromise(caseName, true, true); + setTimeout(async () => { + this.getFocusElementByTypePromise(caseName, true, true); + }, 1000); break; case 'AccessibilityExtensionContextTest_getFocusElement_asyncPromise_4300': await this.clearAccessibilityFocus(); @@ -174,10 +178,6 @@ export class ExtensionContextTest { new GesturePoint(1000, 1000)); this.gestureInjectCallback(caseName, gesturePath); break; - case 'AccessibilityExtensionContextTest_gestureInject_asyncCallback_4900': - gesturePath = undefined; - this.gestureInjectCallback(caseName, gesturePath); - break; case 'AccessibilityExtensionContextTest_gestureInject_asyncPromise_5000': gesturePath = new GesturePath(100); gesturePath.points.push(new GesturePoint(10, 10)); @@ -201,10 +201,6 @@ export class ExtensionContextTest { new GesturePoint(1000, 1000)); this.gestureInjectPromise(caseName, gesturePath); break; - case 'AccessibilityExtensionContextTest_gestureInject_asyncPromise_5400': - gesturePath = undefined; - this.gestureInjectPromise(caseName, gesturePath); - break; default: console.warn('ExtensionContextTest processCase unknown!!!!!!!!!!'); break; @@ -575,52 +571,30 @@ export class ExtensionContextTest { private async gestureInjectCallback(caseName: string, gesturePath: object) { let result = false; - if (gesturePath == undefined) { - this.context.injectGesture(gesturePath, (err, res) => { - if (err && err.code != 0) { - console.error(caseName + " err: " + JSON.stringify(err.code)); - result = true; - } - this.publishCaseResult(caseName, result); - }); - } else { - this.context.injectGesture(gesturePath, (err, res) => { - console.info(caseName + " res: " + JSON.stringify(res)); - result = true; - if (err && err.code != 0) { - console.error(caseName + " err: " + JSON.stringify(err.code)); - result = false; - } - this.publishCaseResult(caseName, result); - }); - } + this.context.injectGesture(gesturePath, (err, res) => { + console.info(caseName + " res: " + JSON.stringify(res)); + result = true; + if (err && err.code != 0) { + console.error(caseName + " err: " + JSON.stringify(err.code)); + result = false; + } + this.publishCaseResult(caseName, result); + }); } private async gestureInjectPromise(caseName: string, gesturePath: object) { let result = false; - if (gesturePath == undefined) { - this.context.injectGesture(gesturePath).then((res) => { - this.publishCaseResult(caseName, result); - }).catch ((err) => { - if (err && err.code != 0) { - console.error(caseName + 'error:' + JSON.stringify(err)); - result = true; - } - this.publishCaseResult(caseName, result); - }); - } else { - this.context.injectGesture(gesturePath).then((res) => { - console.info(caseName + " res: " + JSON.stringify(res)); + this.context.injectGesture(gesturePath).then((res) => { + console.info(caseName + " res: " + JSON.stringify(res)); + result = true; + this.publishCaseResult(caseName, result); + }).catch ((err) => { + if (err && err.code != 0) { + console.error(caseName + 'error:' + JSON.stringify(err)); result = true; - this.publishCaseResult(caseName, result); - }).catch ((err) => { - if (err && err.code != 0) { - console.error(caseName + 'error:' + JSON.stringify(err)); - result = true; - } - this.publishCaseResult(caseName, result); - }); - } + } + this.publishCaseResult(caseName, result); + }); } } \ No newline at end of file diff --git a/barrierfree/accessibilityextensioncontext/entry/src/main/ets/test/AccessibilityExtensionContext.test.ets b/barrierfree/accessibilityextensioncontext/entry/src/main/ets/test/AccessibilityExtensionContext.test.ets index bb94307629303d7bf77864092866430016cf35db..eac739203223eb84df8c0ce1b7c16684a6275675 100644 --- a/barrierfree/accessibilityextensioncontext/entry/src/main/ets/test/AccessibilityExtensionContext.test.ets +++ b/barrierfree/accessibilityextensioncontext/entry/src/main/ets/test/AccessibilityExtensionContext.test.ets @@ -1015,39 +1015,6 @@ export default function abilityTest() { } }) - /* - * @tc.number AccessibilityExtensionContextTest_gestureInject_asyncCallback_4900 - * @tc.name AccessibilityExtensionContextTest_gestureInject_asyncCallback_4900 - * @tc.desc The parameter input is gesturePath, test the gestureInject() function. - * The result of gestureInject() should be boolean type. - * @tc.size SmallTest - * @tc.type User - */ - it('AccessibilityExtensionContextTest_gestureInject_asyncCallback_4900', 0, async function (done) { - let caseName = 'AccessibilityExtensionContextTest_gestureInject_asyncCallback_4900'; - console.info(caseName + 'start'); - - if (isConnect) { - publishCaseExecute(caseName); - - setTimeout(() => { - if (caseResult != undefined) { - console.info(caseName + ':' + caseResult.data); - expect(passStr).assertEqual(caseResult.data); - expect(caseName).assertEqual(caseResult.parameters.case); - } else { - console.info(caseName + ': caseResult is undefined'); - expect(null).assertFail(); - } - done(); - }, 3000); - } else { - console.error(caseName + ': extension not connected'); - expect(null).assertFail(); - done(); - } - }) - /* * @tc.number AccessibilityExtensionContextTest_gestureInject_asyncPromise_5000 * @tc.name AccessibilityExtensionContextTest_gestureInject_asyncPromise_5000 @@ -1179,38 +1146,5 @@ export default function abilityTest() { done(); } }) - - /* - * @tc.number AccessibilityExtensionContextTest_gestureInject_asyncPromise_5400 - * @tc.name AccessibilityExtensionContextTest_gestureInject_asyncPromise_5400 - * @tc.desc The parameter input is gesturePath, test the gestureInject() function. - * The result of gestureInject() should be boolean type. - * @tc.size SmallTest - * @tc.type User - */ - it('AccessibilityExtensionContextTest_gestureInject_asyncPromise_5400', 0, async function(done) { - let caseName = 'AccessibilityExtensionContextTest_gestureInject_asyncPromise_5400'; - console.info(caseName + 'start'); - - if (isConnect) { - publishCaseExecute(caseName); - - setTimeout(() => { - if (caseResult != undefined) { - console.info(caseName + ':' + caseResult.data); - expect(passStr).assertEqual(caseResult.data); - expect(caseName).assertEqual(caseResult.parameters.case); - } else { - console.info(caseName + ': caseResult is undefined'); - expect(null).assertFail(); - } - done(); - }, 3000); - } else { - console.error(caseName + ': extension not connected'); - expect(null).assertFail(); - done(); - } - }) }) } diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/AppScope/app.json b/barrierfree/accessibilityextensioncontextcaperrcode/AppScope/app.json new file mode 100644 index 0000000000000000000000000000000000000000..5a401487806987d4e1e1824c70088b5f67184501 --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/AppScope/app.json @@ -0,0 +1,21 @@ +{ + "app": { + "bundleName": "com.example.accessibilityxts", + "vendor": "huawei", + "versionCode": 1000000, + "versionName": "1.0.0", + "debug": false, + "icon": "$media:icon", + "label": "$string:app_name", + "description": "$string:description_application", + "distributedNotificationEnabled": true, + "keepAlive": true, + "singleUser": true, + "minAPIVersion": 9, + "targetAPIVersion": 9, + "car": { + "apiCompatibleVersion": 9, + "singleUser": false + } + } +} diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/AppScope/resources/base/element/string.json b/barrierfree/accessibilityextensioncontextcaperrcode/AppScope/resources/base/element/string.json new file mode 100644 index 0000000000000000000000000000000000000000..633100a6d90763bfac9d20aaae683119d7320e9c --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/AppScope/resources/base/element/string.json @@ -0,0 +1,8 @@ +{ + "string":[ + { + "name":"app_name", + "value":"ohosProject" + } + ] +} \ No newline at end of file diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/AppScope/resources/base/media/app_icon.png b/barrierfree/accessibilityextensioncontextcaperrcode/AppScope/resources/base/media/app_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..474a55588fd7216113dd42073aadf254d4dba023 Binary files /dev/null and b/barrierfree/accessibilityextensioncontextcaperrcode/AppScope/resources/base/media/app_icon.png differ diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/BUILD.gn b/barrierfree/accessibilityextensioncontextcaperrcode/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..7dc6ff4c863bd2c8c689d23ec078ab1b83ff66a4 --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/BUILD.gn @@ -0,0 +1,43 @@ +# Copyright (c) 2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//test/xts/tools/build/suite.gni") + +ohos_js_hap_suite("ActsAccessibilityExtensionContextCapErrCodeTest") { + hap_profile = "./entry/src/main/module.json" + js_build_mode = "debug" + deps = [ + ":accessibilityextensioncontextcaperrcode_js_assets", + ":accessibilityextensioncontextcaperrcode_resources", + ] + ets2abc = true + certificate_profile = "signature/openharmony_sx.p7b" + hap_name = "ActsAccessibilityExtensionContextCapErrCodeTest" + part_name = "accessibility" + subsystem_name = "barrierfree" +} + +ohos_app_scope("accessibilityextensioncontextcaperrcode_app_profile") { + app_profile = "AppScope/app.json" + sources = [ "AppScope/resources" ] +} + +ohos_js_assets("accessibilityextensioncontextcaperrcode_js_assets") { + source_dir = "./entry/src/main/ets" +} + +ohos_resources("accessibilityextensioncontextcaperrcode_resources") { + sources = [ "./entry/src/main/resources" ] + deps = [ ":accessibilityextensioncontextcaperrcode_app_profile" ] + hap_profile = "./entry/src/main/module.json" +} diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/Test.json b/barrierfree/accessibilityextensioncontextcaperrcode/Test.json new file mode 100644 index 0000000000000000000000000000000000000000..cf1458c159ca893bc27edb9955f13b8578b152e8 --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/Test.json @@ -0,0 +1,26 @@ +{ + "description": "Configuration for hjunit demo Tests", + "driver": { + "type": "OHJSUnitTest", + "test-timeout": "360000", + "bundle-name": "com.example.accessibilityxts", + "module-name": "phone", + "shell-timeout": "600000", + "testcase-timeout": 70000 + }, + "kits": [ + { + "test-file-name": [ + "ActsAccessibilityExtensionContextCapErrCodeTest.hap" + ], + "type": "AppInstallKit", + "cleanup-apps": true + }, + { + "type": "ShellKit", + "run-command": [ + "param set persist.ace.testmode.enabled 1" + ] + } + ] +} diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/AccessibilityExtAbility/AccessibilityExtAbility.ts b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/AccessibilityExtAbility/AccessibilityExtAbility.ts new file mode 100644 index 0000000000000000000000000000000000000000..123975e6dc9fe9ef9b7f58136ec6018a8edcf3ef --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/AccessibilityExtAbility/AccessibilityExtAbility.ts @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import AccessibilityExtensionAbility from '@ohos.application.AccessibilityExtensionAbility'; +import commonEvent from '@ohos.commonEvent'; +import {ExtensionContextTest} from './ExtensionContextTest'; + +class AccessibilityExtAbility extends AccessibilityExtensionAbility { + tester: ExtensionContextTest = undefined; + + onConnect() { + console.info("[Demo] AccessibilityExtAbility onConnect"); + this.tester = new ExtensionContextTest(this.context); + this.tester.init(); + + let commonEventPublishData = { + data: 'connect' + } + commonEvent.publish('onConnectState', commonEventPublishData, publishCallback); + + function publishCallback(err) { + console.info("onConnect====>onConnect publish call back result:" + JSON.stringify(err)); + } + } + + onDisconnect() { + console.info("[Demo] AccessibilityExtAbility onDisconnect"); + let commonEventPublishData = { + data: 'disconnect' + } + commonEvent.publish('onConnectState', commonEventPublishData, publishCallback); + + function publishCallback(err) { + console.info("onDisconnect====>onConnect publish call back result:" + JSON.stringify(err)); + } + + this.tester.clear(); + this.tester = undefined; + } + + onAccessibilityEvent(accessibilityEvent) { + console.info("[Demo] AccessibilityExtAbility onAccessibilityEvent: " + accessibilityEvent.eventType); + } +} + +export default AccessibilityExtAbility; \ No newline at end of file diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/AccessibilityExtAbility/ExtensionContextTest.ts b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/AccessibilityExtAbility/ExtensionContextTest.ts new file mode 100644 index 0000000000000000000000000000000000000000..353014df7a40913c46744baa2bd867418b0dbea4 --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/AccessibilityExtAbility/ExtensionContextTest.ts @@ -0,0 +1,156 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import commonEvent from '@ohos.commonEvent'; +import display from '@ohos.display' +import { GesturePath } from '@ohos.accessibility.GesturePath'; +import { GesturePoint } from '@ohos.accessibility.GesturePoint'; + +export class ExtensionContextTest { + private context = undefined; + private subScriber = undefined; + + constructor(context) { + this.context = context; + } + + async init() { + this.subScriber = await commonEvent.createSubscriber({events: ['caseExecute']}); + commonEvent.subscribe(this.subScriber, (err, data) => { + console.info('ExtensionContextTest subscribe callback data:' + JSON.stringify(data)); + this.processCase(data.data); + }); + } + + clear() { + commonEvent.unsubscribe(this.subScriber); + this.subScriber = undefined; + this.context = undefined; + } + + private publishCaseResult(caseName: string, result: boolean) { + let commonEventPublishData = { + data: (result ? 'pass' : 'fail'), + parameters: { + case: caseName + } + } + commonEvent.publish('caseResult', commonEventPublishData, (err) => { + console.info("ExtensionContextTest publishCaseResult finish: " + JSON.stringify(commonEventPublishData)); + }); + } + + private async processCase(caseName) { + console.info('ExtensionContextTest processCase: ' + caseName); + let gesturePath; + + switch (caseName) { + case 'ActsAccessibilityExtensionContextCapErrCodeTest_getFocusElement_asyncCallback_0100': + this.getFocusElementByTypeCallback(caseName); + break; + case 'ActsAccessibilityExtensionContextCapErrCodeTest_getWindowRootElement_asyncCallback_0200': + this.getWindowRootElementCallback(caseName); + break; + case 'ActsAccessibilityExtensionContextCapErrCodeTest_getWindows_Callback_0300': + this.getWindowsCallback(caseName); + break; + case 'ActsAccessibilityExtensionContextCapErrCodeTest_gestureInject_asyncCallback_0400': + gesturePath = new GesturePath(60000); + gesturePath.points.push(new GesturePoint(50, 50), + new GesturePoint(100, 100), + new GesturePoint(1000, 1000)); + this.gestureInjectCallback(caseName, gesturePath); + break; + case 'ActsAccessibilityExtensionContextCapErrCodeTest_gestureInject_asyncCallback_0500': + gesturePath = new GesturePath(60000); + gesturePath.points.push(new GesturePoint(50, 50)); + this.gestureInjectPromise(caseName, gesturePath); + break; + default: + console.warn('ExtensionContextTest processCase unknown!!!!!!!!!!'); + break; + } + } + + private async getFocusElementByTypeCallback(caseName: string) { + let result = false; + this.context.getFocusElement(async (err, res) => { + if (err && err.code != 0) { + console.error(caseName + "err: " + JSON.stringify(err.code)); + if (err.code == 9300003) { + result = true; + } + } + this.publishCaseResult(caseName, result); + }); + } + + private async getWindowRootElementCallback(caseName: string) { + let result = false; + this.context.getWindowRootElement(async (err, res) => { + console.info(caseName + " res: " + JSON.stringify(res)); + if (err && err.code != 0) { + console.error(caseName + " err: " + JSON.stringify(err.code)); + if (err.code == 9300003) { + result = true; + } + } + this.publishCaseResult(caseName, result); + }); + } + + private async getWindowsCallback(caseName: string) { + let result = false; + this.context.getWindows((err, res) => { + console.info(caseName + " res: " + JSON.stringify(res)); + if (err && err.code != 0) { + console.error(caseName + " err: " + JSON.stringify(err.code)); + if (err.code == 9300003) { + result = true; + } + } + this.publishCaseResult(caseName, result); + }); + } + + private async gestureInjectCallback(caseName: string, gesturePath: object) { + let result = false; + this.context.injectGesture(gesturePath, (err, res) => { + console.info(caseName + " res: " + JSON.stringify(res)); + if (err && err.code != 0) { + console.error(caseName + " err: " + JSON.stringify(err.code)); + if (err.code == 9300003) { + result = true; + } + } + this.publishCaseResult(caseName, result); + }); + } + + private async gestureInjectPromise(caseName: string, gesturePath: object) { + let result = false; + this.context.injectGesture(gesturePath).then((res) => { + console.info(caseName + "err"); + this.publishCaseResult(caseName, result); + }).catch ((err) => { + if (err && err.code != 0) { + console.error(caseName + " err: " + JSON.stringify(err.code)); + if (err.code == 9300003) { + result = true; + } + } + this.publishCaseResult(caseName, result); + }); + } +} diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/Application/AbilityStage.ts b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/Application/AbilityStage.ts new file mode 100644 index 0000000000000000000000000000000000000000..8a1acf6be6bc92e41cb9001dce17015877b7b36c --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/Application/AbilityStage.ts @@ -0,0 +1,7 @@ +import AbilityStage from "@ohos.application.AbilityStage" + +export default class MyAbilityStage extends AbilityStage { + onCreate() { + console.log("[Demo] MyAbilityStage onCreate") + } +} \ No newline at end of file diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/MainAbility/MainAbility.ts b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/MainAbility/MainAbility.ts new file mode 100644 index 0000000000000000000000000000000000000000..40427aad12dce08c70cf7f161e73b7d81c3f5377 --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/MainAbility/MainAbility.ts @@ -0,0 +1,47 @@ +import Ability from '@ohos.application.Ability' +import AbilityDelegatorRegistry from '@ohos.application.abilityDelegatorRegistry' +import { Hypium } from '@ohos/hypium' +import testsuite from '../test/List.test' + +export default class MainAbility extends Ability { + onCreate(want,launchParam){ + // Ability is creating, initialize resources for this ability + console.log("[Demo] MainAbility onCreate") + globalThis.abilityWant = want; + var abilityDelegator: any + abilityDelegator = AbilityDelegatorRegistry.getAbilityDelegator() + var abilityDelegatorArguments: any + abilityDelegatorArguments = AbilityDelegatorRegistry.getArguments() + console.info('start run testcase!!!') + Hypium.hypiumTest(abilityDelegator, abilityDelegatorArguments, testsuite) + } + + onDestroy() { + // Ability is destroying, release resources for this ability + console.log("[Demo] MainAbility onDestroy") + } + + onWindowStageCreate(windowStage) { + // Main window is created, set main page for this ability + console.log("[Demo] MainAbility onWindowStageCreate windowStage="+ windowStage) + //globalThis.windowStage = windowStage + //globalThis.abilityStorage = this.storage + globalThis.abilityContext = this.context + windowStage.setUIContent(this.context, "MainAbility/pages/index/index", null) + } + + onWindowStageDestroy() { + //Main window is destroyed, release UI related resources + console.log("[Demo] MainAbility onWindowStageDestroy") + } + + onForeground() { + // Ability has brought to foreground + console.log("[Demo] MainAbility onForeground") + } + + onBackground() { + // Ability has back to background + console.log("[Demo] MainAbility onBackground") + } +}; diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/MainAbility/pages/index/index.ets b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/MainAbility/pages/index/index.ets new file mode 100644 index 0000000000000000000000000000000000000000..34d783925cf411d04cffd8433ee6d3a2388a1d45 --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/MainAbility/pages/index/index.ets @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import file from '@system.file'; + +@Entry +@Component +struct Index { + @State message: string = 'accessibility ExtensionContext'; + + aboutToAppear(){ + console.info("start run testcase!!!!"); + } + + build() { + Row() { + Column() { + Text(this.message) + .fontSize(50) + .fontWeight(FontWeight.Bold) + .margin({bottom: 10}) + + Row() { + Button('left') + Button('button1') + .margin({ + left: 10, + right: 10 + }) + Button('right') + } + .margin({bottom: 10}) + + Button('button2') + .margin({bottom: 10}) + + Button('button3') + .margin({bottom: 10}) + } + .width('100%') + } + .height('100%') + } +} \ No newline at end of file diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/TestAbility/TestAbility.ts b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/TestAbility/TestAbility.ts new file mode 100644 index 0000000000000000000000000000000000000000..75889c25d1d74af950262f3fd26da4d1cc3e4aa1 --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/TestAbility/TestAbility.ts @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import Ability from '@ohos.application.Ability' + +export default class TestAbility extends Ability { + onCreate(want, launchParam) { + console.log('TestAbility onCreate') + } + + onDestroy() { + console.log('TestAbility onDestroy') + } + + onWindowStageCreate(windowStage) { + console.log('TestAbility onWindowStageCreate') + windowStage.loadContent("TestAbility/pages/index", (err, data) => { + if (err.code) { + console.error('Failed to load the content. Cause:' + JSON.stringify(err)); + return; + } + console.info('Succeeded in loading the content. Data: ' + JSON.stringify(data)) + }); + + globalThis.abilityContext = this.context; + } + + onWindowStageDestroy() { + console.log('TestAbility onWindowStageDestroy') + } + + onForeground() { + console.log('TestAbility onForeground') + } + + onBackground() { + console.log('TestAbility onBackground') + } +}; \ No newline at end of file diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/TestAbility/pages/index.ets b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/TestAbility/pages/index.ets new file mode 100644 index 0000000000000000000000000000000000000000..e29d33fb1f74914762edf3a6b3abc01b92299ad3 --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/TestAbility/pages/index.ets @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import router from '@ohos.router'; + +@Entry +@Component +struct Index { + aboutToAppear() { + console.info('TestAbility index aboutToAppear') + } + @State message: string = 'Hello World' + build() { + Row() { + Column() { + Text(this.message) + .fontSize(50) + .fontWeight(FontWeight.Bold) + Button() { + Text('next page') + .fontSize(20) + .fontWeight(FontWeight.Bold) + }.type(ButtonType.Capsule) + .margin({ + top: 20 + }) + .backgroundColor('#0D9FFB') + .width('35%') + .height('5%') + .onClick(()=>{ + }) + } + .width('100%') + } + .height('100%') + } + } \ No newline at end of file diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/TestRunner/OpenHarmonyTestRunner.ts b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/TestRunner/OpenHarmonyTestRunner.ts new file mode 100644 index 0000000000000000000000000000000000000000..3e708867dfc5e6468c598957128791fa5328c99c --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/TestRunner/OpenHarmonyTestRunner.ts @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import TestRunner from '@ohos.application.testRunner' +import AbilityDelegatorRegistry from '@ohos.application.abilityDelegatorRegistry' + +var abilityDelegator = undefined +var abilityDelegatorArguments = undefined + +function translateParamsToString(parameters) { + const keySet = new Set([ + '-s class', '-s notClass', '-s suite', '-s it', + '-s level', '-s testType', '-s size', '-s timeout', + '-s dryRun' + ]) + let targetParams = ''; + for (const key in parameters) { + if (keySet.has(key)) { + targetParams = `${targetParams} ${key} ${parameters[key]}` + } + } + return targetParams.trim() +} + +async function onAbilityCreateCallback() { + console.log("onAbilityCreateCallback"); +} + +async function addAbilityMonitorCallback(err: any) { + console.info("addAbilityMonitorCallback : " + JSON.stringify(err)) +} + +export default class OpenHarmonyTestRunner implements TestRunner { + constructor() { + } + + onPrepare() { + console.info("OpenHarmonyTestRunner OnPrepare ") + } + + async onRun() { + console.log('OpenHarmonyTestRunner onRun run') + abilityDelegatorArguments = AbilityDelegatorRegistry.getArguments() + abilityDelegator = AbilityDelegatorRegistry.getAbilityDelegator() + var testAbilityName = abilityDelegatorArguments.bundleName + '.MainAbility' + let lMonitor = { + abilityName: testAbilityName, + onAbilityCreate: onAbilityCreateCallback, + }; + abilityDelegator.addAbilityMonitor(lMonitor, addAbilityMonitorCallback) + var cmd = 'aa start -d 0 -a com.example.accessibilityxts.MainAbility' + ' -b ' + abilityDelegatorArguments.bundleName + cmd += ' '+translateParamsToString(abilityDelegatorArguments.parameters) + var debug = abilityDelegatorArguments.parameters["-D"] + if (debug == 'true') + { + cmd += ' -D' + } + console.info('cmd : '+cmd) + abilityDelegator.executeShellCommand(cmd, + (err: any, d: any) => { + console.info('executeShellCommand : err : ' + JSON.stringify(err)); + console.info('executeShellCommand : data : ' + d.stdResult); + console.info('executeShellCommand : data : ' + d.exitCode); + }) + console.info('OpenHarmonyTestRunner onRun end') + } +}; \ No newline at end of file diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/test/AccessibilityExtensionContextCapErrCode.test.ets b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/test/AccessibilityExtensionContextCapErrCode.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..daa188569682bc63af85cdb47fe0673718a5bf5e --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/test/AccessibilityExtensionContextCapErrCode.test.ets @@ -0,0 +1,246 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from "@ohos/hypium" +import commonEvent from '@ohos.commonEvent' +import config from '@ohos.accessibility.config' + +const passStr = 'pass'; +const failStr = 'fail'; + +function publishCaseExecute(caseName: string) { + let commonEventPublishData = { + data: caseName + } + + commonEvent.publish('caseExecute', commonEventPublishData, (err) => { + console.info('caseExecute publish [' + caseName + '] callback result: ' + JSON.stringify(err)); + }); +} + +export default function abilityTest() { + describe('AccessibilityExtensionContextCapErrCodeTest', function () { + let subScriber = undefined; + let isConnect = false; + let caseResult = undefined; + + beforeAll(async function (done) { + console.info('AccessibilityExtensionContextCapErrCodeTest: beforeAll'); + subScriber = await commonEvent.createSubscriber({events: ['onConnectState', 'caseResult']}); + commonEvent.subscribe(subScriber, (err, data) => { + console.info('AccessibilityExtensionContextCapErrCodeTest beforeAll data:' + JSON.stringify(data) ); + if (data.data == 'connect') { + isConnect = true; + } else if (data.data == 'disconnect') { + isConnect = false; + } else if (data.data == passStr || data.data == failStr) { + caseResult = data; + } + }); + + config.enableAbility('com.example.accessibilityxts/AccessibilityExtAbility', + ["keyEventObserver"] + ).then(() => { + console.info(`AccessibilityExtensionContextCapErrCodeTest enableAbility: then`); + }).catch((err) => { + console.error(`AccessibilityExtensionContextCapErrCodeTest enableAbility has error: ${err.code}`); + }); + + setTimeout(done, 5000); + }) + + afterAll(async function (done) { + console.info('AccessibilityExtensionContextCapErrCodeTest: afterAll'); + commonEvent.unsubscribe(subScriber); + isConnect = false; + config.disableAbility('com.example.accessibilityxts/AccessibilityExtAbility').then(() => { + console.info(`AccessibilityExtensionContextCapErrCodeTest disableAbility: then`); + }).catch((err) => { + console.error(`AccessibilityExtensionContextCapErrCodeTest disableAbility has error: ${err.code}`); + }); + setTimeout(done, 5000); + }) + + beforeEach(async function (done) { + console.info('AccessibilityExtensionContextCapErrCodeTest: beforeEach'); + caseResult = undefined; + done(); + }) + + afterEach(async function (done) { + console.info('AccessibilityExtensionContextCapErrCodeTest: afterEach'); + done(); + }) + + /* + * @tc.number ActsAccessibilityExtensionContextCapErrCodeTest_getFocusElement_asyncCallback_0100 + * @tc.name ActsAccessibilityExtensionContextCapErrCodeTest_getFocusElement_asyncCallback_0100 + * @tc.desc No right accessibility so result of getFocusElement() should return errCode. + * @tc.size SmallTest + * @tc.type User + */ + it('ActsAccessibilityExtensionContextCapErrCodeTest_getFocusElement_asyncCallback_0100', 0, async function (done) { + let caseName = 'ActsAccessibilityExtensionContextCapErrCodeTest_getFocusElement_asyncCallback_0100'; + console.info(caseName + 'start'); + + if (isConnect) { + publishCaseExecute(caseName); + + setTimeout(() => { + if (caseResult != undefined) { + console.info(caseName + ':' + caseResult.data); + expect(passStr).assertEqual(caseResult.data); + expect(caseName).assertEqual(caseResult.parameters.case); + } else { + console.info(caseName + ': caseResult is undefined'); + expect(null).assertFail(); + } + done(); + }, 5500); + } else { + console.error(caseName + ': extension not connected'); + expect(null).assertFail(); + done(); + } + }) + + /* + * @tc.number ActsAccessibilityExtensionContextCapErrCodeTest_getWindowRootElement_asyncCallback_0200 + * @tc.name ActsAccessibilityExtensionContextCapErrCodeTest_getWindowRootElement_asyncCallback_0200 + * @tc.desc No right accessibility so result of getWindowRootElement() should return errCode. + * @tc.size SmallTest + * @tc.type User + */ + it('ActsAccessibilityExtensionContextCapErrCodeTest_getWindowRootElement_asyncCallback_0200', 0, async function (done) { + let caseName = 'ActsAccessibilityExtensionContextCapErrCodeTest_getWindowRootElement_asyncCallback_0200'; + console.info(caseName + 'start'); + + if (isConnect) { + publishCaseExecute(caseName); + + setTimeout(() => { + if (caseResult != undefined) { + console.info(caseName + ':' + caseResult.data); + expect(passStr).assertEqual(caseResult.data); + expect(caseName).assertEqual(caseResult.parameters.case); + } else { + console.info(caseName + ': caseResult is undefined'); + expect(null).assertFail(); + } + done(); + }, 5500); + } else { + console.error(caseName + ': extension not connected'); + expect(null).assertFail(); + done(); + } + }) + + /* + * @tc.number ActsAccessibilityExtensionContextCapErrCodeTest_getWindows_Callback_0300 + * @tc.name ActsAccessibilityExtensionContextCapErrCodeTest_getWindows_Callback_0300 + * @tc.desc No right accessibility so result of getWindows should return errCode. + * @tc.size SmallTest + * @tc.type User + */ + it('ActsAccessibilityExtensionContextCapErrCodeTest_getWindows_Callback_0300', 0, async function (done) { + let caseName = 'ActsAccessibilityExtensionContextCapErrCodeTest_getWindows_Callback_0300'; + console.info(caseName + 'start'); + + if (isConnect) { + publishCaseExecute(caseName); + + setTimeout(() => { + if (caseResult != undefined) { + console.info(caseName + ':' + caseResult.data); + expect(passStr).assertEqual(caseResult.data); + expect(caseName).assertEqual(caseResult.parameters.case); + } else { + console.info(caseName + ': caseResult is undefined'); + expect(null).assertFail(); + } + done(); + }, 5500); + } else { + console.error(caseName + ': extension not connected'); + expect(null).assertFail(); + done(); + } + }) + + /* + * @tc.number ActsAccessibilityExtensionContextCapErrCodeTest_gestureInject_asyncCallback_0400 + * @tc.name ActsAccessibilityExtensionContextCapErrCodeTest_gestureInject_asyncCallback_0400 + * @tc.desc No right accessibility so result of injectGesture() should return errCode. + * @tc.size SmallTest + * @tc.type User + */ + it('ActsAccessibilityExtensionContextCapErrCodeTest_gestureInject_asyncCallback_0400', 0, async function(done) { + let caseName = 'ActsAccessibilityExtensionContextCapErrCodeTest_gestureInject_asyncCallback_0400'; + console.info(caseName + 'start'); + + if (isConnect) { + publishCaseExecute(caseName); + + setTimeout(() => { + if (caseResult != undefined) { + console.info(caseName + ':' + caseResult.data); + expect(passStr).assertEqual(caseResult.data); + expect(caseName).assertEqual(caseResult.parameters.case); + } else { + console.info(caseName + ': caseResult is undefined'); + expect(null).assertFail(); + } + done(); + }, 3000); + } else { + console.error(caseName + ': extension not connected'); + expect(null).assertFail(); + done(); + } + }) + + /* + * @tc.number ActsAccessibilityExtensionContextCapErrCodeTest_gestureInject_asyncCallback_0500 + * @tc.name ActsAccessibilityExtensionContextCapErrCodeTest_gestureInject_asyncCallback_0500 + * @tc.desc No right accessibility so result of injectGesture() should return errCode. + * @tc.size SmallTest + * @tc.type User + */ + it('ActsAccessibilityExtensionContextCapErrCodeTest_gestureInject_asyncCallback_0500', 0, async function (done) { + let caseName = 'ActsAccessibilityExtensionContextCapErrCodeTest_gestureInject_asyncCallback_0500'; + console.info(caseName + 'start'); + + if (isConnect) { + publishCaseExecute(caseName); + + setTimeout(() => { + if (caseResult != undefined) { + console.info(caseName + ':' + caseResult.data); + expect(passStr).assertEqual(caseResult.data); + expect(caseName).assertEqual(caseResult.parameters.case); + } else { + console.info(caseName + ': caseResult is undefined'); + expect(null).assertFail(); + } + done(); + }, 3000); + } else { + console.error(caseName + ': extension not connected'); + expect(null).assertFail(); + done(); + } + }) + }) +} diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/test/List.test.ets b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/test/List.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..67cb69058a0a998f9c148f2b28b329bc919a8e74 --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/ets/test/List.test.ets @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import abilityTest from './AccessibilityExtensionContextCapErrCode.test.ets' + +export default function testsuite() { + abilityTest() +} diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/module.json b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/module.json new file mode 100644 index 0000000000000000000000000000000000000000..ec9da52952d10dc0c7c72bf4108efa6d86891441 --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/module.json @@ -0,0 +1,62 @@ +{ + "module": { + "name": "phone", + "type": "entry", + "srcEntrance": "./ets/Application/AbilityStage.ts", + "description": "$string:phone_entry_dsc", + "mainElement": "MainAbility", + "deviceTypes": [ + "default", + "phone" + ], + "deliveryWithInstall": true, + "installationFree": false, + "uiSyntax": "ets", + "pages": "$profile:main_pages", + "abilities": [{ + "name": "com.example.accessibilityxts.MainAbility", + "srcEntrance": "./ets/MainAbility/MainAbility.ts", + "description": "$string:phone_entry_main", + "icon": "$media:icon", + "label": "$string:entry_label", + "visible": true, + "orientation": "portrait", + "skills": [{ + "actions": [ + "action.system.home" + ], + "entities": [ + "entity.system.home" + ] + }] + }], + "extensionAbilities": [ + { + "name": "AccessibilityExtAbility", + "srcEntrance": "./ets/AccessibilityExtAbility/AccessibilityExtAbility.ts", + "label": "$string:Accessibility_label", + "description": "$string:Accessibility_desc", + "type": "accessibility", + "metadata": [ + { + "name": "ohos.accessibleability", + "resource": "$profile:accessibility_config" + } + ], + "permissions": ["ohos.permission.GET_BUNDLE_INFO"] + }], + "requestPermissions": [{ + "name": "ohos.permission.SYSTEM_FLOAT_WINDOW", + "reason": "need use ohos.permission.SYSTEM_FLOAT_WINDOW" + }, + { + "name": "ohos.permission.CAPTURE_SCREEN", + "reason": "need use ohos.permission.SYSTEM_FLOAT_WINDOW" + }, + { + "name": "ohos.permission.WRITE_ACCESSIBILITY_CONFIG", + "reason": "need use ohos.permission.WRITE_ACCESSIBILITY_CONFIG" + } + ] + } +} \ No newline at end of file diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/resources/base/element/string.json b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/resources/base/element/string.json new file mode 100644 index 0000000000000000000000000000000000000000..caccebe85978bae1eaa236f53d98dc3fbbaa3923 --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/resources/base/element/string.json @@ -0,0 +1,40 @@ +{ + "string": [ + { + "name": "phone_entry_dsc", + "value": "i am an entry for phone" + }, + { + "name": "phone_entry_main", + "value": "the phone entry ability" + }, + { + "name": "entry_label", + "value": "ActsAccessibilityExtensionTest" + }, + { + "name": "form_description", + "value": "my form" + }, + { + "name": "serviceability_description", + "value": "my whether" + }, + { + "name": "description_application", + "value": "demo for test" + }, + { + "name": "app_name", + "value": "Demo" + }, + { + "name": "Accessibility_desc", + "value": "accessibility_description" + }, + { + "name": "Accessibility_label", + "value": "accessibility_label" + } + ] +} \ No newline at end of file diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/resources/base/media/icon.png b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/resources/base/media/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..474a55588fd7216113dd42073aadf254d4dba023 Binary files /dev/null and b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/resources/base/media/icon.png differ diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/resources/base/profile/accessibility_config.json b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/resources/base/profile/accessibility_config.json new file mode 100644 index 0000000000000000000000000000000000000000..2f3254e67c36efee5db1d6c9e07007e6fff857ad --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/resources/base/profile/accessibility_config.json @@ -0,0 +1,7 @@ +{ + "accessibilityCapabilities": [ + "keyEventObserver" + ], + "accessibilityCapabilityRationale": "a11y_rationale", + "settingsAbility": "com.accessibility.voiceaid.voiceAidSetting" +} \ No newline at end of file diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/resources/base/profile/main_pages.json b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/resources/base/profile/main_pages.json new file mode 100644 index 0000000000000000000000000000000000000000..74b7ae57500e97c7962acdf33124b86a0d5d3d17 --- /dev/null +++ b/barrierfree/accessibilityextensioncontextcaperrcode/entry/src/main/resources/base/profile/main_pages.json @@ -0,0 +1,5 @@ +{ + "src": [ + "MainAbility/pages/index/index" + ] +} diff --git a/barrierfree/accessibilityextensioncontextcaperrcode/signature/openharmony_sx.p7b b/barrierfree/accessibilityextensioncontextcaperrcode/signature/openharmony_sx.p7b new file mode 100644 index 0000000000000000000000000000000000000000..7ffcdc78527c5c1aa24520ab7e913c5f47c703f0 Binary files /dev/null and b/barrierfree/accessibilityextensioncontextcaperrcode/signature/openharmony_sx.p7b differ diff --git a/barrierfree/accessibilitysendaccessibilityevent/entry/src/main/ets/test/AccessibilitySendAccessibilityEvent.test.ets b/barrierfree/accessibilitysendaccessibilityevent/entry/src/main/ets/test/AccessibilitySendAccessibilityEvent.test.ets index 82c831b785349cfb0516424ca8f2215a0ab4fabf..db9da2cff5399932f230f499c1e072b81c4faaa6 100644 --- a/barrierfree/accessibilitysendaccessibilityevent/entry/src/main/ets/test/AccessibilitySendAccessibilityEvent.test.ets +++ b/barrierfree/accessibilitysendaccessibilityevent/entry/src/main/ets/test/AccessibilitySendAccessibilityEvent.test.ets @@ -34,31 +34,6 @@ export default function abilityTest() { setTimeout(done, 1000); }) - /* - * @tc.number SendAccessibilityEvent_null_0200 - * @tc.name SendAccessibilityEvent_null_0200 - * @tc.desc The parameter input is null, test the sendAccessibilityEvent() function - * The result of sendAccessibilityEvent() should be equal to a rejected promise of 401 err. - * @tc.size SmallTest - * @tc.type User - */ - it('SendAccessibilityEvent_null_0200', 0, async function (done) { - console.info('SendAccessibilityEvent_null_0200'); - let event = null; - - accessibility.sendAccessibilityEvent(event).then((result) => { - console.error(`AccessibilitySendAccessibilityEvent: SendAccessibilityEvent_null_0200 result ${result}`); - expect(null).assertFail(); - done(); - }).catch((err) => { - if (err && err.code != 0) { - console.info(`AccessibilitySendAccessibilityEvent: SendAccessibilityEvent_null_0200 has error: ${err}`); - expect(true).assertTrue(); - done(); - } - }); - }) - /* * @tc.number SendAccessibilityEvent_0300 * @tc.name SendAccessibilityEvent_0300 diff --git a/barrierfree/accessibleregisterstate/src/main/js/test/AccessibleRegisterState.test.js b/barrierfree/accessibleregisterstate/src/main/js/test/AccessibleRegisterState.test.js index a52e49f847f477b455858530e76de7aaaa903806..2747898c92582164ab9796d1ad7d8b72f527956a 100644 --- a/barrierfree/accessibleregisterstate/src/main/js/test/AccessibleRegisterState.test.js +++ b/barrierfree/accessibleregisterstate/src/main/js/test/AccessibleRegisterState.test.js @@ -68,38 +68,6 @@ describe('AccessibleRegisterState', function () { done(); }) - /* - * @tc.number RegisterStateOnOff_0350 - * @tc.name RegisterStateOnOff_0350 - * @tc.desc The parameter input is '', test the accessibility.on() function, - * and return void. - * @tc.size SmallTest - * @tc.type User - */ - it('RegisterStateOnOff_0350', 0, async function (done) { - console.info('RegisterStateOnOff_0350'); - let stateEventType = ''; - let ret = accessibility.on(stateEventType, (data) => {}); - expect(ret).assertEqual(undefined); - done(); - }) - - /* - * @tc.number RegisterStateOnOff_0360 - * @tc.name RegisterStateOnOff_0360 - * @tc.desc The parameter input is null, test the accessibility.on() function, - * and return void. - * @tc.size SmallTest - * @tc.type User - */ - it('RegisterStateOnOff_0360', 0, async function (done) { - console.info('RegisterStateOnOff_0360'); - let stateEventType = null; - let ret = accessibility.on(stateEventType, (data) => {}); - expect(ret).assertEqual(undefined); - done(); - }) - /******************************************************************************** */ /* Cases RegisterStateOnOff_0370-0410 are for accessibility.off() API test */ /******************************************************************************** */ @@ -135,54 +103,6 @@ describe('AccessibleRegisterState', function () { expect(ret).assertEqual(undefined); done(); }) - - /* - * @tc.number RegisterStateOnOff_0390 - * @tc.name RegisterStateOnOff_0390 - * @tc.desc The parameter input is '', test the accessibility.off() function, - * and return void. - * @tc.size SmallTest - * @tc.type User - */ - it('RegisterStateOnOff_0390', 0, async function (done) { - console.info('RegisterStateOnOff_0390'); - let stateEventType = ''; - let ret = accessibility.off(stateEventType, (data) => {}); - expect(ret).assertEqual(undefined); - done(); - }) - - /* - * @tc.number RegisterStateOnOff_0400 - * @tc.name RegisterStateOnOff_0400 - * @tc.desc The parameter input is null, test the accessibility.off() function, - * and return void. - * @tc.size SmallTest - * @tc.type User - */ - it('RegisterStateOnOff_0400', 0, async function (done) { - console.info('RegisterStateOnOff_0400'); - let stateEventType = null; - let ret = accessibility.off(stateEventType, (data) => {}); - expect(ret).assertEqual(undefined); - done(); - }) - - /* - * @tc.number RegisterStateOnOff_0410 - * @tc.name RegisterStateOnOff_0410 - * @tc.desc The parameter input is null, test the accessibility.off() function, - * and return void. - * @tc.size SmallTest - * @tc.type User - */ - it('RegisterStateOnOff_0410', 0, async function (done) { - console.info('RegisterStateOnOff_0410'); - let stateEventType = null; - let ret = accessibility.off(stateEventType, (data) => {}); - expect(ret).assertEqual(undefined); - done(); - }) }) }