diff --git a/ability/ability_runtime/stage/BUILD.gn b/ability/ability_runtime/stage/BUILD.gn index 6e32bc095fce9dbe25cee5f4766623091c0b723d..269205519b4c26bcf924f4e033e81ed6c640140d 100644 --- a/ability/ability_runtime/stage/BUILD.gn +++ b/ability/ability_runtime/stage/BUILD.gn @@ -17,6 +17,7 @@ group("stage") { testonly = true if (is_standard_system) { deps = [ + "actsdebuggabletest:actsdebuggabletest", "actslifecyclemultihap2:ActsLifecycleMultiHap2", "actslifecyclemultihap3:ActsLifecycleMultiHap3", "actslifecyclemultihaptest:ActsLifecycleMultiHapTest", diff --git a/ability/ability_runtime/stage/actsdebuggabletest/BUILD.gn b/ability/ability_runtime/stage/actsdebuggabletest/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..47069d80491117b401c37c5b4fff7d777980122c --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/BUILD.gn @@ -0,0 +1,24 @@ +# Copyright (c) 2023 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") + +group("actsdebuggabletest") { + testonly = true + if (is_standard_system) { + deps = [ + "actsdebuggabletest:ActsDebuggableTest", + "timeout:ActsDebuggableTimeout", + ] + } +} diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/AppScope/app.json b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/AppScope/app.json new file mode 100644 index 0000000000000000000000000000000000000000..adb4358fc8b0c1e73b73179f354d1b54975e486a --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/AppScope/app.json @@ -0,0 +1,19 @@ +{ + "app": { + "bundleName": "com.example.debuggable", + "vendor": "example", + "versionCode": 1000000, + "versionName": "1.0.0", + "icon": "$media:app_icon", + "label": "$string:app_name", + "distributedNotificationEnabled": true, + "keepAlive": true, + "singleUser": true, + "minAPIVersion": 9, + "targetAPIVersion": 9, + "car": { + "apiCompatibleVersion": 9, + "singleUser": false + } + } +} diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/AppScope/resources/base/element/string.json b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/AppScope/resources/base/element/string.json new file mode 100644 index 0000000000000000000000000000000000000000..f7ce431a94839af9c529e54c0c031b237b233811 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/AppScope/resources/base/element/string.json @@ -0,0 +1,8 @@ +{ + "string": [ + { + "name": "app_name", + "value": "Debuggable" + } + ] +} diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/AppScope/resources/base/media/app_icon.png b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/AppScope/resources/base/media/app_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..ce307a8827bd75456441ceb57d530e4c8d45d36c Binary files /dev/null and b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/AppScope/resources/base/media/app_icon.png differ diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/BUILD.gn b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..862d0629e15f2b8d74ed1dfdfb094083655a745c --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/BUILD.gn @@ -0,0 +1,43 @@ +# Copyright (c) 2023 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("ActsDebuggableTest") { + hap_profile = "entry/src/main/module.json" + js_build_mode = "debug" + deps = [ + ":actsdebuggabletest_js_assets", + ":actsdebuggabletest_resources", + ] + ets2abc = true + certificate_profile = "signature/openharmony_sx.p7b" + hap_name = "ActsDebuggableTest" + subsystem_name = "ability" + part_name = "ability_runtime" +} + +ohos_app_scope("actsdebuggabletest_app_profile") { + app_profile = "AppScope/app.json" + sources = [ "AppScope/resources" ] +} + +ohos_js_assets("actsdebuggabletest_js_assets") { + source_dir = "entry/src/main/ets" +} + +ohos_resources("actsdebuggabletest_resources") { + sources = [ "entry/src/main/resources" ] + deps = [ ":actsdebuggabletest_app_profile" ] + hap_profile = "entry/src/main/module.json" +} diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/Test.json b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/Test.json new file mode 100644 index 0000000000000000000000000000000000000000..67e3714e2769efdfe44e070e822c91e5804592be --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/Test.json @@ -0,0 +1,33 @@ +{ + "description": "Configuration for debuggable demo Tests", + "driver": { + "type": "OHJSUnitTest", + "test-timeout": "180000", + "bundle-name": "com.example.debuggable", + "module-name": "entry", + "shell-timeout": "600000", + "testcase-timeout": 15000 + }, + "kits": [ + { + "test-file-name": [ + "ActsDebuggableTest.hap", + "ActsDebuggableTimeout.hap" + ], + "type": "AppInstallKit", + "cleanup-apps": true + }, + { + "type": "ShellKit", + "run-command": [ + "power-shell wakeup", + "power-shell setmode 602", + "uinput -T -d 300 600 -m 300 600 300 100 -u 300 100", + "hilog -b D", + "hilog -Q pidoff", + "hilog -Q domainoff", + "hilog -G 2M" + ] + } + ] +} diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/TestRunner/OpenHarmonyTestRunner.ts b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/TestRunner/OpenHarmonyTestRunner.ts new file mode 100644 index 0000000000000000000000000000000000000000..188fd9a8436db816bad79ac18d88724b7033c48b --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/TestRunner/OpenHarmonyTestRunner.ts @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2023 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 hilog from '@ohos.hilog'; +import TestRunner from '@ohos.application.testRunner'; +import AbilityDelegatorRegistry from '@ohos.app.ability.abilityDelegatorRegistry'; + +let abilityDelegator = undefined; +let 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() { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'onAbilityCreateCallback'); +} + +async function addAbilityMonitorCallback(err: any) { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', 'addAbilityMonitorCallback : %{public}s', JSON.stringify(err) ?? ''); +} + +export default class OpenHarmonyTestRunner implements TestRunner { + constructor() { + } + + onPrepare() { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'OpenHarmonyTestRunner OnPrepare '); + } + + async onRun() { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'OpenHarmonyTestRunner onRun run'); + abilityDelegatorArguments = AbilityDelegatorRegistry.getArguments(); + abilityDelegator = AbilityDelegatorRegistry.getAbilityDelegator(); + let testAbilityName = abilityDelegatorArguments.bundleName + '.TestAbility'; + let lMonitor = { + abilityName: testAbilityName, + onAbilityCreate: onAbilityCreateCallback, + }; + abilityDelegator.addAbilityMonitor(lMonitor, addAbilityMonitorCallback); + let cmd = 'aa start -d 0 -a TestAbility' + ' -b ' + abilityDelegatorArguments.bundleName; + cmd += ' ' + translateParamsToString(abilityDelegatorArguments.parameters); + let debug = abilityDelegatorArguments.parameters['-D']; + if (debug === 'true') + { + cmd += ' -D'; + } + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', 'cmd : %{public}s', cmd); + abilityDelegator.executeShellCommand(cmd, + (err, d) => { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', 'executeShellCommand : err : %{public}s', JSON.stringify(err) ?? ''); + hilog.info(0x0000, 'testTag', 'executeShellCommand : data : %{public}s', d.stdResult ?? ''); + hilog.info(0x0000, 'testTag', 'executeShellCommand : data : %{public}s', d.exitCode ?? ''); + }); + hilog.info(0x0000, 'testTag', '%{public}s', 'OpenHarmonyTestRunner onRun end'); + } +} \ No newline at end of file diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/entryability/EntryAbility.ts b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/entryability/EntryAbility.ts new file mode 100644 index 0000000000000000000000000000000000000000..5a2ad1b43fc919610df43f64ff4f8e01b48a0d29 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/entryability/EntryAbility.ts @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2023 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 hilog from '@ohos.hilog'; +import Ability from '@ohos.app.ability.UIAbility'; +import Window from '@ohos.window'; + +export default class EntryAbility extends Ability { + onCreate(want, launchParam) { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onCreate'); + hilog.info(0x0000, 'testTag', '%{public}s', 'want param:' + JSON.stringify(want) ?? ''); + hilog.info(0x0000, 'testTag', '%{public}s', 'launchParam:' + JSON.stringify(launchParam) ?? ''); + } + + onDestroy() { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onDestroy'); + } + + onWindowStageCreate(windowStage: Window.WindowStage) { + // Main window is created, set main page for this ability + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onWindowStageCreate'); + + windowStage.loadContent('pages/Index', (err, data) => { + if (err.code) { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.ERROR); + hilog.error(0x0000, 'testTag', 'Failed to load the content. Cause: %{public}s', JSON.stringify(err) ?? ''); + return; + } + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', 'Succeeded in loading the content. Data: %{public}s', JSON.stringify(data) ?? ''); + }); + } + + onWindowStageDestroy() { + // Main window is destroyed, release UI related resources + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onWindowStageDestroy'); + } + + onForeground() { + // Ability has brought to foreground + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onForeground'); + } + + onBackground() { + // Ability has back to background + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onBackground'); + } +} diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/pages/Index.ets b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/pages/Index.ets new file mode 100644 index 0000000000000000000000000000000000000000..9fc8c2d8e4ffe7920e1d05e0e78fa713f390182e --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/pages/Index.ets @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2023 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. + */ + +@Entry +@Component +struct Index { + @State message: string = 'Hello World'; + + build() { + Row() { + Column() { + Text(this.message) + .fontSize(50) + .fontWeight(FontWeight.Bold) + + } + .width('100%') + } + .height('100%') + } +} \ No newline at end of file diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/test/ActsDebuggableAaProcessTest.test.ets b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/test/ActsDebuggableAaProcessTest.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..505d28a00924d8de83299f131bc3b10ff06f01b4 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/test/ActsDebuggableAaProcessTest.test.ets @@ -0,0 +1,664 @@ +/* + * Copyright (c) 2023 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 hilog from '@ohos.hilog'; +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium'; +import AbilityDelegatorRegistry from '@ohos.app.ability.abilityDelegatorRegistry'; +import backgroundTaskManager from '@ohos.resourceschedule.backgroundTaskManager'; + +let abilityDelegator = AbilityDelegatorRegistry.getAbilityDelegator(); + +async function requestSuspendDelay() { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'requestSuspendDelay start '); + let myReason = 'test ActsDebuggableAaProcessTest'; + let delayInfo = backgroundTaskManager.requestSuspendDelay(myReason, () => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'requestSuspendDelay delay will timeout. '); + }); + globalThis.delayId = delayInfo.requestId; + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'requestSuspendDelay delayId is ' + globalThis.delayId); + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'requestSuspendDelay actualDelayTime is ' + delayInfo.actualDelayTime); +} + +function sleep(time) { + return new Promise((resolve, reject) => { + setTimeout(() => { + resolve(null); + }, time) + }); +} + +export default function actsDebuggableAaProcessTest() { + + describe('ActsDebuggableAaProcessTest', function () { + beforeAll(async function () { + await abilityDelegator.executeShellCommand('aa start -b com.example.timeout -a EntryAbility').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'beforeAll aa start data is: ' + data.stdResult); + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'beforeAll err is: ' + JSON.stringify(err)); + }); + await sleep(2000); + await requestSuspendDelay(); + }) + + beforeEach(async function () { + await abilityDelegator.executeShellCommand('hilog -r').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'beforeEach ActsDebuggableAaProcessTest hilog -r data is: ' + JSON.stringify(data)); + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'beforeEach ActsDebuggableAaProcessTest hilog -r err is: ' + JSON.stringify(err)); + }); + await sleep(2000); + }) + + afterEach(function () { + }) + + afterAll(async function () { + await abilityDelegator.executeShellCommand('aa force-stop com.example.timeout').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'afterAll force-stop data is: ' + JSON.stringify(data)); + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'afterAll force-stop err is: ' + JSON.stringify(err)); + }); + await sleep(1000); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_0800 + * @tc.name aa process -b com.example.timeout -a EntryAbility -m entry -p 'sleep 100' -S + * @tc.desc Function test + * @tc.level 1 + */ + it('SUB_AA_AMS_Debuggable_0800', 1, async function (done) { + await abilityDelegator.executeShellCommand( + 'aa process -b com.example.timeout -a EntryAbility -m entry -p \'sleep 100\' -S').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0800 data is: ' + JSON.stringify(data)); + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0800 err is: ' + JSON.stringify(err)); + }); + await sleep(500); + + let res = undefined + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'SUB_AA_AMS_Debuggable_0800 data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0800 err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('debuggablePipe perfCmd:sleep 100'); + expect(res).assertContain('debuggablePipe sandbox: true'); + expect(res).assertContain('debuggablePipe abilityName:EntryAbility'); + expect(res).assertContain('debuggablePipe moduleName:entry'); + expect(res).assertContain('debuggablePipe bundleName:com.example.timeout'); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_0900 + * @tc.name aa process -b com.example.timeout -a EntryAbility -p 'sleep 100' -S + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_0900', 1, async function (done) { + await abilityDelegator.executeShellCommand( + 'aa process -b com.example.timeout -a EntryAbility -p \'sleep 100\' -S').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0900 data is: ' + JSON.stringify(data)); + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0900 err is: ' + JSON.stringify(err)); + }); + await sleep(500); + + let res = undefined + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0900 data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0900 err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('debuggablePipe perfCmd:sleep 100'); + expect(res).assertContain('debuggablePipe sandbox: true'); + expect(res).assertContain('debuggablePipe abilityName:EntryAbility'); + expect(res).assertContain('debuggablePipe moduleName:'); + expect(res).assertContain('debuggablePipe bundleName:com.example.timeout'); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_1000 + * @tc.name aa process -b com.example.timeout -a EntryAbility -m entry -p 'sleep 100' + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_1000', 1, async function (done) { + await abilityDelegator.executeShellCommand( + 'aa process -b com.example.timeout -a EntryAbility -m entry -p \'sleep 100\'').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1000 data is: ' + JSON.stringify(data)); + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1000 err is: ' + JSON.stringify(err)); + }); + await sleep(500); + + let res = undefined; + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'SUB_AA_AMS_Debuggable_1000 data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1000 err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('debuggablePipe perfCmd:sleep 100'); + expect(res).assertContain('debuggablePipe abilityName:EntryAbility'); + expect(res).assertContain('debuggablePipe moduleName:entry'); + expect(res).assertContain('debuggablePipe bundleName:com.example.timeout'); + expect(res.indexOf('debuggablePipe sandbox: true') > 0).assertFalse(); + done() + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_1100 + * @tc.name aa process -b com.example.timeout -a EntryAbility -m entry -S + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_1100', 1, async function (done) { + let res = undefined; + await abilityDelegator.executeShellCommand('aa process -b com.example.timeout -a EntryAbility -m entry -S') + .then(data => { + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1100 err is: ' + JSON.stringify(err)); + }) + expect(res).assertContain('usage: aa process '); + await sleep(500); + + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1100 SUB_AA_AMS_Debuggable_1100 hilog data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1100 hilog err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain( + 'debuggablePipe aa process must contains -p or -D and param length must be less than 1024.'); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_1200 + * @tc.name aa process -b com.ohos.test -a EntryAbility -m entry -p 'sleep 100' -S + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_1200', 1, async function (done) { + let res = undefined; + await abilityDelegator.executeShellCommand( + 'aa process -b com.ohos.test -a EntryAbility -m entry -p \'sleep 100\' -S').then(data => { + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'SUB_AA_AMS_Debuggable_1200 err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('error: failed to start native process.'); + await sleep(500); + + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'SUB_AA_AMS_Debuggable_1200 data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'SUB_AA_AMS_Debuggable_1200 err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('debuggablePipe abilityName:EntryAbility'); + expect(res).assertContain('debuggablePipe moduleName:entry'); + expect(res).assertContain('debuggablePipe bundleName:com.ohos.test'); + expect(res).assertContain('debuggablePipe fail to start native process'); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_1300 + * @tc.name aa process -b com.example.timeout -a test -m entry -p 'sleep 100' -S + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_1300', 1, async function (done) { + let res = undefined; + await abilityDelegator.executeShellCommand( + 'aa process -b com.example.timeout -a test -m entry -p \'sleep 100\' -S').then(data => { + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'SUB_AA_AMS_Debuggable_1300 err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('error: failed to start native process.'); + await sleep(500); + + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'SUB_AA_AMS_Debuggable_1300 data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'SUB_AA_AMS_Debuggable_1300 err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('debuggablePipe abilityName:test'); + expect(res).assertContain('debuggablePipe moduleName:entry'); + expect(res).assertContain('debuggablePipe bundleName:com.example.timeout'); + expect(res).assertContain('debuggablePipe fail to start native process'); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_1400 + * @tc.name aa process -b com.example.timeout -a EntryAbility -m test -p 'sleep 100' -S + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_1400', 1, async function (done) { + let res = undefined; + await abilityDelegator.executeShellCommand( + 'aa process -b com.example.timeout -a EntryAbility -m test -p \'sleep 100\' -S').then(data => { + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'SUB_AA_AMS_Debuggable_1400 err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('error: failed to start native process.'); + await sleep(500); + + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'SUB_AA_AMS_Debuggable_1400 data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'SUB_AA_AMS_Debuggable_1400 err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('debuggablePipe abilityName:EntryAbility'); + expect(res).assertContain('debuggablePipe moduleName:test'); + expect(res).assertContain('debuggablePipe bundleName:com.example.timeout'); + expect(res).assertContain('debuggablePipe fail to start native process'); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_1500 + * @tc.name aa process -b com.example.timeout -a EntryAbility -m entry -p 'value length large than 1024' -S + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_1500', 1, async function (done) { + let res = undefined; + let cmd = 'aa process -b com.example.timeout -a EntryAbility -m entry -p ' + + '\'qwertyuiopasdfghjklzxcvbnm123456qwert' + + 'yuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghj' + + 'klzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123' + + '456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuio' + + 'pasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzx' + + 'cvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456q' + + 'wertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasd' + + 'fghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbn' + + 'm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwert' + + 'yuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghj' + + 'klzxcvbnm123456\' -S'; + await abilityDelegator.executeShellCommand(cmd).then(data => { + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1500 aa process err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('usage: aa process '); + await sleep(500); + + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1500 hilog data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1500 hilog err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain( + 'debuggablePipe aa process must contains -p or -D and param length must be less than 1024.'); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_1600 + * @tc.name aa process -b com.example.timeout -a EntryAbility -m entry -p sleep 100 -S + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_1600', 1, async function (done) { + await abilityDelegator.executeShellCommand( + 'aa process -b com.example.timeout -a EntryAbility -m entry -p sleep 100 -S') + .then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1600 aa process data is: ' + JSON.stringify(data)); + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1600 aa process err is: ' + JSON.stringify(err)); + }); + await sleep(500); + + let res = undefined; + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1600 hilog data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1600 hilog err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('debuggablePipe perfCmd:sleep'); + expect(res).assertContain('debuggablePipe sandbox: true'); + expect(res).assertContain('debuggablePipe abilityName:EntryAbility'); + expect(res).assertContain('debuggablePipe moduleName:entry'); + expect(res).assertContain('debuggablePipe bundleName:com.example.timeout'); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_1700 + * @tc.name aa process -b com.example.timeout -a EntryAbility -m entry -S -p + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_1700', 1, async function (done) { + let res = undefined; + await abilityDelegator.executeShellCommand('aa process -b com.example.timeout -a EntryAbility -m entry -S -p') + .then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1700 aa process data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1700 aa process err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('error: option requires a value.'); + expect(res).assertContain('usage: aa process '); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_1800 + * @tc.name aa process -b com.example.timeout -a EntryAbility -m entry -D 'sleep 100' + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_1800', 1, async function (done) { + await abilityDelegator.executeShellCommand( + 'aa process -b com.example.timeout -a EntryAbility -m entry -D \'sleep 100\'').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1800 data is: ' + JSON.stringify(data)); + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1800 err is: ' + JSON.stringify(err)); + }); + await sleep(500); + + let res = undefined; + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'SUB_AA_AMS_Debuggable_1800 data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1800 err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('debuggablePipe debugCmd:sleep 100'); + expect(res).assertContain('debuggablePipe abilityName:EntryAbility'); + expect(res).assertContain('debuggablePipe moduleName:entry'); + expect(res).assertContain('debuggablePipe bundleName:com.example.timeout'); + expect(res.indexOf('debuggablePipe sandbox: true') > 0).assertFalse(); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_1900 + * @tc.name aa process -b com.example.timeout -a EntryAbility -m entry -D 'sleep 100' -S + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_1900', 1, async function (done) { + await abilityDelegator.executeShellCommand( + 'aa process -b com.example.timeout -a EntryAbility -m entry -D \'sleep 100\' -S').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1900 data is: ' + JSON.stringify(data)); + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1900 err is: ' + JSON.stringify(err)); + }); + await sleep(500); + + let res = undefined + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'SUB_AA_AMS_Debuggable_1900 data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_1900 err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('debuggablePipe debugCmd:sleep 100'); + expect(res).assertContain('debuggablePipe sandbox: true'); + expect(res).assertContain('debuggablePipe abilityName:EntryAbility'); + expect(res).assertContain('debuggablePipe moduleName:entry'); + expect(res).assertContain('debuggablePipe bundleName:com.example.timeout'); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_2000 + * @tc.name aa process -b com.example.timeout -a EntryAbility -m entry -D sleep 100 -S + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_2000', 1, async function (done) { + await abilityDelegator.executeShellCommand( + 'aa process -b com.example.timeout -a EntryAbility -m entry -D sleep 100 -S').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2000 aa process data is: ' + JSON.stringify(data)); + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2000 aa process err is: ' + JSON.stringify(err)); + }); + await sleep(500); + + let res = undefined; + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2000 hilog data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2000 hilog err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('debuggablePipe debugCmd:sleep'); + expect(res).assertContain('debuggablePipe sandbox: true'); + expect(res).assertContain('debuggablePipe abilityName:EntryAbility'); + expect(res).assertContain('debuggablePipe moduleName:entry'); + expect(res).assertContain('debuggablePipe bundleName:com.example.timeout'); + expect(res.indexOf('debuggablePipe debugCmd:sleep 100') > 0).assertFalse(); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_2100 + * @tc.name aa process -b com.example.timeout -a EntryAbility -m entry -p 'sleep 100' -D 'sleep 100' -S + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_2100', 1, async function (done) { + await abilityDelegator.executeShellCommand( + 'aa process -b com.example.timeout -a EntryAbility -m entry -p \'sleep 100\' -D \'sleep 100\' -S') + .then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2100 data is: ' + JSON.stringify(data)); + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2100 err is: ' + JSON.stringify(err)); + }); + await sleep(500); + + let res = undefined + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2100 data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2100 err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('debuggablePipe perfCmd:sleep 100'); + expect(res).assertContain('debuggablePipe sandbox: true'); + expect(res).assertContain('debuggablePipe abilityName:EntryAbility'); + expect(res).assertContain('debuggablePipe moduleName:entry'); + expect(res).assertContain('debuggablePipe bundleName:com.example.timeout'); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_2200 + * @tc.name aa process -b com.example.timeout -a EntryAbility -m entry -D 'sleep 100' -p 'sleep 100' -S + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_2200', 1, async function (done) { + await abilityDelegator.executeShellCommand( + 'aa process -b com.example.timeout -a EntryAbility -m entry -D \'sleep 100\' -p \'sleep 100\' -S') + .then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2200 data is: ' + JSON.stringify(data)); + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2200 err is: ' + JSON.stringify(err)); + }); + await sleep(500); + + let res = undefined + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'SUB_AA_AMS_Debuggable_2200 data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2200 err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('debuggablePipe perfCmd:sleep 100'); + expect(res).assertContain('debuggablePipe sandbox: true'); + expect(res).assertContain('debuggablePipe abilityName:EntryAbility'); + expect(res).assertContain('debuggablePipe moduleName:entry'); + expect(res).assertContain('debuggablePipe bundleName:com.example.timeout'); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_2300 + * @tc.name aa process -b com.example.timeout -a EntryAbility -m entry -D 'value length large than 1024' -S + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_2300',1, async function (done) { + let res = undefined; + let cmd = 'aa process -b com.example.timeout -a EntryAbility -m entry -D ' + + '\'qwertyuiopasdfghjklzxcvbnm123456qwert' + + 'yuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghj' + + 'klzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123' + + '456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuio' + + 'pasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzx' + + 'cvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456q' + + 'wertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasd' + + 'fghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbn' + + 'm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwert' + + 'yuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghj' + + 'klzxcvbnm123456\' -S'; + await abilityDelegator.executeShellCommand(cmd).then(data => { + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2300 aa process err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('usage: aa process '); + await sleep(500); + + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2300 hilog data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2300 hilog err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain( + 'debuggablePipe aa process must contains -p or -D and param length must be less than 1024.'); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_2400 + * @tc.name aa process -b com.example.timeout -a EntryAbility -m entry -S -D + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_2400',1, async function (done) { + let res = undefined; + await abilityDelegator.executeShellCommand('aa process -b com.example.timeout -a EntryAbility -m entry -S -D') + .then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2400 aa process data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2400 aa process err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('error: option requires a value.'); + expect(res).assertContain('usage: aa process '); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_2500 + * @tc.name aa process -h + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_2500',1, async function (done) { + let res = undefined; + await abilityDelegator.executeShellCommand('aa process -h').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2500 aa process data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2500 aa process err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('usage: aa process '); + expect(res).assertContain('-h, --help'); + expect(res).assertContain('list available commands'); + expect(res).assertContain('-a -b [-m ]'); + expect(res).assertContain('-p '); + expect(res).assertContain('performance optimization command. Either -p or -D must be selected, -p takes precedence.'); + expect(res).assertContain('debug command. Either -p or -D must be selected, -p takes precedence.'); + expect(res).assertContain('-D '); + expect(res).assertContain('[-S]'); + expect(res).assertContain('debug ability with an element name'); + done(); + }) + }) +} \ No newline at end of file diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/test/ActsDebuggableAaStartTest.test.ets b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/test/ActsDebuggableAaStartTest.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..5439d52b23e058f3f517a3bf9ede239db50dff14 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/test/ActsDebuggableAaStartTest.test.ets @@ -0,0 +1,300 @@ +/* + * Copyright (c) 2023 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 hilog from '@ohos.hilog'; +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium'; +import AbilityDelegatorRegistry from '@ohos.app.ability.abilityDelegatorRegistry'; +import backgroundTaskManager from '@ohos.resourceschedule.backgroundTaskManager'; + +let abilityDelegator = AbilityDelegatorRegistry.getAbilityDelegator(); + +async function cancelSuspendDelay() { + hilog.info(0x0000, 'debuggabletest', '%{public}s', 'cancelSuspendDelay delayId ' + globalThis.delayId); + backgroundTaskManager.cancelSuspendDelay(globalThis.delayId); +} + +function sleep(time) { + return new Promise((resolve, reject) => { + setTimeout(() => { + resolve(null); + }, time) + }); +} + +export default function actsDebuggableAaStartTest() { + describe('ActsDebuggableAaStartTest', function () { + beforeAll(async function () { + }) + + beforeEach(async function () { + await abilityDelegator.executeShellCommand('aa force-stop com.example.timeout').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'beforeEach ActsDebuggableAaStartTest force-stop data is: ' + JSON.stringify(data)); + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'beforeEach ActsDebuggableAaStartTest force-stop err is: ' + JSON.stringify(err)); + }); + await sleep(1000); + await abilityDelegator.executeShellCommand('hilog -r').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'beforeEach ActsDebuggableAaStartTest hilog -r data is: ' + JSON.stringify(data)); + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'beforeEach ActsDebuggableAaStartTest hilog -r err is: ' + JSON.stringify(err)); + }); + await sleep(2000); + }) + afterEach(function () { + }) + afterAll(async function () { + await cancelSuspendDelay(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_0100 + * @tc.name aa start -b com.example.timeout -a EntryAbility -p 'sleep 100' -S + * @tc.desc Function test + * @tc.level 1 + */ + it('SUB_AA_AMS_Debuggable_0100',1, async function (done) { + await abilityDelegator.executeShellCommand( + 'aa start -b com.example.timeout -a EntryAbility -p \'sleep 100\' -S').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0100 data is: ' + JSON.stringify(data)); + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0100 err is: ' + JSON.stringify(err)); + }); + await sleep(800); + + let res = undefined; + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0100 hilog data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0100 hilog err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('debuggablePipe perfCmd:sleep 100'); + expect(res).assertContain('debuggablePipe sandbox: true'); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_0200 + * @tc.name aa start -b com.example.timeout -a EntryAbility -p 'sleep 100' + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_0200',1, async function (done) { + await abilityDelegator.executeShellCommand('aa start -b com.example.timeout -a EntryAbility -p \'sleep 100\'') + .then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0200 data is: ' + JSON.stringify(data)); + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0200 err is: ' + JSON.stringify(err)); + }); + await sleep(800); + + let res = undefined; + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0200 hilog data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0200 hilog err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('debuggablePipe perfCmd:sleep 100'); + expect(res.indexOf('debuggablePipe sandbox: true') > 0).assertFalse(); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_0300 + * @tc.name aa start -b com.example.timeout -a EntryAbility + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_0300',1, async function (done) { + let res = undefined; + await abilityDelegator.executeShellCommand('aa start -b com.example.timeout -a EntryAbility').then(data => { + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0300 err is: ' + JSON.stringify(err)); + }) + expect(res).assertContain('start ability successfully.'); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_0400 + * @tc.name aa start -b com.example.timeout -a EntryAbility -S -p + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_0400',1, async function (done) { + let res = undefined; + await abilityDelegator.executeShellCommand('aa start -b com.example.timeout -a EntryAbility -S -p') + .then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0400 data is: ' + JSON.stringify(data)); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0400 err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('error: option requires a value.'); + expect(res).assertContain('usage: aa start '); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_0500 + * @tc.name aa start -b com.example.timeout -a EntryAbility -S + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_0500',1, async function (done) { + let res = undefined; + await abilityDelegator.executeShellCommand('aa start -b com.example.timeout -a EntryAbility -S').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0500 data is: ' + JSON.stringify(data)); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0500 err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('start ability successfully.'); + await sleep(800); + + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0500 hilog data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0500 hilog err is: ' + JSON.stringify(err)); + }); + + expect(res.indexOf('debuggablePipe perfCmd') > 0).assertFalse(); + expect(res.indexOf('debuggablePipe sandbox') > 0).assertFalse(); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_0600 + * @tc.name aa start -b com.example.timeout -a EntryAbility -p sleep 100 -S + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_0600',1, async function (done) { + let res = undefined; + await abilityDelegator.executeShellCommand('aa start -b com.example.timeout -a EntryAbility -p sleep 100 -S') + .then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0600 data is: ' + JSON.stringify(data)); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0600 err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('start ability successfully.'); + await sleep(800); + + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0600 hilog data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0600 hilog err is: ' + JSON.stringify(err)); + }); + + expect(res).assertContain('debuggablePipe perfCmd:sleep'); + expect(res).assertContain('debuggablePipe sandbox: true'); + expect(res.indexOf('debuggablePipe perfCmd:sleep 100') > 0).assertFalse(); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_0700 + * @tc.name aa start -b com.example.timeout -a EntryAbility -p 'value length large than 1024' -S + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_0700',1, async function (done) { + let res = undefined; + await abilityDelegator.executeShellCommand('aa start -b com.example.timeout -a EntryAbility -p \'qwertyuiopas' + + 'dfghjklzxcvbnm123456qwert' + + 'yuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghj' + + 'klzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123' + + '456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuio' + + 'pasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzx' + + 'cvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456q' + + 'wertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasd' + + 'fghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbn' + + 'm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwert' + + 'yuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghjklzxcvbnm123456qwertyuiopasdfghj' + + 'klzxcvbnm123456\' -S').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0700 data is: ' + JSON.stringify(data)); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0700 err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('usage: aa start '); + await sleep(800); + + await abilityDelegator.executeShellCommand('hilog -x | grep debuggablePipe').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0700 hilog data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_0700 hilog err is: ' + JSON.stringify(err)); + }); + + expect(res).assertContain('debuggablePipe aa start -p param length must be less than 1024.'); + done(); + }) + + /* + * @tc.number SUB_AA_AMS_Debuggable_2600 + * @tc.name aa start -h + * @tc.desc Function test + * @tc.level 3 + */ + it('SUB_AA_AMS_Debuggable_2600',1, async function (done) { + let res = undefined; + await abilityDelegator.executeShellCommand('aa start -h').then(data => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2600 aa process data is: ' + data.stdResult); + res = data.stdResult; + }).catch(err => { + hilog.info(0x0000, 'debuggabletest', '%{public}s', + 'SUB_AA_AMS_Debuggable_2600 aa process err is: ' + JSON.stringify(err)); + }); + expect(res).assertContain('usage: aa start '); + expect(res).assertContain('[-p ]'); + expect(res).assertContain('[-S]'); + done(); + }) + }) +} \ No newline at end of file diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/test/List.test.ets b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/test/List.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..b31662ce23ec456c5e5a30fee97353caee2f3b85 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/test/List.test.ets @@ -0,0 +1,22 @@ +/* + * Copyright (c) 2023 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 aastartTest from './ActsDebuggableAaStartTest.test'; +import aaprocessTest from './ActsDebuggableAaProcessTest.test'; + +export default function testsuite() { + aaprocessTest(); + aastartTest(); +} \ No newline at end of file diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/testability/TestAbility.ets b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/testability/TestAbility.ets new file mode 100644 index 0000000000000000000000000000000000000000..3ce827ff768d056b5de2f6d562e3b4b8da69756e --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/testability/TestAbility.ets @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2023 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 hilog from '@ohos.hilog'; +import Ability from '@ohos.app.ability.UIAbility'; +import AbilityDelegatorRegistry from '@ohos.app.ability.abilityDelegatorRegistry'; +import { Hypium } from '@ohos/hypium'; +import testsuite from '../test/List.test'; +import Window from '@ohos.window'; + +export default class TestAbility extends Ability { + onCreate(want, launchParam) { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onCreate'); + hilog.info(0x0000, 'testTag', '%{public}s', 'want param:' + JSON.stringify(want) ?? ''); + hilog.info(0x0000, 'testTag', '%{public}s', 'launchParam:'+ JSON.stringify(launchParam) ?? ''); + let abilityDelegator: any; + abilityDelegator = AbilityDelegatorRegistry.getAbilityDelegator(); + let abilityDelegatorArguments: any; + abilityDelegatorArguments = AbilityDelegatorRegistry.getArguments(); + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'start run testcase!!!'); + Hypium.hypiumTest(abilityDelegator, abilityDelegatorArguments, testsuite); + } + + onDestroy() { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onDestroy'); + } + + onWindowStageCreate(windowStage: Window.WindowStage) { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onWindowStageCreate'); + windowStage.loadContent('testability/pages/Index', (err, data) => { + if (err.code) { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.ERROR); + hilog.error(0x0000, 'testTag', 'Failed to load the content. Cause: %{public}s', JSON.stringify(err) ?? ''); + return; + } + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', 'Succeeded in loading the content. Data: %{public}s', + JSON.stringify(data) ?? ''); + }); + } + + onWindowStageDestroy() { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onWindowStageDestroy'); + } + + onForeground() { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onForeground'); + } + + onBackground() { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onBackground'); + } +} \ No newline at end of file diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/testability/pages/Index.ets b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/testability/pages/Index.ets new file mode 100644 index 0000000000000000000000000000000000000000..0554acaaa6ed0d2033fbbff765cdcec59154a431 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/ets/testability/pages/Index.ets @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2023 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 hilog from '@ohos.hilog'; + +@Entry +@Component +struct Index { + aboutToAppear() { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility index aboutToAppear'); + } + @State message: string = 'Hello Debuggable'; + 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/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/module.json b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/module.json new file mode 100644 index 0000000000000000000000000000000000000000..7b7b47f86f34c4ff8ee78eab271c777fe0014e63 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/module.json @@ -0,0 +1,47 @@ +{ + "module": { + "name": "entry", + "type": "entry", + "description": "$string:module_desc", + "mainElement": "EntryAbility", + "deviceTypes": [ + "default", + "tablet" + ], + "deliveryWithInstall": true, + "installationFree": false, + "pages": "$profile:main_pages", + "abilities": [ + { + "name": "EntryAbility", + "srcEntrance": "./ets/entryability/EntryAbility.ts", + "description": "$string:EntryAbility_desc", + "icon": "$media:icon", + "label": "$string:EntryAbility_label", + "startWindowIcon": "$media:icon", + "startWindowBackground": "$color:start_window_background", + "visible": true, + "skills": [ + { + "entities": [ + "entity.system.home" + ], + "actions": [ + "action.system.home" + ] + } + ] + }, + { + "name": "TestAbility", + "srcEntrance": "./ets/testability/TestAbility.ets", + "description": "$string:TestAbility_desc", + "icon": "$media:icon", + "label": "$string:TestAbility_label", + "visible": true, + "startWindowIcon": "$media:icon", + "startWindowBackground": "$color:start_window_background" + } + ] + } +} \ No newline at end of file diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/base/element/color.json b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/base/element/color.json new file mode 100644 index 0000000000000000000000000000000000000000..3c712962da3c2751c2b9ddb53559afcbd2b54a02 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/base/element/color.json @@ -0,0 +1,8 @@ +{ + "color": [ + { + "name": "start_window_background", + "value": "#FFFFFF" + } + ] +} \ No newline at end of file diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/base/element/string.json b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/base/element/string.json new file mode 100644 index 0000000000000000000000000000000000000000..d656140d5682ce36990cc9ffa6a0b1bea27df195 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/base/element/string.json @@ -0,0 +1,24 @@ +{ + "string": [ + { + "name": "module_desc", + "value": "module description" + }, + { + "name": "EntryAbility_desc", + "value": "description" + }, + { + "name": "EntryAbility_label", + "value": "label" + }, + { + "name": "TestAbility_desc", + "value": "the test ability" + }, + { + "name": "TestAbility_label", + "value": "test label" + } + ] +} \ No newline at end of file diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/base/media/icon.png b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/base/media/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..ce307a8827bd75456441ceb57d530e4c8d45d36c Binary files /dev/null and b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/base/media/icon.png differ diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/base/profile/main_pages.json b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/base/profile/main_pages.json new file mode 100644 index 0000000000000000000000000000000000000000..1898d94f58d6128ab712be2c68acc7c98e9ab9ce --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/base/profile/main_pages.json @@ -0,0 +1,5 @@ +{ + "src": [ + "pages/Index" + ] +} diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/en_US/element/string.json b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/en_US/element/string.json new file mode 100644 index 0000000000000000000000000000000000000000..d656140d5682ce36990cc9ffa6a0b1bea27df195 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/en_US/element/string.json @@ -0,0 +1,24 @@ +{ + "string": [ + { + "name": "module_desc", + "value": "module description" + }, + { + "name": "EntryAbility_desc", + "value": "description" + }, + { + "name": "EntryAbility_label", + "value": "label" + }, + { + "name": "TestAbility_desc", + "value": "the test ability" + }, + { + "name": "TestAbility_label", + "value": "test label" + } + ] +} \ No newline at end of file diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/zh_CN/element/string.json b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/zh_CN/element/string.json new file mode 100644 index 0000000000000000000000000000000000000000..a59fa630544e65c7ea46730e422faa7e3e71325e --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/entry/src/main/resources/zh_CN/element/string.json @@ -0,0 +1,24 @@ +{ + "string": [ + { + "name": "module_desc", + "value": "模块描述" + }, + { + "name": "EntryAbility_desc", + "value": "description" + }, + { + "name": "EntryAbility_label", + "value": "label" + }, + { + "name": "TestAbility_desc", + "value": "the test ability" + }, + { + "name": "TestAbility_label", + "value": "test label" + } + ] +} \ No newline at end of file diff --git a/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/signature/openharmony_sx.p7b b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/signature/openharmony_sx.p7b new file mode 100644 index 0000000000000000000000000000000000000000..3946e680e8e2ad82f1838f8dd7fa85b739d58b36 Binary files /dev/null and b/ability/ability_runtime/stage/actsdebuggabletest/actsdebuggabletest/signature/openharmony_sx.p7b differ diff --git a/ability/ability_runtime/stage/actsdebuggabletest/timeout/AppScope/app.json b/ability/ability_runtime/stage/actsdebuggabletest/timeout/AppScope/app.json new file mode 100644 index 0000000000000000000000000000000000000000..c0611ce15075db801bd20de029cdc0dfe3ddfff6 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/timeout/AppScope/app.json @@ -0,0 +1,19 @@ +{ + "app": { + "bundleName": "com.example.timeout", + "vendor": "example", + "versionCode": 1000000, + "versionName": "1.0.0", + "icon": "$media:app_icon", + "label": "$string:app_name", + "distributedNotificationEnabled": true, + "keepAlive": true, + "singleUser": true, + "minAPIVersion": 9, + "targetAPIVersion": 9, + "car": { + "apiCompatibleVersion": 9, + "singleUser": false + } + } +} diff --git a/ability/ability_runtime/stage/actsdebuggabletest/timeout/AppScope/resources/base/element/string.json b/ability/ability_runtime/stage/actsdebuggabletest/timeout/AppScope/resources/base/element/string.json new file mode 100644 index 0000000000000000000000000000000000000000..23e04ef6edbb10e85749063495ee94342016d26a --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/timeout/AppScope/resources/base/element/string.json @@ -0,0 +1,8 @@ +{ + "string": [ + { + "name": "app_name", + "value": "Timeout" + } + ] +} diff --git a/ability/ability_runtime/stage/actsdebuggabletest/timeout/AppScope/resources/base/media/app_icon.png b/ability/ability_runtime/stage/actsdebuggabletest/timeout/AppScope/resources/base/media/app_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..ce307a8827bd75456441ceb57d530e4c8d45d36c Binary files /dev/null and b/ability/ability_runtime/stage/actsdebuggabletest/timeout/AppScope/resources/base/media/app_icon.png differ diff --git a/ability/ability_runtime/stage/actsdebuggabletest/timeout/BUILD.gn b/ability/ability_runtime/stage/actsdebuggabletest/timeout/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..92222cb2efe5494e8a5182a9a2b711dcbbf436d7 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/timeout/BUILD.gn @@ -0,0 +1,46 @@ +# Copyright (c) 2023 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_hap_assist_suite("ActsDebuggableTimeout") { + hap_name = "ActsDebuggableTimeout" + js_build_mode = "debug" + + testonly = true + hap_profile = "entry/src/main/module.json" + deps = [ + ":actsdebuggabletimeout_js_assets", + ":actsdebuggabletimeout_resources", + ] + ets2abc = true + certificate_profile = "signature/openharmony_sx.p7b" + + subsystem_name = "ability" + part_name = "ability_runtime" +} + +ohos_app_scope("actsdebuggabletimeout_app_profile") { + app_profile = "AppScope/app.json" + sources = [ "AppScope/resources" ] +} + +ohos_js_assets("actsdebuggabletimeout_js_assets") { + source_dir = "entry/src/main/ets" +} + +ohos_resources("actsdebuggabletimeout_resources") { + sources = [ "entry/src/main/resources" ] + deps = [ ":actsdebuggabletimeout_app_profile" ] + hap_profile = "entry/src/main/module.json" +} diff --git a/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/ets/entryability/EntryAbility.ts b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/ets/entryability/EntryAbility.ts new file mode 100644 index 0000000000000000000000000000000000000000..5a2ad1b43fc919610df43f64ff4f8e01b48a0d29 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/ets/entryability/EntryAbility.ts @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2023 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 hilog from '@ohos.hilog'; +import Ability from '@ohos.app.ability.UIAbility'; +import Window from '@ohos.window'; + +export default class EntryAbility extends Ability { + onCreate(want, launchParam) { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onCreate'); + hilog.info(0x0000, 'testTag', '%{public}s', 'want param:' + JSON.stringify(want) ?? ''); + hilog.info(0x0000, 'testTag', '%{public}s', 'launchParam:' + JSON.stringify(launchParam) ?? ''); + } + + onDestroy() { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onDestroy'); + } + + onWindowStageCreate(windowStage: Window.WindowStage) { + // Main window is created, set main page for this ability + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onWindowStageCreate'); + + windowStage.loadContent('pages/Index', (err, data) => { + if (err.code) { + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.ERROR); + hilog.error(0x0000, 'testTag', 'Failed to load the content. Cause: %{public}s', JSON.stringify(err) ?? ''); + return; + } + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', 'Succeeded in loading the content. Data: %{public}s', JSON.stringify(data) ?? ''); + }); + } + + onWindowStageDestroy() { + // Main window is destroyed, release UI related resources + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onWindowStageDestroy'); + } + + onForeground() { + // Ability has brought to foreground + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onForeground'); + } + + onBackground() { + // Ability has back to background + hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onBackground'); + } +} diff --git a/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/ets/pages/Index.ets b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/ets/pages/Index.ets new file mode 100644 index 0000000000000000000000000000000000000000..86b9aec13687ae982be58bd8562abd1585d50bfa --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/ets/pages/Index.ets @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2023 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. + */ + +@Entry +@Component +struct Index { + @State message: string = 'Hello World'; + + build() { + Row() { + Column() { + Text(this.message) + .fontSize(50) + .fontWeight(FontWeight.Bold) + } + .width('100%') + } + .height('100%') + } +} \ No newline at end of file diff --git a/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/module.json b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/module.json new file mode 100644 index 0000000000000000000000000000000000000000..0e288c05b41ef026b9f802f6c848bd5301ebc785 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/module.json @@ -0,0 +1,37 @@ +{ + "module": { + "name": "entry", + "type": "entry", + "description": "$string:module_desc", + "mainElement": "EntryAbility", + "deviceTypes": [ + "default", + "tablet" + ], + "deliveryWithInstall": true, + "installationFree": false, + "pages": "$profile:main_pages", + "abilities": [ + { + "name": "EntryAbility", + "srcEntrance": "./ets/entryability/EntryAbility.ts", + "description": "$string:EntryAbility_desc", + "icon": "$media:icon", + "label": "$string:EntryAbility_label", + "startWindowIcon": "$media:icon", + "startWindowBackground": "$color:start_window_background", + "visible": true, + "skills": [ + { + "entities": [ + "entity.system.home" + ], + "actions": [ + "action.system.home" + ] + } + ] + } + ] + } +} \ No newline at end of file diff --git a/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/base/element/color.json b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/base/element/color.json new file mode 100644 index 0000000000000000000000000000000000000000..3c712962da3c2751c2b9ddb53559afcbd2b54a02 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/base/element/color.json @@ -0,0 +1,8 @@ +{ + "color": [ + { + "name": "start_window_background", + "value": "#FFFFFF" + } + ] +} \ No newline at end of file diff --git a/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/base/element/string.json b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/base/element/string.json new file mode 100644 index 0000000000000000000000000000000000000000..f94595515a99e0c828807e243494f57f09251930 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/base/element/string.json @@ -0,0 +1,16 @@ +{ + "string": [ + { + "name": "module_desc", + "value": "module description" + }, + { + "name": "EntryAbility_desc", + "value": "description" + }, + { + "name": "EntryAbility_label", + "value": "label" + } + ] +} \ No newline at end of file diff --git a/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/base/media/icon.png b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/base/media/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..ce307a8827bd75456441ceb57d530e4c8d45d36c Binary files /dev/null and b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/base/media/icon.png differ diff --git a/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/base/profile/main_pages.json b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/base/profile/main_pages.json new file mode 100644 index 0000000000000000000000000000000000000000..1898d94f58d6128ab712be2c68acc7c98e9ab9ce --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/base/profile/main_pages.json @@ -0,0 +1,5 @@ +{ + "src": [ + "pages/Index" + ] +} diff --git a/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/en_US/element/string.json b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/en_US/element/string.json new file mode 100644 index 0000000000000000000000000000000000000000..f94595515a99e0c828807e243494f57f09251930 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/en_US/element/string.json @@ -0,0 +1,16 @@ +{ + "string": [ + { + "name": "module_desc", + "value": "module description" + }, + { + "name": "EntryAbility_desc", + "value": "description" + }, + { + "name": "EntryAbility_label", + "value": "label" + } + ] +} \ No newline at end of file diff --git a/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/zh_CN/element/string.json b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/zh_CN/element/string.json new file mode 100644 index 0000000000000000000000000000000000000000..597ecf95e61d7e30367c22fe2f8638008361b044 --- /dev/null +++ b/ability/ability_runtime/stage/actsdebuggabletest/timeout/entry/src/main/resources/zh_CN/element/string.json @@ -0,0 +1,16 @@ +{ + "string": [ + { + "name": "module_desc", + "value": "模块描述" + }, + { + "name": "EntryAbility_desc", + "value": "description" + }, + { + "name": "EntryAbility_label", + "value": "label" + } + ] +} \ No newline at end of file diff --git a/ability/ability_runtime/stage/actsdebuggabletest/timeout/signature/openharmony_sx.p7b b/ability/ability_runtime/stage/actsdebuggabletest/timeout/signature/openharmony_sx.p7b new file mode 100644 index 0000000000000000000000000000000000000000..6e177e4ddd40f9ba7702b5872e1df7eba188169d Binary files /dev/null and b/ability/ability_runtime/stage/actsdebuggabletest/timeout/signature/openharmony_sx.p7b differ