test: refactor run.sh to use common functestlib.sh functions

- Integrated log_info, log_pass, log_fail, log_error, and check_dependencies
- Ensured compatibility with both standalone and run-test.sh execution
- Improved maintainability and consistency across test suites

Signed-off-by: Srikanth Muppandam <[email protected]>

Author: smuppand

Runner/init_env

@@ -1,11 +1,32 @@
 #!/bin/sh
+
 # Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
 # SPDX-License-Identifier: BSD-3-Clause-Clear
 
-# Source this file to setup the test suite environment
-BASEDIR=$(pwd)
-export BASEDIR
-TOOLS=$(pwd)/utils
-export TOOLS
-SUITES=$(pwd)/suites
-export SUITES
+# Dynamically walk up to find the repo root containing both suites/ and utils/
+INIT_DIR="$(cd "$(dirname "$0")" && pwd)"
+ROOT_DIR="$INIT_DIR"
+
+while [ "$ROOT_DIR" != "/" ]; do
+    if [ -d "$ROOT_DIR/suites" ] && [ -d "$ROOT_DIR/utils" ]; then
+        break
+    fi
+    ROOT_DIR=$(dirname "$ROOT_DIR")
+done
+
+# Validate discovery
+if [ ! -d "$ROOT_DIR/suites" ] || [ ! -d "$ROOT_DIR/utils" ]; then
+    echo "[ERROR] Could not detect testkit root from init_env!" >&2
+    exit 1
+fi
+
+export ROOT_DIR
+export TOOLS="$ROOT_DIR/utils"
+export __RUNNER_SUITES_DIR="$ROOT_DIR/suites"
+export __RUNNER_UTILS_BIN_DIR="$ROOT_DIR/common"
+
+echo "[INFO] init_env loaded."
+echo "[INFO] ROOT_DIR=$ROOT_DIR"
+echo "[INFO] TOOLS=$TOOLS"
+echo "[INFO] __RUNNER_SUITES_DIR=$__RUNNER_SUITES_DIR"
+echo "[INFO] __RUNNER_UTILS_BIN_DIR=$__RUNNER_UTILS_BIN_DIR"

Runner/run-test.sh

@@ -3,70 +3,112 @@
 # Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
 # SPDX-License-Identifier: BSD-3-Clause-Clear
 
-# Import test suite definitions
-. "${PWD}"/init_env
+# Resolve the real path of this script
+SCRIPT_DIR="$(dirname "$(realpath "$0")")"
 
-#import test functions library
-. "${TOOLS}"/functestlib.sh
+# Set TOOLS path to utils under the script directory
+TOOLS="$SCRIPT_DIR/utils"
 
+# Safely source init_env from the same directory as this script
+if [ -f "$SCRIPT_DIR/init_env" ]; then
+    # shellcheck source=/dev/null
+    . "$SCRIPT_DIR/init_env"
+else
+    echo "[INFO] init_env not found at $SCRIPT_DIR/init_env — skipping."
+fi
 
-# Find test case path by name
-find_test_case_by_name() {
-    # Check if the file is a directory
-  if [ -d "$1" ]; then
-    # Get the directory name
-    dir_name_in_dir=${1##*/}
-
-    # Check if the directory name matches the user input
-    if [ "${dir_name_in_dir}" = "$test_name" ]; then
-      # Get the absolute path of the directory
-      abs_path=$(readlink -f "$1")
-      echo "$abs_path"  
-    fi
-  fi
+# Source functestlib.sh from utils/
+if [ -f "$TOOLS/functestlib.sh" ]; then
+    # shellcheck source=/dev/null
+    . "$TOOLS/functestlib.sh"
+	# Export key vars so they are visible to child scripts like ./run.sh
+	export ROOT_DIR
+	export TOOLS
+	export __RUNNER_SUITES_DIR
+	export __RUNNER_UTILS_BIN_DIR
+else
+    echo "[ERROR] functestlib.sh not found at $TOOLS/functestlib.sh"
+    exit 1
+fi
 
-  # Recursively search for the directory in the subdirectory
-  for file in "$1"/*; do
-    # Check if the file is a directory
-    if [ -d "$file" ]; then
-      # Recursively search for the directory in the subdirectory
-      find_test_case_by_name "$file"
-    fi
-  done
-}
+# Store results
+RESULTS_PASS=""
+RESULTS_FAIL=""
 
-# Execute a test case
 execute_test_case() {
     local test_path="$1"
+    local test_name
+    test_name=$(basename "$test_path")
+
     if [ -d "$test_path" ]; then
         run_script="$test_path/run.sh"
         if [ -f "$run_script" ]; then
-            log "Executing test case: $test_path"
-            sh "$run_script" 2>&1 
+            log "Executing test case: $test_name"
+            if (cd "$test_path" && sh "./run.sh"); then
+                log_pass "$test_name passed"
+                if [ -z "$RESULTS_PASS" ]; then
+                    RESULTS_PASS="$test_name"
+                else
+                    RESULTS_PASS=$(printf "%s\n%s" "$RESULTS_PASS" "$test_name")
+                fi
+            else
+                log_fail "$test_name failed"
+                if [ -z "$RESULTS_FAIL" ]; then
+                    RESULTS_FAIL="$test_name"
+                else
+                    RESULTS_FAIL=$(printf "%s\n%s" "$RESULTS_FAIL" "$test_name")
+                fi
+            fi
         else
-            log "No run.sh found in $test_path"
+            log_error "No run.sh found in $test_path"
+            RESULTS_FAIL=$(printf "%s\n%s" "$RESULTS_FAIL" "$test_name (missing run.sh)")
         fi
     else
-        log "Test case directory not found: $test_path"
+        log_error "Test case directory not found: $test_path"
+        RESULTS_FAIL=$(printf "%s\n%s" "$RESULTS_FAIL" "$test_name (directory not found)")
     fi
 }
 
-# Function to run a specific test case by name
 run_specific_test_by_name() {
-    test_name="$1"
-    test_path=$(find_test_case_by_name ".")
+    local test_name="$1"
+    local test_path
+    test_path=$(find_test_case_by_name "$test_name")
     if [ -z "$test_path" ]; then
-        log "Test case with name $test_name not found."
+        log_error "Test case with name $test_name not found."
+        RESULTS_FAIL=$(printf "%s\n%s" "$RESULTS_FAIL" "$test_name (not found)")
     else
         execute_test_case "$test_path"
     fi
 }
 
-# Main script logic
+run_all_tests() {
+    find "${__RUNNER_SUITES_DIR}" -type d -name '[A-Za-z]*' -maxdepth 3 | while IFS= read -r test_dir; do
+        if [ -f "$test_dir/run.sh" ]; then
+            execute_test_case "$test_dir"
+        fi
+    done
+}
+
+print_summary() {
+    echo
+    log_info "========== Test Summary =========="
+    echo "PASSED:"
+    [ -n "$RESULTS_PASS" ] && printf "%s\n" "$RESULTS_PASS" || echo " None"
+    echo
+    echo "FAILED:"
+    [ -n "$RESULTS_FAIL" ] && printf "%s\n" "$RESULTS_FAIL" || echo " None"
+    log_info "=================================="
+}
+
 if [ "$#" -eq 0 ]; then
     log "Usage: $0 [all | <testcase_name>]"
     exit 1
 fi
 
+if [ "$1" = "all" ]; then
+    run_all_tests
+else
+    run_specific_test_by_name "$1"
+fi
 
-run_specific_test_by_name "$1"
+print_summary

Runner/suites/Kernel/FunctionalArea/baseport/CPUFreq_Validation/run.sh

@@ -3,54 +3,77 @@
 # Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
 # SPDX-License-Identifier: BSD-3-Clause-Clear
 
-. "${PWD}/init_env"
-TESTNAME="CPUFreq_Validation"
-. "$TOOLS/functestlib.sh"
+# Dynamically find the testkit root by walking up from script dir
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+ROOT_DIR="$SCRIPT_DIR"
+
+while [ "$ROOT_DIR" != "/" ]; do
+    if [ -d "$ROOT_DIR/utils" ] && [ -d "$ROOT_DIR/suites" ]; then
+        break
+    fi
+    ROOT_DIR=$(dirname "$ROOT_DIR")
+done
+
+# Validate root detection
+if [ ! -d "$ROOT_DIR/utils" ] || [ ! -f "$ROOT_DIR/utils/functestlib.sh" ]; then
+    echo "[ERROR] Could not detect testkit root (missing utils/ or functestlib.sh)" >&2
+    exit 1
+fi
+
+TOOLS="$ROOT_DIR/utils"
+INIT_ENV="$ROOT_DIR/init_env"
+FUNCLIB="$TOOLS/functestlib.sh"
 
+# Source init_env if exists
+[ -f "$INIT_ENV" ] && . "$INIT_ENV"
+
+# Source functestlib.sh
+. "$FUNCLIB"
+
+# Export fallback for manual ./run.sh usage
+__RUNNER_SUITES_DIR="${__RUNNER_SUITES_DIR:-$ROOT_DIR/suites}"
+
+cd "$ROOT_DIR" || exit 1
+
+TESTNAME="CPUFreq_Validation"
 test_path=$(find_test_case_by_name "$TESTNAME")
+
 log_info "-----------------------------------------------------------------------------------------"
 log_info "-------------------Starting $TESTNAME Testcase----------------------------"
 log_info "=== CPUFreq Frequency Walker with Validation ==="
 
-# Color codes (ANSI escape sequences)
-GREEN="\033[32m"
-RED="\033[31m"
-YELLOW="\033[33m"
-BLUE="\033[34m"
-NC="\033[0m"
-
 NUM_CPUS=$(nproc)
-printf "${YELLOW}Detected %s CPU cores.${NC}\n" "$NUM_CPUS"
+log_info "Detected $NUM_CPUS CPU cores."
 
 overall_pass=0
 status_dir="/tmp/cpufreq_status.$$"
 mkdir -p "$status_dir"
 
 validate_cpu_core() {
-    local cpu=$1
-    local core_id=$2
+    local cpu="$1"
+    local core_id="$2"
     status_file="$status_dir/core_$core_id"
 
-    printf "${BLUE}Processing %s...${NC}\n" "$cpu"
+    log_info "Processing $cpu..."
 
     if [ ! -d "$cpu/cpufreq" ]; then
-        printf "${BLUE}[SKIP]${NC} %s does not support cpufreq.\n" "$cpu"
+        log_info "[SKIP] $cpu does not support cpufreq."
         echo "skip" > "$status_file"
         return
     fi
 
     available_freqs=$(cat "$cpu/cpufreq/scaling_available_frequencies" 2>/dev/null)
 
     if [ -z "$available_freqs" ]; then
-        printf "${YELLOW}[INFO]${NC} No available frequencies for %s. Skipping...\n" "$cpu"
+        log_info "[INFO] No available frequencies for $cpu. Skipping..."
         echo "skip" > "$status_file"
         return
     fi
 
-    if echo "userspace" | tee "$cpu/cpufreq/scaling_governor" > /dev/null; then
-        printf "${YELLOW}[INFO]${NC} Set governor to userspace.\n"
+    if echo "userspace" > "$cpu/cpufreq/scaling_governor"; then
+        log_info "[INFO] Set governor to userspace."
     else
-        printf "${RED}[ERROR]${NC} Cannot set userspace governor for %s.\n" "$cpu"
+        log_error "Cannot set userspace governor for $cpu."
         echo "fail" > "$status_file"
         return
     fi
@@ -59,23 +82,23 @@ validate_cpu_core() {
 
     for freq in $available_freqs; do
         log_info "Setting $cpu to frequency $freq kHz..."
-        if echo "$freq" | tee "$cpu/cpufreq/scaling_setspeed" > /dev/null; then
+        if echo "$freq" > "$cpu/cpufreq/scaling_setspeed"; then
             sleep 0.2
             actual_freq=$(cat "$cpu/cpufreq/scaling_cur_freq")
             if [ "$actual_freq" = "$freq" ]; then
-                printf "${GREEN}[PASS]${NC} %s set to %s kHz.\n" "$cpu" "$freq"
+                log_info "[PASS] $cpu set to $freq kHz."
             else
-                printf "${RED}[FAIL]${NC} Tried to set %s to %s kHz, but current is %s kHz.\n" "$cpu" "$freq" "$actual_freq"
+                log_error "[FAIL] Tried to set $cpu to $freq kHz, but current is $actual_freq kHz."
                 echo "fail" > "$status_file"
             fi
         else
-            printf "${RED}[ERROR]${NC} Failed to set %s to %s kHz.\n" "$cpu" "$freq"
+            log_error "[ERROR] Failed to set $cpu to $freq kHz."
             echo "fail" > "$status_file"
         fi
     done
 
-    echo "Restoring $cpu governor to 'ondemand'..."
-    echo "ondemand" | sudo tee "$cpu/cpufreq/scaling_governor" > /dev/null
+    log_info "Restoring $cpu governor to 'ondemand'..."
+    echo "ondemand" > "$cpu/cpufreq/scaling_governor"
 }
 
 cpu_index=0
@@ -93,34 +116,36 @@ for status_file in "$status_dir"/core_*; do
     status=$(cat "$status_file")
     case "$status" in
         pass)
-            printf "CPU%s: ${GREEN}[PASS]${NC}\n" "$idx"
+            log_info "CPU$idx: [PASS]"
             ;;
         fail)
-            printf "CPU%s: ${RED}[FAIL]${NC}\n" "$idx"
+            log_error "CPU$idx: [FAIL]"
             overall_pass=1
             ;;
         skip)
-            printf "CPU%s: ${BLUE}[SKIPPED]${NC}\n" "$idx"
+            log_info "CPU$idx: [SKIPPED]"
             ;;
         *)
-            printf "CPU%s: ${RED}[UNKNOWN STATUS]${NC}\n" "$idx"
+            log_error "CPU$idx: [UNKNOWN STATUS]"
             overall_pass=1
             ;;
     esac
 done
 
 log_info ""
 log_info "=== Overall CPUFreq Validation Result ==="
+
+res_file="$test_path/$TESTNAME.res"
 if [ "$overall_pass" -eq 0 ]; then
-    printf "${GREEN}[OVERALL PASS]${NC} All CPUs validated successfully.\n"
     log_pass "$TESTNAME : Test Passed"
-    echo "$TESTNAME PASS" > "$test_path/$TESTNAME.res"
+    log_info "Writing PASS to $res_file"
+    echo "$TESTNAME PASS" > "$res_file"
     rm -r "$status_dir"
     exit 0
 else
-    printf "${RED}[OVERALL FAIL]${NC} Some CPUs failed frequency validation.\n"
     log_fail "$TESTNAME : Test Failed"
-    echo "$TESTNAME FAIL" > "$test_path/$TESTNAME.res"
+    log_info "Writing FAIL to $res_file"
+    echo "$TESTNAME FAIL" > "$res_file"
     rm -r "$status_dir"
     exit 1
 fi