run_exec_autotests.bash 20.3 KB
Newer Older
1
#!/bin/bash
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
#/*
# * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
# * contributor license agreements.  See the NOTICE file distributed with
# * this work for additional information regarding copyright ownership.
# * The OpenAirInterface Software Alliance licenses this file to You under
# * the OAI Public License, Version 1.0  (the "License"); you may not use this file
# * except in compliance with the License.
# * You may obtain a copy of the License at
# *
# *      http://www.openairinterface.org/?page_id=698
# *
# * Unless required by applicable law or agreed to in writing, software
# * distributed under the License is distributed on an "AS IS" BASIS,
# * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# * See the License for the specific language governing permissions and
# * limitations under the License.
# *-------------------------------------------------------------------------------
# * For more information about the OpenAirInterface (OAI) Software Alliance:
# *      contact@openairinterface.org
# */
22 23

# \author Navid Nikaein, Rohit Gupta
24

25 26
if [ -s $OPENAIR_DIR/cmake_targets/tools/build_helper ] ; then
   source $OPENAIR_DIR/cmake_targets/tools/build_helper
27 28 29 30 31
else
   echo "Error: no file in the file tree: is OPENAIR_DIR variable set?"
   exit 1
fi

32 33
trap handle_ctrl_c INT

34
source $OPENAIR_DIR/cmake_targets/tools/test_helper
guptar's avatar
guptar committed
35

36

37
SUDO="sudo -E -S"
guptar's avatar
guptar committed
38
tdir=$OPENAIR_DIR/cmake_targets/autotests
39 40
rm -fr $tdir/bin 
mkdir -p $tdir/bin
41
results_file="$tdir/log/results_autotests.xml"
guptar's avatar
guptar committed
42 43 44 45 46 47 48 49

updated=$(svn st -q $OPENAIR_DIR)
if [ "$updated" != "" ] ; then
	echo "some files are not in svn:\n $updated"
fi

cd $tdir 

50 51 52 53 54 55 56 57 58 59 60 61
#\param $1 -> name of test case
#\param $2 -> name of compilation program
#\param $3 -> arguments for compilation program
#\param $4 -> name of pre-executable to install kernel modules, etc
#\param $5 -> arguments of pre-executable
#\param $6 -> name of executable
#\param $7 -> arguments for running the program
#\param $8 -> search expression
#\param $9 -> search expression which should NOT be found (for ex. segmentation fault) 
#\param $10 -> number of runs
#\param $11 -> pre_compile program execution
#\param $12 -> class of the test case (compilation, execution)
62
#\param $13 -> output of compilation program that needs to be found for test case to pass
63
#\param $14 -> tags to help identify the test case for readability in output xml file
64
function test_compile() {
65 66 67

    xUnit_start
    test_case_name=$1
68 69
    log_dir=$tdir/log/$test_case_name
    log_file=$log_dir/test.$1.log.txt
70 71 72 73 74 75 76 77 78 79
    compile_prog=$2
    compile_args=$3
    pre_exec_file=$4
    pre_exec_args=$5
    exec_args=$7
    search_expr_array=("${!8}")
    search_expr_negative=$9
    nruns=${10}
    pre_compile_prog=${11}
    class=${12}
80
    compile_prog_out=${13}
81
    tags=${14}
82 83 84
    xmlfile_testcase=$log_dir/test.$1.xml
    #build_dir=$tdir/$1/build
    #exec_file=$build_dir/$6
85
    
86 87 88 89
    #compile_prog_out=`eval "echo $compile_prog_out"`
    #echo "compile_prog_out = $compile_prog_out"
    read -a compile_prog_out_array <<< "$compile_prog_out"

90 91
    #Temporary log file where execution log is stored.
    temp_exec_log=$log_dir/temp_log.txt
92 93
    rm -fr $log_dir
    mkdir -p $log_dir
94 95 96 97 98 99 100 101 102 103 104 105 106 107



    #echo "log_dir = $log_dir"
    #echo "log_file = $log_file"
    #echo "exec_file = $exec_file"
    #echo "exec_args = $exec_args"
    #echo "search_expr = $search_expr"
    #echo "pre_exec_file = $pre_exec_file"
    #echo "nruns = $nruns"
    echo "class = $class"
    
    compile_prog_array=()
    read -a compile_prog_array <<<"$compile_prog"
108
    
109 110
    #tags_array=()
    #read -a tags_array <<<"$tags"
111
    
112 113 114 115
    #pre_compile_prog_array=()
    #readarray -t pre_compile_prog_array <<< "$pre_compile_prog"
    result=1
    result_string=""
116 117
    for (( run_index=1; run_index <= $nruns; run_index++ ))
    do
118 119 120 121
       
    #tags_array_index=0
    #for pre_compile_prog_array_index in "${pre_compile_prog_array[@]}"  
    #do
122
    
123 124 125 126 127 128 129 130
    #for compile_prog_array_index in "${compile_prog_array[@]}"  
    #do
       echo "Compiling test case $test_case_name.${tags} Log file = $log_file"  
       date=`date`
       echo "<COMPILATION LOG file=$test_case_name.${tags} , Run = $run_index>, Date = $date " >> $log_file
       #rm -fr $build_dir
       #mkdir -p $build_dir
       cd $log_dir
131
       {   
132
          uname -a
133 134 135
          compile_log_dir=`eval echo \"$OPENAIR_DIR/cmake_targets/log/\"`
          echo "Removing compilation log files in $compile_log_dir"
          rm -frv $compile_log_dir
136 137
          echo "Executing $pre_exec_file $pre_exe_args ...."
          eval $pre_exec_file  $pre_exec_args
138 139 140 141
          echo "Executing $compile_prog $compile_prog_args ...."
          eval $compile_prog  $compile_prog_args
          echo "Copying compilation log files to test case log directory: $log_dir"
          cp -fvr $OPENAIR_DIR/cmake_targets/log/ $log_dir/compile_log
142 143 144
       }>> $log_file 2>&1
       echo "</COMPILATION LOG>" >> $log_file 2>&1
       if [ "$class" == "compilation" ]; then
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
         for compile_prog_out_index in ${compile_prog_out_array[@]}
            do 
                if  [ -s "$compile_prog_out_index" ]; then
                    let "result = result&1"
                    
                    echo_success "$test_case_name.${tags} RUN = $run_index $compile_prog_out_index = compiled"
                    
                else
                    let "result = result&0"
                            
                    echo_error "$test_case_name.${tags} RUN = $run_index $compile_prog_out_index failed"
                    
                 fi
            done #end of for loop compile_prog_out_index
         if [ "$result" == "1" ]; then
            result_string=$result_string" Run_$run_index = PASS"
         else   
            result_string=$result_string" Run_$run_index = FAIL"           
163
         fi
164

165
       fi
166 167 168
       #let "tags_array_index++"
    #done # End of for loop compile_prog_array
    #done # End of for loop (pre_compile_prog_array_index)
169
    done #End of for loop (run_index)
170 171 172 173 174 175 176 177 178 179
    
   
    #If for for some reason upper for loop does not execute, we fail the test case completely
    if [ "$result_string" == "" ]; then
      result=0
    fi
    if [ "$result" == "1" ]; then
      echo_success "$test_case_name.${tags} PASSED"
      xUnit_success "compilation" "$test_case_name.$tags" "PASS" "$result_string" "$xmlfile_testcase"
    else             
Rohit Gupta's avatar
Rohit Gupta committed
180 181
      echo_error "$test_case_name.${tags} FAILED"
      xUnit_fail "compilation" "$test_case_name.$tags" "FAIL" "$result_string" "$xmlfile_testcase"
182
    fi
183 184 185
}


guptar's avatar
guptar committed
186 187 188 189 190 191 192 193 194

#\param $1 -> name of test case
#\param $2 -> name of compilation program
#\param $3 -> arguments for compilation program
#\param $4 -> name of pre-executable to install kernel modules, etc
#\param $5 -> arguments of pre-executable
#\param $6 -> name of executable
#\param $7 -> arguments for running the program
#\param $8 -> search expression
195 196
#\param $9 -> search expression which should NOT be found (for ex. segmentation fault) 
#\param $10 -> number of runs
197 198
#\param $11 -> pre_compile program execution
#\param $12 -> class of the test case (compilation, execution)
199 200
#\param $13 -> output of compilation program that needs to be found for test case to pass
#\param $14 -> tags to help identify the test case for readability in output xml file
201
#\param $15 => password for the user to run certain commands as sudo
202
#\param $16 => test config file params to be modified
guptar's avatar
guptar committed
203

204
function test_compile_and_run() {
guptar's avatar
guptar committed
205
    xUnit_start
206
    test_case_name=$1
207 208
    log_dir=$tdir/log/$test_case_name
    log_file=$log_dir/test.$1.log.txt
guptar's avatar
guptar committed
209 210 211 212
    compile_prog=$2
    compile_args=$3
    pre_exec_file=$4
    pre_exec_args=$5
213
    main_exec=$6
guptar's avatar
guptar committed
214
    exec_args=$7
guptar's avatar
guptar committed
215
    search_expr_array=("${!8}")
216 217
    search_expr_negative=$9
    nruns=${10}
218 219
    pre_compile_prog=${11}
    class=${12}
220 221
    compile_prog_out=${13}
    tags=${14}
222
    mypassword=${15}
223 224
    test_config_file=${16}

guptar's avatar
guptar committed
225
    build_dir=$tdir/$1/build
226 227
    #exec_file=$build_dir/$6
    xmlfile_testcase=$log_dir/test.$1.xml
guptar's avatar
guptar committed
228 229
    #Temporary log file where execution log is stored.
    temp_exec_log=$log_dir/temp_log.txt
230
    export OPENAIR_LOGDIR=$log_dir
231 232 233 234 235 236 237
    rm -fr $log_dir
    mkdir -p $log_dir
    
    rm -fr $OPENAIR_DIR/cmake_targets/log

    echo "" > $temp_exec_log
    echo "" > $log_file
238 239 240
    #echo "log_dir = $log_dir"
    #echo "log_file = $log_file"
    #echo "exec_file = $exec_file"
241
    #echo "exec_args = $exec_args"
242 243 244
    #echo "search_expr = $search_expr"
    #echo "pre_exec_file = $pre_exec_file"
    #echo "nruns = $nruns"
245
    echo "class = $class"
guptar's avatar
guptar committed
246
    
247 248
    #compile_prog_array=()
    #read -a compile_prog_array <<<"$compile_prog"
249 250 251 252

    #test_config_file=`eval "echo \"$test_config_file\" "`

    #echo "test_config_file = $test_config_file"
253
  
254 255 256 257 258
    tags_array=()
    read -a tags_array <<<"$tags"
    
    main_exec_args_array=()
    readarray -t main_exec_args_array <<< "$exec_args"
259 260 261 262 263 264
    
    
    #for search_expr in "${compile_prog_array[@]}"  
    #do
       echo "Compiling test case $test_case_name Log file = $log_file"  
       echo "<COMPILATION LOG file=$log_file>" >> $log_file
265

266 267
       #rm -fr $build_dir
       #mkdir -p $build_dir
268

269
       cd $log_dir
270
       {   
271
          uname -a
272 273 274 275 276 277 278 279
          echo "Executing $pre_compile_prog"
          eval $pre_compile_prog
 
          if [ "$test_config_file" != "" ]; then
            echo "Modifying test_config_file parameters..."
            echo "$test_config_file" |xargs -L 1 $OPENAIR_DIR/cmake_targets/autotests/tools/search_repl.py 
          fi
          echo "Executing $compile_prog $compile_args"
280 281 282
          eval "$compile_prog $compile_args"
          echo "Copying compilation log files to test case log directory: $log_dir"
          cp -fvr $OPENAIR_DIR/cmake_targets/log/ $log_dir/compile_log
283 284
       }>> $log_file 2>&1
       echo "</COMPILATION LOG>" >> $log_file 2>&1
285
    #done
286
    
287 288
    #process the test case if it is that of execution
    if [ "$class" == "execution" ]; then
289 290 291
      tags_array_index=0
      for main_exec_args_array_index in "${main_exec_args_array[@]}"  
      do
292 293 294 295
        global_result=1
        result_string=""
        
       for (( run_index=1; run_index <= $nruns; run_index++ ))
296
        do
297 298
          temp_exec_log=$log_dir/test.$test_case_name.${tags_array[$tags_array_index]}.run_$run_index
          echo "" > $temp_exec_log
guptar's avatar
guptar committed
299

300 301 302 303 304
          echo "Executing test case $test_case_name.${tags_array[$tags_array_index]}, Run Index = $run_index, Execution Log file = $temp_exec_log"

          echo "-----------------------------------------------------------------------------" >> $temp_exec_log  2>&1
          echo "<EXECUTION LOG Test Case = $test_case_name.${tags_array[$tags_array_index]}, Run = $run_index >" >> $temp_exec_log  2>&1
           
305
          if [ -n "$pre_exec_file" ]; then
306
            {  echo " Executing $pre_exec_file $pre_exec_args " 
307
               eval " $pre_exec_file $pre_exec_args " ; }>> $temp_exec_log  2>&1
308

309
          fi
310 311
          echo "Executing $main_exec $main_exec_args_array_index "
          echo "Executing $main_exec $main_exec_args_array_index " >> $temp_exec_log
312
          { uname -a ; eval "$main_exec $main_exec_args_array_index" ;} >> $temp_exec_log  2>&1
313

314
          echo "</EXECUTION LOG Test Case = $test_case_name.${tags_array[$tags_array_index]},  Run = $run_index >" >> $temp_exec_log  2>&1
315
          cat $temp_exec_log >> $log_file  2>&1
316
          
guptar's avatar
guptar committed
317
    
318 319 320
          result=1
          for search_expr in "${search_expr_array[@]}"
          do
guptar's avatar
guptar committed
321
     
322
            search_result=`grep -E "$search_expr" $temp_exec_log`
guptar's avatar
guptar committed
323

324 325
            #echo "search_expr  =   $search_expr"
            #echo "search_result = $search_result"
guptar's avatar
guptar committed
326

327 328 329 330 331 332
            if [ -z "$search_result" ]; then
              let "result = result & 0"
            else
              let "result = result & 1"
            fi
          done
333 334 335 336 337 338 339
          
          #If we find a negative search result then there is crash of program and test case is failed even if above condition is true
          search_result=`grep -iE "$search_expr_negative" $temp_exec_log`
          if [ -n "$search_result" ]; then
            result=0
          fi
          let "global_result = global_result & result"
guptar's avatar
guptar committed
340

341
          #echo "result = $result"
342 343 344
          
          #this is a result of this run
          #test_case_result=""
345
          if [ "$result" -eq "0" ]; then
346 347
            result_string=$result_string" Run_$run_index =FAIL"
            echo_error "$test_case_name.${tags_array[$tags_array_index]} RUN = $run_index Result = FAIL"
348
          fi
guptar's avatar
guptar committed
349

350
          if [ "$result" -eq "1" ]; then
351 352
            result_string=$result_string" Run_$run_index =PASS"
            echo_success "$test_case_name.${tags_array[$tags_array_index]} RUN = $run_index Result = PASS"
353
          fi
guptar's avatar
guptar committed
354

355
          
356 357 358 359 360 361
        done #End of for loop (nindex)

       echo " Result String = $result_string" 

       if [ "$result_string" == "" ]; then
           echo_error "execution $test_case_name.$compile_prog.${tags_array[$tags_array_index]} Run_Result = \"$result_string\"  Result = FAIL"
Rohit Gupta's avatar
Rohit Gupta committed
362
	   xUnit_fail "execution" "$test_case_name.${tags_array[$tags_array_index]}" "FAIL" "$result_string" "$xmlfile_testcase"
363 364 365 366 367 368 369 370 371 372 373 374
       else
        if [ "$global_result" == "0" ]; then
           echo_error "execution $test_case_name.${tags_array[$tags_array_index]} Run_Result = \"$result_string\" Result =  FAIL"
           xUnit_fail "execution" "$test_case_name.${tags_array[$tags_array_index]}" "FAIL" "$result_string" "$xmlfile_testcase"
        fi

        if [ "$global_result" == "1" ]; then
            echo_success "execution $test_case_name.${tags_array[$tags_array_index]} Run_Result = \"$result_string\"  Result = PASS "
	    xUnit_success "execution" "$test_case_name.${tags_array[$tags_array_index]}" "PASS" "$result_string"   "$xmlfile_testcase"     
        fi  
       fi

375
       let "tags_array_index++"
376
     done 
377
   fi
378
   rm -fr $build_dir
guptar's avatar
guptar committed
379 380
}

381 382 383
dbin=$OPENAIR_DIR/cmake_targets/autotests/bin
dlog=$OPENAIR_DIR/cmake_targets/autotests/log

guptar's avatar
guptar committed
384

385
function print_help() {
386 387 388 389 390 391 392 393
 echo_info '
This program runs automated test case system for OpenAirInterface
You should have ubuntu 14.xx, updated, and the Linux kernel >= 3.14
Options
-h | --help
   This help
-g | --run-group
   Run test cases in a group. For example, ./run_exec_autotests "0101* 010102"
Rohit Gupta's avatar
Rohit Gupta committed
394 395
-p
   Use password for logging
396 397
'
}
398

399
function main () {
400
RUN_GROUP=0
Rohit Gupta's avatar
Rohit Gupta committed
401 402
SET_PASSWORD=0
passwd=""
403 404 405
test_case_group=""
test_case_group_array=()
test_case_array=()
406
echo_info "Note that the user should be sudoer for executing certain commands, for example loading kernel modules"
Rohit Gupta's avatar
Rohit Gupta committed
407

408 409 410 411 412 413

until [ -z "$1" ]
  do
    case "$1" in
       -g | --run-group)
            RUN_GROUP=1
414
            test_case_group=$2
415
            test_case_group=`sed "s/\+/\*/g" <<<  "${test_case_group}"` # Replace + with * for bash string substituion
416
            echo_info "Will execute test cases only in group $test_case_group"
417
            shift 2;;
Rohit Gupta's avatar
Rohit Gupta committed
418 419 420 421
        -p)
            SET_PASSWORD=1
            passwd=$2
            shift 2;;
422 423 424 425 426 427 428 429 430
        -h | --help)
            print_help
            exit 1;;
	*)
	    print_help
            echo_fatal "Unknown option $1"
            break;;
   esac
  done
431

432 433
if [ "$SET_PASSWORD" != "1" ]; then
   read -s -p "Enter Password: " passwd
Rohit Gupta's avatar
Rohit Gupta committed
434 435 436
fi

tmpfile=`mktemp`
437
echo $passwd | $SUDO echo $HOME > $tmpfile
Rohit Gupta's avatar
Rohit Gupta committed
438
tstsudo=`cat $tmpfile`
Rohit Gupta's avatar
Rohit Gupta committed
439
if [ "$tstsudo" != "$HOME" ]; then
440
  echo "$USER might not have sudo privileges. Exiting" 
Rohit Gupta's avatar
Rohit Gupta committed
441
  exit
442 443
else
  echo "$USER has sudo privileges"
Rohit Gupta's avatar
Rohit Gupta committed
444 445 446
fi
echo "tstsudo = $tstsudo"
rm -fr $tmpfile
447

448 449
xml_conf="$OPENAIR_DIR/cmake_targets/autotests/test_case_list.xml"

450
test_case_list=`xmlstarlet sel -T -t -m /testCaseList/testCase -s A:N:- "@id" -v "@id" -n $xml_conf`
451 452 453 454 455 456
test_case_excl_list=`xmlstarlet sel -t -v "/testCaseList/TestCaseExclusionList" $xml_conf`
echo "Test Case Exclusion List = $test_case_excl_list "

test_case_excl_list=`sed "s/\+/\*/g" <<< "$test_case_excl_list" ` # Replace + with * for bash string substituion

read -a test_case_excl_array <<< "$test_case_excl_list"
457 458 459

echo "test_case_list = $test_case_list"

460 461
echo "Test Case Exclusion List = $test_case_excl_list \n"

462 463
readarray -t test_case_array <<<"$test_case_list"

464 465
read -a test_case_group_array <<< "$test_case_group"
 
466 467
for search_expr in "${test_case_array[@]}"
  do
468 469 470 471 472 473 474 475 476 477 478 479 480 481
    flag_run_test_case=0
    # search if this test case needs to be executed
    if [ "$RUN_GROUP" -eq "1" ]; then
       for search_group in "${test_case_group_array[@]}"
       do  
          if [[ $search_expr == $search_group ]];then
             flag_run_test_case=1
             echo_info "Test case $search_expr match found in group"
             break
          fi
       done
    else
       flag_run_test_case=1
    fi
482

483 484 485 486 487 488 489 490 491
    for search_excl in "${test_case_excl_array[@]}"
       do  
          if [[ $search_expr == $search_excl ]];then
             flag_run_test_case=0
             echo_info "Test case $search_expr match found in test case excl group. Will skip the test case for execution..."
             break
          fi
       done

492

493 494 495 496 497
    #We skip this test case if it is not in the group list
    if [ "$flag_run_test_case" -ne "1" ]; then
      continue
    fi

498
    name=$search_expr
499 500 501 502 503 504 505 506 507 508 509 510 511 512
    class=`xmlstarlet sel -t -v "/testCaseList/testCase[@id='$search_expr']/class" $xml_conf`
    desc=`xmlstarlet sel -t -v "/testCaseList/testCase[@id='$search_expr']/desc" $xml_conf`
    pre_compile_prog=`xmlstarlet sel -t -v "/testCaseList/testCase[@id='$search_expr']/pre_compile_prog" $xml_conf`
    compile_prog=`xmlstarlet sel -t -v "/testCaseList/testCase[@id='$search_expr']/compile_prog" $xml_conf`
    compile_prog_args=`xmlstarlet sel -t -v "/testCaseList/testCase[@id='$search_expr']/compile_prog_args" $xml_conf`
    pre_exec=`xmlstarlet sel -t -v "/testCaseList/testCase[@id='$search_expr']/pre_exec" $xml_conf`
    pre_exec_args=`xmlstarlet sel -t -v "/testCaseList/testCase[@id='$search_expr']/pre_exec_args" $xml_conf`
    main_exec=`xmlstarlet sel -t -v "/testCaseList/testCase[@id='$search_expr']/main_exec" $xml_conf`
    main_exec_args=`xmlstarlet sel -t -v "/testCaseList/testCase[@id='$search_expr']/main_exec_args" $xml_conf`
    search_expr_true=`xmlstarlet sel -t -v "/testCaseList/testCase[@id='$search_expr']/search_expr_true" $xml_conf`
    search_expr_false=`xmlstarlet sel -t -v "/testCaseList/testCase[@id='$search_expr']/search_expr_false" $xml_conf`
    nruns=`xmlstarlet sel -t -v "/testCaseList/testCase[@id='$search_expr']/nruns" $xml_conf`
    compile_prog_out=`xmlstarlet sel -t -v "/testCaseList/testCase[@id='$search_expr']/compile_prog_out" $xml_conf`
    tags=`xmlstarlet sel -t -v "/testCaseList/testCase[@id='$search_expr']/tags" $xml_conf`
513
    test_config_file=`xmlstarlet sel -t -v "/testCaseList/testCase[@id='$search_expr']/test_config_file" $xml_conf`
514

515 516 517 518 519
    echo "class = $class"
    echo "name = $name"
    echo "Description = $desc"
    echo "pre_compile_prog = $pre_compile_prog"
    echo "compile_prog = $compile_prog"
520 521
    echo "compile_prog_args = $compile_prog_args"
    echo "compile_prog_out = $compile_prog_out"
522 523 524 525 526 527 528 529
    echo "pre_exec = $pre_exec"
    echo "pre_exec_args = $pre_exec_args"
    echo "main_exec = $main_exec"
    echo "main_exec_args = $main_exec_args"
    echo "search_expr_true = $search_expr_true"
    echo "search_expr_false = $search_expr_false"
    echo "nruns = $nruns"

530

531
    #eval $pre_exec
532
    compile_prog_out=`eval echo \"$compile_prog_out\"`
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550

    search_array_true=()

    IFS=\"                  #set the shell's field separator
    set -f                  #don't try to glob 
    #set -- $search_expr_true             #split on $IFS
    for i in $search_expr_true
      do echo "i = $i"
        if [ -n "$i" ] && [ "$i" != " " ]; then
          search_array_true+=("$i")
          #echo "inside i = \"$i\" "
        fi 
      done
    unset IFS 

    #echo "arg1 = ${search_array_true[0]}"
    #echo " arg2 = ${search_array_true[1]}"
    if [ "$class" == "compilation" ]; then
551 552
        test_compile "$name" "$compile_prog" "$compile_prog_args" "$pre_exec" "$pre_exec_args" "$main_exec" "$main_exec_args" "search_array_true[@]" "$search_expr_false" "$nruns" "$pre_compile_prog" "$class" "$compile_prog_out" "$tags"
    elif  [ "$class" == "execution" ]; then
553
        echo \'passwd\' | $SUDO killall -q oaisim_nos1
554
        test_compile_and_run "$name" "$compile_prog" "$compile_prog_args" "$pre_exec" "$pre_exec_args" "$main_exec" "$main_exec_args" "search_array_true[@]" "$search_expr_false" "$nruns" "$pre_compile_prog" "$class" "$compile_prog_out" "$tags" "$mypassword" "$test_config_file"
555
    else
556
        echo "Unexpected class of test case...Skipping the test case $name ...."
557 558 559 560 561 562 563 564
    fi

    done
    
    

}

565 566
uname -a

567
main "$@"
568 569 570 571 572 573 574 575 576

xUnit_write "$results_file"

echo "Test Results are written to $results_file"

exit