hujixiang1@huawei.com

Signed-off-by: Nhu-jixiang1 <hujixiang1@huawei.com>
Change-Id: I75d293034a867d21254cafda7956abef6722f3e3

useriam/BUILD.gn

@@ -16,6 +16,9 @@ import("//test/xts/tools/build/suite.gni")
 group("useriam") {
   testonly = true
   if (is_standard_system) {
-    deps = [ "face_auth/js_api_test/function_test/userauth:ActsUserauthTest" ]
+    deps = [
+      "face_auth/js_api_test/function_test/userauth:ActsUserauthTest",
+      "face_auth/js_api_test/function_test/userauthpart2:ActsUserauthTwoTest",
+    ]
   }
 }

useriam/face_auth/js_api_test/function_test/userauthpart2/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("ActsUserauthTwoTest") {
+  hap_profile = "./entry/src/main/config.json"
+  deps = [
+    ":hjs_demo_js_assets",
+    ":hjs_demo_resources",
+  ]
+  certificate_profile = "./signature/openharmony_sx.p7b"
+  hap_name = "ActsUserauthTwoTest"
+}
+ohos_js_assets("hjs_demo_js_assets") {
+  source_dir = "./entry/src/main/js/default"
+}
+ohos_resources("hjs_demo_resources") {
+  sources = [ "./entry/src/main/js/resources" ]
+  hap_profile = "./entry/src/main/config.json"
+}

useriam/face_auth/js_api_test/function_test/userauthpart2/Test.json

+{
+    "description": "Configuration for hjunit demo Tests",
+    "driver": {
+        "type": "JSUnitTest",
+        "test-timeout": "900000",
+        "package": "com.example.myapplication101",
+        "shell-timeout": "600000"
+    },
+    "kits": [
+        {
+            "test-file-name": [
+                "ActsUserauthTwoTest.hap"
+            ],
+            "type": "AppInstallKit",
+            "cleanup-apps": true
+        },
+        {
+            "type": "ShellKit",
+            "run-command": [
+                "remount",
+                "mkdir /data/test"
+            ]
+        },
+        {
+            "type": "PushKit",
+            "push": [
+                "ActsUserauthTwoTest.hap->/data/test/ActsUserauthTwoTest.hap"
+            ]
+        },
+        {
+            "type": "ShellKit",
+            "run-command": [
+                "chmod 644 /data/test/*.hap",
+		"chmod 777 -R data"
+            ]
+        }
+    ]
+}

useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/config.json

+{
+  "app": {
+    "bundleName": "com.example.myapplication101",
+    "vendor": "example",
+    "version": {
+      "code": 12,
+      "name": "1.0.0"
+    },
+    "apiVersion": {
+      "compatible": 4,
+      "target": 5,
+      "releaseType": "Beta1"
+    }
+  },
+  "deviceConfig": {},
+  "module": {
+    "package": "com.example.myapplication101",
+    "name": ".MyApplication",
+    "mainAbility": "com.example.myapplication101.MainAbility",
+    "deviceType": [
+      "phone",
+      "tablet",
+      "tv",
+      "wearable"
+    ],
+    "distro": {
+      "deliveryWithInstall": true,
+      "moduleName": "entry",
+      "moduleType": "entry",
+      "installationFree": false
+    },
+    "abilities": [
+      {
+        "skills": [
+          {
+            "entities": [
+              "entity.system.home"
+            ],
+            "actions": [
+              "action.system.home"
+            ]
+          }
+        ],
+        "name": "com.example.myapplication101.MainAbility",
+        "icon": "$media:icon",
+        "description": "$string:mainability_description",
+        "label": "$string:entry_MainAbility",
+        "type": "page",
+        "launchType": "standard",
+        "visible": true
+      }
+    ],
+    "js": [
+      {
+        "pages": [
+          "pages/index/index"
+        ],
+        "name": "default",
+        "window": {
+          "designWidth": 720,
+          "autoDesignWidth": true
+        }
+      }
+    ],
+    "reqPermissions": [
+      {
+        "reason": "reason_manage_face",
+        "usedScene": {
+          "ability": ["com.myface.Ability","com.myface.AbilityBackground"],
+          "when": "always"
+        },
+        "name": "ohos.permission.MANAGE_FACE"
+      },
+      {
+        "reason": "reason_access_biometric",
+        "usedScene": {
+          "ability": ["com.mybiometric.Ability","com.mybiometric.AbilityBackground"],
+          "when": "always"
+        },
+        "name": "ohos.permission.ACCESS_BIOMETRIC"
+      }
+    ]
+  }
+}

useriam/face_auth/js_api_test/function_test/userauthpart2/entry/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.
+ */
+
+export default {
+    onCreate() {
+        console.info('AceApplication onCreate');
+    },
+    onDestroy() {
+        console.info('AceApplication onDestroy');
+    }
+};

useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/default/i18n/en-US.json

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

useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/default/i18n/zh-CN.json

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

useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/default/pages/index/index.css

+.container {
+    flex-direction: column;
+    justify-content: center;
+    align-items: center;
+    width: 100%;
+    height: 100%;
+}
+
+.title {
+    font-size: 40px;
+    color: #000000;
+    opacity: 0.9;
+}
+
+@media screen and (device-type: tablet) and (orientation: landscape) {
+    .title {
+        font-size: 100px;
+    }
+}
+
+@media screen and (device-type: wearable) {
+    .title {
+        font-size: 28px;
+        color: #FFFFFF;
+    }
+}
+
+@media screen and (device-type: tv) {
+    .container {
+        background-image: url("/common/images/Wallpaper.png");
+        background-size: cover;
+        background-repeat: no-repeat;
+        background-position: center;
+    }
+
+    .title {
+        font-size: 100px;
+        color: #FFFFFF;
+    }
+}
+
+@media screen and (device-type: phone) and (orientation: landscape) {
+    .title {
+        font-size: 60px;
+    }
+}

useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/default/pages/index/index.hml

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

useriam/face_auth/js_api_test/function_test/userauthpart2/entry/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 {Core, ExpectExtend} from 'deccjsunit/index'
+import fileio from '@ohos.fileio'
+
+export default {
+    data: {
+        title: ""
+    },
+    onInit() {
+        this.title = this.$t('strings.world');
+    },
+    onShow() {
+        console.info('onShow start')
+        const core = Core.getInstance()
+        const expectExtend = new ExpectExtend({
+            'id': 'extend'
+        })
+        core.addService('expect', expectExtend)
+        core.init()
+        const configService = core.getDefaultService('config')
+        this.timeout = 35000;
+        configService.setConfig(this)
+        require('../../../test/List.test.js')
+        core.execute()
+        console.info('onShow end')
+    },
+    onReady() {
+    },
+}

useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/resources/base/element/string.json

+{
+  "string": [
+    {
+      "name": "entry_MainAbility",
+      "value": "entry_MainAbility"
+    },
+    {
+      "name": "mainability_description",
+      "value": "JS_Empty Ability"
+    }
+  ]
+}
\ No newline at end of file

useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/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("./Security_IAM_PIN_Func_CallbackJsunit.test.js")
+require("./Security_IAM_Coauth_Func_CallbackJsunit.test.js")
+require("./Security_IAM_Face_Func_CallbackJsunit.test.js")
\ No newline at end of file

useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/test/Publicfunction-n.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 {describe, it, expect} from 'deccjsunit/index'
+import userIDM from '@ohos.useridm'
+import pinAuth from '@ohos.pinauth'
+import userAuth from '@ohos.userauth'
+
+let UserIDM = null
+let PinAuth = null
+let UserAuth = null
+
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+//同步
+function publicRegisterInputer(PinAuth,AuthSubType,Inputerdata){
+    console.info('testFace publicRegisterInputer in');
+    try {
+        console.info('testFace publicRegisterInputer in try');
+        console.info('testFace publicRegisterInputer PinAuth = ' + PinAuth);
+        let registerresult = PinAuth.registerInputer({
+            onGetData: (AuthSubType, IInputData) => {
+                console.info('testFace faceDemo registerInputer AuthSubType');
+                console.info('testFace faceDemo registerInputer AuthSubType111');
+                IInputData.onSetData(AuthSubType, Inputerdata)
+            }
+        })
+        console.log("testFace publicRegisterInputer result is: " + registerresult);
+        return registerresult;
+    }
+    catch (e) {
+        console.log("testFace publicRegisterInputer fail " + e);
+        expect(null).assertFail();
+    }
+}
+
+function publicunRegisterInputer(PinAuth,callback){
+    console.info('testFace publicunRegisterInputer in');
+    try {
+        console.info('testFace publicunRegisterInputer in try');
+        console.info('testFace publicunRegisterInputer PinAuth = ' + PinAuth);
+        let unRegist = 1;
+        PinAuth.unregisterInputer();
+        callback(unRegist)
+    }
+    catch (e) {
+        console.log("testFace publicRegisterInputer fail " + e);
+        expect(null).assertFail();
+    }
+}
+
+function publicOpenSession(UserIDM,callback){
+    console.info('testFace publicOpenSession in');
+    try {
+        console.info('testFace publicOpenSession in try');
+        console.info('testFace faceDemo UserIDM = ' + UserIDM);
+        let challenge = null
+        UserIDM.openSession( function(data){
+            try{
+                console.log("testFace before get challenge");
+                console.log("testFace + " + data);
+                challenge = data;
+                console.log("testFace end ");
+                console.log("testFace after get challenge");
+                callback(challenge);
+                expect(true).assertEqual(challenge != null);
+            }
+            catch(e) {
+                console.info('testFace faceDemo openSession error = ' + JSON.stringify(e));
+            }
+        });
+    }
+    catch (e) {
+        console.log("testFace publicOpenSession fail " + e);
+        console.log(e);
+        expect(null).assertFail();
+    }
+}
+
+function publicCloseSession(UserIDM,callback){
+    console.info('testFace publicCloseSession in');
+    try {
+        console.info('testFace publicCloseSession in try');
+        console.info('testFace publicCloseSession UserIDM = ' + UserIDM);
+        let closesession = 0;
+        UserIDM.closeSession();
+        callback(closesession);
+    }
+    catch (e) {
+        console.log("testFace publicCloseSession fail " + e);
+        expect(null).assertFail();
+    }}
+
+async function publicaddCredential(UserIDM,CredentialInfo,callback1,callback2){
+    console.info('testFace publicaddCredential in');
+    try {
+        console.info('testFace publicaddCredential in try');
+        let onresult = {
+            addCredresult: null,
+            credentialId: null,
+        }
+        let onAcquireInfo = {
+            addCredmodule : null,
+            addCredacquire : null,
+            addCredextr : null
+        }
+        console.info('faceTest publicaddCredential UserIDM = ' + UserIDM);
+        UserIDM.addCredential(CredentialInfo, {
+            onResult: function(result,extraInfo){
+                console.info("testFace addCredential result = " + result);
+                console.info("testFace addCredential extraInfo = " + JSON.stringify(extraInfo));
+                console.log(result)
+                onresult.addCredresult= result;
+                if(extraInfo != undefined) {
+                    onresult.credentialId = extraInfo.credentialId
+                } else {
+                    onresult.credentialId = null;
+                }
+                callback1(onresult)
+            },
+            onAcquireInfo:function (modulea,acquire,extr){
+                console.info('testFace publicaddCredential onAcquireInfo in');
+                onAcquireInfo.addCredmodule = modulea;
+                onAcquireInfo.addCredacquire = acquire;
+                onAcquireInfo.addCredextr = extr;
+                console.info('testFace publicaddCredential onAcquireInfo =' + JSON.stringify(onAcquireInfo));
+                console.info(modulea);
+                callback2(onAcquireInfo)
+            },
+        })
+    }
+    catch (e) {
+        console.log("testFace publicaddCredential fail " + e);
+        expect(null).assertFail();
+    }
+}
+
+function publicupdateCred(UserIDM,CredentialInfo,callback1,callback2){
+    console.info('testFace publicupdateCred in');
+    try {
+        console.info('testFace publicupdateCred in try');
+        console.info('testFace publicupdateCred UserIDM = ' + UserIDM);
+        let onresult = {
+            updateCredresult: null,
+            CredentialId: null,
+        }
+        let onacquireinfo = {
+            updateCredmodule : null,
+            updateCredacquire : null,
+            updateCredextr : null
+        }
+        UserIDM.updateCredential(CredentialInfo, {
+            onResult: function(result,extraInfo){
+                console.log("testFace faceDemo updateCredential result = " + result)
+                onresult.updateCredresult = result
+                console.log("testFace faceDemo updateCredential credentialId = " + extraInfo.credentialId)
+                if(extraInfo != undefined) {
+                    onresult.CredentialId = extraInfo.credentialId
+                } else {
+                    onresult.CredentialId = null;
+                }
+                console.info('testFace publicupdateCred updateCredential  onResult = ' + JSON.stringify(onresult));
+                callback1(onresult)
+            },
+            onAcquireInfo:function (modulea,acquire,extr){
+                console.info('testFace publicupdateCred updateCredential  onAcquireInfo in ');
+                onacquireinfo.updateCredmodule = modulea
+                onacquireinfo.updateCredacquire = acquire
+                onacquireinfo.updateCredextr = extr
+                console.info('testFace public updateCredential onacquireinfo = ' + JSON.stringify(onacquireinfo));
+                console.log("testFace faceDemo updateCredential module = " + modulea)
+                callback2(onacquireinfo)
+            }
+        })
+    }
+    catch (e) {
+        console.log("testFace publicupdateCred fail " + e);
+        expect(null).assertFail();
+    }
+}
+
+//同步
+function publiccancel(UserIDM,challenge){
+    console.info('testFace publiccancel in');
+    try {
+        console.info('testFace publiccancel in try');
+        console.info('testFace publiccancel UserIDM = ' + UserIDM);
+        let cancelresult = UserIDM.cancel(challenge)
+        console.log("testFace cancelresult is " + cancelresult);
+        return cancelresult
+    }
+    catch (e) {
+        console.log("testFace publiccancel fail " + e);
+        expect(null).assertFail();
+    }
+}
+
+function publicdelUser(UserIDM,token,callback1,callback2){
+    console.info('testFace publicdelUser in');
+    try {
+        console.info('testFace publicdelUser in try');
+        console.info('testFace publicdelUser UserIDM = ' + UserIDM);
+        let onresult = {
+            delUserresult: null,
+            CredentialId: null,
+        }
+        let onacquireinfo = {
+            delUsermodule : null,
+            delUseracquire : null,
+            delUserextr : null
+        }
+        UserIDM.delUser(token, {
+            onResult: function(result,extraInfo){
+                console.log("testFace faceDemo delUser result = " + result)
+                onresult.delUserresult = result
+                if(extraInfo != undefined) {
+                    onresult.CredentialId = extraInfo.credentialId
+                } else {
+                    onresult.CredentialId = null;
+                }
+                console.info('testFace publicdelUser delUser = ' + JSON.stringify(onresult));
+                callback1(onresult)
+            },
+            onAcquireInfo:function (modulea,acquire,extr){
+                console.log("testFace faceDemo delUser onAcquireInfo in ");
+                onacquireinfo.delUsermodule = modulea
+                onacquireinfo.delUseracquire = acquire
+                onacquireinfo.delUserextr = extr
+                console.log("testFace faceDemo delUser onAcquireInfo = " + JSON.stringify(onacquireinfo));
+                callback2(onacquireinfo)
+            }
+        })
+    }
+    catch (e) {
+        console.log("testFace publicdelUser fail " + e);
+        expect(null).assertFail();
+    }
+}
+
+function publicdelCred(UserIDM,credentialId,token,callback1,callback2){
+    console.info('testFace publicdelCred in');
+    try {
+        console.info('testFace publicdelCred in try');
+        console.info('testFace publicdelCred UserIDM = ' + UserIDM);
+        let onresult = {
+            delCredresult: null,
+            CredentialId: null,
+        }
+        let onacquireinfo = {
+            delCredmodule : null,
+            delCredacquire : null,
+            delCredextr : null
+        }
+        UserIDM.delCred(credentialId, token,{
+            onResult: function(result,extraInfo){
+                console.log("testFace faceDemo delCred result = " + result)
+                onresult.delCredresult = result
+                console.log("testFace faceDemo delCred extraInfo = " + extraInfo)
+                if(extraInfo != undefined) {
+                    onresult.CredentialId = extraInfo.credentialId
+                } else {
+                    onresult.CredentialId = null;
+                }
+                console.log("testFace faceDemo delCred onresult = " + JSON.stringify(onresult));
+                callback1(onresult)
+            },
+            onAcquireInfo:function (modulea,acquire,extr){
+                console.info('testFace publicdelCred delCred onAcquireInfo in');
+                onacquireinfo.delCredmodule = modulea
+                onacquireinfo.delCredacquire = acquire
+                onacquireinfo.delCredextr = extr
+                console.log("testFace faceDemo delCred module = " + modulea);
+                console.log("testFace faceDemo delCred onacquireinfo = " + JSON.stringify(onacquireinfo));
+                callback2(onacquireinfo)
+            }
+        })
+    }
+    catch (e) {
+        console.log("testFace publicdelCred fail " + e);
+        expect(null).assertFail();
+    }
+}
+
+function publicgetAuthInfo(UserIDM,authType,callback){
+    console.info('testFace publicgetAuthInfo in');
+    try {
+        console.info('testFace publicgetAuthInfo in try');
+        console.info('testFace publicgetAuthInfo UserIDM = ' + UserIDM);
+        UserIDM.getAuthInfo(authType, function (AsyncCallback) {
+            console.log("testFace faceDemo getAuthInfo AsyncCallback = " + JSON.stringify(AsyncCallback))
+            callback(AsyncCallback)
+        })
+    }
+    catch (e) {
+        console.log("testFace publicgetAuthInfo fail " + e);
+        expect(null).assertFail();
+    }
+}
+
+function publicgetallAuthInfo(UserIDM,callback){
+    console.info('testFace publicgetallAuthInfo in');
+    try {
+        console.info('testFace publicgetallAuthInfo in try');
+        console.info('testFace publicgetallAuthInfo UserIDM = ' + UserIDM);
+        UserIDM.getAuthInfo(function (AsyncCallback) {
+            console.log("testFace faceDemo getallAuthInfo AsyncCallback = " + JSON.stringify(AsyncCallback))
+            callback(AsyncCallback)
+        })
+    }
+    catch (e) {
+        console.log("testFace publicgetallAuthInfo fail " + e);
+        expect(null).assertFail();
+    }
+}
+
+//同步
+function publicgetAvailabeStatus(UserAuth,authType,authTrustLevel){
+    console.info('testFace publicgetAvailabeStatus in');
+    try {
+        console.info('testFace publicgetAvailabeStatus in try');
+        console.info('testFace publicgetAvailabeStatus UserAuth = ' + UserAuth);
+        let AvailabeStatus = null
+        AvailabeStatus = UserAuth.getAvailabeStatus(authType, authTrustLevel);
+        console.info('testFace publicgetAvailabeStatus result = ' + JSON.stringify(AsyncCallback));
+        return AvailabeStatus
+    }
+    catch (e) {
+        console.log("testFace publicgetAvailabeStatus fail " + e);
+        expect(null).assertFail();
+    }
+}
+
+function publicgetProperty(UserAuth,GetPropertyRequest,callback){
+    console.info('testFace publicgetProperty in');
+    try {
+        console.info('testFace publicgetProperty in try');
+        console.info('testFace publicgetProperty UserAuth = ' + UserAuth);
+        UserAuth.getProperty(GetPropertyRequest,function (AsyncCallback) {
+            console.log("testFace faceDemo getallAuthInfo AsyncCallback = " + JSON.stringify(AsyncCallback))
+            callback(AsyncCallback)
+        })
+    }
+    catch (e) {
+        console.log("testFace  publicgetProperty fail " + e);
+        expect(null).assertFail();
+    }
+}
+
+
+function publicsetProperty(UserAuth,SetPropertyRequest,callback){
+    console.info('testFace publicsetProperty in');
+    try {
+        console.info('testFace publicsetProperty in try');
+        console.info('testFace publicsetProperty UserAuth = ' + UserAuth);
+        UserAuth.setProperty(SetPropertyRequest,function (AsyncCallback) {
+            console.log("testFace faceDemo getallAuthInfo AsyncCallback = " + JSON.stringify(AsyncCallback))
+            callback(AsyncCallback)
+        })
+    }
+    catch (e) {
+        console.log("testFace publicsetProperty fail " + e);
+        expect(null).assertFail();
+    }
+}
+
+function publicauth(UserAuth,challenge,authType,authTrustLevel,callback1,callback2){
+    console.info('testFace publicauth in');
+    try {
+        console.info('testFace publicauth in try');
+        console.info('testFace publicauth UserAuth = ' + UserAuth);
+        let onresult = {
+            authresult: null,
+            authextr: null,
+        }
+        let onacquireinfo = {
+            authmodule : null,
+            authacquire : null,
+            authextr : null
+        }
+        let contextID1 = null
+        contextID1 = UserAuth.auth(challenge, authType,authTrustLevel,{
+            onResult: function(result,extraInfo){
+                console.log("testFace faceDemo auth result = " + result)
+                onresult.authresult = result
+                console.log("testFace faceDemo auth extraInfo = " + JSON.stringify(extraInfo));
+                onresult.authextr = extraInfo;
+                console.info('testFace publicauth auth onResult = ' + JSON.stringify(onresult));
+                callback1(onresult)
+            },
+            onAcquireInfo:function (modulea,acquire,extr){
+                console.info('faceTest publicauth auth onAcquireInfo in');
+                onacquireinfo.authmodule = modulea;
+                onacquireinfo.authacquire = acquire;
+                onacquireinfo.authextr = extr;
+                console.log("testFace faceDemo auth module = " + JSON.stringify(modulea));
+                console.info('testFace publicauth auth onAcquireInfo = ' + JSON.stringify(onacquireinfo));
+                callback2(onacquireinfo)
+            }
+        });
+        console.info('testFace publicauth auth contextID1 = ' + contextID1);
+        return contextID1
+    }
+    catch (e) {
+        console.log("testFace publicauth fail " + e);
+        expect(null).assertFail();
+    }
+}
+
+function publicauthUser(UserAuth,userID,challenge,authType,authTrustLevel,callback1,callback2){
+    console.info('testFace publicauthUser in');
+    try {
+        console.info('testFace publicauthUser in try');
+        console.info('testFace publicauthUser UserAuth = ' + UserAuth);
+        let onresult = {
+            authresult: null,
+            authextr: null,
+        }
+        let onacquireinfo = {
+            authmodule : null,
+            authacquire : null,
+            authextr : null
+        }
+        let contextID1 = null
+        contextID1 = UserAuth.authUser(userID, challenge, authType, authTrustLevel, {
+            onResult: function(result,extraInfo){
+                console.log("testFace faceDemo authUser result = " + result)
+                onresult.authresult = result
+                console.log("testFace faceDemo authUser authextr = " + extraInfo)
+                onresult.authextr = extraInfo;
+                console.info('testFace publicauthUser authUser onResult = ' + JSON.stringify(onresult));
+                callback1(onresult)
+            },
+            onAcquireInfo:function (modulea,acquire,extr){
+                console.info('testFace publicauthUser authUser onAcquireInfo in');
+                onacquireinfo.authmodule = modulea
+                onacquireinfo.authacquire = acquire
+                onacquireinfo.authextr = extr
+                console.log("testFace faceDemo authUser module = " + modulea);
+                console.info('testFace publicauthUser authUser onacquireinfo = ' + JSON.stringify(onacquireinfo));
+                callback2(onacquireinfo)
+            }
+        })
+        console.info('testFace publicauthUser authUser contextID1 = ' + contextID1);
+        return contextID1
+    }
+    catch (e) {
+        console.log("testFace publicauthUser fail " + e);
+        expect(null).assertFail();
+    }
+}
+
+//同步
+function publicgecancelAuth(UserAuth,contextID){
+    console.info('testFace publicgecancelAuth in');
+    try {
+        console.info('testFace publicgecancelAuth in try');
+        console.info('testFace publicgecancelAuth UserAuth = ' + UserAuth);
+        let cancelAuthresult = null
+        cancelAuthresult = UserAuth.cancelAuth(contextID)
+        console.info('testFace publicgecancelAuth cancelAuth cancelAuthresult = ' + cancelAuthresult);
+        return cancelAuthresult
+    }
+    catch (e) {
+        console.log("testFace publiccancelAuth fail " + e);
+        expect(null).assertFail();
+    }
+}
+
+
+export{publicRegisterInputer, publicgetallAuthInfo, 
+publicunRegisterInputer, publicOpenSession, publicCloseSession, 
+publicaddCredential, publicupdateCred, publiccancel, publicdelUser, 
+publicdelCred, publicgetAuthInfo, publicgetAvailabeStatus, publicgetProperty, 
+publicsetProperty, publicauth, publicauthUser, publicgecancelAuth}
\ No newline at end of file

useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/test/Security_IAM_Coauth_Func_CallbackJsunit.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 {describe, it, expect} from 'deccjsunit/index'
+import userAuth from '@ohos.userauth'
+import userIDM from '@ohos.useridm'
+import pinAuth from '@ohos.pinauth'
+import * as publicFC from './Publicfunction-n'
+
+
+let UserIDM = userIDM.constructor()
+let PinAuth = pinAuth.constructor()
+let UserAuth = userAuth.constructor()
+
+let AuthType = {
+    PIN : 1,
+    FACE : 2
+}
+let AuthSubType = {
+    PIN_SIX : 10000,
+    PIN_NUMBER : 10001,
+    PIN_MIXED : 10002,
+    FACE_2D : 20000,
+    FACE_3D : 20001
+}
+let AuthTurstLevel = {
+    ATL1 : 10000,
+    ATL2 : 20000,
+    ATL3 : 30000,
+    ATL4 : 40000
+}
+
+let SetPropertyType = {
+    PROCESS_ALGORITHM : 1,
+}
+
+let ResultCode = {
+    SUCCESS : 0,
+    FAIL : 1,
+    GENERAL_ERROR : 2,
+    CANCELED : 3,
+    TIMEOUT : 4,
+    TYPE_NOT_SUPPORT : 5,
+    TRUST_LEVEL_NOT_SUPPORT : 6,
+    BUSY : 7,
+    INVALID_PARAMETERS : 8,
+    LOCKED : 9,
+    NOT_ENROLLED : 10,
+    AUTH_FAIL : 14
+}
+
+let GetPropertyType = {
+    AUTH_SUB_TYPE : 1,
+    REMAIN_TIMES : 2,
+    FREEZING_TIME : 3
+}
+
+let Inputerdata = new Uint8Array([1, 2, 3, 4, 5, 6]);
+let Inputerdatan = new Uint8Array([1, 1, 1, 1, 1, 1]);
+let Inputerdatanum = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
+let Inputerdatanumn = new Uint8Array([1, 1, 1, 1, 1, 1, 1, 1]);
+let Inputerdatamix = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+let Inputerdatamixn = new Uint8Array([1, 1, 1, 1, 1, 1, 1, 1, 1]);
+
+let GetPropertyTypearray=new Array();
+GetPropertyTypearray[0]=GetPropertyType.AUTH_SUB_TYPE;      
+GetPropertyTypearray[1]=GetPropertyType.FREEZING_TIME;
+GetPropertyTypearray[2]=GetPropertyType.REMAIN_TIMES;
+
+let GetPropertyRequestpin = {
+    authType:AuthType.PIN,
+    keys:GetPropertyTypearray
+    }
+
+let GetPropertyRequestface = {
+    authType:AuthType.FACE,
+    keys:GetPropertyTypearray
+    }
+
+let CredentialInfopinsix = {
+    credType: AuthType.PIN,
+    credSubType: AuthSubType.PIN_SIX,
+    token: null
+}
+
+let CredentialInfopinnum = {
+    credType: AuthType.PIN,
+    credSubType: AuthSubType.PIN_NUMBER,
+    token: null
+}
+
+let CredentialInfopinmix = {
+    credType: AuthType.PIN,
+    credSubType: AuthSubType.PIN_MIXED,
+    token: null
+}
+
+let CredentialInfoface2d = {
+    credType: AuthType.FACE,
+    credSubType: AuthSubType.FACE_2D,
+    token: null
+}
+
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+
+
+describe('userauthTest', function () {
+	
+    /*
+        * @tc.number    : testGetEntriesString101
+        * @tc.name      : Use getEntries get the value by mixing the string key
+        * @tc.desc      : Mixed strings value can be obtained correctly
+        * @tc.size      : MediumTest
+        * @tc.type      : Function
+        * @tc.level     : Level 1
+    */
+
+    it('Security_IAM_Coauth_Func_0102', 3, async function (done) {
+        try {
+            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdata)
+            publicFC.publicOpenSession(UserIDM, function (data) {
+                let challenge1 = data;
+                console.info('Coauth_Func_0102 publicOpenSession challenge1 = ' + challenge1);
+                publicFC.publicOpenSession(UserIDM, function (data) {
+                    let challenge2 = data;
+                    console.info('Security_IAM_Coauth_Func_0102 publicOpenSession challenge2 = ' + challenge2);
+                    publicFC.publicaddCredential(UserIDM, CredentialInfopinsix, function (data) {
+                        let addcredresult101 = data.addCredresult;
+                        console.info('Security_IAM_Coauth_Func_0102 addcredresult101 = ' + addcredresult101);
+                        publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1, function (data) {
+                            let info101 = data.authresult;
+                            console.info('Security_IAM_Coauth_Func_0102 publicauth info101 = ' + info101);
+                            publicFC.publicauth(UserAuth, challenge2, AuthType.PIN, AuthTurstLevel.ATL1,
+							function (data) {
+                                let info1011 = data.authresult;
+                                console.info('Security_IAM_Coauth_Func_0102 publicauth info1011 = ' + info1011);
+                                expect(ResultCode.AUTH_FAIL).assertEqual(info101);
+                                expect(ResultCode.SUCCESS).assertEqual(info1011);
+                                let token = data.authextr.token
+                                publicFC.publicdelUser(UserIDM, token, function (data) {
+                                    let deluserresult = data.delUserresult;
+                                    console.info('Security_IAM_Coauth_Func_0102 deluserresult = ' + deluserresult);
+                                    publicFC.publicCloseSession(UserIDM, function (data) {
+                                        console.info('Security_IAM_Coauth_Func_0102 CloseSession data = ' + data);
+                                        publicFC.publicunRegisterInputer(PinAuth, function (data) {
+                                            console.info('Security_IAM_Coauth_Func_0102 unRegister data = ' + data);
+                                            done();
+                                        })
+                                    })
+                                }, function (data) {
+                                })
+                            }, function (data) {
+                            })
+                        }, function (data) {
+                        })
+                    }, function (data) {
+                    })
+                })
+            })
+        } catch (e) {
+            console.log("testtwochallenge101 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+
+//     it('Security_IAM_Coauth_Func_0104', 3, async function (done) {
+//         try {
+//             publicFC.publicRegisterInputer(PinAuth,AuthSubType.PIN_SIX,Inputerdata)
+//             publicFC.publicOpenSession(UserIDM,function(data){
+//                 let challenge = data
+//                 publicFC.publicaddCredential(UserIDM,CredentialInfopinsix,
+//                     function(onresult) {
+//                         console.info('testFace Coauth_Func_0104 addCredresult = ' + onresult.addCredresult);
+//                         console.log("testFace Coauth_Func_0104 authUser result = " + onresult.addCredresult);
+//                         publicFC.publicauth(UserAuth,challenge,AuthType.PIN,AuthTurstLevel.ATL1,
+//                             function(onresult) {
+//                                 console.info(
+//                                    'testFace Coauth_Func_0104 addCred onResult = ' + JSON.stringify(onresult));
+//                                 let token = onresult.authextr.token
+//                                 CredentialInfoface2d.token = token
+//                                 publicFC.publicaddCredential(UserIDM,CredentialInfoface2d,function(onresult) {
+//                                     console.info('testFace Coauth_Func_0104 addface=' + onresult.authresult);
+//                                     console.log("testFace Coauth_Func_0104 addface= " + onresult.addCredresult)
+//                                     publicFC.publicgetAuthInfo(UserIDM,AuthType.FACE,function(AsyncCallback) {
+//                                         console.log("testFace Coauth_Func_0104 getAuthInfo= " + AsyncCallback)
+//                                         expect(AuthSubType.FACE_2D).assertEqual(AsyncCallback[0].authSubType);
+//                                         publicFC.publicgetAuthInfo(UserIDM,AuthType.PIN,function(AsyncCallback) {
+//                                             console.log("testFace Coauth_Func_0104 getAuthInfo = " + AsyncCallback)
+//                                             expect(AuthSubType.PIN_SIX).assertEqual(AsyncCallback[0].authSubType);
+//                                             publicFC.publicdelUser(UserIDM,token,function(onresult){
+//                                                 let delresult = onresult.delUserresult;
+//                                                 console.log("testFace Coauth_Func_0104 delUser= " + delresult)
+//                                                 publicFC.publicCloseSession(UserIDM,function(data){
+//                                                     console.log("testFaceCoauth_Func_0104 CloseSession= " + data)
+//                                                     publicFC.publicunRegisterInputer(PinAuth)
+//                                                     done();
+//                                                 })
+//                                             },function(onacquireinfo){
+//                                             })
+//                                         })
+//                                     })
+//                                 }, function(onAcquireInfo) {
+//                                 })
+//                             }, function(onAcquireInfo) {
+//                             }
+//                         );
+//                     }, function(onAcquireInfo) {
+//                     });
+//             })
+//         } catch (e) {
+//             console.log("Security_IAM_Coauth_Func_0104 fail " + e);
+//             expect(null).assertFail();
+//         }
+//     })
+
+    it('Security_IAM_Coauth_Func_0105', 3, async function (done) {
+        try {
+            publicFC.publicRegisterInputer(PinAuth,AuthSubType.PIN_SIX,Inputerdata)
+            publicFC.publicOpenSession(UserIDM,function(data){
+                let challenge = data
+                publicFC.publicaddCredential(UserIDM,CredentialInfopinsix,function(onresult) {
+                    console.info('testFace Security_IAM_Coauth_Func_0105 addCredresult = ' + onresult.addCredresult);
+                    console.log("testFace Coauth_Func_0105 authUser result = " + onresult.addCredresult);
+                    publicFC.publicauth(UserAuth,challenge,AuthType.PIN,AuthTurstLevel.ATL1, function(onresult) {
+                        console.info('testFace Coauth_Func_0105 addCred onResult = ' + onresult.authresult);
+                        let token = onresult.authextr.token
+                        CredentialInfoface2d.token = token
+                        publicFC.publicaddCredential(UserIDM,CredentialInfopinsix,function(onresult) {
+                            console.info('testFace Coauth_Func_0105 addface onResult = ' + onresult.authresult);
+                            publicFC.publicgetAuthInfo(UserIDM,AuthType.PIN,function(data){
+                                let CredInfo = data;
+                                console.info('testFace Coauth_Func_0105 getAuthInfo = ' + CredInfo[0].authSubType);
+                                expect(AuthSubType.PIN_SIX).assertEqual(CredInfo[0].authSubType);
+                                    publicFC.publicdelUser(UserIDM,token,function(onresult){
+                                        console.log("testFace Coauth_Func_0105 delUser = " + onresult.delUserresult)
+                                        publicFC.publicCloseSession(UserIDM,function(data){
+                                            console.log("testFace Coauth_Func_0105 CloseSession callback = " + data);
+                                            publicFC.publicunRegisterInputer(PinAuth,function(data){
+                                                done();
+                                            });
+                                        })
+                                    },function(onacquireinfo){
+                                    })
+                                })
+                            }, function(onAcquireInfo) {
+                            })
+                        }, function(onAcquireInfo) {
+                        });
+                    }, function(onAcquireInfo) {
+                    });
+            })
+        } catch (e) {
+            console.log("Security_IAM_Coauth_Func_0105 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+
+    // it('Security_IAM_Coauth_Func_0106', 3, async function (done) {
+    //     try {
+    //         publicFC.publicRegisterInputer(PinAuth,AuthSubType.PIN_SIX,Inputerdata)
+    //         publicFC.publicOpenSession(UserIDM,function(data){
+    //             let challenge = data
+    //             publicFC.publicaddCredential(UserIDM,CredentialInfopinsix,
+    //                 function(onresult) {
+    //                     console.info('testFace Coauth_Func_0106 addCredresult = ' + onresult.addCredresult);
+    //                     console.log("testFace Coauth_Func_0106 authUser result = " + onresult.addCredresult);
+    //                     publicFC.publicauth(UserAuth,challenge,AuthType.PIN,AuthTurstLevel.ATL1,
+    //                         function(onresult) {
+    //                             console.info('testFace Coauth_Func_0106 addCred= ' + JSON.stringify(onresult));
+    //                             let token = onresult.authextr.token
+    //                             CredentialInfoface2d.token = token
+    //                             publicFC.publicaddCredential(UserIDM,CredentialInfoface2d,function(onresult) {
+    //                                 console.info('testFace Coauth_Func_0106 addface= ' + onresult.authresult);
+    //                                 console.log("testFace Coauth_Func_0106 addCface = " + onresult.addCredresult)
+    //                                 publicFC.publicgetallAuthInfo(UserIDM,function(AsyncCallback) {
+    //                                     console.log("testFace Coauth_Func_0106 getAuthInfo = " + AsyncCallback)
+    //                                     expect(AuthSubType.PIN_SIX).assertEqual(AsyncCallback[0].authSubType);
+    //                                     expect(AuthSubType.FACE_2D).assertEqual(AsyncCallback[1].authSubType);
+    //                                     publicFC.publicdelUser(UserIDM,token,function(onresult){
+    //                                         console.log("testFaceCoauth_Func_0106delUser="+ onresult.delUserresult)
+    //                                         publicFC.publicCloseSession(UserIDM,function(data){
+    //                                             console.log("testFace Coauth_Func_0106 CloseSession = " + data)
+    //                                             publicFC.publicunRegisterInputer(PinAuth)
+    //                                             done();
+    //                                         })
+    //                                     },function(onacquireinfo){
+    //                                     })
+    //                                 })
+    //                             }, function(onAcquireInfo) {
+    //                             })
+    //                         }, function(onAcquireInfo) {
+    //                         }
+    //                     );
+    //                 }, function(onAcquireInfo) {
+    //                 });
+    //         })
+    //     } catch (e) {
+    //         console.log("Security_IAM_Coauth_Func_0106 fail " + e);
+    //         expect(null).assertFail();
+    //     }
+    // })
+
+
+    it('Security_IAM_Coauth_Func_0108', 3, async function (done) {
+        try {
+            publicFC.publicRegisterInputer(PinAuth,AuthSubType.PIN_SIX,Inputerdata)
+            publicFC.publicOpenSession(UserIDM,function(data){
+                let challenge = data
+                publicFC.publicaddCredential(UserIDM,CredentialInfopinsix,
+                    function(onresult) {
+                        console.info('testFace Coauth_Func_0108 addCredresult = ' + onresult.addCredresult);
+                        console.log("testFace faceDemo Coauth_Func_0108 authUser = " + onresult.addCredresult);
+                        publicFC.publicauth(UserAuth,challenge,AuthType.PIN,AuthTurstLevel.ATL1,
+                            function(onresult) {
+                                console.info('testFace Coauth_Func_0108 addCred = ' + JSON.stringify(onresult));
+                                let token = onresult.authextr.token
+                                CredentialInfoface2d.token = token
+                                publicFC.publicaddCredential(UserIDM,CredentialInfoface2d,function(onresult) {
+                                    console.info('testFace Coauth_Func_0108 ddCredentialface=' + onresult.authresult);
+                                    console.log("testFace Coauth_Func_0108 addface result =" + onresult.addCredresult)
+                                    let AvailabeStatus = publicFC.publicgetAvailabeStatus(
+									UserAuth,AuthType.FACE,AuthTurstLevel.ATL1)
+                                    expect(ResultCode.SUCCESS).assertEqual(AvailabeStatus);
+                                    AvailabeStatus = publicFC.publicgetAvailabeStatus(
+									UserAuth,AuthType.FACE,AuthTurstLevel.ATL2)
+                                    expect(ResultCode.SUCCESS).assertEqual(AvailabeStatus);
+                                    AvailabeStatus = publicFC.publicgetAvailabeStatus(
+									UserAuth,AuthType.FACE,AuthTurstLevel.ATL3)
+                                    expect(ResultCode.FAIL).assertEqual(AvailabeStatus);
+                                    AvailabeStatus = publicFC.publicgetAvailabeStatus(
+									UserAuth,AuthType.FACE,AuthTurstLevel.ATL4)
+                                    expect(ResultCode.FAIL).assertEqual(AvailabeStatus);
+                                    publicFC.publicdelUser(UserIDM,token,function(onresult){
+                                        console.log("testFace Coauth_Func_0108 delUser = " + onresult.delUserresult)
+                                        publicFC.publicCloseSession(UserIDM,function(data){
+                                            console.log("testFace Coauth_Func_0108 CloseSession callback = " + data)
+                                            publicFC.publicunRegisterInputer(PinAuth, function(data){
+                                                done();
+                                            })
+                                        })
+                                    },function(onacquireinfo){
+                                    })
+                                }, function(onAcquireInfo) {
+                                })
+                            }, function(onAcquireInfo) {
+                            }
+                        );
+                    }, function(onAcquireInfo) {
+                    });
+            })
+        } catch (e) {
+            console.log("Security_IAM_Coauth_Func_0108 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+
+    it('Security_IAM_Coauth_Func_0109', 2, async function (done) {
+        try {
+            publicFC.publicRegisterInputer(PinAuth,AuthSubType.PIN_SIX,Inputerdata)
+            publicFC.publicOpenSession(UserIDM,function(data){
+                let challenge = data
+                publicFC.publicaddCredential(UserIDM,CredentialInfopinsix,
+                    function(onresult) {
+                        console.info('testFace Coauth_Func_0108 addCredresult = ' + onresult.addCredresult);
+                        console.log("testFace Coauth_Func_0109 authUser result = " + onresult.addCredresult);
+                        let AvailabeStatus
+						AvailabeStatus = publicFC.publicgetAvailabeStatus(UserAuth,AuthType.PIN,AuthTurstLevel.ATL1)
+                        console.info('testFace Security_IAM_Coauth_Func_0109 AvailabeStatus1 = ' + AvailabeStatus);
+                        expect(ResultCode.SUCCESS).assertEqual(AvailabeStatus);
+                        AvailabeStatus = publicFC.publicgetAvailabeStatus(UserAuth,AuthType.PIN,AuthTurstLevel.ATL2)
+                        console.info('testFace Security_IAM_Coauth_Func_0109 AvailabeStatus2 = ' + AvailabeStatus);
+                        expect(ResultCode.SUCCESS).assertEqual(AvailabeStatus);
+                        AvailabeStatus = publicFC.publicgetAvailabeStatus(UserAuth,AuthType.PIN,AuthTurstLevel.ATL3)
+                        console.info('testFace Security_IAM_Coauth_Func_0109 AvailabeStatus3 = ' + AvailabeStatus);
+                        expect(ResultCode.SUCCESS).assertEqual(AvailabeStatus);
+                        AvailabeStatus = publicFC.publicgetAvailabeStatus(UserAuth,AuthType.PIN,AuthTurstLevel.ATL4)
+                        console.info('testFace Security_IAM_Coauth_Func_0109 AvailabeStatus4 = ' + AvailabeStatus);
+                        expect(ResultCode.SUCCESS).assertEqual(AvailabeStatus);
+                        publicFC.publicauth(UserAuth,challenge,AuthType.PIN,AuthTurstLevel.ATL1,
+                            function(onresult) {
+                                console.info('testFace Coauth_Func_0109 addCred onResult = ' + onresult.authresult);
+                                let token = onresult.authextr.token
+                                publicFC.publicdelUser(UserIDM,token,function(onresult){
+                                    console.log("testFace Coauth_Func_0109 delUser result= " + onresult.delUserresult)
+                                    publicFC.publicCloseSession(UserIDM,function(data){
+                                        console.log("testFace Coauth_Func_0109 CloseSession callback = " + data)
+                                        publicFC.publicunRegisterInputer(PinAuth,function(data){
+                                            done();
+                                        })
+                                    })
+                                },function(onacquireinfo){
+                                })
+                            }, function(onAcquireInfo) {
+                            }
+                        );
+                    }, function(onAcquireInfo) {
+                    });
+            })
+        } catch (e) {
+            console.log("Security_IAM_Coauth_Func_0109 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+
+//    it('Security_IAM_Coauth_Func_0110', 3, async function (done) {
+//        try {
+//            publicFC.publicRegisterInputer(PinAuth,AuthSubType.PIN_SIX,Inputerdata)
+//            publicFC.publicOpenSession(UserIDM,function(data){
+//                let challenge = data
+//                publicFC.publicaddCredential(UserIDM,CredentialInfopinsix, function(onresult) {
+//                    console.info('testFace Coauth_Func_0110 addCredresult = ' + onresult.addCredresult);
+//                    console.log("testFace Coauth_Func_0110 authUser result = " + onresult.addCredresult);
+//                    publicFC.publicauth(UserAuth,challenge,AuthType.PIN,AuthTurstLevel.ATL1, function(onresult) {
+//                        console.info('testFace Coauth_Func_0110 addCred onResult = ' + JSON.stringify(onresult));
+//                        let token = onresult.authextr.token
+//                        CredentialInfoface2d.token = token
+//                        publicFC.publicaddCredential(UserIDM,CredentialInfoface2d,function(onresult) {
+//                            console.info('testFace Coauth_Func_0110 ddCredentialface= ' + onresult.authresult);
+//                            console.log("testFace Coauth_Func_0110 ddCredentialface = " + onresult.addCredresult)
+//                            publicFC.publicgetProperty(UserAuth,GetPropertyRequestface,function(onresult) {
+//                                expect(ResultCode.SUCCESS).assertEqual(onresult[0].result);
+//                                expect(AuthSubType.FACE_2D).assertEqual(onresult[0].authSubType);
+//                                publicFC.publicgetProperty(UserAuth,GetPropertyRequestpin,function(onresult) {
+//                                    expect(ResultCode.SUCCESS).assertEqual(onresult[0].result);
+//                                    expect(AuthSubType.PIN_SIX).assertEqual(onresult[0].authSubType);
+//                                    publicFC.publicdelUser(UserIDM,token,function(onresult){
+//                                        console.log("testFace Coauth_Func_0110 delUser= " + onresult.delUserresult)
+//                                        publicFC.publicCloseSession(UserIDM,function(data){
+//                                            console.log("testFace Coauth_Func_0110 CloseSession callback = " + data)
+//                                            publicFC.publicunRegisterInputer(PinAuth)
+//                                            done();
+//                                        })
+//                                    },function(onacquireinfo){
+//                                    })
+//                                })
+//                            })
+//                        }, function(onAcquireInfo) {
+//                        })
+//                    }, function(onAcquireInfo) {
+//                    }
+//                )}, function(onAcquireInfo) {
+//                })
+//            })
+//        } catch (e) {
+//            console.log("Security_IAM_Coauth_Func_0110 fail " + e);
+//            expect(null).assertFail();
+//        }
+//    })
+    
+    it('Security_IAM_Coauth_Func_0112', 3, async function (done) {
+        console.info('testFace Security_IAM_Coauth_Func_0112 start');
+        try {
+            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdata)
+            publicFC.publicOpenSession(UserIDM, function (data) {
+                let challenge1 = data;
+                console.info("Security_IAM_Coauth_Func_0112 challenge1 = " + challenge1);
+                publicFC.publicaddCredential(UserIDM, CredentialInfopinnum, function (data) {
+                    let addcredresult101 = data.addcredresult;
+                    publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1, function (data) {
+                        let auth101 = data
+                        console.info("Security_IAM_Coauth_Func_0112 auth1 = " + auth101.authresult);
+                        let token = auth101.authextr.token
+                        console.info("Security_IAM_Coauth_Func_0112 token = " + token);
+                        publicFC.publicunRegisterInputer(PinAuth, async function (data) {
+                            console.info("Security_IAM_Coauth_Func_0112 unRegist = " + data);
+                            await setTimeout(
+							publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdatan), 500)
+                            console.info("Security_IAM_Coauth_Func_0112 challenge2 = " + challenge1);
+                            await publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1,
+							function (data) {
+                                console.info("Security_IAM_Coauth_Func_0112 authresult1 = " + data.authresult);
+                                let authresult1 = data.authresult
+                                expect(ResultCode.AUTH_FAIL).assertEqual(authresult1);
+                                publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1,
+								function (data) {
+                                    console.info("Security_IAM_Coauth_Func_0112 authresult2 = " + data.authresult);
+                                    let authresult2 = data.authresult
+                                    expect(ResultCode.AUTH_FAIL).assertEqual(authresult2);
+                                    publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1,
+									function (data) {
+                                        console.info("Security_IAM_Coauth_Func_0112 authresult3 =" + data.authresult);
+                                        let authresult3 = data.authresult
+                                        expect(ResultCode.AUTH_FAIL).assertEqual(authresult3);
+                                        publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1,
+										function (data) {
+                                            console.info("Coauth_Func_0112 authresult4 = " + data.authresult);
+                                            let authresult4 = data.authresult
+                                            expect(ResultCode.AUTH_FAIL).assertEqual(authresult4);
+                                            publicFC.publicgetProperty(UserAuth,GetPropertyRequestpin, function(data){
+                                                expect(1).assertEqual(data.remainTimes);
+                                                publicFC.publicunRegisterInputer(PinAuth, async function (data) {
+                                                    console.info("Security_IAM_Coauth_Func_0112 unRegist = " + data);
+                                                    await setTimeout(publicFC.publicRegisterInputer(
+													PinAuth, AuthSubType.PIN_SIX, Inputerdata), 500)
+                                                    console.info("Coauth_Func_0112 challenge2 = " + challenge1);
+                                                    await publicFC.publicauth(
+													UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1,
+													function (data) {
+                                                        let authresult5 = data.authresult
+                                                        expect(ResultCode.SUCCESS).assertEqual(authresult5);
+                                                        publicFC.publicdelUser(UserIDM, token, function (data) {
+                                                            let delresult = data.delUserresult
+                                                            console.info("Coauth_Func_0112 delresult = " + delresult);
+                                                            publicFC.publicCloseSession(UserIDM, function (data) {
+                                                                console.info("Coauth_Func_0112 closesession=" + data);
+                                                                publicFC.publicunRegisterInputer(PinAuth,
+																function (data) {
+                                                                    console.info("Coauth_Func_0112 unRegist=" + data);
+                                                                    done();
+                                                                })
+                                                            })
+                                                        }, function (data) {
+                                                        })
+                                                    }, function (data) {
+                                                    })
+                                                })
+                                            })
+                                        }, function (data) {
+                                        })      
+                                    }, function (data) {
+                                    })    
+                                }, function (data) {
+                                })
+                            }, function (data) {
+                            })
+                        })
+                    }, function (data) {
+                    })
+                }, function (data) {
+                })
+            })
+        } catch (e) {
+            console.log("Security_IAM_Coauth_Func_0112 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+
+    it('Security_IAM_Coauth_Func_0113', 3, async function (done) {
+        console.info('testFace Security_IAM_Coauth_Func_0113 start');
+        try {
+            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdata)
+            publicFC.publicOpenSession(UserIDM, function (data) {
+                let challenge1 = data;
+                console.info("Security_IAM_Coauth_Func_0113 challenge1 = " + challenge1);
+                publicFC.publicaddCredential(UserIDM, CredentialInfopinnum, function (data) {
+                    let addcredresult101 = data.addcredresult;
+                    publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1, function (data) {
+                        let auth101 = data
+                        console.info("Security_IAM_Coauth_Func_0113 auth1 = " + auth101.authresult);
+                        let token = auth101.authextr.token
+                        console.info("Security_IAM_Coauth_Func_0113 token = " + token);
+                        publicFC.publicunRegisterInputer(PinAuth, async function (data) {
+                            console.info("Security_IAM_Coauth_Func_0113 unRegist = " + data);
+                            await setTimeout(
+							publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdatan), 500)
+                            console.info("Security_IAM_Coauth_Func_0113 challenge2 = " + challenge1);
+                            await publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1,
+							function (data) {
+                                let authresult1 = data.authresult
+                                expect(ResultCode.AUTH_FAIL).assertEqual(authresult1);
+                                publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1,
+								function (data) {
+                                    let authresult2 = data.authresult
+                                    expect(ResultCode.AUTH_FAIL).assertEqual(authresult2);
+                                    publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1,
+									function (data) {
+                                        let authresult3 = data.authresult
+                                        expect(ResultCode.AUTH_FAIL).assertEqual(authresult3);
+                                        publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1,
+										function (data) {
+                                            let authresult4 = data.authresult
+                                            expect(ResultCode.AUTH_FAIL).assertEqual(authresult4);
+                                            publicFC.publicauth(
+											UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1, function (data) {
+                                                let authresult5 = data.authresult
+                                                expect(ResultCode.AUTH_FAIL).assertEqual(authresult5);
+                                                publicFC.publicgetProperty(UserAuth,GetPropertyRequestpin,
+												function(data){
+                                                    expect(0).assertEqual(data[0].remainTimes);
+                                                    publicFC.publicunRegisterInputer(PinAuth, async function (data) {
+                                                        console.info("Coauth_Func_0113 unRegist = " + data);
+                                                        await setTimeout(publicFC.publicRegisterInputer(
+														PinAuth, AuthSubType.PIN_SIX, Inputerdata), 500)
+                                                        console.info("Coauth_Func_0113 challenge2 = " + challenge1);
+                                                        await publicFC.publicauth(
+														UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1,
+														async function (data) {
+                                                            let authresult6 = data.authresult
+                                                            expect(ResultCode.LOCKED).assertEqual(authresult6);
+// await sleep(181000);
+// await publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1, async function (data) {
+//     let authresult7 = data.authresult
+//     expect(ResultCode.SUCCESS).assertEqual(authresult7);
+//     publicFC.publicdelUser(UserIDM, token, function (data) {
+//         let delresult = data.delUserresult
+//         console.info("Security_IAM_Coauth_Func_0113 delresult = " + delresult);
+                                                                    publicFC.publicCloseSession(UserIDM,
+																	function (data) {
+                                                                        console.info("closesession = " + data);
+                                                                        publicFC.publicunRegisterInputer(
+																		PinAuth, function (data) {
+                                                                            console.info("unRegist = " + data);
+                                                                            done();
+                                                                        })
+                                                                    })
+                                                            //     }, function (data) {
+                                                            //     })
+                                                            // }, function (data) {
+                                                            // })
+                                                        }, function (data) {
+                                                        })
+                                                    })
+                                                })
+                                            }, function (data) {
+                                            }) 
+                                        }, function (data) {
+                                        })      
+                                    }, function (data) {
+                                    })    
+                                }, function (data) {
+                                })
+                            }, function (data) {
+                            })
+                        })
+                    }, function (data) {
+                    })
+                }, function (data) {
+                })
+            })
+        } catch (e) {
+            console.log("Security_IAM_Coauth_Func_0112 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+})

useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/test/Security_IAM_Face_Func_CallbackJsunit.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 {describe, it, expect} from 'deccjsunit/index'
+import userAuth from '@ohos.userauth'
+import userIDM from '@ohos.useridm'
+import pinAuth from '@ohos.pinauth'
+import * as publicFC from './Publicfunction-n.js'
+
+let UserIDM = userIDM.constructor()
+let PinAuth = pinAuth.constructor()
+let UserAuth = userAuth.constructor()
+
+let AuthType = {
+    PIN : 1,
+    FACE : 2
+}
+let AuthSubType = {
+    PIN_SIX : 10000,
+    PIN_NUMBER : 10001,
+    PIN_MIXED : 10002,
+    FACE_2D : 20000,
+    FACE_3D : 20001
+}
+let AuthTurstLevel = {
+    ATL1 : 10000,
+    ATL2 : 20000,
+    ATL3 : 30000,
+    ATL4 : 40000
+}
+
+let SetPropertyType = {
+    PROCESS_ALGORITHM : 1,
+}
+
+let userID = {
+    User1 : 1000,
+    User2 : 2,
+    User3 : 3,
+    User4 : 4,
+    User5 : 5
+}
+
+let ResultCode = {
+    SUCCESS : 0,
+    FAIL : 1,
+    GENERAL_ERROR : 2,
+    CANCELED : 3,
+    TIMEOUT : 4,
+    TYPE_NOT_SUPPORT : 5,
+    TRUST_LEVEL_NOT_SUPPORT : 6,
+    BUSY : 7,
+    INVALID_PARAMETERS : 8,
+    LOCKED : 9,
+    NOT_ENROLLED : 10
+}
+
+let GetPropertyType = {
+    AUTH_SUB_TYPE : 1,
+    REMAIN_TIMES : 2,
+    FREEZING_TIME : 3
+}
+
+let Inputerdata = new Uint8Array([12,34,56]);
+
+let GetPropertyTypearray=new Array();
+GetPropertyTypearray[0]=GetPropertyType.AUTH_SUB_TYPE;      
+GetPropertyTypearray[1]=GetPropertyType.FREEZING_TIME;
+GetPropertyTypearray[2]=GetPropertyType.REMAIN_TIMES;
+
+let GetPropertyRequestpin = {
+    authType:AuthType.PIN,
+    keys:GetPropertyTypearray
+    }
+
+let GetPropertyRequestface = {
+    authType:AuthType.FACE,
+    keys:GetPropertyTypearray
+    }
+
+let CredentialInfopinsix = {
+    credType: AuthType.PIN,
+    credSubType: AuthSubType.PIN_SIX,
+    token:new Uint8Array([1,2,3,4,5,6])
+}
+
+let CredentialInfopinnum = {
+    credType: AuthType.PIN,
+    credSubType: AuthSubType.PIN_NUMBER,
+    token: null
+}
+
+let CredentialInfopinmix = {
+    credType: AuthType.PIN,
+    credSubType: AuthSubType.PIN_MIXED,
+    token: null
+}
+
+let CredentialInfoface2d = {
+    credType: AuthType.FACE,
+    credSubType: AuthSubType.FACE_2D,
+    token: null
+}
+
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+describe('userauthTest', function () {
+
+    it('Security_IAM_Face_AddCred_Func_0101', 0, async function (done) {
+        try {
+            publicFC.publicRegisterInputer(PinAuth,AuthSubType.PIN_SIX,Inputerdata)
+            let challenge ;
+            publicFC.publicOpenSession(UserIDM, function (data) {
+                console.info('Security_IAM_Face_AddCred_Func_0101 openSession challenge = ' + data);
+                challenge = data;
+                publicFC.publicaddCredential(UserIDM,CredentialInfopinsix, function (onresult) {
+                    console.info('Face_AddCred_Func_0101 addCredential Result1 = ' + JSON.stringify(onresult));
+                    let info101;
+                    publicFC.publicauth(UserAuth,challenge,AuthType.PIN,AuthTurstLevel.ATL1, function (data) {
+                        console.info('Security_IAM_Face_AddCred_Func_0101 auth onResult = ' + JSON.stringify(data));
+                        info101 = data;
+                        let token = info101.authextr.token;
+                        CredentialInfoface2d.token = token;
+                        let addfaceresult;
+                        publicFC.publicaddCredential(UserIDM,CredentialInfoface2d, function (onresult) {
+                            console.info('Face_AddCred_Func_0101 addCredential Result2=' + JSON.stringify(onresult));
+                            addfaceresult = onresult;
+                            expect(ResultCode.SUCCESS).assertEqual(addfaceresult.addCredresult);
+                            publicFC.publicauth(UserAuth,challenge,AuthType.FACE,AuthTurstLevel.ATL1, function (data) {
+                                console.info('testFace Face_AddCred_Func_0101 onResult = ' + JSON.stringify(data));
+                                let faceauth101 = data;
+                                expect(ResultCode.SUCCESS).assertEqual(faceauth101.authresult);
+                                publicFC.publicauthUser(
+                                    UserAuth,userID.User1,challenge,AuthType.FACE,AuthTurstLevel.ATL1,function (data) {
+                                    console.info('testFace Face_AddCred_Func_0101 onResult= ' + JSON.stringify(data));
+                                    faceauth101 = data;
+                                    expect(ResultCode.SUCCESS).assertEqual(faceauth101.authresult);
+                                    let credentialId = addfaceresult.credentialId;
+                                    let delcredresult ;
+                                    publicFC.publicdelCred(UserIDM,credentialId,token, function (data) {
+                                        console.info('testFace Face_AddCred_Func_0101 del=' + JSON.stringify(data));
+                                        delcredresult = data;
+                                        expect(ResultCode.SUCCESS).assertEqual(delcredresult.delCredresult);
+                                        publicFC.publicdelUser(UserIDM,token, function (data) {
+                                            console.info('Face_AddCred_Func_0101 delUser= ' + JSON.stringify(data));
+                                            publicFC.publicCloseSession(UserIDM, function (data) {
+                                                console.info('Security_IAM_Face_AddCred_Func_0101 closeSession');
+                                                publicFC.publicunRegisterInputer(PinAuth, function (data) {
+                                                    console.info('Security_IAM_Face_AddCred_Func_0101 unRegister');
+                                                    done();
+                                                })
+                                            })
+                                        }, function (data) {
+                                        })
+                                    }, function (onacquireinfo) {
+                                    })
+                                }, function (onacquireinfo) {
+                                })
+                            }, function (onacquireinfo) {
+                            })
+                        }, function (onacquireinfo) {
+                        })
+                    }, function (data) {
+                    })
+                }, function (onacquireinfo) {
+                })
+            })
+        } catch (e) {
+            console.log("Security_IAM_Face_AddCred_Func_0101 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+
+//    it('testaddfacecancel101', 0, async function (done) {
+//        try {
+//            publicFC.publicRegisterInputer(PinAuth,AuthSubType.PIN_SIX,Inputerdata);
+//            let challenge;
+//            let result1 = null;
+//            let extraInfo1 = null;
+//            let module1 = null;
+//            let acquire1 = null;
+//            let extr1 = null;
+//            let token;
+//            publicFC.publicOpenSession(UserIDM, function (data) {
+//                console.info('testFace testaddfacecancel101 OpenSession challenge = ' + data);
+//                challenge = data;
+//                publicFC.publicaddCredential(UserIDM,CredentialInfopinsix, function (data) {
+//                    console.info('testFace testaddfacecancel101 addCredential onResult = ' + JSON.stringify(data));
+//                    let info101;
+//                    publicFC.publicauth(UserAuth,challenge,AuthType.PIN,AuthTurstLevel.ATL1, function (data) {
+//                        console.info('testFace testaddfacecancel101 publicauth onResult = ' + JSON.stringify(data));
+//                        info101 = data;
+//                        token = info101.authextr.token
+//                        CredentialInfoface2d.token = token
+//                        UserIDM.addCredential(CredentialInfoface2d, {
+//                            onResult: function(result,extraInfo){
+//                                console.log(result)
+//                                result1 = result
+//                                extraInfo1 = extraInfo.credentialId
+//                            },
+//                            onAcquireInfo:function (module,acquire,extr){
+//                                module1 = module
+//                                acquire1 = acquire
+//                                extr1 = extr
+//                                console.info(module);
+//                            }
+//                        })
+//                    }, function (data) {
+//                    })
+//                }, function (data) {
+//                })
+//            })
+//            await sleep(13000);
+//            let cancelresult = publicFC.publiccancel(UserIDM,challenge)
+//            expect(ResultCode.SUCCESS).assertEqual(cancelresult);
+//            await sleep(1000);
+//            expect(ResultCode.CANCELED).assertEqual(result1);
+//            publicFC.publicCloseSession(UserIDM, function (data) {
+//                console.info('testFace testaddfacecancel101 publicCloseSession ');
+//                publicFC.publicunRegisterInputer(PinAuth, function (data) {
+//                    console.info('testFace testaddfacecancel101 publicunRegisterInputer ');
+//                })
+//                done();
+//            })
+//        } catch (e) {
+//            console.log("testaddfacecancel101 fail " + e);
+//            expect(null).assertFail();
+//        }
+//    })
+//
+//    it('testaddfacecancel102', 0, async function (done) {
+//        try {
+//            publicFC.publicRegisterInputer(PinAuth,AuthSubType.PIN_SIX,Inputerdata);
+//            let challenge;
+//            publicFC.publicOpenSession(UserIDM, function (data) {
+//                console.info('testFace testaddfacecancel102 OpenSession challenge = ' + data);
+//                challenge = data;
+//                publicFC.publicaddCredential(UserIDM,CredentialInfopinsix, function (data) {
+//                    console.info('testFace testaddfacecancel102 addCredential onResult = ' + JSON.stringify(data));
+//                    let info101;
+//                    publicFC.publicauth(UserAuth,challenge,AuthType.PIN,AuthTurstLevel.ATL1,async function (data) {
+//                        console.info('testFace testaddfacecancel102 publicauth onResult = ' + JSON.stringify(data));
+//                        info101 = data;
+//                        let token = info101.authextr.token
+//                        CredentialInfoface2d.token = token
+//                        let result1 = null
+//                        let extraInfo1 = null
+//                        let module1 = null
+//                        let acquire1 = null
+//                        let extr1 = null
+//                        await UserIDM.addCredential(CredentialInfoface2d, {
+//                            onResult: function(result,extraInfo){
+//                                console.log(result)
+//                                result1 = result
+//                                extraInfo1 = extraInfo.credentialId
+//                            },
+//                            onAcquireInfo:function (module,acquire,extr){
+//                                module1 = module
+//                                acquire1 = acquire
+//                                extr1 = extr
+//                                console.info(module);
+//                            }
+//                        })
+//                        await sleep(3000);
+//                        let cancelresult = publicFC.publiccancel(UserIDM,challenge)
+//                        expect(ResultCode.SUCCESS).assertEqual(cancelresult);
+//                        expect(ResultCode.CANCELED).assertEqual(result1);
+//                        publicFC.publicCloseSession(UserIDM, function (data) {
+//                            console.info('testFace testaddfacecancel102 publicCloseSession ');
+//                            publicFC.publicunRegisterInputer(PinAuth, function (data) {
+//                                console.info('testFace testaddfacecancel102 publicunRegisterInputer ');
+//                            })
+//                            done();
+//                        })
+//                    }, function (data) {
+//                    })
+//                }, function (data) {
+//                })
+//            })
+//        } catch (e) {
+//            console.log("testaddfacecancel102 fail " + e);
+//            expect(null).assertFail();
+//        }
+//    })
+//
+//    it('testaddfacecancel103', 0, async function (done) {
+//        try {
+//            publicFC.publicRegisterInputer(PinAuth,AuthSubType.PIN_SIX,Inputerdata);
+//            let challenge;
+//            publicFC.publicOpenSession(UserIDM, function (data) {
+//                console.info('testFace testaddfacecancel103 OpenSession challenge = ' + data);
+//                challenge = data;
+//                publicFC.publicaddCredential(UserIDM,CredentialInfopinsix, function (data) {
+//                    console.info('testFace testaddfacecancel103 addCredential onResult = ' + JSON.stringify(data));
+//                    let info101;
+//                    publicFC.publicauth(UserAuth,challenge,AuthType.PIN,AuthTurstLevel.ATL1, async function (data) {
+//                        console.info('testFace testaddfacecancel103 publicauth onResult = ' + JSON.stringify(data));
+//                        info101 = data;
+//                        let token = info101.authextr.token
+//                        CredentialInfoface2d.token = token
+//                        let result1 = null
+//                        let extraInfo1 = null
+//                        let module1 = null
+//                        let acquire1 = null
+//                        let extr1 = null
+//                        await UserIDM.addCredential(CredentialInfoface2d, {
+//                            onResult: function(result,extraInfo){
+//                                console.log(result)
+//                                result1 = result
+//                                extraInfo1 = extraInfo.credentialId
+//                            },
+//                            onAcquireInfo:function (module,acquire,extr){
+//                                module1 = module
+//                                acquire1 = acquire
+//                                extr1 = extr
+//                                console.info(module);
+//                            }
+//                        })
+//                        await sleep(3000);
+//                        let cancelresult = publicFC.publiccancel(UserIDM,challenge)
+//                        expect(ResultCode.SUCCESS).assertEqual(cancelresult);
+//                        expect(ResultCode.CANCELED).assertEqual(result1);
+//                        publicFC.publicCloseSession(UserIDM, function (data) {
+//                            console.info('testFace testaddfacecancel103 publicCloseSession ');
+//                            publicFC.publicunRegisterInputer(PinAuth, function (data) {
+//                                console.info('testFace testaddfacecancel103 publicunRegisterInputer ');
+//                            })
+//                            done();
+//                        })
+//                    }, function (data) {
+//                    })
+//                }, function (data) {
+//                })
+//            })
+//        } catch (e) {
+//            console.log("testaddfacecancel103 fail " + e);
+//            expect(null).assertFail();
+//        }
+//    })
+
+//    it('testauthfacecancel101', 0, async function (done) {
+//        try {
+//            publicFC.publicRegisterInputer(PinAuth,AuthSubType.PIN_SIX,Inputerdata);
+//            let challenge ;
+//            publicFC.publicOpenSession(UserIDM, function (data) {
+//                console.info('testFace testauthfacecancel101 publicOpenSession challenge = ' + data);
+//                challenge = data;
+//                publicFC.publicaddCredential(UserIDM,CredentialInfopinsix, function (data) {
+//                    console.info('testFace testauthfacecancel101 addCredential onResult=' + JSON.stringify(data));
+//                    let info101 ;
+//                    publicFC.publicauth(UserAuth,challenge,AuthType.PIN,AuthTurstLevel.ATL1, function (data) {
+//                        console.info('testFace testauthfacecancel101 auth onResult = ' + JSON.stringify(data));
+//                        info101 = data;
+//                        let token = info101.authextr.token
+//                        CredentialInfoface2d.token = token
+//                        publicFC.publicaddCredential(UserIDM,CredentialInfoface2d, async function (data) {
+//                            console.info('testFace testauthfacecancel101 addCredential = ' + JSON.stringify(data));
+//                            let result1 = null;
+//                            let extraInfo1 = null;
+//                            let module1 = null;
+//                            let acquire1 = null;
+//                            let extr1 = null;
+//                            let contextID1 = null;
+//                            contextID1 = await UserAuth.auth(challenge, AuthType.FACE, AuthTurstLevel.ATL1, {
+//                                onResult: function(result,extraInfo){
+//                                    console.log(result);
+//                                    result1 = result;
+//                                    extraInfo1 = extraInfo;
+//                                },
+//                                onAcquireInfo:function (module,acquire,extr){
+//                                    module1 = module;
+//                                    acquire1 = acquire;
+//                                    extr1 = extr;
+//                                    console.info(module);
+//                                }
+//                            });
+//                            await sleep(3000);
+//                            let authfacecancel101 = publicFC.publicgecancelAuth(UserAuth,contextID1)
+//                            expect(ResultCode.SUCCESS).assertEqual(authfacecancel101);
+//                            expect(ResultCode.CANCELED).assertEqual(result1);
+//                            publicFC.publicdelUser(UserIDM,token, function (data) {
+//                                console.info('testFace testauthfacecancel101 delUser = ' + JSON.stringify(data));
+//                                publicFC.publicCloseSession(UserIDM, function (data) {
+//                                    console.info('testFace testauthfacecancel101 publicCloseSession');
+//                                    publicFC.publicunRegisterInputer(PinAuth, function (data) {
+//                                        console.info('testFace testauthfacecancel101 publicunRegisterInputer');
+//                                        done();
+//                                    })
+//                                })
+//                            })
+//                        }, function (data) {
+//                        })
+//                    }, function (data) {
+//                    })
+//                }, function (data) {
+//                })
+//            })
+//
+//        } catch (e) {
+//            console.log("testauthfacecancel101 fail " + e);
+//            expect(null).assertFail();
+//        }
+//    })
+//
+//    it('testauthfacecancel102', 0, async function (done) {
+//        try {
+//            publicFC.publicRegisterInputer(PinAuth,AuthSubType.PIN_SIX,Inputerdata);
+//            let challenge ;
+//            publicFC.publicOpenSession(UserIDM, function (data) {
+//                console.info('testFace testauthfacecancel102 publicOpenSession challenge = ' + data);
+//                challenge = data;
+//                publicFC.publicaddCredential(UserIDM,CredentialInfopinsix, function (data) {
+//                    console.info('testFace testauthfacecancel102 addCredential onResult = ' + JSON.stringify(data));
+//                    let info101 ;
+//                    publicFC.publicauth(UserAuth,challenge,AuthType.PIN,AuthTurstLevel.ATL1, function (data) {
+//                        console.info('testFace testauthfacecancel102 publicauth onResult = ' + JSON.stringify(data));
+//                        info101 = data;
+//                        let token = info101.authextr.token
+//                        CredentialInfoface2d.token = token
+//                        publicFC.publicaddCredential(UserIDM,CredentialInfoface2d, async function (data) {
+//                            console.info('testFace testauthfacecancel102 addCredential = ' + JSON.stringify(data));
+//                            let result1 = null;
+//                            let extraInfo1 = null;
+//                            let module1 = null;
+//                            let acquire1 = null;
+//                            let extr1 = null;
+//                            let contextID1 = null;
+//                            contextID1 = await UserAuth.auth(challenge, AuthType.FACE, AuthTurstLevel.ATL1, {
+//                                onResult: function(result,extraInfo){
+//                                    console.log(result);
+//                                    result1 = result;
+//                                    extraInfo1 = extraInfo;
+//                                },
+//                                onAcquireInfo:function (module,acquire,extr){
+//                                    module1 = module;
+//                                    acquire1 = acquire;
+//                                    extr1 = extr;
+//                                    console.info(module);
+//                                }
+//                            });
+//                            await sleep(8000);
+//                            let authfacecancel101 = publicFC.publicgecancelAuth(UserAuth,contextID1)
+//                            expect(ResultCode.SUCCESS).assertEqual(authfacecancel101);
+//                            expect(ResultCode.CANCELED).assertEqual(result1);
+//                            publicFC.publicdelUser(UserIDM,token, function (data) {
+//                                console.info('testFace testauthfacecancel102 delUser = ' + JSON.stringify(data));
+//                                publicFC.publicCloseSession(UserIDM, function (data) {
+//                                    console.info('testFace testauthfacecancel102 publicCloseSession');
+//                                    publicFC.publicunRegisterInputer(PinAuth, function (data) {
+//                                        console.info('testFace testauthfacecancel102 publicunRegisterInputer');
+//                                        done();
+//                                    })
+//                                })
+//                            }, function (data) {
+//                            })
+//                        }, function (data) {
+//                        })
+//                    }, function (data) {
+//                    })
+//                }, function (data) {
+//                })
+//            })
+//
+//        } catch (e) {
+//            console.log("testauthfacecancel102 fail " + e);
+//            expect(null).assertFail();
+//        }
+//    })
+//
+//    it('testauthfacecancel103', 0, async function (done) {
+//        try {
+//            publicFC.publicRegisterInputer(PinAuth,AuthSubType.PIN_SIX,Inputerdata);
+//            let challenge ;
+//            publicFC.publicOpenSession(UserIDM, function (data) {
+//                console.info('testFace testauthfacecancel103 publicOpenSession challenge = ' + data);
+//                challenge = data;
+//                publicFC.publicaddCredential(UserIDM,CredentialInfopinsix, function (data) {
+//                    console.info('testFace testauthfacecancel103 addCredential= ' + JSON.stringify(data));
+//                    let info101 ;
+//                    publicFC.publicauth(UserAuth,challenge,AuthType.PIN,AuthTurstLevel.ATL1, function (data) {
+//                        console.info('testFace testauthfacecancel103 publicauth = ' + JSON.stringify(data));
+//                        info101 = data;
+//                        let token = info101.authextr.token
+//                        CredentialInfoface2d.token = token
+//                        publicFC.publicaddCredential(UserIDM,CredentialInfoface2d, async function (data) {
+//                            console.info('testFace testauthfacecancel103 addCredential= ' + JSON.stringify(data));
+//                            let result1 = null;
+//                            let extraInfo1 = null;
+//                            let module1 = null;
+//                            let acquire1 = null;
+//                            let extr1 = null;
+//                            let contextID1 = null;
+//                            contextID1 = await UserAuth.auth(challenge, AuthType.FACE, AuthTurstLevel.ATL1, {
+//                                onResult: function(result,extraInfo){
+//                                    console.log(result);
+//                                    result1 = result;
+//                                    extraInfo1 = extraInfo;
+//                                },
+//                                onAcquireInfo:function (module,acquire,extr){
+//                                    module1 = module;
+//                                    acquire1 = acquire;
+//                                    extr1 = extr;
+//                                    console.info(module);
+//                                }
+//                            });
+//                            await sleep(10000);
+//                            let authfacecancel101 = publicFC.publicgecancelAuth(UserAuth,contextID1)
+//                            expect(ResultCode.SUCCESS).assertEqual(authfacecancel101);
+//                            expect(ResultCode.CANCELED).assertEqual(result1);
+//                            publicFC.publicdelUser(UserIDM,token, function (data) {
+//                                console.info('testFace testauthfacecancel103 delUser = ' + JSON.stringify(data));
+//                                publicFC.publicCloseSession(UserIDM, function (data) {
+//                                    console.info('testFace testauthfacecancel103 publicCloseSession');
+//                                    publicFC.publicunRegisterInputer(PinAuth, function (data) {
+//                                        console.info('testFace testauthfacecancel103 publicunRegisterInputer');
+//                                        done();
+//                                    })
+//                                })
+//                            }, function (data) {
+//                            })
+//                        }, function (data) {
+//                        })
+//                    }, function (data) {
+//                    })
+//                }, function (data) {
+//                })
+//            })
+//
+//        } catch (e) {
+//            console.log("testauthfacecancel103 fail " + e);
+//            expect(null).assertFail();
+//        }
+//    })
+//
+//    it('testauthuserfacecancel101', 0, async function (done) {
+//        try {
+//            publicFC.publicRegisterInputer(PinAuth,AuthSubType.PIN_SIX,Inputerdata);
+//            let challenge ;
+//            publicFC.publicOpenSession(UserIDM, function (data) {
+//                console.info('testFace testauthuserfacecancel101 publicOpenSession challenge = ' + data);
+//                challenge = data;
+//                publicFC.publicaddCredential(UserIDM,CredentialInfopinsix, function (data) {
+//                    console.info('testFace testauthuserfacecancel101 addCredential= ' + JSON.stringify(data));
+//                    let info101 ;
+//                    publicFC.publicauth(UserAuth,challenge,AuthType.PIN,AuthTurstLevel.ATL1, function (data) {
+//                        console.info('testFace testauthuserfacecancel101 auth onResult = ' + JSON.stringify(data));
+//                        info101 = data;
+//                        let token = info101.authextr.token;
+//                        CredentialInfoface2d.token = token;
+//                        publicFC.publicaddCredential(UserIDM,CredentialInfoface2d, async function (data) {
+//                            console.info('testFace testauthuserfacecancel101addCredential=' + JSON.stringify(data));
+//                            let result1 = null;
+//                            let extraInfo1 = null;
+//                            let module1 = null;
+//                            let acquire1 = null;
+//                            let extr1 = null;
+//                            let contextID1 = null;
+//                            contextID1 = await UserAuth.authUser(
+    //                            userID.User1, challenge, AuthType.FACE, AuthTurstLevel.ATL1, {
+//                                onResult: function(result,extraInfo){
+//                                    console.log(result);
+//                                    result1 = result;
+//                                    extraInfo1 = extraInfo;
+//                                },
+//                                onAcquireInfo:function (module,acquire,extr){
+//                                    module1 = module;
+//                                    acquire1 = acquire;
+//                                    extr1 = extr;
+//                                    console.info(module);
+//                                }
+//                            })
+//                            await sleep(3000);
+//                            let authfacecancel101 = publicFC.publicgecancelAuth(UserAuth,contextID1);
+//                            expect(ResultCode.SUCCESS).assertEqual(authfacecancel101);
+//                            expect(ResultCode.CANCELED).assertEqual(result1);
+//                            publicFC.publicCloseSession(UserIDM, function (data) {
+//                                console.info('testFace testauthuserfacecancel101 publicCloseSession');
+//                                publicFC.publicunRegisterInputer(PinAuth, function (data) {
+//                                    console.info('testFace testauthuserfacecancel101 publicunRegisterInputer');
+//                                    done();
+//                                })
+//                            })
+//                        }, function (data) {
+//                        })
+//                    }, function (data) {
+//                    });
+//                }, function (data) {
+//                })
+//            })
+//        } catch (e) {
+//            console.log("testauthuserfacecancel101 fail " + e);
+//            expect(null).assertFail();
+//        }
+//    })
+//
+//    it('testauthuserfacecancel102', 0, async function (done) {
+//        try {
+//            publicFC.publicRegisterInputer(PinAuth,AuthSubType.PIN_SIX,Inputerdata);
+//            let challenge ;
+//            publicFC.publicOpenSession(UserIDM, function (data) {
+//                console.info('testFace testauthuserfacecancel102 publicOpenSession challenge = ' + data);
+//                challenge = data;
+//                publicFC.publicaddCredential(UserIDM,CredentialInfopinsix, function (data) {
+//                    console.info('testFace testauthuserfacecancel102 addCredential Result=' + JSON.stringify(data));
+//                    let info101 ;
+//                    publicFC.publicauth(UserAuth,challenge,AuthType.PIN,AuthTurstLevel.ATL1, function (data) {
+//                        console.info('testFace testauthuserfacecancel102 auth onResult = ' + JSON.stringify(data));
+//                        info101 = data;
+//                        let token = info101.authextr.token;
+//                        CredentialInfoface2d.token = token;
+//                        publicFC.publicaddCredential(UserIDM,CredentialInfoface2d, async function (data) {
+//                            console.info('testFace testauthuserfacecancel102 addCred=' + JSON.stringify(data));
+//                            let result1 = null;
+//                            let extraInfo1 = null;
+//                            let module1 = null;
+//                            let acquire1 = null;
+//                            let extr1 = null;
+//                            let contextID1 = null;
+//                            contextID1 = await UserAuth.authUser(
+    //                            userID.User1, challenge, AuthType.FACE, AuthTurstLevel.ATL1, {
+//                                onResult: function(result,extraInfo){
+//                                    console.log(result);
+//                                    result1 = result;
+//                                    extraInfo1 = extraInfo;
+//                                },
+//                                onAcquireInfo:function (module,acquire,extr){
+//                                    module1 = module;
+//                                    acquire1 = acquire;
+//                                    extr1 = extr;
+//                                    console.info(module);
+//                                }
+//                            })
+//                            await sleep(8000);
+//                            let authfacecancel101 = publicFC.publicgecancelAuth(UserAuth,contextID1);
+//                            expect(ResultCode.SUCCESS).assertEqual(authfacecancel101);
+//                            expect(ResultCode.CANCELED).assertEqual(result1);
+//                            publicFC.publicCloseSession(UserIDM, function (data) {
+//                                console.info('testFace testauthuserfacecancel102 publicCloseSession');
+//                                publicFC.publicunRegisterInputer(PinAuth, function (data) {
+//                                    console.info('testFace testauthuserfacecancel102 publicunRegisterInputer');
+//                                    done();
+//                                })
+//                            })
+//                        }, function (data) {
+//                        })
+//                    }, function (data) {
+//                    });
+//                }, function (data) {
+//                })
+//            })
+//        } catch (e) {
+//            console.log("testauthuserfacecancel102 fail " + e);
+//            expect(null).assertFail();
+//        }
+//    })
+//
+//    it('testauthuserfacecancel103', 0, async function (done) {
+//        try {
+//            publicFC.publicRegisterInputer(PinAuth,AuthSubType.PIN_SIX,Inputerdata);
+//            let challenge ;
+//            publicFC.publicOpenSession(UserIDM, function (data) {
+//                console.info('testFace testauthuserfacecancel103 publicOpenSession challenge = ' + data);
+//                challenge = data;
+//                publicFC.publicaddCredential(UserIDM,CredentialInfopinsix, function (data) {
+//                    console.info('testFace testauthuserfacecancel103 addCredential= ' + JSON.stringify(data));
+//                    let info101 ;
+//                    publicFC.publicauth(UserAuth,challenge,AuthType.PIN,AuthTurstLevel.ATL1, function (data) {
+//                        console.info('testFace testauthuserfacecancel103 publicauth= ' + JSON.stringify(data));
+//                        info101 = data;
+//                        let token = info101.authextr.token;
+//                        CredentialInfoface2d.token = token;
+//                        publicFC.publicaddCredential(UserIDM,CredentialInfoface2d, async function (data) {
+//                            console.info('testFace testauthuserfacecancel103 addCred=' + JSON.stringify(data));
+//                            let result1 = null;
+//                            let extraInfo1 = null;
+//                            let module1 = null;
+//                            let acquire1 = null;
+//                            let extr1 = null;
+//                            let contextID1 = null;
+//                            contextID1 = await UserAuth.authUser(
+    //                            userID.User1, challenge, AuthType.FACE, AuthTurstLevel.ATL1, {
+//                                onResult: function(result,extraInfo){
+//                                    console.log(result);
+//                                    result1 = result;
+//                                    extraInfo1 = extraInfo;
+//                                },
+//                                onAcquireInfo:function (module,acquire,extr){
+//                                    module1 = module;
+//                                    acquire1 = acquire;
+//                                    extr1 = extr;
+//                                    console.info(module);
+//                                }
+//                            })
+//                            await sleep(11000);
+//                            let authfacecancel101 = publicFC.publicgecancelAuth(UserAuth,contextID1);
+//                            expect(ResultCode.SUCCESS).assertEqual(authfacecancel101);
+//                            expect(ResultCode.CANCELED).assertEqual(result1);
+//                            publicFC.publicCloseSession(UserIDM, function (data) {
+//                                console.info('testFace testauthuserfacecancel103 publicCloseSession');
+//                                publicFC.publicunRegisterInputer(PinAuth, function (data) {
+//                                    console.info('testFace testauthuserfacecancel103 publicunRegisterInputer');
+//                                    done();
+//                                })
+//                            })
+//                        }, function (data) {
+//                        })
+//                    }, function (data) {
+//                    });
+//                }, function (data) {
+//                })
+//            })
+//        } catch (e) {
+//            console.log("testauthuserfacecancel103 fail " + e);
+//            expect(null).assertFail();
+//        }
+//    })
+
+    it('Security_IAM_Face_AddCred_Func_0102', 2, async function (done) {
+        try {
+            publicFC.publicRegisterInputer(PinAuth,AuthSubType.PIN_SIX,Inputerdata);
+            let challenge ;
+            publicFC.publicOpenSession(UserIDM, function (data) {
+                console.info('testFace Security_IAM_Face_AddCred_Func_0102 publicOpenSession challenge = ' + data);
+                challenge = data;
+                publicFC.publicaddCredential(UserIDM,CredentialInfopinsix, function (data) {
+                    console.info('testFace Face_AddCred_Func_0102 addCredential= ' + JSON.stringify(data));
+                    let info101 ;
+                    publicFC.publicauth(UserAuth,challenge,AuthType.PIN,AuthTurstLevel.ATL1, function (data) {
+                        console.info('testFace Face_AddCred_Func_0102 publicauth = ' + JSON.stringify(data));
+                        info101 = data;
+                        let token = info101.authextr.token;
+                        CredentialInfoface2d.token = token;
+                        let addfaceresult ;
+                        publicFC.publicaddCredential(UserIDM,CredentialInfoface2d, function (data) {
+                            console.info('testFace Face_AddCred_Func_0102 addCredential=' + JSON.stringify(data));
+                            addfaceresult = data;
+                            let credentialId = addfaceresult.credentialId;
+                            let token1 = token + "Wrong Word";
+                            let delcredresult ;
+                            publicFC.publicdelCred(UserIDM,credentialId,token1, function (data) {
+                                console.info('testFace Face_AddCred_Func_0102 publicdelCred=' + JSON.stringify(data));
+                                delcredresult = data;
+                                expect(ResultCode.FAIL).assertEqual(delcredresult.authresult);
+                                publicFC.publicdelUser(UserIDM,token, function (data) {
+                                    console.info('testFace Face_AddCred_Func_0102 delUser= ' + JSON.stringify(data));
+                                    publicFC.publicCloseSession(UserIDM, function (data) {
+                                        console.info('testFace Face_AddCred_Func_0102 publicCloseSession ');
+                                        publicFC.publicunRegisterInputer(PinAuth, function (data) {
+                                            console.info('testFace Face_AddCred_Func_0102 publicunRegister ');
+                                            done();
+                                        })
+                                    })
+                                }, function (data) {
+                                })
+                            }, function (data) {
+                            })
+                        }, function (data) {
+                        })
+                    }, function (data) {
+                    })
+                }, function (data) {
+                })
+            })
+        } catch (e) {
+            console.log("testdelface102 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+})

useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/test/Security_IAM_PIN_Func_CallbackJsunit.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 {describe, it, expect} from 'deccjsunit/index'
+import userAuth from '@ohos.userauth'
+import userIDM from '@ohos.useridm'
+import pinAuth from '@ohos.pinauth'
+import * as publicFC from './Publicfunction-n'
+
+let UserIDM = userIDM.constructor()
+let PinAuth = pinAuth.constructor()
+let UserAuth = userAuth.constructor()
+
+let AuthType = {
+    PIN: 1,
+    FACE: 2
+}
+let AuthSubType = {
+    PIN_SIX: 10000,
+    PIN_NUMBER: 10001,
+    PIN_MIXED: 10002,
+    FACE_2D: 20000,
+    FACE_3D: 20001
+}
+let AuthTurstLevel = {
+    ATL1: 10000,
+    ATL2: 20000,
+    ATL3: 30000,
+    ATL4: 40000
+}
+
+let SetPropertyType = {
+    PROCESS_ALGORITHM: 1,
+}
+
+let userID = {
+    User1: 100,
+    User2: 2,
+    User3: 3,
+    User4: 4,
+    User5: 5
+}
+
+let ResultCode = {
+    SUCCESS: 0,
+    FAIL: 1,
+    GENERAL_ERROR: 2,
+    CANCELED: 3,
+    TIMEOUT: 4,
+    TYPE_NOT_SUPPORT: 5,
+    TRUST_LEVEL_NOT_SUPPORT: 6,
+    BUSY: 7,
+    INVALID_PARAMETERS: 8,
+    LOCKED: 9,
+    NOT_ENROLLED: 10,
+    Authfail: 14
+}
+
+let GetPropertyType = {
+    AUTH_SUB_TYPE: 1,
+    REMAIN_TIMES: 2,
+    FREEZING_TIME: 3
+}
+
+let Inputerdata = new Uint8Array([1, 2, 3, 4, 5, 6]);
+let Inputerdatan = new Uint8Array([1, 1, 1, 1, 1, 1]);
+let Inputerdatanum = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
+let Inputerdatanumn = new Uint8Array([1, 1, 1, 1, 1, 1, 1, 1]);
+let Inputerdatamix = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+let Inputerdatamixn = new Uint8Array([1, 1, 1, 1, 1, 1, 1, 1, 1]);
+
+let GetPropertyTypearray = new Array();
+GetPropertyTypearray[0] = GetPropertyType.AUTH_SUB_TYPE;
+GetPropertyTypearray[1] = GetPropertyType.FREEZING_TIME;
+GetPropertyTypearray[2] = GetPropertyType.REMAIN_TIMES;
+
+let GetPropertyRequestpin = {
+    authType: AuthType.PIN,
+    keys: GetPropertyTypearray
+}
+
+let GetPropertyRequestface = {
+    authType: AuthType.FACE,
+    keys: GetPropertyTypearray
+}
+
+let CredentialInfopinsix = {
+    credType: AuthType.PIN,
+    credSubType: AuthSubType.PIN_SIX,
+    token: null
+}
+
+let CredentialInfopinnum = {
+    credType: AuthType.PIN,
+    credSubType: AuthSubType.PIN_NUMBER,
+    token: null
+}
+
+let CredentialInfopinmix = {
+    credType: AuthType.PIN,
+    credSubType: AuthSubType.PIN_MIXED,
+    token: null
+}
+
+let CredentialInfoface2d = {
+    credType: AuthType.FACE,
+    credSubType: AuthSubType.FACE_2D,
+    token: null
+}
+
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+describe('userauthTest', function () {
+    it('Security_IAM_PIN_AddCred_Func_0101', 0, async function (done) {
+        try {
+            let registerresult = publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdata)
+            expect(true).assertEqual(registerresult);
+            registerresult = publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdata)
+            expect(false).assertEqual(registerresult);
+            publicFC.publicunRegisterInputer(PinAuth, function (data) {
+                console.info("testFace Security_IAM_PIN_AddCred_Func_0101 publicunRegisterInputer unRegist = " + data)
+            })
+            done();
+        } catch (e) {
+            console.log("testFace Security_IAM_PIN_AddCred_Func_0101 fail " + e);
+            expect(null).assertFail();
+        }
+
+    })
+
+    it('Security_IAM_PIN_AddCred_Func_0102', 1, async function (done) {
+        console.info('testFace Security_IAM_PIN_AddCred_Func_0102 start');
+        try {
+            let challenge;
+            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdata);
+            publicFC.publicOpenSession(UserIDM, function (data) {
+                console.info('testFace Security_IAM_PIN_AddCred_Func_0102 publicOpenSession data = ' + data);
+                challenge = data;
+                publicFC.publicaddCredential(UserIDM, CredentialInfopinsix, function (data) {
+                    console.info('testFace PIN_AddCred_Func_0102 callback data = ' + JSON.stringify(data));
+                    let addcredresult101 = data.addCredresult;
+                    console.info("testFace PIN_AddCred_Func_0102 addcredresult101 = " + addcredresult101);
+                    expect(ResultCode.SUCCESS).assertEqual(addcredresult101);
+                    let token;
+                    console.info('testFace Security_IAM_PIN_AddCred_Func_0102 addSuccess');
+                    publicFC.publicauthUser(UserAuth, userID.User1, challenge, AuthType.PIN, AuthTurstLevel.ATL1,
+					function (data) {
+                        let auth101 = data.authresult
+                        console.info("testFace Security_IAM_PIN_AddCred_Func_0102 auth101 = " + auth101);
+                        expect(ResultCode.SUCCESS).assertEqual(auth101);
+                        publicFC.publicauth(UserAuth, challenge, AuthType.PIN, AuthTurstLevel.ATL1, function (data) {
+                            console.info('testFace Security_IAM_PIN_AddCred_Func_0102 publicauth');
+                            token = data.authextr.token;
+                            expect(ResultCode.SUCCESS).assertEqual(data.authresult);
+                            console.info("testFace Security_IAM_PIN_AddCred_Func_0102 token = " + token);
+                            publicFC.publicdelUser(UserIDM, token, function (data) {
+                                console.info("testFace PIN_AddCred_Func_0102 publicdelUser callback success");
+                                let deluserresult = data.delUserresult;
+                                console.info("testFace PIN_AddCred_Func_0102 deluserresult = " + deluserresult);
+                                expect(ResultCode.SUCCESS).assertEqual(deluserresult);
+                                publicFC.publicCloseSession(UserIDM, function (data) {
+                                    console.info("testFace PIN_AddCred_Func_0102 CloseSession success data =" + data);
+                                    publicFC.publicunRegisterInputer(PinAuth, function (data) {
+                                        console.info("testFace PIN_AddCred_Func_0102 unRegisterInputer = " + data);
+                                        done();
+                                    })
+                                })
+                            }, function (data) {
+                            })
+                        }, function (data) {
+                        })
+                    }, function (data) {
+                    })
+                }, function (data) {
+                })
+            })
+        } catch (e) {
+            console.log("testaddCredential101 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+
+    it('Security_IAM_PIN_AddCred_Func_0103', 1, async function (done) {
+        console.info('testFace Security_IAM_PIN_AddCred_Func_0103 start');
+        try {
+            let challenge;
+            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_NUMBER, Inputerdatanum);
+            publicFC.publicOpenSession(UserIDM, function (data) {
+                console.info('testFace Security_IAM_PIN_AddCred_Func_0103 publicOpenSession data = ' + data);
+                challenge = data;
+                publicFC.publicaddCredential(UserIDM, CredentialInfopinnum, function (data) {
+                    console.info('testFace PIN_AddCred_Func_0103 callback data = ' + JSON.stringify(data));
+                    let addcredresult101 = data.addCredresult;
+                    console.info("testFace PIN_AddCred_Func_0103 addcredresult101 = " + addcredresult101);
+                    expect(ResultCode.SUCCESS).assertEqual(addcredresult101);
+                    let token;
+                    console.info('testFace Security_IAM_PIN_AddCred_Func_0103 addSuccess');
+                    publicFC.publicauthUser(UserAuth, userID.User1, challenge, AuthType.PIN, AuthTurstLevel.ATL1,
+					function (data) {
+                        let auth101 = data.authresult
+                        console.info("testFace Security_IAM_PIN_AddCred_Func_0103 auth101 = " + auth101);
+                        expect(ResultCode.SUCCESS).assertEqual(auth101);
+                        publicFC.publicauth(UserAuth, challenge, AuthType.PIN, AuthTurstLevel.ATL1, function (data) {
+                            console.info('testFace Security_IAM_PIN_AddCred_Func_0103 publicauth');
+                            token = data.authextr.token;
+                            expect(ResultCode.SUCCESS).assertEqual(data.authresult);
+                            console.info("testFace Security_IAM_PIN_AddCred_Func_0103 token = " + token);
+                            publicFC.publicdelUser(UserIDM, token, function (data) {
+                                console.info("testFace Security_IAM_PIN_AddCred_Func_0103 publicdelUser");
+                                let deluserresult = data.delUserresult;
+                                console.info("testFace PIN_AddCred_Func_0103 deluserresult = " + deluserresult);
+                                expect(ResultCode.SUCCESS).assertEqual(deluserresult);
+                                publicFC.publicCloseSession(UserIDM, function (data) {
+                                    console.info("testFace PIN_AddCred_Func_0103 publicCloseSession = " + data);
+                                    publicFC.publicunRegisterInputer(PinAuth, function (data) {
+                                        console.info("testFace  PIN_AddCred_Func_0103 unRegister success = " + data);
+                                        done();
+                                    })
+                                })
+                            }, function (data) {
+                            })
+                        }, function (data) {
+                        })
+                    }, function (data) {
+                    })
+                }, function (data) {
+                })
+            })
+        } catch (e) {
+            console.log("testaddCredential101 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+
+    it('Security_IAM_PIN_AddCred_Func_0104', 1, async function (done) {
+        console.info('testFace Security_IAM_PIN_AddCred_Func_0104 start');
+        try {
+            let challenge;
+            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_MIXED, Inputerdatamix);
+            publicFC.publicOpenSession(UserIDM, function (data) {
+                console.info('testFace Security_IAM_PIN_AddCred_Func_0104 publicOpenSession data = ' + data);
+                challenge = data;
+                publicFC.publicaddCredential(UserIDM, CredentialInfopinmix, function (data) {
+                    console.info('testFace Security_IAM_PIN_AddCred_Func_0104 callback = ' + JSON.stringify(data));
+                    let addcredresult101 = data.addCredresult;
+                    console.info("testFace PIN_AddCred_Func_0104 addcredresult101 = " + addcredresult101);
+                    expect(ResultCode.SUCCESS).assertEqual(addcredresult101);
+                    let token;
+                    console.info('testFace Security_IAM_PIN_AddCred_Func_0104 addSuccess');
+                    publicFC.publicauthUser(UserAuth, userID.User1, challenge, AuthType.PIN, AuthTurstLevel.ATL1,
+					function (data) {
+                        let auth101 = data.authresult
+                        console.info("testFace Security_IAM_PIN_AddCred_Func_0104 auth101 = " + auth101);
+                        expect(ResultCode.SUCCESS).assertEqual(auth101);
+                        publicFC.publicauth(UserAuth, challenge, AuthType.PIN, AuthTurstLevel.ATL1,
+						function (data) {
+                            console.info('testFace Security_IAM_PIN_AddCred_Func_0104 publicauth');
+                            token = data.authextr.token;
+                            expect(ResultCode.SUCCESS).assertEqual(data.authresult);
+                            console.info("testFace Security_IAM_PIN_AddCred_Func_0104 token = " + token);
+                            publicFC.publicdelUser(UserIDM, token, function (data) {
+                                console.info("testFace Security_IAM_PIN_AddCred_Func_0104 publicdelUser callback");
+                                let deluserresult = data.delUserresult;
+                                console.info("testFace PIN_AddCred_Func_0104 publicdeluserresult = " + deluserresult);
+                                expect(ResultCode.SUCCESS).assertEqual(deluserresult);
+                                publicFC.publicCloseSession(UserIDM, function (data) {
+                                    console.info("testFace PIN_AddCred_Func_0104 publicCloseSession = " + data);
+                                    publicFC.publicunRegisterInputer(PinAuth, function (data) {
+                                        console.info("testFace PIN_AddCred_Func_0104 unRegister success = " + data);
+                                        done();
+                                    })
+                                })
+                            }, function (data) {
+                            })
+                        }, function (data) {
+                        })
+                    }, function (data) {
+                    })
+                }, function (data) {
+                })
+            })
+        } catch (e) {
+            console.log("testaddCredential101 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+    //
+    //    it('Security_IAM_PIN_AddCred_Func_0105', , async function (done) {
+    //        console.info('testFace Security_IAM_PIN_AddCred_Func_0105 start');
+    //        try {
+    //            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_MIXED, Inputerdata);
+    //            let challenge;
+    //            publicFC.publicOpenSession(UserIDM, function (data) {
+    //                challenge = data;
+    //                console.info("testFace Security_IAM_PIN_AddCred_Func_0105 challenge" + challenge);
+    //                let result1 = null;
+    //                publicFC.publicaddCredential(UserIDM, CredentialInfopinmix, async function (data) {
+    //                    result1 = data.addCredresult;
+    //                    console.info("testFace Security_IAM_PIN_AddCred_Func_0105 result1" + result1);
+    ////                    await sleep(3000);
+    //                }, function (data) {
+    //                });
+    //                let cancelresult = publicFC.publiccancel(UserIDM, challenge);
+    //                console.info("testFace Security_IAM_PIN_AddCred_Func_0105 publiccancel = " + cancelresult);
+    //                expect(ResultCode.SUCCESS).assertEqual(cancelresult);
+    ////                expect(ResultCode.CANCELED).assertEqual(result1);
+    //                publicFC.publicCloseSession(UserIDM, function (data) {
+    //                    console.info("testFace Security_IAM_PIN_AddCred_Func_0105 closesession = " + data);
+    //                    publicFC.publicunRegisterInputer(PinAuth, function (data) {
+    //                        console.info("testFace Security_IAM_PIN_AddCred_Func_0105 unRegist = " + data);
+    //                        done();
+    //                    })
+    //                })
+    //            })
+    //        } catch (e) {
+    //            console.log("Security_IAM_PIN_AddCred_Func_0105 fail " + e);
+    //            expect(null).assertFail();
+    //        }
+    //    })
+
+    //    it('Security_IAM_PIN_AddCred_Func_0106', 0, async function (done) {
+    //        try {
+    //            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_MIXED, Inputerdata)
+    //            let challenge;
+    //            publicFC.publicOpenSession(UserIDM, function (data) {
+    //                challenge = data;
+    //                console.info("testFace Security_IAM_PIN_AddCred_Func_0106 challenge" + challenge);
+    //                let result2 = null;
+    //                publicFC.publicaddCredential(UserIDM, CredentialInfopinmix, async function (data) {
+    //                    result2 = data.addCredresult;
+    //                    console.info("testFace Security_IAM_PIN_AddCred_Func_0106 result2" + result2);
+    //                    await sleep(8000);
+    //                    let cancelresult = publicFC.publiccancel(UserIDM, challenge);
+    //                    expect(ResultCode.SUCCESS).assertEqual(cancelresult);
+    //                    expect(ResultCode.CANCELED).assertEqual(result2);
+    //                    publicFC.publicCloseSession(UserIDM, function (data) {
+    //                        console.info("testFace Security_IAM_PIN_AddCred_Func_0106 closesession = " + data);
+    //                        publicFC.publicunRegisterInputer(PinAuth, function (data) {
+    //                            console.info("testFace Security_IAM_PIN_AddCred_Func_0106 unRegist = " + data);
+    //                            done();
+    //                        })
+    //                    })
+    //                }, function (data) {
+    //                })
+    //            })
+    //        } catch (e) {
+    //            console.log("testFace Security_IAM_PIN_AddCred_Func_0106 fail " + e);
+    //            expect(null).assertFail();
+    //        }
+    //    })
+
+    //    it('Security_IAM_PIN_AddCred_Func_0107', 0, async function (done) {
+    //        console.info('testFace testaddCredentialcancel101 start');
+    //        try {
+    //
+    //            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_MIXED, Inputerdata)
+    //            let challenge
+    //            publicFC.publicOpenSession(UserIDM, function (data) {
+    //                challenge = data;
+    //                console.info("Security_IAM_PIN_AddCred_Func_0107 challenge" + challenge);
+    //                let result3 = null;
+    //                publicFC.publicaddCredential(UserIDM, CredentialInfopinmix,async function (data) {
+    //                    result3 = data.addCredresult;
+    //                    console.info("Security_IAM_PIN_AddCred_Func_0107 result3" + result3);
+    //                    await sleep(11000);
+    //                    let cancelresult = publicFC.publiccancel(UserIDM, challenge);
+    //                    expect(ResultCode.SUCCESS).assertEqual(cancelresult);
+    //                    expect(ResultCode.CANCELED).assertEqual(result3);
+    //                    publicFC.publicauth(UserAuth, challenge, AuthType.PIN, AuthTurstLevel.ATL1,function (data) {
+    //                        let token = data.authextr.token;
+    //                        console.info("Security_IAM_PIN_AddCred_Func_0107 token" + token);
+    //                        publicFC.publicdelUser(UserIDM, token, function (data) {
+    //                            let deluserresult = data.delUserresult;
+    //                            console.info("Security_IAM_PIN_AddCred_Func_0107 deluserresult" + deluserresult);
+    //                            publicFC.publicCloseSession(UserIDM, function (data) {
+    //                                console.info("Security_IAM_PIN_AddCred_Func_0107 closesession = " + data);
+    //                                publicFC.publicunRegisterInputer(PinAuth, function (data) {
+    //                                    console.info("Security_IAM_PIN_AddCred_Func_0107 unRegist = " + data);
+    //                                    done();
+    //                                })
+    //                            })
+    //                        }, function (data) {
+    //                        })
+    //                    }, function (data) {
+    //                    })
+    //                }, function (data) {
+    //                })
+    //            })
+    //        } catch (e) {
+    //            console.log("Security_IAM_PIN_AddCred_Func_0107 fail " + e);
+    //            expect(null).assertFail();
+    //        }
+    //    })
+
+
+    it('Security_IAM_PIN_Auth_Func_0101', 3, async function (done) {
+        console.info('testFace Security_IAM_Error_Func_0101 start');
+        try {
+            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdata)
+            publicFC.publicOpenSession(UserIDM, function (data) {
+                let challenge1 = data;
+                console.info("Security_IAM_PIN_Auth_Func_0101 challenge1 = " + challenge1);
+                publicFC.publicaddCredential(UserIDM, CredentialInfopinnum, function (data) {
+                    let addcredresult101 = data.addcredresult;
+                    publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1, function (data) {
+                        let auth101 = data
+                        console.info("Security_IAM_PIN_Auth_Func_0101 auth1 = " + auth101.authresult);
+                        let token = auth101.authextr.token
+                        console.info("Security_IAM_PIN_Auth_Func_0101 token = " + token);
+                        publicFC.publicunRegisterInputer(PinAuth, async function (data) {
+                            console.info("Security_IAM_PIN_Auth_Func_0101 unRegist = " + data);
+                            setTimeout(publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdatan), 500)
+                            console.info("Security_IAM_PIN_Auth_Func_0101 challenge2 = " + challenge1);
+                            await publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1,
+							function (data) {
+                                let authresult = data.authresult
+                                expect(ResultCode.Authfail).assertEqual(authresult);
+                                publicFC.publicdelUser(UserIDM, token, function (data) {
+                                    let delresult = data.delUserresult
+                                    console.info("Security_IAM_PIN_Auth_Func_0101 delresult = " + delresult);
+                                    publicFC.publicCloseSession(UserIDM, function (data) {
+                                        console.info("Security_IAM_PIN_Auth_Func_0101 closesession = " + data);
+                                        publicFC.publicunRegisterInputer(PinAuth, function (data) {
+                                            console.info("Security_IAM_PIN_Auth_Func_0101 unRegist = " + data);
+                                            done();
+                                        })
+                                    })
+                                }, function (data) {
+                                })
+                            }, function (data) {
+                            })
+                        })
+                    }, function (data) {
+                    })
+                }, function (data) {
+                })
+            })
+        } catch (e) {
+            console.log("Security_IAM_PIN_Auth_Func_0101 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+
+
+    it('Security_IAM_PIN_Auth_Func_0102', 3, async function (done) {
+        console.info('testFace Security_IAM_PIN_Auth_Func_0102 start');
+        try {
+            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_MIXED, Inputerdatamix)
+            publicFC.publicOpenSession(UserIDM, function (data) {
+                let challenge1 = data;
+                console.info("Security_IAM_PIN_Auth_Func_0102 challenge1 = " + challenge1);
+                publicFC.publicaddCredential(UserIDM, CredentialInfopinnum, function (data) {
+                    let addcredresult102 = data.addcredresult;
+                    publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1, function (data) {
+                        let auth102 = data
+                        console.info("Security_IAM_PIN_Auth_Func_0102 auth102 = " + auth102);
+                        let token = auth102.authextr.token
+                        console.info("Security_IAM_PIN_Auth_Func_0102 token = " + token);
+                        publicFC.publicunRegisterInputer(PinAuth, async function (data) {
+                            console.info("Security_IAM_PIN_Auth_Func_0102 unRegist = " + data);
+                            setTimeout(
+							publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_MIXED, Inputerdatamixn), 500)
+                            await publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1,
+							function (data) {
+                                let authresult = data.authresult
+                                expect(ResultCode.Authfail).assertEqual(authresult);
+                                let deluserresult = publicFC.publicdelUser(UserIDM, token, function (data) {
+                                    let delresult = data.delUserresult
+                                    console.info("Security_IAM_PIN_Auth_Func_0102 delresult = " + delresult);
+                                    publicFC.publicCloseSession(UserIDM, function (data) {
+                                        console.info("Security_IAM_PIN_Auth_Func_0102 closesession = " + data);
+                                        publicFC.publicunRegisterInputer(PinAuth, function (data) {
+                                            console.info("Security_IAM_PIN_Auth_Func_0102 unRegist = " + data);
+                                            done();
+                                        })
+                                    })
+                                }, function (data) {
+                                })
+                            }, function (data) {
+                            })
+                        })
+                    }, function (data) {
+                    })
+                }, function (data) {
+                })
+            })
+        } catch (e) {
+            console.log("Security_IAM_PIN_Auth_Func_0102 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+
+
+    it('Security_IAM_PIN_Auth_Func_0103', 3, async function (done) {
+        console.info('testFace Security_IAM_PIN_Auth_Func_0103 start');
+        try {
+            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_NUMBER, Inputerdatanum)
+            publicFC.publicOpenSession(UserIDM, function (data) {
+                let challenge1 = data;
+                console.info("Security_IAM_PIN_Auth_Func_0103 challenge1 = " + challenge1);
+                publicFC.publicaddCredential(UserIDM, CredentialInfopinnum, function (data) {
+                    let addcredresult103 = data.addcredresult;
+                    publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1, function (data) {
+                        let auth103 = data
+                        console.info("Security_IAM_PIN_Auth_Func_0103 auth103 = " + auth103);
+                        let token = auth103.authextr.token
+                        console.info("Security_IAM_PIN_Auth_Func_0103 token = " + token);
+                        publicFC.publicunRegisterInputer(PinAuth, async function (data) {
+                            console.info("Security_IAM_PIN_Auth_Func_0103 unRegist = " + data);
+                            setTimeout(
+							publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_NUMBER, Inputerdatanumn), 500)
+                            await publicFC.publicauth(UserAuth, challenge1, AuthType.PIN, AuthTurstLevel.ATL1,
+							function (data) {
+                                let authresult = data.authresult
+                                expect(ResultCode.Authfail).assertEqual(authresult);
+                                let deluserresult = publicFC.publicdelUser(UserIDM, token, function (data) {
+                                    let delresult = data.delUserresult
+                                    console.info("Security_IAM_PIN_Auth_Func_0103 delresult = " + delresult);
+                                    publicFC.publicCloseSession(UserIDM, function (data) {
+                                        console.info("Security_IAM_PIN_Auth_Func_0103 closesession = " + data);
+                                        publicFC.publicunRegisterInputer(PinAuth, function (data) {
+                                            console.info("Security_IAM_PIN_Auth_Func_0103 unRegist = " + data);
+                                            done();
+                                        })
+                                    })
+                                }, function (data) {
+                                })
+                            }, function (data) {
+                            })
+                        })
+                    }, function (data) {
+                    })
+                }, function (data) {
+                })
+            })
+        } catch (e) {
+            console.log("Security_IAM_PIN_Auth_Func_0103 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+
+
+    it('Security_IAM_PIN_Auth_Func_0104', 3, async function (done) {
+        console.info('testFace Security_IAM_PIN_Auth_Func_0104 start');
+        try {
+            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdata)
+            publicFC.publicOpenSession(UserIDM, function (data) {
+                let challenge1 = data;
+                console.info("Security_IAM_PIN_Auth_Func_0104 challenge1 = " + challenge1);
+                publicFC.publicaddCredential(UserIDM, CredentialInfopinnum, function (data) {
+                    let addcredresult101 = data.addcredresult;
+                    publicFC.publicauthUser(UserAuth, userID.User1, challenge1, AuthType.PIN, AuthTurstLevel.ATL1,
+					function (data) {
+                        let auth101 = data
+                        console.info("Security_IAM_PIN_Auth_Func_0104 auth1 = " + auth101.authresult);
+                        let token = auth101.authextr.token
+                        console.info("Security_IAM_PIN_Auth_Func_0104 token = " + token);
+                        publicFC.publicunRegisterInputer(PinAuth, async function (data) {
+                            console.info("Security_IAM_PIN_Auth_Func_0104 unRegist = " + data);
+                            setTimeout(publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdatan),500)
+                            console.info("Security_IAM_PIN_Auth_Func_0104 challenge2 = " + challenge1);
+                            await publicFC.publicauthUser(
+							UserAuth, userID.User1, challenge1, AuthType.PIN, AuthTurstLevel.ATL1, function (data) {
+                                let authresult = data.authresult
+                                expect(ResultCode.Authfail).assertEqual(authresult);
+                                publicFC.publicdelUser(UserIDM, token, function (data) {
+                                    let delresult = data.delUserresult
+                                    console.info("Security_IAM_PIN_Auth_Func_0104 delresult = " + delresult);
+                                    publicFC.publicCloseSession(UserIDM, function (data) {
+                                        console.info("Security_IAM_PIN_Auth_Func_0104 closesession = " + data);
+                                        publicFC.publicunRegisterInputer(PinAuth, function (data) {
+                                            console.info("Security_IAM_PIN_Auth_Func_0104 unRegist = " + data);
+                                            done();
+                                        })
+                                    })
+                                }, function (data) {
+                                })
+                            }, function (data) {
+                            })
+                        })
+                    }, function (data) {
+                    })
+                }, function (data) {
+                })
+            })
+        } catch (e) {
+            console.log("Security_IAM_PIN_Auth_Func_0104 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+
+
+    it('Security_IAM_PIN_Auth_Func_0105', 3, async function (done) {
+        console.info('testFace Security_IAM_PIN_Auth_Func_0105 start');
+        try {
+            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_MIXED, Inputerdatamix)
+            publicFC.publicOpenSession(UserIDM, function (data) {
+                let challenge1 = data;
+                console.info("Security_IAM_PIN_Auth_Func_0105 challenge1 = " + challenge1);
+                publicFC.publicaddCredential(UserIDM, CredentialInfopinnum, function (data) {
+                    let addcredresult102 = data.addcredresult;
+                    publicFC.publicauthUser(UserAuth, userID.User1, challenge1, AuthType.PIN, AuthTurstLevel.ATL1,
+					function (data) {
+                        let auth102 = data
+                        console.info("Security_IAM_PIN_Auth_Func_0105 auth102 = " + auth102);
+                        let token = auth102.authextr.token
+                        console.info("Security_IAM_PIN_Auth_Func_0105 token = " + token);
+                        publicFC.publicunRegisterInputer(PinAuth, async function (data) {
+                            console.info("Security_IAM_PIN_Auth_Func_0105 unRegist = " + data);
+                            setTimeout(
+							publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_MIXED, Inputerdatamixn), 500)
+                            await publicFC.publicauthUser(
+							UserAuth, userID.User1, challenge1, AuthType.PIN, AuthTurstLevel.ATL1, function (data) {
+                                let authresult = data.authresult
+                                expect(ResultCode.Authfail).assertEqual(authresult);
+                                let deluserresult = publicFC.publicdelUser(UserIDM, token, function (data) {
+                                    let delresult = data.delUserresult
+                                    console.info("Security_IAM_PIN_Auth_Func_0105 delresult = " + delresult);
+                                    publicFC.publicCloseSession(UserIDM, function (data) {
+                                        console.info("Security_IAM_PIN_Auth_Func_0105 closesession = " + data);
+                                        publicFC.publicunRegisterInputer(PinAuth, function (data) {
+                                            console.info("Security_IAM_PIN_Auth_Func_0105 unRegist = " + data);
+                                            done();
+                                        })
+                                    })
+                                }, function (data) {
+                                })
+                            }, function (data) {
+                            })
+                        })
+                    }, function (data) {
+                    })
+                }, function (data) {
+                })
+            })
+        } catch (e) {
+            console.log("Security_IAM_PIN_Auth_Func_0105 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+
+
+    it('Security_IAM_PIN_Auth_Func_0106', 3, async function (done) {
+        console.info('testFace Security_IAM_PIN_Auth_Func_0106 start');
+        try {
+            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_NUMBER, Inputerdatanum)
+            publicFC.publicOpenSession(UserIDM, function (data) {
+                let challenge1 = data;
+                console.info("Security_IAM_PIN_Auth_Func_0106 challenge1 = " + challenge1);
+                publicFC.publicaddCredential(UserIDM, CredentialInfopinnum, function (data) {
+                    let addcredresult103 = data.addcredresult;
+                    publicFC.publicauthUser(
+					UserAuth, userID.User1, challenge1, AuthType.PIN, AuthTurstLevel.ATL1, function (data) {
+                        let auth103 = data
+                        console.info("Security_IAM_PIN_Auth_Func_0106 auth103 = " + auth103);
+                        let token = auth103.authextr.token
+                        console.info("Security_IAM_PIN_Auth_Func_0106 token = " + token);
+                        publicFC.publicunRegisterInputer(PinAuth, async function (data) {
+                            console.info("Security_IAM_PIN_Auth_Func_0106 unRegist = " + data);
+                            setTimeout(
+							publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_NUMBER, Inputerdatanumn), 500)
+                            await publicFC.publicauthUser(
+							UserAuth, userID.User1, challenge1, AuthType.PIN, AuthTurstLevel.ATL1, function (data) {
+                                let authresult = data.authresult
+                                expect(ResultCode.Authfail).assertEqual(authresult);
+                                let deluserresult = publicFC.publicdelUser(UserIDM, token, function (data) {
+                                    let delresult = data.delUserresult
+                                    console.info("Security_IAM_PIN_Auth_Func_0106 delresult = " + delresult);
+                                    publicFC.publicCloseSession(UserIDM, function (data) {
+                                        console.info("Security_IAM_PIN_Auth_Func_0106 closesession = " + data);
+                                        publicFC.publicunRegisterInputer(PinAuth, function (data) {
+                                            console.info("Security_IAM_PIN_Auth_Func_0106 unRegist = " + data);
+                                            done();
+                                        })
+                                    })
+                                }, function (data) {
+                                })
+                            }, function (data) {
+                            })
+                        })
+                    }, function (data) {
+                    })
+                }, function (data) {
+                })
+            })
+        } catch (e) {
+            console.log("Security_IAM_PIN_Auth_Func_0103 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+
+
+    //    it('Security_IAM_PIN_Auth_Func_0107', 0, async function (done) {
+    //        try {
+    //            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdata)
+    //            publicFC.publicOpenSession(UserIDM, function (data) {
+    //                let challenge = data;
+    //                console.info("Security_IAM_PIN_Auth_Func_0107 challenge = " + challenge);
+    //                publicFC.publicaddCredential(UserIDM, CredentialInfopinsix, function (data) {
+    //                    let addcredresult101 = data.addCredresult;
+    //                    console.info("Security_IAM_PIN_Auth_Func_0107 addcredresult101 = " + addcredresult101);
+    //                    let result1 = null;
+    //                    let contextID1 = null;
+    //                    contextID1 = publicFC.publicauth(challenge, AuthType.PIN, AuthTurstLevel.ATL1,
+    //                    async function (data) {
+    //                        console.info("Security_IAM_PIN_Auth_Func_0107 contextID1 = " + contextID1);
+    //                        result1 = data.authresult;
+    //                        console.info("Security_IAM_PIN_Auth_Func_0107 result1 = " + result1);
+    //                        await sleep(3000);
+    //                        let cancelAuthresult = publicFC.publicgecancelAuth(UserAuth, contextID1)
+    //                        console.info("Security_IAM_PIN_Auth_Func_0107 cancelAuthresult = " + cancelAuthresult);
+    //                        expect(ResultCode.SUCCESS).assertEqual(cancelAuthresult);
+    //                        expect(ResultCode.CANCELED).assertEqual(result1);
+    //                        publicFC.publicCloseSession(UserIDM, function (data) {
+    //                            console.info("Security_IAM_PIN_Auth_Func_0107 closesession = " + data);
+    //                            publicFC.publicunRegisterInputer(PinAuth, function (data) {
+    //                                console.info("Security_IAM_PIN_Auth_Func_0107 unRegist = " + data);
+    //                                done();
+    //                            })
+    //                        })
+    //                    }, function (data) {
+    //                    })
+    //                }, function (data) {
+    //                })
+    //            })
+    //        } catch (e) {
+    //            console.log("Security_IAM_PIN_Auth_Func_0107 fail " + e);
+    //            expect(null).assertFail();
+    //        }
+    //    })
+
+    //    it('Security_IAM_PIN_Auth_Func_0108', 0, async function (done) {
+    //        try {
+    //            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdata)
+    //            publicFC.publicOpenSession(UserIDM, function (data) {
+    //                let challenge = data;
+    //                console.info("Security_IAM_PIN_Auth_Func_0108 challenge = " + challenge);
+    //                publicFC.publicaddCredential(UserIDM, CredentialInfopinsix, function (data) {
+    //                    let addcredresult102 = data.addCredresult;
+    //                    console.info("Security_IAM_PIN_Auth_Func_0108 addcredresult102 = " + addcredresult102);
+    //                    let result2 = null;
+    //                    let contextID2 = null;
+    //                    contextID2 = publicFC.publicauth(challenge, AuthType.PIN, AuthTurstLevel.ATL1,
+    //                    async function (data) {
+    //                        console.info("Security_IAM_PIN_Auth_Func_0108 contextID2 = " + contextID2);
+    //                        result2 = data.authresult;
+    //                        console.info("Security_IAM_PIN_Auth_Func_0108 result2 = " + result2);
+    //                        await sleep(8000);
+    //                        let cancelAuthresult = publicFC.publicgecancelAuth(UserAuth, contextID2)
+    //                        console.info("Security_IAM_PIN_Auth_Func_0108 cancelAuthresult = " + cancelAuthresult);
+    //                        expect(ResultCode.SUCCESS).assertEqual(cancelAuthresult);
+    //                        expect(ResultCode.CANCELED).assertEqual(result2);
+    //                        publicFC.publicCloseSession(UserIDM, function (data) {
+    //                            console.info("Security_IAM_PIN_Auth_Func_0108 closesession = " + data);
+    //                            publicFC.publicunRegisterInputer(PinAuth, function (data) {
+    //                                console.info("Security_IAM_PIN_Auth_Func_0108 unRegist = " + data);
+    //                                done();
+    //                            })
+    //                        })
+    //                    }, function (data) {
+    //                    })
+    //                }, function (data) {
+    //                })
+    //            })
+    //        } catch (e) {
+    //            console.log("Security_IAM_PIN_Auth_Func_0108 fail " + e);
+    //            expect(null).assertFail();
+    //        }
+    //    })
+
+    //    it('Security_IAM_PIN_Auth_Func_0109', 0, async function (done) {
+    //        try {
+    //
+    //            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdata)
+    //            publicFC.publicOpenSession(UserIDM, function (data) {
+    //                let challenge = data;
+    //                console.info("Security_IAM_PIN_Auth_Func_0109 challenge = " + challenge);
+    //                publicFC.publicaddCredential(UserIDM, CredentialInfopinsix, function (data) {
+    //                    let addcredresult103 = data.addCredresult;
+    //                    console.info("Security_IAM_PIN_Auth_Func_0109 addcredresult103 = " + addcredresult103);
+    //                    let result3 = null;
+    //                    let contextID3 = null;
+    //                    contextID3 = publicFC.publicauth(challenge, AuthType.PIN, AuthTurstLevel.ATL1,
+    //                    async function (data) {
+    //                        console.info("Security_IAM_PIN_Auth_Func_0109 contextID3 = " + contextID3);
+    //                        result3 = data.authresult;
+    //                        console.info("Security_IAM_PIN_Auth_Func_0109 result3 = " + result3);
+    //                        let token = data.authextr.token;
+    //                        await sleep(11000);
+    //                        let cancelAuthresult = publicFC.publicgecancelAuth(UserAuth, contextID3)
+    //                        console.info("Security_IAM_PIN_Auth_Func_0109 cancelAuthresult = " + cancelAuthresult);
+    //                        expect(ResultCode.SUCCESS).assertEqual(cancelAuthresult);
+    //                        expect(ResultCode.CANCELED).assertEqual(result3);
+    //                        publicFC.publicdelUser(UserIDM, token, function (data) {
+    //                            let deluserresult = data.delUserresult
+    //                            console.info("Security_IAM_PIN_Auth_Func_0109 deluserresult = " + deluserresult);
+    //                            publicFC.publicCloseSession(UserIDM, function (data) {
+    //                                console.info("Security_IAM_PIN_Auth_Func_0109 closesession = " + data);
+    //                                publicFC.publicunRegisterInputer(PinAuth, function (data) {
+    //                                    console.info("Security_IAM_PIN_Auth_Func_0109 unRegist = " + data);
+    //                                    done();
+    //                                })
+    //                            })
+    //                        }, function (data) {
+    //                        })
+    //                    }, function (data) {
+    //                    })
+    //                }, function (data) {
+    //                })
+    //            })
+    //
+    //        } catch (e) {
+    //            console.log("testcancelauth103 fail " + e);
+    //            expect(null).assertFail();
+    //        }
+    //    })
+
+    //    it('Security_IAM_PIN_Auth_Func_0110', 0, async function (done) {
+    //        try {
+    //            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdata)
+    //            publicFC.publicOpenSession(UserIDM, function (data) {
+    //                let challenge = data;
+    //                console.info("testFace Security_IAM_PIN_Auth_Func_0110 challenge = " + challenge);
+    //                publicFC.publicaddCredential(UserIDM, CredentialInfopinsix, function (data) {
+    //                    let addcredresult101 = data.addCredresult;
+    //                    console.info("testFace PIN_Auth_Func_0110 addcredresult101 = " + addcredresult101);
+    //                    let result1 = null;
+    //                    let contextID1 = null;
+    //                    contextID1 = publicFC.publicauthUser(challenge, AuthType.PIN, AuthTurstLevel.ATL1,
+    //                    async function (data) {
+    //                        console.info("testFace Security_IAM_PIN_Auth_Func_0110 contextID1 = " + contextID1);
+    //                        result1 = data.authresult;
+    //                        console.info("testFace Security_IAM_PIN_Auth_Func_0110 result2 = " + result1);
+    //                        await sleep(3000);
+    //                        let cancelAuthresult = publicFC.publicgecancelAuth(UserAuth, contextID1)
+    //                        console.info("testFace PIN_Auth_Func_0110 cancelAuthresult = " + cancelAuthresult);
+    //                        expect(ResultCode.SUCCESS).assertEqual(cancelAuthresult);
+    //                        expect(ResultCode.CANCELED).assertEqual(result1);
+    //                        publicFC.publicCloseSession(UserIDM, function (data) {
+    //                            console.info("testFace Security_IAM_PIN_Auth_Func_0110 closesession = " + data);
+    //                            publicFC.publicunRegisterInputer(PinAuth, function (data) {
+    //                                console.info("testFace Security_IAM_PIN_Auth_Func_0110 unRegist = " + data);
+    //                                done();
+    //                            })
+    //                        })
+    //                    }, function (data) {
+    //                    })
+    //                }, function (data) {
+    //                })
+    //            })
+    //        } catch (e) {
+    //            console.log("testFace Security_IAM_PIN_Auth_Func_0110 fail " + e);
+    //            expect(null).assertFail();
+    //        }
+    //    })
+
+    //    it('Security_IAM_PIN_Auth_Func_0111', 0, async function (done) {
+    //        try {
+    //            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdata)
+    //            publicFC.publicOpenSession(UserIDM, function (data) {
+    //                let challenge = data;
+    //                console.info("testFace Security_IAM_PIN_Auth_Func_0111 challenge = " + challenge);
+    //                publicFC.publicaddCredential(UserIDM, CredentialInfopinsix, function (data) {
+    //                    let addcredresult102 = data.addCredresult;
+    //                    console.info("testFace PIN_Auth_Func_0111 addcredresult102 = " + addcredresult102);
+    //                    let result2 = null;
+    //                    let contextID2 = null;
+    //                    contextID2 = publicFC.publicauthUser(challenge, AuthType.PIN, AuthTurstLevel.ATL1,
+    //                    async function (data) {
+    //                        console.info("testFace Security_IAM_PIN_Auth_Func_0111 contextID2 = " + contextID2);
+    //                        result2 = data.authresult;
+    //                        console.info("testFace Security_IAM_PIN_Auth_Func_0111 result2 = " + result2);
+    //                        await sleep(8000);
+    //                        let cancelAuthresult = publicFC.publicgecancelAuth(UserAuth, contextID2)
+    //                        console.info("testFace PIN_Auth_Func_0111 cancelAuthresult = " + cancelAuthresult);
+    //                        expect(ResultCode.SUCCESS).assertEqual(cancelAuthresult);
+    //                        expect(ResultCode.CANCELED).assertEqual(result2);
+    //                        publicFC.publicCloseSession(UserIDM, function (data) {
+    //                            console.info("testFace Security_IAM_PIN_Auth_Func_0111 closesession = " + data);
+    //                            publicFC.publicunRegisterInputer(PinAuth, function (data) {
+    //                                console.info("testFace Security_IAM_PIN_Auth_Func_0111 unRegist = " + data);
+    //                                done();
+    //                            })
+    //                        })
+    //                    }, function (data) {
+    //                    })
+    //                }, function (data) {
+    //                })
+    //            })
+    //        } catch (e) {
+    //            console.log("testFace Security_IAM_PIN_Auth_Func_0111 fail " + e);
+    //            expect(null).assertFail();
+    //        }
+    //    })
+
+    //    it('Security_IAM_PIN_Auth_Func_0112', 0, async function (done) {
+    //        try {
+    //            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdata)
+    //            publicFC.publicOpenSession(UserIDM, function (data) {
+    //                let challenge = data;
+    //                console.info("testFace Security_IAM_PIN_Auth_Func_0112 challenge = " + challenge);
+    //                publicFC.publicaddCredential(UserIDM, CredentialInfopinsix, function (data) {
+    //                    let addcredresult103 = data.addCredresult;
+    //                    console.info("testFace PIN_Auth_Func_0112 addcredresult103 = " + addcredresult103);
+    //                    let result3 = null;
+    //                    let contextID3 = null;
+    //                    contextID3 = publicFC.publicauthUser(challenge, AuthType.PIN, AuthTurstLevel.ATL1,
+    //                    async function (data) {
+    //                        console.info("testFace Security_IAM_PIN_Auth_Func_0112 contextID3 = " + contextID3);
+    //                        result3 = data.authresult;
+    //                        console.info("testFace Security_IAM_PIN_Auth_Func_0112 result3 = " + result3);
+    //                        let token = data.authextr.token;
+    //                        await sleep(11000);
+    //                        let cancelAuthresult = publicFC.publicgecancelAuth(UserAuth, contextID3)
+    //                        console.info("testFace PIN_Auth_Func_0112 cancelAuthresult = " + cancelAuthresult);
+    //                        expect(ResultCode.SUCCESS).assertEqual(cancelAuthresult);
+    //                        expect(ResultCode.CANCELED).assertEqual(result3);
+    //                        publicFC.publicdelUser(UserIDM, token, function (data) {
+    //                            let deluserresult = data.delUserresult
+    //                            console.info("testFace PIN_Auth_Func_0112 deluserresult = " + deluserresult);
+    //                            publicFC.publicCloseSession(UserIDM, function (data) {
+    //                                console.info("testFace Security_IAM_PIN_Auth_Func_0112 closesession = " + data);
+    //                                publicFC.publicunRegisterInputer(PinAuth, function (data) {
+    //                                    console.info("testFace Security_IAM_PIN_Auth_Func_0112 unRegist = " + data);
+    //                                    done();
+    //                                })
+    //                            })
+    //                        }, function (data) {
+    //                        })
+    //                    }, function (data) {
+    //                    })
+    //                }, function (data) {
+    //                })
+    //            })
+    //        } catch (e) {
+    //            console.log("testFace Security_IAM_PIN_Auth_Func_0112 fail " + e);
+    //            expect(null).assertFail();
+    //        }
+    //    })
+
+    it('Security_IAM_PIN_Update_Func_0101', 0, async function (done) {
+        console.info('testFace Security_IAM_PIN_Update_Func_0101 start');
+        try {
+            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdata)
+            publicFC.publicOpenSession(UserIDM, function (data) {
+                let challenge = data;
+                console.info("Security_IAM_PIN_Update_Func_0101 challenge = " + challenge);
+                publicFC.publicaddCredential(UserIDM, CredentialInfopinsix, function (data) {
+                    let addcredresult101 = data.addcredresult;
+                    console.info("Security_IAM_PIN_Update_Func_0101 addcredresult101 = " + addcredresult101);
+                    publicFC.publicauth(UserAuth, challenge, AuthType.PIN, AuthTurstLevel.ATL1, function (data) {
+                        let auth101 = data
+                        console.info("Security_IAM_PIN_Update_Func_0101 auth101 = " + auth101);
+                        let token = auth101.authextr.token
+                        console.info("Security_IAM_PIN_Update_Func_0101 token = " + token);
+                        publicFC.publicunRegisterInputer(PinAuth, async function (data) {
+                            console.info("Security_IAM_PIN_Update_Func_0101 unRegist = " + data);
+                            await setTimeout(
+							publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_NUMBER, Inputerdatanum), 500)
+                            CredentialInfopinnum.token = token
+                            console.info("PIN_Update_Func_0101 Infopinnum.token = " + CredentialInfopinnum.token);
+                            await publicFC.publicupdateCred(UserIDM, CredentialInfopinnum, function (data) {
+                                let updateresult = data.updateCredresult;
+                                console.info("Security_IAM_PIN_Update_Func_0101 updateresult = " + updateresult);
+                                expect(ResultCode.SUCCESS).assertEqual(updateresult);
+                                publicFC.publicauth(UserAuth, challenge, AuthType.PIN, AuthTurstLevel.ATL1,
+								function (data) {
+                                    auth101 = data
+                                    console.info("Security_IAM_PIN_Update_Func_0101 auth101 = " + auth101);
+                                    let token1 = auth101.authextr.token
+                                    console.info("Security_IAM_PIN_Update_Func_0101 token1 = " + token1);
+                                    publicFC.publicdelUser(UserIDM, token1, function (data) {
+                                        console.info("PIN_Update_Func_0101 delUser result  = " + data.delUserresult);
+                                        publicFC.publicCloseSession(UserIDM, function (data) {
+                                            console.info("Security_IAM_PIN_Update_Func_0101 closesession = " + data);
+                                            publicFC.publicunRegisterInputer(PinAuth, function (data) {
+                                                console.info("Security_IAM_PIN_Update_Func_0101 unRegist = " + data);
+                                                done();
+                                            })
+                                        })
+                                    }, function (data) {
+                                    })
+                                }, function (data) {
+                                })
+
+                            }, function (data) {
+                            })
+                        })
+                    }, function (data) {
+                    })
+                }, function (data) {
+                })
+            })
+        } catch (e) {
+            console.log("testupdateCredential101 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+
+    it('Security_IAM_PIN_Update_Func_0102', 3, async function (done) {
+        console.info('testFace Security_IAM_PIN_Update_Func_0102 start');
+        try {
+            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_NUMBER, Inputerdatanum)
+            publicFC.publicOpenSession(UserIDM, function (data) {
+                let challenge = data;
+                console.info("Security_IAM_PIN_Update_Func_0102 challenge = " + challenge);
+                publicFC.publicaddCredential(UserIDM, CredentialInfopinnum, function (data) {
+                    let addcredresult102 = data.addcredresult;
+                    console.info("Security_IAM_PIN_Update_Func_0102 addcredresult102 = " + addcredresult102);
+                    publicFC.publicauth(UserAuth, challenge, AuthType.PIN, AuthTurstLevel.ATL1, function (data) {
+                        let auth102 = data
+                        console.info("Security_IAM_PIN_Update_Func_0102 auth102 = " + auth102);
+                        let token = auth102.authextr.token
+                        console.info("Security_IAM_PIN_Update_Func_0102 token = " + token);
+                        publicFC.publicunRegisterInputer(PinAuth, async function (data) {
+                            console.info("Security_IAM_PIN_Update_Func_0102 unRegist = " + data);
+                            await setTimeout(
+							publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_MIXED, Inputerdatamix), 500)
+                            console.info("Security_IAM_PIN_Update_Func_0102 challenge = " + challenge);
+                            CredentialInfopinnum.token = token
+                            console.info("PIN_Update_Func_0102 Infopinnum.token = " + CredentialInfopinnum.token);
+                            await publicFC.publicupdateCred(UserIDM, CredentialInfopinnum, function (data) {
+                                let updateresult = data.updateCredresult;
+                                console.info("Security_IAM_PIN_Update_Func_0102 updateresult = " + updateresult);
+                                expect(ResultCode.SUCCESS).assertEqual(updateresult);
+                                publicFC.publicauth(UserAuth, challenge, AuthType.PIN, AuthTurstLevel.ATL1,
+								function (data) {
+                                    auth102 = data
+                                    console.info("Security_IAM_PIN_Update_Func_0102 auth102 = " + auth102);
+                                    let token2 = auth102.authextr.token
+                                    console.info("Security_IAM_PIN_Update_Func_0102 token2 = " + token2);
+                                    let deluserresult = publicFC.publicdelUser(UserIDM, token2, function (data) {
+                                        publicFC.publicCloseSession(UserIDM, function (data) {
+                                            console.info("Security_IAM_PIN_Update_Func_0102 closesession = " + data);
+                                            publicFC.publicunRegisterInputer(PinAuth, function (data) {
+                                                console.info("Security_IAM_PIN_Update_Func_0102 unRegist = " + data);
+                                                done();
+                                            })
+                                        })
+                                    }, function (data) {
+                                    })
+                                }, function (data) {
+                                })
+                            }, function (data) {
+                            })
+                        })
+                    }, function (data) {
+                    })
+
+                }, function (data) {
+                })
+            })
+        } catch (e) {
+            console.log("Security_IAM_PIN_Update_Func_0102 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+
+    it('Security_IAM_PIN_Update_Func_0103', 3, async function (done) {
+        console.info('testFace Security_IAM_PIN_Update_Func_0103 start');
+        try {
+            publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_MIXED, Inputerdatamix)
+            publicFC.publicOpenSession(UserIDM, function (data) {
+                let challenge = data;
+                console.info("Security_IAM_PIN_Update_Func_0103 challenge = " + challenge);
+                publicFC.publicaddCredential(UserIDM, CredentialInfopinnum, function (data) {
+                    let addcredresult103 = data.addcredresult;
+                    console.info("Security_IAM_PIN_Update_Func_0103 addcredresult103 = " + addcredresult103);
+                    publicFC.publicauth(UserAuth, challenge, AuthType.PIN, AuthTurstLevel.ATL1, function (data) {
+                        let auth103 = data
+                        console.info("Security_IAM_PIN_Update_Func_0103 auth103 = " + auth103);
+                        let token = auth103.authextr.token
+                        console.info("Security_IAM_PIN_Update_Func_0103 token = " + token);
+                        publicFC.publicunRegisterInputer(PinAuth, async function (data) {
+                            console.info("Security_IAM_PIN_Update_Func_0103 unRegist = " + data);
+                            await setTimeout(
+							publicFC.publicRegisterInputer(PinAuth, AuthSubType.PIN_SIX, Inputerdata), 500)
+                            console.info("Security_IAM_PIN_Update_Func_0103 challenge = " + challenge);
+                            CredentialInfopinnum.token = token
+                            console.info("PIN_Update_Func_0103 Infopinnum.token = " + CredentialInfopinnum.token);
+                            await publicFC.publicupdateCred(UserIDM, CredentialInfopinnum, function (data) {
+                                let updateresult = data.updateCredresult;
+                                console.info("Security_IAM_PIN_Update_Func_0103 updateresult = " + updateresult);
+                                expect(ResultCode.SUCCESS).assertEqual(updateresult);
+                                publicFC.publicauth(UserAuth, challenge, AuthType.PIN, AuthTurstLevel.ATL1,
+								function (data) {
+                                    auth103 = data
+                                    console.info("Security_IAM_PIN_Update_Func_0103 auth103 = " + auth103);
+                                    let token3 = auth103.authextr.token
+                                    console.info("Security_IAM_PIN_Update_Func_0103 token3 = " + token3);
+                                    publicFC.publicdelUser(UserIDM, token3, function (data) {
+                                        publicFC.publicCloseSession(UserIDM, function (data) {
+                                            console.info("Security_IAM_PIN_Update_Func_0103 closesession = " + data);
+                                            publicFC.publicunRegisterInputer(PinAuth, function (data) {
+                                                console.info("Security_IAM_PIN_Update_Func_0103 unRegist = " + data);
+                                                done();
+                                            })
+                                        })
+                                    }, function (data) {
+                                    })
+                                }, function (data) {
+                                })
+                            }, function (data) {
+                            })
+                        })
+                    }, function (data) {
+                    })
+                }, function (data) {
+                })
+            })
+        } catch (e) {
+            console.log("testupdateCredential103 fail " + e);
+            expect(null).assertFail();
+        }
+    })
+})
+