diff --git a/frameworks/js/ani/dts/cryptoFramework.d.ts b/frameworks/js/ani/dts/cryptoFramework.d.ts
index f5efa385e12de4a4c9ca75fff3da3735572e1e4f..8dfe765c45d34e0ff569012a6a988c56ce5b33af 100644
--- a/frameworks/js/ani/dts/cryptoFramework.d.ts
+++ b/frameworks/js/ani/dts/cryptoFramework.d.ts
@@ -59,7 +59,6 @@ declare namespace cryptoFramework {
     cipherName: string;
   }
 
-
   interface Key {
     getEncoded(): DataBlob;
     readonly format: string;
diff --git a/frameworks/js/ani/inc/ani_common.h b/frameworks/js/ani/inc/ani_common.h
index 09035c4ddd8736ccda8c20d3fe4aef2771f098ff..f9bd6fb0da05aea22f2b6ef0a4e20563d4c0c112 100644
--- a/frameworks/js/ani/inc/ani_common.h
+++ b/frameworks/js/ani/inc/ani_common.h
@@ -51,7 +51,7 @@ constexpr int SPEC_ITEM_TYPE_UINT8ARR = 4;
 
 #define ANI_LOGE_THROW(code, msg) \
     do { \
-        LOGE(msg); \
+        LOGE("%{public}s", msg); \
         set_business_error(ConvertResultCode(code), msg); \
     } while (0)
 
diff --git a/frameworks/js/ani/src/ani_common.cpp b/frameworks/js/ani/src/ani_common.cpp
index a2babd0e1e579f25c0b70d90bea3a494a2d675ff..9d6a8d9f08141b1556e27ddc60e8c1c5a770175c 100644
--- a/frameworks/js/ani/src/ani_common.cpp
+++ b/frameworks/js/ani/src/ani_common.cpp
@@ -121,7 +121,7 @@ void BigIntegerToArrayU8(const HcfBigInteger &bigint, array<uint8_t> &arr)
 void StringToDataBlob(const string &str, HcfBlob &blob)
 {
     blob.data = str.empty() ? nullptr : reinterpret_cast<uint8_t *>(const_cast<char *>(str.c_str()));
-    blob.len = str.size();
+    blob.len = str.size() + 1;
 }
 
 int GetAsyKeySpecType(HcfAsyKeySpecItem item)
diff --git a/frameworks/js/ani/src/ani_signature_utils.cpp b/frameworks/js/ani/src/ani_signature_utils.cpp
index ec7b9370286d496e315059f593d5d41d2b23ee0f..0e99e161f8cdaefbfbb6f98e30340d71e65cdac8 100644
--- a/frameworks/js/ani/src/ani_signature_utils.cpp
+++ b/frameworks/js/ani/src/ani_signature_utils.cpp
@@ -18,11 +18,13 @@
 namespace ANI::CryptoFramework {
 EccSignatureSpec GenEccSignatureSpec(array_view<uint8_t> data)
 {
+    // api 20
     TH_THROW(std::runtime_error, "GenEccSignatureSpec not implemented");
 }
 
 array<uint8_t> GenEccSignature(EccSignatureSpec const& spec)
 {
+    // api 20
     TH_THROW(std::runtime_error, "GenEccSignature not implemented");
 }
 } // namespace ANI::CryptoFramework
diff --git a/frameworks/js/ani/test/test_asy_key_generator.ets b/frameworks/js/ani/test/test_asy_key_generator.ets
index b3066c8fbf4f2382f730f1c5c67d12e581a7384c..77293747d95974f849dac5ccd9d80e88e5cf077c 100644
--- a/frameworks/js/ani/test/test_asy_key_generator.ets
+++ b/frameworks/js/ani/test/test_asy_key_generator.ets
@@ -27,12 +27,12 @@ function testAsyKeyGeneratorSync() {
     let skBlob = priKey.getEncoded();
     let pkStr = utils.uint8ArrayToHexStr(pkBlob.data);
     let skStr = utils.uint8ArrayToHexStr(skBlob.data);
-    console.log("AsyKeyGenerator algName: " + generator.algName);
-    console.log('generateKeyPair pubKey: ' + pkStr);
-    console.log('generateKeyPair priKey: ' + skStr);
+    console.println("AsyKeyGenerator algName: " + generator.algName);
+    console.println('generateKeyPair pubKey: ' + pkStr);
+    console.println('generateKeyPair priKey: ' + skStr);
     priKey.clearMem();
   } catch (err: BusinessError) {
-    console.error(`[error] generateKeyPair: ${err.code} ${err.message}`);
+    console.println(`[error] generateKeyPair: ${err.code} ${err.message}`);
   }
 }
 
@@ -66,12 +66,12 @@ function testAsyKeyConvertKeySync() {
     let skBlob = priKey.getEncoded();
     let pkStr = utils.uint8ArrayToHexStr(pkBlob.data);
     let skStr = utils.uint8ArrayToHexStr(skBlob.data);
-    console.log("AsyKeyGenerator algName: " + generator.algName);
-    console.log('convertKey pubKey: ' + pkStr);
-    console.log('convertKey priKey: ' + skStr);
+    console.println("AsyKeyGenerator algName: " + generator.algName);
+    console.println('convertKey pubKey: ' + pkStr);
+    console.println('convertKey priKey: ' + skStr);
     priKey.clearMem();
   } catch (err: BusinessError) {
-    console.error(`[error] convertKey: ${err.code} ${err.message}`);
+    console.println(`[error] convertKey: ${err.code} ${err.message}`);
   }
 }
 
@@ -105,97 +105,97 @@ function testConvertPemKeySync() {
     let priKey = keyPair.priKey;
     let pkStr = pubKey.getEncodedPem('X509');
     let skStr = priKey.getEncodedPem('PKCS8');
-    console.log("AsyKeyGenerator algName: " + generator.algName);
-    console.log('convertPemKey pubKey: ' + pkStr);
-    console.log('convertPemKey priKey: ' + skStr);
+    console.println("AsyKeyGenerator algName: " + generator.algName);
+    console.println('convertPemKey pubKey: ' + pkStr);
+    console.println('convertPemKey priKey: ' + skStr);
     priKey.clearMem();
   } catch (err: BusinessError) {
-    console.error(`[error] convertPemKey: ${err.code} ${err.message}`);
+    console.println(`[error] convertPemKey: ${err.code} ${err.message}`);
   }
 }
 
 // ERROR: TypeError: Cannot find type 'AsyKeySpecItem'.
 /*
 function showEccSpecDetailInfo(keyName: string, key: cryptoFramework.PubKey | cryptoFramework.PriKey) {
-  console.log('showEccSpecDetailInfo ' + keyName + ':');
+  console.println('showEccSpecDetailInfo ' + keyName + ':');
   let a = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_A_BN);
-  console.log('a: ' + a);
+  console.println('a: ' + a);
   let b = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_B_BN);
-  console.log('b: ' + b);
+  console.println('b: ' + b);
   let gX = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_G_X_BN);
-  console.log('gX: ' + gX);
+  console.println('gX: ' + gX);
   let gY = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_G_Y_BN);
-  console.log('gY: ' + gY);
+  console.println('gY: ' + gY);
   let n = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_N_BN);
-  console.log('n: ' + n);
+  console.println('n: ' + n);
   let h = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_H_NUM);
-  console.log('h: ' + h);
+  console.println('h: ' + h);
   let fieldType = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_FIELD_TYPE_STR);
-  console.log('fieldType: ' + fieldType);
+  console.println('fieldType: ' + fieldType);
   let fieldSize = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_FIELD_SIZE_NUM);
-  console.log('fieldSize: ' + fieldSize);
+  console.println('fieldSize: ' + fieldSize);
   let curveName = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_CURVE_NAME_STR);
-  console.log('curveName: ' + curveName);
+  console.println('curveName: ' + curveName);
   if (keyName === 'pubKey') {
     let pkX = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_PK_X_BN);
-    console.log('pkX: ' + pkX);
+    console.println('pkX: ' + pkX);
     let pkY = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_PK_Y_BN);
-    console.log('pkY: ' + pkY);
+    console.println('pkY: ' + pkY);
   } else if (keyName === 'priKey') {
     let sk = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_SK_BN);
-    console.log('sk: ' + sk);
+    console.println('sk: ' + sk);
   }
 }
 */
 
 function showPubKeyEccSpecDetailInfo(key: cryptoFramework.PubKey) {
-  console.log('showPubKeyEccSpecDetailInfo:');
+  console.println('showPubKeyEccSpecDetailInfo:');
   let a = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_A_BN);
-  console.log('a: ' + a);
+  console.println('a: ' + a);
   let b = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_B_BN);
-  console.log('b: ' + b);
+  console.println('b: ' + b);
   let gX = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_G_X_BN);
-  console.log('gX: ' + gX);
+  console.println('gX: ' + gX);
   let gY = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_G_Y_BN);
-  console.log('gY: ' + gY);
+  console.println('gY: ' + gY);
   let n = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_N_BN);
-  console.log('n: ' + n);
+  console.println('n: ' + n);
   let h = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_H_NUM);
-  console.log('h: ' + h);
+  console.println('h: ' + h);
   let fieldType = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_FIELD_TYPE_STR);
-  console.log('fieldType: ' + fieldType);
+  console.println('fieldType: ' + fieldType);
   let fieldSize = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_FIELD_SIZE_NUM);
-  console.log('fieldSize: ' + fieldSize);
+  console.println('fieldSize: ' + fieldSize);
   let curveName = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_CURVE_NAME_STR);
-  console.log('curveName: ' + curveName);
+  console.println('curveName: ' + curveName);
   let pkX = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_PK_X_BN);
-  console.log('pkX: ' + pkX);
+  console.println('pkX: ' + pkX);
   let pkY = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_PK_Y_BN);
-  console.log('pkY: ' + pkY);
+  console.println('pkY: ' + pkY);
 }
 
 function showPriKeyEccSpecDetailInfo(key: cryptoFramework.PriKey) {
-  console.log('showPriKeyEccSpecDetailInfo:');
+  console.println('showPriKeyEccSpecDetailInfo:');
   let a = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_A_BN);
-  console.log('a: ' + a);
+  console.println('a: ' + a);
   let b = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_B_BN);
-  console.log('b: ' + b);
+  console.println('b: ' + b);
   let gX = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_G_X_BN);
-  console.log('gX: ' + gX);
+  console.println('gX: ' + gX);
   let gY = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_G_Y_BN);
-  console.log('gY: ' + gY);
+  console.println('gY: ' + gY);
   let n = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_N_BN);
-  console.log('n: ' + n);
+  console.println('n: ' + n);
   let h = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_H_NUM);
-  console.log('h: ' + h);
+  console.println('h: ' + h);
   let fieldType = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_FIELD_TYPE_STR);
-  console.log('fieldType: ' + fieldType);
+  console.println('fieldType: ' + fieldType);
   let fieldSize = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_FIELD_SIZE_NUM);
-  console.log('fieldSize: ' + fieldSize);
+  console.println('fieldSize: ' + fieldSize);
   let curveName = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_CURVE_NAME_STR);
-  console.log('curveName: ' + curveName);
+  console.println('curveName: ' + curveName);
   let sk = key.getAsyKeySpec(cryptoFramework.AsyKeySpecItem.ECC_SK_BN);
-  console.log('sk: ' + sk);
+  console.println('sk: ' + sk);
 }
 
 function testAsyKeySpec() {
@@ -225,17 +225,17 @@ function testAsyKeySpec() {
     showPubKeyEccSpecDetailInfo(pubKey);
     showPriKeyEccSpecDetailInfo(priKey);
   } catch (err: BusinessError) {
-    console.error(`[error] AsyKeySpec: ${err.code} ${err.message}`);
+    console.println(`[error] AsyKeySpec: ${err.code} ${err.message}`);
   }
 }
 
 export function testAsyKeyGenerator() {
-  console.log(">>>>>>>>>>>>>>>>>>>> AsyKeyGeneratorSync");
+  console.println(">>>>>>>>>>>>>>>>>>>> AsyKeyGeneratorSync");
   testAsyKeyGeneratorSync();
-  console.log(">>>>>>>>>>>>>>>>>>>> AsyKeyConvertKeySync");
+  console.println(">>>>>>>>>>>>>>>>>>>> AsyKeyConvertKeySync");
   testAsyKeyConvertKeySync();
-  console.log(">>>>>>>>>>>>>>>>>>>> AsyKeyConvertPemKeySync");
+  console.println(">>>>>>>>>>>>>>>>>>>> AsyKeyConvertPemKeySync");
   testConvertPemKeySync();
-  console.log(">>>>>>>>>>>>>>>>>>>> AsyKeySpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> AsyKeySpec");
   testAsyKeySpec();
 }
diff --git a/frameworks/js/ani/test/test_asy_key_generator_by_spec.ets b/frameworks/js/ani/test/test_asy_key_generator_by_spec.ets
index 998e154643ae38a6d5732c364bd10424c6521a74..3ee2996a364375688161d2ee918a87240f87a132 100644
--- a/frameworks/js/ani/test/test_asy_key_generator_by_spec.ets
+++ b/frameworks/js/ani/test/test_asy_key_generator_by_spec.ets
@@ -34,12 +34,12 @@ function testRsaKeyPairSpec() {
     let generatorBySpec = cryptoFramework.createAsyKeyGeneratorBySpec(rsaKeyPairSpec);
     let keyPair = generatorBySpec.generateKeyPairSync();
     if (keyPair !== null) {
-      console.log('get rsa key pair result success!');
+      console.println('get rsa key pair result success!');
     } else {
-      console.error('get rsa key pair result fail!');
+      console.println('get rsa key pair result fail!');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] testRsaKeyPairSpec: ${err.code} ${err.message}`);
+    console.println(`[error] testRsaKeyPairSpec: ${err.code} ${err.message}`);
   }
 }
 
@@ -61,13 +61,13 @@ function testRsaPubKeySpec() {
     let rsaGeneratorSpec = cryptoFramework.createAsyKeyGeneratorBySpec(rsaPubKeySpec);
     let pubKey = rsaGeneratorSpec.generatePubKeySync();
     if (pubKey !== null) {
-      console.log('get rsa pub key result success!');
+      console.println('get rsa pub key result success!');
     } else {
-      console.error('get rsa pub key result fail!');
+      console.println('get rsa pub key result fail!');
     }
 
   } catch (err: BusinessError) {
-    console.error(`[error] testRsaPubKeySpec: ${err.code} ${err.message}`);
+    console.println(`[error] testRsaPubKeySpec: ${err.code} ${err.message}`);
   }
 }
 
@@ -94,12 +94,12 @@ function testEccCommonSpec() {
     let generatorBySpec = cryptoFramework.createAsyKeyGeneratorBySpec(eccCommonSpec);
     let keyPair = generatorBySpec.generateKeyPairSync(); // Generate an ECC key pair.
     if (keyPair !== null) {
-      console.log('get key pair result success!');
+      console.println('get key pair result success!');
     } else {
-      console.error('get key pair result fail!');
+      console.println('get key pair result fail!');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] testEccCommonSpec: ${err.code} ${err.message}`);
+    console.println(`[error] testEccCommonSpec: ${err.code} ${err.message}`);
   }
 }
 
@@ -147,12 +147,12 @@ function testEccPriKeySpec() {
     let generatorBySpec = cryptoFramework.createAsyKeyGeneratorBySpec(eccPriKeySpec);
     let priKey = generatorBySpec.generatePriKeySync();
     if (priKey !== null) {
-      console.log('get pri key result success!');
+      console.println('get pri key result success!');
     } else {
-      console.error('get pri key result fail!');
+      console.println('get pri key result fail!');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] testEccPriKeySpec: ${err.code} ${err.message}`);
+    console.println(`[error] testEccPriKeySpec: ${err.code} ${err.message}`);
   }
 }
 
@@ -189,12 +189,12 @@ function testSm2KeyPairSpec() {
     let generatorBySpec = cryptoFramework.createAsyKeyGeneratorBySpec(sm2KeyPairSpec);
     let keyPair = generatorBySpec.generateKeyPairSync();
     if (keyPair !== null) {
-      console.log('get key pair result success!');
+      console.println('get key pair result success!');
     } else {
-      console.error('get key pair result fail!');
+      console.println('get key pair result fail!');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] testSm2AsyKeyGeneratorBySpecSync: ${err.code} ${err.message}`);
+    console.println(`[error] testSm2AsyKeyGeneratorBySpecSync: ${err.code} ${err.message}`);
   }
 }
 
@@ -222,12 +222,12 @@ function testDsaKeyPairSpec() {
     let asyKeyPairSpec = cryptoFramework.createAsyKeyGeneratorBySpec(dsaKeyPairSpec);
     let keyPair = asyKeyPairSpec.generateKeyPairSync();
     if (keyPair !== null) {
-      console.log('get key pair result success!');
+      console.println('get key pair result success!');
     } else {
-      console.error('get key pair result fail!');
+      console.println('get key pair result fail!');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] getDsaCommonParamsSpec: ${err.code} ${err.message}`);
+    console.println(`[error] getDsaCommonParamsSpec: ${err.code} ${err.message}`);
   }
 }
 
@@ -243,12 +243,12 @@ function testDsaPubKeySpec() {
     let generatorBySpec = cryptoFramework.createAsyKeyGeneratorBySpec(dsaPubKeySpec);
     let pubKey = generatorBySpec.generatePubKeySync();
     if (pubKey !== null) {
-      console.log('get pub key result success!');
+      console.println('get pub key result success!');
     } else {
-      console.error('get pub key result fail!');
+      console.println('get pub key result fail!');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] testDsaPubKeySpec: ${err.code} ${err.message}`);
+    console.println(`[error] testDsaPubKeySpec: ${err.code} ${err.message}`);
   }
 }
 
@@ -264,18 +264,18 @@ function testX25519Keypair() {
     let generatorBySpec = cryptoFramework.createAsyKeyGeneratorBySpec(X25519CommonParamsSpec);
     let keyPair = generatorBySpec.generateKeyPairSync();
     if (keyPair !== null) {
-      console.log('get key pair result success!');
+      console.println('get key pair result success!');
       let pkBlob = keyPair.pubKey.getEncoded();
       let skBlob = keyPair.priKey.getEncoded();
       let pkStr = utils.uint8ArrayToHexStr(pkBlob.data);
       let skStr = utils.uint8ArrayToHexStr(skBlob.data);
-      console.log('pub key: ' + pkStr);
-      console.log('pri key: ' + skStr);
+      console.println('pub key: ' + pkStr);
+      console.println('pri key: ' + skStr);
     } else {
-      console.error('get key pair result fail!');
+      console.println('get key pair result fail!');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] testX25519Keypair: ${err.code} ${err.message}`);
+    console.println(`[error] testX25519Keypair: ${err.code} ${err.message}`);
   }
 }
 
@@ -290,12 +290,12 @@ function testX25519PubKeySpec() {
     let generatorBySpec = cryptoFramework.createAsyKeyGeneratorBySpec(X25519CommonParamsSpec);
     let pubKey = generatorBySpec.generatePubKeySync();
     if (pubKey !== null) {
-      console.log('get pub key result success!');
+      console.println('get pub key result success!');
     } else {
-      console.error('get pub key result fail!');
+      console.println('get pub key result fail!');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] testX25519PubKeySpec: ${err.code} ${err.message}`);
+    console.println(`[error] testX25519PubKeySpec: ${err.code} ${err.message}`);
   }
 }
 
@@ -310,12 +310,12 @@ function testX25519PriKeySpec() {
     let generatorBySpec = cryptoFramework.createAsyKeyGeneratorBySpec(X25519CommonParamsSpec);
     let priKey = generatorBySpec.generatePriKeySync();
     if (priKey !== null) {
-      console.log('get pri key result success!');
+      console.println('get pri key result success!');
     } else {
-      console.error('get pri key result fail!');
+      console.println('get pri key result fail!');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] testX25519PriKeySpec: ${err.code} ${err.message}`);
+    console.println(`[error] testX25519PriKeySpec: ${err.code} ${err.message}`);
   }
 }
 
@@ -331,12 +331,12 @@ function testEd25519Keypair() {
     let generatorBySpec = cryptoFramework.createAsyKeyGeneratorBySpec(ed25519CommonParamsSpec);
     let keyPair = generatorBySpec.generateKeyPairSync();
     if (keyPair !== null) {
-      console.log('get key pair result success!');
+      console.println('get key pair result success!');
     } else {
-      console.error('get key pair result fail!');
+      console.println('get key pair result fail!');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] testEd25519Keypair: ${err.code} ${err.message}`);
+    console.println(`[error] testEd25519Keypair: ${err.code} ${err.message}`);
   }
 }
 
@@ -351,12 +351,12 @@ function testEd25519PubKeySpec() {
     let generatorBySpec = cryptoFramework.createAsyKeyGeneratorBySpec(ed25519CommonParamsSpec);
     let pubKey = generatorBySpec.generatePubKeySync();
     if (pubKey !== null) {
-      console.log('get pub key result success!');
+      console.println('get pub key result success!');
     } else {
-      console.error('get pub key result fail!');
+      console.println('get pub key result fail!');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] testEd25519PubKeySpec: ${err.code} ${err.message}`);
+    console.println(`[error] testEd25519PubKeySpec: ${err.code} ${err.message}`);
   }
 }
 
@@ -371,12 +371,12 @@ function testEd25519PriKeySpec() {
     let generatorBySpec = cryptoFramework.createAsyKeyGeneratorBySpec(ed25519CommonParamsSpec);
     let priKey = generatorBySpec.generatePriKeySync();
     if (priKey !== null) {
-      console.log('get pri key result success!');
+      console.println('get pri key result success!');
     } else {
-      console.error('get pri key result fail!');
+      console.println('get pri key result fail!');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] testEd25519PriKeySpec: ${err.code} ${err.message}`);
+    console.println(`[error] testEd25519PriKeySpec: ${err.code} ${err.message}`);
   }
 }
 
@@ -399,12 +399,12 @@ function testDhKeyPairSpec() {
     let generatorBySpec = cryptoFramework.createAsyKeyGeneratorBySpec(dhKeyPairSpec);
     let keyPair = generatorBySpec.generateKeyPairSync();
     if (keyPair !== null) {
-      console.log('get key pair result success!');
+      console.println('get key pair result success!');
     } else {
-      console.error('get key pair result fail!');
+      console.println('get key pair result fail!');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] testDhKeyPairSpec: ${err.code} ${err.message}`);
+    console.println(`[error] testDhKeyPairSpec: ${err.code} ${err.message}`);
   }
 }
 
@@ -426,12 +426,12 @@ function testDhPubKeySpec() {
     let generatorBySpec = cryptoFramework.createAsyKeyGeneratorBySpec(dhPubKeySpec);
     let pubKey = generatorBySpec.generatePubKeySync();
     if (pubKey !== null) {
-      console.log('get pub key result success!');
+      console.println('get pub key result success!');
     } else {
-      console.error('get pub key result fail!');
+      console.println('get pub key result fail!');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] testDhPubKeySpec: ${err.code} ${err.message}`);
+    console.println(`[error] testDhPubKeySpec: ${err.code} ${err.message}`);
   }
 }
 
@@ -453,46 +453,46 @@ function testDhPriKeySpec() {
     let generatorBySpec = cryptoFramework.createAsyKeyGeneratorBySpec(dhPriKeySpec);
     let priKey = generatorBySpec.generatePriKeySync();
     if (priKey !== null) {
-      console.log('get pri key result success!');
+      console.println('get pri key result success!');
     } else {
-      console.error('get pri key result fail!');
+      console.println('get pri key result fail!');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] testDhPriKeySpec: ${err.code} ${err.message}`);
+    console.println(`[error] testDhPriKeySpec: ${err.code} ${err.message}`);
   }
 }
 
 export function testAsyKeyGeneratorBySpec() {
-  console.log(">>>>>>>>>>>>>>>>>>>> EccCommonSpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> EccCommonSpec");
   testEccCommonSpec();
-  console.log(">>>>>>>>>>>>>>>>>>>> EccPriKeySpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> EccPriKeySpec");
   testEccPriKeySpec();
-  console.log(">>>>>>>>>>>>>>>>>>>> Sm2KeyPairSpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> Sm2KeyPairSpec");
   testSm2KeyPairSpec();
-  console.log(">>>>>>>>>>>>>>>>>>>> DsaKeyPairSpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> DsaKeyPairSpec");
   testDsaKeyPairSpec();
-  console.log(">>>>>>>>>>>>>>>>>>>> DsaPubKeySpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> DsaPubKeySpec");
   testDsaPubKeySpec();
-  console.log(">>>>>>>>>>>>>>>>>>>> RsaKeyPairSpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> RsaKeyPairSpec");
   testRsaKeyPairSpec();
-  console.log(">>>>>>>>>>>>>>>>>>>> RsaPubKeySpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> RsaPubKeySpec");
   testRsaPubKeySpec();
-  console.log(">>>>>>>>>>>>>>>>>>>> X25519Keypair");
+  console.println(">>>>>>>>>>>>>>>>>>>> X25519Keypair");
   testX25519Keypair();
-  console.log(">>>>>>>>>>>>>>>>>>>> X25519PubKeySpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> X25519PubKeySpec");
   testX25519PubKeySpec();
-  console.log(">>>>>>>>>>>>>>>>>>>> X25519PriKeySpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> X25519PriKeySpec");
   testX25519PriKeySpec();
-  console.log(">>>>>>>>>>>>>>>>>>>> Ed25519Keypair");
+  console.println(">>>>>>>>>>>>>>>>>>>> Ed25519Keypair");
   testEd25519Keypair();
-  console.log(">>>>>>>>>>>>>>>>>>>> Ed25519PubKeySpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> Ed25519PubKeySpec");
   testEd25519PubKeySpec();
-  console.log(">>>>>>>>>>>>>>>>>>>> Ed25519PriKeySpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> Ed25519PriKeySpec");
   testEd25519PriKeySpec();
-  console.log(">>>>>>>>>>>>>>>>>>>> DhKeyPairSpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> DhKeyPairSpec");
   testDhKeyPairSpec();
-  console.log(">>>>>>>>>>>>>>>>>>>> DhPubKeySpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> DhPubKeySpec");
   testDhPubKeySpec();
-  console.log(">>>>>>>>>>>>>>>>>>>> DhPriKeySpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> DhPriKeySpec");
   testDhPriKeySpec();
 }
diff --git a/frameworks/js/ani/test/test_cipher.ets b/frameworks/js/ani/test/test_cipher.ets
index 7a8f09cc4e8d53a6ab0b1b49768e2143de11d198..4f8c0f1bc9231baf8462e4ebb5b88f30d1afa744 100644
--- a/frameworks/js/ani/test/test_cipher.ets
+++ b/frameworks/js/ani/test/test_cipher.ets
@@ -36,7 +36,7 @@ function encrypt(algorithm: string, symKey: cryptoFramework.SymKey, data: crypto
   params: cryptoFramework.GcmParamsSpec | cryptoFramework.CcmParamsSpec | cryptoFramework.IvParamsSpec | null
 ): cryptoFramework.DataBlob {
   let cipher = cryptoFramework.createCipher(algorithm);
-  console.log("Cipher algName: " + cipher.algName);
+  console.println("Cipher algName: " + cipher.algName);
   cipher.initSync(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, params);
   if (algorithm.includes('GCM') || algorithm.includes('CCM')) {
     let encryptData = cipher.updateSync(data);
@@ -79,12 +79,12 @@ function aesCipher(algorithm: string,
     let encryptText = encrypt(algorithm, symKey, plainText, params);
     let decryptText = decrypt(algorithm, symKey, encryptText, params);
     if (plainText.data.toString() === decryptText.data.toString()) {
-      console.log(`${algorithm} success`);
+      console.println(`${algorithm} success`);
     } else {
-      console.error(`${algorithm} failed`);
+      console.println(`${algorithm} failed`);
     }
   } catch (err: BusinessError) {
-    console.error(`[error] ${algorithm}: ${err.code} ${err.message}`);
+    console.println(`[error] ${algorithm}: ${err.code} ${err.message}`);
   }
 }
 
@@ -128,23 +128,23 @@ function testCipherSpec() {
     let mgf1Psrc = cipher.getCipherSpec(cryptoFramework.CipherSpecItem.OAEP_MGF1_PSRC_UINT8ARR);
     let mgfName = cipher.getCipherSpec(cryptoFramework.CipherSpecItem.OAEP_MGF_NAME_STR);
     let mdName = cipher.getCipherSpec(cryptoFramework.CipherSpecItem.OAEP_MD_NAME_STR);
-    console.log("CipherSpec Uint8Array: " + mgf1Psrc.toString());
-    console.log("CipherSpec mgfName: " + mgfName);
-    console.log("CipherSpec mdName: " + mdName);
+    console.println("CipherSpec Uint8Array: " + mgf1Psrc.toString());
+    console.println("CipherSpec mgfName: " + mgfName);
+    console.println("CipherSpec mdName: " + mdName);
   } catch (err: BusinessError) {
-    console.error(`[error] CipherSpec: ${err.code} ${err.message}`);
+    console.println(`[error] CipherSpec: ${err.code} ${err.message}`);
   }
 }
 
 export function testCipher() {
-  console.log(">>>>>>>>>>>>>>>>>>>> AesGcmSync");
+  console.println(">>>>>>>>>>>>>>>>>>>> AesGcmSync");
   testAesGcmSync();
-  console.log(">>>>>>>>>>>>>>>>>>>> AesCcmSync");
+  console.println(">>>>>>>>>>>>>>>>>>>> AesCcmSync");
   testAesCcmSync();
-  console.log(">>>>>>>>>>>>>>>>>>>> AesCbcSync");
+  console.println(">>>>>>>>>>>>>>>>>>>> AesCbcSync");
   testAesCbcSync();
-  console.log(">>>>>>>>>>>>>>>>>>>> AesEcbSync");
+  console.println(">>>>>>>>>>>>>>>>>>>> AesEcbSync");
   testAesEcbSync();
-  console.log(">>>>>>>>>>>>>>>>>>>> CipherSpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> CipherSpec");
   testCipherSpec();
 }
diff --git a/frameworks/js/ani/test/test_dh_key_util.ets b/frameworks/js/ani/test/test_dh_key_util.ets
index 43026d120ff4d5411d2a7e5ff8cc50b6607f5a7e..7aaa47c72ba9a332814dcca925fd759b24156549 100644
--- a/frameworks/js/ani/test/test_dh_key_util.ets
+++ b/frameworks/js/ani/test/test_dh_key_util.ets
@@ -20,18 +20,18 @@ import utils from "./test_utils";
 function testGenDHCommonParamsSpec() {
   try {
     let spec = cryptoFramework.DHKeyUtil.genDHCommonParamsSpec(2048, 1024);
-    console.log("DHKeyUtil.genDHCommonParamsSpec:");
-    console.log("DHCommonParamsSpec spec.algName: " + spec.algName);
-    console.log("DHCommonParamsSpec spec.specType: " + spec.specType);
-    console.log("DHCommonParamsSpec spec.p: " + spec.p);
-    console.log("DHCommonParamsSpec spec.g: " + spec.g);
-    console.log("DHCommonParamsSpec spec.l: " + spec.l);
+    console.println("DHKeyUtil.genDHCommonParamsSpec:");
+    console.println("DHCommonParamsSpec spec.algName: " + spec.algName);
+    console.println("DHCommonParamsSpec spec.specType: " + spec.specType);
+    console.println("DHCommonParamsSpec spec.p: " + spec.p);
+    console.println("DHCommonParamsSpec spec.g: " + spec.g);
+    console.println("DHCommonParamsSpec spec.l: " + spec.l);
   } catch (err: BusinessError) {
-    console.error(`[error] DHKeyUtil.genDHCommonParamsSpec: ${err.code} ${err.message}`);
+    console.println(`[error] DHKeyUtil.genDHCommonParamsSpec: ${err.code} ${err.message}`);
   }
 }
 
 export function testDHKeyUtil() {
-  console.log(">>>>>>>>>>>>>>>>>>>> GenDHCommonParamsSpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> GenDHCommonParamsSpec");
   testGenDHCommonParamsSpec();
 }
diff --git a/frameworks/js/ani/test/test_ecc_key_util.ets b/frameworks/js/ani/test/test_ecc_key_util.ets
index 061423a6d37f9f9c578bb6a961f74a682efa9b13..ca3db7a32d35aeba9e9e805402fb57dd68226839 100644
--- a/frameworks/js/ani/test/test_ecc_key_util.ets
+++ b/frameworks/js/ani/test/test_ecc_key_util.ets
@@ -21,19 +21,19 @@ function testGenECCCommonParamsSpec() {
   try {
     let spec = cryptoFramework.ECCKeyUtil.genECCCommonParamsSpec('NID_brainpoolP256r1');
     let ecFiledFp = spec.field as cryptoFramework.ECFieldFp;
-    console.log("ECCKeyUtil.genECCCommonParamsSpec:");
-    console.log("ECCCommonParamsSpec spec.algName: " + spec.algName);
-    console.log("ECCCommonParamsSpec spec.specType: " + spec.specType);
-    console.log("ECCCommonParamsSpec spec.field.fieldType: " + ecFiledFp.fieldType);
-    console.log("ECCCommonParamsSpec spec.field.p: " + ecFiledFp.p);
-    console.log("ECCCommonParamsSpec spec.a: " + spec.a);
-    console.log("ECCCommonParamsSpec spec.b: " + spec.b);
-    console.log("ECCCommonParamsSpec spec.g.x: " + spec.g.x);
-    console.log("ECCCommonParamsSpec spec.g.y: " + spec.g.y);
-    console.log("ECCCommonParamsSpec spec.n: " + spec.n);
-    console.log("ECCCommonParamsSpec spec.h: " + spec.h);
+    console.println("ECCKeyUtil.genECCCommonParamsSpec:");
+    console.println("ECCCommonParamsSpec spec.algName: " + spec.algName);
+    console.println("ECCCommonParamsSpec spec.specType: " + spec.specType);
+    console.println("ECCCommonParamsSpec spec.field.fieldType: " + ecFiledFp.fieldType);
+    console.println("ECCCommonParamsSpec spec.field.p: " + ecFiledFp.p);
+    console.println("ECCCommonParamsSpec spec.a: " + spec.a);
+    console.println("ECCCommonParamsSpec spec.b: " + spec.b);
+    console.println("ECCCommonParamsSpec spec.g.x: " + spec.g.x);
+    console.println("ECCCommonParamsSpec spec.g.y: " + spec.g.y);
+    console.println("ECCCommonParamsSpec spec.n: " + spec.n);
+    console.println("ECCCommonParamsSpec spec.h: " + spec.h);
   } catch (err: BusinessError) {
-    console.error(`[error] ECCKeyUtil.genECCCommonParamsSpec: ${err.code} ${err.message}`);
+    console.println(`[error] ECCKeyUtil.genECCCommonParamsSpec: ${err.code} ${err.message}`);
   }
 }
 
@@ -47,11 +47,11 @@ function testConvertPoint() {
       0x98
     ]);
     let point = cryptoFramework.ECCKeyUtil.convertPoint('NID_brainpoolP256r1', pkData);
-    console.log("ECCKeyUtil.convertPoint:");
-    console.log("Point point.x: " + point.x);
-    console.log("Point point.y: " + point.y);
+    console.println("ECCKeyUtil.convertPoint:");
+    console.println("Point point.x: " + point.x);
+    console.println("Point point.y: " + point.y);
   } catch (err: BusinessError) {
-    console.error(`[error] ECCKeyUtil.convertPoint: ${err.code} ${err.message}`);
+    console.println(`[error] ECCKeyUtil.convertPoint: ${err.code} ${err.message}`);
   }
 }
 
@@ -62,18 +62,18 @@ function testGetEncodedPoint() {
       y: BigInt('37705793773900352766227640862738381713868374157045352837992005507978837073048')
     };
     let encoded = cryptoFramework.ECCKeyUtil.getEncodedPoint('NID_brainpoolP256r1', point, 'COMPRESSED');
-    console.log("ECCKeyUtil.getEncodedPoint:");
-    console.log("Uint8Array encoded: " + encoded);
+    console.println("ECCKeyUtil.getEncodedPoint:");
+    console.println("Uint8Array encoded: " + encoded);
   } catch (err: BusinessError) {
-    console.error(`[error] ECCKeyUtil.getEncodedPoint: ${err.code} ${err.message}`);
+    console.println(`[error] ECCKeyUtil.getEncodedPoint: ${err.code} ${err.message}`);
   }
 }
 
 export function testECCKeyUtil() {
-  console.log(">>>>>>>>>>>>>>>>>>>> GenECCCommonParamsSpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> GenECCCommonParamsSpec");
   testGenECCCommonParamsSpec();
-  console.log(">>>>>>>>>>>>>>>>>>>> ConvertPoint");
+  console.println(">>>>>>>>>>>>>>>>>>>> ConvertPoint");
   testConvertPoint();
-  console.log(">>>>>>>>>>>>>>>>>>>> GetEncodedPoint");
+  console.println(">>>>>>>>>>>>>>>>>>>> GetEncodedPoint");
   testGetEncodedPoint();
 }
diff --git a/frameworks/js/ani/test/test_kdf.ets b/frameworks/js/ani/test/test_kdf.ets
index d7a980d7542cb218ffa21cc12c6ca5c4d415e2f2..14e2c1b494b39fa40636a78e9c14abd531778976 100644
--- a/frameworks/js/ani/test/test_kdf.ets
+++ b/frameworks/js/ani/test/test_kdf.ets
@@ -29,11 +29,11 @@ function testPBKDF2Sync() {
     let kdf = cryptoFramework.createKdf('PBKDF2|SHA256');
     let secret = kdf.generateSecretSync(spec);
     let str = utils.uint8ArrayToHexStr(secret.data);
-    console.log("PBKDF2 algName: " + kdf.algName);
-    console.log("PBKDF2: " + str);
+    console.println("PBKDF2 algName: " + kdf.algName);
+    console.println("PBKDF2: " + str);
   }
   catch (err: BusinessError) {
-    console.error(`[error] PBKDF2: ${err.code} ${err.message}`);
+    console.println(`[error] PBKDF2: ${err.code} ${err.message}`);
   }
 }
 
@@ -49,10 +49,10 @@ function testHKDFSync() {
     let kdf = cryptoFramework.createKdf('HKDF|SHA256|EXTRACT_AND_EXPAND');
     let secret = kdf.generateSecretSync(spec);
     let str = utils.uint8ArrayToHexStr(secret.data);
-    console.log("HKDF algName: " + kdf.algName);
-    console.log("HKDF: " + str);
+    console.println("HKDF algName: " + kdf.algName);
+    console.println("HKDF: " + str);
   } catch (err: BusinessError) {
-    console.error(`[error] HKDF: ${err.code} ${err.message}`);
+    console.println(`[error] HKDF: ${err.code} ${err.message}`);
   }
 }
 
@@ -71,18 +71,18 @@ function testScryptSync() {
     let kdf = cryptoFramework.createKdf('SCRYPT');
     let secret = kdf.generateSecretSync(spec);
     let str = utils.uint8ArrayToHexStr(secret.data);
-    console.log("Scrypt algName: " + kdf.algName);
-    console.log("Scrypt: " + str);
+    console.println("Scrypt algName: " + kdf.algName);
+    console.println("Scrypt: " + str);
   } catch (err: BusinessError) {
-    console.error(`[error] Scrypt: ${err.code} ${err.message}`);
+    console.println(`[error] Scrypt: ${err.code} ${err.message}`);
   }
 }
 
 export function testKdf() {
-  console.log(">>>>>>>>>>>>>>>>>>>> PBKDF2Sync");
+  console.println(">>>>>>>>>>>>>>>>>>>> PBKDF2Sync");
   testPBKDF2Sync();
-  console.log(">>>>>>>>>>>>>>>>>>>> HKDFSync");
+  console.println(">>>>>>>>>>>>>>>>>>>> HKDFSync");
   testHKDFSync();
-  console.log(">>>>>>>>>>>>>>>>>>>> ScryptSync");
+  console.println(">>>>>>>>>>>>>>>>>>>> ScryptSync");
   testScryptSync();
 }
diff --git a/frameworks/js/ani/test/test_key_agreement.ets b/frameworks/js/ani/test/test_key_agreement.ets
index 3cbfa2198b1eb3d092a37bdcfb8435f50589d38f..7291fc3d029d8f97ab0521dd69ac528928d99533 100644
--- a/frameworks/js/ani/test/test_key_agreement.ets
+++ b/frameworks/js/ani/test/test_key_agreement.ets
@@ -38,22 +38,22 @@ function testKeyAgreementSync()
     let keyPairA = generator.convertKeySync({ data: pubKeyArray }, { data: priKeyArray });
     let keyPairB = generator.generateKeyPairSync();
     let keyAgreement = cryptoFramework.createKeyAgreement('ECC256');
-    console.log("KeyAgreement algName: " + keyAgreement.algName);
+    console.println("KeyAgreement algName: " + keyAgreement.algName);
     let secret1 = keyAgreement.generateSecretSync(keyPairA.priKey, keyPairB.pubKey);
     let secret2 = keyAgreement.generateSecretSync(keyPairB.priKey, keyPairA.pubKey);
     if (secret1.data.toString() === secret2.data.toString()) {
-      console.log('KeyAgreement ecdh result success');
-      console.log('KeyAgreement ecdh secret.data: ' + utils.uint8ArrayToHexStr(secret1.data));
+      console.println('KeyAgreement ecdh result success');
+      console.println('KeyAgreement ecdh secret.data: ' + utils.uint8ArrayToHexStr(secret1.data));
     } else {
-      console.error('KeyAgreement ecdh result failed');
+      console.println('KeyAgreement ecdh result failed');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] KeyAgreement: ${err.code} ${err.message}`);
+    console.println(`[error] KeyAgreement: ${err.code} ${err.message}`);
   }
 }
 
 export function testKeyAgreement()
 {
-  console.log(">>>>>>>>>>>>>>>>>>>> KeyAgreementSync");
+  console.println(">>>>>>>>>>>>>>>>>>>> KeyAgreementSync");
   testKeyAgreementSync();
 }
diff --git a/frameworks/js/ani/test/test_mac.ets b/frameworks/js/ani/test/test_mac.ets
index c042492c5eb951f238dfa54235348493219ade0c..7932c2c222b8bea4d5cc92427f5c4fb283acb565 100644
--- a/frameworks/js/ani/test/test_mac.ets
+++ b/frameworks/js/ani/test/test_mac.ets
@@ -38,11 +38,11 @@ function testMacSync() {
     });
     let output = mac.doFinalSync();
     let str = utils.uint8ArrayToHexStr(output.data);
-    console.log("CMAC algName: " + mac.algName);
-    console.log("CMAC-AES128: " + str);
+    console.println("CMAC algName: " + mac.algName);
+    console.println("CMAC-AES128: " + str);
   }
   catch (err: BusinessError) {
-    console.error(`[error] CMAC-AES128: ${err.code} ${err.message}`);
+    console.println(`[error] CMAC-AES128: ${err.code} ${err.message}`);
   }
 }
 
@@ -63,17 +63,17 @@ function testMacAsync() {
     });
     let output = await mac.doFinal();
     let str = utils.uint8ArrayToHexStr(output.data);
-    console.log("HMAC algName: " + mac.algName);
-    console.log("HMAC-SHA256: " + str);
+    console.println("HMAC algName: " + mac.algName);
+    console.println("HMAC-SHA256: " + str);
   }
   catch (err: BusinessError) {
-    console.error(`[error] HMAC-SHA256: ${err.code} ${err.message}`);
+    console.println(`[error] HMAC-SHA256: ${err.code} ${err.message}`);
   }
 }
 
 export function testMac() {
-  console.log(">>>>>>>>>>>>>>>>>>>> MacSync");
+  console.println(">>>>>>>>>>>>>>>>>>>> MacSync");
   testMacSync();
-  console.log(">>>>>>>>>>>>>>>>>>>> MacAsync");
+  console.println(">>>>>>>>>>>>>>>>>>>> MacAsync");
   testMacAsync();
 }
diff --git a/frameworks/js/ani/test/test_md.ets b/frameworks/js/ani/test/test_md.ets
index 614a5bbc605b2f9e298d65ec4a6dea6177ef4bfa..1e2e80271cf23c9217d0d49a5b8dcac4fb545951 100644
--- a/frameworks/js/ani/test/test_md.ets
+++ b/frameworks/js/ani/test/test_md.ets
@@ -27,12 +27,12 @@ function testMdSync() {
     });
     let output = md.digestSync();
     let str = utils.uint8ArrayToHexStr(output.data);
-    console.log("MD5 algName: " + md.algName);
-    console.log("MD5: " + str);
+    console.println("MD5 algName: " + md.algName);
+    console.println("MD5: " + str);
     let length = md.getMdLength();
-    console.log("MD5 length: " + length);
+    console.println("MD5 length: " + length);
   } catch (err: BusinessError) {
-    console.log(`[error] MD5: ${err.code} ${err.message}`);
+    console.println(`[error] MD5: ${err.code} ${err.message}`);
   }
 }
 
@@ -46,17 +46,17 @@ function testMdAsync() {
     });
     let output = await md.digest();
     let str = utils.uint8ArrayToHexStr(output.data);
-    console.log("MD5: " + str);
+    console.println("MD5: " + str);
     let length = md.getMdLength();
-    console.log("MD5 length: " + length);
+    console.println("MD5 length: " + length);
   } catch (err: BusinessError) {
-    console.log(`[error] MD5: ${err.code} ${err.message}`);
+    console.println(`[error] MD5: ${err.code} ${err.message}`);
   }
 }
 
 export function testMd() {
-  console.log(">>>>>>>>>>>>>>>>>>>> MdSync");
+  console.println(">>>>>>>>>>>>>>>>>>>> MdSync");
   testMdSync();
-  console.log(">>>>>>>>>>>>>>>>>>>> MdAsync");
+  console.println(">>>>>>>>>>>>>>>>>>>> MdAsync");
   testMdAsync();
 }
diff --git a/frameworks/js/ani/test/test_rand.ets b/frameworks/js/ani/test/test_rand.ets
index 94d72fa895cfefb9551edc40cbde3f38b0a38631..e39a0f9b1a9a9e0c0687085b2d6edb88599a0578 100644
--- a/frameworks/js/ani/test/test_rand.ets
+++ b/frameworks/js/ani/test/test_rand.ets
@@ -28,10 +28,10 @@ function testRandomSync() {
     });
     let output = random.generateRandomSync(16);
     let str = utils.uint8ArrayToHexStr(output.data);
-    console.log("Random algName: " + random.algName);
-    console.log("Random: " + str);
+    console.println("Random algName: " + random.algName);
+    console.println("Random: " + str);
   } catch (err: BusinessError) {
-    console.error(`[error] Random: ${err.code} ${err.message}`);
+    console.println(`[error] Random: ${err.code} ${err.message}`);
   }
 }
 
@@ -45,42 +45,16 @@ function testRandomAsync() {
     });
     let output = await random.generateRandom(16);
     let str = utils.uint8ArrayToHexStr(output.data);
-    console.log("Random algName: " + random.algName);
-    console.log("Random: " + str);
+    console.println("Random algName: " + random.algName);
+    console.println("Random: " + str);
   } catch (err: BusinessError) {
-    console.error(`[error] Random: ${err.code} ${err.message}`);
-  }
-}
-
-function testRandomCallback() {
-  try {
-    let data = "Hello World";
-    let dataBytes = utils.stringToUint8Array(data);
-    let random = cryptoFramework.createRandom();
-    random.setSeed({
-      data: dataBytes
-    });
-    random.generateRandom(16, (err, dataBlob) => {
-      console.log(`Random: ${err}`);
-      console.log(`Random: ${err.code} ${err.message}`);
-      if (err) {
-        console.error(`[error] Random: ${err.code} ${err.message}`);
-      } else {
-        let str = utils.uint8ArrayToHexStr(dataBlob.data);
-        console.log("Random algName: " + random.algName);
-        console.log("Random: " + str);
-      }
-    });
-  } catch (err: BusinessError) {
-    console.error(`[error] Random: ${err.code} ${err.message}`);
+    console.println(`[error] Random: ${err.code} ${err.message}`);
   }
 }
 
 export function testRandom() {
-  console.log(">>>>>>>>>>>>>>>>>>>> RandomSync");
+  console.println(">>>>>>>>>>>>>>>>>>>> RandomSync");
   testRandomSync();
-  console.log(">>>>>>>>>>>>>>>>>>>> RandomAsync");
+  console.println(">>>>>>>>>>>>>>>>>>>> RandomAsync");
   testRandomAsync();
-  console.log(">>>>>>>>>>>>>>>>>>>> RandomCallback");
-  testRandomCallback();
 }
diff --git a/frameworks/js/ani/test/test_sign.ets b/frameworks/js/ani/test/test_sign.ets
index 851a90985ede7bb4c68936e529c26c799bc091b7..24ec27e20a2b968eb9e2d0fab133c47ee75bd3c2 100644
--- a/frameworks/js/ani/test/test_sign.ets
+++ b/frameworks/js/ani/test/test_sign.ets
@@ -23,7 +23,7 @@ function sign(algName: string, priKey: cryptoFramework.PriKey,
   signer.initSync(priKey);
   signer.updateSync(input1);
   let signData = signer.signSync(input2);
-  console.log("sign algName: " + signer.algName);
+  console.println("sign algName: " + signer.algName);
   return signData;
 }
 
@@ -33,7 +33,7 @@ function verify(algName: string, pubKey: cryptoFramework.PubKey, signData: crypt
   verifier.initSync(pubKey);
   verifier.updateSync(input1);
   let res = verifier.verifySync(input2, signData);
-  console.log("verify algName: " + verifier.algName);
+  console.println("verify algName: " + verifier.algName);
   return res;
 }
 
@@ -49,17 +49,17 @@ function testSignSync() {
       data: utils.stringToUint8Array(str2)
     };
     let generator = cryptoFramework.createAsyKeyGenerator("SM2_256");
-    console.log("AsyKeyGenerator algName: " + generator.algName);
+    console.println("AsyKeyGenerator algName: " + generator.algName);
     let keyPair = generator.generateKeyPairSync();
     let signData = sign(algName, keyPair.priKey, input1, input2);
     let res = verify(algName, keyPair.pubKey, signData, input1, input2);
     if (res === true) {
-      console.log('Sign success');
+      console.println('Sign success');
     } else {
-      console.error('Sign failed');
+      console.println('Sign failed');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] Sign: ${err.code} ${err.message}`);
+    console.println(`[error] Sign: ${err.code} ${err.message}`);
   }
 }
 
@@ -70,17 +70,17 @@ function testSignSpec() {
     let saltLen = signer.getSignSpec(cryptoFramework.SignSpecItem.PSS_SALT_LEN_NUM);
     let mdName = signer.getSignSpec(cryptoFramework.SignSpecItem.PSS_MD_NAME_STR);
     let mgfName = signer.getSignSpec(cryptoFramework.SignSpecItem.PSS_MGF_NAME_STR);
-    console.log("SignSpec saltLen: " + saltLen);
-    console.log("SignSpec mdName: " + mdName);
-    console.log("SignSpec mgfName: " + mgfName);
+    console.println("SignSpec saltLen: " + saltLen);
+    console.println("SignSpec mdName: " + mdName);
+    console.println("SignSpec mgfName: " + mgfName);
   } catch (err: BusinessError) {
-    console.error(`[error] SignSpec: ${err.code} ${err.message}`);
+    console.println(`[error] SignSpec: ${err.code} ${err.message}`);
   }
 }
 
 export function testSign() {
-  console.log(">>>>>>>>>>>>>>>>>>>> SignSync");
+  console.println(">>>>>>>>>>>>>>>>>>>> SignSync");
   testSignSync();
-  console.log(">>>>>>>>>>>>>>>>>>>> SignSpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> SignSpec");
   testSignSpec();
 }
diff --git a/frameworks/js/ani/test/test_sm2_crypto_util.ets b/frameworks/js/ani/test/test_sm2_crypto_util.ets
index 4e3b4e107f12983aeda5b4fdc34c5ee9bc627a04..1bee988c6dcc469d405a3860a40e04378e781fb5 100644
--- a/frameworks/js/ani/test/test_sm2_crypto_util.ets
+++ b/frameworks/js/ani/test/test_sm2_crypto_util.ets
@@ -31,11 +31,11 @@ function testGenCipherTextBySpec() {
       ])
     }
     let cipherText = cryptoFramework.SM2CryptoUtil.genCipherTextBySpec(spec, 'C1C3C2');
-    console.log("SM2CryptoUtil.genCipherTextBySpec:");
-    console.log("CipherText cipherText.data: " + cipherText.data);
+    console.println("SM2CryptoUtil.genCipherTextBySpec:");
+    console.println("CipherText cipherText.data: " + cipherText.data);
   }
   catch (err: BusinessError) {
-    console.error(`[error] SM2CryptoUtil.genCipherTextBySpec: ${err.code} ${err.message}`);
+    console.println(`[error] SM2CryptoUtil.genCipherTextBySpec: ${err.code} ${err.message}`);
   }
 }
 
@@ -55,20 +55,20 @@ function testGetCipherTextSpec() {
       data: cipherTextArray
     };
     let spec: cryptoFramework.SM2CipherTextSpec = cryptoFramework.SM2CryptoUtil.getCipherTextSpec(cipherText, 'C1C3C2');
-    console.log("SM2CryptoUtil.getCipherTextSpec:");
-    console.log("SM2CipherTextSpec spec.xCoordinate: " + spec.xCoordinate);
-    console.log("SM2CipherTextSpec spec.yCoordinate: " + spec.yCoordinate);
-    console.log("SM2CipherTextSpec spec.cipherTextData: " + utils.uint8ArrayToHexStr(spec.cipherTextData));
-    console.log("SM2CipherTextSpec spec.hashData: " + utils.uint8ArrayToHexStr(spec.hashData));
+    console.println("SM2CryptoUtil.getCipherTextSpec:");
+    console.println("SM2CipherTextSpec spec.xCoordinate: " + spec.xCoordinate);
+    console.println("SM2CipherTextSpec spec.yCoordinate: " + spec.yCoordinate);
+    console.println("SM2CipherTextSpec spec.cipherTextData: " + utils.uint8ArrayToHexStr(spec.cipherTextData));
+    console.println("SM2CipherTextSpec spec.hashData: " + utils.uint8ArrayToHexStr(spec.hashData));
   }
   catch (err: BusinessError) {
-    console.error(`[error] SM2CryptoUtil.getCipherTextSpec: ${err.code} ${err.message}`);
+    console.println(`[error] SM2CryptoUtil.getCipherTextSpec: ${err.code} ${err.message}`);
   }
 }
 
 export function testSM2CryptoUtil() {
-  console.log(">>>>>>>>>>>>>>>>>>>> GenCipherTextBySpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> GenCipherTextBySpec");
   testGenCipherTextBySpec();
-  console.log(">>>>>>>>>>>>>>>>>>>> GetCipherTextSpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> GetCipherTextSpec");
   testGetCipherTextSpec();
 }
diff --git a/frameworks/js/ani/test/test_sym_key_generator.ets b/frameworks/js/ani/test/test_sym_key_generator.ets
index 88c10b8486e7c49bc8aad618fdde63254883413a..68f971509a8d1d3055029d25b96ee0fe92a8b82e 100644
--- a/frameworks/js/ani/test/test_sym_key_generator.ets
+++ b/frameworks/js/ani/test/test_sym_key_generator.ets
@@ -23,13 +23,13 @@ function testSymKeyGeneratorSync() {
     let symKey = generator.generateSymKeySync();
     let encodedKey = symKey.getEncoded();
     let str = utils.uint8ArrayToHexStr(encodedKey.data);
-    console.log("SymKeyGenerator algName: " + generator.algName);
-    console.log("SymKeyGenerator symKey.algName: " + symKey.algName);
-    console.log("SymKeyGenerator symKey.format: " + symKey.format);
-    console.log("generateSymKey: " + str);
+    console.println("SymKeyGenerator algName: " + generator.algName);
+    console.println("SymKeyGenerator symKey.algName: " + symKey.algName);
+    console.println("SymKeyGenerator symKey.format: " + symKey.format);
+    console.println("generateSymKey: " + str);
     symKey.clearMem();
   } catch (err: BusinessError) {
-    console.error(`[error] generateSymKey: ${err.code} ${err.message}`);
+    console.println(`[error] generateSymKey: ${err.code} ${err.message}`);
   }
 }
 
@@ -42,19 +42,19 @@ function testSymKeyConvertKeySync() {
     let symKey = generator.convertKeySync(keyBlob);
     let encodedKey = symKey.getEncoded();
     let str = utils.uint8ArrayToHexStr(encodedKey.data);
-    console.log("SymKeyGenerator algName: " + generator.algName);
-    console.log("SymKeyGenerator symKey.algName: " + symKey.algName);
-    console.log("SymKeyGenerator symKey.format: " + symKey.format);
-    console.log("convertKey: " + str);
+    console.println("SymKeyGenerator algName: " + generator.algName);
+    console.println("SymKeyGenerator symKey.algName: " + symKey.algName);
+    console.println("SymKeyGenerator symKey.format: " + symKey.format);
+    console.println("convertKey: " + str);
     symKey.clearMem();
   } catch (err: BusinessError) {
-    console.error(`[error] convertKey: ${err.code} ${err.message}`);
+    console.println(`[error] convertKey: ${err.code} ${err.message}`);
   }
 }
 
 export function testSymKeyGenerator() {
-  console.log(">>>>>>>>>>>>>>>>>>>> SymKeyGeneratorSync");
+  console.println(">>>>>>>>>>>>>>>>>>>> SymKeyGeneratorSync");
   testSymKeyGeneratorSync();
-  console.log(">>>>>>>>>>>>>>>>>>>> SymKeyConvertKeySync");
+  console.println(">>>>>>>>>>>>>>>>>>>> SymKeyConvertKeySync");
   testSymKeyConvertKeySync();
 }
diff --git a/frameworks/js/ani/test/test_utils.ets b/frameworks/js/ani/test/test_utils.ets
index 9d8fa4627da6fe26a4c0981713211d6e922f2e80..45337a803b12cb0f45c4ce456c5bdb28e6a40c1f 100644
--- a/frameworks/js/ani/test/test_utils.ets
+++ b/frameworks/js/ani/test/test_utils.ets
@@ -57,11 +57,7 @@ export function uint8ArrayToString(data: Uint8Array): string {
 }
 
 export function doFullGC(): void {
-  try {
-      GC.waitForFinishGC(GC.startGC(GC.Cause.FULL, GC.IN_PLACE_MODE));
-  } catch (err) {
-      assertTrue(false, "Unexpected exception during GC");
-  }
+  GC.waitForFinishGC(GC.startGC(GC.Cause.FULL, GC.IN_PLACE_MODE));
   Coroutine.Schedule();
 }
 
diff --git a/frameworks/js/ani/test/test_verify.ets b/frameworks/js/ani/test/test_verify.ets
index 1111e5e37c32d232417d83f78530ddd239e93898..923949e97881f0d3804d153b5c358a6e48fe4f15 100644
--- a/frameworks/js/ani/test/test_verify.ets
+++ b/frameworks/js/ani/test/test_verify.ets
@@ -62,14 +62,14 @@ function testVerifySync() {
     verify.initSync(keyPair.pubKey);
     verify.updateSync(inputData);
     let res = verify.verifySync(null, signDataBytes);
-    console.log("Verify algName: " + verify.algName);
+    console.println("Verify algName: " + verify.algName);
     if (res === true) {
-        console.log('Verify success');
+        console.println('Verify success');
     } else {
-      console.error('Verify failed');
+      console.println('Verify failed');
     }
   } catch (err: BusinessError) {
-    console.error(`[error] Verify: ${err.code} ${err.message}`);
+    console.println(`[error] Verify: ${err.code} ${err.message}`);
   }
 }
 
@@ -89,12 +89,12 @@ function testRecoverSync() {
     verifier.initSync(keyPair.pubKey);
     let rawSignData = verifier.recoverSync(signData);
     if (rawSignData !== null) {
-      console.log("Recover rawSignData: " + utils.uint8ArrayToHexStr(rawSignData.data));
+      console.println("Recover rawSignData: " + utils.uint8ArrayToHexStr(rawSignData.data));
     } else {
-      console.error("Recover failed");
+      console.println("Recover failed");
     }
   } catch (err: BusinessError) {
-    console.error(`[error] Recover: ${err.code} ${err.message}`);
+    console.println(`[error] Recover: ${err.code} ${err.message}`);
   }
 }
 
@@ -105,19 +105,19 @@ function testVerifySpec() {
     let saltLen = verifyer.getVerifySpec(cryptoFramework.SignSpecItem.PSS_SALT_LEN_NUM);
     let mdName = verifyer.getVerifySpec(cryptoFramework.SignSpecItem.PSS_MD_NAME_STR);
     let mgfName = verifyer.getVerifySpec(cryptoFramework.SignSpecItem.PSS_MGF_NAME_STR);
-    console.log("VerifySpec saltLen: " + saltLen);
-    console.log("VerifySpec mdName: " + mdName);
-    console.log("VerifySpec mgfName: " + mgfName);
+    console.println("VerifySpec saltLen: " + saltLen);
+    console.println("VerifySpec mdName: " + mdName);
+    console.println("VerifySpec mgfName: " + mgfName);
   } catch (err: BusinessError) {
-    console.error(`[error] VerifySpec: ${err.code} ${err.message}`);
+    console.println(`[error] VerifySpec: ${err.code} ${err.message}`);
   }
 }
 
 export function testVerify() {
-  console.log(">>>>>>>>>>>>>>>>>>>> VerifySync");
+  console.println(">>>>>>>>>>>>>>>>>>>> VerifySync");
   testVerifySync();
-  console.log(">>>>>>>>>>>>>>>>>>>> RecoverSync");
+  console.println(">>>>>>>>>>>>>>>>>>>> RecoverSync");
   testRecoverSync();
-  console.log(">>>>>>>>>>>>>>>>>>>> VerifySpec");
+  console.println(">>>>>>>>>>>>>>>>>>>> VerifySpec");
   testVerifySpec();
 }