add powermgr testcase for rk3568

Signed-off-by: Nlogic42 <wanglong108@huawei.com>

powermgr/BUILD.gn

@@ -13,8 +13,13 @@
 import("//build/ohos_var.gni")
 group("powermgr") {
   testonly = true
-
+  if (device_name == "rk3568") {
+    if (is_standard_system) {
+      deps = [ "powermgrbattery_rk3568:powermgr_battery_test_rk3568" ]
+    }
+  } else {
     if (is_standard_system) {
       deps = [ "powermgrbattery:powermgr_battery_test" ]
     }
+  }
 }

powermgr/powermgrbattery_rk3568/BUILD.gn

+# Copyright (C) 2021 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("powermgr_battery_test_rk3568") {
+  hap_profile = "./src/main/config.json"
+  deps = [
+    ":powermgr_battery_js_assets",
+    ":powermgr_battery_resources",
+  ]
+  certificate_profile = "./signature/openharmony_sx.p7b"
+  hap_name = "ActsPowerMgrBatteryTest"
+}
+ohos_js_assets("powermgr_battery_js_assets") {
+  source_dir = "./src/main/js/default"
+}
+ohos_resources("powermgr_battery_resources") {
+  sources = [ "./src/main/resources" ]
+  hap_profile = "./src/main/config.json"
+}

powermgr/powermgrbattery_rk3568/Test.json

+{
+    "description": "Configuration for powermgr battery Tests",
+    "driver": {
+        "type": "JSUnitTest",
+        "test-timeout": "60000",
+        "package": "com.example.mybatteryapp",
+        "shell-timeout": "60000"
+    },
+    "kits": [
+        {
+            "test-file-name": [
+                "ActsPowerMgrBatteryTest.hap"
+            ],
+            "type": "AppInstallKit",
+            "cleanup-apps": true
+        }
+    ]
+}
+

powermgr/powermgrbattery_rk3568/src/main/config.json

+{
+  "app": {
+    "bundleName": "com.example.mybatteryapp",
+    "vendor": "example",
+    "version": {
+      "code": 1,
+      "name": "1.0"
+    },
+    "apiVersion": {
+      "compatible": 4,
+      "target": 5
+    }
+  },
+  "deviceConfig": {},
+  "module": {
+    "package": "com.example.mybatteryapp",
+    "name": ".MyApplication",
+    "deviceType": [
+      "phone"
+    ],
+    "distro": {
+      "deliveryWithInstall": true,
+      "moduleName": "entry",
+      "moduleType": "entry"
+    },
+    "abilities": [
+      {
+        "visible": true,
+        "skills": [
+          {
+            "entities": [
+              "entity.system.home"
+            ],
+            "actions": [
+              "action.system.home"
+            ]
+          }
+        ],
+        "name": "com.example.mybatteryapp.MainAbility",
+        "icon": "$media:icon",
+        "description": "$string:mainability_description",
+        "label": "$string:app_name",
+        "type": "page",
+        "launchType": "standard"
+      }
+    ],
+    "js": [
+      {
+        "pages": [
+          "pages/index/index"
+        ],
+        "name": "default",
+        "window": {
+          "designWidth": 720,
+          "autoDesignWidth": false
+        }
+      }
+    ]
+  }
+}

powermgr/powermgrbattery_rk3568/src/main/js/default/app.js

+/*
+ * Copyright (C) 2021 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 device from '@system.device';
+
+export default {
+    onCreate() {
+        console.info('AceApplication onCreate');
+    },
+    onDestroy() {
+        console.info('AceApplication onDestroy');
+    }
+};

powermgr/powermgrbattery_rk3568/src/main/js/default/i18n/en-US.json

+{
+  "strings": {
+    "hello": "Hello",
+    "world": "World"
+  }
+}
\ No newline at end of file

powermgr/powermgrbattery_rk3568/src/main/js/default/i18n/zh-CN.json

+{
+  "strings": {
+    "hello": "您好",
+    "world": "世界"
+  }
+}
\ No newline at end of file

powermgr/powermgrbattery_rk3568/src/main/js/default/pages/index/index.css

+.container {
+    flex-direction: column;
+    justify-content: center;
+    align-items: center;
+}
+
+.title {
+    font-size: 100px;
+}

powermgr/powermgrbattery_rk3568/src/main/js/default/pages/index/index.hml

+<div class="container">
+    <text class="title">
+        {{ $t('strings.hello') }} {{ title }}
+    </text>
+</div>

powermgr/powermgrbattery_rk3568/src/main/js/default/pages/index/index.js

+/*
+ * Copyright (C) 2021 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 app from '@system.app'
+
+import {Core, ExpectExtend} from 'deccjsunit/index'
+
+export default {
+    data: {
+        title: ""
+    },
+    onInit() {
+        this.title = this.$t('strings.world');
+    },
+    onShow() {
+        console.info('onShow finish')
+        const core = Core.getInstance()
+        const expectExtend = new ExpectExtend({
+            'id': 'extend'
+        })
+        core.addService('expect', expectExtend)
+//        core.addService('report', instrumentLog)
+        core.init()
+//        core.subscribeEvent('spec', instrumentLog)
+//        core.subscribeEvent('suite', instrumentLog)
+//        core.subscribeEvent('task', instrumentLog)
+
+        const configService = core.getDefaultService('config')
+        configService.setConfig(this)
+
+        require('../../test/List.test')
+        core.execute()
+    },
+    onReady() {
+    },
+}
\ No newline at end of file

powermgr/powermgrbattery_rk3568/src/main/js/default/test/List.test.js

+/*
+ * Copyright (C) 2021 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.
+ */
+require('./battery_unit.test.js')
+require('./power_manager_running_lock.test.js')
\ No newline at end of file

powermgr/powermgrbattery_rk3568/src/main/js/default/test/battery_unit.test.js

++137/*
+ * Copyright (C) 2021 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 app from '@system.app'
+import Context from '@ohos.napi_context'
+import batteryInfo from '@ohos.batteryInfo';
+import brightness from '@ohos.brightness';
+import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index'
+
+describe('appInfoTest', function () {
+  console.log("*************Battery Unit Test Begin*************");
+  
+  /**
+   * @tc.number battery_manager_js_0100
+   * @tc.name battery_soc_test
+   * @tc.desc Battery acquisition kit
+   */
+  it('battery_soc_test', 0, function () {
+    var batterySoc = batteryInfo.batterySOC;
+    console.info('batterySoc = ' + batterySoc);
+    expect(batterySoc >= -1 && batterySoc <= 100).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_0200
+   * @tc.name charging_status_test
+   * @tc.desc Battery charging kit
+   */
+  it('charging_status_test', 0, function () {
+    var chargingStatus = batteryInfo.chargingStatus;
+    console.info('chargingStatus = ' + chargingStatus);
+    expect(chargingStatus >= 0 && chargingStatus <= 4).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_0300
+   * @tc.name health_status_test
+   * @tc.desc Get Battery Health Get KIT
+   */
+  it('health_status_test', 0, function () {
+    var healthStatus = batteryInfo.healthStatus;
+    console.info('healthStatus = ' + healthStatus);
+    expect(healthStatus >= 0 && healthStatus <= 6).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_0400
+   * @tc.name plugged_type_test
+   * @tc.desc Obtaining the USB Connection Type KIT
+   */
+  it('plugged_type_test', 0, function () {
+    var pluggedType = batteryInfo.pluggedType;
+    console.info('pluggedType = ' + pluggedType);
+    expect(pluggedType >= 0 && pluggedType <= 4).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_0500
+   * @tc.name voltage_test
+   * @tc.desc Obtaining the Voltage Interface KIT
+   */
+  it('voltage_test', 0, function () {
+    var voltage = batteryInfo.voltage;
+    console.info('voltage = ' + voltage);
+    expect(voltage >= -1).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_0600
+   * @tc.name technology_test
+   * @tc.desc Obtaining the Battery Technology Interface KIT
+   */
+  it('technology_test', 0, function () {
+    var technology = batteryInfo.technology;
+    console.info('technology = ' + technology);
+    expect(technology !== null).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_0700
+   * @tc.name battery_temperature_test
+   * @tc.desc BatteryTemperature values Interface Test
+   */
+  it('battery_temperature_test', 0, function () {
+    var batteryTemperature = batteryInfo.batteryTemperature;
+    console.info('batteryTemperature = ' + batteryTemperature);
+    expect(batteryTemperature <= 700).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_0800
+   * @tc.name enum_health_state_test_unknown
+   * @tc.desc BatteryHealthState values Interface Test
+   */
+  it('enum_health_state_test_unknown', 0, function () {
+    var batteryHealthState = batteryInfo.BatteryHealthState.UNKNOWN;
+    console.info('batteryHealthState = ' + batteryHealthState);
+    expect(batteryHealthState == 0).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_0900
+   * @tc.name enum_health_state_test_good
+   * @tc.desc BatteryHealthState values Interface Test
+   */
+  it('enum_health_state_test_good', 0, function () {
+    var batteryHealthState = batteryInfo.BatteryHealthState.GOOD;
+    console.info('batteryHealthState = ' + batteryHealthState);
+    expect(batteryHealthState == 1).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_1000
+   * @tc.name enum_health_state_test_overheat
+   * @tc.desc BatteryHealthState values Interface Test
+   */
+  it('enum_health_state_test_overheat', 0, function () {
+    var batteryHealthState = batteryInfo.BatteryHealthState.OVERHEAT;
+    console.info('batteryHealthState = ' + batteryHealthState);
+    expect(batteryHealthState == 2).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_1100
+   * @tc.name enum_health_state_test_overvoltage
+   * @tc.desc BatteryHealthState values Interface Test
+   */
+  it('enum_health_state_test_overvoltage', 0, function () {
+    var batteryHealthState = batteryInfo.BatteryHealthState.OVERVOLTAGE;
+    console.info('batteryHealthState = ' + batteryHealthState);
+    expect(batteryHealthState == 3).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_1200
+   * @tc.name enum_health_state_test_cold
+   * @tc.desc BatteryHealthState values Interface Test
+   */
+  it('enum_health_state_test_cold', 0, function () {
+    var batteryHealthState = batteryInfo.BatteryHealthState.COLD;
+    console.info('batteryHealthState = ' + batteryHealthState);
+    expect(batteryHealthState == 4).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_1300
+   * @tc.name enum_health_state_test_dead
+   * @tc.desc BatteryHealthState values Interface Test
+   */
+  it('enum_health_state_test_dead', 0, function () {
+    var batteryHealthState = batteryInfo.BatteryHealthState.DEAD;
+    console.info('batteryHealthState = ' + batteryHealthState);
+    expect(batteryHealthState == 5).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_1400
+   * @tc.name enum_charge_state_test_none
+   * @tc.desc BatteryChargeState values Interface Test
+   */
+  it('enum_charge_state_test_none', 0, function () {
+    var batteryChargeState = batteryInfo.BatteryChargeState.NONE;
+    console.info('batteryChargeState = ' + batteryChargeState);
+    expect(batteryChargeState == 0).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_1500
+   * @tc.name enum_charge_state_test_enable
+   * @tc.desc BatteryChargeState values Interface Test
+   */
+  it('enum_charge_state_test_enable', 0, function () {
+    var batteryChargeState = batteryInfo.BatteryChargeState.ENABLE;
+    console.info('batteryChargeState = ' + batteryChargeState);
+    expect(batteryChargeState == 1).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_1600
+   * @tc.name enum_charge_state_test_disable
+   * @tc.desc BatteryChargeState values Interface Test
+   */
+  it('enum_charge_state_test_disable', 0, function () {
+    var batteryChargeState = batteryInfo.BatteryChargeState.DISABLE;
+    console.info('batteryChargeState = ' + batteryChargeState);
+    expect(batteryChargeState == 2).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_1700
+   * @tc.name enum_charge_state_test_full
+   * @tc.desc BatteryChargeState values Interface Test
+   */
+  it('enum_charge_state_test_full', 0, function () {
+    var batteryChargeState = batteryInfo.BatteryChargeState.FULL;
+    console.info('batteryChargeState = ' + batteryChargeState);
+    expect(batteryChargeState == 3).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_1800
+   * @tc.name enum_plugged_type_test_none
+   * @tc.desc BatteryPluggedType values Interface Test
+   */
+  it('enum_plugged_type_test_none', 0, function () {
+    var batteryPluggedType = batteryInfo.BatteryPluggedType.NONE;
+    console.info('batteryPluggedType = ' + batteryPluggedType);
+    expect(batteryPluggedType == 0).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_1900
+   * @tc.name enum_plugged_type_test_ac
+   * @tc.desc BatteryPluggedType values Interface Test
+   */
+  it('enum_plugged_type_test_ac', 0, function () {
+    var batteryPluggedType = batteryInfo.BatteryPluggedType.AC;
+    console.info('batteryPluggedType = ' + batteryPluggedType);
+    expect(batteryPluggedType == 1).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_2000
+   * @tc.name enum_plugged_type_test_usb
+   * @tc.desc BatteryPluggedType values Interface Test
+   */
+  it('enum_plugged_type_test_usb', 0, function () {
+    var batteryPluggedType = batteryInfo.BatteryPluggedType.USB;
+    console.info('batteryPluggedType = ' + batteryPluggedType);
+    expect(batteryPluggedType == 2).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_2100
+   * @tc.name enum_plugged_type_test_wireless
+   * @tc.desc BatteryPluggedType values Interface Test
+   */
+  it('enum_plugged_type_test_wireless', 0, function () {
+    var batteryPluggedType = batteryInfo.BatteryPluggedType.WIRELESS;
+    console.info('batteryPluggedType = ' + batteryPluggedType);
+    expect(batteryPluggedType == 3).assertTrue()
+  })
+
+  /**
+   * @tc.number battery_manager_js_2200
+   * @tc.name brightness_test
+   * @tc.desc Set Value Interface Test
+   */
+  it('brightness_test', 0, function () {
+    brightness.setValue(10);
+    brightness.setValue(0);
+    brightness.setValue(255);
+    expect(0 == 0).assertTrue();
+  })
+
+  /**
+   * @tc.number battery_manager_js_2300
+   * @tc.name is_battery_present_test
+   * @tc.desc Battry Present Interface Test
+   */
+  it('is_battery_present_test', 0, function () {
+    var isBatteryPresent = batteryInfo.isBatteryPresent;
+    console.info('isBatteryPresent = ' + isBatteryPresent);
+    if (isBatteryPresent) {
+        expect(isBatteryPresent).assertTrue();
+    }else{
+        expect(isBatteryPresent).assertFalse();        
+    }
+  })
+})
\ No newline at end of file

powermgr/powermgrbattery_rk3568/src/main/js/default/test/power_manager_running_lock.test.js

+/*
+ * Copyright (C) 2021 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 app from '@system.app'
+import Context from '@ohos.napi_context'
+import runningLock from '@ohos.runningLock';
+import power from '@ohos.power';
+import '@ohos.permission.RUNNING_LOCK'
+
+import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index'
+
+describe('appInfoTest', function () {
+    console.log("*************Power Unit Test Begin*************");
+    //createRunningLock(name: string, type: RunningLockType): Promise<RunningLock>
+    it('create_running_lock_promise_test', 0, async function (done) {
+        runningLock.createRunningLock("running_lock_test_1", runningLock.RunningLockType.BACKGROUND)
+        .then(runninglock => {
+            expect(runninglock !== null).assertTrue();
+            console.info('create_running_lock_promise_test success');
+            done();
+        })
+        .catch(error => {
+            console.log('create_running_lock_promise_test error: ' + error);
+            expect().assertFail();
+            done();
+        })
+    })
+    //createRunningLock(name: string, type: RunningLockType, callback: AsyncCallback<RunningLock>)
+    it('create_running_lock_callback_test', 0, async function (done) {
+        runningLock.createRunningLock("running_lock_test_2", runningLock.RunningLockType.BACKGROUND,
+		(error, runninglock) => {
+            if (typeof error === "undefined") {
+                console.info('create_running_lock_callback_test: runningLock is ' + runninglock);
+                expect(runninglock !== null).assertTrue();
+                var used = runninglock.isUsed();
+                console.info('create_running_lock_callback_test is used: ' + used);
+                expect(used).assertFalse();
+                runninglock.lock(500);
+                used = runninglock.isUsed();
+                console.info('after lock create_running_lock_callback_test is used: ' + used);
+                expect(used).assertTrue();
+                console.info('create_running_lock_callback_test success');
+                done();
+            } else {
+                console.log('create_running_lock_callback_test: ' + error);
+                expect().assertFail();
+                done();
+            }
+        })
+    })
+    //lock(timeout: number)
+    it('running_lock_lock_test', 0, async function (done) {
+        runningLock.createRunningLock("running_lock_test_3", runningLock.RunningLockType.BACKGROUND)
+        .then(runninglock => {
+            expect(runninglock !== null).assertTrue();
+            var used = runninglock.isUsed();
+            console.info('running_lock_lock_test is used: ' + used);
+            expect(used).assertFalse();
+            runninglock.lock(500);
+            used = runninglock.isUsed();
+            console.info('after lock running_lock_lock_test is used: ' + used);
+            expect(used).assertTrue();
+            console.info('running_lock_lock_test success');
+            done();
+        })
+        .catch(error => {
+            console.log('running_lock_lock_test error: ' + error);
+            expect().assertFail();
+            done();
+        })
+    })
+    //isUsed()
+    it('running_lock_isused_test', 0, async function (done) {
+        runningLock.createRunningLock("running_lock_test_4", runningLock.RunningLockType.BACKGROUND)
+        .then(runninglock => {
+            expect(runninglock !== null).assertTrue();
+            var used = runninglock.isUsed();
+            console.info('running_lock_isused_test used: ' + used);
+            expect(used).assertFalse();
+            console.info('running_lock_isused_test success');
+            done();
+        })
+        .catch(error => {
+            console.log('running_lock_isused_test error: ' + error);
+            expect().assertFail();
+            done();
+        })
+    })
+    //unlock()
+    it('running_lock_unlock_test', 0, async function (done) {
+        runningLock.createRunningLock("running_lock_test_5", runningLock.RunningLockType.BACKGROUND)
+        .then(runninglock => {
+            expect(runninglock !== null).assertTrue();
+            var used = runninglock.isUsed();
+            console.info('running_lock_unlock_test is used: ' + used);
+            expect(used).assertFalse();
+            runninglock.lock(500);
+            used = runninglock.isUsed();
+            console.info('after lock running_lock_unlock_test is used: ' + used);
+            expect(used).assertTrue();
+            runninglock.unlock();
+            used = runninglock.isUsed();
+            console.info('after unlock running_lock_unlock_test is used: ' + used);
+            expect(used).assertFalse();
+            console.info('running_lock_unlock_test success');
+            done();
+        })
+        .catch(error => {
+            console.log('running_lock_unlock_test error: ' + error);
+            expect().assertFail();
+            done();
+        })
+    })
+    //Runninglock锁的类型为BACKGROUND
+    it('enum_runningLock_type_background_test', 0, function () {
+        var runningLockType = runningLock.RunningLockType.BACKGROUND;
+        console.info('runningLockType = ' + runningLockType);
+        expect(runningLockType == 1).assertTrue();
+        console.info('enum_runningLock_type_background_test success');
+    })
+    //Runninglock锁的类型为PROXIMITY_SCREEN_CONTROL
+    it('enum_runningLock_type_proximityscreencontrol_test', 0, function () {
+        var runningLockType = runningLock.RunningLockType.PROXIMITY_SCREEN_CONTROL;
+        console.info('runningLockType = ' + runningLockType);
+        expect(runningLockType == 2).assertTrue();
+        console.info('enum_runningLock_type_proximityscreencontrol_test success');
+    })
+    //isRunningLockTypeSupported(type: RunningLockType): Promise<boolean>
+    it('is_runninglock_type_supported_promise_test_1', 0, async function (done) {
+        runningLock.isRunningLockTypeSupported(runningLock.RunningLockType.PROXIMITY_SCREEN_CONTROL)
+        .then(supported => {
+            console.info('is_runninglock_type_supported_test_1 PROXIMITY_SCREEN_CONTROL supported is ' + supported);
+            expect(supported).assertTrue();
+            console.info('is_runninglock_type_supported_test_1 success');
+            done();
+        })
+        .catch(error => {
+            console.log('is_runninglock_type_supported_test_1 error: ' + error);
+            expect().assertFail();
+            done();
+        })
+    })
+    //isRunningLockTypeSupported(type: RunningLockType)  多余
+    it('is_runninglock_type_supported_promise_test_2', 0, async function (done) {
+        runningLock.isRunningLockTypeSupported(runningLock.RunningLockType.BACKGROUND)
+        .then(supported => {
+            console.info('is_runninglock_type_supported_promise_test_2 BACKGROUND supported is ' + supported);
+            expect(supported).assertTrue();
+            console.info('is_runninglock_type_supported_promise_test_2 success');
+            done();
+        })
+        .catch(error => {
+            console.log('is_runninglock_type_supported_promise_test_2 error: ' + error);
+            expect().assertFail();
+            done();
+        })
+    })
+    //isRunningLockTypeSupported(type: RunningLockType, callback: AsyncCallback<boolean>)
+    it('is_runninglock_type_supported_callback_test_3', 0, async function (done) {
+        runningLock.isRunningLockTypeSupported(runningLock.RunningLockType.BACKGROUND, (error, supported) => {
+            if (typeof error === "undefined") {
+                console.info('is_runninglock_type_supported_callback_test_3 BACKGROUND supported is ' + supported);
+                expect(supported).assertTrue();
+                console.info('is_runninglock_type_supported_callback_test_3 success');
+                done();
+            } else {
+                console.log('is_runninglock_type_supported_callback_test_3: ' + error);
+                expect().assertFail();
+                done();
+            }
+        })
+    })
+    it('power_is_screen_on_promise_test', 0, async function (done) {//isScreenOn(): Promise<boolean>
+        power.isScreenOn()
+        .then(screenOn => {
+            console.info('power_is_screen_on_promise_test screenOn is ' + screenOn);
+            expect(screenOn).assertTrue();
+            console.info('power_is_screen_on_promise_test success');
+            done();
+        })
+        .catch(error => {
+            console.log('power_is_screen_on_promise_test error: ' + error);
+            expect().assertFail();
+            done();
+        })
+    })
+    it('power_is_screen_on_callback_test', 0, async function (done) {//isScreenOn(callback: AsyncCallback<boolean>)
+        power.isScreenOn((error, screenOn) => {
+            if (typeof error === "undefined") {
+                console.info('power_is_screen_on_callback_test screenOn is ' + screenOn);
+                expect(screenOn).assertTrue();
+                console.info('power_is_screen_on_callback_test success');
+                done();
+            } else {
+                console.log('power_is_screen_on_callback_test: ' + error);
+                expect().assertFail();
+                done();
+            }
+        })
+    })
+})

powermgr/powermgrbattery_rk3568/src/main/resources/base/element/string.json

+{
+  "string": [
+    {
+      "name": "app_name",
+      "value": "MyBatteryApp"
+    },
+    {
+      "name": "mainability_description",
+      "value": "JS_Phone_Empty Feature Ability"
+    }
+  ]
+}
\ No newline at end of file