bin/lib

   1 # The Evaluator -- Shell Function Library
   2 # (c) 2001 Martin Mares <mj@ucw.cz>
   3
   4 # Logging functions.
   5 # File handles used: fd1=log, fd2=progress
   6
   7 function log-init
   8 {
   9         exec >>$TDIR/log
  10         HAVE_LOG=1
  11 }
  12
  13 function pstart
  14 {
  15         echo >&2 -n "$@"
  16 }
  17
  18 function pcont
  19 {
  20         echo >&2 -n "$@"
  21 }
  22
  23 function pend
  24 {
  25         echo >&2 "$@"
  26 }
  27
  28 function die
  29 {
  30         echo >&2 "$@"
  31         [ -n "$HAVE_LOG" ] && echo "Fatal error: $@"
  32         exit 1
  33 }
  34
  35 # Sandbox subroutines
  36
  37 function box-init
  38 {
  39         pstart "Preparing sandbox... "
  40         [ -n "$TEST_USER" ] || die "TEST_USER not set. Please fix."
  41         if [ $TEST_USER == $EVAL_USER ] ; then
  42                 pcont "running locally (INSECURE), "
  43                 BOXDIR=box
  44                 BOXCMD=bin/box
  45                 mkdir -p box
  46         else
  47                 pcont "used account $TEST_USER, "
  48                 BOXDIR=$MO_ROOT/$TEST_USER
  49                 BOXCMD=bin/box-$TEST_USER
  50         fi
  51         [ -d $BOXDIR -a -f $BOXCMD ] || die "Sandbox set up incorrectly"
  52         BOXCMD="$BOXCMD -c$BOXDIR"
  53         echo "Sandbox directory: $BOXDIR"
  54         echo "Sandbox command: $BOXCMD"
  55         box-clean
  56         pend "OK"
  57 }
  58
  59 function box-clean
  60 {
  61         [ -n "$BOXCMD" ] || die "box-init not called"
  62         rm -rf $BOXDIR/*
  63 }
  64
  65 # Initialization of testing directories
  66
  67 function dir-init
  68 {
  69         pstart "Initializing... "
  70         PDIR=problems/$PROBLEM
  71         SDIR=solutions/$CONTESTANT/$PROBLEM
  72         TDIR=testing/$CONTESTANT/$PROBLEM
  73         [ -d $PDIR ] || die "Problem $PROBLEM not known"
  74         [ -d $SDIR ] || die "Solution of $PROBLEM not found"
  75         mkdir -p $TDIR
  76         rm -rf $TDIR
  77         cp -a $SDIR $TDIR
  78         cat >$TDIR/log <<EOF
  79 Testing solution of $PROBLEM by $CONTESTANT
  80 Test started at `date`
  81 Contestant's solution directory: $SDIR
  82 Problem directory: $PDIR
  83 Testing directory: $TDIR
  84 EOF
  85         >$TDIR/points
  86         pend "OK"
  87 }
  88
  89 # Locating source file in SDIR, pass name in SRCN (without path) and extension in SRCEXT
  90
  91 function locate-source
  92 {
  93         pstart "Locating source... "
  94         for a in $EXTENSIONS ; do
  95                 if [ -f $SDIR/$PROBLEM.$a ] ; then
  96                         [ -z "$SRCN" ] || die "Multiple source files found: $SDIR/$PROBLEM.$a and $SDIR/$SRCN. Please fix."
  97                         SRCN=$PROBLEM.$a
  98                         SRCEXT=$a
  99                 fi
 100         done
 101         [ -n "$SRCN" ] || die "NOT FOUND"
 102         pend $SRCN
 103         echo "Found source file: $SDIR/$SRCN"
 104 }
 105
 106 # Compilation (compile SDIR/SRCN with PDIR/EXTRAS to EXE=TDIR/PROBLEM)
 107
 108 function compile
 109 {
 110         pstart "Compiling... "
 111         cp -a $SDIR/$SRCN $TDIR/$SRCN
 112         if [ -n "$EXTRAS" ] ; then
 113                 echo "Extras: $EXTRAS"
 114                 for a in $EXTRAS ; do cp $PDIR/$a $TDIR/ ; done
 115         fi
 116         box-clean
 117         for a in $SRCN $EXTRAS ; do cp $TDIR/$a $BOXDIR/ ; done
 118         SRC=$SRCN
 119         EXE=$PROBLEM
 120         CCMD=COMP_$SRCEXT
 121         CCMD="`eval echo ${!CCMD}`"
 122         COMP_SANDBOX_OPTS="`eval echo $COMP_SANDBOX_OPTS`"
 123         echo "Compiler command: $CCMD"
 124         echo "Compiler sandbox options: $COMP_SANDBOX_OPTS"
 125
 126         echo "Compiler input files:"
 127         ls -Al $BOXDIR
 128         if ! $BOXCMD $COMP_SANDBOX_OPTS -- $CCMD 2>$TDIR/compile.out ; then
 129                 COMPILE_MSG="`cat $TDIR/compile.out`"
 130                 pend "FAILED: $COMPILE_MSG"
 131                 echo "$COMPILE_MSG"
 132                 return 1
 133         fi
 134         cat $TDIR/compile.out
 135         rm $TDIR/compile.out
 136         echo "Compiler output files:"
 137         ls -Al $BOXDIR
 138         if [ ! -f $BOXDIR/$PROBLEM ] ; then
 139                 pend "FAILED: Missing executable file"
 140                 echo "Missing executable file"
 141                 return 1
 142         fi
 143         EXE=$TDIR/$PROBLEM
 144         cp -a $BOXDIR/$PROBLEM $EXE
 145         echo "Compiled OK, result copied to $EXE"
 146         pend "OK"
 147 }
 148
 149 # Running of test program with file input/output
 150
 151 function test-run-with-files
 152 {
 153         pcont "<init> "
 154         box-clean
 155         echo "Executable file: $TDIR/$PROBLEM"
 156         cp $TDIR/$PROBLEM $BOXDIR/
 157         echo "Input: $TDIR/$PROBLEM"
 158         cp $PDIR/$TEST.in $BOXDIR/$PROBLEM.in
 159         echo "Input files:"
 160         ls -Al $BOXDIR
 161
 162         pcont "<run> "
 163         echo "Timeout: $TIME_LIMIT s"
 164         echo "Memory: $MEM_LIMIT KB"
 165         BOXOPTS="`eval echo $TEST_SANDBOX_OPTS`"
 166         echo "Sandbox options: $BOXOPTS"
 167         if ! $BOXCMD $BOXOPTS -- ./$PROBLEM 2>$TDIR/exec.out ; then
 168                 TEST_MSG="`cat $TDIR/exec.out`"
 169                 pend "$TEST_MSG"
 170                 echo "$TEST_MSG"
 171                 echo >$PTSFILE "0 $TEST_MSG"
 172                 return 1
 173         fi
 174         cat $TDIR/exec.out
 175         rm $TDIR/exec.out
 176         echo "Output files:"
 177         ls -Al $BOXDIR
 178         if [ ! -s $BOXDIR/$PROBLEM.out ] ; then
 179                 pend "No output file."
 180                 echo "No output file."
 181                 echo >$PTSFILE "0 No output."
 182                 return 1
 183         fi
 184         cp $BOXDIR/$PROBLEM.out $TDIR/$TEST.out
 185 }
 186
 187 # Syntax checks
 188
 189 function syntax-check
 190 {
 191         [ -n "$SYNTAX_CHECK" ] || return 0
 192         pcont "<syntax> "
 193         SCHECK="`eval echo $SYNTAX_CHECK`"
 194         echo "Syntax check command: $SCHECK"
 195         $SCHECK && return 0
 196         pend "Wrong syntax."
 197         echo "Wrong syntax."
 198         echo >$PTSFILE "0 Wrong syntax."
 199         return 1
 200 }
 201
 202 # Output checks
 203
 204 function output-check
 205 {
 206         pcont "<check> "
 207         ln $PDIR/$TEST.out $TDIR/$TEST.ok
 208         OCHECK="`eval echo $OUTPUT_CHECK`"
 209         echo "Output check command: $OCHECK"
 210         $OCHECK && return 0
 211         pend "Wrong answer."
 212         echo "Wrong answer."
 213         echo >$PTSFILE "0 Wrong answer."
 214         return 1
 215 }