diff --git a/scripts/common.sh b/scripts/common.sh
index 754517f31..d67389d56 100755
--- a/scripts/common.sh
+++ b/scripts/common.sh
@@ -148,7 +148,7 @@ if ${require_docker}; then
 fi
 
 OPENIM_GIT_BRANCH=$(git symbolic-ref --short -q HEAD 2>/dev/null || true)
-OPENIM_ROOT_HASH=$(openim::build::short_hash "${HOSTNAME:-}:"${OPENIM_ROOT}":${OPENIM_GIT_BRANCH}")
+OPENIM_ROOT_HASH=$(openim::build::short_hash "${HOSTNAME:-}:${OPENIM_ROOT}:${OPENIM_GIT_BRANCH}")
 OPENIM_BUILD_IMAGE_TAG_BASE="build-${OPENIM_ROOT_HASH}"
 #OPENIM_BUILD_IMAGE_TAG="${OPENIM_BUILD_IMAGE_TAG_BASE}-${OPENIM_BUILD_IMAGE_VERSION}"
 #OPENIM_BUILD_IMAGE="${OPENIM_BUILD_IMAGE_REPO}:${OPENIM_BUILD_IMAGE_TAG}"
diff --git a/scripts/ensure-tag.sh b/scripts/ensure-tag.sh
index 2847342f4..5fedf7019 100755
--- a/scripts/ensure-tag.sh
+++ b/scripts/ensure-tag.sh
@@ -18,9 +18,9 @@ OPENIM_ROOT=$(dirname "${BASH_SOURCE[0]}")/..
 
 version="${VERSION}"
 if [ "${version}" == "" ];then
-  version=v`${OPENIM_ROOT}/_output/tools/gsemver bump`
+  version=v$(${OPENIM_ROOT}/_output/tools/gsemver bump)
 fi
 
-if [ -z "`git tag -l ${version}`" ];then
+if [ -z "$(git tag -l ${version})" ];then
   git tag -a -m "release version ${version}" ${version}
 fi
diff --git a/scripts/gen-swagger-docs.sh b/scripts/gen-swagger-docs.sh
index ccf5eaeaa..68410e79c 100755
--- a/scripts/gen-swagger-docs.sh
+++ b/scripts/gen-swagger-docs.sh
@@ -67,7 +67,7 @@ echo -e "=== any\nRepresents an untyped JSON map - see the description of the fi
 asciidoctor definitions.adoc
 asciidoctor paths.adoc
 
-cp ${OPENIM_OUTPUT_TMP}/definitions.html ${OPENIM_OUTPUT_TMP}/_output/
-cp ${OPENIM_OUTPUT_TMP}/paths.html ${OPENIM_OUTPUT_TMP}/_output/operations.html
+cp "$OPENIM_OUTPUT_TMP/definitions.html" "$OPENIM_OUTPUT_TMP/_output/"
+cp "$OPENIM_OUTPUT_TMP/paths.html" "$OPENIM_OUTPUT_TMP/_output/operations.html"
 
 success "SUCCESS"
\ No newline at end of file
diff --git a/scripts/genconfig.sh b/scripts/genconfig.sh
index dcca1ff25..498b0b908 100755
--- a/scripts/genconfig.sh
+++ b/scripts/genconfig.sh
@@ -47,7 +47,7 @@ do
 done
 
 if [ "${missing}" ];then
-  openim::log::error 'You may run `source scripts/environment.sh` to set these environment'
+  openim::log::error "You may run 'source scripts/environment.sh' to set these environment"
   exit 1
 fi
 
diff --git a/scripts/githooks/pre-push.sh b/scripts/githooks/pre-push.sh
index 8a5b0a869..9bd938915 100644
--- a/scripts/githooks/pre-push.sh
+++ b/scripts/githooks/pre-push.sh
@@ -38,7 +38,7 @@ printError() {
 
 printMessage "Running local OpenIM pre-push hook."
 
-if [[ `git status --porcelain` ]]; then
+if [[ $(git status --porcelain) ]]; then
   printError "This scripts needs to run against committed code only. Please commit or stash you changes."
   exit 1
 fi
diff --git a/scripts/init-githooks.sh b/scripts/init-githooks.sh
index 7c3b3001b..4ee470742 100755
--- a/scripts/init-githooks.sh
+++ b/scripts/init-githooks.sh
@@ -50,7 +50,7 @@ help_info() {
 }
 
 delete_hooks() {
-  for file in ${OPENIM_ROOT}/scripts/githooks/*.sh; do
+  for file in "${OPENIM_ROOT}"/scripts/githooks/*.sh; do
     hook_name=$(basename "$file" .sh)  # This removes the .sh extension
     rm -f "$HOOKS_DIR/$hook_name"
   done
diff --git a/scripts/install/test.sh b/scripts/install/test.sh
index 77b0d55d5..4a78e4504 100755
--- a/scripts/install/test.sh
+++ b/scripts/install/test.sh
@@ -40,78 +40,80 @@ IAM_ROOT=$(dirname "${BASH_SOURCE[0]}")/../..
 # API Server API Address:Port
 INSECURE_OPENIMAPI="http://${OPENIM_API_HOST}:${API_OPENIM_PORT}"
 INSECURE_OPENIMAUTO=${OPENIM_RPC_AUTH_HOST}:${OPENIM_AUTH_PORT}
-CCURL="curl -f -s -XPOST" # Create
-UCURL="curl -f -s -XPUT" # Update
-RCURL="curl -f -s -XGET" # Retrieve
+CCURL="curl -f -s -XPOST"   # Create
+UCURL="curl -f -s -XPUT"    # Update
+RCURL="curl -f -s -XGET"    # Retrieve
 DCURL="curl -f -s -XDELETE" # Delete
 
 openim::test::check_error() {
-  local response=$1
-  local err_code=$(echo "$response" | jq '.errCode')
-  openim::log::status "Response from user registration: $response"
-  if [[ "$err_code" != "0" ]]; then
-    openim::log::error_exit "Error occurred: $response, You can read the error code in the API documentation https://docs.openim.io/restapi/errcode"
-  else
-    openim::log::success "Operation was successful."
-  fi
+	local response=$1
+	local err_code=$(echo "$response" | jq '.errCode')
+	openim::log::status "Response from user registration: $response"
+	if [[ "$err_code" != "0" ]]; then
+		openim::log::error_exit "Error occurred: $response, You can read the error code in the API documentation https://docs.openim.io/restapi/errcode"
+	else
+		openim::log::success "Operation was successful."
+	fi
 }
 
 # The `openim::test::auth` function serves as a test suite for authentication-related operations.
 function openim::test::auth() {
-  # 1. Retrieve and set the authentication token.
-  openim::test::get_token
-  
-  # 2. Force logout the test user from a specific platform.
-  openim::test::force_logout
-  
-  # Log the completion of the auth test suite.
-  openim::log::success "Auth test suite completed successfully."
+	# 1. Retrieve and set the authentication token.
+	openim::test::get_token
+
+	# 2. Force logout the test user from a specific platform.
+	openim::test::force_logout
+
+	# Log the completion of the auth test suite.
+	openim::log::success "Auth test suite completed successfully."
 }
 
 #################################### Auth Module ####################################
 
 # Define a function to get a token for a specific user
 openim::test::get_token() {
-  local user_id="${1:-openIM123456}" # Default user ID if not provided
-  token_response=$(${CCURL} "${OperationID}" "${Header}" ${INSECURE_OPENIMAPI}/auth/user_token \
-  -d'{"secret": "'"$SECRET"'","platformID": 1,"userID": "'$user_id'"}')
-  token=$(echo $token_response | grep -Po 'token[" :]+\K[^"]+')
-  echo "$token"
+	local user_id="${1:-openIM123456}" # Default user ID if not provided
+	token_response=$(
+		${CCURL} "${OperationID}" "${Header}" ${INSECURE_OPENIMAPI}/auth/user_token \
+		-d'{"secret": "'"$SECRET"'","platformID": 1,"userID": "'$user_id'"}'
+	)
+	token=$(echo $token_response | grep -Po 'token[" :]+\K[^"]+')
+	echo "$token"
 }
 
-
 Header="-HContent-Type: application/json"
 OperationID="-HoperationID: 1646445464564"
 Token="-Htoken: $(openim::test::get_token)"
 
 # Forces a user to log out from the specified platform by user ID.
 openim::test::force_logout() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "platformID": 2,
   "userID": "4950983283"
 }
 EOF
-)
-echo "Requesting force logout for user: $request_body"
+	)
+	echo "Requesting force logout for user: $request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/auth/force_logout" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/auth/force_logout" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
-
 #################################### User Module ####################################
 
 # Registers a new user with provided user ID, nickname, and face URL using the API.
 openim::test::user_register() {
-# Assign the parameters to local variables, with defaults if not provided
-local user_id="${1:-${TEST_USER_ID}}"
-local nickname="${2:-cubxxw}"
-local face_url="${3:-https://github.com/cubxxw}"
-
-# Create the request body using the provided or default values
-  local request_body=$(cat <<EOF
+	# Assign the parameters to local variables, with defaults if not provided
+	local user_id="${1:-${TEST_USER_ID}}"
+	local nickname="${2:-cubxxw}"
+	local face_url="${3:-https://github.com/cubxxw}"
+
+	# Create the request body using the provided or default values
+	local request_body=$(
+		cat <<EOF
 {
   "secret": "${SECRET}",
   "users": [
@@ -123,20 +125,21 @@ local face_url="${3:-https://github.com/cubxxw}"
   ]
 }
 EOF
-)
+	)
 
-echo "Request body for user registration: $request_body"
+	echo "Request body for user registration: $request_body"
 
-# Send the registration request
-local user_register_response=$(${CCURL} "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/user_register" -d "${request_body}")
+	# Send the registration request
+	local user_register_response=$(${CCURL} "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/user_register" -d "${request_body}")
 
-# Check for errors in the response
-openim::test::check_error "$user_register_response"
+	# Check for errors in the response
+	openim::test::check_error "$user_register_response"
 }
 
 # Checks if the provided list of user IDs exist in the system.
 openim::test::check_user_account() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "checkUserIDs": [
     "${1}",
@@ -146,17 +149,18 @@ openim::test::check_user_account() {
   ]
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/account_check" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/account_check" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Retrieves a list of users with pagination, limited to a specific number per page.
 openim::test::get_users() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "pagination": {
     "pageNumber": 1,
@@ -164,17 +168,18 @@ openim::test::get_users() {
   }
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/get_users" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/get_users" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Obtains detailed information for a list of user IDs.
 openim::test::get_users_info() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "userIDs": [
     "${1}",
@@ -182,17 +187,18 @@ openim::test::get_users_info() {
   ]
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/get_users_info" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/get_users_info" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Retrieves the online status for a list of user IDs.
 openim::test::get_users_online_status() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "userIDs": [
     "${TEST_USER_ID}",
@@ -202,17 +208,18 @@ openim::test::get_users_online_status() {
   ]
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/get_users_online_status" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/get_users_online_status" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Updates the information for a user, such as nickname and face URL.
 openim::test::update_user_info() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "userInfo": {
     "userID": "${TEST_USER_ID}",
@@ -221,32 +228,34 @@ openim::test::update_user_info() {
   }
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/update_user_info" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/update_user_info" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Gets the online status for users that a particular user has subscribed to.
 openim::test::get_subscribe_users_status() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "userID": "${TEST_USER_ID}"
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/get_subscribe_users_status" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/get_subscribe_users_status" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Subscribes to the online status of a list of users for a particular user ID.
 openim::test::subscribe_users_status() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "userID": "9168684795",
   "userIDs": [
@@ -257,104 +266,108 @@ openim::test::subscribe_users_status() {
   "genre": 1
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/subscribe_users_status" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/subscribe_users_status" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Sets the global message receiving option for a user, determining their messaging preferences.
 openim::test::set_global_msg_recv_opt() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "userID": "${TEST_USER_ID}",
   "globalRecvMsgOpt": 0
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/set_global_msg_recv_opt" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/user/set_global_msg_recv_opt" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # [openim::test::user function description]
 # The `openim::test::user` function serves as a test suite for user-related operations.
 # It sequentially invokes all user-related test functions to ensure the API's user operations are functioning correctly.
 function openim::test::user() {
-# 1. Register a test user.
-local USER_ID=$RANDOM
-local TEST_USER_ID=$RANDOM
-openim::test::user_register "${USER_ID}" "user01" "new_face_url"
-openim::test::user_register "${TEST_USER_ID}" "user01" "new_face_url"
-# 2. Check if the test user's account exists.
-openim::test::check_user_account "${TEST_USER_ID}"
+	# 1. Register a test user.
+	local USER_ID=$RANDOM
+	local TEST_USER_ID=$RANDOM
+	openim::test::user_register "${USER_ID}" "user01" "new_face_url"
+	openim::test::user_register "${TEST_USER_ID}" "user01" "new_face_url"
+	# 2. Check if the test user's account exists.
+	openim::test::check_user_account "${TEST_USER_ID}"
 
-# 3. Retrieve a list of users.
-openim::test::get_users
+	# 3. Retrieve a list of users.
+	openim::test::get_users
 
-# 4. Get detailed information for the test user.
-openim::test::get_users_info "${TEST_USER_ID}"
+	# 4. Get detailed information for the test user.
+	openim::test::get_users_info "${TEST_USER_ID}"
 
-# 5. Check the online status of the test user.
-openim::test::get_users_online_status
+	# 5. Check the online status of the test user.
+	openim::test::get_users_online_status
 
-# 6. Update the test user's information.
-openim::test::update_user_info
+	# 6. Update the test user's information.
+	openim::test::update_user_info
 
-# 7. Get the status of users subscribed by the test user.
-openim::test::get_subscribe_users_status
+	# 7. Get the status of users subscribed by the test user.
+	openim::test::get_subscribe_users_status
 
-# 8. Subscribe the test user to a set of user statuses.
-openim::test::subscribe_users_status
+	# 8. Subscribe the test user to a set of user statuses.
+	openim::test::subscribe_users_status
 
-# 9. Set the message receiving option for the test user.
-openim::test::set_global_msg_recv_opt
+	# 9. Set the message receiving option for the test user.
+	openim::test::set_global_msg_recv_opt
 
-# Log the completion of the user test suite.
-openim::log::success "User test suite completed successfully."
+	# Log the completion of the user test suite.
+	openim::log::success "User test suite completed successfully."
 }
 
 #################################### Friend Module ####################################
 
 # Checks if two users are friends.
 openim::test::is_friend() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "userID1": "${1}",
   "userID2": "${2}"
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/is_friend" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/is_friend" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Deletes a friend for a user.
 openim::test::delete_friend() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "ownerUserID":"${1}",
   "friendUserID":"${2}"
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/delete_friend" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/delete_friend" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Gets the friend application list for a user.
 openim::test::get_friend_apply_list() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "userID": "${MANAGER_USERID_1}",
   "pagination": {
@@ -363,17 +376,18 @@ openim::test::get_friend_apply_list() {
   }
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/get_friend_apply_list" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/get_friend_apply_list" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Gets the friend list for a user.
 openim::test::get_friend_list() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "userID": "${1}",
   "pagination": {
@@ -382,34 +396,36 @@ openim::test::get_friend_list() {
   }
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/get_friend_list" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/get_friend_list" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Sets a remark for a friend.
 openim::test::set_friend_remark() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "ownerUserID": "${1}",
   "friendUserID": "${2}",
   "remark": "remark"
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/set_friend_remark" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/set_friend_remark" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Adds a friend request.
 openim::test::add_friend() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "fromUserID": "${1}",
   "toUserID": "${2}",
@@ -417,36 +433,37 @@ openim::test::add_friend() {
   "ex": ""
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/add_friend" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/add_friend" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Imports friends for a user.
 openim::test::import_friend() {
-local friend_ids=$(printf ', "%s"' "${@:2}")
-friend_ids=${friend_ids:2}
-  local request_body=$(cat <<EOF
+	local friend_ids=$(printf ', "%s"' "${@:2}")
+	friend_ids=${friend_ids:2}
+	local request_body=$(
+		cat <<EOF
 {
   "ownerUserID": "${1}",
   "friendUserIDs": [${friend_ids}]
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/import_friend" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/import_friend" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
-
 # Responds to a friend request.
 openim::test::add_friend_response() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "fromUserID": "${1}",
   "toUserID": "${2}",
@@ -454,17 +471,18 @@ openim::test::add_friend_response() {
   "handleMsg": "agree"
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/add_friend_response" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/add_friend_response" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Retrieves the friend application list that the user has applied for.
 openim::test::get_self_friend_apply_list() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "userID": "${1}",
   "pagination": {
@@ -473,49 +491,52 @@ openim::test::get_self_friend_apply_list() {
   }
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/get_self_friend_apply_list" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/get_self_friend_apply_list" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Adds a user to the blacklist.
 openim::test::add_black() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "ownerUserID": "${1}",
   "blackUserID": "${2}"
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/add_black" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/add_black" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Removes a user from the blacklist.
 openim::test::remove_black() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "ownerUserID": "${1}",
   "blackUserID": "${2}"
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/remove_black" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/remove_black" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Retrieves the blacklist for a user.
 openim::test::get_black_list() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "userID": "${1}",
   "pagination": {
@@ -524,119 +545,122 @@ openim::test::get_black_list() {
   }
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/get_black_list" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/get_black_list" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Updates the pin status of multiple friends.
 openim::test::update_pin_status() {
-local ownerUserID="${1}"
-shift  # Shift the arguments to skip the first one (ownerUserID)
-local isPinned="${1}"
-shift  # Shift the arguments to skip the isPinned argument
-
-# Constructing the list of friendUserIDs
-local friendUserIDsArray=()
-for friendUserID in "$@"; do
-friendUserIDsArray+=("\"${friendUserID}\"")
-done
-local friendUserIDs=$(IFS=,; echo "${friendUserIDsArray[*]}")
-
-  local request_body=$(cat <<EOF
+	local ownerUserID="${1}"
+	shift # Shift the arguments to skip the first one (ownerUserID)
+	local isPinned="${1}"
+	shift # Shift the arguments to skip the isPinned argument
+
+	# Constructing the list of friendUserIDs
+	local friendUserIDsArray=()
+	for friendUserID in "$@"; do
+		friendUserIDsArray+=("\"${friendUserID}\"")
+	done
+	local friendUserIDs=$(
+		IFS=,
+		echo "${friendUserIDsArray[*]}"
+	)
+
+	local request_body=$(
+		cat <<EOF
 {
   "ownerUserID": "${ownerUserID}",
   "friendUserIDs": [${friendUserIDs}],
   "isPinned": ${isPinned}
 }
 EOF
-)
-echo "Requesting to update pin status: $request_body"
+	)
+	echo "Requesting to update pin status: $request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/update_pin_status" -d "${request_body}")
-echo "Response: $response"
-openim::test::check_error "$response"
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/friend/update_pin_status" -d "${request_body}")
+	echo "Response: $response"
+	openim::test::check_error "$response"
 }
 
-
 # [openim::test::friend function description]
 # The `openim::test::friend` function serves as a test suite for friend-related operations.
 # It sequentially invokes all friend-related test functions to ensure the API's friend operations are functioning correctly.
 function openim::test::friend() {
-local FRIEND_USER_ID=$RANDOM
-local BLACK_USER_ID=$RANDOM
-local TEST_USER_ID=$RANDOM
-# Assumes that TEST_USER_ID, FRIEND_USER_ID, and other necessary IDs are set as environment variables before running this suite.
-# 0. Register a friend user.
-openim::test::user_register "${TEST_USER_ID}" "user01" "new_face_url"
-openim::test::user_register "${FRIEND_USER_ID}" "frient01" "new_face_url"
-openim::test::user_register "${BLACK_USER_ID}" "frient02" "new_face_url"
+	local FRIEND_USER_ID=$RANDOM
+	local BLACK_USER_ID=$RANDOM
+	local TEST_USER_ID=$RANDOM
+	# Assumes that TEST_USER_ID, FRIEND_USER_ID, and other necessary IDs are set as environment variables before running this suite.
+	# 0. Register a friend user.
+	openim::test::user_register "${TEST_USER_ID}" "user01" "new_face_url"
+	openim::test::user_register "${FRIEND_USER_ID}" "frient01" "new_face_url"
+	openim::test::user_register "${BLACK_USER_ID}" "frient02" "new_face_url"
 
-# 1. Check if two users are friends.
-openim::test::is_friend "${TEST_USER_ID}" "${FRIEND_USER_ID}"
+	# 1. Check if two users are friends.
+	openim::test::is_friend "${TEST_USER_ID}" "${FRIEND_USER_ID}"
 
-# 2. Send a friend request from one user to another.
-openim::test::add_friend "${TEST_USER_ID}" "${FRIEND_USER_ID}"
+	# 2. Send a friend request from one user to another.
+	openim::test::add_friend "${TEST_USER_ID}" "${FRIEND_USER_ID}"
 
-local original_token=$Token
+	local original_token=$Token
 
-# Switch to FRIEND_USER_ID's token
-local friend_token="-Htoken: $(openim::test::get_token "${FRIEND_USER_ID}")"
-# 3. Respond to a friend request.
-# TODO：
-#   openim::test::add_friend_response "${FRIEND_USER_ID}" "${TEST_USER_ID}"
+	# Switch to FRIEND_USER_ID's token
+	local friend_token="-Htoken: $(openim::test::get_token "${FRIEND_USER_ID}")"
+	# 3. Respond to a friend request.
+	# TODO：
+	#   openim::test::add_friend_response "${FRIEND_USER_ID}" "${TEST_USER_ID}"
 
-Token=$original_token
-# 4. Retrieve the friend list of the test user.
-openim::test::get_friend_list "${TEST_USER_ID}"
+	Token=$original_token
+	# 4. Retrieve the friend list of the test user.
+	openim::test::get_friend_list "${TEST_USER_ID}"
 
-# 5. Set a remark for a friend.
-# TODO：
-#   openim::test::set_friend_remark "${TEST_USER_ID}" "${FRIEND_USER_ID}"
+	# 5. Set a remark for a friend.
+	# TODO：
+	#   openim::test::set_friend_remark "${TEST_USER_ID}" "${FRIEND_USER_ID}"
 
-# 6. Retrieve the friend application list for the test user.
-openim::test::get_friend_apply_list "${TEST_USER_ID}" 1 100
+	# 6. Retrieve the friend application list for the test user.
+	openim::test::get_friend_apply_list "${TEST_USER_ID}" 1 100
 
-# 7. Retrieve the friend application list that the user has applied for.
-openim::test::get_self_friend_apply_list "${TEST_USER_ID}" 1 100
+	# 7. Retrieve the friend application list that the user has applied for.
+	openim::test::get_self_friend_apply_list "${TEST_USER_ID}" 1 100
 
-# 8. Delete a friend.
-# TODO：
-#   openim::test::delete_friend "${TEST_USER_ID}" "${FRIEND_USER_ID}"
+	# 8. Delete a friend.
+	# TODO：
+	#   openim::test::delete_friend "${TEST_USER_ID}" "${FRIEND_USER_ID}"
 
-# 9. Add a user to the blacklist.
-openim::test::add_black "${TEST_USER_ID}" "${BLACK_USER_ID}"
+	# 9. Add a user to the blacklist.
+	openim::test::add_black "${TEST_USER_ID}" "${BLACK_USER_ID}"
 
-# 10. Remove a user from the blacklist.
-openim::test::remove_black "${TEST_USER_ID}" "${BLACK_USER_ID}"
+	# 10. Remove a user from the blacklist.
+	openim::test::remove_black "${TEST_USER_ID}" "${BLACK_USER_ID}"
 
-# 11. Retrieve the blacklist for the test user.
-openim::test::get_black_list "${TEST_USER_ID}"
+	# 11. Retrieve the blacklist for the test user.
+	openim::test::get_black_list "${TEST_USER_ID}"
 
-# 12. Import friends for the user (Optional).
-# TODO：
-#   openim::test::import_friend "${TEST_USER_ID}" "11111114" "11111115"
+	# 12. Import friends for the user (Optional).
+	# TODO：
+	#   openim::test::import_friend "${TEST_USER_ID}" "11111114" "11111115"
 
-# 13. pin Friend
-# Add this call to your test suite where appropriate
-# TODO：
-#  openim::test::update_pin_status "${TEST_USER_ID}" true "${FRIEND_USER_ID}"
-#
-#  openim::test::update_pin_status "${TEST_USER_ID}" false "${FRIEND_USER_ID}"
+	# 13. pin Friend
+	# Add this call to your test suite where appropriate
+	# TODO：
+	#  openim::test::update_pin_status "${TEST_USER_ID}" true "${FRIEND_USER_ID}"
+	#
+	#  openim::test::update_pin_status "${TEST_USER_ID}" false "${FRIEND_USER_ID}"
 
-# Log the completion of the friend test suite.
-openim::log::success "Friend test suite completed successfully."
+	# Log the completion of the friend test suite.
+	openim::log::success "Friend test suite completed successfully."
 }
 
-
 #################################### Group Module ####################################
 
 # Creates a new group.
 openim::test::create_group() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "memberUserIDs": [
     "${1}"
@@ -659,17 +683,18 @@ openim::test::create_group() {
   }
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/create_group" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/create_group" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Invites a user to join a group.
 openim::test::invite_user_to_group() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "groupID": "${1}",
   "invitedUserIDs": [
@@ -679,49 +704,52 @@ openim::test::invite_user_to_group() {
   "reason": "your reason"
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/invite_user_to_group" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/invite_user_to_group" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Transfers the ownership of a group to another user.
 openim::test::transfer_group() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "groupID":"${1}",
   "oldOwnerUserID":"${2}",
   "newOwnerUserID": "${3}"
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/transfer_group" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/transfer_group" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Retrieves information about multiple groups.
 openim::test::get_groups_info() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "groupIDs": ["${1}", "${2}"]
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/get_groups_info" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/get_groups_info" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Removes a user from a group.
 openim::test::kick_group() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "groupID": "${1}",
   "kickedUserIDs": [
@@ -730,33 +758,35 @@ openim::test::kick_group() {
   "reason": "Bye!"
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/kick_group" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/kick_group" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Retrieves information about group members.
 openim::test::get_group_members_info() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "groupID": "${1}",
   "userIDs": ["${2}"]
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/get_group_members_info" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/get_group_members_info" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Retrieves a list of group members.
 openim::test::get_group_member_list() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "groupID": "${1}",
   "pagination": {
@@ -765,17 +795,18 @@ openim::test::get_group_member_list() {
   }
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/get_group_member_list" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/get_group_member_list" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Retrieves a list of groups that a user has joined.
 openim::test::get_joined_group_list() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "fromUserID": "${1}",
   "pagination": {
@@ -784,18 +815,18 @@ openim::test::get_joined_group_list() {
   }
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/get_joined_group_list" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/get_joined_group_list" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
-
 # Sets group member information.
 openim::test::set_group_member_info() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "members": [
     {
@@ -809,78 +840,83 @@ openim::test::set_group_member_info() {
   ]
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/set_group_member_info" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/set_group_member_info" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Mutes a group.
 openim::test::mute_group() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "groupID": "${1}"
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/mute_group" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/mute_group" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Cancels the muting of a group.
 openim::test::cancel_mute_group() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "groupID": "${1}"
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/cancel_mute_group" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/cancel_mute_group" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Dismisses a group.
 openim::test::dismiss_group() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "groupID":"${1}"
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/dismiss_group" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/dismiss_group" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Cancels muting a group member.
 openim::test::cancel_mute_group_member() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "groupID": "${1}",
   "userID": "${2}"
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/cancel_mute_group_member" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/cancel_mute_group_member" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Allows a user to join a group.
 openim::test::join_group() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
  "groupID": "${1}",
  "reqMessage": "req msg join group",
@@ -888,17 +924,18 @@ openim::test::join_group() {
  "inviterUserID": "${2}"
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/join_group" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/join_group" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Sets group information.
 openim::test::set_group_info() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "groupInfoForSet": {
     "groupID": "${1}",
@@ -913,34 +950,35 @@ openim::test::set_group_info() {
   }
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/set_group_info" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/set_group_info" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
-
 # Allows a user to quit a group.
 openim::test::quit_group() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "groupID": "${1}",
   "userID": "${2}"
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/quit_group" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/quit_group" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Retrieves the list of group applications received by the user.
 openim::test::get_recv_group_applicationList() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "fromUserID": "${1}",
   "pagination": {
@@ -949,17 +987,18 @@ openim::test::get_recv_group_applicationList() {
   }
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/get_recv_group_applicationList" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/get_recv_group_applicationList" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Responds to a group application.
 openim::test::group_application_response() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "groupID": "${1}",
   "fromUserID": "${2}",
@@ -967,17 +1006,18 @@ openim::test::group_application_response() {
   "handleResult": 1
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/group_application_response" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/group_application_response" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Retrieves the list of group applications made by the user.
 openim::test::get_user_req_group_applicationList() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "userID": "${1}",
   "pagination": {
@@ -986,34 +1026,36 @@ openim::test::get_user_req_group_applicationList() {
   }
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/get_user_req_group_applicationList" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/get_user_req_group_applicationList" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Mutes a group member for a specified duration.
 openim::test::mute_group_member() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "groupID": "${1}",
   "userID": "${2}",
   "mutedSeconds": ${3}
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/mute_group_member" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/mute_group_member" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Retrieves a list of group applications from specific users.
 openim::test::get_group_users_req_application_list() {
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "groupID": "${1}",
   "userIDs": [
@@ -1021,165 +1063,170 @@ openim::test::get_group_users_req_application_list() {
   ]
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/get_group_users_req_application_list" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/group/get_group_users_req_application_list" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # [openim::test::group function description]
 # The `openim::test::group` function serves as a test suite for group-related operations.
 # It sequentially invokes all group-related test functions to ensure the API's group operations are functioning correctly.
 function openim::test::group() {
-local USER_ID=$RANDOM
-local OTHER_USER1_ID=$RANDOM
-local OTHER_USER2_ID=$RANDOM
-local TEST_USER_ID=$RANDOM
+	local USER_ID=$RANDOM
+	local OTHER_USER1_ID=$RANDOM
+	local OTHER_USER2_ID=$RANDOM
+	local TEST_USER_ID=$RANDOM
 
-local GROUP_ID=$RANDOM
-local GROUP_ID2=$RANDOM
-# Assumes that TEST_GROUP_ID, USER_ID, and other necessary IDs are set as environment variables before running this suite.
-# 0. Register a friend user.
-openim::test::user_register "${USER_ID}" "group00" "new_face_url"
-openim::test::user_register "${OTHER_USER1_ID}" "group01" "new_face_url"
-openim::test::user_register "${OTHER_USER2_ID}" "group02" "new_face_url"
+	local GROUP_ID=$RANDOM
+	local GROUP_ID2=$RANDOM
+	# Assumes that TEST_GROUP_ID, USER_ID, and other necessary IDs are set as environment variables before running this suite.
+	# 0. Register a friend user.
+	openim::test::user_register "${USER_ID}" "group00" "new_face_url"
+	openim::test::user_register "${OTHER_USER1_ID}" "group01" "new_face_url"
+	openim::test::user_register "${OTHER_USER2_ID}" "group02" "new_face_url"
 
-# 0. Create a new group.
-openim::test::create_group "$OTHER_USER2_ID" "$OTHER_USER1_ID" "$USER_ID" "$GROUP_ID"
+	# 0. Create a new group.
+	openim::test::create_group "$OTHER_USER2_ID" "$OTHER_USER1_ID" "$USER_ID" "$GROUP_ID"
 
-# 1. Invite user to group.
-openim::test::invite_user_to_group "$GROUP_ID" "$MANAGER_USERID_1" "$MANAGER_USERID_2"
+	# 1. Invite user to group.
+	openim::test::invite_user_to_group "$GROUP_ID" "$MANAGER_USERID_1" "$MANAGER_USERID_2"
 
-# 2. Transfer group ownership.
-openim::test::transfer_group "$GROUP_ID" "$USER_ID" "$OTHER_USER1_ID"
+	# 2. Transfer group ownership.
+	openim::test::transfer_group "$GROUP_ID" "$USER_ID" "$OTHER_USER1_ID"
 
-# 3. Get group information.
-openim::test::get_groups_info "$GROUP_ID" "$OTHER_USER1_ID"
+	# 3. Get group information.
+	openim::test::get_groups_info "$GROUP_ID" "$OTHER_USER1_ID"
 
-# 4. Kick a user from the group.
-openim::test::kick_group "$GROUP_ID" "$OTHER_USER2_ID"
+	# 4. Kick a user from the group.
+	openim::test::kick_group "$GROUP_ID" "$OTHER_USER2_ID"
 
-# 5. Get group members info.
-openim::test::get_group_members_info "$GROUP_ID" "$USER_ID"
+	# 5. Get group members info.
+	openim::test::get_group_members_info "$GROUP_ID" "$USER_ID"
 
-# 6. Get group member list.
-openim::test::get_group_member_list "$GROUP_ID" 1 100
+	# 6. Get group member list.
+	openim::test::get_group_member_list "$GROUP_ID" 1 100
 
-# 7. Get joined group list.
-openim::test::get_joined_group_list "$USER_ID" 10 1
+	# 7. Get joined group list.
+	openim::test::get_joined_group_list "$USER_ID" 10 1
 
-# 8. Set group member info.
-openim::test::set_group_member_info "$GROUP_ID" "$USER_ID" "New NickName" "New Face URL" 60 "Extra Info"
+	# 8. Set group member info.
+	openim::test::set_group_member_info "$GROUP_ID" "$USER_ID" "New NickName" "New Face URL" 60 "Extra Info"
 
-# 9. Mute group.
-openim::test::mute_group "$GROUP_ID"
+	# 9. Mute group.
+	openim::test::mute_group "$GROUP_ID"
 
-# 10. Cancel mute group.
-openim::test::cancel_mute_group "$GROUP_ID"
+	# 10. Cancel mute group.
+	openim::test::cancel_mute_group "$GROUP_ID"
 
-# 11. Dismiss group.
-openim::test::dismiss_group "$GROUP_ID"
+	# 11. Dismiss group.
+	openim::test::dismiss_group "$GROUP_ID"
 
-openim::test::create_group "$OTHER_USER2_ID" "$OTHER_USER1_ID" "$USER_ID" "$GROUP_ID2"
+	openim::test::create_group "$OTHER_USER2_ID" "$OTHER_USER1_ID" "$USER_ID" "$GROUP_ID2"
 
-# 12. Cancel mute group member.
-openim::test::cancel_mute_group_member "$GROUP_ID" "$USER_ID"
+	# 12. Cancel mute group member.
+	openim::test::cancel_mute_group_member "$GROUP_ID" "$USER_ID"
 
-# 13. Join group.
-# TODO:
-#   openim::test::join_group "$GROUP_ID2" "$OTHER_USER2_ID"
+	# 13. Join group.
+	# TODO:
+	#   openim::test::join_group "$GROUP_ID2" "$OTHER_USER2_ID"
 
-# 14. Set group info.
-openim::test::set_group_info "$GROUP_ID2"
+	# 14. Set group info.
+	openim::test::set_group_info "$GROUP_ID2"
 
-# 15. Quit group.
-openim::test::quit_group "$GROUP_ID2" "$OTHER_USER1_ID"
+	# 15. Quit group.
+	openim::test::quit_group "$GROUP_ID2" "$OTHER_USER1_ID"
 
-# 16. Get received group application list.
-openim::test::get_recv_group_applicationList "$USER_ID" 1 100
+	# 16. Get received group application list.
+	openim::test::get_recv_group_applicationList "$USER_ID" 1 100
 
-# 17. Group application response.
-# TODO:
-#   openim::test::group_application_response "$GROUP_ID2" "$OTHER_USER2_ID"
+	# 17. Group application response.
+	# TODO:
+	#   openim::test::group_application_response "$GROUP_ID2" "$OTHER_USER2_ID"
 
-# 18. Get user requested group application list.
-openim::test::get_user_req_group_applicationList "$USER_ID" 1 100
+	# 18. Get user requested group application list.
+	openim::test::get_user_req_group_applicationList "$USER_ID" 1 100
 
-# 19. Mute group member.
-openim::test::mute_group_member "$GROUP_ID" "$OTHER_USER1_ID" 3600
+	# 19. Mute group member.
+	openim::test::mute_group_member "$GROUP_ID" "$OTHER_USER1_ID" 3600
 
-# 20. Get group users request application list.
-openim::test::get_group_users_req_application_list "$GROUP_ID" "$USER_ID"
+	# 20. Get group users request application list.
+	openim::test::get_group_users_req_application_list "$GROUP_ID" "$USER_ID"
 
-# Log the completion of the group test suite.
-openim::log::success "Group test suite completed successfully."
+	# Log the completion of the group test suite.
+	openim::log::success "Group test suite completed successfully."
 }
 
 #################################### Register And Check Module ####################################
 
 # Define a function to register a user
 openim::register_user() {
-user_register_response=$(${CCURL} "${Header}" ${INSECURE_OPENIMAPI}/user/user_register \
--d'{
+	user_register_response=$(
+		${CCURL} "${Header}" ${INSECURE_OPENIMAPI}/user/user_register \
+		-d'{
 "secret": "openIM123",
 "users": [{"userID": "11111112","nickname": "yourNickname","faceURL": "yourFaceURL"}]
-}')
+}'
+	)
 
-echo "$user_register_response"
+	echo "$user_register_response"
 }
 
 # Define a function to check the account
 openim::test::check_account() {
-local token=$1
-account_check_response=$(${CCURL} "${Header}" -H"operationID: 1646445464564" -H"token: ${token}" ${INSECURE_OPENIMAPI}/user/account_check \
--d'{
+	local token=$1
+	account_check_response=$(
+		${CCURL} "${Header}" -H"operationID: 1646445464564" -H"token: ${token}" ${INSECURE_OPENIMAPI}/user/account_check \
+		-d'{
 "checkUserIDs": ["11111111","11111112"]
-}')
+}'
+	)
 
-echo "$account_check_response"
+	echo "$account_check_response"
 }
 
 # Define a function to register, get a token and check the account
 openim::test::register_and_check() {
-# Register a user
-user_register_response=$(openim::register_user)
+	# Register a user
+	user_register_response=$(openim::register_user)
 
-if [[ "$user_register_response" == *"\"errCode\": 0"* ]]; then
-echo "User registration successful."
+	if [[ "$user_register_response" == *"\"errCode\": 0"* ]]; then
+		echo "User registration successful."
 
-# Get token
-token=$(openim::get_token)
+		# Get token
+		token=$(openim::get_token)
 
-if [[ -n "$token" ]]; then
-echo "Token acquired: $token"
+		if [[ -n "$token" ]]; then
+			echo "Token acquired: $token"
 
-# Check account
-account_check_response=$(openim::check_account "$token")
+			# Check account
+			account_check_response=$(openim::check_account "$token")
 
-if [[ "$account_check_response" == *"\"errCode\": 0"* ]]; then
-echo "Account check successful."
-else
-echo "Account check failed."
-fi
-else
-echo "Failed to acquire token."
-fi
-else
-echo "User registration failed."
-fi
+			if [[ "$account_check_response" == *"\"errCode\": 0"* ]]; then
+				echo "Account check successful."
+			else
+				echo "Account check failed."
+			fi
+		else
+			echo "Failed to acquire token."
+		fi
+	else
+		echo "User registration failed."
+	fi
 }
 
 #################################### Msg Module ####################################
 
 # Sends a message.
 openim::test::send_msg() {
-local sendID="${1}"
-local recvID="${2}"
-local groupID="${3}"
+	local sendID="${1}"
+	local recvID="${2}"
+	local groupID="${3}"
 
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "sendID": "${sendID}",
   "recvID": "${recvID}",
@@ -1204,26 +1251,27 @@ local groupID="${3}"
   }
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/msg/send_msg" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/msg/send_msg" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # Searches for messages.
 openim::test::search_msg() {
-local sendID="${1}"
-local recvID="${2}"
-local msgType="${3}"
-local sendTime="${4}"
-local sessionType="${5}"
-local pageNumber="${6}"
-local showNumber="${7}"
-
-# Construct the request body
-  local request_body=$(cat <<EOF
+	local sendID="${1}"
+	local recvID="${2}"
+	local msgType="${3}"
+	local sendTime="${4}"
+	local sessionType="${5}"
+	local pageNumber="${6}"
+	local showNumber="${7}"
+
+	# Construct the request body
+	local request_body=$(
+		cat <<EOF
 {
   "sendID": "${sendID}",
   "recvID": "${recvID}",
@@ -1236,27 +1284,28 @@ local showNumber="${7}"
   }
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-# Send the request
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/msg/search_msg" -d "${request_body}")
+	# Send the request
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/msg/search_msg" -d "${request_body}")
 
-# Check the response for errors
-openim::test::check_error "$response"
+	# Check the response for errors
+	openim::test::check_error "$response"
 }
 
 # Pulls messages by sequence.
 openim::test::pull_msg_by_seq() {
-local userID="${1}"
-local conversationID="${2}"
-local beginSeq="${3}"
-local endSeq="${4}"
-local num="${5}"
-local order="${6}"  # Assuming 0 for ascending, 1 for descending
-
-# Construct the request body
-  local request_body=$(cat <<EOF
+	local userID="${1}"
+	local conversationID="${2}"
+	local beginSeq="${3}"
+	local endSeq="${4}"
+	local num="${5}"
+	local order="${6}" # Assuming 0 for ascending, 1 for descending
+
+	# Construct the request body
+	local request_body=$(
+		cat <<EOF
 {
   "userID": "${userID}",
   "seqRanges": [
@@ -1270,101 +1319,100 @@ local order="${6}"  # Assuming 0 for ascending, 1 for descending
   "order": ${order}
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-# Send the request
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/msg/pull_msg_by_seq" -d "${request_body}")
+	# Send the request
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/msg/pull_msg_by_seq" -d "${request_body}")
 
-# Check the response for errors
-openim::test::check_error "$response"
+	# Check the response for errors
+	openim::test::check_error "$response"
 }
 
 # Revokes a message.
 openim::test::revoke_msg() {
-local userID="${1}"
-local conversationID="${2}"
-local seq="${3}"
+	local userID="${1}"
+	local conversationID="${2}"
+	local seq="${3}"
 
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "userID": "${userID}",
   "conversationID": "${conversationID}",
   "seq": ${seq}
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/msg/revoke_msg" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/msg/revoke_msg" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
-
 # Clears all messages for a user.
 openim::test::user_clear_all_msg() {
-local userID="${1}"
+	local userID="${1}"
 
-  local request_body=$(cat <<EOF
+	local request_body=$(
+		cat <<EOF
 {
   "userID": "${userID}"
 }
 EOF
-)
-echo "$request_body"
+	)
+	echo "$request_body"
 
-local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/msg/user_clear_all_msg" -d "${request_body}")
+	local response=$(${CCURL} "${Token}" "${OperationID}" "${Header}" "${INSECURE_OPENIMAPI}/msg/user_clear_all_msg" -d "${request_body}")
 
-openim::test::check_error "$response"
+	openim::test::check_error "$response"
 }
 
 # [openim::test::msg function description]
 # The `openim::test::msg` function serves as a test suite for message-related operations.
 # It sequentially invokes all message-related test functions to ensure the API's message operations are functioning correctly.
-function openim::test::msg()
-{
-local SEND_USER_ID="${MANAGER_USERID_1}" # This should be the sender's userID
-local GROUP_ID="" # GroupID if it's a group message
-local USER_ID="$RANDOM"
-openim::test::user_register "${USER_ID}" "msg00" "new_face_url"
-local RECV_USER_ID="${USER_ID}" # Receiver's userID
+function openim::test::msg() {
+	local SEND_USER_ID="${MANAGER_USERID_1}" # This should be the sender's userID
+	local GROUP_ID=""                        # GroupID if it's a group message
+	local USER_ID="$RANDOM"
+	openim::test::user_register "${USER_ID}" "msg00" "new_face_url"
+	local RECV_USER_ID="${USER_ID}" # Receiver's userID
 
-# 0. Send a message.
-openim::test::send_msg "${SEND_USER_ID}" "${RECV_USER_ID}" "${GROUP_ID}"
+	# 0. Send a message.
+	openim::test::send_msg "${SEND_USER_ID}" "${RECV_USER_ID}" "${GROUP_ID}"
 
-# Wait for a short duration to ensure message is sent
-# 1. Search for the message
-local SEARCH_TIME="2023-01-01T00:00:00Z" # You may need to adjust this
-local MSG_TYPE=101
-local SESSION_TYPE=1
-local PAGE_NUMBER=1
-local SHOW_NUMBER=20
+	# Wait for a short duration to ensure message is sent
+	# 1. Search for the message
+	local SEARCH_TIME="2023-01-01T00:00:00Z" # You may need to adjust this
+	local MSG_TYPE=101
+	local SESSION_TYPE=1
+	local PAGE_NUMBER=1
+	local SHOW_NUMBER=20
 
-echo "Searching for messages between ${SEND_USER_ID} and ${RECV_USER_ID}..."
-openim::test::search_msg "${MANAGER_USERID_1}" "${RECV_USER_ID}" "${MSG_TYPE}" "${SEARCH_TIME}" "${SESSION_TYPE}" "${PAGE_NUMBER}" "${SHOW_NUMBER}"
+	echo "Searching for messages between ${SEND_USER_ID} and ${RECV_USER_ID}..."
+	openim::test::search_msg "${MANAGER_USERID_1}" "${RECV_USER_ID}" "${MSG_TYPE}" "${SEARCH_TIME}" "${SESSION_TYPE}" "${PAGE_NUMBER}" "${SHOW_NUMBER}"
 
-# 3. Pull messages by sequence.
-local CONVERSATION_ID="ci_${SEND_USER_ID}_${RECV_USER_ID}" # Adjust as per your conversation ID format
-local BEGIN_SEQ=0
-local END_SEQ=10
-local NUM=5
-local ORDER=0 # Assuming 0 for ascending order
-openim::test::pull_msg_by_seq "${RECV_USER_ID}" "${CONVERSATION_ID}" "${BEGIN_SEQ}" "${END_SEQ}" "${NUM}" "${ORDER}"
+	# 3. Pull messages by sequence.
+	local CONVERSATION_ID="ci_${SEND_USER_ID}_${RECV_USER_ID}" # Adjust as per your conversation ID format
+	local BEGIN_SEQ=0
+	local END_SEQ=10
+	local NUM=5
+	local ORDER=0 # Assuming 0 for ascending order
+	openim::test::pull_msg_by_seq "${RECV_USER_ID}" "${CONVERSATION_ID}" "${BEGIN_SEQ}" "${END_SEQ}" "${NUM}" "${ORDER}"
 
+	# Assuming message sending was successful and returned a sequence number.
+	local SEQ_NUMBER=1 # This should be the actual sequence number of the message sent.
 
-# Assuming message sending was successful and returned a sequence number.
-local SEQ_NUMBER=1 # This should be the actual sequence number of the message sent.
+	# 2. Revoke a message.
+	# TODO：
+	# openim::test::revoke_msg "${RECV_USER_ID}" "si_${SEND_USER_ID}_${RECV_USER_ID}" "${SEQ_NUMBER}"
 
-# 2. Revoke a message.
-# TODO：
-# openim::test::revoke_msg "${RECV_USER_ID}" "si_${SEND_USER_ID}_${RECV_USER_ID}" "${SEQ_NUMBER}"
+	# 4. Clear all messages for a user.
+	openim::test::user_clear_all_msg "${RECV_USER_ID}"
 
-# 4. Clear all messages for a user.
-openim::test::user_clear_all_msg "${RECV_USER_ID}"
-
-# Log the completion of the message test suite.
-openim::log::success "Message test suite completed successfully."
+	# Log the completion of the message test suite.
+	openim::log::success "Message test suite completed successfully."
 }
 
 #################################### Man Module ####################################
@@ -1372,10 +1420,9 @@ openim::log::success "Message test suite completed successfully."
 # TODO:
 
 openim::test::man() {
-openim::log::info "TODO: openim test man"
+	openim::log::info "TODO: openim test man"
 }
 
-
 #################################### Build Module ####################################
 
 # Function: openim::test::smoke
@@ -1383,9 +1430,9 @@ openim::log::info "TODO: openim test man"
 # These are preliminary checks to ensure that the most crucial operations like user registration
 # and account checking are operational.
 openim::test::smoke() {
-openim::register_user
-openim::test::check_account
-openim::test::register_and_check
+	openim::register_user
+	openim::test::check_account
+	openim::test::register_and_check
 }
 
 # Function: openim::test::api
@@ -1393,11 +1440,11 @@ openim::test::register_and_check
 # service such as authentication, user operations, friend management, group interactions, and
 # message handling. It is used to verify the integrity and functionality of API endpoints.
 openim::test::api() {
-openim::test::auth
-openim::test::user
-openim::test::friend
-openim::test::group
-openim::test::msg
+	openim::test::auth
+	openim::test::user
+	openim::test::friend
+	openim::test::group
+	openim::test::msg
 }
 
 # Function: openim::test::test
@@ -1405,17 +1452,17 @@ openim::test::msg
 # It ensures that each component of the service is tested, utilizing utility functions for
 # environment checking and completing with a success message if all tests pass.
 openim::test::test() {
-openim::util::require-jq
-openim::test::smoke
-openim::test::man
-openim::test::api
+	openim::util::require-jq
+	openim::test::smoke
+	openim::test::man
+	openim::test::api
 
-openim::log::info "$(echo -e '\033[32mcongratulations, all test passed!\033[0m')"
+	openim::log::info "$(echo -e '\033[32mcongratulations, all test passed!\033[0m')"
 }
 
 # Main execution logic: This conditional block checks if the script's arguments match any known
 # test function patterns and, if so, evaluates the function call. This allows for specific test
 # functions to be triggered based on the passed arguments.
-if [[ "$*" =~ openim::test:: ]];then
-eval $*
+if [[ "$*" =~ openim::test:: ]]; then
+	eval $*
 fi
diff --git a/scripts/lib/util.sh b/scripts/lib/util.sh
index ccf60b7b6..a40668d70 100755
--- a/scripts/lib/util.sh
+++ b/scripts/lib/util.sh
@@ -1086,7 +1086,7 @@ function openim::util::ensure-install-nginx {
     exit 1
   fi
 
-  for port in 80
+  for port in "80"
   do
     if echo |telnet 127.0.0.1 $port 2>&1|grep refused &>/dev/null;then
       exit 1
@@ -2320,7 +2320,7 @@ function openim::util::ensure-install-nginx {
     exit 1
   fi
 
-  for port in 80
+  for port in "80"
   do
     if echo |telnet 127.0.0.1 $port 2>&1|grep refused &>/dev/null;then
       exit 1
@@ -2467,7 +2467,7 @@ function openim::util::desc() {
 }
 
 function openim::util:run::prompt() {
-    echo -n "$yellow\$ $reset"
+    echo -n "${yellow}\$ ${reset}"
 }
 
 started=""
@@ -2488,7 +2488,7 @@ function openim::util::run() {
     if [ -n "$DEMO_RUN_FAST" ]; then
       rate=1000
     fi
-    echo "$green$1$reset" | pv -qL $rate
+    echo "${green}$1${reset}" | pv -qL "$rate"
     if [ -n "$DEMO_RUN_FAST" ]; then
       sleep 0.5
     fi
diff --git a/scripts/update-yamlfmt.sh b/scripts/update-yamlfmt.sh
index 388c3ca85..90ec8aa62 100755
--- a/scripts/update-yamlfmt.sh
+++ b/scripts/update-yamlfmt.sh
@@ -27,16 +27,16 @@ cd "${OPENIM_ROOT}"
 
 find_files() {
   find . -not \( \
-  \( \
-  -wholename './output' \
-  -o -wholename './.git' \
-  -o -wholename './_output' \
-  -o -wholename './_gopath' \
-  -o -wholename './release' \
-  -o -wholename './target' \
-  -o -wholename '*/vendor/*' \
-  \) -prune \
-  \) -name 'OWNERS*'
+      \( \
+        -wholename './output' \
+        -o -wholename './.git' \
+        -o -wholename './_output' \
+        -o -wholename './_gopath' \
+        -o -wholename './release' \
+        -o -wholename './target' \
+        -o -wholename '*/vendor/*' \
+      \) -prune \
+    \) -name 'OWNERS*'
 }
 
 export GO111MODULE=on
diff --git a/scripts/verify-shellcheck.sh b/scripts/verify-shellcheck.sh
index 2f85ec075..8a5ad7321 100755
--- a/scripts/verify-shellcheck.sh
+++ b/scripts/verify-shellcheck.sh
@@ -43,6 +43,54 @@ disabled=(
   1091
   # this lint prefers command -v to which, they are not the same
   2230
+  # Error SC2155 indicates that you should separate variable declaration and assignment to avoid masking the return value of the command.
+  # In Bash scripts, when you declare and assign a local variable at the same time a command is executed, you only get the output of the command, but not the exit status (return value) of the command.  #
+  2155
+  # ShellCheck issues SC2086 warnings when you refer to a variable in a script but don't put it in double quotes.This can lead to unexpected behavior when scripts encounter Spaces, 
+  # newlines, and wildcards in file names or other data.
+  2086
+  2206
+
+  # TODO: 需要修复，然后开启
+  2034
+  2048
+  2148
+  2059
+  2214
+  2145
+  2128
+  2550
+  2046
+  2181
+  1102
+  2045
+  2068
+  2145
+  2207
+  2231
+  2013
+  2154
+  2120
+  1083
+  2001
+  2012
+  2016
+  2164
+  2223
+  2166
+  2119
+  2162
+  2295
+  2002
+  2004
+  2202
+  2178
+  2064
+  2260
+  2043
+  2178
+  2044
+  2153
 )
 # comma separate for passing to shellcheck
 join_by() {
@@ -76,7 +124,7 @@ do git check-ignore -q "$script" || all_shell_scripts+=("$script");
   -path ./logs\* -o \
   -path ./vendor\* -o \
   \( -path ./third_party\* -a -not -path ./third_party/forked\* \) \
-\))
+\) -print 2>/dev/null)
 
 # detect if the host machine has the required shellcheck version installed
 # if so, we will use that instead.
@@ -117,7 +165,7 @@ if ${HAVE_SHELLCHECK}; then
 else
   openim::log::info "Using shellcheck ${SHELLCHECK_VERSION} docker image."
   "${DOCKER}" run \
-  --rm -v "${OPENIM_ROOT}:"${OPENIM_ROOT}"" -w "${OPENIM_ROOT}" \
+  --rm -v "${OPENIM_ROOT}:${OPENIM_ROOT}" -w "${OPENIM_ROOT}" \
   "${SHELLCHECK_IMAGE}" \
   shellcheck "${SHELLCHECK_OPTIONS[@]}" "${all_shell_scripts[@]}" >&2 || res=$?
 fi
diff --git a/test/wrktest.sh b/test/wrktest.sh
index d24e97029..10a41121f 100755
--- a/test/wrktest.sh
+++ b/test/wrktest.sh
@@ -256,7 +256,7 @@ case $1 in
     t2=$(basename $3|sed 's/.dat//g') # 对比图中粉色线条名称
 
     join $2 $3 > /tmp/plot_diff.dat
-    openim::wrk::plot_diff `basename $2` `basename $3`
+    openim::wrk::plot_diff "$(basename "$2")" "$(basename "$3")"
     exit 0
     ;;
   *)