#!/bin/bash
#
# @echo off
#
# Calculate the current state of all bugs
# and report the summary tables.
#
# Paremeters:
#
# arg1 - the first multi-result directory
# arg2 - the second multi-result directory
#
# Note: fictitious invalid name could be applied instead of either arg1 or arg2.
#
# arg3 - ALLBUGS file which is a manually prepared description of all bugs,
# those features of current state of bugs which could not be obtained
# automatically
# arg4 - kernel bugzilla Bug List file
# arg5 - local bugzilla Bug List file
#
# (for additional comments see Do and asltsrun utilities).
# Includes
. common
. settings
print_complete_list_per_comp=yes
# Opcodes of TEST-RESULT
PASS=0
FAIL=1
BLOCKED=2
SKIPPED=3
UNDEFINED=4
ST_FAIL=" FAIL "
ST_BLCK=" BLOCKED "
ST_PASS=" PASS "
ST_SKIP=" SKIPPED "
ST_UNDF=" UNDEFINED "
ST_EMPT=" "
# Opcodes of (STATE-MANUALLY)
Man_REJECTED=0
Man_FIXED=1
Man_INTEGRATED=2
Man_FIXED_INTEGRATED=3
Man_EMPTY=4
Man_UNDEFINED=5
# Overall status
REJ_STATUS=0
PASS_STATUS=1
FAIL_STATUS=2
# Opcodes of component
I_COMP=0
C_COMP=1
M_COMP=2
U_COMP=3
S_COMP=4
UNDEF_COMP=5
# Return opcode of TEST-RESULT according to weights
gen_stat()
{
if [ "x$1" != x ]; then
stat=`echo "$1" | awk -F: '{ print $4}'`
if [ "$stat" != 0 ]; then
rval=$FAIL
else
stat=`echo "$1" | awk -F: '{ print $5}'`
if [ "$stat" != 0 ]; then
if [ "$rval" != $FAIL ]; then
rval=$BLOCKED
fi
else
stat=`echo "$1" | awk -F: '{ print $6}'`
if [ "$stat" != 0 ]; then
if [ "$rval" != $FAIL -a "$rval" != $BLOCKED ]; then
rval=$PASS
fi
else
stat=`echo "$1" | awk -F: '{ print $7}'`
if [ "$stat" != 0 ]; then
if [ "$rval" != $FAIL -a "$rval" != $BLOCKED -a "$rval" != $PASS ]; then
rval=$SKIPPED
fi
fi
fi
fi
fi
fi
}
# Inputs/outputs are 'Opcodes of TEST-RESULT'
generate_status()
{
rval="$UNDEFINED"
gen_stat "$c32n_GL"
gen_stat "$c64n_GL"
gen_stat "$c32s_GL"
gen_stat "$c64s_GL"
gen_stat "$l32n_GL"
gen_stat "$l64n_GL"
gen_stat "$l32s_GL"
gen_stat "$l64s_GL"
return $rval
}
# Get name of 'Opcode of TEST-RESULT'
get_test_result_name()
{
case $1 in
0) echo "$ST_PASS";;
1) echo "$ST_FAIL";;
2) echo "$ST_BLCK";;
3) echo "$ST_SKIP";;
4) echo "$ST_UNDF";;
*) echo "?"
esac
}
get_state_result()
{
if [ "x$2" != x ]; then
State=`get_element_of_line "$1" ":" $2 0`
Result=`get_element_of_line "$1" ":" $2 1`
if [ "x$State" == x ]; then
StateResult=" "
elif [ "$State" == NEW ]; then
StateResult="$State "
elif [ "x$Result" == x ]; then
StateResult="$State "
else
StateResult="$State $Result"
fi
else
StateResult=" "
fi
echo "$StateResult"
}
# Check(STATE-MANUALLY) == {REJECTED|FIXED|INTEGRATED|FIXED INTEGRATED|<empty>}
check_state_manually()
{
rval=$Man_UNDEFINED
x=`echo "$1" | awk -F" " '{print $1}'`
y=`echo "$1" | awk -F" " '{print $2}'`
# FIXED INTEGRATED
if [ "x$y" != x ]; then
if [ "$x" != FIXED -o "$y" != INTEGRATED ]; then
CerrSTMAN=h
else
rval=$Man_FIXED_INTEGRATED
z=`echo "$1" | awk -F" " '{print NF}'`
if [ "$z" != 2 ]; then
CerrSTMAN=i
fi
fi
elif [ "$x" == REJECTED ]; then
rval=$Man_REJECTED
elif [ "$x" == FIXED ]; then
rval=$Man_FIXED
elif [ "$x" == INTEGRATED ]; then
rval=$Man_INTEGRATED
elif [ "x$x" == x ]; then
rval=$Man_EMPTY
else
CerrSTMAN=j
fi
return $rval
}
# Check(TEST-RESULT) == {PASS|FAIL|BLOCKED|SKIPPED|UNDEFINED}
check_test_result()
{
if [ "$1" != $PASS\
-a "$1" != $FAIL\
-a "$1" != $BLOCKED\
-a "$1" != $SKIPPED\
-a "$1" != $UNDEFINED ]; then
CerrTSRESID=k
fi
}
check_conformity()
{
entry=7
rval=$FAIL_STATUS
if [ "$1" == $Man_REJECTED ]; then
entry=0
rval=$REJ_STATUS
elif [ "$1" == $Man_FIXED -a "$2" == $UNDEFINED ]; then
entry=1
rval=$PASS_STATUS
elif [ "$1" == $Man_FIXED_INTEGRATED -a "$2" == $UNDEFINED ]; then
entry=1
rval=$PASS_STATUS
elif [ "$1" == $Man_EMPTY -o "$1" == $Man_INTEGRATED ]; then
if [ "$2" == $PASS ]; then
entry=2
rval=$PASS_STATUS
elif [ "$2" == $FAIL ]; then
entry=4
rval=$FAIL_STATUS
elif [ "$2" == $BLOCKED ]; then
entry=5
rval=$FAIL_STATUS
elif [ "$2" == $SKIPPED ]; then
entry=3
rval=$PASS_STATUS
elif [ "$2" == $UNDEFINED ]; then
entry=6
rval=$FAIL_STATUS
else
CerrCONFORMITY=l
fi
else
entry=7
echo "ERROR 0: check_conformity, <$1> <$2>"
InternalErrCount=$[ $InternalErrCount + 1 ]
CerrCONFORMITY=m
fi
if [ "$1" == $Man_FIXED_INTEGRATED -o "$1" == $Man_INTEGRATED ]; then
if [ "x$LBZID" == x -a "x$KBZID" == x ]; then
CerrCONFORMITY=u
fi
fi
entry_of_table=$entry
return $rval
}
# Check(COMP) == {I|C|M|U|S}
check_component()
{
rval=$UNDEF_COMP
if [[ "$1" == I* ]]; then
rval=$I_COMP
elif [[ "$1" == C* ]]; then
rval=$C_COMP
elif [[ "$1" == M* ]]; then
rval=$M_COMP
elif [[ "$1" == U* ]]; then
rval=$U_COMP
elif [[ "$1" == S* ]]; then
rval=$S_COMP
else
CerrCOMP=g
echo "ERROR 0: check_component, <$1>"
InternalErrCount=$[ $InternalErrCount + 1 ]
fi
return $rval
}
report_state_of_bugs()
{
local second_file=
rintinbzcnt=0
notresolvedcnt=0
rnotintcnt=0
rjinbzilla=0
rstateinbzilla=0
rstateinbzillafail=0
init_summary_table
echo ""
echo ""
echo ""
echo "Table 1 (Complete list of per-bug states)"
echo ""
report_head_of_table
OLD_IFS=$IFS
IFS="|"
cat\
"$BDEMO_SUM"\
"$ALLBUGS" |\
while [ 1 ]
do
read number s0 s1 s2 s3 s4 s5 s6 s7
if [ $? -ne 0 ] ; then
do_report_summary
echo ""
report_errors_encountered
echo ""
echo ""
echo ""
report_bug_summary
echo ""
echo ""
echo ""
report_rejected_in_bzilla
echo ""
echo ""
echo ""
report_resolved_integrated
echo ""
echo ""
echo ""
report_resolved_not_integrated
echo ""
echo ""
echo ""
report_not_resolved
echo ""
echo ""
echo ""
report_resolved_state_in_bzilla
echo ""
echo ""
echo ""
report_resolved_state_in_bzilla_but_fail
echo ""
echo ""
echo ""
report_bzilla_summary
echo ""
echo ""
echo ""
report_internal_bugs_number
break
fi
if [ "$number" == ALLBUGS ] ; then
second_file=yes
continue
fi
if [ "$second_file" == yes ] ; then
if [ "x$number" == x ]; then
continue
fi
CerrMISC=" "
# Local/kernel bugzilla State/Result parameters
LBZID=`echo $s1 | sed 's/ //'g`
lst=`get_state_result "$LBSUM_PARSED" "$LBZID"`
KBZID=`echo $s2 | sed 's/ //'g`
kst=`get_state_result "$KBSUM_PARSED" "$KBZID"`
lState=`echo "$lst" | awk -F" " '{print $1}'`
lResult=`echo "$lst" | awk -F" " '{print $2}'`
kState=`echo "$kst" | awk -F" " '{print $1}'`
kResult=`echo "$kst" | awk -F" " '{print $2}'`
resolved_state_in_bzilla=
resolved_state_in_bzilla_but_fail=
if [ "$lState" == RESO\
-o "$lState" == REJE\
-o "$lState" == CLOS\
-o "$kState" == RESO\
-o "$kState" == REJE\
-o "$kState" == CLOS ]; then
resolved_state_in_bzilla=yes
fi
# Check consistancy of bug-data.
#
# Check that the state of bugs reported by local and kernel
# bugzilla dont contradict with the actual state of bugs
# reported by test runs and manually provided data.
# Check STATE-MANUALLY (error # 1)
CerrSTMAN=" "
check_state_manually "$s3"
MANstat=$?
# Check TEST-RESULT (error # 1)
TSRESstat="${SUMMARY[$number]}"
CerrTSRESID=" "
check_test_result "$TSRESstat"
# Check Component (error # 2,3,4,5,6)
LerrCOMP=" "
KerrCOMP=" "
CerrCOMP=" "
Component=`echo $s0 | sed 's/ //'g`
check_component "$Component"
Component=$?
if [ "x$KBZID" != x ]; then
if [ "x$kState" == x ]; then
KerrCOMP=s
else
Comp=`get_element_of_line "$KBSUM_PARSED" ":" "$KBZID" 2`
if [ "$Comp" != "ACPI" ]; then
KerrCOMP=v
elif [[ "$Component" != $I_COMP ]]; then
KerrCOMP=f
fi
fi
fi
if [ "x$LBZID" != x ]; then
if [ "x$lState" == x ]; then
LerrCOMP=s
else
Comp=`get_element_of_line "$LBSUM_PARSED" ":" "$LBZID" 2`
if [ "$Comp" == "Core/Int" ]; then
if [[ "$Component" != $I_COMP ]]; then
LerrCOMP=a
fi
elif [ "$Comp" == "iASL Com" ]; then
if [[ "$Component" != $C_COMP ]]; then
LerrCOMP=b
fi
elif [ "$Comp" == "ACPI Spe" ]; then
if [[ "$Component" != $S_COMP ]]; then
LerrCOMP=c
fi
elif [ "$Comp" == "Utilitie" ]; then
if [ "$Component" != $U_COMP -a "$Component" != $M_COMP ]; then
LerrCOMP=d
fi
else
LerrCOMP=e
fi
fi
fi
# Check conformity of STATE-MANUALLY & TEST-RESULT (error # 1)
CerrCONFORMITY=" "
entry_of_table=100
check_conformity "$MANstat" "$TSRESstat"
overall_status=$?
# Increment the relevant entry of the summary table
if [ "$Component" != $UNDEF_COMP ]; then
increment_summary_table "$Component" "$entry_of_table"
else
CerrMISC=t
echo "ERROR 0: report_state_of_bugs, <$number> <$Component> <$entry_of_table>"
InternalErrCount=$[ $InternalErrCount + 1 ]
fi
if [ "$overall_status" == $FAIL_STATUS ]; then
tobefixed="*"
else
tobefixed=" "
fi
# Check REJECTED (error # 1)
LerrRJ=" "
KerrRJ=" "
if [ "x$LBZID" != x -o "x$KBZID" != x ]; then
MNrejected=
if [ "$overall_status" == $REJ_STATUS ]; then
MNrejected=yes
fi
# Local bugzilla
if [ "x$LBZID" != x ]; then
rejected=
if [ "$lResult" == INVA ]; then
rejected=yes
fi
if [ "$rejected" != "$MNrejected" ]; then
LerrRJ=A
fi
fi
# Kernel bugzilla
if [ "x$KBZID" != x ]; then
rejected=
if [ "$kState" == REJE ]; then
rejected=yes
fi
if [ "$rejected" != "$MNrejected" ]; then
KerrRJ=F
fi
fi
fi
# Check State-Result (error # 7,8,9,a,b,c,d,e)
intgr=
if [[ "$s3" == *INTEGRATED* ]]; then
intgr=yes
fi
LerrSTAT=" "
LerrRES=" "
KerrSTAT=" "
KerrRES=" "
CerrPRIOR=" "
x=`echo $s4 | sed 's/ //'g`
if [ "$overall_status" == $REJ_STATUS ]; then
if [ "x$x" != x ]; then
CerrPRIOR=n
fi
elif [ "$overall_status" == $PASS_STATUS ]; then
if [ "x$LBZID" != x ]; then
if [ "$lState" == CLOS -a "x$intgr" == x ]; then
LerrSTAT=L
elif [ "$lState" != RESO -a "$lState" != CLOS ]; then
LerrSTAT=R
elif [ "$lState" == RESO ]; then
LerrSTAT=C
if [ "$lResult" != FIXE ]; then
LerrRES=D
fi
else
if [ "$lResult" != FIXE ]; then
LerrRES=D
fi
fi
fi
if [ "x$KBZID" != x ]; then
if [ "$kState" == CLOS -a "x$intgr" == x ]; then
KerrSTAT=L
elif [ "$kState" != RESO -a "$kState" != CLOS ]; then
KerrSTAT=R
elif [ "$kState" == RESO ]; then
KerrSTAT=C
if [ "$kResult" != CODE -a "$kResult" != PATC ]; then
KerrRES=H
fi
else
if [ "$kResult" != CODE -a "$kResult" != PATC ]; then
KerrRES=H
fi
fi
fi
if [ "x$x" != x ]; then
CerrPRIOR=o
fi
else
if [ "x$LBZID" != x ]; then
if [ "$lState" == RESO\
-o "$lState" == CLOS ]; then
LerrSTAT=B
elif [ "$lResult" == FIXE\
-o "$lResult" == CODE\
-o "$lResult" == PATC ]; then
LerrRES=E
fi
fi
if [ "x$KBZID" != x ]; then
if [ "$kState" == RESO\
-o "$kState" == CLOS ]; then
KerrSTAT=G
elif [ "$kResult" == FIXE\
-o "$kResult" == CODE\
-o "$kResult" == PATC ]; then
KerrRES=J
fi
fi
if [ "x$LBZID" == x -a "x$KBZID" == x ]; then
LerrSTAT=r
KerrSTAT=r
fi
if [ "x$x" == x ]; then
CerrPRIOR=p
fi
fi
# Check INTEGRATED (error # f,g,h,i)
CerrINTEGR=" "
rejected_in_bz=
rejected_not_in_bz=
not_resolved=
resolved_integrated_in_bz=
resolved_not_integrated_in_bz=
if [ "$overall_status" == $REJ_STATUS ]; then
if [ "x$KBZID" != x -o "x$LBZID" != x ]; then
rejected_in_bz=yes
else
rejected_not_in_bz=yes
fi
elif [ "$overall_status" == $FAIL_STATUS ]; then
not_resolved=yes
if [ "x$LBZID" != x -o "x$KBZID" != x ]; then
if [ "$resolved_state_in_bzilla" == yes ]; then
resolved_state_in_bzilla_but_fail=yes
fi
if [ "x$intgr" != x ]; then
CerrINTEGR=K
fi
fi
else
if [ "x$LBZID" != x -o "x$KBZID" != x ]; then
if [ "x$intgr" == x ]; then
CerrINTEGR=I
resolved_not_integrated_in_bz=yes
else
resolved_integrated_in_bz=yes
fi
fi
fi
# Local & Kernel bugzilla summary
if [ "x$LBZID" != x -o "x$KBZID" != x ]; then
if [ "$kState" == NEW ]; then
KBarr[0]=$[ ${KBarr[0]} + 1 ]
elif [ "$kState" == ASSI ]; then
KBarr[1]=$[ ${KBarr[1]} + 1 ]
elif [ "$kState" == NEED ]; then
KBarr[2]=$[ ${KBarr[2]} + 1 ]
elif [ "$kState" == RESO ]; then
if [ "$kResult" == CODE ]; then
KBarr[3]=$[ ${KBarr[3]} + 1 ]
elif [ "$kResult" == PATC ]; then
KBarr[4]=$[ ${KBarr[4]} + 1 ]
elif [ "$kResult" == FIXE ]; then
KBarr[5]=$[ ${KBarr[5]} + 1 ]
elif [ "$kResult" == INVA ]; then
KBarr[6]=$[ ${KBarr[6]} + 1 ]
else
KBarr[9]=$[ ${KBarr[9]} + 1 ]
fi
elif [ "$kState" == REJE ]; then
if [ "$kResult" == DOCU ]; then
KBarr[7]=$[ ${KBarr[7]} + 1 ]
else
KBarr[9]=$[ ${KBarr[9]} + 1 ]
fi
elif [ "$kState" == CLOS ]; then
if [ "$kResult" == CODE ]; then
KBarr[8]=$[ ${KBarr[8]} + 1 ]
else
KBarr[9]=$[ ${KBarr[9]} + 1 ]
fi
fi
if [ "$lState" == NEW ]; then
LBarr[0]=$[ ${LBarr[0]} + 1 ]
elif [ "$lState" == ASSI ]; then
LBarr[1]=$[ ${LBarr[1]} + 1 ]
elif [ "$lState" == NEED ]; then
LBarr[2]=$[ ${LBarr[2]} + 1 ]
elif [ "$lState" == RESO ]; then
if [ "$lResult" == CODE ]; then
LBarr[3]=$[ ${LBarr[3]} + 1 ]
elif [ "$lResult" == PATC ]; then
LBarr[4]=$[ ${LBarr[4]} + 1 ]
elif [ "$lResult" == FIXE ]; then
LBarr[5]=$[ ${LBarr[5]} + 1 ]
elif [ "$lResult" == INVA ]; then
LBarr[6]=$[ ${LBarr[6]} + 1 ]
else
LBarr[9]=$[ ${LBarr[9]} + 1 ]
fi
elif [ "$lState" == REJE ]; then
if [ "$lResult" == DOCU ]; then
LBarr[7]=$[ ${LBarr[7]} + 1 ]
else
LBarr[9]=$[ ${LBarr[9]} + 1 ]
fi
elif [ "$lState" == CLOS ]; then
if [ "$lResult" == CODE ]; then
LBarr[8]=$[ ${LBarr[8]} + 1 ]
else
LBarr[9]=$[ ${LBarr[9]} + 1 ]
fi
fi
if [ "$overall_status" == $REJ_STATUS ]; then
if [ "x$LBZID" != x ]; then
LBarr[10]=$[ ${LBarr[10]} + 1 ]
fi
if [ "x$KBZID" != x ]; then
KBarr[10]=$[ ${KBarr[10]} + 1 ]
fi
elif [ "$overall_status" == $PASS_STATUS ]; then
if [ "x$LBZID" != x ]; then
LBarr[11]=$[ ${LBarr[11]} + 1 ]
fi
if [ "x$KBZID" != x ]; then
KBarr[11]=$[ ${KBarr[11]} + 1 ]
fi
else
if [ "x$LBZID" != x ]; then
LBarr[12]=$[ ${LBarr[12]} + 1 ]
fi
if [ "x$KBZID" != x ]; then
KBarr[12]=$[ ${KBarr[12]} + 1 ]
fi
fi
fi
TSRESname=`get_test_result_name "$TSRESstat"`
if [ "$overall_status" == $REJ_STATUS ]; then
TSRESname="$ST_EMPT"
fi
# Summary error string
LErrStr="$LerrRJ$LerrCOMP$LerrSTAT$LerrRES"
KErrStr="$KerrRJ$KerrCOMP$KerrSTAT$KerrRES"
CommonErrStr="$CerrCOMP$CerrSTMAN$CerrTSRESID$CerrCONFORMITY$CerrPRIOR$CerrINTEGR"
AllErrors="$LErrStr$KErrStr$CommonErrStr$CerrMISC $tobefixed"
x=`echo "$AllErrors" | sed 's/ //'g`
AccumulateErrors="$AccumulateErrors$x"
line="$AllErrors|$number|$s0|$s1|$lst|$s2|$kst|$TSRESname|$s3|$s4| $tobefixed$s5"
SUMMARY[$number]="$line"
if [ "x$print_complete_list_per_comp" != x ]; then
if [[ "$Component" == $I_COMP ]]; then
SUMMARY_I="$SUMMARY_I:$number"
elif [[ "$Component" == $C_COMP ]]; then
SUMMARY_C="$SUMMARY_C:$number"
elif [[ "$Component" == $M_COMP ]]; then
SUMMARY_M="$SUMMARY_M:$number"
elif [[ "$Component" == $U_COMP ]]; then
SUMMARY_U="$SUMMARY_U:$number"
elif [[ "$Component" == $S_COMP ]]; then
SUMMARY_S="$SUMMARY_S:$number"
else
SUMMARY_UNDEF="$SUMMARY_UNDEF:$number"
fi
fi
if [ "$not_resolved" == yes ]; then
if [[ "$Component" == $I_COMP ]]; then
NOT_RESOLVED_I="$NOT_RESOLVED_I:$number"
elif [[ "$Component" == $C_COMP ]]; then
NOT_RESOLVED_C="$NOT_RESOLVED_C:$number"
elif [[ "$Component" == $M_COMP ]]; then
NOT_RESOLVED_M="$NOT_RESOLVED_M:$number"
elif [[ "$Component" == $U_COMP ]]; then
NOT_RESOLVED_U="$NOT_RESOLVED_U:$number"
elif [[ "$Component" == $S_COMP ]]; then
NOT_RESOLVED_S="$NOT_RESOLVED_S:$number"
else
NOT_RESOLVED_UNDEF="$NOT_RESOLVED_UNDEF:$number"
fi
notresolvedcnt=$[ $notresolvedcnt + 1 ]
elif [ "$resolved_integrated_in_bz" == yes ]; then
if [[ "$Component" == $I_COMP ]]; then
RESOLVED_INTEGRATED_IN_BZ_I="$RESOLVED_INTEGRATED_IN_BZ_I:$number"
elif [[ "$Component" == $C_COMP ]]; then
RESOLVED_INTEGRATED_IN_BZ_C="$RESOLVED_INTEGRATED_IN_BZ_C:$number"
elif [[ "$Component" == $M_COMP ]]; then
RESOLVED_INTEGRATED_IN_BZ_M="$RESOLVED_INTEGRATED_IN_BZ_M:$number"
elif [[ "$Component" == $U_COMP ]]; then
RESOLVED_INTEGRATED_IN_BZ_U="$RESOLVED_INTEGRATED_IN_BZ_U:$number"
elif [[ "$Component" == $S_COMP ]]; then
RESOLVED_INTEGRATED_IN_BZ_S="$RESOLVED_INTEGRATED_IN_BZ_S:$number"
else
RESOLVED_INTEGRATED_IN_BZ_UNDEF="$RESOLVED_INTEGRATED_IN_BZ_UNDEF:$number"
fi
rintinbzcnt=$[ $rintinbzcnt + 1 ]
elif [ "$resolved_not_integrated_in_bz" == yes ]; then
if [[ "$Component" == $I_COMP ]]; then
RESOLVED_NOT_INTEGRATED_IN_BZ_I="$RESOLVED_NOT_INTEGRATED_IN_BZ_I:$number"
elif [[ "$Component" == $C_COMP ]]; then
RESOLVED_NOT_INTEGRATED_IN_BZ_C="$RESOLVED_NOT_INTEGRATED_IN_BZ_C:$number"
elif [[ "$Component" == $M_COMP ]]; then
RESOLVED_NOT_INTEGRATED_IN_BZ_M="$RESOLVED_NOT_INTEGRATED_IN_BZ_M:$number"
elif [[ "$Component" == $U_COMP ]]; then
RESOLVED_NOT_INTEGRATED_IN_BZ_U="$RESOLVED_NOT_INTEGRATED_IN_BZ_U:$number"
elif [[ "$Component" == $S_COMP ]]; then
RESOLVED_NOT_INTEGRATED_IN_BZ_S="$RESOLVED_NOT_INTEGRATED_IN_BZ_S:$number"
else
RESOLVED_NOT_INTEGRATED_IN_BZ_UNDEF="$RESOLVED_NOT_INTEGRATED_IN_BZ_UNDEF:$number"
fi
rnotintcnt=$[ $rnotintcnt + 1 ]
elif [ "$rejected_in_bz" == yes ]; then
REJECTED_IN_BZILLA="$REJECTED_IN_BZILLA:$number"
rjinbzilla=$[ $rjinbzilla + 1 ]
elif [ "$rejected_not_in_bz" == yes ]; then
if [[ "$Component" == $I_COMP ]]; then
REJECTED_NOT_IN_BZILLA_I="$REJECTED_NOT_IN_BZILLA_I:$number"
elif [[ "$Component" == $C_COMP ]]; then
REJECTED_NOT_IN_BZILLA_C="$REJECTED_NOT_IN_BZILLA_C:$number"
elif [[ "$Component" == $M_COMP ]]; then
REJECTED_NOT_IN_BZILLA_M="$REJECTED_NOT_IN_BZILLA_M:$number"
elif [[ "$Component" == $U_COMP ]]; then
REJECTED_NOT_IN_BZILLA_U="$REJECTED_NOT_IN_BZILLA_U:$number"
elif [[ "$Component" == $S_COMP ]]; then
REJECTED_NOT_IN_BZILLA_S="$REJECTED_NOT_IN_BZILLA_S:$number"
else
REJECTED_NOT_IN_BZILLA_UNDEF="$REJECTED_NOT_IN_BZILLA_UNDEF:$number"
fi
rjnotinbzilla=$[ $rjnotinbzilla + 1 ]
fi
if [ "$resolved_state_in_bzilla" == yes ]; then
if [[ "$Component" == $I_COMP ]]; then
RESOLVED_STATE_IN_BZILLA_I="$RESOLVED_STATE_IN_BZILLA_I:$number"
elif [[ "$Component" == $C_COMP ]]; then
RESOLVED_STATE_IN_BZILLA_C="$RESOLVED_STATE_IN_BZILLA_C:$number"
elif [[ "$Component" == $M_COMP ]]; then
RESOLVED_STATE_IN_BZILLA_M="$RESOLVED_STATE_IN_BZILLA_M:$number"
elif [[ "$Component" == $U_COMP ]]; then
RESOLVED_STATE_IN_BZILLA_U="$RESOLVED_STATE_IN_BZILLA_U:$number"
elif [[ "$Component" == $S_COMP ]]; then
RESOLVED_STATE_IN_BZILLA_S="$RESOLVED_STATE_IN_BZILLA_S:$number"
else
RESOLVED_STATE_IN_BZILLA_UNDEF="$RESOLVED_STATE_IN_BZILLA_UNDEF:$number"
fi
rstateinbzilla=$[ $rstateinbzilla + 1 ]
fi
if [ "$resolved_state_in_bzilla_but_fail" == yes ]; then
if [[ "$Component" == $I_COMP ]]; then
RESOLVED_STATE_IN_BZILLA_BUT_FAIL_I="$RESOLVED_STATE_IN_BZILLA_BUT_FAIL_I:$number"
elif [[ "$Component" == $C_COMP ]]; then
RESOLVED_STATE_IN_BZILLA_BUT_FAIL_C="$RESOLVED_STATE_IN_BZILLA_BUT_FAIL_C:$number"
elif [[ "$Component" == $M_COMP ]]; then
RESOLVED_STATE_IN_BZILLA_BUT_FAIL_M="$RESOLVED_STATE_IN_BZILLA_BUT_FAIL_M:$number"
elif [[ "$Component" == $U_COMP ]]; then
RESOLVED_STATE_IN_BZILLA_BUT_FAIL_U="$RESOLVED_STATE_IN_BZILLA_BUT_FAIL_U:$number"
elif [[ "$Component" == $S_COMP ]]; then
RESOLVED_STATE_IN_BZILLA_BUT_FAIL_S="$RESOLVED_STATE_IN_BZILLA_BUT_FAIL_S:$number"
else
RESOLVED_STATE_IN_BZILLA_BUT_FAIL_UNDEF="$RESOLVED_STATE_IN_BZILLA_BUT_FAIL_UNDEF:$number"
fi
rstateinbzillafail=$[ $rstateinbzillafail + 1 ]
fi
else
c32n_GL="$s0"
c64n_GL="$s1"
c32s_GL="$s2"
c64s_GL="$s3"
l32n_GL="$s4"
l64n_GL="$s5"
l32s_GL="$s6"
l64s_GL="$s7"
generate_status "$number"
status=$?
if [ "x$number" != x ]; then
SUMMARY[$number]="$status"
fi
fi
done
IFS=$OLD_IFS
}
init_summary_table()
{
# Elements of arrays:
# 0 - rejected
# 1 - undef_fixed
# 2 - pass
# 3 - skipped
# 4 - failed
# 5 - blocked
# 6 - undef_not_fixed
InternalErrCount=0
# Interpreter
StINT[0]=0
StINT[1]=0
StINT[2]=0
StINT[3]=0
StINT[4]=0
StINT[5]=0
StINT[6]=0
StINT[7]=0
# iASL
StASL[0]=0
StASL[1]=0
StASL[2]=0
StASL[3]=0
StASL[4]=0
StASL[5]=0
StASL[6]=0
StASL[7]=0
# Simulation
StSIM[0]=0
StSIM[1]=0
StSIM[2]=0
StSIM[3]=0
StSIM[4]=0
StSIM[5]=0
StSIM[6]=0
StSIM[7]=0
# Utilities
StUTIL[0]=0
StUTIL[1]=0
StUTIL[2]=0
StUTIL[3]=0
StUTIL[4]=0
StUTIL[5]=0
StUTIL[6]=0
StUTIL[7]=0
# Specs
StSPEC[0]=0
StSPEC[1]=0
StSPEC[2]=0
StSPEC[3]=0
StSPEC[4]=0
StSPEC[5]=0
StSPEC[6]=0
StSPEC[7]=0
# LBarr
LBarr[0]=0
LBarr[1]=0
LBarr[2]=0
LBarr[3]=0
LBarr[4]=0
LBarr[5]=0
LBarr[6]=0
LBarr[7]=0
LBarr[8]=0
LBarr[9]=0
LBarr[10]=0
LBarr[11]=0
LBarr[12]=0
# KBarr
KBarr[0]=0
KBarr[1]=0
KBarr[2]=0
KBarr[3]=0
KBarr[4]=0
KBarr[5]=0
KBarr[6]=0
KBarr[7]=0
KBarr[8]=0
KBarr[9]=0
KBarr[10]=0
KBarr[11]=0
KBarr[12]=0
}
increment_summary_table()
{
if [ "$1" == $I_COMP ]; then
StINT[$2]=$[ ${StINT[$2]} + 1 ]
elif [ "$1" == $C_COMP ]; then
StASL[$2]=$[ ${StASL[$2]} + 1 ]
elif [ "$1" == $S_COMP ]; then
StSPEC[$2]=$[ ${StSPEC[$2]} + 1 ]
elif [ "$1" == $M_COMP ]; then
StSIM[$2]=$[ ${StSIM[$2]} + 1 ]
elif [ "$1" == $U_COMP ]; then
StUTIL[$2]=$[ ${StUTIL[$2]} + 1 ]
fi
}
report_bug_summary()
{
y0=$[ ${StINT[0]} + ${StASL[0]} + ${StSIM[0]} + ${StUTIL[0]} + ${StSPEC[0]} ]
y1=$[ ${StINT[1]} + ${StASL[1]} + ${StSIM[1]} + ${StUTIL[1]} + ${StSPEC[1]} ]
y2=$[ ${StINT[2]} + ${StASL[2]} + ${StSIM[2]} + ${StUTIL[2]} + ${StSPEC[2]} ]
y3=$[ ${StINT[3]} + ${StASL[3]} + ${StSIM[3]} + ${StUTIL[3]} + ${StSPEC[3]} ]
x=" "
echo "Table 2 (Summary of bugs)"
echo ""
echo " | Interpreter iASL Simulation Utilities Specs | TOTAL |"
echo "=============================|=========================================================|===========|"
echo "F |* & REJECTED | ${StINT[0]}$x${StASL[0]}$x${StSIM[0]}$x${StUTIL[0]}$x${StSPEC[0]} | $y0"
echo " I |UNDEFINED & FIXED | ${StINT[1]}$x${StASL[1]}$x${StSIM[1]}$x${StUTIL[1]}$x${StSPEC[1]} | $y1"
echo " X |PASS | ${StINT[2]}$x${StASL[2]}$x${StSIM[2]}$x${StUTIL[2]}$x${StSPEC[2]} | $y2"
echo " ED |SKIPPED | ${StINT[3]}$x${StASL[3]}$x${StSIM[3]}$x${StUTIL[3]}$x${StSPEC[3]} | $y3"
echo "-----------------------------|---------------------------------------------------------|"
y4=$[ ${StINT[4]} + ${StASL[4]} + ${StSIM[4]} + ${StUTIL[4]} + ${StSPEC[4]} ]
y5=$[ ${StINT[5]} + ${StASL[5]} + ${StSIM[5]} + ${StUTIL[5]} + ${StSPEC[5]} ]
y6=$[ ${StINT[6]} + ${StASL[6]} + ${StSIM[6]} + ${StUTIL[6]} + ${StSPEC[6]} ]
# y7=$[ ${StINT[7]} + ${StASL[7]} + ${StSIM[7]} + ${StUTIL[7]} + ${StSPEC[7]} ]
x00=$[ ${StINT[0]} + ${StINT[1]} + ${StINT[2]} + ${StINT[3]} ]
x01=$[ ${StASL[0]} + ${StASL[1]} + ${StASL[2]} + ${StASL[3]} ]
x02=$[ ${StSIM[0]} + ${StSIM[1]} + ${StSIM[2]} + ${StSIM[3]} ]
x03=$[ ${StUTIL[0]} + ${StUTIL[1]} + ${StUTIL[2]} + ${StUTIL[3]} ]
x04=$[ ${StSPEC[0]} + ${StSPEC[1]} + ${StSPEC[2]} + ${StSPEC[3]} ]
x05=$[ $x00 + $x01 + $x02 + $x03 + $x04 ]
echo " Total (fixed) | $x00$x$x01$x$x02$x$x03$x$x04 | $x05"
echo "-----------------------------|---------------------------------------------------------|"
echo "TO |FAIL | ${StINT[4]}$x${StASL[4]}$x${StSIM[4]}$x${StUTIL[4]}$x${StSPEC[4]} | $y4"
echo " BE |BLOCKED | ${StINT[5]}$x${StASL[5]}$x${StSIM[5]}$x${StUTIL[5]}$x${StSPEC[5]} | $y5"
echo " FIXED|UNDEFINED & !FIXED | ${StINT[6]}$x${StASL[6]}$x${StSIM[6]}$x${StUTIL[6]}$x${StSPEC[6]} | $y6"
# echo " | Other (must be 0) | ${StINT[7]}$x${StASL[7]}$x${StSIM[7]}$x${StUTIL[7]}$x${StSPEC[7]} | $y7"
echo "-----------------------------|---------------------------------------------------------|"
x10=$[ ${StINT[4]} + ${StINT[5]} + ${StINT[6]} ]
x11=$[ ${StASL[4]} + ${StASL[5]} + ${StASL[6]} ]
x12=$[ ${StSIM[4]} + ${StSIM[5]} + ${StSIM[6]} ]
x13=$[ ${StUTIL[4]} + ${StUTIL[5]} + ${StUTIL[6]} ]
x14=$[ ${StSPEC[4]} + ${StSPEC[5]} + ${StSPEC[6]} ]
x15=$[ $x10 + $x11 + $x12 + $x13 + $x14 ]
echo " Total (NOT fixed) | $x10$x$x11$x$x12$x$x13$x$x14 | $x15"
x20=$[ $x00 + $x10 ]
x21=$[ $x01 + $x11 ]
x22=$[ $x02 + $x12 ]
x23=$[ $x03 + $x13 ]
x24=$[ $x04 + $x14 ]
x25=$[ $x20 + $x21 + $x22 + $x23 + $x24 ]
echo "-----------------------------|---------------------------------------------------------|"
echo " TOTAL ($MAXBDEMO) | $x20$x$x21$x$x22$x$x23$x$x24 | $x25"
echo "===================================================================================================|"
if [ "$x25" != "$MAXBDEMO" ]; then
echo "ERROR 0: report_bug_summary, incorrect TOTAL, expected <$MAXBDEMO> received <$x25>"
InternalErrCount=$[ $InternalErrCount + 1 ]
fi
}
report_internal_bugs_number()
{
echo "Number of data inconsistency internal errors: InternalErrCount = $InternalErrCount (program to be updated)"
}
status_calculation_comment()
{
echo "Calculate status of bug according to the results of bdemo-tests run on two systems"
echo "for all modes (norm-32,norm-64,slack-32,slack-64):"
echo ""
echo " UNDEFINED & FIXED == PASS"
echo ""
echo " UNDEFINED & {FAIL|BLOCKED| |PASS|SKIPPED} == UNDEFINED == FAIL"
echo " REJECTED & {FAIL|BLOCKED|UNDEFINED|PASS|SKIPPED} == REJECTED == PASS"
echo " FAIL & { BLOCKED|UNDEFINED|PASS|SKIPPED} == FAIL == FAIL"
echo " BLOCKED & { UNDEFINED|PASS|SKIPPED} == BLOCKED == FAIL"
echo " PASS & { SKIPPED} == PASS == PASS"
}
status_entries_comment()
{
echo "Bug status entries:"
echo ""
echo " REJECTED : bug is rejected - no matter what are the results of bdemo-test runs"
echo " UNDEFINED & FIXED : no runtime bdemo-test for this bug (impossible), status FIXED was set up manually"
echo " FAIL : some of runs of the relevant bdemo-test on either system in different modes failed"
echo " BLOCKED : no failures for the bdemo-test but it was not run in some of modes (see FAIL) (blocked temporary for some reason)"
echo " PASS : the bdemo-test doesn't failed or blocked and some runs resulted in PASS"
echo " SKIPPED : no FAIL/BLOCKED/PASS for this bdemo-test and some run was SKIPPED (no conditions to run the test)"
echo " UNDEFINED : no result of bdemo-test for this bug (either temporary or impossible to generate runtime test conditions at all)"
}
# arg1 - the first multi-result directory
# arg2 - the second multi-result directory
init_bdemo_sum()
{
if [ -d "$DIR0" ]; then
BDEMO_SUM="$DIR0/__STATUS_OF_ALL_BDEMO_TESTS"
elif [ -d "$DIR1" ]; then
BDEMO_SUM="$DIR1/__STATUS_OF_ALL_BDEMO_TESTS"
else
do_exit 1 "No one directory specified by both parameters"
fi
}
report_head_of_table()
{
echo "Errors IID COMP LBZID ST/RES KBZID ST/RES TEST-RESULT STATE-MANUALLY PR SUMMARY"
echo "=====================================================================================================|"
}
report_end_of_table()
{
echo "=====================================================================================================|"
}
report_mid_line()
{
echo " |---|-------|------|---------|------|---------|------------|------------------|-----|"
}
do_report_summary()
{
if [ "x$print_complete_list_per_comp" != x ]; then
report_subset_of_summary "$SUMMARY_S"
report_subset_of_summary "$SUMMARY_C"
report_subset_of_summary "$SUMMARY_M"
report_subset_of_summary "$SUMMARY_U"
report_subset_of_summary "$SUMMARY_UNDEF"
report_subset_of_summary "$SUMMARY_I"
else
index=0
while [ 1 ]
do
if [[ $index -ge $MAXBDEMO ]]; then
break
fi
echo "${SUMMARY[$index]}"
index=$[ $index + 1 ]
done
fi
report_end_of_table
}
# arg1 - numbers of bugs - ":n0:n1:...:nX"
report_subset_of_summary()
{
if [ "x$1" != x ]; then
echo "$1" | awk -F: '{ for (i=2; i<=NF; i++) { print $i}}' |\
while [ 1 ]
do
read number
if [ $? -ne 0 ] ; then
break
fi
echo "${SUMMARY[$number]}"
done
fi
}
report_rejected_in_bzilla()
{
x=$[ $rjnotinbzilla + $rjinbzilla ]
echo "Table 3 (Rejected, $rjnotinbzilla + $rjinbzilla == $x)"
echo ""
report_head_of_table
report_subset_of_summary "$REJECTED_NOT_IN_BZILLA_S"
report_subset_of_summary "$REJECTED_NOT_IN_BZILLA_C"
report_subset_of_summary "$REJECTED_NOT_IN_BZILLA_M"
report_subset_of_summary "$REJECTED_NOT_IN_BZILLA_U"
report_subset_of_summary "$REJECTED_NOT_IN_BZILLA_UNDEF"
report_subset_of_summary "$REJECTED_NOT_IN_BZILLA_I"
if [ $rjnotinbzilla -gt 0 ]; then
report_mid_line
fi
report_subset_of_summary "$REJECTED_IN_BZILLA"
report_end_of_table
}
report_resolved_integrated()
{
echo "Table 4 (PASS-state and INTEGRATED (of BZ), $rintinbzcnt)"
echo ""
report_head_of_table
report_subset_of_summary "$RESOLVED_INTEGRATED_IN_BZ_S"
report_subset_of_summary "$RESOLVED_INTEGRATED_IN_BZ_C"
report_subset_of_summary "$RESOLVED_INTEGRATED_IN_BZ_M"
report_subset_of_summary "$RESOLVED_INTEGRATED_IN_BZ_U"
report_subset_of_summary "$RESOLVED_INTEGRATED_IN_BZ_UNDEF"
report_subset_of_summary "$RESOLVED_INTEGRATED_IN_BZ_I"
report_end_of_table
}
report_resolved_not_integrated()
{
echo "Table 5 (PASS-state but NOT INTEGRATED (of BZ), $rnotintcnt)"
echo ""
report_head_of_table
report_subset_of_summary "$RESOLVED_NOT_INTEGRATED_IN_BZ_S"
report_subset_of_summary "$RESOLVED_NOT_INTEGRATED_IN_BZ_C"
report_subset_of_summary "$RESOLVED_NOT_INTEGRATED_IN_BZ_M"
report_subset_of_summary "$RESOLVED_NOT_INTEGRATED_IN_BZ_U"
report_subset_of_summary "$RESOLVED_NOT_INTEGRATED_IN_BZ_UNDEF"
report_subset_of_summary "$RESOLVED_NOT_INTEGRATED_IN_BZ_I"
report_end_of_table
}
report_not_resolved()
{
echo "Table 6 (FAIL-state, $notresolvedcnt)"
echo ""
report_head_of_table
report_subset_of_summary "$NOT_RESOLVED_S"
report_subset_of_summary "$NOT_RESOLVED_C"
report_subset_of_summary "$NOT_RESOLVED_M"
report_subset_of_summary "$NOT_RESOLVED_U"
report_subset_of_summary "$NOT_RESOLVED_UNDEF"
report_subset_of_summary "$NOT_RESOLVED_I"
report_end_of_table
}
report_resolved_state_in_bzilla()
{
echo "Table 7 (RESOLVED-Bugzilla-State, $rstateinbzilla)"
echo ""
report_head_of_table
report_subset_of_summary "$RESOLVED_STATE_IN_BZILLA_S"
report_subset_of_summary "$RESOLVED_STATE_IN_BZILLA_C"
report_subset_of_summary "$RESOLVED_STATE_IN_BZILLA_M"
report_subset_of_summary "$RESOLVED_STATE_IN_BZILLA_U"
report_subset_of_summary "$RESOLVED_STATE_IN_BZILLA_UNDEF"
report_subset_of_summary "$RESOLVED_STATE_IN_BZILLA_I"
report_end_of_table
}
report_resolved_state_in_bzilla_but_fail()
{
echo "Table 8 (RESOLVED-Bugzilla-State BUT FAIL-state, $rstateinbzillafail)"
echo ""
report_head_of_table
report_subset_of_summary "$RESOLVED_STATE_IN_BZILLA_BUT_FAIL_S"
report_subset_of_summary "$RESOLVED_STATE_IN_BZILLA_BUT_FAIL_C"
report_subset_of_summary "$RESOLVED_STATE_IN_BZILLA_BUT_FAIL_M"
report_subset_of_summary "$RESOLVED_STATE_IN_BZILLA_BUT_FAIL_U"
report_subset_of_summary "$RESOLVED_STATE_IN_BZILLA_BUT_FAIL_UNDEF"
report_subset_of_summary "$RESOLVED_STATE_IN_BZILLA_BUT_FAIL_I"
report_end_of_table
}
report_bzilla_summary()
{
y=$[ ${LBarr[0]} + ${LBarr[1]} + ${LBarr[2]} + ${LBarr[3]}\
+ ${LBarr[4]} + ${LBarr[5]} + ${LBarr[6]} + ${LBarr[7]}\
+ ${LBarr[8]} + ${LBarr[9]} ]
z=$[ ${KBarr[0]} + ${KBarr[1]} + ${KBarr[2]} + ${KBarr[3]}\
+ ${KBarr[4]} + ${KBarr[5]} + ${KBarr[6]} + ${KBarr[7]}\
+ ${KBarr[8]} + ${KBarr[9]} ]
x=" "
echo "Table 9 (Summary per-State-Result in BZ)"
echo ""
echo "State Result | LBZ KBZ"
echo "=============|==================="
echo "NEW | ${LBarr[0]}$x${KBarr[0]}"
echo "ASSI | ${LBarr[1]}$x${KBarr[1]}"
echo "NEED | ${LBarr[2]}$x${KBarr[2]}"
echo "RESO CODE | ${LBarr[3]}$x${KBarr[3]}"
echo "RESO PATC | ${LBarr[4]}$x${KBarr[4]}"
echo "RESO FIXE | ${LBarr[5]}$x${KBarr[5]}"
echo "RESO INVA | ${LBarr[6]}$x${KBarr[6]}"
echo "REJE DOCU | ${LBarr[7]}$x${KBarr[7]}"
echo "CLOS CODE | ${LBarr[8]}$x${KBarr[8]}"
echo "Other | ${LBarr[9]}$x${KBarr[9]}"
echo "-------------|-------------------"
echo "Total | $y$x$z"
echo "=============|==================="
y=$[ ${LBarr[10]} + ${LBarr[11]} + ${LBarr[12]} ]
z=$[ ${KBarr[10]} + ${KBarr[11]} + ${KBarr[12]} ]
echo ""
echo ""
echo ""
echo "Table 10 (Summary state of bugs (of BZ))"
echo ""
echo " State | LBZ KBZ"
echo "=============|==================="
echo "REJECTED | ${LBarr[10]}$x${KBarr[10]}"
echo "PASS-state | ${LBarr[11]}$x${KBarr[11]}"
echo "FAIL-state | ${LBarr[12]}$x${KBarr[12]}"
echo "-------------|-------------------"
echo "Total | $y$x$z"
echo "================================="
}
report_errors_encountered()
{
echo "A list of encountered errors:"
echo ""
if [ -f "$ERROR_OPCODES" ]; then
z=`echo "$AccumulateErrors" | transform_to_single_chars`
report_lines_per_char "$ERROR_OPCODES" "$z"
else
echo "Error: ERROR_OPCODES is not file: <$ERROR_OPCODES>"
fi
}
# ############################## MAIN ###############################
date
DIR0="$1"
DIR1="$2"
ALLBUGS="$3"
KBSUM="$4"
LBSUM="$5"
BUG_STATE_DIR="$6"
BDEMO_SUM=
KBSUM_PARSED=
LBSUM_PARSED=
c32n_GL=
c64n_GL=
c32s_GL=
c64s_GL=
l32n_GL=
l64n_GL=
l32s_GL=
l64s_GL=
UTILSTATUS=0
SUMMARY=
# NOT_RESOLVED=
# RESOLVED_INTEGRATED_IN_BZ=
# RESOLVED_NOT_INTEGRATED_IN_BZ=
# RESOLVED_STATE_IN_BZILLA=
# REJECTED_IN_BZILLA=
# REJECTED_NOT_IN_BZILLA=
LBarr=
KBarr=
ERROR_OPCODES="$BUG_STATE_DIR/ERROR_OPCODES"
# Opcodes of errors
# REJECTED_ERR=1
# COMP_ERR=9
# Arrays for summary information for Interpreter, iASL, Simulation, Utilities, Specs.
StINT=
StASL=
StSIM=
StUTIL=
StSPEC=
# Prepare the summary table of bdemo summary files of two multi-results:
echo "Preparing the summary table of bdemo summary files of two multi-results:"
echo " the first : $DIR0"
echo " the second : $DIR1"
echo " ALLBUGS : $ALLBUGS"
echo " kernel bugzilla Bug List file : $KBSUM"
echo " local bugzilla Bug List file : $LBSUM"
# Initialization
INIT_MAX_BDEMO
system0=
system1=
if [ -d "$DIR0" ]; then
COMMONLOGFILE="$DIR0/Summary"
if [ ! -f "$COMMONLOGFILE" ]; then
do_exit 1 "COMMONLOGFILE is not file: <$COMMONLOGFILE>"
else
system0=`get_name_of_system "$COMMONLOGFILE"`
fi
fi
if [ -d "$DIR1" ]; then
COMMONLOGFILE="$DIR1/Summary"
if [ ! -f "$COMMONLOGFILE" ]; then
do_exit 1 "COMMONLOGFILE is not file: <$COMMONLOGFILE>"
else
system1=`get_name_of_system "$COMMONLOGFILE"`
fi
fi
if [ ! -f "$KBSUM" ]; then
do_exit 1 "KBSUM is not file: <$KBSUM>"
fi
if [ ! -f "$LBSUM" ]; then
do_exit 1 "LBSUM is not file: <$LBSUM>"
fi
if [ -d "$DIR0" ]; then
KBSUM_PARSED="$DIR0/__KERNEL_ASLTS_BUG_LIST"
LBSUM_PARSED="$DIR0/__LOCAL_ASLTS_BUG_LIST"
elif [ -d "$DIR1" ]; then
KBSUM_PARSED="$DIR1/__KERNEL_ASLTS_BUG_LIST"
LBSUM_PARSED="$DIR1/__LOCAL_ASLTS_BUG_LIST"
fi
if [ "x$KBSUM_PARSED" == x -o "x$LBSUM_PARSED" == x ]; then
do_exit 1 "Failed to initialize KBSUM_PARSED & LBSUM_PARSED"
fi
if [ ! -f "$ALLBUGS" ]; then
do_exit 1 "ALLBUGS is not file: <$ALLBUGS>"
fi
init_bdemo_sum
# Parse the Bug List files (kernel and local bugzilla)
echo "Parse the Bug List files (kernel and local bugzilla)"
echo " kernel bugzilla Bug List file : $KBSUM"
echo " local bugzilla Bug List file : $LBSUM"
parsebuglist "$KBSUM" > "$KBSUM_PARSED"
if [ $? -ne 0 ]; then
do_exit 1 "Failed to parse KBSUM: <$KBSUM>"
fi
parsebuglist "$LBSUM" > "$LBSUM_PARSED"
if [ $? -ne 0 ]; then
do_exit 1 "Failed to parse LBSUM: <$LBSUM>"
fi
# Concatenate the summary files of bdemos of two multi-results
bdemosconc "$DIR0" "$DIR1"
if [ ! -f "$BDEMO_SUM" ]; then
do_exit 1 "BDEMO_SUM is not file: <$BDEMO_SUM>"
fi
echo ""
echo ""
echo "The tables below represent the current state of all bugs encountered by ASLTS project."
echo ""
echo "The underlying systems the aslts tests were run:"
echo ""
echo " the first <$system0>"
echo " the second <$system1>"
echo ""
echo "The aslts tests multi-results analyzed:"
echo ""
echo " the first multi-result directory : <$DIR0>"
echo " the second multi-result directory : <$DIR1>"
echo ""
report_state_of_bugs
if [ 0 -eq 1 ]; then
echo ""
status_calculation_comment
echo ""
status_entries_comment
fi
echo ""
date
exit $UTILSTATUS