lib_bmc_com.exp
#JimmyChang
#==================================================
#proc : DUT
#==================================================
proc pre_arg_check {} {
global testcase filetime auto_log_name dbg_log_name runtimes timeout error_message error_report send_slow starti dut_num DUT_model dut_num DUT_port work_dir iteration rtm
if { $dut_num == "" || $DUT_port == "" || $iteration =="" || $rtm == ""} {
set iii $iteration
send_user "\ndut_num = $dut_num\n"
send_user "DUT_port = $DUT_port\n"
send_user "iteration = $iteration\n"
#rtm = 1 = true, rtm = 0 = false
send_user "rtm = $rtm\n"
send_user "please input \$dut_num, \$DUT_port , \$iteration , \$rtm variables for testing ........., thanks"
send_user "\"e.g. expect 0.exp \"13\" \"3313\" "
sleep 2
exit
}
}
proc pre_config {{run 1}} {
#global testcase filetime auto_log_name dbg_log_name runtimes timeout error_message error_report send_slow starti
global testcase filetime log_a auto_log_name dbg_log_name runtimes timeout error_message error_report send_slow starti dut_num DUT_model dut_num DUT_port work_dir iteration fail_iteration baK_timeout
pre_arg_check
#append auto_log_name "$testcase" "_auto_$filetime"
#append dbg_log_name "$testcase" "_dbg_$filetime"
append auto_log_name "$testcase" "_$DUT_model" "_dut-$dut_num" "_auto_$filetime"
## for debug log
##append dbg_log_name "$testcase" "_$DUT_model" "_dut-$dut_num" "_dbg_$filetime"
set log_a [open ./log/$auto_log_name.log w]
log_file -a -noappend ./log/$auto_log_name.log
## for debug log
## exec echo "" > ./log/$dbg_log_name.log
## exp_internal -f ./log/$dbg_log_name.log 0
set starti 1
#20170622 jimmy : new argv for iteration
if { $iteration != ""} {
set runtimes "$iteration"
} else {
set runtimes "$run"
}
#20170622 jimmy : new argv for iteration
set timeout 300
set baK_timeout 0
#set timeout 3600
set send_slow {1 .01}
trap error_report {SIGINT }
set error_message ""
set fail_iteration ""
}
proc bmc_debug_console_login {} {
global bmc_debug_console_prompt bmc_debug_console_user bmc_debug_console_pw bmc_debug_console_port
puts "\nrunning proc bmc_debug_console_login {}"
sleep_sec 1
send -s "telnet 0 $bmc_debug_console_port\r"
send -s "\r\r\r"
expect {
"this is ser2net TCP port*" { send "\r" ; exp_continue}
"rhel7-x86_64 login:" { send "$bmc_debug_console_user\r" ; exp_continue}
"Password:" { send "$bmc_debug_console_pw\r" ; exp_continue}
"$bmc_debug_console_prompt" { sendU_log "bmc_debug_console_login : pass\n" ; send "tail -f /var/log/debug\r";exp_continue}
#$Con_server_prompt { sendU_log "bmc_debug_console_login : pass\n"}
default {append error_message "bmc_debug_console_login : fail\n" ; exit}
}
send -s "\r"
#set send_slow {1 .1}
}
proc DUT_login {} {
global DUT_prompt DUT_port dut_linux_user dut_linux_pw Con_server_prompt login_prompt DUT_login
#puts "\nrunning proc DUT_login {}"
#sleep_sec 1
send -s "telnet 0 $DUT_port\r"
#send -s "\r\r\r"
#ctrl c
#send -s "\003"
expect {
"this is ser2net TCP port*" { send "\r" ; exp_continue}
#"*WARNNING!!! THIS IMAGE IS FOR INTERNAL USE ONLY*" { send "\r" ; exp_continue}
"Started AE 7" { send "\r" ; exp_continue}
"$login_prompt" { send "$dut_linux_user\r" ; exp_continue}
#-ex "(yes/no)?" { send "yes\r"; exp_continue}
"Password:" { send "$dut_linux_pw\r" ; exp_continue}
"$DUT_prompt" { sendU_log "DUT_login : pass\n"}
#$Con_server_prompt { sendU_log "DUT_login : pass\n"}
default {append error_message "DUT_login : fail\n" ; exit}
}
send -s "\r"
}
proc SHMM_login {} {
global DUT_prompt DUT_port dut_linux_user dut_linux_pw Con_server_prompt login_prompt DUT_login
#puts "\nrunning proc DUT_login {}"
#sleep_sec 1
send -s "telnet 0 $DUT_port\r"
#send -s "\r\r\r"
#ctrl c
#send -s "\003"
expect {
"this is ser2net TCP port*" { send "\r" ; exp_continue}
#"*WARNNING!!! THIS IMAGE IS FOR INTERNAL USE ONLY*" { send "\r" ; exp_continue}
"Started AE 7" { send "\r" ; exp_continue}
"$login_prompt" { send "$dut_linux_user\r" ; exp_continue}
#-ex "(yes/no)?" { send "yes\r"; exp_continue}
"Password:" { send "$dut_linux_pw\r" ; exp_continue}
"$DUT_prompt" { sendU_log "DUT_login : pass\n"}
#$Con_server_prompt { sendU_log "DUT_login : pass\n"}
default {append error_message "DUT_login : fail\n" ; exit}
}
send -s "\r"
}
proc uboot_login {} {
global DUT_prompt DUT_port dut_linux_user dut_linux_pw Con_server_prompt login_prompt LMP_uboot_prompt
send -s "telnet 0 $DUT_port\r"
expect {
"this is ser2net TCP port*" { send "\r" ; exp_continue}
"$LMP_uboot_prompt" { sendU_log "uboot_login : pass\n"}
default {append error_message "uboot_login : fail\n" ; exit}
}
send -s "\r"
}
proc uboot_logout {} {
global error_message DUT_prompt sendU_log LMP_uboot_prompt
puts "\nrunning proc DUT_logout {}"
expect {
$LMP_uboot_prompt {
send -s "\x1d"
sleep_sec 1
expect {
"telnet>" {send -s "q\r\r";sendU_log "uboot_logout : pass\n"}
default { sendU_log "uboot_logout : fail\n";append error_message "uboot_logout : fail\n"}
}
}
}
}
proc IPMC_debug_console_login {} {
global DUT_prompt DUT_port dut_linux_user dut_linux_pw Con_server_prompt login_prompt DUT_login ipmc_debug_port bmc_debug_console_prompt
#puts "\nrunning proc IPMC_debug_console_login {}"
#sleep_sec 1
send -s "telnet 0 $ipmc_debug_port\r"
#send -s "\r\r\r"
#ctrl c
#send -s "\003"
expect {
"this is ser2net TCP port*" { send "\r"; exp_continue }
#"CLI*" { send "\r" }
#"Started AE 7" { send "\r" ; exp_continue}
#"$login_prompt" { send "$dut_linux_user\r" ; exp_continue}
#-ex "(yes/no)?" { send "yes\r"; exp_continue}
#"Password:" { send "$dut_linux_pw\r" ; exp_continue}
#"$DUT_prompt" { sendU_log "DUT_login : pass\n"}
$bmc_debug_console_prompt { sendU_log "IPMC_debug_console_login : pass\n"}
default {append error_message "IPMC_debug_console_login : fail\n" ; exit}
}
}
proc IPMC_debug_console_logout {} {
global error_message DUT_prompt sendU_log ipmc_debug_port bmc_debug_console_promp
puts "\nrunning proc IPMC_debug_console_logout {}"
send -s "\x1d"
sleep_sec 1
expect {
"telnet>" {send -s "q\r\r";sendU_log "IPMC_debug_console_logout : pass\n"}
default { sendU_log "IPMC_debug_console_logout : fail\n";append error_message "IPMC_debug_console_logout : fail\n"}
}
}
proc SOL_login {} {
global DUT_prompt DUT_port dut_linux_user dut_linux_pw Con_server_prompt BMC_ip BMC_user BMC_pw
puts "\nrunning proc SOL_login {}"
Con_server_send "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw raw 0x2C 0x47 0x00 0x01 0x00" "$Con_server_prompt "
Con_server_send "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sol activate " "Use ~?"
send -s "\r\r\r"
expect {
#"*this is ser2net TCP port*" { send "\r" ; exp_continue}
"*WARNNING!!! THIS IMAGE IS FOR INTERNAL USE ONLY*" { send "\r" ; exp_continue}
"*login: " { send "$dut_linux_user\r" ; exp_continue}
#-ex "(yes/no)?" { send "yes\r"; exp_continue}
"Password:" { send "$dut_linux_pw\r" ; exp_continue}
"$DUT_prompt" { sendU_log "DUT_login : pass\n"}
#$Con_server_prompt { sendU_log "DUT_login : pass\n"}
default {append error_message "DUT_login : fail\n" ; exit}
}
send -s "\r\r\r\r\r"
}
proc SOL_logout {} {
global DUT_prompt DUT_port dut_linux_user dut_linux_pw Con_server_prompt
puts "\nrunning proc SOL_logout {}"
send -s "\x7e\x2e\r"
expect {
"*command not found*" { send "\x7e\x2e\r" ; exp_continue}
"*terminated ipmitool*" { send "\r\r" ; exp_continue}
$Con_server_prompt { sendU_log "sol exit : pass\n"}
#default {append error_message "sol exit : fail\n" ; exit}
}
console_ssh_login
}
proc DUT_ssh_login {} {
global con_server_ip1 con_server_ip2 spawn_id error_message lmp_login lmp_linux bcn_type Con_server_prompt con_server_user con_server_pw OS_ip dut_linux_pw DUT_prompt
puts "\nrunning proc DUT_ssh_login {}"
send -s "ssh root@$OS_ip\r"
expect {
-ex "(yes/no)?" { send "yes\r"; exp_continue}
"*?assword:*" { send "$dut_linux_pw\r" ; exp_continue}
"$DUT_prompt" { sendU_log "enter dut via ssh:pass\n"}
default {append error_message "enter dut via ssh : fail\n" ; break }
}
sendU_log "console ssh Login : pass\n"
}
proc DUT_login_1005 {} {
global DUT_prompt DUT_port dut_linux_user dut_linux_pw Con_server_prompt
puts "\nrunning proc DUT_login {}"
sleep_sec 1
send -s "telnet 0 $DUT_port\r"
send -s "\r\r\r"
expect {
"Starting File System Check on" { send "\r\r\r" ; exp_continue}
"*this is ser2net TCP port*" { send "\r" ; exp_continue}
"*login*" { send "$dut_linux_user\r" ; exp_continue}
#-ex "(yes/no)?" { send "yes\r"; exp_continue}
"Password:" { send "$dut_linux_pw\r" ; exp_continue}
"$DUT_prompt" { sendU_log "DUT_login : pass\n"}
#$Con_server_prompt { sendU_log "DUT_login : pass\n"}
default {append error_message "DUT_login : fail\n" ; exit}
}
send -s "\r"
}
proc DUT_logout {} {
global error_message DUT_prompt sendU_log
puts "\nrunning proc DUT_logout {}"
expect {
$DUT_prompt {
send -s "\x1d"
sleep_sec 1
expect {
"telnet>" {send -s "q\r\r";sendU_log "DUT_logout : pass\n"}
default { sendU_log "DUT_logout : fail\n";append error_message "DUT_logout : fail\n"}
}
}
}
}
proc DUT_logout_2 {} {
global error_message DUT_prompt sendU_log
puts "\nrunning proc DUT_logout_2 {}"
send -s "\x1d"
sleep_sec 1
expect {
"telnet>" {send -s "q\r\r";sendU_log "DUT_logout_2 : pass\n"}
default { sendU_log "DUT_logout_2 : fail\n";append error_message "DUT_logout_2 : fail\n"}
}
}
proc test_start {} {
global test_time_1 filetime
set test_time_1 [clock seconds]
send_user "\n========================================================================"
send_user "\n The test START time is (YYMMDD_HMS): [clock format $test_time_1 -format %Y%m%d_%H%M%S]"
send_user "\n========================================================================\n"
set filetime [clock format $test_time_1 -format %Y%m%d_%H%M%S]
puts $filetime
}
proc test_finish {} {
global test_time_2 test_time_1
set test_time_2 [clock seconds]
set test_duration [ expr $test_time_2 - $test_time_1 ]
send_user "\n========================================================================"
send_user "\n The test FINISHED time is (YYMMDD_HMS): [clock format $test_time_2 -format %Y%m%d_%H%M%S]"
send_user "\n The test DURATION are $test_duration seconds "
send_user "\n========================================================================\n"
test_server_ssh_login
}
#rtm is from "set rtm [lindex $argv 3]" in config.tcl
proc sel_clear_ver_check {{sleep_time 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt bmc_lan_interface shmm_ip ipmb_addr shmm_prompt slot_num rtm_fru_file ipmitool_ver BSP_VERSION_INFO rtm fail_iteration bl_ver ipmc_ver fpga_ver bios_ver nvram_ver rtm_bootloader_ver rtm_mmc_ver rtm_cpld_ver
send_user "\n========================================================================"
send_user "\n START : sel_clear_ver_check"
send_user "\n========================================================================\n"
expect {
$DUT_prompt {
Send_expectout "cat /proc/BSP_VERSION_INFO" "cat(.*)$DUT_prompt" "*$BSP_VERSION_INFO*"
Send_expectout "unset MAILCHECK" "unset(.*)$DUT_prompt" "*"
Send_expectout "ipmitool picmg addrinfo" "ipmitool(.*)$DUT_prompt" "*"
Send_expectout "ipmitool -V" "ipmitool(.*)$DUT_prompt" "*$ipmitool_ver*"
Send_expectout "ipmitool fru" "ipmitool(.*)$DUT_prompt" "*"
Send_expectout "ipmitool hpm check" "ipmitool(.*)$DUT_prompt" "*ACPI6 BL*$bl_ver*ACPI6 IPMC*$ipmc_ver*ACPI6 FPGA*$fpga_ver*ACPI6 BIOS*$bios_ver*ACPI6 NVRAM*$nvram_ver*"
Send_expectout "ipmitool mc info" "ipmitool(.*)$DUT_prompt" "*"
Send_expectout "ipmitool channel info" "ipmitool(.*)$DUT_prompt" "*"
Send_expectout "ipmitool sel clear " "ipmitool(.*)$DUT_prompt" "*"
Send_expectout "ipmitool sel time get " "ipmitool(.*)$DUT_prompt" "*"
Send_expectout "ipmitool sel elist " "ipmitool(.*)$DUT_prompt" "*"
Send_expectout "dmesg -C " "dmesg(.*)$DUT_prompt" "*"
if { $rtm == 1 } {
Send_expectout "ipmitool -b 7 -t 0xa6 hpm check" "ipmitool(.*)$DUT_prompt" "*CPRT6 BL*$rtm_bootloader_ver*CPRT6 MMC*$rtm_mmc_ver*CPRT6 CPLD*$rtm_cpld_ver*"
Send_expectout "ipmitool -b 7 -t 0xa6 mc info" "ipmitool(.*)$DUT_prompt" "*"
Send_expectout "ipmitool -b 7 -t 0xa6 channel info" "ipmitool(.*)$DUT_prompt" "*"
Send_expectout "ipmitool -b 7 -t 0xa6 sel clear " "ipmitool(.*)$DUT_prompt" "*"
Send_expectout "ipmitool -b 7 -t 0xa6 sel elist " "ipmitool(.*)$DUT_prompt" "*"
} else {
send_user "\nthere is no rtm board\n"
}
send_user "\n========================================================================"
send_user "\n END : sel_clear_ver_check"
send_user "\n========================================================================\n"
}
}
}
proc ver_check {{sleep_time 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt bmc_lan_interface shmm_ip ipmb_addr shmm_prompt slot_num rtm_fru_file
send_user "\n========================================================================"
send_user "\n START : ver_check"
send_user "\n========================================================================\n"
expect {
$DUT_prompt {
DUT_send "cat /proc/BSP_VERSION_INFO" "$DUT_prompt"
DUT_ipmitool 1 "picmg addrinfo" "$DUT_prompt"
DUT_ipmitool 1 "-V" "1.8.18"
#hpm check
DUT_ipmitool 1 "hpm check " "$DUT_prompt"
DUT_ipmitool 1 "-b 7 -t 0xa6 hpm check " "$DUT_prompt"
#mc info
DUT_ipmitool 1 "mc info" "$DUT_prompt"
#channel info
DUT_ipmitool 1 "channel info" "$DUT_prompt"
DUT_ipmitool 1 "-b 7 -t 0xa6 channel info" "$DUT_prompt"
#sel
DUT_ipmitool 1 "sel time get " "$DUT_prompt"
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
DUT_ipmitool 1 "-b 7 -t 0xa6 sel elist " "$DUT_prompt"
send_user "\n========================================================================"
send_user "\n END : ver_check"
send_user "\n========================================================================\n"
}
}
}
proc basic_info_check_acpi6 {{sleep_time 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt bmc_lan_interface shmm_ip ipmb_addr shmm_prompt slot_num
send_user "\n========================================================================"
send_user "\n START : basic_info_check_acpi6"
send_user "\n========================================================================\n"
send -s "\r"
expect {
$DUT_prompt {
DUT_send "dmidecode -t system |grep -v '#'|grep -i version" "$DUT_prompt"
DUT_send "dmidecode -t baseboard |grep -v '#'|grep -i version" "$DUT_prompt"
DUT_send "dmidecode -t bios |grep -v '#'|grep -i version" "$DUT_prompt"
DUT_send "dmidecode -t processor |grep -v '#'|grep -i version" "$DUT_prompt"
DUT_send "dmidecode -t cache |grep -i installed" "$DUT_prompt"
DUT_send "dmidecode -t memory |grep -v '#'|grep Size:" "$DUT_prompt"
DUT_send "dmesg |grep -i emerg" "$DUT_prompt"
DUT_send "dmesg |grep -i alert" "$DUT_prompt"
DUT_send "dmesg |grep -i crit" "$DUT_prompt"
DUT_send "dmesg |grep -i error" "$DUT_prompt"
DUT_send "dmesg |grep -i fail" "$DUT_prompt"
DUT_send "dmesg |grep -i \"call trace\"" "$DUT_prompt"
DUT_send "dmesg |grep -i \"ipmi\"" "$DUT_prompt"
DUT_fail_expectout 1 "dmesg |grep -i fail |tail -100" "tail(.*)$DUT_prompt" "*fail*"
DUT_fail_expectout 1 "dmesg |grep -i error |tail -100" "tail(.*)$DUT_prompt" "*error*"
DUT_fail_expectout 1 "dmesg |grep -i \"call trace\"|tail -100" "tail(.*)$DUT_prompt" "*call trace*"
DUT_ipmitool 1 "mc selftest" "Selftest: passed"
#DUT_ipmitool 1 "mc info" "$DUT_prompt"
#lan info
DUT_ipmitool 1 "lan print $bmc_lan_interface" "$DUT_prompt"
#DUT_oem_adv_bmc_bank_info
DUT_ipmitool 1 "raw 0x2e 0x71 0x39 0x28 0x00 0x00 " "$DUT_prompt"
#DUT_oem_adv_bios_bank_info
DUT_ipmitool 1 "raw 0x2e 0x71 0x39 0x28 0x00 0x01 " "$DUT_prompt"
#fru control properties
DUT_ipmitool 1 "raw 0x2c 0x1e 0x00 0x00" "00 0c"
#fru info
DUT_ipmitool 1 "fru print " "$DUT_prompt"
#sensor info
DUT_ipmitool 1 "sensor list " "$DUT_prompt"
DUT_ipmitool 1 "sdr elist " "$DUT_prompt"
#hw info
#DUT_send "lspci " "$DUT_prompt"
#DUT_send "lspci |wc -l " "$DUT_prompt"
#DUT_send "cat /proc/cpuinfo " "$DUT_prompt"
#DUT_send "cat /proc/meminfo" "$DUT_prompt"
DUT_send "fdisk -l" "$DUT_prompt"
DUT_send "df -h" "$DUT_prompt"
#get mc info check via IOL
#send ipmi command via iol lanplus to get mc info:
DUT_ipmitool 2 "mc info" "$Con_server_prompt"
#send ipmi command via iol lan to get mc info:
DUT_ipmitool 3 "mc info" "$Con_server_prompt"
#####
#get mc info via IPMB-0 and IPMB-L
#send ipmi command via ipmb-0 to get mc info:
DUT_logout
Con_server_send "ipmitool -I lan -H $shmm_ip -A none -t $ipmb_addr -b 0 mc info" "$Con_server_prompt"
#send ipmi command via ipmb-0 and ipmb-L to get rtm mc info:
#Con_server_send "ipmitool -I lan -H $shmm_ip -A none -T $ipmb_addr -B 0 -b 7 -t 0xa6 mc info" "$Con_server_prompt"
DUT_login
#####
#####
#get board info via ATCA shmm
DUT_logout
console_ssh_login
Shmm_ssh_login
Shmm_send "clia ipmc -v $ipmb_addr" "$shmm_prompt"
Shmm_send "clia board $slot_num"
Shmm_ssh_logout
#ATCA shmm
#####
DUT_login
#DUT_sel_get 1
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
send_user "\n========================================================================"
send_user "\n END : basic_info_check_acpi6"
send_user "\n========================================================================\n"
}
}
}
proc time_sync {{sub_function *} {expected_result *} {sub_test_case default_none} {sleep_time 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt test_server_ip2
puts "\nrunning proc time_sync { sub_function = $sub_function }"
if { $sub_function != " " } {
Send_expectout "ntpdate $test_server_ip2" "ntpdate(.*)$DUT_prompt" "*"
Send_expectout "sudo timedatectl set-timezone Asia/Taipei" "timedatectl(.*)$DUT_prompt" "*"
Send_expectout "ipmitool sel time set \"`date +\"%m/%d/%Y %H:%M:%S\"`\"" "ipmitool(.*)$DUT_prompt" "*"
Send_expectout "ipmitool sel time get" "ipmitool(.*)$DUT_prompt" "*"
Send_expectout "hwclock -r" "hwclock(.*)$DUT_prompt" "*"
Send_expectout "hwclock -w" "hwclock(.*)$DUT_prompt" "*"
Send_expectout "hwclock -r" "hwclock(.*)$DUT_prompt" "*"
} else {
puts "please provide sub-function for testing"
}
}
#this function is not using "regular expression", so if expected result fail, the auto test will wait for time_out, around 300, but it's simple to use
proc Send_expect {{sub_function *} {expected_result *} {sub_test_case none}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt
puts "\nrunning proc Send { sub_function = $sub_function }"
if { $sub_function != " " } {
send -s "$sub_function\r"
expect {
"$expected_result" {sendU_log "\nCase discription : $sub_test_case\nExpected string match ($expected_result) : pass\n"}
default { sendU_log "\nCase discription : $sub_test_case\nExpected string match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"}
}
} else {
puts "please provide sub-function for testing"
}
}
#it's powerful, but need "regular expression" for each case
proc Send_expectout {{sub_function *} {reg *} {expected_result *} {sub_test_case none} {failexit 0} {reset_timeout 300}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt expectout starti fail_iteration baK_timeout spawn_id testcase
puts "\nrunning proc Send_expectout {}"
if { $sub_function != "" } {
match_max 100000000
set timeout $reset_timeout
send_user "debug info: new command($sub_function) for expect timeout = $timeout"
send -s "$sub_function\r"
expect {
-re "$reg" {set expectout $expect_out(0,string);send -s "\r"}
default { sendU_log "reg = $reg; \"Expect Result\" doesn't match regular expression: fail\n";append error_message "reg = $reg;it doesn't match regular expression: (fail)\n"}
}
if {[string match $expected_result $expectout ]==1} {
sendU_log "\nspawn_id = $spawn_id\ntimeout for this expect : $timeout\nCase description : $sub_test_case\nExpected string match ($expected_result) \nExpected string match result : (pass)\n"
send_user "\n===============\[Issues History Count\]===============\n"
send_user "Testcase = $testcase\n"
send_user "The history of error_message buffer = $fail_iteration"
send_user "\n===============\[Issues History Count\]===============\n"
} else {
sendU_log "\nspawn_id = $spawn_id\ntimeout for this expect : $timeout\nCase description : $sub_test_case\nExpected string match ($expected_result) \nExpected string match result : (fail)\n";append fail_iteration "\nissue at iteration:$starti \n";append error_message "\nstring match : fail\n"
send_user "expected_result = $expected_result\n"
send_user "expectout = $expectout\n"
set expectout_failexit 1
if { $failexit == 1 && $expectout_failexit == 1 } {
send_user "\n===========================================\n"
send_user "Test has issue then exit"
send_user "\n===========================================\n"
exit
} else {
send_user "\n===========================================\n"
send_user "Test has issue but continue testing"
send_user "\n===========================================\n"
}
}
} else {
send_user "debug info: please provide sub-function for testing"
}
# the default value for baK_timeout is 0(it's set in pre_config {} ), for some special case timeout is defined in test case script, so it's needed to be backup in test case script
if { $baK_timeout != 0} {
set timeout $baK_timeout
send_user "debug info: test finished : set to baktimeout : $baK_timeout"
} else {
send_user "debug info: test finished : set timeout to 300"
set timeout 300
}
}
proc Send_expectout_stringmatch_fail {{sub_function *} {reg *} {expected_result *} {sub_test_case none} {failexit 0}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt expectout starti fail_iteration
puts "\nrunning proc Send_expectout_stringmatch_fail {}"
if { $sub_function != "" } {
match_max 20000
send -s "$sub_function\r"
expect {
-re "$reg" {set expectout $expect_out(0,string);send -s "\r"}
}
if {[string match $expected_result $expectout ]==1} {
#sendU_log "\nCase description : $sub_test_case\nExpected string match ($expected_result) \nExpected string match result : pass\n"
sendU_log "\nspawn_id = $spawn_id\nCase description : $sub_test_case\nExpected string match ($expected_result) \nExpected string match result : (fail)\n";append fail_iteration "\nissue at iteration:$starti \n";append error_message "\nstring match : fail\n"
set expectout_failexit 1
if { $failexit == 1 && $expectout_failexit == 1 } {
send_user "\n===========================================\n"
send_user "Test fail then exit"
send_user "\n===========================================\n"
exit
} else {
send_user "\n===========================================\n"
send_user "Test fail but continue testing"
send_user "\n===========================================\n"
}
} else {
#sendU_log "\nCase description : $sub_test_case\nExpected string match ($expected_result) \nExpected string match result : fail\n";append fail_iteration "\nissue at iteration:$starti \n";append error_message "\nstring match : fail\n"
sendU_log "\nspawn_id = $spawn_id\nCase description : $sub_test_case\nExpected string match ($expected_result) \nExpected string match result : (pass)\n"
send_user "expected_result = $expected_result\n"
send_user "expectout = $expectout\n"
}
} else {
send_user "please provide sub-function for testing"
}
}
#it's almost same as function of "DUT_ipmitool"
proc DUT_send {{sub_function *} {expected_result *} {sub_test_case default_none} {sleep_time 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt
puts "\nrunning proc DUT_send { sub_function = $sub_function }"
expect {
$DUT_prompt {
if { $sub_function != " " } {
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
send -s "$sub_function\r"
sleep_sec "$sleep_time"
expect {
"$expected_result" {sendU_log "DUT_send $sub_function expected_result = $expected_result: pass\n"}
default { sendU_log "DUT_send $sub_function expected_result=$expected_result: fail\n";append error_message "DUT_send $sub_function expected_result=$expected_result: fail\n"}
}
} else {
puts "please provide sub-function for testing"
}
}
}
}
proc Con_server_send {{sub_function *} {expected_result *} {sub_test_case default_none} {sleep_time 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt
puts "\nrunning proc Con_server_send { sub_function = $sub_function }"
expect {
$Con_server_prompt {
if { $sub_function != " " } {
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
send -s "$sub_function\r"
sleep_sec "$sleep_time"
expect {
"$expected_result" {sendU_log "Con_server_send $sub_function expected_result = $expected_result: pass\n"}
default { sendU_log "Con_server_send $sub_function expected_result=$expected_result: fail\n";append error_message "Con_server_send $sub_function expected_result=$expected_result: fail\n"}
}
} else {
puts "please provide sub-function for testing"
}
sleep_sec 2
}
}
}
proc Test_server_send {{sub_function *} {expected_result *} {sub_test_case default_none} {sleep_time 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Test_server_prompt
puts "\nrunning proc Test_server_send { sub_function = $sub_function }"
expect {
$Test_server_prompt {
if { $sub_function != " " } {
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
send -s "$sub_function\r"
sleep_sec "$sleep_time"
expect {
"$expected_result" {sendU_log "Test_server_send $sub_function expected_result = $expected_result: pass\n"}
default { sendU_log "Test_server_send $sub_function expected_result=$expected_result: fail\n";append error_message "Test_server_send $sub_function expected_result=$expected_result: fail\n"}
}
} else {
puts "please provide sub-function for testing"
}
sleep_sec 2
}
}
}
proc DUT_ipmitool {{check_id 1} {sub_function *} {expected_result *} {sub_test_case default_none} {sleep_time1 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt
#puts "\nrunning proc DUT_ipmitool { sub_function = $sub_function }"
#puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
if { $sub_function != "" } {
send -s "ipmitool $sub_function\r"
sleep_sec $sleep_time1
expect {
"$expected_result" {sendU_log "DUT_ipmitool $sub_function expected_result = $expected_result: pass\n"}
default { sendU_log "DUT_ipmitool $sub_function expected_result = $expected_result: fail\n";append error_message "DUT_ipmitool $sub_function expected_result = $expected_result: fail\n"}
}
sleep_sec 1
} else {
puts "please provide sub-function for testing"
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw $sub_function\r"
sleep_sec $sleep_time1
expect {
"$expected_result" {sendU_log "DUT_ipmitool $sub_function expected_result = $expected_result: pass\n"}
default { sendU_log "DUT_ipmitool $sub_function expected_result = $expected_result: fail\n";append error_message "DUT_ipmitool $sub_function expected_result = $expected_result: fail\n"}
}
sleep_sec 1
DUT_login
}
3 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw $sub_function\r"
sleep_sec $sleep_time1
expect {
"$expected_result" {sendU_log "DUT_ipmitool $sub_function expected_result = $expected_result: pass\n"}
default { sendU_log "DUT_ipmitool $sub_function expected_result = $expected_result: fail\n";append error_message "DUT_ipmitool $sub_function expected_result = $expected_result: fail\n"}
}
sleep_sec 1
DUT_login
}
default {puts "do nothing!";}
}
}
}
}
proc DUT_ipmitool_multi_expected {{check_id 1} {sub_function *} {expected_result1 *} {expected_result2 *}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt
puts "\nrunning proc DUT_ipmitool_multi_expected {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
if { $sub_function != "" } {
send -s "ipmitool $sub_function\r"
sleep_sec 2
expect {
"$expected_result1" {sendU_log "DUT_ipmitool_multi_expected $sub_function expected_result1 = $expected_result1: pass\n" ; exp_continue }
"$expected_result2" {sendU_log "DUT_ipmitool_multi_expected $sub_function expected_result2 = $expected_result2: fail\n" ; exp_continue }
"$DUT_prompt" {sendU_log "DUT_ipmitool_multi_expected $sub_function : pass\n" }
default { sendU_log "DUT_ipmitool_multi_expected $sub_function expected_result1 = $expected_result1: fail\n";append error_message "DUT_ipmitool_multi_expected $sub_function : fail\n"}
}
sleep_sec 1
} else {
puts "please provide mc watchdog sub-function for testing"
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw $sub_function\r"
sleep_sec 2
expect {
"$expected_result1" {sendU_log "DUT_ipmitool_multi_expected $sub_function expected_result1 = $expected_result1: pass\n" ; exp_continue }
"$expected_result2" {sendU_log "DUT_ipmitool_multi_expected $sub_function expected_result2 = $expected_result2: fail\n" ; exp_continue }
"$DUT_prompt" {sendU_log "DUT_ipmitool_multi_expected $sub_function : pass\n" }
default { sendU_log "DUT_ipmitool_multi_expected $sub_function expected_result1 = $expected_result1: fail\n";append error_message "DUT_ipmitool_multi_expected $sub_function : fail\n"}
}
sleep_sec 1
DUT_login
}
default {puts "do nothing!";}
}
}
}
}
proc DUT_send_multi_expected {{check_id 1} {sub_function *} {expected_result1 *} {expected_result2 *}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt
puts "\nrunning proc DUT_send_multi_expected {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
if { $sub_function != "" } {
send -s "$sub_function\r"
sleep_sec 2
expect {
"$expected_result1" {sendU_log "DUT_send_multi_expected $sub_function expected_result1 = $expected_result1: pass\n" ; exp_continue }
"$expected_result2" {sendU_log "DUT_send_multi_expected $sub_function expected_result2 = $expected_result2: fail\n" ; exp_continue }
"$DUT_prompt" {sendU_log "DUT_send_multi_expected $sub_function : pass\n" }
default { sendU_log "DUT_send_multi_expected $sub_function expected_result1 = $expected_result1: fail\n";append error_message "DUT_send_multi_expected $sub_function : fail\n"}
}
sleep_sec 1
} else {
puts "please provide mc watchdog sub-function for testing"
}
}
}
}
#powerful string match fucntion, done, happy
proc DUT_ipmitool_expectout {{check_id 1} {sub_function *} {expected_result *} {sub_test_case default_none} { sleeptime 1} } {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt expectout shmm_ip ipmb_addr
puts "\nrunning proc DUT_ipmitool_expectout {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
if { $sub_function != "" } {
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
send -s "ipmitool $sub_function\r"
sleep $sleeptime
expect {
-re "ipmitool(.*)$DUT_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
if {[string match $expected_result $expectout ]==1} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
}
} else {
send_user "please provide sub-function for testing"
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 3
if { $sub_function != "" } {
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw $sub_function\r"
expect {
-re "ipmitool(.*)$Con_server_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
if {[string match $expected_result $expectout ]==1} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
}
} else {
send_user "please provide sub-function for testing"
}
DUT_login
}
3 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 3
if { $sub_function != "" } {
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw $sub_function\r"
expect {
-re "ipmitool(.*)$Con_server_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
if {[string match $expected_result $expectout ]==1} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
}
} else {
send_user "please provide sub-function for testing"
}
DUT_login
}
4 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 3
if { $sub_function != "" } {
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
send -s "ipmitool -I lan -H $shmm_ip -A none -t $ipmb_addr $sub_function\r"
expect {
-re "ipmitool(.*)$Con_server_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
if {[string match $expected_result $expectout ]==1} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
}
} else {
send_user "please provide sub-function for testing"
}
DUT_login
}
default {puts "do nothing!";}
}
}
}
}
#powerful string match fucntion, done, happy
#$reg is needed
#powerful string match fucntion, done, happy
proc Con_ipmitool_expectout {{sub_function *} {expected_result *} {sub_test_case default_none} } {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt expectout
puts "\nrunning proc Con_ipmitool_expectout {}"
expect {
$Con_server_prompt {
if { $sub_function != "" } {
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
send -s "ipmitool $sub_function\r"
expect {
-re "ipmitool(.*)$Con_server_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
if {[string match $expected_result $expectout ]==1} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
exit;
}
} else {
send_user "please provide sub-function for testing"
}
}
}
}
#powerful string match fucntion, done, happy
#$reg is needed
proc DUT_expectout {{check_id 1} {sub_function *} {reg *} {expected_result *} {sub_test_case default_none} } {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt expectout ipmb_addr shmm_ip
puts "\nrunning proc DUT_expectout {}"
#puts "check_id = $check_id"
#set a $DUT_prompt
#puts $DUT_prompt
#puts "a = $a"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
if { $sub_function != "" } {
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
send -s "$sub_function\r"
expect {
-re "$reg" {set expectout $expect_out(0,string);send -s "\r"}
#-re "\r\n(.*)$DUT_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
if {[string match $expected_result $expectout ]==1} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
puts "expected_result = $expected_result"
puts "expectout = $expectout"
}
} else {
send_user "please provide sub-function for testing"
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 3
if { $sub_function != "" } {
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw $sub_function\r"
expect {
-re "ipmitool(.*)$Con_server_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
if {[string match $expected_result $expectout ]==1} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
}
} else {
send_user "please provide sub-function for testing"
}
DUT_login
}
default {puts "do nothing!";}
}
}
}
}
proc DUT_fail_expectout {{check_id 1} {sub_function *} {reg *} {expected_result *} {sub_test_case default_none} } {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt expectout ipmb_addr shmm_ip
puts "\nrunning proc DUT_expectout {}"
#puts "check_id = $check_id"
#set a $DUT_prompt
#puts $DUT_prompt
#puts "a = $a"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
if { $sub_function != "" } {
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
send -s "$sub_function\r"
expect {
-re "$reg" {set expectout $expect_out(0,string);send -s "\r"}
#-re "\r\n(.*)$DUT_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
if {[string match $expected_result $expectout ]==1} {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "expected_result = $expected_result"
send_user "expectout = $expectout"
}
} else {
send_user "please provide sub-function for testing"
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 3
if { $sub_function != "" } {
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw $sub_function\r"
expect {
-re "ipmitool(.*)$Con_server_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
if {[string match $expected_result $expectout ]==1} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
}
} else {
send_user "please provide sub-function for testing"
}
DUT_login
}
default {puts "do nothing!";}
}
}
}
}
proc DUT_DUI_cli_expectout {{check_id 1} {sub_function *} {reg *} {expected_result *} {sub_test_case default_none} } {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt expectout ipmb_addr shmm_ip
puts "\nrunning proc DUT_DUI_cli_expectout {}"
#puts "check_id = $check_id"
#set a $DUT_prompt
#puts $DUT_prompt
#puts "a = $a"
expect {
cli> {
switch -exact $check_id {
1 {
if { $sub_function != "" } {
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
#send -s "$sub_function\r"
send "$sub_function\r"
expect {
-re "$reg" {set expectout $expect_out(0,string);send -s "\r"}
#-re "\r\n(.*)$DUT_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
if {[string match $expected_result $expectout ]==1} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
puts "expected_result = $expected_result"
puts "expectout = $expectout"
}
} else {
send_user "please provide sub-function for testing"
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 3
if { $sub_function != "" } {
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw $sub_function\r"
expect {
-re "ipmitool(.*)$Con_server_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
if {[string match $expected_result $expectout ]==1} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
}
} else {
send_user "please provide sub-function for testing"
}
DUT_login
}
default {puts "do nothing!";}
}
}
}
}
proc DUT_BSP_kdb_expectout {{check_id 1} {sub_function *} {reg *} {expected_result *} {sub_test_case default_none} } {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt expectout ipmb_addr shmm_ip
puts "\nrunning proc DUT_DUI_cli_expectout {}"
#puts "check_id = $check_id"
#set a $DUT_prompt
#puts $DUT_prompt
#puts "a = $a"
expect {
kdb> {
switch -exact $check_id {
1 {
if { $sub_function != "" } {
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
send -s "$sub_function\r"
expect {
-re "$reg" {set expectout $expect_out(0,string);send -s "\r"}
#-re "\r\n(.*)$DUT_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
if {[string match $expected_result $expectout ]==1} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
puts "expected_result = $expected_result"
puts "expectout = $expectout"
}
} else {
send_user "please provide sub-function for testing"
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 3
if { $sub_function != "" } {
###### improve sub_test_case info 20161217
send_user "\n***** sub_test_case info : $sub_test_case *****\n"
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw $sub_function\r"
expect {
-re "ipmitool(.*)$Con_server_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
if {[string match $expected_result $expectout ]==1} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
}
} else {
send_user "please provide sub-function for testing"
}
DUT_login
}
default {puts "do nothing!";}
}
}
}
}
proc DUT_sel_elist {check_id} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt
puts "\nrunning proc DUT_sel_elist {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
#send -s "\r"
#expect $DUT_prompt
send -s "ipmitool sel list | wc -l\r"
sleep_sec 1
expect {
-re "\r\n(\[0-9a-z]*)\r\n" {set sel_amount $expect_out(1,string)}
}
sleep_sec 1
puts "sel_amount=$sel_amount"
sendU_log "sel amount is $sel_amount\n"
if { $sel_amount < 6 } {
set sleep_time 1
} else {
set sleep_time [ expr $sel_amount / 6 ]
}
send -s "ipmitool sel elist\r"
sleep_sec $sleep_time
sleep_sec 1
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
#send -s "\r"
#expect $Con_server_prompt
sleep_sec 1
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw sel list |wc -l\r"
sleep_sec 1
expect {
#-re "\r\n(.*)\r\n(.*)\r\n" {set sel_amount $expect_out(2,string)}
-re "\r\n(.*)\r\n(\[0-9a-z]*)\r\n" {set sel_amount $expect_out(2,string)}
}
puts "\nsel_amount=$sel_amount"
#remove all space as blow 2 methods
#set sel_amount [string map {" " ""} $sel_amount];
#set sel_amount [string trim $sel_amount " "]
#conver hex2dec
set hex2dec [expr 0x$sel_amount]
puts "\nsel_amount = $sel_amount"
puts "\nhex2dec=$sel_amount"
set sleep_time [ expr $sel_amount / 6 ]
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw sel elist\r"
sleep_sec $sleep_time
expect {
"$Con_server_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
}
default {puts "do nothing!";}
}
}
}
}
proc DUT_sel_get {check_id {sleep_time1 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt sel_get_time sel_amount
puts "\nrunning proc DUT_sel_get {}"
puts "check_id = $check_id"
switch -exact $check_id {
1 {
send -s "ipmitool sel list | wc -l\r"
expect {
-re ".*wc.*\r\n(.*)\r\n" {set sel_amount $expect_out(1,string)}
}
#sleep_sec 1
puts "sel_amount=$sel_amount"
sendU_log "sel amount is $sel_amount\n"
Send_expectout "ipmitool sel elist" "ipmitool(.*)$DUT_prompt" "*"
if { $sel_amount == 0} {
puts "SEL is empty"
} else {
for {set k 1} {$k <= $sel_amount} {incr k} {
Send_expectout "ipmitool sel get $k" "ipmitool(.*)$DUT_prompt" "*" "sel get"
}
}
}
2 {
DUT_linux_lan_set
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw sel list | wc -l\r"
expect {
-re ".*wc.*\r\n(.*)\r\n" {set sel_amount $expect_out(1,string)}
}
#sleep_sec 1
puts "sel_amount=$sel_amount"
sendU_log "sel amount is $sel_amount\n"
Send_expectout "ipmitool sel elist" "sel(.*)$DUT_prompt" "*"
if { $sel_amount == 0} {
puts "SEL is empty"
} else {
for {set k 1} {$k <= $sel_amount} {incr k} {
Send_expectout "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw sel get $k" "get(.*)$DUT_prompt" "*" "sel get"
}
}
}
}
}
proc DUT_sel_get_bak {check_id {sleep_time1 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt sel_get_time sel_amount
puts "\nrunning proc DUT_sel_get {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
sleep_sec 5
send -s "ipmitool sel list | wc -l\r"
sleep_sec 1
expect {
-re ".*ipmitool.*\r\n(.*)\r\n" {set sel_amount $expect_out(1,string)}
}
#sleep_sec 1
puts "sel_amount=$sel_amount"
sendU_log "sel amount is $sel_amount\n"
set sleep_time [ expr $sel_amount / 6 ]
if { $sel_amount <= 12} {
set sleep_time "$sel_get_time"
} else {
set sleep_time [ expr $sel_amount / 2 + "$sel_get_time" ]
sleep_sec 1
}
send -s "ipmitool sel elist\r"
sleep_sec $sleep_time
#sleep_sec 1
if { $sel_amount == 0} {
puts "SEL is empty"
} else {
for {set k 1} {$k <= $sel_amount} {incr k} {
send -s "ipmitool sel get $k\r"
sleep_sec "$sel_get_time"
expect {
"$DUT_prompt" {sendU_log "ipmitool sel get $k : pass\n"}
default {sendU_log "ipmitool sel get $k : fail\n";append error_message "ipmitool sel get $k: fail\n"}
}
}
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "\r"
expect {
"$Con_server_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
sleep_sec 1
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw sel list |wc -l\r"
sleep_sec 1
expect {
#-re "\r\n(.*)\r\n(.*)\r\n" {set sel_amount $expect_out(2,string)}
#-re "\r\n(.*)\r\n(\[0-9a-z]*)\r\n" {set sel_amount $expect_out(2,string)}
-re "\r\n(\[0-9a-z]*)\r\n" {set sel_amount $expect_out(1,string)}
}
puts "\nsel_amount=$sel_amount"
#remove all space as blow 2 methods
#set sel_amount [string map {" " ""} $sel_amount];
#set sel_amount [string trim $sel_amount " "]
#conver hex2dec
set hex2dec [expr 0x$sel_amount]
puts "\nsel_amount = $sel_amount"
puts "\nhex2dec=$sel_amount"
#set sleep_time [ expr $sel_amount / 6 ]
if { $sel_amount <= 12} {
set sleep_time "$sel_get_time"
} else {
set sleep_time [ expr $sel_amount / 2 + "$sel_get_time" ]
sleep_sec 1
}
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw sel elist\r"
sleep_sec $sleep_time
expect {
"$Con_server_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
if { $sel_amount == 0} {
puts "SEL is empty"
} else {
for {set k 1} {$k <= $sel_amount} {incr k} {
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw sel get $k\r"
sleep_sec "$sel_get_time"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sel get $k : pass\n"}
default {sendU_log "ipmitool sel get $k : fail\n";append error_message "ipmitool sel get $k: fail\n"}
}
}
}
DUT_login
}
default {puts "do nothing!";}
}
}
}
}
proc DUT_rtm_sel_get {check_id {sleep_time1 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt sel_get_time sel_amount
puts "\nrunning proc DUT_sel_get {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
sleep_sec 5
send -s "ipmitool -b 7 -t 0xa6 sel list | wc -l\r"
sleep_sec 1
expect {
-re ".*ipmitool.*\r\n(.*)\r\n" {set sel_amount $expect_out(1,string)}
}
#sleep_sec 1
puts "sel_amount=$sel_amount"
sendU_log "sel amount is $sel_amount\n"
set sleep_time [ expr $sel_amount / 6 ]
if { $sel_amount <= 12} {
set sleep_time "$sel_get_time"
} else {
set sleep_time [ expr $sel_amount / 2 + "$sel_get_time" ]
sleep_sec 1
}
send -s "ipmitool -b 7 -t 0xa6 sel elist\r"
sleep_sec $sleep_time
#sleep_sec 1
if { $sel_amount == 0} {
puts "SEL is empty"
} else {
for {set k 1} {$k <= $sel_amount} {incr k} {
send -s "ipmitool -b 7 -t 0xa6 sel get $k\r"
sleep_sec "$sel_get_time"
expect {
"$DUT_prompt" {sendU_log "ipmitool sel get $k : pass\n"}
default {sendU_log "ipmitool sel get $k : fail\n";append error_message "ipmitool sel get $k: fail\n"}
}
}
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "\r"
expect {
"$Con_server_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
sleep_sec 1
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw -b 7 -t 0xa6 sel list |wc -l\r"
sleep_sec 1
expect {
#-re "\r\n(.*)\r\n(.*)\r\n" {set sel_amount $expect_out(2,string)}
#-re "\r\n(.*)\r\n(\[0-9a-z]*)\r\n" {set sel_amount $expect_out(2,string)}
-re "\r\n(\[0-9a-z]*)\r\n" {set sel_amount $expect_out(1,string)}
}
puts "\nsel_amount=$sel_amount"
#remove all space as blow 2 methods
#set sel_amount [string map {" " ""} $sel_amount];
#set sel_amount [string trim $sel_amount " "]
#conver hex2dec
set hex2dec [expr 0x$sel_amount]
puts "\nsel_amount = $sel_amount"
puts "\nhex2dec=$sel_amount"
#set sleep_time [ expr $sel_amount / 6 ]
if { $sel_amount <= 12} {
set sleep_time "$sel_get_time"
} else {
set sleep_time [ expr $sel_amount / 2 + "$sel_get_time" ]
sleep_sec 1
}
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw -b 7 -t 0xa6 sel elist\r"
sleep_sec $sleep_time
expect {
"$Con_server_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
if { $sel_amount == 0} {
puts "SEL is empty"
} else {
for {set k 1} {$k <= $sel_amount} {incr k} {
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw -b 7 -t 0xa6 sel get $k\r"
sleep_sec "$sel_get_time"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sel get $k : pass\n"}
default {sendU_log "ipmitool sel get $k : fail\n";append error_message "ipmitool sel get $k: fail\n"}
}
}
}
DUT_login
}
default {puts "do nothing!";}
}
}
}
}
proc DUT_sensor_thresh_hysteresis_rtm { {sleep_time1 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt sel_get_time sel_amount sensor_spec_thresh_hysteresis_rtm work_dir Test_server_prompt sensor_amount tool_path
puts "\nrunning proc DUT_sensor_thresh_hysteresis_rtm {}"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_rtm | grep ^a |wc -l\r"
#sleep_sec 1
expect {
-re "\r\n(\[0-9a-z]*)\r\n" {set sensor_amount $expect_out(1,string)}
}
send_user "\nsensor_amount = $sensor_amount\n"
#this first loop is for geting sensor number and sensor name
for {set k 1} {$k <= $sensor_amount} {incr k} {
#a$k is for sensor number from spec. file.
#puts "ak = a$k"
#get a sensor value from spec.
#get sensor name
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_rtm |grep \"a$k \"|awk 'BEGIN {FS=\"|\"}; {print \$2}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
#sleep_sec 1
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec $expect_out(1,string)}
}
send_user "\nsensor name = $expectout_spec\n"
#get sensor reading value
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sdr list |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"};{print \$2}'|awk 'BEGIN {FS=\" \"};{print \$1}' \r"
###sleep_sec 1
expect {
-re "ipmitool.*\r\n(.*)\r\n" {set expectout_spec_reading $expect_out(1,string)}
}
#send_user "sensor reading = $expectout_spec_reading"
send_user "\nexpectout_spec_reading = $expectout_spec_reading\n"
if { $expectout_spec_reading == no || $expectout_spec_reading == 0 } {
send_user "sensor no reading or 0, jump to next sensor for testing"
continue
}
#get sensor histeresis
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_rtm |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$12}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
###sleep_sec 1
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_hysteresis $expect_out(1,string)}
}
send_user "\nsensor histeresis = $expectout_hysteresis\n"
#get sensor 6 threshold value
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_rtm |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$6}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_lnr $expect_out(1,string)}
}
send_user "\nexpectout_spec_lnr = $expectout_spec_lnr\n"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_rtm |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$7}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_lcr $expect_out(1,string)}
}
send_user "\nexpectout_spec_lcr = $expectout_spec_lcr\n"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_rtm |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$8}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_lnc $expect_out(1,string)}
}
send_user "\nexpectout_spec_lnc = $expectout_spec_lnc\n"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_rtm |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$9}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_unc $expect_out(1,string)}
}
send_user "\nexpectout_spec_unc = $expectout_spec_unc\n"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_rtm |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$10}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_ucr $expect_out(1,string)}
}
send_user "\nexpectout_spec_ucr = $expectout_spec_ucr\n"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_rtm |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$11}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_unr $expect_out(1,string)}
}
send_user "\nexpectout_spec_unr = $expectout_spec_unr\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor get \"$expectout_spec\" "
#sleep_sec 1
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor get \"$expectout_spec\" : pass\n"}
default {sendU_log "ipmitool sensor get \"$expectout_spec\" : fail\n";append error_message "ipmitool sensor get \"$expectout_spec\": fail\n"}
}
#upper assert
set sensor_unc [ expr $expectout_spec_reading - 3*$expectout_hysteresis ]
set sensor_ucr [ expr $expectout_spec_reading - 2*$expectout_hysteresis ]
set sensor_unr [ expr $expectout_spec_reading - 1*$expectout_hysteresis ]
sleep_sec 3
#none_na is for recording the number of none na threshold
set none_na 0
if { [string match $expectout_spec_unc na ] ==0 } {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" unc $sensor_unc\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_unc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_unc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_unc: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nunc is na\n" }
sleep_sec 1
if { [string match $expectout_spec_ucr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" ucr $sensor_ucr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_ucr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_ucr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_ucr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nucr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_unr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" unr $sensor_unr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_unr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_unr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_unr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nunr is na\n" }
sleep_sec 15
#upper deassert
set sensor_dunr [ expr $expectout_spec_reading + 7*$expectout_hysteresis ]
set sensor_ducr [ expr $expectout_spec_reading + 6*$expectout_hysteresis ]
set sensor_dunc [ expr $expectout_spec_reading + 5*$expectout_hysteresis ]
if { [string match $expectout_spec_unr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" unr $sensor_dunr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_dunr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dunr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dunr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nunr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_ucr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" ucr $sensor_ducr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_ducr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_ducr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_ducr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nucr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_unc na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" unc $sensor_dunc\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_dunc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dunc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dunc: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nunc is na\n" }
sleep_sec 1
sleep_sec 120
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor get \"$expectout_spec\"\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor get: pass\n"}
default {sendU_log "ipmitool sensor get: fail\n";append error_message "ipmitool sensor get : fail\n"}
}
sleep_sec 10
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel elist |grep \"$expectout_spec\"\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sel elist: pass\n"}
default {sendU_log "ipmitool sel elist: fail\n";append error_message "ipmitool sel elist : fail\n"}
}
sleep_sec 10
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel elist |grep \"$expectout_spec\"|wc -l\r"
#expect {
# "$none_na" {sendU_log "threshold sel quanty : pass\n"}
# default {sendU_log "threshold sel quanty : fail\n";append error_message "threshold sel quanty : fail\n"}
#}
expect {
-re "wc.*\r\n(\[0-9]*)\r\n*" {set expectout_wc $expect_out(1,string);send -s "\r"}
}
#"\r\n(\[0-9a-z]*)\r\n"
if { [string match [string trim $expectout_wc] $none_na] ==1} {
sendU_log "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na : pass\n"
} else {
sendU_log "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na: fail\n";append error_message "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na : fail\n"
}
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel clear\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sel clear: pass\n"}
default {sendU_log "ipmitool sel clear: fail\n";append error_message "ipmitool sel clear : fail\n"}
}
sleep_sec 10
#none_na is for recording the number of none na threshold
set none_na 0
#lower assert
set sensor_lnc [ expr $expectout_spec_reading + 3*$expectout_hysteresis ]
set sensor_lcr [ expr $expectout_spec_reading + 2*$expectout_hysteresis ]
set sensor_lnr [ expr $expectout_spec_reading + 1*$expectout_hysteresis ]
if { [string match $expectout_spec_lnc na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lnc $sensor_lnc\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_lnc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lnc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lnc: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlnc is na\n" }
sleep_sec 1
if { [string match $expectout_spec_lcr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lcr $sensor_lcr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_lcr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lcr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lcr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlcr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_lnr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lnr $sensor_lnr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_lnr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lnr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lnr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlnr is na\n" }
sleep_sec 15
#lower deassert
set sensor_dlnr [ expr $expectout_spec_reading - 4*$expectout_hysteresis ]
set sensor_dlcr [ expr $expectout_spec_reading - 3*$expectout_hysteresis ]
set sensor_dlnc [ expr $expectout_spec_reading - 2*$expectout_hysteresis ]
if { [string match $expectout_spec_lnr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lnr $sensor_dlnr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_dlnr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlnr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlnr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlnr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_lcr na ] ==0} {
incr none_na
puts "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lcr $sensor_dlcr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_dlcr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlcr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlcr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlcr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_lnc na ] ==0 } {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lnc $sensor_dlnc\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_dlnc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlnc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlnc: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlnc is na\n" }
sleep_sec 1
sleep_sec 120
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor get \"$expectout_spec\"\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor get: pass\n"}
default {sendU_log "ipmitool sensor get: fail\n";append error_message "ipmitool sensor get : fail\n"}
}
sleep_sec 10
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel elist |grep \"$expectout_spec\"\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sel elist: pass\n"}
default {sendU_log "ipmitool sel elist: fail\n";append error_message "ipmitool sel elist : fail\n"}
}
sleep_sec 10
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel elist |grep \"$expectout_spec\"|wc -l\r"
#expect {
# "$none_na" {sendU_log "threshold sel quanty : pass\n"}
# default {sendU_log "threshold sel quanty : fail\n";append error_message "threshold sel quanty : fail\n"}
#}
expect {
-re "wc.*\r\n(\[0-9]*)\r\n" {set expectout_wc $expect_out(1,string);send -s "\r"}
}
if { [string match [string trim $expectout_wc] $none_na] ==1} {
sendU_log "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na : pass\n"
} else {
sendU_log "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na: fail\n";append error_message "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na : fail\n"
}
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel clear\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sel clear: pass\n"}
default {sendU_log "ipmitool sel clear: fail\n";append error_message "ipmitool sel clear : fail\n"}
}
sleep_sec 10
}
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw mc reset cold\r"
expect {
"$Con_server_prompt" {sendU_log "mc reset cold: pass\n"}
default {sendU_log "mc reset cold: fail\n";append error_message "mc reset cold : fail\n"}
}
}
proc DUT_sensor_thresh_hysteresis_rtm_bak2 {check_id {sleep_time1 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt sel_get_time sel_amount sensor_spec_thresh_hysteresis_rtm
puts "\nrunning proc DUT_sensor_thresh_hysteresis_rtm {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
send -s "cat $sensor_spec_thresh_hysteresis_rtm | grep ^a |wc -l\r"
#sleep_sec 1
expect {
-re "\r\n(\[0-9a-z]*)\r\n" {set sensor_amount $expect_out(1,string)}
}
puts "sensor_amount = $sensor_amount"
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
#this first loop is for geting sensor number and sensor name
for {set k 1} {$k <= $sensor_amount} {incr k} {
#a$k is for sensor number from spec. file.
#puts "ak = a$k"
#get a sensor value from spec.
#get sensor name
send -s "cat $sensor_spec_thresh_hysteresis_rtm |grep \"a$k \"|awk 'BEGIN {FS=\"|\"}; {print \$2}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
#sleep_sec 1
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec $expect_out(1,string)}
}
#get sensor reading value
send -s "ipmitool sdr list |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"};{print \$2}'|awk 'BEGIN {FS=\" \"};{print \$1}' \r"
###sleep_sec 1
expect {
-re "ipmitool.*\r\n(.*)\r\n" {set expectout_spec_reading $expect_out(1,string)}
}
send_user "expectout_spec_reading = $expectout_spec_reading"
if { $expectout_spec_reading == no || $expectout_spec_reading == 0 } {
send_user "sensor no reading or 0, jump to next sensor for testing"
continue
}
#get sensor histeresis
send -s "cat $sensor_spec_thresh_hysteresis_rtm |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$12}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
###sleep_sec 1
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_hysteresis $expect_out(1,string)}
}
#get sensor 6 threshold value
send -s "cat $sensor_spec_thresh_hysteresis_rtm |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$6}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_lnr $expect_out(1,string)}
}
send -s "cat $sensor_spec_thresh_hysteresis_rtm |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$7}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_lcr $expect_out(1,string)}
}
send -s "cat $sensor_spec_thresh_hysteresis_rtm |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$8}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_lnc $expect_out(1,string)}
}
send -s "cat $sensor_spec_thresh_hysteresis_rtm |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$9}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_unc $expect_out(1,string)}
}
send -s "cat $sensor_spec_thresh_hysteresis_rtm |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$10}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_ucr $expect_out(1,string)}
}
send -s "cat $sensor_spec_thresh_hysteresis_rtm |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$11}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_unr $expect_out(1,string)}
}
##sensor get
send -s "ipmitool sensor get \"$expectout_spec\" "
sleep_sec 1
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor get \"$expectout_spec\" : pass\n"}
default {sendU_log "ipmitool sensor get \"$expectout_spec\" : fail\n";append error_message "ipmitool sensor get \"$expectout_spec\": fail\n"}
}
###sleep_sec 3
#####asserted
#set sensor threshold
set sensor_unc [ expr $expectout_spec_reading - 3*$expectout_hysteresis ]
set sensor_ucr [ expr $expectout_spec_reading - 2*$expectout_hysteresis ]
set sensor_unr [ expr $expectout_spec_reading - 1*$expectout_hysteresis ]
###sleep_sec 3
if { [string match $expectout_spec_unc na ] ==0 } {
send -s "ipmitool sensor thresh \"$expectout_spec\" unc $sensor_unc\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_unc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_unc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_unc: fail\n"}
}
} else { puts " it's na , so continue" }
if { [string match $expectout_spec_ucr na ] ==0} {
send -s "ipmitool sensor thresh \"$expectout_spec\" ucr $sensor_ucr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_ucr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_ucr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_ucr: fail\n"}
}
} else { puts " it's na , so continue" }
if { [string match $expectout_spec_unr na ] ==0} {
send -s "ipmitool sensor thresh \"$expectout_spec\" unr $sensor_unr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_unr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_unr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_unr: fail\n"}
}
} else { puts " it's na , so continue" }
sleep_sec 10
DUT_ipmitool 1 "sensor get \"$expectout_spec\"" "$DUT_prompt"
sleep_sec 10
#sel
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
#DUT_ipmitool 1 "sel clear" "$DUT_prompt"
#deasserted
set sensor_dunr [ expr $expectout_spec_reading + 7*$expectout_hysteresis ]
set sensor_ducr [ expr $expectout_spec_reading + 6*$expectout_hysteresis ]
set sensor_dunc [ expr $expectout_spec_reading + 5*$expectout_hysteresis ]
if { [string match $expectout_spec_unr na ] ==0} {
send -s "ipmitool sensor thresh \"$expectout_spec\" unr $sensor_dunr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dunr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dunr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dunr: fail\n"}
}
} else { puts " it's na , so continue" }
if { [string match $expectout_spec_ucr na ] ==0} {
send -s "ipmitool sensor thresh \"$expectout_spec\" ucr $sensor_ducr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_ducr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_ducr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_ducr: fail\n"}
}
} else { puts " it's na , so continue" }
if { [string match $expectout_spec_unc na ] ==0} {
send -s "ipmitool sensor thresh \"$expectout_spec\" unc $sensor_dunc\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dunc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dunc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dunc: fail\n"}
}
} else { puts " it's na , so continue" }
sleep_sec 10
DUT_ipmitool 1 "sensor get \"$expectout_spec\"" "$DUT_prompt"
sleep_sec 10
#sel
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
#DUT_ipmitool 1 "sel clear" "$DUT_prompt"
###sleep_sec 1
# lower asserted
set sensor_lnc [ expr $expectout_spec_reading + 3*$expectout_hysteresis ]
set sensor_lcr [ expr $expectout_spec_reading + 2*$expectout_hysteresis ]
set sensor_lnr [ expr $expectout_spec_reading + 1*$expectout_hysteresis ]
if { [string match $expectout_spec_lnc na ] ==0} {
send -s "ipmitool sensor thresh \"$expectout_spec\" lnc $sensor_lnc\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_lnc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lnc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lnc: fail\n"}
}
} else { puts " it's na , so continue" }
if { [string match $expectout_spec_lcr na ] ==0} {
send -s "ipmitool sensor thresh \"$expectout_spec\" lcr $sensor_lcr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_lcr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lcr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lcr: fail\n"}
}
} else { puts " it's na , so continue" }
if { [string match $expectout_spec_lnr na ] ==0} {
send -s "ipmitool sensor thresh \"$expectout_spec\" lnr $sensor_lnr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_lnr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lnr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lnr: fail\n"}
}
} else { puts " it's na , so continue" }
sleep_sec 10
DUT_ipmitool 1 "sensor get \"$expectout_spec\"" "$DUT_prompt"
sleep_sec 10
#sel
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
#DUT_ipmitool 1 "sel clear" "$DUT_prompt"
sleep_sec 3
#lower deasserted
set sensor_dlnr [ expr $expectout_spec_reading - 4*$expectout_hysteresis ]
set sensor_dlcr [ expr $expectout_spec_reading - 3*$expectout_hysteresis ]
set sensor_dlnc [ expr $expectout_spec_reading - 2*$expectout_hysteresis ]
if { [string match $expectout_spec_lnr na ] ==0} {
send -s "ipmitool sensor thresh \"$expectout_spec\" lnr $sensor_dlnr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dlnr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlnr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlnr: fail\n"}
}
} else { puts " it's na , so continue" }
if { [string match $expectout_spec_lcr na ] ==0} {
send -s "ipmitool sensor thresh \"$expectout_spec\" lcr $sensor_dlcr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dlcr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlcr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlcr: fail\n"}
}
} else { puts " it's na , so continue" }
if { [string match $expectout_spec_lnc na ] ==0 } {
send -s "ipmitool sensor thresh \"$expectout_spec\" lnc $sensor_dlnc\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dlnc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlnc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlnc: fail\n"}
}
} else { puts " it's na , so continue" }
###sleep_sec 3
#sensor get
sleep_sec 10
DUT_ipmitool 1 "sensor get \"$expectout_spec\"" "$DUT_prompt"
sleep_sec 10
#sel
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
DUT_ipmitool 1 "sel clear " "Please allow a few seconds to erase."
sleep_sec 10
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "\r"
expect {
"$Con_server_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
DUT_login
}
default {puts "do nothing!";}
}
}
}
}
proc DUT_sensor_thresh_hysteresis_rtm_bak {check_id {sleep_time1 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt sel_get_time sel_amount sensor_spec_thresh_hysteresis_rtm
puts "\nrunning proc DUT_sensor_thresh_hysteresis_rtm {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
send -s "cat $sensor_spec_thresh_hysteresis_rtm | grep ^a |wc -l\r"
#sleep_sec 1
expect {
-re "\r\n(\[0-9a-z]*)\r\n" {set sensor_amount $expect_out(1,string)}
}
puts "sensor_amount = $sensor_amount"
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
##sleep_sec 1
##puts "sensor_amount=$sensor_amount"
##sendU_log "sensor_amount is $sensor_amount\n"
#this first loop is for geting sensor number and sensor name
for {set k 1} {$k <= $sensor_amount} {incr k} {
#a$k is for sensor number from spec. file.
#puts "ak = a$k"
#get a sensor value from spec.
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
#get sensor name
send -s "cat $sensor_spec_thresh_hysteresis_rtm |grep \"a$k \"|awk 'BEGIN {FS=\"|\"}; {print \$2}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
#sleep_sec 1
expect {
#-re "g'\r\n(.*)\r\n" {set expectout_spec $expect_out(1,string)}
-re "cat.*\r\n(.*)\r\n" {set expectout_spec $expect_out(1,string)}
#-re "cat.*\r(.*)\r\n" {set expectout_spec $expect_out(1,string)}
}
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
#get sensor reading value
send -s "ipmitool sdr list |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"};{print \$2}'|awk 'BEGIN {FS=\" \"};{print \$1}' \r"
###sleep_sec 1
expect {
-re "ipmitool.*\r\n(.*)\r\n" {set expectout_spec_reading $expect_out(1,string)}
}
send_user "expectout_spec_reading = $expectout_spec_reading"
if { $expectout_spec_reading == no || $expectout_spec_reading == 0 } {
send_user "sensor no reading or 0, jump to next sensor for testing"
continue
}
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
#get sensor histeresis
send -s "cat $sensor_spec_thresh_hysteresis_rtm |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$12}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
###sleep_sec 1
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_hysteresis $expect_out(1,string)}
}
#puts "$expectout_hysteresis"
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
##sensor get
send -s "ipmitool sensor get \"$expectout_spec\" "
sleep_sec 1
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor get \"$expectout_spec\" : pass\n"}
default {sendU_log "ipmitool sensor get \"$expectout_spec\" : fail\n";append error_message "ipmitool sensor get \"$expectout_spec\": fail\n"}
}
###sleep_sec 3
#####asserted
#set sensor threshold
set sensor_unc [ expr $expectout_spec_reading - 3*$expectout_hysteresis ]
set sensor_ucr [ expr $expectout_spec_reading - 2*$expectout_hysteresis ]
set sensor_unr [ expr $expectout_spec_reading - 1*$expectout_hysteresis ]
###sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" unc $sensor_unc\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_unc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_unc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_unc: fail\n"}
}
###sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" ucr $sensor_ucr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_ucr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_ucr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_ucr: fail\n"}
}
###sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" unr $sensor_unr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_unr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_unr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_unr: fail\n"}
}
sleep_sec 10
DUT_ipmitool 1 "sensor get \"$expectout_spec\"" "$DUT_prompt"
sleep_sec 10
#sel
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
#DUT_ipmitool 1 "sel clear" "$DUT_prompt"
#deasserted
set sensor_dunr [ expr $expectout_spec_reading + 7*$expectout_hysteresis ]
set sensor_ducr [ expr $expectout_spec_reading + 6*$expectout_hysteresis ]
set sensor_dunc [ expr $expectout_spec_reading + 5*$expectout_hysteresis ]
###sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" unr $sensor_dunr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dunr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dunr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dunr: fail\n"}
}
###sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" ucr $sensor_ducr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_ducr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_ducr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_ducr: fail\n"}
}
###sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" unc $sensor_dunc\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dunc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dunc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dunc: fail\n"}
}
###sleep_sec 3
sleep_sec 10
DUT_ipmitool 1 "sensor get \"$expectout_spec\"" "$DUT_prompt"
sleep_sec 10
#sel
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
#DUT_ipmitool 1 "sel clear" "$DUT_prompt"
###sleep_sec 1
# lower asserted
set sensor_lnc [ expr $expectout_spec_reading + 3*$expectout_hysteresis ]
set sensor_lcr [ expr $expectout_spec_reading + 2*$expectout_hysteresis ]
set sensor_lnr [ expr $expectout_spec_reading + 1*$expectout_hysteresis ]
###sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" lnc $sensor_lnc\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_lnc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lnc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lnc: fail\n"}
}
###sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" lcr $sensor_lcr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_lcr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lcr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lcr: fail\n"}
}
###sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" lnr $sensor_lnr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_lnr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lnr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lnr: fail\n"}
}
sleep_sec 10
DUT_ipmitool 1 "sensor get \"$expectout_spec\"" "$DUT_prompt"
sleep_sec 10
#sel
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
#DUT_ipmitool 1 "sel clear" "$DUT_prompt"
sleep_sec 3
#lower deasserted
set sensor_dlnr [ expr $expectout_spec_reading - 4*$expectout_hysteresis ]
set sensor_dlcr [ expr $expectout_spec_reading - 3*$expectout_hysteresis ]
set sensor_dlnc [ expr $expectout_spec_reading - 2*$expectout_hysteresis ]
###sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" lnr $sensor_dlnr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dlnr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlnr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlnr: fail\n"}
}
###sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" lcr $sensor_dlcr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dlcr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlcr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlcr: fail\n"}
}
###sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" lnc $sensor_dlnc\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dlnc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlnc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlnc: fail\n"}
}
###sleep_sec 3
#sensor get
sleep_sec 10
DUT_ipmitool 1 "sensor get \"$expectout_spec\"" "$DUT_prompt"
sleep_sec 10
#sel
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
DUT_ipmitool 1 "sel clear " "Please allow a few seconds to erase."
sleep_sec 10
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "\r"
expect {
"$Con_server_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
DUT_login
}
default {puts "do nothing!";}
}
}
}
}
proc DUT_sensor_thresh_hysteresis_temp { {sleep_time1 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt sel_get_time sel_amount sensor_spec_thresh_hysteresis_temp work_dir Test_server_prompt sensor_amount tool_path
puts "\nrunning proc DUT_sensor_thresh_hysteresis_temp {}"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_temp | grep ^a |wc -l\r"
#sleep_sec 1
expect {
-re "\r\n(\[0-9a-z]*)\r\n" {set sensor_amount $expect_out(1,string)}
}
send_user "\nsensor_amount = $sensor_amount\n"
#this first loop is for geting sensor number and sensor name
for {set k 1} {$k <= $sensor_amount} {incr k} {
#a$k is for sensor number from spec. file.
#puts "ak = a$k"
#get a sensor value from spec.
#get sensor name
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_temp |grep \"a$k \"|awk 'BEGIN {FS=\"|\"}; {print \$2}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
#sleep_sec 1
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec $expect_out(1,string)}
}
send_user "\nsensor name = $expectout_spec\n"
#get sensor reading value
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sdr list |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"};{print \$2}'|awk 'BEGIN {FS=\" \"};{print \$1}' \r"
###sleep_sec 1
expect {
-re "ipmitool.*\r\n(.*)\r\n" {set expectout_spec_reading $expect_out(1,string)}
}
#send_user "sensor reading = $expectout_spec_reading"
send_user "\nexpectout_spec_reading = $expectout_spec_reading\n"
if { $expectout_spec_reading == no || $expectout_spec_reading == 0 } {
send_user "sensor no reading or 0, jump to next sensor for testing"
continue
}
#get sensor histeresis
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_temp |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$12}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
###sleep_sec 1
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_hysteresis $expect_out(1,string)}
}
send_user "\nsensor histeresis = $expectout_hysteresis\n"
#get sensor 6 threshold value
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_temp |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$6}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_lnr $expect_out(1,string)}
}
send_user "\nexpectout_spec_lnr = $expectout_spec_lnr\n"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_temp |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$7}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_lcr $expect_out(1,string)}
}
send_user "\nexpectout_spec_lcr = $expectout_spec_lcr\n"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_temp |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$8}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_lnc $expect_out(1,string)}
}
send_user "\nexpectout_spec_lnc = $expectout_spec_lnc\n"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_temp |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$9}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_unc $expect_out(1,string)}
}
send_user "\nexpectout_spec_unc = $expectout_spec_unc\n"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_temp |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$10}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_ucr $expect_out(1,string)}
}
send_user "\nexpectout_spec_ucr = $expectout_spec_ucr\n"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_temp |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$11}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_unr $expect_out(1,string)}
}
send_user "\nexpectout_spec_unr = $expectout_spec_unr\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor get \"$expectout_spec\" "
#sleep_sec 1
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor get \"$expectout_spec\" : pass\n"}
default {sendU_log "ipmitool sensor get \"$expectout_spec\" : fail\n";append error_message "ipmitool sensor get \"$expectout_spec\": fail\n"}
}
#upper assert
set sensor_unc [ expr $expectout_spec_reading - 3*$expectout_hysteresis ]
set sensor_ucr [ expr $expectout_spec_reading - 2*$expectout_hysteresis ]
set sensor_unr [ expr $expectout_spec_reading - 1*$expectout_hysteresis ]
sleep_sec 3
#none_na is for recording the number of none na threshold
set none_na 0
if { [string match $expectout_spec_unc na ] ==0 } {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" unc $sensor_unc\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_unc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_unc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_unc: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nunc is na\n" }
sleep_sec 1
if { [string match $expectout_spec_ucr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" ucr $sensor_ucr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_ucr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_ucr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_ucr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nucr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_unr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" unr $sensor_unr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_unr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_unr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_unr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nunr is na\n" }
sleep_sec 15
#upper deassert
set sensor_dunr [ expr $expectout_spec_reading + 7*$expectout_hysteresis ]
set sensor_ducr [ expr $expectout_spec_reading + 6*$expectout_hysteresis ]
set sensor_dunc [ expr $expectout_spec_reading + 5*$expectout_hysteresis ]
if { [string match $expectout_spec_unr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" unr $sensor_dunr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_dunr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dunr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dunr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nunr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_ucr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" ucr $sensor_ducr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_ducr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_ducr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_ducr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nucr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_unc na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" unc $sensor_dunc\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_dunc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dunc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dunc: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nunc is na\n" }
sleep_sec 1
sleep_sec 120
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor get \"$expectout_spec\"\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor get: pass\n"}
default {sendU_log "ipmitool sensor get: fail\n";append error_message "ipmitool sensor get : fail\n"}
}
sleep_sec 10
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel elist |grep \"$expectout_spec\"\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sel elist: pass\n"}
default {sendU_log "ipmitool sel elist: fail\n";append error_message "ipmitool sel elist : fail\n"}
}
sleep_sec 10
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel elist |grep \"$expectout_spec\"|wc -l\r"
#expect {
# "$none_na" {sendU_log "threshold sel quanty : pass\n"}
# default {sendU_log "threshold sel quanty : fail\n";append error_message "threshold sel quanty : fail\n"}
#}
expect {
-re "wc.*\r\n(\[0-9]*)\r\n*" {set expectout_wc $expect_out(1,string);send -s "\r"}
}
#"\r\n(\[0-9a-z]*)\r\n"
if { [string match [string trim $expectout_wc] $none_na] ==1} {
sendU_log "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na : pass\n"
} else {
sendU_log "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na: fail\n";append error_message "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na : fail\n"
}
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel clear\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sel clear: pass\n"}
default {sendU_log "ipmitool sel clear: fail\n";append error_message "ipmitool sel clear : fail\n"}
}
sleep_sec 10
#none_na is for recording the number of none na threshold
set none_na 0
#lower assert
set sensor_lnc [ expr $expectout_spec_reading + 3*$expectout_hysteresis ]
set sensor_lcr [ expr $expectout_spec_reading + 2*$expectout_hysteresis ]
set sensor_lnr [ expr $expectout_spec_reading + 1*$expectout_hysteresis ]
if { [string match $expectout_spec_lnc na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lnc $sensor_lnc\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_lnc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lnc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lnc: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlnc is na\n" }
sleep_sec 1
if { [string match $expectout_spec_lcr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lcr $sensor_lcr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_lcr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lcr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lcr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlcr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_lnr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lnr $sensor_lnr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_lnr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lnr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lnr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlnr is na\n" }
sleep_sec 15
#lower deassert
set sensor_dlnr [ expr $expectout_spec_reading - 4*$expectout_hysteresis ]
set sensor_dlcr [ expr $expectout_spec_reading - 3*$expectout_hysteresis ]
set sensor_dlnc [ expr $expectout_spec_reading - 2*$expectout_hysteresis ]
if { [string match $expectout_spec_lnr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lnr $sensor_dlnr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_dlnr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlnr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlnr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlnr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_lcr na ] ==0} {
incr none_na
puts "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lcr $sensor_dlcr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_dlcr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlcr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlcr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlcr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_lnc na ] ==0 } {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lnc $sensor_dlnc\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_dlnc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlnc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlnc: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlnc is na\n" }
sleep_sec 1
sleep_sec 120
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor get \"$expectout_spec\"\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor get: pass\n"}
default {sendU_log "ipmitool sensor get: fail\n";append error_message "ipmitool sensor get : fail\n"}
}
sleep_sec 10
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel elist |grep \"$expectout_spec\"\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sel elist: pass\n"}
default {sendU_log "ipmitool sel elist: fail\n";append error_message "ipmitool sel elist : fail\n"}
}
sleep_sec 10
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel elist |grep \"$expectout_spec\"|wc -l\r"
#expect {
# "$none_na" {sendU_log "threshold sel quanty : pass\n"}
# default {sendU_log "threshold sel quanty : fail\n";append error_message "threshold sel quanty : fail\n"}
#}
expect {
-re "wc.*\r\n(\[0-9]*)\r\n" {set expectout_wc $expect_out(1,string);send -s "\r"}
}
if { [string match [string trim $expectout_wc] $none_na] ==1} {
sendU_log "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na : pass\n"
} else {
sendU_log "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na: fail\n";append error_message "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na : fail\n"
}
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel clear\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sel clear: pass\n"}
default {sendU_log "ipmitool sel clear: fail\n";append error_message "ipmitool sel clear : fail\n"}
}
sleep_sec 10
}
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw mc reset cold\r"
expect {
"$Con_server_prompt" {sendU_log "mc reset cold: pass\n"}
default {sendU_log "mc reset cold: fail\n";append error_message "mc reset cold : fail\n"}
}
}
proc DUT_sensor_thresh_hysteresis_volt { {sleep_time1 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt sel_get_time sel_amount sensor_spec_thresh_hysteresis_volt work_dir Test_server_prompt sensor_amount tool_path
puts "\nrunning proc DUT_sensor_thresh_hysteresis_volt {}"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_volt | grep ^a |wc -l\r"
#sleep_sec 1
expect {
-re "\r\n(\[0-9a-z]*)\r\n" {set sensor_amount $expect_out(1,string)}
}
send_user "\nsensor_amount = $sensor_amount\n"
#this first loop is for geting sensor number and sensor name
for {set k 1} {$k <= $sensor_amount} {incr k} {
#a$k is for sensor number from spec. file.
#puts "ak = a$k"
#get a sensor value from spec.
#get sensor name
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_volt |grep \"a$k \"|awk 'BEGIN {FS=\"|\"}; {print \$2}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
#sleep_sec 1
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec $expect_out(1,string)}
}
send_user "\nsensor name = $expectout_spec\n"
#get sensor reading value
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sdr list |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"};{print \$2}'|awk 'BEGIN {FS=\" \"};{print \$1}' \r"
###sleep_sec 1
expect {
-re "ipmitool.*\r\n(.*)\r\n" {set expectout_spec_reading $expect_out(1,string)}
}
#send_user "sensor reading = $expectout_spec_reading"
send_user "\nexpectout_spec_reading = $expectout_spec_reading\n"
if { $expectout_spec_reading == no || $expectout_spec_reading == 0 } {
send_user "sensor no reading or 0, jump to next sensor for testing"
continue
}
#get sensor histeresis
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_volt |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$12}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
###sleep_sec 1
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_hysteresis $expect_out(1,string)}
}
send_user "\nsensor histeresis = $expectout_hysteresis\n"
#get sensor 6 threshold value
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_volt |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$6}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_lnr $expect_out(1,string)}
}
send_user "\nexpectout_spec_lnr = $expectout_spec_lnr\n"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_volt |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$7}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_lcr $expect_out(1,string)}
}
send_user "\nexpectout_spec_lcr = $expectout_spec_lcr\n"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_volt |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$8}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_lnc $expect_out(1,string)}
}
send_user "\nexpectout_spec_lnc = $expectout_spec_lnc\n"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_volt |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$9}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_unc $expect_out(1,string)}
}
send_user "\nexpectout_spec_unc = $expectout_spec_unc\n"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_volt |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$10}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_ucr $expect_out(1,string)}
}
send_user "\nexpectout_spec_ucr = $expectout_spec_ucr\n"
send -s "cat $tool_path$sensor_spec_thresh_hysteresis_volt |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$11}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_unr $expect_out(1,string)}
}
send_user "\nexpectout_spec_unr = $expectout_spec_unr\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor get \"$expectout_spec\" "
#sleep_sec 1
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor get \"$expectout_spec\" : pass\n"}
default {sendU_log "ipmitool sensor get \"$expectout_spec\" : fail\n";append error_message "ipmitool sensor get \"$expectout_spec\": fail\n"}
}
#upper assert
set sensor_unc [ expr $expectout_spec_reading - 3*$expectout_hysteresis ]
set sensor_ucr [ expr $expectout_spec_reading - 2*$expectout_hysteresis ]
set sensor_unr [ expr $expectout_spec_reading - 1*$expectout_hysteresis ]
sleep_sec 3
#none_na is for recording the number of none na threshold
set none_na 0
if { [string match $expectout_spec_unc na ] ==0 } {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" unc $sensor_unc\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_unc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_unc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_unc: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nunc is na\n" }
sleep_sec 1
if { [string match $expectout_spec_ucr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" ucr $sensor_ucr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_ucr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_ucr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_ucr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nucr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_unr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" unr $sensor_unr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_unr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_unr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_unr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nunr is na\n" }
sleep_sec 15
#upper deassert
set sensor_dunr [ expr $expectout_spec_reading + 7*$expectout_hysteresis ]
set sensor_ducr [ expr $expectout_spec_reading + 6*$expectout_hysteresis ]
set sensor_dunc [ expr $expectout_spec_reading + 5*$expectout_hysteresis ]
if { [string match $expectout_spec_unr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" unr $sensor_dunr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_dunr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dunr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dunr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nunr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_ucr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" ucr $sensor_ducr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_ducr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_ducr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_ducr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nucr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_unc na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" unc $sensor_dunc\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_dunc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dunc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dunc: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nunc is na\n" }
sleep_sec 1
sleep_sec 120
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor get \"$expectout_spec\"\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor get: pass\n"}
default {sendU_log "ipmitool sensor get: fail\n";append error_message "ipmitool sensor get : fail\n"}
}
sleep_sec 10
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel elist |grep \"$expectout_spec\"\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sel elist: pass\n"}
default {sendU_log "ipmitool sel elist: fail\n";append error_message "ipmitool sel elist : fail\n"}
}
sleep_sec 10
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel elist |grep \"$expectout_spec\"|wc -l\r"
#expect {
# "$none_na" {sendU_log "threshold sel quanty : pass\n"}
# default {sendU_log "threshold sel quanty : fail\n";append error_message "threshold sel quanty : fail\n"}
#}
expect {
-re "wc.*\r\n(\[0-9]*)\r\n*" {set expectout_wc $expect_out(1,string);send -s "\r"}
}
#"\r\n(\[0-9a-z]*)\r\n"
if { [string match [string trim $expectout_wc] $none_na] ==1} {
sendU_log "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na : pass\n"
} else {
sendU_log "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na: fail\n";append error_message "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na : fail\n"
}
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel clear\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sel clear: pass\n"}
default {sendU_log "ipmitool sel clear: fail\n";append error_message "ipmitool sel clear : fail\n"}
}
sleep_sec 10
#none_na is for recording the number of none na threshold
set none_na 0
#lower assert
set sensor_lnc [ expr $expectout_spec_reading + 3*$expectout_hysteresis ]
set sensor_lcr [ expr $expectout_spec_reading + 2*$expectout_hysteresis ]
set sensor_lnr [ expr $expectout_spec_reading + 1*$expectout_hysteresis ]
if { [string match $expectout_spec_lnc na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lnc $sensor_lnc\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_lnc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lnc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lnc: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlnc is na\n" }
sleep_sec 1
if { [string match $expectout_spec_lcr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lcr $sensor_lcr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_lcr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lcr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lcr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlcr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_lnr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lnr $sensor_lnr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_lnr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lnr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lnr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlnr is na\n" }
sleep_sec 15
#lower deassert
set sensor_dlnr [ expr $expectout_spec_reading - 4*$expectout_hysteresis ]
set sensor_dlcr [ expr $expectout_spec_reading - 3*$expectout_hysteresis ]
set sensor_dlnc [ expr $expectout_spec_reading - 2*$expectout_hysteresis ]
if { [string match $expectout_spec_lnr na ] ==0} {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lnr $sensor_dlnr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_dlnr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlnr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlnr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlnr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_lcr na ] ==0} {
incr none_na
puts "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lcr $sensor_dlcr\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_dlcr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlcr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlcr: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlcr is na\n" }
sleep_sec 1
if { [string match $expectout_spec_lnc na ] ==0 } {
incr none_na
send_user "\nnone_na = $none_na\n"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lnc $sensor_dlnc\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor thresh sensor_dlnc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlnc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlnc: fail\n"}
}
} else { send_user "\nnone_na = $none_na\n\nlnc is na\n" }
sleep_sec 1
sleep_sec 120
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor get \"$expectout_spec\"\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sensor get: pass\n"}
default {sendU_log "ipmitool sensor get: fail\n";append error_message "ipmitool sensor get : fail\n"}
}
sleep_sec 10
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel elist |grep \"$expectout_spec\"\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sel elist: pass\n"}
default {sendU_log "ipmitool sel elist: fail\n";append error_message "ipmitool sel elist : fail\n"}
}
sleep_sec 10
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel elist |grep \"$expectout_spec\"|wc -l\r"
#expect {
# "$none_na" {sendU_log "threshold sel quanty : pass\n"}
# default {sendU_log "threshold sel quanty : fail\n";append error_message "threshold sel quanty : fail\n"}
#}
expect {
-re "wc.*\r\n(\[0-9]*)\r\n" {set expectout_wc $expect_out(1,string);send -s "\r"}
}
if { [string match [string trim $expectout_wc] $none_na] ==1} {
sendU_log "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na : pass\n"
} else {
sendU_log "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na: fail\n";append error_message "threshold sel quanty expectout_wc == none_na ; $expectout_wc == $none_na : fail\n"
}
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sel clear\r"
expect {
"$Con_server_prompt" {sendU_log "ipmitool sel clear: pass\n"}
default {sendU_log "ipmitool sel clear: fail\n";append error_message "ipmitool sel clear : fail\n"}
}
sleep_sec 10
}
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw mc reset cold\r"
expect {
"$Con_server_prompt" {sendU_log "mc reset cold: pass\n"}
default {sendU_log "mc reset cold: fail\n";append error_message "mc reset cold : fail\n"}
}
}
proc DUT_sensor_thresh_hysteresis_volt_bak2 {check_id {sleep_time1 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt sel_get_time sel_amount sensor_spec sensor_spec_thresh_hysteresis_temp sensor_spec_thresh_hysteresis_volt sensor_spec_thresh_no_hysteresis
puts "\nrunning proc DUT_sensor_thresh_hysteresis_volt {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
send -s "cat $sensor_spec_thresh_hysteresis_volt | wc -l\r"
sleep_sec 1
expect {
-re "\r\n(\[0-9a-z]*)\r\n" {set sensor_amount $expect_out(1,string)}
}
puts "sensor_amount = $sensor_amount"
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
##sleep_sec 1
##puts "sensor_amount=$sensor_amount"
##sendU_log "sensor_amount is $sensor_amount\n"
#this first loop is for geting sensor number and sensor name
for {set k 1} {$k <= $sensor_amount} {incr k} {
#a$k is for sensor number from spec. file.
#puts "ak = a$k"
#get a sensor value from spec.
#send -s "\r"
# expect {
# "$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
# default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
#}
#get sensor name
send -s "cat $sensor_spec_thresh_hysteresis_volt |grep \"a$k \"|awk 'BEGIN {FS=\"|\"}; {print \$2}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
###sleep_sec 1
expect {
#-re "g'\r\n(.*)\r\n" {set expectout_spec $expect_out(1,string)}
-re "cat.*\r\n(.*)\r\n" {set expectout_spec $expect_out(1,string)}
}
#send -s "\r"
# expect {
# "$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
# default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
#}
#get sensor reading value
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sdr list |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"};{print \$2}'|awk 'BEGIN {FS=\" \"};{print \$1}' \r"
###sleep_sec 1
expect {
-re "ipmitool.*\r\n(.*)\r\n" {set expectout_spec_reading $expect_out(1,string)}
}
send_user "expectout_spec_reading = $expectout_spec_reading"
if { $expectout_spec_reading == no || $expectout_spec_reading == 0 } {
send_user "sensor no reading or 0, jump to next sensor for testing"
continue
}
#send -s "\r"
# expect {
# "$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
# default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
#}
#get sensor histeresis
send -s "cat $sensor_spec_thresh_hysteresis_volt |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$12}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
###sleep_sec 1
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_hysteresis $expect_out(1,string)}
}
#puts "$expectout_hysteresis"
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
##sensor get
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor get \"$expectout_spec\" "
sleep_sec 1
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor get \"$expectout_spec\" : pass\n"}
default {sendU_log "ipmitool sensor get \"$expectout_spec\" : fail\n";append error_message "ipmitool sensor get \"$expectout_spec\": fail\n"}
}
###sleep_sec 3
#####asserted
#set sensor threshold
set sensor_unc [ expr $expectout_spec_reading - 3*$expectout_hysteresis ]
set sensor_ucr [ expr $expectout_spec_reading - 2*$expectout_hysteresis ]
set sensor_unr [ expr $expectout_spec_reading - 1*$expectout_hysteresis ]
###sleep_sec 3
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" unc $sensor_unc\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_unc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_unc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_unc: fail\n"}
}
###sleep_sec 3
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" ucr $sensor_ucr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_ucr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_ucr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_ucr: fail\n"}
}
###sleep_sec 3
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" unr $sensor_unr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_unr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_unr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_unr: fail\n"}
}
sleep_sec 10
##### new add
DUT_ipmitool 1 "sensor get \"$expectout_spec\"" "$DUT_prompt"
sleep_sec 10
#sel
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
#DUT_ipmitool 1 "sel clear" "$DUT_prompt"
#deasserted
set sensor_dunr [ expr $expectout_spec_reading + 7*$expectout_hysteresis ]
set sensor_ducr [ expr $expectout_spec_reading + 6*$expectout_hysteresis ]
set sensor_dunc [ expr $expectout_spec_reading + 5*$expectout_hysteresis ]
###sleep_sec 3
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" unr $sensor_dunr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dunr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dunr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dunr: fail\n"}
}
###sleep_sec 3
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" ucr $sensor_ducr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_ducr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_ducr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_ducr: fail\n"}
}
###sleep_sec 3
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" unc $sensor_dunc\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dunc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dunc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dunc: fail\n"}
}
###sleep_sec 3
sleep_sec 10
DUT_ipmitool 1 "sensor get \"$expectout_spec\"" "$DUT_prompt"
sleep_sec 10
#sel
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
#DUT_ipmitool 1 "sel clear" "$DUT_prompt"
###sleep_sec 1
# lower asserted
set sensor_lnc [ expr $expectout_spec_reading + 3*$expectout_hysteresis ]
set sensor_lcr [ expr $expectout_spec_reading + 2*$expectout_hysteresis ]
set sensor_lnr [ expr $expectout_spec_reading + 1*$expectout_hysteresis ]
###sleep_sec 3
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lnc $sensor_lnc\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_lnc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lnc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lnc: fail\n"}
}
###sleep_sec 3
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lcr $sensor_lcr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_lcr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lcr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lcr: fail\n"}
}
###sleep_sec 3
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lnr $sensor_lnr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_lnr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lnr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lnr: fail\n"}
}
sleep_sec 10
DUT_ipmitool 1 "sensor get \"$expectout_spec\"" "$DUT_prompt"
sleep_sec 10
#sel
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
#DUT_ipmitool 1 "sel clear" "$DUT_prompt"
sleep_sec 3
#lower deasserted
set sensor_dlnr [ expr $expectout_spec_reading - 4*$expectout_hysteresis ]
set sensor_dlcr [ expr $expectout_spec_reading - 3*$expectout_hysteresis ]
set sensor_dlnc [ expr $expectout_spec_reading - 2*$expectout_hysteresis ]
###sleep_sec 3
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lnr $sensor_dlnr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dlnr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlnr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlnr: fail\n"}
}
###sleep_sec 3
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lcr $sensor_dlcr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dlcr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlcr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlcr: fail\n"}
}
###sleep_sec 3
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor thresh \"$expectout_spec\" lnc $sensor_dlnc\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dlnc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlnc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlnc: fail\n"}
}
###sleep_sec 3
#sensor get
sleep_sec 10
DUT_ipmitool 1 "sensor get \"$expectout_spec\"" "$DUT_prompt"
sleep_sec 10
#sel
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
DUT_ipmitool 1 "sel clear " "Please allow a few seconds to erase."
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "\r"
expect {
"$Con_server_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
DUT_login
}
default {puts "do nothing!";}
}
}
}
}
proc DUT_sensor_thresh_hysteresis {check_id {sleep_time1 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt sel_get_time sel_amount sensor_spec sensor_spec_thresh_hysteresis sensor_spec_thresh_no_hysteresis
puts "\nrunning proc DUT_sensor_thresh_hysteresis {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
send -s "cat $sensor_spec_thresh_hysteresis | wc -l\r"
sleep_sec 1
expect {
-re "\r\n(\[0-9a-z]*)\r\n" {set sensor_amount $expect_out(1,string)}
}
puts "sensor_amount = $sensor_amount"
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
##sleep_sec 1
##puts "sensor_amount=$sensor_amount"
##sendU_log "sensor_amount is $sensor_amount\n"
#this first loop is for geting sensor number and sensor name
for {set k 1} {$k <= $sensor_amount} {incr k} {
#a$k is for sensor number from spec. file.
#puts "ak = a$k"
#get a sensor value from spec.
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
#get sensor name
send -s "cat $sensor_spec_thresh_hysteresis |grep \"a$k \"|awk 'BEGIN {FS=\"|\"}; {print \$2}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
sleep_sec 1
expect {
#-re "g'\r\n(.*)\r\n" {set expectout_spec $expect_out(1,string)}
-re "cat.*\r\n(.*)\r\n" {set expectout_spec $expect_out(1,string)}
}
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
#get sensor reading value
send -s "ipmitool sdr list |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"};{print \$2}'|awk 'BEGIN {FS=\" \"};{print \$1}' \r"
sleep_sec 1
expect {
-re "ipmitool.*\r\n(.*)\r\n" {set expectout_spec_reading $expect_out(1,string)}
}
puts "expectout_spec_reading = $expectout_spec_reading"
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
#get sensor histeresis
send -s "cat $sensor_spec_thresh_hysteresis |grep \"$expectout_spec\"|awk 'BEGIN {FS=\"|\"}; {print \$12}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
sleep_sec 1
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_hysteresis $expect_out(1,string)}
}
#puts "$expectout_hysteresis"
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
##sensor get
send -s "ipmitool sensor get \"$expectout_spec\" "
sleep_sec 1
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor get \"$expectout_spec\" : pass\n"}
default {sendU_log "ipmitool sensor get \"$expectout_spec\" : fail\n";append error_message "ipmitool sensor get \"$expectout_spec\": fail\n"}
}
sleep_sec 3
#####asserted
#set sensor threshold
set sensor_unc [ expr $expectout_spec_reading - 3*$expectout_hysteresis ]
set sensor_ucr [ expr $expectout_spec_reading - 2*$expectout_hysteresis ]
set sensor_unr [ expr $expectout_spec_reading - 1*$expectout_hysteresis ]
sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" unc $sensor_unc\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_unc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_unc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_unc: fail\n"}
}
sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" ucr $sensor_ucr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_ucr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_ucr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_ucr: fail\n"}
}
sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" unr $sensor_unr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_unr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_unr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_unr: fail\n"}
}
sleep_sec 3
DUT_ipmitool 1 "sensor get \"$expectout_spec\"" "$DUT_prompt"
#sel
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
DUT_ipmitool 1 "sel clear" "$DUT_prompt"
#deasserted
set sensor_dunr [ expr $expectout_spec_reading + 7*$expectout_hysteresis ]
set sensor_ducr [ expr $expectout_spec_reading + 6*$expectout_hysteresis ]
set sensor_dunc [ expr $expectout_spec_reading + 5*$expectout_hysteresis ]
sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" unr $sensor_dunr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dunr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dunr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dunr: fail\n"}
}
sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" ucr $sensor_ducr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_ducr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_ducr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_ducr: fail\n"}
}
sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" unc $sensor_dunc\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dunc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dunc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dunc: fail\n"}
}
sleep_sec 3
DUT_ipmitool 1 "sensor get \"$expectout_spec\"" "$DUT_prompt"
sleep_sec 1
#sel
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
DUT_ipmitool 1 "sel clear" "$DUT_prompt"
sleep_sec 1
# lower asserted
set sensor_lnc [ expr $expectout_spec_reading + 3*$expectout_hysteresis ]
set sensor_lcr [ expr $expectout_spec_reading + 2*$expectout_hysteresis ]
set sensor_lnr [ expr $expectout_spec_reading + 1*$expectout_hysteresis ]
sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" lnc $sensor_lnc\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_lnc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lnc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lnc: fail\n"}
}
sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" lcr $sensor_lcr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_lcr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lcr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lcr: fail\n"}
}
sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" lnr $sensor_lnr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_lnr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_lnr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_lnr: fail\n"}
}
sleep_sec 3
DUT_ipmitool 1 "sensor get \"$expectout_spec\"" "$DUT_prompt"
#sel
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
DUT_ipmitool 1 "sel clear" "$DUT_prompt"
sleep_sec 3
#lower deasserted
set sensor_dlnr [ expr $expectout_spec_reading - 4*$expectout_hysteresis ]
set sensor_dlcr [ expr $expectout_spec_reading - 3*$expectout_hysteresis ]
set sensor_dlnc [ expr $expectout_spec_reading - 2*$expectout_hysteresis ]
sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" lnr $sensor_dlnr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dlnr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlnr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlnr: fail\n"}
}
sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" lcr $sensor_dlcr\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dlcr: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlcr: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlcr: fail\n"}
}
sleep_sec 3
send -s "ipmitool sensor thresh \"$expectout_spec\" lnc $sensor_dlnc\r"
expect {
"$DUT_prompt" {sendU_log "ipmitool sensor thresh sensor_dlnc: pass\n"}
default {sendU_log "ipmitool sensor thresh sensor_dlnc: fail\n";append error_message "ipmitool sensor get \"ipmitool sensor thresh sensor_dlnc: fail\n"}
}
sleep_sec 3
#sensor get
DUT_ipmitool 1 "sensor get \"$expectout_spec\"" "$DUT_prompt"
#sel
DUT_ipmitool 1 "sel elist " "$DUT_prompt"
DUT_ipmitool 1 "sel clear " "$DUT_prompt"
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "\r"
expect {
"$Con_server_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
DUT_login
}
default {puts "do nothing!";}
}
}
}
}
#check sensor spec. line by line by expect_out buffer
proc DUT_sensor_check_6 { {sleep_time1 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt sel_get_time sel_amount sensor_spec sensor_spec_thresh_VOL_TEMP sensor_spec_thresh_FAN Test_server_prompt work_dir sensor_spec
match_max 5000
#get sensor amount
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor |wc -l\r"
expect {
-re "wc.*\r\n(.*)\r\n.*" {set expectout_sensor_amount $expect_out(1,string);send -s "\r"}
}
puts "expectout_sensor_amount = $expectout_sensor_amount"
#get sensor list from sepc file, line by line to variable
set openfile [open \/home\/user\/auto\/acpi6\/main\/spec\/sensor_spec_acpi6_1-1.txt]
set readfile [read $openfile]
set spec_splitn [split $readfile \n]
#get sensor list from dut reading, line by line to variable
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor list |cut -d \"|\" -f \"1,3-10\"|sed 's/ *$//g'\r"
expect {
-re "//g.*\r\n(.*)$Test_server_prompt" {set expectout_dut $expect_out(0,string);send -s "\r"}
}
set dut_splitn [split [string trim $expectout_dut "//g'\\r\\n"] \n]
#delect lindex 0 , coz it's empty line
set dut_splitn [ lreplace $dut_splitn 0 0 ]
puts "dut_splitn = $dut_splitn"
for { set i 0 ; set i2 0} { $i <= [string trim $expectout_sensor_amount] } { incr i ; incr i2} {
if {[string match [lindex $spec_splitn $i] [lindex $dut_splitn $i2] ]==1} {
sendU_log "\nSensor reading = [lindex $dut_splitn $i2]\nExpected string match [lindex $spec_splitn $i] : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nSensor reading = [lindex $dut_splitn $i2]\nExpected string match [lindex $spec_splitn $i] : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
#puts "expected_result = $expected_result"
#puts "expectout = $expectout"
}
}
#close $readfile
}
#check sensor spec. by expect_out buffer
proc DUT_sensor_check_5 { {sleep_time1 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt sel_get_time sel_amount sensor_spec sensor_spec_thresh_VOL_TEMP sensor_spec_thresh_FAN Test_server_prompt work_dir sensor_spec
#Send_expectout "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor list |cut -d \"|\" -f \"1,3-10\"|sed 's/ *$//g'\r" "//g(.*)$Test_server_prompt" "*degrees C*"
match_max 5000
set read_log_1 [open $work_dir\/spec\/$sensor_spec]
set expected_result [read $read_log_1]
#puts $expected_result
close $read_log_1
puts "expected_result = $expected_result\r\n"
#set expected_result "*degrees C*"
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor list |cut -d \"|\" -f \"1,3-10\"|sed 's/ *$//g'\r"
expect {
-re "//g(.*)$Test_server_prompt" {set expectout $expect_out(1,string);send -s "\r"}
}
puts "expectout = $expectout\r\n"
if {[string match [string trim $expected_result \r\n ] [string trim $expectout \r\n ] ]==1} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
#puts "expected_result = $expected_result"
#puts "expectout = $expectout"
}
}
#check sensor spec. , line by line
proc DUT_sensor_check_4 { {sleep_time1 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt sel_get_time sel_amount sensor_spec sensor_spec_thresh_VOL_TEMP sensor_spec_thresh_FAN Test_server_prompt work_dir
puts "\nrunning proc DUT_sensor_check {}"
expect {
$Test_server_prompt {
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor list | wc -l\r"
expect {
-re "\r\n(\[0-9a-z]*)\r\n" {set sensor_amount $expect_out(1,string)}
}
for {set k 1} {$k <= $sensor_amount} {incr k} {
#get sensor name
send -s "cat $work_dir\/spec\/$sensor_spec |grep \"a$k \"|awk 'BEGIN {FS=\"|\"}; {print \$2}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "sed.*\r\n(.*)\r\n" {set expectout_sensor_name $expect_out(1,string)}
}
puts "expectout_sensor_name = $expectout_sensor_name"
sleep 7
#get sensor spec
send -s "cat $work_dir\/spec\/$sensor_spec |grep --color=never \"a$k \"|cut -d \"|\" -f \"2,4-11\"\r"
expect {
-re "grep.*\r\n(.*)\r\n" {set expectout_spec $expect_out(1,string)}
}
puts "expectout_spec = $expectout_spec"
sleep 7
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw sensor list |grep --color=never \"$expectout_sensor_name \"|cut -d \"|\" -f \"1,3-10\"|sed 's/ *$//g'\r"
expect {
-re "ipmitool.*\r\n(.*)\r\n" {set expectout_dut $expect_out(1,string)}
}
puts "expectout_dut = $expectout_dut"
#it's for gloable style rex
set s *
append s $expectout_dut $s
puts "s = $s"
if { [string match $s $expectout_spec] ==1 } {
sendU_log "expectout_dut $expectout_dut = expectout_spec $expectout_spec : pass\n"
} else {
sendU_log "expectout_dut $expectout_dut != expectout_spec $expectout_spec : fail\n";append error_message "expect_out buffer: fail\n"
}
}
}
}
}
#check sensor spec. , column by column
proc DUT_sensor_check_2 {check_id {sleep_time1 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt sel_get_time sel_amount sensor_spec sensor_spec_thresh_VOL_TEMP sensor_spec_thresh_FAN
puts "\nrunning proc DUT_sensor_check {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
#send -s "\r"
#expect {
# "$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
# default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
#}
send -s "ipmitool sensor list | wc -l\r"
expect {
-re "\r\n(\[0-9a-z]*)\r\n" {set sensor_amount $expect_out(1,string)}
}
for {set k 1} {$k <= $sensor_amount} {incr k} {
send -s "cat $sensor_spec |grep \"a$k \"|awk 'BEGIN {FS=\"|\"}; {print \$2}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec $expect_out(1,string)}
}
send -s "ipmitool sensor list |grep \"$expectout_spec \"|cut -d \"|\" -f 1|sed 's/ *$//g'\r"
expect {
-re "ipmitool.*\r\n(.*)\r\n" {set expectout_dut $expect_out(1,string)}
}
if { "$expectout_dut" == "$expectout_spec" } {
sendU_log "expectout_dut $expectout_dut = expectout_spec $expectout_spec : pass\n"
} else {
sendU_log "expectout_dut $expectout_dut != expectout_spec $expectout_spec : fail\n";append error_message "expect_out buffer: fail\n"
}
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
#the second for loop is for all the value of sensor
for {set k2 6} {$k2 <= 11} {incr k2} {
send -s "cat $sensor_spec |grep \"$expectout_spec \"|cut -d \"|\" -f \"$k2\"|tr -d \" \" \r"
expect {
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_v $expect_out(1,string)}
}
set sensor_list_col [ expr $k2 - 1 ]
send -s "ipmitool sensor list |grep \"$expectout_spec \"|cut -d \"|\" -f \"$sensor_list_col\"|tr -d \" \" \r"
expect {
-re "ipmitool.*\r\n(.*)\r\n" {set expectout_dut_v $expect_out(1,string)}
}
send_user "DUT. expectout_dut = $expectout_dut_v\n"
if { "$expectout_dut_v" == "$expectout_spec_v" } {
sendU_log "DUT $expectout_dut sensor ID : $k : column $sensor_list_col : $expectout_dut_v = SPEC. $expectout_spec : column $k2 : $expectout_spec_v : pass\n"
} else {
sendU_log "DUT $expectout_dut sensor ID : $k : column $sensor_list_col : $expectout_dut_v != SPEC. $expectout_spec : column $k2 : $expectout_spec_v: fail\n";append error_message "expect_out buffer: fail\n"
}
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
}
#unset expect_out(buffer)
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "\r"
expect {
"$Con_server_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
DUT_login
}
default {puts "do nothing!";}
}
}
}
}
proc DUT_sensor_check {check_id {sleep_time1 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt sel_get_time sel_amount sensor_spec sensor_spec_thresh_VOL_TEMP sensor_spec_thresh_FAN
puts "\nrunning proc DUT_sensor_check {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
send -s "ipmitool sensor list | wc -l\r"
sleep_sec 1
expect {
-re "\r\n(\[0-9a-z]*)\r\n" {set sensor_amount $expect_out(1,string)}
}
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
##sleep_sec 1
##puts "sensor_amount=$sensor_amount"
##sendU_log "sensor_amount is $sensor_amount\n"
#this first loop is for geting sensor number and sensor name
for {set k 1} {$k <= $sensor_amount} {incr k} {
#a$k is for sensor number from spec. file.
#puts "ak = a$k"
#get a sensor value from spec.
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
unset expect_out(buffer)
puts "unset expect_out(buffer)"
#send -s "cat 3260_sensor_spec.txt |grep \"a$k \"|awk 'BEGIN {FS=\"|\"}; {print \$2}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
send -s "cat $sensor_spec |grep \"a$k \"|awk 'BEGIN {FS=\"|\"}; {print \$2}'|sed 's/ *$//g'|sed 's/^ *//g'\r"
sleep_sec 1
expect {
#-re "g'\r\n(.*)\r\n" {set expectout_spec $expect_out(1,string)}
-re "cat.*\r\n(.*)\r\n" {set expectout_spec $expect_out(1,string)}
}
#sleep_sec 1
#puts "expectout_spec = $expectout_spec\n"
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
#get a sensor value from dut
#send -s "ii |grep \"$expectout_spec \"|cut -d \"|\" -f 1|sed 's/ *$//g'\r"
send -s "ipmitool sensor list |grep \"$expectout_spec \"|cut -d \"|\" -f 1|sed 's/ *$//g'\r"
sleep_sec 1
expect {
-re "ipmitool.*\r\n(.*)\r\n" {set expectout_dut $expect_out(1,string)}
}
#sleep_sec 1
#puts "expectout_dut = $expectout_dut\n"
if { "$expectout_dut" == "$expectout_spec" } {
sendU_log "expectout_dut $expectout_dut = expectout_spec $expectout_spec : pass\n"
} else {
sendU_log "expectout_dut $expectout_dut != expectout_spec $expectout_spec : fail\n";append error_message "expect_out buffer: fail\n"
}
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
#the second for loop is for all the value of sensor
for {set k2 6} {$k2 <= 11} {incr k2} {
#puts "ak = a$k2"
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
send -s "cat $sensor_spec |grep \"$expectout_spec \"|cut -d \"|\" -f \"$k2\"|tr -d \" \" \r"
sleep_sec 1
expect {
#-re "\r\n(\[0-9A-Za-z].*)\r\n" {set expectout_spec_v $expect_out(1,string)}
-re "cat.*\r\n(.*)\r\n" {set expectout_spec_v $expect_out(1,string)}
}
#sleep_sec 1
#send_user "SPEC. $expectout_spec = $expectout_spec_v\n"
#puts "expectout_spec_v = $expectout_spec_v\n"
# $sensor_list_col is for dut sensor value
set sensor_list_col [ expr $k2 - 1 ]
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
#send -s "ii |grep \"$expectout_spec \"|cut -d \"|\" -f \"$sensor_list_col\"|tr -d \" \" \r"
send -s "ipmitool sensor list |grep \"$expectout_spec \"|cut -d \"|\" -f \"$sensor_list_col\"|tr -d \" \" \r"
sleep_sec 1
expect {
#-re "\r\n(\[0-9A-Za-z].*)\r\n" {set expectout_dut_v $expect_out(1,string)}
-re "ipmitool.*\r\n(.*)\r\n" {set expectout_dut_v $expect_out(1,string)}
}
sleep_sec 1
send_user "DUT. expectout_dut = $expectout_dut_v\n"
if { "$expectout_dut_v" == "$expectout_spec_v" } {
sendU_log "DUT $expectout_dut sensor ID : $k : column $sensor_list_col : $expectout_dut_v = SPEC. $expectout_spec : column $k2 : $expectout_spec_v : pass\n"
} else {
sendU_log "DUT $expectout_dut sensor ID : $k : column $sensor_list_col : $expectout_dut_v != SPEC. $expectout_spec : column $k2 : $expectout_spec_v: fail\n";append error_message "expect_out buffer: fail\n"
}
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
}
#unset expect_out(buffer)
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "\r"
expect {
"$Con_server_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
DUT_login
}
default {puts "do nothing!";}
}
}
}
}
#####
proc DUT_sensor_spec_check {check_id} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt
puts "\nrunning proc DUT_sensor_spec_check {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
send -s "\r"
expect $DUT_prompt
send -s "ipmitool sensor list | wc -l\r"
sleep_sec 1
expect {
-re "\r\n(\[0-9a-z]*)\r\n" {set sensor_amount $expect_out(1,string)}
}
sleep_sec 1
puts "sensor_amount=$sensor_amount"
sendU_log "sensor amount is $sensor_amount\n"
#set sleep_time [ expr $sensor_amount / 6 ]
#send -s "ipmitool sel elist\r"
#sleep_sec $sleep_time
sleep_sec 1
if { $sensor_amount == 0} {
puts "sensor is empty"
} else {
for {set k 1} {$k <= $sensor_amount} {incr k} {
send -s "ipmitool sensor get $k\r"
sleep_sec 1
}
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "\r"
expect $Con_server_prompt
sleep_sec 1
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw sel list |wc -l\r"
sleep_sec 1
expect {
#-re "\r\n(.*)\r\n(.*)\r\n" {set sel_amount $expect_out(2,string)}
-re "\r\n(.*)\r\n(\[0-9a-z]*)\r\n" {set sel_amount $expect_out(2,string)}
}
puts "\nsel_amount=$sel_amount"
#remove all space as blow 2 methods
#set sel_amount [string map {" " ""} $sel_amount];
#set sel_amount [string trim $sel_amount " "]
#conver hex2dec
set hex2dec [expr 0x$sel_amount]
puts "\nsel_amount = $sel_amount"
puts "\nhex2dec=$sel_amount"
set sleep_time [ expr $sel_amount / 6 ]
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw sel elist\r"
sleep_sec $sleep_time
expect {
"$Con_server_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
if { $sel_amount == 0} {
puts "SEL is empty"
} else {
for {set k 1} {$k <= $sel_amount} {incr k} {
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw sel get $k\r"
sleep_sec 1
}
}
DUT_login
}
default {puts "do nothing!";}
}
}
}
}
#####
proc DUT_sel_gen_unknown {count_num} {
global error_message sendU_log DUT_prompt sensor_file_path image_ip sensor_file
puts "\nrunning proc DUT_sel_gen_unknown {}"
expect {
$DUT_prompt {
for {set count 0} {$count < $count_num} {incr count} {
send -s "ipmitool raw 0x0a 0x44 0x00 0x00 0x02 0x00 0x00 0x00 0x00 0x00 0x00 0x04 0xc2 0x00 0x6f 0x00 0x00 0x00\r"
#send -s "ipmitool -I open event 1\r"
#sleep_sec 1
puts "sel count = $count\n"
expect {
"$DUT_prompt" {sendU_log "DUT_sel_gen_unknown : pass\n"}
default { sendU_log "DUT_sel_gen_unknown : fail\n";append error_message "DUT_sel_gen_unknown : fail\n"}
}
}
}
}
}
proc DUT_dynamic_credential_check {check_id {sleep_time1 1}} {
global error_message sendU_log DUT_prompt BMC_ip BMC_user BMC_pw Con_server_prompt sel_get_time con_server_ip2_hex ascii_user ascii_pw
puts "\nrunning proc DUT_dynamic_credential_check {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
puts "con_server_ip2_hex = $con_server_ip2_hex"
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
#it's for 5342
#send -s "ipmitool raw 0x2c 0x3f 0x00 0x00 0x00 0x01 0x01 0x04 0x03 0xff 0xff 0xff 0xff $con_server_ip2_hex | awk '{print \$2}'\r"
#it's for acpi6
send -s "ipmitool raw 0x2c 0x3f 0x00 0x00 0x00 0x01 0x01 0x04 0x01 0xff 0xff 0xff 0xff $con_server_ip2_hex | awk '{print \$2}'\r"
sleep_sec 1
expect {
-re "ipmitool.*\r\n(.*)\r\n" {set expectout $expect_out(1,string)}
}
puts "expectout = $expectout"
send -s "ipmitool raw 0x2c 0x3f 0x00 0x$expectout 0x02\r\n"
sleep_sec 1
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
send -s "ipmitool raw 0x2c 0x3f 0x00 0x$expectout 0x03\r\n"
sleep_sec 1
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
#get password
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
send -s "ipmitool raw 0x2c 0x3f 0x00 0x$expectout 0x04|awk '{print \$4,\$5,\$6,\$7,\$8,\$9,\$10,\$11,\$12,\$13,\$14}'\r"
sleep_sec 1
expect {
#-re "ipmitool.*\r\n(.*)\r\n" {set expectout_pw1 $expect_out(1,string)}
-re "awk.*\r\n(.*)\r\n" {set expectout_pw1 $expect_out(1,string)}
}
puts "expectout_pw1=$expectout_pw1"
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
send -s "ipmitool raw 0x2c 0x3f 0x00 0x$expectout 0x05|awk '{print \$4,\$5,\$6,\$7,\$8,\$9,\$10,\$11,\$12,\$13,\$14}'\r"
sleep_sec 1
expect {
#-re "ipmitool.*\r\n(.*)\r\n" {set expectout_pw2 $expect_out(1,string)}
-re "awk.*\r\n(.*)\r\n" {set expectout_pw2 $expect_out(1,string)}
}
puts "expectout_pw2=$expectout_pw2"
#example for hex to ascii
#+++++++++++++++++++++
#jc@bmc-project:~$ tclsh
#%
#% set hex {{} 45 4c 72 42 45 4c 46 5a 53 51 30 48 4a 70 54 00 00 00 00 00}
#{} 45 4c 72 42 45 4c 46 5a 53 51 30 48 4a 70 54 00 00 00 00 00
#% set ascii [ subst [ join $hex \\x ] ]
#ELrBELFZSQ0HJpT
#
#+++++++++++++++++++++
#set hex "45 4c 72 42 45 4c 46 5a 53 51 30 48 4a 70 54 00 00 00 00 00"
#set hex_convert [join $hex ""]
#binary format H* $hex_convert
#set ascii [binary format H* $hex_convert ]
#+++++++++++++++++++++
#conver hex2dec
#set hex2dec [expr 0x$sel_amount]
#puts "\nsel_amount = $sel_amount"
#puts "\nhex2dec=$sel_amount"
#+++++++++++++++++++++
#convert hex to ascii
set hex "$expectout_pw1 $expectout_pw2"
puts "hex = $hex"
set hex_converter [join $hex ""]
puts "hex_converter = $hex_converter"
set ascii_pw [binary format H* $hex_converter ]
puts "ascii_pw = $ascii_pw"
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
#get username
send -s "ipmitool user list |grep ^6|awk '{print \$2}'\r"
sleep_sec 1
expect {
-re "ipmitool.*\r\n(.*)\r\n" {set ascii_user $expect_out(1,string)}
}
puts "ascii_user = $ascii_user"
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "\r"
expect {
"$Con_server_prompt" {sendU_log "read Con_server_prompt status : pass\n"}
default {sendU_log "read Con_server_prompt status : fail\n";append error_message "read Con_server_prompt status: fail\n"}
}
DUT_login
}
default {puts "do nothing!";}
}
}
}
}
#==================================================
#proc : lan
#==================================================
proc DUT_linux_lan_set {} {
global error_message sendU_log DUT_prompt BMC_ip OS_ip con_server_ip DUT_netmask OS_interface
puts "\nrunning proc DUT_linux_lan_set {}"
Send_expectout "ifconfig $OS_interface $OS_ip netmask $DUT_netmask" "ifconfig(.*)$DUT_prompt" "*"
#expect {
# $DUT_prompt {
#
# send -s "ifconfig $OS_interface $OS_ip netmask $DUT_netmask\r"
# expect {
# "$DUT_prompt" {sendU_log "DUT_linux_lan_set : pass\n"}
# default { sendU_log "DUT_linux_lan_set : fail\n";append error_message "DUT_linux_lan_set : fail\n"}
# }
# }
#}
}
proc DUT_bmc_lan_set {} {
global error_message sendU_log DUT_prompt BMC_ip OS_ip con_server_ip DUT_netmask OS_interface DUT_default_gw bmc_lan_interface BMC_macaddr com_check_time dut_num BMC_macaddr2 BMC_macaddr3 BMC_macaddr4 BMC_ip2 BMC_ip3 BMC_ip4 DUT_model BMC_lan_count
puts "\nrunning proc DUT_bmc_lan_set {}"
if { "$BMC_lan_count" == 1 } {
#Send_expectout "ipmitool lan print $bmc_lan_interface" "ipmitool lan print(.*)$DUT_prompt" "*IP Address Source : Static Address*"
Send_expectout "ipmitool lan set $bmc_lan_interface macaddr $BMC_macaddr" "ipmitool(.*)$DUT_prompt" "*$BMC_macaddr*"
Send_expectout "ipmitool lan set $bmc_lan_interface ipaddr $BMC_ip" "ipmitool(.*)$DUT_prompt" "*$BMC_ip*"
Send_expectout "ipmitool lan set $bmc_lan_interface netmask $DUT_netmask" "ipmitool(.*)$DUT_prompt" "*$DUT_netmask*"
Send_expectout "ipmitool lan set $bmc_lan_interface defgw ipaddr $DUT_default_gw" "ipmitool(.*)$DUT_prompt" "*$DUT_default_gw*"
} elseif { "$BMC_lan_count" == 2 } {
#Send_expectout "ipmitool lan print $bmc_lan_interface" "ipmitool lan print(.*)$DUT_prompt" "*IP Address Source : Static Address*"
sleep_sec 1
Send_expectout "ipmitool lan set $bmc_lan_interface macaddr $BMC_macaddr" "ipmitool(.*)$DUT_prompt" "*$BMC_macaddr*"
sleep_sec 1
Send_expectout "ipmitool lan set 2 macaddr $BMC_macaddr2" "ipmitool(.*)$DUT_prompt" "*$BMC_macaddr2*"
sleep_sec 1
Send_expectout "ipmitool lan set $bmc_lan_interface ipaddr $BMC_ip" "ipmitool(.*)$DUT_prompt" "*"
sleep_sec 1
Send_expectout "ipmitool lan set 2 ipaddr $BMC_ip2" "ipmitool(.*)$DUT_prompt" "*$BMC_ip2*"
sleep_sec 1
Send_expectout "ipmitool lan set $bmc_lan_interface netmask $DUT_netmask" "ipmitool(.*)$DUT_prompt" "*$DUT_netmask*"
sleep_sec 1
Send_expectout "ipmitool lan set $bmc_lan_interface defgw ipaddr $DUT_default_gw" "ipmitool(.*)$DUT_prompt" "*$DUT_default_gw*"
sleep_sec 1
Send_expectout "ipmitool lan print $bmc_lan_interface" "ipmitool(.*)$DUT_prompt" "*"
Send_expectout "ipmitool lan print 2" "ipmitool(.*)$DUT_prompt" "*"
} elseif { "$BMC_lan_count" == 4 } {
#Send_expectout "ipmitool lan print $bmc_lan_interface" "ipmitool lan print(.*)$DUT_prompt" "*IP Address Source : Static Address*"
Send_expectout "ipmitool lan set $bmc_lan_interface macaddr $BMC_macaddr" "ipmitool(.*)$DUT_prompt" "*$BMC_macaddr*"
Send_expectout "ipmitool lan set 2 macaddr $BMC_macaddr2" "ipmitool(.*)$DUT_prompt" "*$BMC_macaddr2*"
Send_expectout "ipmitool lan set 3 macaddr $BMC_macaddr3" "ipmitool(.*)$DUT_prompt" "*$BMC_macaddr3*"
Send_expectout "ipmitool lan set 4 macaddr $BMC_macaddr4" "ipmitool(.*)$DUT_prompt" "*$BMC_macaddr4*"
Send_expectout "ipmitool lan set $bmc_lan_interface ipaddr $BMC_ip" "ipmitool(.*)$DUT_prompt" "*$BMC_ip*"
Send_expectout "ipmitool lan set 2 ipaddr $BMC_ip2" "ipmitool(.*)$DUT_prompt" "*$BMC_ip2*"
Send_expectout "ipmitool lan set 3 ipaddr $BMC_ip3" "ipmitool(.*)$DUT_prompt" "**$BMC_ip3*"
Send_expectout "ipmitool lan set 4 ipaddr $BMC_ip4" "ipmitool(.*)$DUT_prompt" "**$BMC_ip4*"
Send_expectout "ipmitool lan set $bmc_lan_interface netmask $DUT_netmask" "ipmitool(.*)$DUT_prompt" "*$DUT_netmask*"
Send_expectout "ipmitool lan set $bmc_lan_interface defgw ipaddr $DUT_default_gw" "ipmitool(.*)$DUT_prompt" "*"
Send_expectout "ipmitool lan print $bmc_lan_interface" "ipmitool lan print(.*)$DUT_prompt" "*IP Address*$BMC_ip*Subnet Mask*$DUT_netmask*MAC Address*$BMC_macaddr*Default Gateway IP*$DUT_default_gw*"
Send_expectout "ipmitool lan print 2" "ipmitool(.*)$DUT_prompt" "*IP Address*$BMC_ip2*Subnet Mask*$DUT_netmask2*MAC Address*$BMC_macaddr2*Default Gateway IP*$DUT_default_gw*"
Send_expectout "ipmitool lan print 3" "ipmitool(.*)$DUT_prompt" "*IP Address*$BMC_ip3*Subnet Mask*$DUT_netmask3*MAC Address*$BMC_macaddr3*Default Gateway IP*$DUT_default_gw*"
Send_expectout "ipmitool lan print 4" "ipmitool(.*)$DUT_prompt" "*IP Address*$BMC_ip4*Subnet Mask*$DUT_netmask4*MAC Address*$BMC_macaddr4*Default Gateway IP*$DUT_default_gw*"
} else {
send_user "there is no bmc lan interface for testing"
}
}
proc DUT_bmc_lan_set_bak {} {
global error_message sendU_log DUT_prompt BMC_ip OS_ip con_server_ip DUT_netmask OS_interface DUT_default_gw bmc_lan_interface BMC_macaddr com_check_time dut_num BMC_macaddr2 BMC_macaddr3 BMC_macaddr4 BMC_ip2 BMC_ip3 BMC_ip4 DUT_model
puts "\nrunning proc DUT_bmc_lan_set {}"
expect {
$DUT_prompt {
puts "\nrunning proc DUT_lanset {}"
#sleep_sec "$com_check_time"
send -s "ipmitool lan print $bmc_lan_interface\r"
#sleep_sec "$com_check_time"
expect {
"$DUT_prompt" {sendU_log " lan print $bmc_lan_interface : pass\n"}
default { sendU_log " lan print $bmc_lan_interface : fail\n";append error_message " lan print $bmc_lan_interface : fail\n"}
}
#main test interface
send -s "ipmitool lan set $bmc_lan_interface macaddr $BMC_macaddr\r"
expect {
"$BMC_macaddr" {sendU_log "lan set bmc macaddr : pass\n"}
default { sendU_log "lan set bmc macaddr : fail\n";append error_message "lan set bmc macaddr : fail\n"}
}
#sleep_sec "$com_check_time"
#for acpi6 or 4 lan interfaces on bmc
#if "$dut_num" <= "16" , the dut will be 5342, but it's not good modification
if { "$dut_num" <= "16" && "$DUT_model" == "5342" } {
#send -s "ipmitool lan set $bmc_lan_interface macaddr $BMC_macaddr2\r"
send -s "ipmitool lan set 2 macaddr $BMC_macaddr2\r"
expect {
"$BMC_macaddr2" {sendU_log "lan set bmc macaddr : pass\n"}
default { sendU_log "lan set bmc macaddr : fail\n";append error_message "lan set bmc macaddr2 : fail\n"}
}
#send -s "ipmitool lan set $bmc_lan_interface macaddr $BMC_macaddr3\r"
send -s "ipmitool lan set 2 macaddr $BMC_macaddr3\r"
expect {
"$BMC_macaddr3" {sendU_log "lan set bmc macaddr : pass\n"}
default { sendU_log "lan set bmc macaddr : fail\n";append error_message "lan set bmc macaddr3 : fail\n"}
}
#send -s "ipmitool lan set $bmc_lan_interface macaddr $BMC_macaddr4\r"
send -s "ipmitool lan set 4 macaddr $BMC_macaddr4\r"
expect {
"$BMC_macaddr4" {sendU_log "lan set bmc macaddr : pass\n"}
default { sendU_log "lan set bmc macaddr : fail\n";append error_message "lan set bmc macaddr4 : fail\n"}
}
#if bmc_lan_interface = 1 , the below lan set will be 2
#for acpi6 or 2 lan interfaces on bmc
} elseif { "$dut_num" <= "16" && "$DUT_model" == "acpi6" } {
send -s "ipmitool lan set 2 macaddr $BMC_macaddr2\r"
expect {
"$BMC_macaddr2" {sendU_log "lan set bmc macaddr : pass\n"}
default { sendU_log "lan set bmc macaddr : fail\n";append error_message "lan set bmc macaddr2 : fail\n"}
}
} else {
send_user "it's not 2 or 4 lan interfaces on bmc"
}
send -s "ipmitool lan print $bmc_lan_interface\r"
#sleep_sec "$com_check_time"
expect {
"$DUT_prompt" {sendU_log " lan print $bmc_lan_interface : pass\n"}
default { sendU_log " lan print $bmc_lan_interface : fail\n";append error_message " lan print $bmc_lan_interface : fail\n"}
}
#main test interface
send -s "ipmitool lan set $bmc_lan_interface ipaddr $BMC_ip\r"
expect {
"$BMC_ip" {sendU_log "lan set bmc ipaddr : pass\n"}
default { sendU_log "lan set bmc ip check : fail\n";append error_message "lan set bmc ip check : fail\n"}
}
if { "$dut_num" <= "16" && "$DUT_model" == "5342" } {
send -s "ipmitool lan set 1 ipaddr $BMC_ip2\r"
expect {
"$BMC_ip2" {sendU_log "lan set bmc BMC_ip2 : pass\n"}
default { sendU_log "lan set bmc BMC_ip2 : fail\n";append error_message "lan set bmc BMC_ip2 : fail\n"}
}
send -s "ipmitool lan set 2 ipaddr $BMC_ip3\r"
expect {
"$BMC_ip3" {sendU_log "lan set bmc BMC_ip3 : pass\n"}
default { sendU_log "lan set bmc BMC_ip3 : fail\n";append error_message "lan set bmc BMC_ip3 : fail\n"}
}
send -s "ipmitool lan set 4 ipaddr $BMC_ip4\r"
expect {
"$BMC_ip4" {sendU_log "lan set bmc BMC_ip4 : pass\n"}
default { sendU_log "lan set bmc BMC_ip4 : fail\n";append error_message "lan set bmc BMC_ip4 : fail\n"}
}
#if bmc_lan_interface = 1 , the below lan set will be 2
} elseif { "$dut_num" <= "16" && "$DUT_model" == "acpi6" } {
send -s "ipmitool lan set 2 ipaddr $BMC_ip2\r"
expect {
"$BMC_ip2" {sendU_log "lan set bmc BMC_ip2 : pass\n"}
default { sendU_log "lan set bmc BMC_ip2 : fail\n";append error_message "lan set bmc BMC_ip2 : fail\n"}
}
} else {
send_user "it's not 2 or 4 lan interfaces on bmc"
}
#sleep_sec "$com_check_time"
send -s "ipmitool lan print $bmc_lan_interface\r"
#sleep_sec "$com_check_time"
expect {
"$DUT_prompt" {sendU_log " lan print $bmc_lan_interface : pass\n"}
default { sendU_log " lan print $bmc_lan_interface : fail\n";append error_message " lan print $bmc_lan_interface : fail\n"}
}
send -s "ipmitool lan set $bmc_lan_interface defgw ipaddr $DUT_default_gw\r"
expect {
"$DUT_default_gw" {sendU_log "lan set bmc default gw : pass\n"}
default { sendU_log "lan set bmc default gw : fail\n";append error_message "lan set bmc default gw : fail\n"}
}
#sleep_sec "$com_check_time"
send -s "ipmitool lan print $bmc_lan_interface\r"
#sleep_sec "$com_check_time"
expect {
"$DUT_prompt" {sendU_log " lan print $bmc_lan_interface : pass\n"}
default { sendU_log " lan print $bmc_lan_interface : fail\n";append error_message " lan print $bmc_lan_interface : fail\n"}
}
send -s "ipmitool lan set $bmc_lan_interface netmask $DUT_netmask\r"
expect {
"$DUT_netmask" {sendU_log "lan set bmc netmask : pass\n"}
default { sendU_log "lan set bmc netmask : fail\n";append error_message "lan set bmc ip netmask : fail\n"}
}
sleep_sec "$com_check_time"
send -s "ipmitool lan print $bmc_lan_interface\r"
#sleep_sec "$com_check_time"
expect {
"$DUT_prompt" {sendU_log " lan print $bmc_lan_interface : pass\n"}
default { sendU_log " lan print $bmc_lan_interface : fail\n";append error_message " lan print $bmc_lan_interface : fail\n"}
}
}
}
}
proc DUT_fw_scp {fw_path} {
global error_message sendU_log DUT_prompt Con_server_prompt BMC_ip OS_ip BMC_user BMC_pw con_server_ip1 con_server_ip2 con_server_user con_server_pw test_server_pw test_server_user test_server_ip2
puts "\nrunning proc DUT_fw_scp {}"
expect {
$DUT_prompt {
#send -s "scp jc@$con_server_ip2:\/home\/user\/regression\/3260\/fireeye\/* .\r"
send -s "\r"
expect {
"$DUT_prompt" {sendU_log "clear expect_out buffer : pass\n"}
default {sendU_log "clear expect_out buffer : fail\n";append error_message "clear expect_out buffer: fail\n"}
}
send -s "scp $con_server_user@$con_server_ip2:$fw_path* .\r"
#send -s "scp $test_server_user@$test_server_ip2:$fw_path* .\r"
sleep_sec 5
expect {
-ex "(yes/no)?" { send "yes\r"; exp_continue}
"*password:*" { send "$test_server_pw\r" ; exp_continue}
"$DUT_prompt" { sendU_log "DUT_fw_scp : pass\n"}
default {append error_message "DUT_fw_scp : fail\n" ; exit}
}
}
}
}
#####################################################
proc DUT_fw_upgrade {{check_id} {fw_ver} {chk_fw_ver} {sleep_time1 10} { zbuffer 1055 }} {
global error_message sendU_log DUT_prompt BMC_ip bootloader_path bl_ver ipmc_path ipmc_ver bios_path bios_ver nvram_path nvram_ver bootloader_file ipmc_file bios_file nvram_file shmm_ip ipmb_addr Con_server_prompt BMC_pw BMC_user
#check_id 1 = kcs
#check_id 2 = iol lan
#check_id 3 = iol lanplus
#check_id 4 = ipmb
#check_id 5 = os2bmc
puts "\nrunning proc DUT_fw_upgrade { fw_ver = $fw_ver }"
puts "check_id = $check_id"
expect {
"$DUT_prompt" {
switch -exact $check_id {
1 {
send -s "ipmitool hpm upgrade $fw_ver force $zbuffer\r"
sleep_sec 1
expect "(y/n):"
send -s "y\r"
expect {
-re "y(.*)$DUT_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
set expected_result "*|*|*$chk_fw_ver 00000000*Firmware upgrade procedure successful*"
if {[string match $expected_result $expectout ]==1 && [string match -nocase "*fail*" $expectout ]==0 && [string match -nocase "*unable*" $expectout ]==0 && [string match -nocase "*error*" $expectout ]==0} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
puts "expected_result = $expected_result"
puts "expectout = $expectout"
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw hpm upgrade $fw_ver force\r"
sleep_sec 1
expect "(y/n):"
send -s "y\r"
expect {
-re "y(.*)$Con_server_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
set expected_result "*|*|*$chk_fw_ver 00000000*Firmware upgrade procedure successful*"
if {[string match $expected_result $expectout ]==1 && [string match -nocase "*fail*" $expectout ]==0 && [string match -nocase "*unable*" $expectout ]==0 && [string match -nocase "*error*" $expectout ]==0} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
puts "expected_result = $expected_result"
puts "expectout = $expectout"
}
DUT_login
}
3 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw hpm upgrade $fw_ver force\r"
sleep_sec 1
expect "(y/n):"
send -s "y\r"
expect {
-re "y(.*)$Con_server_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
set expected_result "*|*|*$chk_fw_ver 00000000*Firmware upgrade procedure successful*"
if {[string match $expected_result $expectout ]==1 && [string match -nocase "*fail*" $expectout ]==0 && [string match -nocase "*unable*" $expectout ]==0 && [string match -nocase "*error*" $expectout ]==0} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
puts "expected_result = $expected_result"
puts "expectout = $expectout"
}
DUT_login
}
4 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
send -s "ipmitool -I lan -H $shmm_ip -A none -t $ipmb_addr hpm upgrade $fw_ver force\r"
sleep_sec 1
expect "(y/n):"
send -s "y\r"
expect {
-re "y(.*)$Con_server_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
set expected_result "*|*|*$chk_fw_ver 00000000*Firmware upgrade procedure successful*"
if {[string match $expected_result $expectout ]==1 && [string match -nocase "*fail*" $expectout ]==0 && [string match -nocase "*unable*" $expectout ]==0 && [string match -nocase "*error*" $expectout ]==0} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
puts "expected_result = $expected_result"
puts "expectout = $expectout"
}
DUT_login
}
5 {
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw hpm upgrade $fw_ver force\r"
expect "(y/n):"
send -s "y\r"
#sleep_sec $sleep_time1
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
}
}
}
}
}
proc DUT_fw_upgrade_bak {{check_id} {fw_ver} {sleep_time1 10} { zbuffer 254 }} {
global error_message sendU_log DUT_prompt BMC_ip bootloader_path bl_ver ipmc_path ipmc_ver bios_path bios_ver nvram_path nvram_ver bootloader_file ipmc_file bios_file nvram_file shmm_ip ipmb_addr Con_server_prompt BMC_pw BMC_user
#check_id 1 = kcs
#check_id 2 = iol lan
#check_id 3 = iol lanplus
puts "\nrunning proc DUT_fw_upgrade { fw_ver = $fw_ver }"
puts "check_id = $check_id"
expect {
"$DUT_prompt" {
switch -exact $check_id {
1 {
send -s "ipmitool hpm upgrade -z $zbuffer $fw_ver force\r"
sleep_sec 1
####it's a workaround for bug
#expect "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):"
#send -s "Y\r"
####it's a workaround for bug
#sleep_sec 5
expect "(y/n):"
send -s "y\r"
#sleep_sec $sleep_time1
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
#expect {
# "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):" { send -s "Y\r"; exp_continue}
# "(y/n):" { send "y\r" ; exp_continue}
# $DUT_prompt { sleep_sec $sleep_time1; sendU_log "Firmware upgrade : pass\n"}
# default {default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}; exit}
#}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw hpm upgrade $fw_ver force\r"
#sleep_sec 5
####it's a workaround for bug
#expect "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):"
#send -s "Y\r"
####it's a workaround for bug
#sleep_sec 5
expect "(y/n):"
send -s "y\r"
#sleep_sec $sleep_time1
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
#expect {
# "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):" { send -s "Y\r"; exp_continue}
# "(y/n):" { send "y\r" ; exp_continue}
# $DUT_prompt { sleep_sec $sleep_time1; sendU_log "Firmware upgrade : pass\n"}
# default {default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}; exit}
#}
DUT_login
}
3 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw hpm upgrade $fw_ver force\r"
#sleep_sec 5
###it's a workaround for bug timout=300
#expect "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):"
#send -s "Y\r"
####it's a workaround for bug
#sleep_sec 5
expect "(y/n):"
send -s "y\r"
#sleep_sec $sleep_time1
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
#expect {
# "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):" { send -s "Y\r"; exp_continue}
# "(y/n):" { send "y\r" ; exp_continue}
# $DUT_prompt { sleep_sec $sleep_time1; sendU_log "Firmware upgrade : pass\n"}
# default {default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}; exit}
#}
DUT_login
}
4 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
send -s "ipmitool -I lan -H $shmm_ip -A none -t $ipmb_addr hpm upgrade $fw_ver force\r"
#sleep_sec 5
###it's a workaround for bug timout=300
#expect "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):"
#send -s "Y\r"
####it's a workaround for bug
#sleep_sec 5
expect "(y/n):"
send -s "y\r"
#sleep_sec $sleep_time1
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
#expect {
# "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):" { send -s "Y\r"; exp_continue}
# "(y/n):" { send "y\r" ; exp_continue}
# $DUT_prompt { sleep_sec $sleep_time1; sendU_log "Firmware upgrade : pass\n"}
# default {default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}; exit}
#}
DUT_login
}
5 {
#send -s "\x1d"
#expect {
# "telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
#}
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw hpm upgrade $fw_ver force\r"
#sleep_sec 5
###it's a workaround for bug timout=300
#expect "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):"
#send -s "Y\r"
####it's a workaround for bug
#sleep_sec 5
expect "(y/n):"
send -s "y\r"
#sleep_sec $sleep_time1
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
#expect {
# "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):" { send -s "Y\r"; exp_continue}
# "(y/n):" { send "y\r" ; exp_continue}
# $DUT_prompt { sleep_sec $sleep_time1; sendU_log "Firmware upgrade : pass\n"}
# default {default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}; exit}
#}
#DUT_login
}
}
}
}
}
#proc Con_server_fw_upgrade2 {{check_id} {fw_ver} {sleep_time1 10}} {
# global error_message sendU_log DUT_prompt BMC_ip bootloader_path bl_ver ipmc_path ipmc_ver bios_path bios_ver nvram_path nvram_ver bootloader_file ipmc_file bios_file nvram_file shmm_ip ipmb_addr Con_server_prompt BMC_pw BMC_user
# #check_id 1 = kcs
# #check_id 2 = iol lan
# #check_id 3 = iol lanplus
#
# puts "\nrunning proc Con_server_fw_upgrade { fw_ver = $fw_ver }"
# puts "check_id = $check_id"
#
# expect {
# $Con_server_prompt {
# if { $sub_function != " " } {
# ###### improve sub_test_case info 20161217
# send_user "\n***** sub_test_case info : $sub_test_case *****\n"
#
# send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw hpm upgrade $fw_ver force\r"
# expect "(y/n):"
# send -s "y\r"
# #sleep_sec $sleep_time1
# expect {
# "Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
# default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
# }
# sleep_sec 2
# }
# }
# }
#}
#
#proc Con_server_rtm_fw_upgrade2 {{check_id} {fw_ver} {sleep_time1 10}} {
# global error_message sendU_log DUT_prompt BMC_ip bootloader_path bl_ver ipmc_path ipmc_ver bios_path bios_ver nvram_path nvram_ver bootloader_file ipmc_file bios_file nvram_file shmm_ip ipmb_addr Con_server_prompt BMC_pw BMC_user
# #check_id 1 = kcs
# #check_id 2 = iol lan
# #check_id 3 = iol lanplus
#
# puts "\nrunning proc Con_server_fw_upgrade { fw_ver = $fw_ver }"
# puts "check_id = $check_id"
#
# expect {
# $Con_server_prompt {
# if { $sub_function != " " } {
# ###### improve sub_test_case info 20161217
# send_user "\n***** sub_test_case info : $sub_test_case *****\n"
#
# send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw hpm upgrade $fw_ver force\r"
# expect "(y/n):"
# send -s "y\r"
# #sleep_sec $sleep_time1
# expect {
# "Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
# default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
# }
# sleep_sec 2
# }
# }
# }
#}
proc DUT_rtm_fw_upgrade {{check_id} {fw_ver} {sleep_time1 10}} {
global error_message sendU_log DUT_prompt BMC_ip bootloader_path bl_ver ipmc_path ipmc_ver bios_path bios_ver nvram_path nvram_ver bootloader_file ipmc_file bios_file nvram_file shmm_ip ipmb_addr Con_server_prompt BMC_pw BMC_user
#check_id 1 = kcs
#check_id 2 = iol lan
#check_id 3 = iol lanplus
puts "\nrunning proc DUT_rtm_fw_upgrade { fw_ver = $fw_ver }"
puts "check_id = $check_id"
expect {
"$DUT_prompt" {
switch -exact $check_id {
1 {
send -s "ipmitool -b 7 -t 0xa6 hpm upgrade $fw_ver force\r"
sleep_sec 1
####it's a workaround for bug
#expect "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):"
#send -s "Y\r"
####it's a workaround for bug
#sleep_sec 5
expect "(y/n):"
send -s "y\r"
#sleep_sec $sleep_time1
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
#expect {
# "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):" { send -s "Y\r"; exp_continue}
# "(y/n):" { send "y\r" ; exp_continue}
# $DUT_prompt { sleep_sec $sleep_time1; sendU_log "Firmware upgrade : pass\n"}
# default {default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}; exit}
#}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw -b 7 -t 0xa6 hpm upgrade $fw_ver force\r"
#sleep_sec 5
####it's a workaround for bug
#expect "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):"
#send -s "Y\r"
####it's a workaround for bug
#sleep_sec 5
expect "(y/n):"
send -s "y\r"
#sleep_sec $sleep_time1
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
#expect {
# "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):" { send -s "Y\r"; exp_continue}
# "(y/n):" { send "y\r" ; exp_continue}
# $DUT_prompt { sleep_sec $sleep_time1; sendU_log "Firmware upgrade : pass\n"}
# default {default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}; exit}
#}
DUT_login
}
3 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
send -s "ipmitool -I lanplus -H $BMC_ip -U $BMC_user -P $BMC_pw -b 7 -t 0xa6 hpm upgrade $fw_ver force\r"
#sleep_sec 5
###it's a workaround for bug timout=300
#expect "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):"
#send -s "Y\r"
####it's a workaround for bug
#sleep_sec 5
expect "(y/n):"
send -s "y\r"
#sleep_sec $sleep_time1
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
#expect {
# "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):" { send -s "Y\r"; exp_continue}
# "(y/n):" { send "y\r" ; exp_continue}
# $DUT_prompt { sleep_sec $sleep_time1; sendU_log "Firmware upgrade : pass\n"}
# default {default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}; exit}
#}
DUT_login
}
4 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
send -s "ipmitool -I lan -H $shmm_ip -A none -T $ipmb_addr -B 0 -b 7 -t 0xa6 hpm upgrade $fw_ver force\r"
#sleep_sec 5
###it's a workaround for bug timout=300
#expect "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):"
#send -s "Y\r"
####it's a workaround for bug
#sleep_sec 5
expect "(y/n):"
send -s "y\r"
#sleep_sec $sleep_time1
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
#expect {
# "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):" { send -s "Y\r"; exp_continue}
# "(y/n):" { send "y\r" ; exp_continue}
# $DUT_prompt { sleep_sec $sleep_time1; sendU_log "Firmware upgrade : pass\n"}
# default {default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}; exit}
#}
DUT_login
}
}
}
}
}
proc Con_server_fw_upgrade {{check_id} {fw_ver} {sleep_time1 10}} {
global error_message sendU_log DUT_prompt BMC_ip bootloader_path bl_ver ipmc_path ipmc_ver bios_path bios_ver nvram_path nvram_ver bootloader_file ipmc_file bios_file nvram_file shmm_ip ipmb_addr Con_server_prompt
#check_id 1 = kcs
#check_id 2 = iol lan
#check_id 3 = iol lanplus
puts "\nrunning proc Con_server_fw_upgrade { fw_ver = $fw_ver }"
puts "check_id = $check_id"
expect {
"$Con_server_prompt" {
switch -exact $check_id {
1 {
send -s "ipmitool hpm upgrade $fw_ver force\r"
sleep_sec 1
####it's a workaround for bug
#expect "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):"
#send -s "Y\r"
####it's a workaround for bug
#sleep_sec 5
expect "(y/n):"
send -s "y\r"
#sleep_sec $sleep_time1
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
#expect {
# "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):" { send -s "Y\r"; exp_continue}
# "(y/n):" { send "y\r" ; exp_continue}
# $DUT_prompt { sleep_sec $sleep_time1; sendU_log "Firmware upgrade : pass\n"}
# default {default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}; exit}
#}
}
2 {
#send -s "\x1d"
#expect {
#"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
#}
send -s "ipmitool -I lan -H $BMC_ip -U administrator -P advantech hpm upgrade $fw_ver force\r"
#sleep_sec 5
####it's a workaround for bug
#expect "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):"
#send -s "Y\r"
####it's a workaround for bug
#sleep_sec 5
expect "(y/n):"
send -s "y\r"
#sleep_sec $sleep_time1
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
#expect {
# "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):" { send -s "Y\r"; exp_continue}
# "(y/n):" { send "y\r" ; exp_continue}
# $DUT_prompt { sleep_sec $sleep_time1; sendU_log "Firmware upgrade : pass\n"}
# default {default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}; exit}
#}
#DUT_login
}
3 {
#send -s "\x1d"
#expect {
# "telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
#}
send -s "ipmitool -I lanplus -H $BMC_ip -C 1 -U administrator -P advantech hpm upgrade $fw_ver force\r"
#sleep_sec 5
###it's a workaround for bug timout=300
#expect "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):"
#send -s "Y\r"
####it's a workaround for bug
#sleep_sec 5
expect "(y/n):"
send -s "y\r"
#sleep_sec $sleep_time1
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
#send -s "ipmitool -I lanplus -H $BMC_ip -U administrator -P advantech hpm check\r"
#expect {
# "$Con_server_prompt" {sendU_log "Fhpm check : pass\n"}
# default { sendU_log "hpm check : fail\n";append error_message "hpm check : fail\n"}
#}
#expect {
# "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):" { send -s "Y\r"; exp_continue}
# "(y/n):" { send "y\r" ; exp_continue}
# $DUT_prompt { sleep_sec $sleep_time1; sendU_log "Firmware upgrade : pass\n"}
# default {default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}; exit}
#}
#DUT_login
}
4 {
#send -s "\x1d"
#expect {
#"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
#}
send -s "ipmitool -I lan -H $shmm_ip -A none -t $ipmb_addr hpm upgrade $fw_ver force\r"
#sleep_sec 5
###it's a workaround for bug timout=300
#expect "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):"
#send -s "Y\r"
####it's a workaround for bug
#sleep_sec 5
expect "(y/n):"
send -s "y\r"
#sleep_sec $sleep_time1
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
#expect {
# "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):" { send -s "Y\r"; exp_continue}
# "(y/n):" { send "y\r" ; exp_continue}
# $DUT_prompt { sleep_sec $sleep_time1; sendU_log "Firmware upgrade : pass\n"}
# default {default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}; exit}
#}
#DUT_login
}
}
}
}
}
proc Con_server_rtm_fw_upgrade {{check_id} {fw_ver} {sleep_time1 10}} {
global error_message sendU_log DUT_prompt BMC_ip bootloader_path bl_ver ipmc_path ipmc_ver bios_path bios_ver nvram_path nvram_ver bootloader_file ipmc_file bios_file nvram_file shmm_ip ipmb_addr Con_server_prompt
#check_id 1 = kcs
#check_id 2 = iol lan
#check_id 3 = iol lanplus
puts "\nrunning proc Con_server_fw_upgrade { fw_ver = $fw_ver }"
puts "check_id = $check_id"
expect {
"$Con_server_prompt" {
switch -exact $check_id {
1 {
send -s "ipmitool hpm upgrade -b 7 -t 0xa6 $fw_ver force\r"
expect "(y/n):"
send -s "y\r"
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
}
2 {
send -s "ipmitool -I lan -H $BMC_ip -U administrator -P advantech -b 7 -t 0xa6 hpm upgrade $fw_ver force\r"
expect "(y/n):"
send -s "y\r"
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
send -s "ipmitool -I lan -H $BMC_ip -U administrator -P advantech -b 7 -t 0xa6 hpm check\r"
expect {
"$Con_server_prompt" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "hpm check : fail\n";append error_message "hpm check : fail\n"}
}
}
3 {
send -s "ipmitool -I lanplus -H $BMC_ip -C 1 -U administrator -P advantech -b 7 -t 0xa6 hpm upgrade $fw_ver force\r"
expect "(y/n):"
send -s "y\r"
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
}
4 {
send -s "ipmitool -I lan -H $shmm_ip -A none -t $ipmb_addr -B 0 -b 7 -t 0xa6 hpm upgrade $fw_ver force\r"
expect "(y/n):"
send -s "y\r"
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
}
}
}
}
}
proc DUT_fw_upgrade_C1 {{fw_ver} {sleep_time1 10}} {
global error_message sendU_log DUT_prompt BMC_ip bootloader_path bl_ver ipmc_path ipmc_ver bios_path bios_ver nvram_path nvram_ver bootloader_file ipmc_file bios_file nvram_file shmm_ip ipmb_addr
#check_id 1 = kcs
#check_id 2 = iol lan
#check_id 3 = iol lanplus
puts "\nrunning proc DUT_fw_upgrade { fw_ver = $fw_ver }"
expect {
$DUT_prompt {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
send -s "ipmitool -I lanplus -H $BMC_ip -C 1 -U administrator -P advantech hpm upgrade $fw_ver force\r"
#sleep_sec 5
###it's a workaround for bug timout=300
#expect "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):"
#send -s "Y\r"
####it's a workaround for bug
#sleep_sec 5
expect "(y/n):"
send -s "y\r"
#sleep_sec $sleep_time1
expect {
"Firmware upgrade procedure successful" {sendU_log "Firmware upgrade : pass\n"}
default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}
}
#expect {
# "Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N):" { send -s "Y\r"; exp_continue}
# "(y/n):" { send "y\r" ; exp_continue}
# $DUT_prompt { sleep_sec $sleep_time1; sendU_log "Firmware upgrade : pass\n"}
# default {default { sendU_log "Firmware upgrade : fail\n";append error_message "Firmware upgrade : fail\n"}; exit}
#}
DUT_login
}
}
}
proc DUT_fw_activate { {check_id} {sleep_time1 10} } {
global error_message sendU_log DUT_prompt BMC_ip bootloader_path bl_ver ipmc_path ipmc_ver bios_path bios_ver nvram_path nvram_ver bootloader_file ipmc_file bios_file nvram_file shmm_ip ipmb_addr BMC_user BMC_pw Con_server_prompt
#check_id 1 = kcs
#check_id 2 = iol lan
#check_id 3 = iol lanplus
#check_id 4 = ipmb
#check_id 5 = os2bmc
puts "\nrunning proc DUT_fw_activate {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
send -s "ipmitool hpm activate\r"
expect {
-re "ipmitool(.*)$DUT_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
set expected_result "*Waiting firmware activation...*OK*"
if {[string match $expected_result $expectout ]==1 && [string match -nocase "*fail*" $expectout ]==0 && [string match -nocase "*unable*" $expectout ]==0 && [string match -nocase "*error*" $expectout ]==0} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
puts "expected_result = $expected_result"
puts "expectout = $expectout"
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw hpm activate\r"
expect {
-re "ipmitool(.*)$Con_server_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
set expected_result "*Waiting firmware activation...*OK*"
if {[string match $expected_result $expectout ]==1 && [string match -nocase "*fail*" $expectout ]==0 && [string match -nocase "*unable*" $expectout ]==0 && [string match -nocase "*error*" $expectout ]==0} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
puts "expected_result = $expected_result"
puts "expectout = $expectout"
}
#send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw hpm check\r"
#expect {
# "$Con_server_prompt" {sendU_log "hpm check : pass\n"}
# default { sendU_log "hpm check : fail\n";append error_message "hpm check : fail\n"}
#}
DUT_login
}
3 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
send -s "ipmitool -I lanplus -C 1 -H $BMC_ip -U $BMC_user -P $BMC_pw hpm activate\r"
expect {
-re "ipmitool(.*)$Con_server_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
set expected_result "*Waiting firmware activation...*OK*"
if {[string match $expected_result $expectout ]==1 && [string match -nocase "*fail*" $expectout ]==0 && [string match -nocase "*unable*" $expectout ]==0 && [string match -nocase "*error*" $expectout ]==0} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
puts "expected_result = $expected_result"
puts "expectout = $expectout"
}
#send -s "ipmitool -I lanplus -C 1 -H $BMC_ip -U $BMC_user -P $BMC_pw hpm check\r"
#expect {
# "$Con_server_prompt" {sendU_log "hpm check : pass\n"}
# default { sendU_log "hpm check : fail\n";append error_message "hpm check : fail\n"}
#}
DUT_login
}
4 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
send -s "ipmitool -I lan -H $shmm_ip -A none -t $ipmb_addr hpm activate\r"
expect {
-re "ipmitool(.*)$Con_server_prompt" {set expectout $expect_out(0,string);send -s "\r"}
}
set expected_result "*Waiting firmware activation...*OK*"
if {[string match $expected_result $expectout ]==1 && [string match -nocase "*fail*" $expectout ]==0 && [string match -nocase "*unable*" $expectout ]==0 && [string match -nocase "*error*" $expectout ]==0} {
sendU_log "\nstring match ($expected_result) : pass\n"
send_user "error_message = $error_message"
} else {
sendU_log "\nstring match ($expected_result) : fail\n";append error_message "\nstring match : fail\n"
send_user "error_message = $error_message"
puts "expected_result = $expected_result"
puts "expectout = $expectout"
}
DUT_login
}
5 {
sleep_sec 1
send -s "ipmitool -I lanplus -C 1 -H $BMC_ip -U $BMC_user -P $BMC_pw hpm activate\r"
expect {
"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
}
}
}
}
}
proc DUT_fw_activate_bak { {check_id} {sleep_time1 10} } {
global error_message sendU_log DUT_prompt BMC_ip bootloader_path bl_ver ipmc_path ipmc_ver bios_path bios_ver nvram_path nvram_ver bootloader_file ipmc_file bios_file nvram_file shmm_ip ipmb_addr BMC_user BMC_pw Con_server_prompt
#check_id 1 = kcs
#check_id 2 = iol lan
#check_id 3 = iol lanplus
puts "\nrunning proc DUT_fw_activate {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
send -s "ipmitool hpm activate\r"
#sleep_sec $sleep_time1
expect {
"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw hpm activate\r"
#sleep_sec $sleep_time1
expect {
"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
DUT_login
}
3 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "ipmitool -I lanplus -C 1 -H $BMC_ip -U $BMC_user -P $BMC_pw hpm activate\r"
#sleep_sec $sleep_time1
expect {
"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
send -s "ipmitool -I lanplus -C 1 -H $BMC_ip -U $BMC_user -P $BMC_pw hpm check\r"
#sleep_sec $sleep_time1
expect {
"$Con_server_prompt" {sendU_log "hpm check : pass\n"}
default { sendU_log "hpm check : fail\n";append error_message "hpm check : fail\n"}
}
DUT_login
}
4 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "ipmitool -I lan -H $shmm_ip -A none -t $ipmb_addr hpm activate\r"
#sleep_sec $sleep_time1
expect {
"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
DUT_login
}
5 {
#send -s "\x1d"
#expect {
# "telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
#}
sleep_sec 1
send -s "ipmitool -I lanplus -C 1 -H $BMC_ip -U $BMC_user -P $BMC_pw hpm activate\r"
#sleep_sec $sleep_time1
expect {
"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
#send -s "ipmitool -I lanplus -C 1 -H $BMC_ip -U $BMC_user -P $BMC_pw hpm check\r"
##sleep_sec $sleep_time1
#expect {
# "$DUT_prompt" {sendU_log "hpm check : pass\n"}
# default { sendU_log "hpm check : fail\n";append error_message "hpm check : fail\n"}
#}
#DUT_login
}
}
}
}
}
proc DUT_rtm_fw_activate { {check_id} {sleep_time1 10} } {
global error_message sendU_log DUT_prompt BMC_ip bootloader_path bl_ver ipmc_path ipmc_ver bios_path bios_ver nvram_path nvram_ver bootloader_file ipmc_file bios_file nvram_file shmm_ip ipmb_addr BMC_user BMC_pw Con_server_prompt
#check_id 1 = kcs
#check_id 2 = iol lan
#check_id 3 = iol lanplus
puts "\nrunning proc DUT_fw_activate {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
send -s "ipmitool -b 7 -t 0xa6 hpm activate\r"
#sleep_sec $sleep_time1
expect {
#"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
"$DUT_prompt" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw -b 7 -t 0xa6 hpm activate\r"
#sleep_sec $sleep_time1
expect {
"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
send -s "ipmitool -I lan -H $BMC_ip -U $BMC_user -P $BMC_pw hpm activate\r"
#sleep_sec $sleep_time1
expect {
"$Con_server_prompt" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
DUT_login
}
3 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "ipmitool -I lanplus -C 1 -H $BMC_ip -U $BMC_user -P $BMC_pw -b 7 -t 0xa6 hpm activate\r"
#sleep_sec $sleep_time1
expect {
"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
send -s "ipmitool -I lanplus -C 1 -H $BMC_ip -U $BMC_user -P $BMC_pw -b 7 -t 0xa6 hpm check\r"
#sleep_sec $sleep_time1
expect {
"$Con_server_prompt" {sendU_log "hpm check : pass\n"}
default { sendU_log "hpm check : fail\n";append error_message "hpm check : fail\n"}
}
DUT_login
}
4 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "ipmitool -I lan -H $shmm_ip -A none -T $ipmb_addr -B 0 -b 7 -t 0xa6 hpm activate\r"
#sleep_sec $sleep_time1
expect {
#"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
"$Con_server_prompt" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
DUT_login
}
}
}
}
}
proc Con_server_fw_activate { {check_id} {sleep_time1 10} } {
global error_message sendU_log DUT_prompt BMC_ip bootloader_path bl_ver ipmc_path ipmc_ver bios_path bios_ver nvram_path nvram_ver bootloader_file ipmc_file bios_file nvram_file shmm_ip ipmb_addr Con_server_prompt
#check_id 1 = kcs
#check_id 2 = iol lan
#check_id 3 = iol lanplus
puts "\nrunning proc DUT_fw_activate {}"
puts "check_id = $check_id"
expect {
$Con_server_prompt {
switch -exact $check_id {
1 {
send -s "ipmitool hpm activate\r"
#sleep_sec $sleep_time1
expect {
"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
}
2 {
#send -s "\x1d"
#expect {
#"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
#}
#sleep_sec 1
send -s "ipmitool -I lan -H $BMC_ip -U administrator -P advantech hpm activate\r"
#sleep_sec $sleep_time1
expect {
"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
#DUT_login
}
3 {
#send -s "\x1d"
#expect {
# "telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
#}
#sleep_sec 1
send -s "ipmitool -I lanplus -C 1 -H $BMC_ip -U administrator -P advantech hpm activate\r"
#sleep_sec $sleep_time1
expect {
"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
#send -s "ipmitool -I lanplus -C 1 -H $BMC_ip -U administrator -P advantech hpm check\r"
##sleep_sec $sleep_time1
#expect {
# "$Con_server_prompt" {sendU_log "hpm check : pass\n"}
# default { sendU_log "hpm check : fail\n";append error_message "hpm check : fail\n"}
#}
#DUT_login
}
4 {
#send -s "\x1d"
#expect {
#"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
#}
#sleep_sec 1
send -s "ipmitool -I lan -H $shmm_ip -A none -t $ipmb_addr hpm activate\r"
#sleep_sec $sleep_time1
expect {
"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
#DUT_login
}
}
}
}
}
proc Con_server_rtm_fw_activate { {check_id} {sleep_time1 10} } {
global error_message sendU_log DUT_prompt BMC_ip bootloader_path bl_ver ipmc_path ipmc_ver bios_path bios_ver nvram_path nvram_ver bootloader_file ipmc_file bios_file nvram_file shmm_ip ipmb_addr Con_server_prompt
#check_id 1 = kcs
#check_id 2 = iol lan
#check_id 3 = iol lanplus
puts "\nrunning proc DUT_fw_activate {}"
puts "check_id = $check_id"
expect {
$Con_server_prompt {
switch -exact $check_id {
1 {
send -s "ipmitool -b 7 -t 0xa6 hpm activate\r"
#sleep_sec $sleep_time1
expect {
"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
}
2 {
#send -s "\x1d"
#expect {
#"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
#}
#sleep_sec 1
send -s "ipmitool -I lan -H $BMC_ip -U administrator -P advantech -b 7 -t 0xa6 hpm activate\r"
#sleep_sec $sleep_time1
expect {
"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
#DUT_login
}
3 {
#send -s "\x1d"
#expect {
# "telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
#}
sleep_sec 1
send -s "ipmitool -I lanplus -C 1 -H $BMC_ip -U administrator -P advantech -b 7 -t 0xa6 hpm activate\r"
#sleep_sec $sleep_time1
expect {
"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
#DUT_login
}
4 {
#send -s "\x1d"
#expect {
#"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
#}
sleep_sec 1
send -s "ipmitool -I lan -H $shmm_ip -A none -t $ipmb_addr -B 0 -b 7 -t 0xa6 hpm activate\r"
#sleep_sec $sleep_time1
expect {
"*Waiting firmware activation...*OK*" {sendU_log "hpm activate : pass\n"}
default { sendU_log "hpm activate : fail\n";append error_message "hpm activate : fail\n"}
}
#DUT_login
}
}
}
}
}
proc DUT_fw_rollback { {check_id} {sleep_time1 10} } {
global error_message sendU_log DUT_prompt BMC_ip bootloader_path bl_ver ipmc_path ipmc_ver bios_path bios_ver nvram_path nvram_ver bootloader_file ipmc_file bios_file nvram_file
#check_id 1 = kcs
#check_id 2 = iol lan
#check_id 3 = iol lanplus
puts "\nrunning proc DUT_fw_rollback {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
send -s "ipmitool hpm rollback\r"
#sleep_sec $sleep_time1
expect {
"Rollback occurred on component mask" {sendU_log "hpm rollback : pass\n"}
default { sendU_log "hpm rollback : fail\n";append error_message "hpm rollback : fail\n"}
}
}
2 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "ipmitool -I lan -H $BMC_ip -U administrator -P advantech hpm rollback\r"
#sleep_sec $sleep_time1
expect {
"Rollback occurred on component mask" {sendU_log "hpm rollback : pass\n"}
default { sendU_log "hpm rollback : fail\n";append error_message "hpm rollback : fail\n"}
}
DUT_login
}
3 {
send -s "\x1d"
expect {
"telnet>" {send -s "q\r\r";sendU_log "logout DUT : pass\n"}
}
sleep_sec 1
send -s "ipmitool -I lanplus -C 1 -H $BMC_ip -U administrator -P advantech hpm rollback\r"
#sleep_sec $sleep_time1
expect {
"Rollback occurred on component mask" {sendU_log "hpm rollback : pass\n"}
default { sendU_log "hpm rollback : fail\n";append error_message "hpm rollback : fail\n"}
}
DUT_login
}
}
}
}
}
#==================================================
#proc : DUT linux info
#==================================================
proc DUT_lspci {check_id} {
global error_message sendU_log DUT_prompt
puts "\nrunning proc DUT_lspci {}"
puts "check_id = $check_id"
expect {
$DUT_prompt {
switch -exact $check_id {
1 {
send -s "lspci |\r"
sleep_sec 10
expect {
"$DUT_prompt" {sendU_log "DUT_lspci : pass\n"; send -s "ls -al\r"}
default { sendU_log "DUT_lspci : fail\n";append error_message "DUT_lspci : fail\n"}
}
}
2 {
send -s "lspci |grep -i ethernet\r"
sleep_sec 10
expect {
"$DUT_prompt" {sendU_log "DUT_lspci : pass\n"; send -s "ls -al\r"}
default { sendU_log "DUT_lspci : fail\n";append error_message "DUT_lspci : fail\n"}
}
}
default {puts "do nothing!";}
}
}
}
}
#==================================================
#proc : AUTO main fucntion
#==================================================
proc test_server_ssh_login {} {
global con_server_ip1 con_server_ip2 spawn_id error_message lmp_login lmp_linux bcn_type Con_server_prompt test_server_user test_server_pw test_server_ip1 Test_server_prompt
puts "\nrunning proc test_server_ssh_login {}"
spawn ssh $test_server_user@$test_server_ip1
expect {
-ex "(yes/no)?" { send "yes\r"; exp_continue}
"*?assword:*" { send "$test_server_pw\r" ; exp_continue}
$Test_server_prompt { sendU_log "enter console server via ssh:pass\n"}
default {append error_message "enter console server via ssh : fail\n" ; break }
}
sendU_log "console ssh Login : pass\n"
}
##### proc test_server_ssh_login {} {
##### global con_server_ip1 con_server_ip2 spawn_id error_message lmp_login lmp_linux bcn_type Con_server_prompt test_server_user test_server_pw test_server_ip1 Test_server_prompt
##### send -s "ssh $test_server_user@$test_server_ip1\r"
##### expect {
##### -ex "(yes/no)?" { send "yes\r"; exp_continue}
##### "*?assword:*" { send "$test_server_pw\r" ; exp_continue}
##### $Test_server_prompt { sendU_log "enter console server via ssh:pass\n"}
##### default {append error_message "enter console server via ssh : fail\n" ; break }
##### }
##### sendU_log "console ssh Login : pass\n"
##### }
proc test_server_ssh_logout {} {
global error_message sendU_log Con_server_prompt console_server_ip shmm_ip shmm_prompt"
send -s "exit\r"
expect {
"*" {sendU_log "test_server_ssh_logout : pass\n"}
default { sendU_log "test_server_ssh_logout : fail\n";append error_message "test_server_ssh_logout : fail\n"}
}
}
#Send_expectout "sshpass -p '$test_server_pw' ssh -o StrictHostKeyChecking=no $test_server_user@$test_server_ip1"
proc console_ssh_login {{newspawn 1}} {
global con_server_ip1 con_server_ip2 spawn_id error_message lmp_login lmp_linux bcn_type Con_server_prompt con_server_user con_server_pw bak_spawn_id
puts "\nrunning proc console_ssh_login {}"
if { $newspawn == 1 } {
spawn ssh $con_server_user@$con_server_ip2
set bak_spawn_id $spawn_id
send_user "spawn_id = $spawn_id\n"
} else {
set spawn_id $bak_spawn_id
send_user "spawn_id = $spawn_id\n"
send "ssh $con_server_user@$con_server_ip2\r"
}
expect {
-ex "(yes/no)?" { send "yes\r"; exp_continue}
"*?assword:*" { send "$con_server_pw\r" ; exp_continue}
$Con_server_prompt { sendU_log "debug info : enter console server via ssh:pass\n"}
default {append error_message "debug info : enter console server via ssh : fail\n" ; break }
}
sendU_log "console ssh Login : pass\n"
}
proc console_sudo {} {
global con_server_ip1 spawn_id error_message lmp_login lmp_linux bcn_type Con_server_prompt con_server_user con_server_pw
puts "\nrunning proc console_sudo {}"
send -s "sudo -i\r"
sleep_sec 2
expect {
"*password*" { send "$con_server_pw\r" ; exp_continue}
$Con_server_prompt { sendU_log "sudo -i :pass\n"}
default {append error_message "sudo -i : fail\n" ; break }
}
sendU_log "console ssh Login : pass\n"
}
proc sendU_log {string} {
global spawn_id log_a starti dut_num DUT_port testcase iteration
puts "\nrunning proc sendU_log {}"
if { "[info level]" != "1" } {
send_user "\n===============\[Check point\]===============\n"
send_user "timestamp = \[[exec date +%Y%m%d-%H%M%S]\] [lindex [info level -1] 0]: $string"
send_user "testcase = $testcase\n"
send_user "iteration = $starti of $iteration\n"
send_user "dut_num = $dut_num ; DUT_port = $DUT_port\n"
send_user "===============\[Check point\]===============\n"
} else {
send_user "\[[exec date +%T]\] $string"
}
send -s "\n"
}
proc sendU_log_sum {string} {
global spawn_id log_a dut_num DUT_port BMC_ip OS_ip OS_interface ipmb_addr
puts "\nrunning proc sendU_log_sum {}"
if { "[info level]" != "1" } {
send_user "\n+++++++++++++++++++++++++++++++\[ Summary \]++++++++++++++++++++++++++++++\n"
send_user "\ndut_num = $dut_num ; DUT_port = $DUT_port\n"
send_user "\nOS_ip = $OS_ip ; OS_interface = $OS_interface ; ipmb_addr = $ipmb_addr\n"
send_user "\n\[[exec date +%T]\] [lindex [info level -1] 0]: $string\n"
send_user "\n+++++++++++++++++++++++++++++++\[ Summary \]++++++++++++++++++++++++++++++\n"
} else {
send_user "\[[exec date +%T]\] $string"
}
send -s "\n"
}
proc debug_on {} {
global debug_enable
puts "\nrunning proc debug_on {}"
if {$debug_enable} {exp_internal 1}
}
proc debug_off {} {
exp_internal 0
puts "\nrunning proc debug_off {}"
}
proc sleep_sec { sec } {
send_user "\nrunning proc sleep_sec { sleep = $sec seconds }"
sleep $sec
}
#error report
proc error_report {} {
global spawn_id error_message passfail testcase test_time_2 test_time_1 auto_log_name work_dir new_file old_file Con_server_prompt Test_server_prompt
puts "\nrunning proc error_report {}"
if { $error_message != ""} {
set result FAIL
#sendU_log_sum "\n 1: Testcase $testcase \[FAIL\]\n"
sendU_log_sum "2: >>>>>>>>>>>>>>>>\n$error_message"
sendU_log_sum "\n 2: Overall test result: Fail\n"
set new_file $work_dir
append new_file "\/log\/" "$auto_log_name"
append old_file "$new_file" ".log"
append new_file "_FAIL.log"
puts "old_file=$old_file\n"
puts "new_file=$new_file\n"
puts "error_message != \"\""
send -s "mv $old_file $new_file\r\n"
expect {
"cannot stat" { sendU_log "\n\nmv log:fail\n";exit}
#"$Con_server_prompt" {sendU_log "\n\nmv log: pass\n";exit}
"$Test_server_prompt" {sendU_log "\n\nmv log: pass\n";exit}
}
#sleep_sec 1
} else {
set result PASS
#sendU_log_sum "\n 3: Testcase $testcase \[PASS\]\n"
sendU_log_sum "\n 3: Overall test result: PASS\n"
set new_file $work_dir
append new_file "\/log\/" "$auto_log_name"
append old_file "$new_file" ".log"
append new_file "_PASS.log"
puts "old_file=$old_file\n"
puts "new_file=$new_file\n"
puts "error_message == \"\"\n"
send -s "mv $old_file $new_file\r\n"
expect {
"cannot stat" { sendU_log "\n\nmv log:fail\n";exit}
#"$Con_server_prompt" {sendU_log "\n\nmv log: pass\n";exit}
"$Test_server_prompt" {sendU_log "\n\nmv log: pass\n";exit}
}
#sleep_sec 1
}
exit
}
proc err_print {msg} {
global i spawn_id error_message
puts "\nrunning proc err_print {}"
if { "[info level]" != "1" } {
append error_message "\[[exec date +%T]\]-ERROR-in [lindex [info level -1] 0]: $msg"
send_user "\[[exec date +%T]\]-ERROR-in [lindex [info level -1] 0]: $msg"
} else {
append error_message "\[[exec date +%T]\]-ERROR-$msg"
send_user "\[[exec date +%T]\]-ERROR-$msg"
}
}
proc report_error { case} {
global i spawn_id error_message
puts "\nrunning proc report_error {}"
#error report
if { $error_message != ""} {
puts "====Testcase $case \[FAIL\]====\n"
puts "===vvvvvv Error Report vvvvvvv===\n$error_message"
puts "===^^^^^^^^^^^^^^^^^^^^^^^^^^^==="
} else {
puts "==Testcase $case \[PASS\]==\n"
}
}
#==================================================