diff --git a/hiviewdfx/BUILD.gn b/hiviewdfx/BUILD.gn index 5f25e3bd9ce3cf6420999a7bf14b5bee0c9bd161..c08d36d1a2c159e1108609abce7e0b7437fdebb6 100644 --- a/hiviewdfx/BUILD.gn +++ b/hiviewdfx/BUILD.gn @@ -18,6 +18,7 @@ group("hiviewdfxtestacts") { "abilityconstanttest:ActsAbilityConstantTest", "apprecoverytest:ActsAppRecoveryTest", "bytracetest:ActsBytraceJsTest", + "crossplatform/hiviewdfxhilogetstest:hilog_ets_test", "hiappeventtest/hiappeventcpptest:ActsHiAppEventCPPTest", "hiappeventtest/hiappeventjstest:ActsHiAppeventTest", "hiappeventtest/hiappeventsubjstest:ActsHiAppeventSubTest", diff --git a/hiviewdfx/crossplatform/hiviewdfxhilogetstest/AppScope/app.json b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/AppScope/app.json new file mode 100644 index 0000000000000000000000000000000000000000..50c2c881dc2d53d4ef74d2cf1ff1a7e1997e279e --- /dev/null +++ b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/AppScope/app.json @@ -0,0 +1,16 @@ +{ + "app": { + "bundleName": "ohos.acts.hiviewdfx.crossplatform.hilog.normal", + "vendor": "example", + "versionCode": 1000000, + "versionName": "1.0.0", + "icon": "$media:app_icon", + "label": "$string:app_name", + "minAPIVersion": 9, + "targetAPIVersion": 9, + "car": { + "apiCompatibleVersion": 9, + "singleUser": false + } + } +} diff --git a/hiviewdfx/crossplatform/hiviewdfxhilogetstest/AppScope/resources/base/element/string.json b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/AppScope/resources/base/element/string.json new file mode 100644 index 0000000000000000000000000000000000000000..3811bc441fc0f128eb4d14c53ed463ffb8dc3811 --- /dev/null +++ b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/AppScope/resources/base/element/string.json @@ -0,0 +1,8 @@ +{ + "string": [ + { + "name": "app_name", + "value": "xtsDemo1" + } + ] +} diff --git a/hiviewdfx/crossplatform/hiviewdfxhilogetstest/AppScope/resources/base/media/app_icon.png b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/AppScope/resources/base/media/app_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..ce307a8827bd75456441ceb57d530e4c8d45d36c Binary files /dev/null and b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/AppScope/resources/base/media/app_icon.png differ diff --git a/hiviewdfx/crossplatform/hiviewdfxhilogetstest/BUILD.gn b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..b9c83782937bd76c182ea2ff793fa76262e1e2db --- /dev/null +++ b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/BUILD.gn @@ -0,0 +1,49 @@ +# 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("hilog_ets_test") { + hap_profile = "src/main/module.json" + deps = [ + ":windowStage_js_assets", + ":windowStage_resources", + ] + ets2abc = true + certificate_profile = "./signature/openharmony_sx.p7b" + + # hap_name: HAP的名字，可选，默认为目标名 + hap_name = "hilog_ets_test" + part_name = "hilog_native" + subsystem_name = "hiviewdfx" +} +ohos_app_scope("windowStage_app_profile") { + # app_profile: HAP的AppScope中的app.json，只在Stage模型下使用 + app_profile = "AppScope/app.json" + + # sources: 资源文件路径 + sources = [ "AppScope/resources" ] +} +ohos_js_assets("windowStage_js_assets") { + # source_dir: js或ets代码路径，兼容FA模型的单ability配置到ability目录 + source_dir = "src/main/ets" +} +ohos_resources("windowStage_resources") { + # sources: 资源文件路径 + sources = [ "src/main/resources" ] + + # deps: 当前目标的依赖 + deps = [ ":windowStage_app_profile" ] + + # hap_profile: HAP的config.json，Stage模型对应module.json + hap_profile = "src/main/module.json" +} diff --git a/hiviewdfx/crossplatform/hiviewdfxhilogetstest/Test.json b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/Test.json new file mode 100644 index 0000000000000000000000000000000000000000..a18a84f3a61c080503b09341594120a97f97ce85 --- /dev/null +++ b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/Test.json @@ -0,0 +1,27 @@ +{ + "description": "Configuration for hjunit demo Tests", + // 指定设备执行的驱动 + "driver": { + "type": "OHJSUnitTest", + //test-timeout: 测试hap 整体执行用例的执行时长 + "test-timeout": "60000", + //shell-timeout: aa test 拉起命令执行时长 + "shell-timeout": "60000", + //bundle-name: 与HAP的app.json 中 bundleName 保持一致 + "bundle-name": "ohos.acts.hiviewdfx.crossplatform.hilog.normal", + //module-name: 与HAP的module.json 中"module"字段的 name 保持一致 + "module-name": "entry_test" + //testcase-timeout: 测试hap 单条用例的执行时长 + //"testcase-timeout": 5000 + }, + // kit的作用主要是为了支撑测试执行活动，在测试前执行预制操作(Setup)，在测试后执行清理操作(Teardown) + "kits": [ + { + "test-file-name": [ + "ActsDemoStageTest.hap" + ], + "type": "AppInstallKit", + "cleanup-apps": true + } + ] +} \ No newline at end of file diff --git a/hiviewdfx/crossplatform/hiviewdfxhilogetstest/signature/openharmony_sx.p7b b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/signature/openharmony_sx.p7b new file mode 100644 index 0000000000000000000000000000000000000000..05890e8ea8af91e8fdfe20652fd302ea8bb6a641 Binary files /dev/null and b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/signature/openharmony_sx.p7b differ diff --git a/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/ets/TestAbility/TestAbility.ets b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/ets/TestAbility/TestAbility.ets new file mode 100644 index 0000000000000000000000000000000000000000..4aa70267fc0864b224853ab7815f9b443c4609bf --- /dev/null +++ b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/ets/TestAbility/TestAbility.ets @@ -0,0 +1,62 @@ +/* + * 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 UIAbility from '@ohos.app.ability.UIAbility'; +import AbilityDelegatorRegistry from '@ohos.app.ability.abilityDelegatorRegistry'; +import hilog from '@ohos.hilog'; +import { Hypium } from '@ohos/hypium'; +import testsuite from '../test/List.test'; +import window from '@ohos.window'; + +export default class TestAbility extends UIAbility { + onCreate(want, launchParam) { + 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) ?? ''); + var abilityDelegator: any + abilityDelegator = AbilityDelegatorRegistry.getAbilityDelegator() + var abilityDelegatorArguments: any + abilityDelegatorArguments = AbilityDelegatorRegistry.getArguments() + hilog.info(0x0000, 'testTag', '%{public}s', 'start run testcase!!!'); + Hypium.hypiumTest(abilityDelegator, abilityDelegatorArguments, testsuite) + } + + onDestroy() { + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onDestroy'); + } + + onWindowStageCreate(windowStage: window.WindowStage) { + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onWindowStageCreate'); + windowStage.loadContent('TestAbility/pages/Index', (err, data) => { + if (err.code) { + hilog.error(0x0000, 'testTag', 'Failed to load the content. Cause: %{public}s', JSON.stringify(err) ?? ''); + return; + } + hilog.info(0x0000, 'testTag', 'Succeeded in loading the content. Data: %{public}s', + JSON.stringify(data) ?? ''); + }); + } + + onWindowStageDestroy() { + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onWindowStageDestroy'); + } + + onForeground() { + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onForeground'); + } + + onBackground() { + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onBackground'); + } +} \ No newline at end of file diff --git a/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/ets/TestAbility/pages/Index.ets b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/ets/TestAbility/pages/Index.ets new file mode 100644 index 0000000000000000000000000000000000000000..4ca1473bf3dac44d66fbc66a95ea93f4b8ba4b49 --- /dev/null +++ b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/ets/TestAbility/pages/Index.ets @@ -0,0 +1,48 @@ +/* + * 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.info(0x0000, 'testTag', '%{public}s', '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/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/ets/TestRunner/OpenHarmonyTestRunner.ts b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/ets/TestRunner/OpenHarmonyTestRunner.ts new file mode 100644 index 0000000000000000000000000000000000000000..92a16d84e8870da219c51d9f1342c79203c1f42d --- /dev/null +++ b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/ets/TestRunner/OpenHarmonyTestRunner.ts @@ -0,0 +1,49 @@ +import hilog from '@ohos.hilog'; +import TestRunner from '@ohos.application.testRunner'; +import AbilityDelegatorRegistry from '@ohos.app.ability.abilityDelegatorRegistry'; + +var abilityDelegator = undefined +var abilityDelegatorArguments = undefined + +async function onAbilityCreateCallback() { + hilog.info(0x0000, 'testTag', '%{public}s', 'onAbilityCreateCallback'); +} + +async function addAbilityMonitorCallback(err: any) { + hilog.info(0x0000, 'testTag', 'addAbilityMonitorCallback : %{public}s', JSON.stringify(err) ?? ''); +} + +export default class OpenHarmonyTestRunner implements TestRunner { + constructor() { + } + + onPrepare() { + hilog.info(0x0000, 'testTag', '%{public}s', 'OpenHarmonyTestRunner OnPrepare '); + } + + async onRun() { + hilog.info(0x0000, 'testTag', '%{public}s', 'OpenHarmonyTestRunner onRun run'); + abilityDelegatorArguments = AbilityDelegatorRegistry.getArguments() + abilityDelegator = AbilityDelegatorRegistry.getAbilityDelegator() + var testAbilityName = abilityDelegatorArguments.bundleName + '.TestAbility' + let lMonitor = { + abilityName: testAbilityName, + onAbilityCreate: onAbilityCreateCallback, + }; + abilityDelegator.addAbilityMonitor(lMonitor, addAbilityMonitorCallback) + var cmd = 'aa start -d 0 -a TestAbility' + ' -b ' + abilityDelegatorArguments.bundleName + var debug = abilityDelegatorArguments.parameters['-D'] + if (debug == 'true') + { + cmd += ' -D' + } + hilog.info(0x0000, 'testTag', 'cmd : %{public}s', cmd); + abilityDelegator.executeShellCommand(cmd, + (err: any, d: any) => { + 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/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/ets/test/List.test.ets b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/ets/test/List.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..a4d7577049f8e039755e566ddd30e0f2f1ab663d --- /dev/null +++ b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/ets/test/List.test.ets @@ -0,0 +1,19 @@ +/* + * 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 HilogJsTest from './hilog.test' + +export default function testsuite() { + HilogJsTest() +} \ No newline at end of file diff --git a/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/ets/test/hilog.test.ets b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/ets/test/hilog.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..a876c21d9408a4d2982e7d8a6cc838d12a60ac1d --- /dev/null +++ b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/ets/test/hilog.test.ets @@ -0,0 +1,611 @@ +/* + * 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 { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from "@ohos/hypium"; +import hilog from "@ohos.hilog"; +export default function HilogJsTest() { + describe("HilogJsTest", function () { + beforeAll(function () { + console.info("beforeAll called"); + }); + + afterAll(function () { + console.info("afterAll called"); + }); + + /** + * @tc.number: TEST_HILOG_DEBUG_001 + * @tc.name : testHilogDebug001 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogDebug001", 2, function () { + console.info("testHilogDebug001 start"); + try { + hilog.debug(0x3200, "HILOGTEST", "%{public}s", "hilogJs1800"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogDebug001 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogDebug001 end"); + }); + + /** + * @tc.number: TEST_HILOG_DEBUG_002 + * @tc.name : testHilogDebug002 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogDebug002", 2, function () { + console.info("testHilogDebug002 start"); + try { + hilog.debug(0x3200, "HILOGTEST", "%{public}d", 2.1); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogDebug002 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogDebug002 end"); + }); + + /** + * @tc.number: TEST_HILOG_DEBUG_003 + * @tc.name : testHilogDebug003 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogDebug003", 2, function () { + console.info("testHilogDebug003 start"); + try { + hilog.debug(0x3200, "HILOGTEST", "%{public}d", 65535); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogDebug003 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogDebug003 end"); + }); + + /** + * @tc.number: TEST_HILOG_DEBUG_004 + * @tc.name : testHilogDebug004 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogDebug004", 2, function () { + console.info("testHilogDebug004 start"); + try { + hilog.debug(0x3200, "HILOGTEST", "%{public}s", "hilog info"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogDebug004 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogDebug004 end"); + }); + + /** + * @tc.number: TEST_HILOG_DEBUG_005 + * @tc.name : testHilogDebug005 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogDebug005", 2, function () { + console.info("testHilogDebug005 start"); + try { + hilog.debug(0x3200, "HILOGTEST", "%{public}d", 2147483647); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogDebug005 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogDebug005 end"); + }); + + /** + * @tc.number: TEST_HILOG_DEBUG_006 + * @tc.name : testHilogDebug006 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogDebug006", 2, function () { + console.info("testHilogDebug006 start"); + try { + hilog.debug(0x3200, "HILOGTEST", "%{public}s", "100%s%d%x%f"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogDebug006 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogDebug006 end"); + }); + + /** + * @tc.number: TEST_HILOG_DEBUG_007 + * @tc.name : testHilogDebug007 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogDebug007", 2, function () { + console.info("testHilogDebug007 start"); + try { + hilog.debug(0x3200, "HILOGTEST", "%{public}s", "65536"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogDebug007 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogDebug007 end"); + }); + + /** + * @tc.number: TEST_HILOG_DEBUG_008 + * @tc.name : testHilogDebug008 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogDebug008", 2, function () { + console.info("testHilogDebug008 start"); + try { + hilog.debug(0x3200, "HILOGTEST", "username:%{public}s, password:%{private}s.", "username", "password"); + expect(true).assertTrue(); + hilog.debug(0x3200, "HILOGTEST", "username:%{public}s, password:%s.", "username123", "password"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogDebug008 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogDebug008 end"); + }); + + /** + * @tc.number: TEST_HILOG_DEBUG_009 + * @tc.name : testHilogDebug009 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogDebug009", 2, function () { + console.info("testHilogDebug009 start"); + try { + hilog.debug(0x3200, "HILOGTEST", "%{public}s", "hilog public"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogDebug009 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogDebug009 end"); + }); + + /** + * @tc.number: TEST_HILOG_DEBUG_010 + * @tc.name : testHilogDebug010 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogDebug010", 2, function () { + console.info("testHilogDebug010 start"); + try { + hilog.debug(0x3200, "HILOGTEST", "%{nopublic}s", "Hilogtest"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogDebug010 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogDebug010 end"); + }); + + /** + * @tc.number: TEST_HILOG_INFO_001 + * @tc.name : testHilogInfo001 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogInfo001", 2, function () { + console.info("testHilogInfo001 start"); + try { + hilog.info(0x3200, "HILOGTEST", "%{public}s", "hilogJs0400"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogInfo001 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogInfo001 end"); + }); + + /** + * @tc.number: TEST_HILOG_INFO_002 + * @tc.name : testHilogInfo002 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogInfo002", 2, function () { + console.info("testHilogInfo002 start"); + try { + hilog.info(0x3200, "HILOGTEST", "username:%{public}s, password:%{private}s.", "username", "password"); + expect(true).assertTrue(); + hilog.info(0x3200, "HILOGTEST", "username:%{public}s, password:%s.", "username123", "password"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogInfo002 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogInfo002 end"); + }); + + /** + * @tc.number: TEST_HILOG_INFO_003 + * @tc.name : testHilogInfo003 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogInfo003", 2, function () { + console.info("testHilogInfo003 start"); + try { + hilog.info(0xffff, "HILOGTEST", "username:%{public}s, password:%{public}s.", "username", "password"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogInfo003 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogInfo003 end"); + }); + + /** + * @tc.number: TEST_HILOG_INFO_004 + * @tc.name : testHilogInfo004 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogInfo004", 2, function () { + console.info("testHilogInfo004 start"); + try { + hilog.info(0xfffe, "HILOGTEST", "username:%{public}s, password:%{public}s.", "username", "password"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogInfo004 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogInfo004 end"); + }); + + /** + * @tc.number: TEST_HILOG_INFO_005 + * @tc.name : testHilogInfo005 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogInfo005", 2, function () { + console.info("testHilogInfo005 start"); + try { + hilog.info(0xfffff, "HILOGTEST", "username:%{public}s, password:%{public}s.", "username", "password"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogInfo005 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogInfo005 end"); + }); + + /** + * @tc.number: TEST_HILOG_INFO_006 + * @tc.name : testHilogInfo006 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogInfo006", 2, function () { + console.info("testHilogInfo006 start"); + try { + hilog.info(0xffffe, "HILOGTEST", "username:%{public}s, password:%{public}s.", "username", "password"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogInfo006 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogInfo006 end"); + }); + + /** + * @tc.number: TEST_HILOG_INFO_007 + * @tc.name : testHilogInfo007 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogInfo007", 2, function () { + console.info("testHilogInfo007 start"); + try { + hilog.info(100, "HILOGTEST", "username:%{public}s, password:%{public}s.", "username", "password"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogInfo007 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogInfo007 end"); + }); + + /** + * @tc.number: TEST_HILOG_INFO_009 + * @tc.name : testHilogInfo009 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogInfo008", 2, function () { + console.info("testHilogInfo008 start"); + try { + hilog.info(0x3200, "HILOGTEST", "username:%{public}s.", null); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogInfo008 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogInfo008 end"); + }); + + /** + * @tc.number: TEST_HILOG_INFO_009 + * @tc.name : testHilogInfo009 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogInfo009", 2, function () { + console.info("testHilogInfo009 start"); + try { + hilog.info(0x3200, "HILOGTEST", "username:%{public}s.", undefined); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogInfo009 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogInfo009 end"); + }); + + /** + * @tc.number: TEST_HILOG_INFO_010 + * @tc.name : testHilogInfo010 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogInfo010", 2, function () { + console.info("testHilogInfo010 start"); + try { + hilog.info(0x3200, "HILOGTEST", "MAX Number:%{public}d, MIN Number:%{public}d", Number.MAX_VALUE, Number.MIN_VALUE); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogInfo010 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogInfo010 end"); + }); + + /** + * @tc.number: TEST_HILOG_INFO_011 + * @tc.name : testHilogInfo011 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogInfo011", 2, function () { + console.info("testHilogInfo011 start"); + try { + hilog.info(0x3200, "HILOGTEST", "���IJ���:%{public}s, ��ϴ�ӡ:%{public}s", "���Ĵ�ӡ����", "for����test,.;:*_-=^(%)?#$/|\\"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogInfo011 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogInfo011 end"); + }); + + /** + * @tc.number: TEST_HILOG_INFO_012 + * @tc.name : testHilogInfo012 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogInfo012", 2, function () { + console.info("testHilogInfo012 start"); + try { + hilog.info(0x3200, "HILOGTEST", "boolean1:%{public}s, boolean2:%{public}s", true, false); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogInfo012 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogInfo012 end"); + }); + + /** + * @tc.number: TEST_HILOG_WARN_001 + * @tc.name : testHilogWarn001 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogWarn001", 2, function () { + console.info("testHilogWarn001 start"); + try { + hilog.warn(0x3200, "HILOGTEST", "%{public}s", "hilogJs0500"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogWarn001 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogWarn001 end"); + }); + + /** + * @tc.number: TEST_HILOG_ERROR_001 + * @tc.name : testHilogError001 + * @tc.desc : hilog begin interface test. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogError001", 2, function () { + console.info("testHilogError001 start"); + try { + hilog.error(0x3200, "HILOGTEST", "%{public}s", "hilogJs0200"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogError001 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogError001 end"); + }); + + /** + * @tc.number: TEST_HILOG_ERROR_002 + * @tc.name : testHilogError002 + * @tc.desc :The log tool can read valid app log types when domain on. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogError002", 2, function () { + console.info("testHilogError002 start"); + try { + hilog.error(0xffff, "HILOGTEST", "%{public}s", ["hilogJs0100"]); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogError002 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogError002 end"); + }); + + /** + * @tc.number: TEST_HILOG_ERROR_003 + * @tc.name : testHilogError003 + * @tc.desc : The log tool can't read white app log types when domain on. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogError003", 2, function () { + console.info("testHilogError003 start"); + try { + hilog.error(0xd003200, "HILOGTEST", "%{public}s", ["hilogJs0200"]); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogError003 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogError003 end"); + }); + + /** + * @tc.number: TEST_HILOG_ERROR_004 + * @tc.name : testHilogError004 + * @tc.desc : The log tool can read valid app log types when domain off. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogError004", 2, function () { + console.info("testHilogError004 start"); + try { + hilog.error(0xffff, "HILOGTEST", "%{public}s", ["hilogJs0100"]); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogError004 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogError004 end"); + }); + + /** + * @tc.number: TEST_HILOG_ERROR_005 + * @tc.name : testHilogError005 + * @tc.desc : The log tool can read white app log types when domain off. + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogError005", 2, function () { + console.info("testHilogError005 start"); + try { + hilog.error(0xd003200, "HILOGTEST", "%{public}s", ["hilogJs0200"]); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogError005 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogError005 end"); + }); + + /** + * @tc.number: TEST_HILOG_FATAL_001 + * @tc.name : testHilogFatal001 + * @tc.desc : Print FATAL level logs + * @tc.size : MediumTest + * @tc.type : Method + * @tc.level : Level 2 + */ + it("testHilogFatal001", 2, function () { + console.info("testHilogFatal001 start"); + try { + hilog.fatal(0x3200, "HILOGTEST", "%{public}s", "hilogJs0300"); + expect(true).assertTrue(); + } catch (error) { + console.log(`testHilogFatal001 got an error: ${JSON.stringify(error)}`); + expect().assertFail(); + } + console.info("testHilogFatal001 end"); + }); + }); +} diff --git a/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/module.json b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/module.json new file mode 100644 index 0000000000000000000000000000000000000000..a4443e713ad997179d4e68fbe682c1969fa541a0 --- /dev/null +++ b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/module.json @@ -0,0 +1,36 @@ +{ + "module": { + "name": "entry_test", + "type": "feature", + "description": "$string:module_test_desc", + "mainElement": "TestAbility", + "deviceTypes": [ + "phone" + ], + "deliveryWithInstall": true, + "installationFree": false, + "pages": "$profile:test_pages", + "abilities": [ + { + "name": "TestAbility", + "srcEntry": "./ets/TestAbility/TestAbility.ets", + "description": "$string:TestAbility_desc", + "icon": "$media:icon", + "label": "$string:TestAbility_label", + "exported": true, + "startWindowIcon": "$media:icon", + "startWindowBackground": "$color:start_window_background", + "skills": [ + { + "actions": [ + "action.system.home" + ], + "entities": [ + "entity.system.home" + ] + } + ] + } + ] + } +} diff --git a/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/resources/base/element/color.json b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/resources/base/element/color.json new file mode 100644 index 0000000000000000000000000000000000000000..3c712962da3c2751c2b9ddb53559afcbd2b54a02 --- /dev/null +++ b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/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/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/resources/base/element/string.json b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/resources/base/element/string.json new file mode 100644 index 0000000000000000000000000000000000000000..65d8fa5a7cf54aa3943dcd0214f58d1771bc1f6c --- /dev/null +++ b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/resources/base/element/string.json @@ -0,0 +1,16 @@ +{ + "string": [ + { + "name": "module_test_desc", + "value": "test ability description" + }, + { + "name": "TestAbility_desc", + "value": "the test ability" + }, + { + "name": "TestAbility_label", + "value": "test label" + } + ] +} \ No newline at end of file diff --git a/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/resources/base/media/icon.png b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/resources/base/media/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..ce307a8827bd75456441ceb57d530e4c8d45d36c Binary files /dev/null and b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/resources/base/media/icon.png differ diff --git a/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/resources/base/profile/test_pages.json b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/resources/base/profile/test_pages.json new file mode 100644 index 0000000000000000000000000000000000000000..77e90731b5a38d861663029b483df3d3ac9ec74b --- /dev/null +++ b/hiviewdfx/crossplatform/hiviewdfxhilogetstest/src/main/resources/base/profile/test_pages.json @@ -0,0 +1,5 @@ +{ + "src": [ + "TestAbility/pages/Index" + ] +}