fstests: Replace all __[u]intNN_t types with standard [u]intNN_t
[xfstests-dev.git] / check
1 #!/bin/bash
2 #
3 # Control script for QA
4 #
5 # Copyright (c) 2000-2002,2006 Silicon Graphics, Inc.  All Rights Reserved.
6 #
7 # This program is free software; you can redistribute it and/or
8 # modify it under the terms of the GNU General Public License as
9 # published by the Free Software Foundation.
10 #
11 # This program is distributed in the hope that it would be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 # GNU General Public License for more details.
15 #
16 # You should have received a copy of the GNU General Public License
17 # along with this program; if not, write the Free Software Foundation,
18 # Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19 #
20 #
21
22 tmp=/tmp/$$
23 status=0
24 needwrap=true
25 needsum=true
26 n_try=0
27 try=""
28 n_bad=0
29 sum_bad=0
30 bad=""
31 n_notrun=0
32 notrun=""
33 interrupt=true
34 diff="diff -u"
35 showme=false
36 have_test_arg=false
37 randomize=false
38 export here=`pwd`
39 xfile=""
40 brief_test_summary=false
41 err_msg=""
42 do_report=false
43 DUMP_OUTPUT=false
44
45 # start the initialisation work now
46 iam=check
47
48 export MSGVERB="text:action"
49 export QA_CHECK_FS=${QA_CHECK_FS:=true}
50
51 # number of diff lines from a failed test, 0 for whole output
52 export DIFF_LENGTH=${DIFF_LENGTH:=10}
53
54 # by default don't output timestamps
55 timestamp=${TIMESTAMP:=false}
56
57 rm -f $tmp.list $tmp.tmp $tmp.grep $here/$iam.out $tmp.xlist $tmp.report.*
58
59 SRC_GROUPS="generic shared"
60 export SRC_DIR="tests"
61
62 usage()
63 {
64     echo "Usage: $0 [options] [testlist]"'
65
66 check options
67     -nfs                test NFS
68     -glusterfs                test GlusterFS
69     -cifs               test CIFS
70     -9p                 test 9p
71     -overlay            test overlay
72     -pvfs2          test PVFS2
73     -tmpfs              test TMPFS
74     -ubifs              test ubifs
75     -l                  line mode diff
76     -udiff              show unified diff (default)
77     -n                  show me, do not run tests
78     -T                  output timestamps
79     -r                  randomize test order
80     -d                  dump test output to stdout
81     -b                  brief test summary
82     -R fmt[,fmt]        generate report in formats specified. Supported format: [xunit]
83     --large-fs          optimise scratch device for large filesystems
84     -s section          run only specified section from config file
85     -S section          exclude the specified section from the config file
86
87 testlist options
88     -g group[,group...] include tests from these groups
89     -x group[,group...] exclude tests from these groups
90     -X exclude_file     exclude individual tests
91     -E external_file    exclude individual tests
92     [testlist]          include tests matching names in testlist
93
94 testlist argument is a list of tests in the form of <test dir>/<test name>.
95
96 <test dir> is a directory under tests that contains a group file,
97 with a list of the names of the tests in that directory.
98
99 <test name> may be either a specific test file name (e.g. xfs/001) or
100 a test file name match pattern (e.g. xfs/*).
101
102 group argument is either a name of a tests group to collect from all
103 the test dirs (e.g. quick) or a name of a tests group to collect from
104 a specific tests dir in the form of <test dir>/<group name> (e.g. xfs/quick).
105
106 exclude_file argument refers to a name of a file inside each test directory.
107 for every test dir where this file is found, the listed test names are
108 excluded from the list of tests to run from that test dir.
109
110 external_file argument is a path to a single file containing a list of tests
111 to exclude in the form of <test dir>/<test name>.
112
113 examples:
114  check xfs/001
115  check -g quick
116  check -g xfs/quick
117  check -x stress xfs/*
118  check -X .exclude -g auto
119  check -E ~/.xfstests.exclude
120 '
121             exit 0
122 }
123
124 get_sub_group_list()
125 {
126         local d=$1
127         local grp=$2
128
129         test -s "$SRC_DIR/$d/group" || return 1
130
131         local grpl=$(sed -n < $SRC_DIR/$d/group \
132                 -e 's/#.*//' \
133                 -e 's/$/ /' \
134                 -e "s;^\($VALID_TEST_NAME\).* $grp .*;$SRC_DIR/$d/\1;p")
135         echo $grpl
136 }
137
138 get_group_list()
139 {
140         local grp=$1
141         local grpl=""
142         local sub=$(dirname $grp)
143
144         if [ -n "$sub" -a "$sub" != "." -a -d "$SRC_DIR/$sub" ]; then
145                 # group is given as <subdir>/<group> (e.g. xfs/quick)
146                 grp=$(basename $grp)
147                 get_sub_group_list $sub $grp
148                 return
149         fi
150
151         for d in $SRC_GROUPS $FSTYP; do
152                 if ! test -d "$SRC_DIR/$d" ; then
153                         continue
154                 fi
155                 grpl="$grpl $(get_sub_group_list $d $grp)"
156         done
157         echo $grpl
158 }
159
160 # Find all tests, excluding files that are test metadata such as group files.
161 # It matches test names against $VALID_TEST_NAME defined in common/rc
162 get_all_tests()
163 {
164         touch $tmp.list
165         for d in $SRC_GROUPS $FSTYP; do
166                 if ! test -d "$SRC_DIR/$d" ; then
167                         continue
168                 fi
169                 ls $SRC_DIR/$d/* | \
170                         grep -v "\..*" | \
171                         grep "^$SRC_DIR/$d/$VALID_TEST_NAME"| \
172                         grep -v "group\|Makefile" >> $tmp.list 2>/dev/null
173         done
174 }
175
176 # takes the list of tests to run in $tmp.list, and removes the tests passed to
177 # the function from that list.
178 trim_test_list()
179 {
180         test_list="$*"
181
182         rm -f $tmp.grep
183         numsed=0
184         for t in $test_list
185         do
186             if [ $numsed -gt 100 ]; then
187                 grep -v -f $tmp.grep <$tmp.list >$tmp.tmp
188                 mv $tmp.tmp $tmp.list
189                 numsed=0
190                 rm -f $tmp.grep
191             fi
192             echo "^$t\$" >>$tmp.grep
193             numsed=`expr $numsed + 1`
194         done
195         grep -v -f $tmp.grep <$tmp.list >$tmp.tmp
196         mv $tmp.tmp $tmp.list
197 }
198
199
200 _wallclock()
201 {
202     date "+%s"
203 }
204
205 _timestamp()
206 {
207     now=`date "+%T"`
208     echo -n " [$now]"
209 }
210
211 _prepare_test_list()
212 {
213         unset list
214         # Tests specified on the command line
215         if [ -s $tmp.arglist ]; then
216                 cat $tmp.arglist > $tmp.list
217         else
218                 touch $tmp.list
219         fi
220
221         # Specified groups to include
222         for group in $GROUP_LIST; do
223                 list=$(get_group_list $group)
224                 if [ -z "$list" ]; then
225                         echo "Group \"$group\" is empty or not defined?"
226                         exit 1
227                 fi
228
229                 for t in $list; do
230                         grep -s "^$t\$" $tmp.list >/dev/null || \
231                                                         echo "$t" >>$tmp.list
232                 done
233         done
234
235         if ! $have_test_arg && [ -z "$GROUP_LIST" ]; then
236                 # no test numbers, do everything
237                 get_all_tests
238         fi
239
240         # Specified groups to exclude
241         for xgroup in $XGROUP_LIST; do
242                 list=$(get_group_list $xgroup)
243                 if [ -z "$list" ]; then
244                         echo "Group \"$xgroup\" is empty or not defined?"
245                         exit 1
246                 fi
247
248                 trim_test_list $list
249         done
250
251         # sort the list of tests into numeric order
252         list=`sort -n $tmp.list | uniq`
253         rm -f $tmp.list $tmp.tmp $tmp.grep
254
255         if $randomize
256         then
257                 list=`echo $list | awk -f randomize.awk`
258         fi
259 }
260
261 # Process command arguments first.
262 while [ $# -gt 0 ]; do
263         case "$1" in
264         -\? | -h | --help) usage ;;
265
266         -nfs)           FSTYP=nfs ;;
267         -glusterfs)     FSTYP=glusterfs ;;
268         -cifs)          FSTYP=cifs ;;
269         -9p)            FSTYP=9p ;;
270         -overlay)       FSTYP=overlay; export OVERLAY=true ;;
271         -pvfs2)         FSTYP=pvfs2 ;;
272         -tmpfs)         FSTYP=tmpfs ;;
273         -ubifs)         FSTYP=ubifs ;;
274
275         -g)     group=$2 ; shift ;
276                 GROUP_LIST="$GROUP_LIST ${group//,/ }"
277                 ;;
278
279         -x)     xgroup=$2 ; shift ;
280                 XGROUP_LIST="$XGROUP_LIST ${xgroup//,/ }"
281                 ;;
282
283         -X)     xfile=$2; shift ;
284                 for d in $SRC_GROUPS $FSTYP; do
285                         [ -f $SRC_DIR/$d/$xfile ] || continue
286                         for f in `sed "s/#.*$//" $SRC_DIR/$d/$xfile`; do
287                                 echo $d/$f >> $tmp.xlist
288                         done
289                 done
290                 ;;
291         -E)     xfile=$2; shift ;
292                 if [ -f $xfile ]; then
293                         sed "s/#.*$//" "$xfile" >> $tmp.xlist
294                 fi
295                 ;;
296         -s)     RUN_SECTION="$RUN_SECTION $2"; shift ;;
297         -S)     EXCLUDE_SECTION="$EXCLUDE_SECTION $2"; shift ;;
298         -l)     diff="diff" ;;
299         -udiff) diff="$diff -u" ;;
300
301         -n)     showme=true ;;
302         -r)     randomize=true ;;
303
304         -T)     timestamp=true ;;
305         -d)     DUMP_OUTPUT=true ;;
306         -b)     brief_test_summary=true;;
307         -R)     report_fmt=$2 ; shift ;
308                 REPORT_LIST="$REPORT_LIST ${report_fmt//,/ }"
309                 do_report=true
310                 ;;
311         --large-fs) export LARGE_SCRATCH_DEV=yes ;;
312         --extra-space=*) export SCRATCH_DEV_EMPTY_SPACE=${r#*=} ;;
313
314         -*)     usage ;;
315         *)      # not an argument, we've got tests now.
316                 have_test_arg=true ;;
317         esac
318
319         # if we've found a test specification, the break out of the processing
320         # loop before we shift the arguments so that this is the first argument
321         # that we process in the test arg loop below.
322         if $have_test_arg; then
323                 break;
324         fi
325
326         shift
327 done
328
329 # we need common/config, source it after processing args, overlay needs FSTYP
330 # set before sourcing common/config
331 if ! . ./common/config; then
332         echo "$iam: failed to source common/config"
333         exit 1
334 fi
335
336 # Process tests from command line now.
337 if $have_test_arg; then
338         while [ $# -gt 0 ]; do
339                 case "$1" in
340                 -*)     echo "Arguments before tests, please!"
341                         status=1
342                         exit $status
343                         ;;
344                 *)      # Expand test pattern (e.g. xfs/???, *fs/001)
345                         list=$(cd $SRC_DIR; echo $1)
346                         for t in $list; do
347                                 test_dir=`dirname $t`
348                                 test_dir=${test_dir#$SRC_DIR/*}
349                                 test_name=`basename $t`
350                                 group_file=$SRC_DIR/$test_dir/group
351
352                                 if egrep -q "^$test_name" $group_file; then
353                                         # in group file ... OK
354                                         echo $SRC_DIR/$test_dir/$test_name \
355                                                 >>$tmp.arglist
356                                 else
357                                         # oops
358                                         echo "$t - unknown test, ignored"
359                                 fi
360                         done
361                         ;;
362                 esac
363
364                 shift
365         done
366 fi
367
368 # we need common/rc
369 if ! . ./common/rc
370 then
371     echo "check: failed to source common/rc"
372     exit 1
373 fi
374
375 if [ `id -u` -ne 0 ]
376 then
377     echo "check: QA must be run as root"
378     exit 1
379 fi
380
381 _wipe_counters()
382 {
383         n_try="0"
384         n_bad="0"
385         n_notrun="0"
386         unset try notrun bad
387 }
388
389 _wrapup()
390 {
391         seq="check"
392         check="$RESULT_BASE/check"
393
394         if $showme; then
395                 if $needwrap; then
396                         if $do_report; then
397                                 _make_section_report
398                         fi
399                         needwrap=false
400                 fi
401         elif $needwrap; then
402                 if [ -f $check.time -a -f $tmp.time ]; then
403                         cat $check.time $tmp.time  \
404                                 | $AWK_PROG '
405                                 { t[$1] = $2 }
406                                 END {
407                                         if (NR > 0) {
408                                                 for (i in t) print i " " t[i]
409                                         }
410                                 }' \
411                                 | sort -n >$tmp.out
412                         mv $tmp.out $check.time
413                 fi
414
415                 echo "" >>$check.log
416                 date >>$check.log
417
418                 echo "SECTION       -- $section" >>$tmp.summary
419                 echo "=========================" >>$tmp.summary
420                 if [ ! -z "$n_try" -a $n_try != 0 ]; then
421                         if [ $brief_test_summary == "false" ]; then
422                                 echo "Ran:$try"
423                                 echo "Ran:$try" >>$tmp.summary
424                         fi
425                         echo "Ran:$try" >>$check.log
426                 fi
427
428                 $interrupt && echo "Interrupted!" | tee -a $check.log
429
430                 if [ ! -z "$notrun" ]; then
431                         if [ $brief_test_summary == "false" ]; then
432                                 echo "Not run:$notrun"
433                                 echo "Not run:$notrun" >>$tmp.summary
434                         fi
435                         echo "Not run:$notrun" >>$check.log
436                 fi
437
438                 if [ ! -z "$n_bad" -a $n_bad != 0 ]; then
439                         echo "Failures:$bad"
440                         echo "Failed $n_bad of $n_try tests"
441                         echo "Failures:$bad" >>$check.log
442                         echo "Failed $n_bad of $n_try tests" >>$check.log
443                         echo "Failures:$bad" >>$tmp.summary
444                         echo "Failed $n_bad of $n_try tests" >>$tmp.summary
445                 else
446                         echo "Passed all $n_try tests"
447                         echo "Passed all $n_try tests" >>$check.log
448                         echo "Passed all $n_try tests" >>$tmp.summary
449                 fi
450                 echo "" >>$tmp.summary
451                 if $do_report; then
452                         _make_section_report
453                 fi
454                 needwrap=false
455         fi
456
457         sum_bad=`expr $sum_bad + $n_bad`
458         _wipe_counters
459         rm -f /tmp/*.rawout /tmp/*.out /tmp/*.err /tmp/*.time
460         if ! $OPTIONS_HAVE_SECTIONS; then
461                 rm -f $tmp.*
462         fi
463 }
464
465 _summary()
466 {
467         _wrapup
468         if $showme; then
469                 :
470         elif $needsum; then
471                 count=`wc -L $tmp.summary | cut -f1 -d" "`
472                 cat $tmp.summary
473                 needsum=false
474         fi
475         rm -f $tmp.*
476 }
477
478 _check_filesystems()
479 {
480         if [ -f ${RESULT_DIR}/require_test ]; then
481                 _check_test_fs || err=true
482                 rm -f ${RESULT_DIR}/require_test*
483         fi
484         if [ -f ${RESULT_DIR}/require_scratch ]; then
485                 _check_scratch_fs || err=true
486                 rm -f ${RESULT_DIR}/require_scratch*
487         fi
488 }
489
490 _expunge_test()
491 {
492         local TEST_ID="$1"
493         if [ -s $tmp.xlist ]; then
494                 if grep -q $TEST_ID $tmp.xlist; then
495                         echo "       [expunged]"
496                         return 1
497                 fi
498         fi
499         return 0
500 }
501
502 _prepare_test_list
503
504 if $OPTIONS_HAVE_SECTIONS; then
505         trap "_summary; exit \$status" 0 1 2 3 15
506 else
507         trap "_wrapup; exit \$status" 0 1 2 3 15
508 fi
509
510 for section in $HOST_OPTIONS_SECTIONS; do
511         OLD_FSTYP=$FSTYP
512         OLD_TEST_FS_MOUNT_OPTS=$TEST_FS_MOUNT_OPTS
513         get_next_config $section
514
515         # Do we need to run only some sections ?
516         if [ ! -z "$RUN_SECTION" ]; then
517                 skip=true
518                 for s in $RUN_SECTION; do
519                         if [ $section == $s ]; then
520                                 skip=false
521                                 break;
522                         fi
523                 done
524                 if $skip; then
525                         continue
526                 fi
527         fi
528
529         # Did this section get excluded?
530         if [ ! -z "$EXCLUDE_SECTION" ]; then
531                 skip=false
532                 for s in $EXCLUDE_SECTION; do
533                         if [ $section == $s ]; then
534                                 skip=true
535                                 break;
536                         fi
537                 done
538                 if $skip; then
539                         continue
540                 fi
541         fi
542
543         mkdir -p $RESULT_BASE
544         if [ ! -d $RESULT_BASE ]; then
545                 echo "failed to create results directory $RESULT_BASE"
546                 status=1
547                 exit
548         fi
549
550         if $OPTIONS_HAVE_SECTIONS; then
551                 echo "SECTION       -- $section"
552         fi
553
554         sect_start=`_wallclock`
555         if $RECREATE_TEST_DEV || [ "$OLD_FSTYP" != "$FSTYP" ]; then
556                 echo "RECREATING    -- $FSTYP on $TEST_DEV"
557                 _test_unmount 2> /dev/null
558                 if ! _test_mkfs >$tmp.err 2>&1
559                 then
560                         echo "our local _test_mkfs routine ..."
561                         cat $tmp.err
562                         echo "check: failed to mkfs \$TEST_DEV using specified options"
563                         status=1
564                         exit
565                 fi
566                 if ! _test_mount
567                 then
568                         echo "check: failed to mount $TEST_DEV on $TEST_DIR"
569                         status=1
570                         exit
571                 fi
572                 _prepare_test_list
573         elif [ "$OLD_TEST_FS_MOUNT_OPTS" != "$TEST_FS_MOUNT_OPTS" ]; then
574                 _test_unmount 2> /dev/null
575                 if ! _test_mount
576                 then
577                         echo "check: failed to mount $TEST_DEV on $TEST_DIR"
578                         status=1
579                         exit
580                 fi
581         fi
582
583         init_rc
584
585         seq="check"
586         check="$RESULT_BASE/check"
587
588         # don't leave old full output behind on a clean run
589         rm -f $check.full
590
591         [ -f $check.time ] || touch $check.time
592
593         # print out our test configuration
594         echo "FSTYP         -- `_full_fstyp_details`"
595         echo "PLATFORM      -- `_full_platform_details`"
596         if [ ! -z "$SCRATCH_DEV" ]; then
597           echo "MKFS_OPTIONS  -- `_scratch_mkfs_options`"
598           echo "MOUNT_OPTIONS -- `_scratch_mount_options`"
599         fi
600         echo
601         needwrap=true
602
603         if [ ! -z "$SCRATCH_DEV" ]; then
604           _scratch_unmount 2> /dev/null
605           # call the overridden mkfs - make sure the FS is built
606           # the same as we'll create it later.
607
608           if ! _scratch_mkfs >$tmp.err 2>&1
609           then
610               echo "our local _scratch_mkfs routine ..."
611               cat $tmp.err
612               echo "check: failed to mkfs \$SCRATCH_DEV using specified options"
613               status=1
614               exit
615           fi
616
617           # call the overridden mount - make sure the FS mounts with
618           # the same options that we'll mount with later.
619           if ! _scratch_mount >$tmp.err 2>&1
620           then
621               echo "our local mount routine ..."
622               cat $tmp.err
623               echo "check: failed to mount \$SCRATCH_DEV using specified options"
624               status=1
625               exit
626           fi
627         fi
628
629         seqres="$check"
630         _check_test_fs
631
632         for seq in $list
633         do
634             err=false
635             err_msg=""
636             if [ ! -f $seq ]; then
637                 # Try to get full name in case the user supplied only seq id
638                 # and the test has a name. A bit of hassle to find really
639                 # the test and not its sample output or helping files.
640                 bname=$(basename $seq)
641                 full_seq=$(find $(dirname $seq) -name $bname* -executable |
642                     awk '(NR == 1 || length < length(shortest)) { shortest = $0 }\
643                         END { print shortest }')
644                 if [ -f $full_seq ] \
645                     && [ x$(echo $bname | grep -o "^$VALID_TEST_ID") != x ]; then
646                     seq=$full_seq
647                 fi
648             fi
649
650             # the filename for the test and the name output are different.
651             # we don't include the tests/ directory in the name output.
652             export seqnum=`echo $seq | sed -e "s;$SRC_DIR/;;"`
653
654             # Similarly, the result directory needs to replace the tests/
655             # part of the test location.
656             group=`dirname $seq`
657             if $OPTIONS_HAVE_SECTIONS; then
658                 export RESULT_DIR=`echo $group | sed -e "s;$SRC_DIR;${RESULT_BASE}/$section;"`
659                 REPORT_DIR="$RESULT_BASE/$section"
660             else
661                 export RESULT_DIR=`echo $group | sed -e "s;$SRC_DIR;$RESULT_BASE;"`
662                 REPORT_DIR="$RESULT_BASE"
663             fi
664             seqres="$REPORT_DIR/$seqnum"
665
666             mkdir -p $RESULT_DIR
667
668             echo -n "$seqnum"
669
670             if $showme; then
671                 _expunge_test $seqnum
672                 if [ $? -eq 1 ]; then
673                         continue
674                 fi
675                 echo
676                 start=0
677                 stop=0
678                 n_notrun=`expr $n_notrun + 1`
679                 if $do_report; then
680                         _make_testcase_report "list"
681                 fi
682                 continue
683             fi
684             tc_status="pass"
685             if [ ! -f $seq ]; then
686                 echo " - no such test?"
687             else
688                 # really going to try and run this one
689                 #
690                 rm -f $seqres.out.bad
691
692                 # check if we really should run it
693                 _expunge_test $seqnum
694                 if [ $? -eq 1 ]; then
695                         continue
696                 fi
697
698                 # slashes now in names, sed barfs on them so use grep
699                 lasttime=`grep -w ^$seqnum $check.time | awk '// {print $2}'`
700                 if [ "X$lasttime" != X ]; then
701                         echo -n " ${lasttime}s ..."
702                 else
703                         echo -n "       "       # prettier output with timestamps.
704                 fi
705                 rm -f core $seqres.notrun
706
707                 start=`_wallclock`
708                 $timestamp && echo -n " ["`date "+%T"`"]"
709                 [ ! -x $seq ] && chmod u+x $seq # ensure we can run it
710                 $LOGGER_PROG "run xfstest $seqnum"
711                 if [ -w /dev/kmsg ]; then
712                         export date_time=`date +"%F %T"`
713                         echo "run fstests $seqnum at $date_time" > /dev/kmsg
714                         # _check_dmesg depends on this log in dmesg
715                         touch ${RESULT_DIR}/check_dmesg
716                 fi
717                 if [ "$DUMP_OUTPUT" = true ]; then
718                         ./$seq 2>&1 | tee $tmp.rawout
719                         # Because $? would get tee's return code
720                         sts=${PIPESTATUS[0]}
721                 else
722                         ./$seq >$tmp.rawout 2>&1
723                         sts=$?
724                 fi
725                 $timestamp && _timestamp
726                 stop=`_wallclock`
727
728                 _fix_malloc <$tmp.rawout >$tmp.out
729                 rm -f $tmp.rawout
730
731                 if [ -f core ]
732                 then
733                     err_msg="[dumped core]"
734                     echo -n " $err_msg"
735                     mv core $RESULT_BASE/$seqnum.core
736                     err=true
737                 fi
738
739                 if [ -f $seqres.notrun ]
740                 then
741                     $timestamp || echo -n " [not run] "
742                     $timestamp && echo " [not run]" && echo -n "        $seqnum -- "
743                     cat $seqres.notrun
744                     notrun="$notrun $seqnum"
745                     n_notrun=`expr $n_notrun + 1`
746                     tc_status="notrun"
747                 else
748                     if [ $sts -ne 0 ]
749                     then
750                         err_msg="[failed, exit status $sts]"
751                         echo -n " $err_msg"
752                         err=true
753                     fi
754                     if [ ! -f $seq.out ]
755                     then
756                         _dump_err "no qualified output"
757                         err=true
758                     else
759
760                         # coreutils 8.16+ changed quote formats in error messages from
761                         # `foo' to 'foo'. Filter old versions to match the new version.
762                         sed -i "s/\`/\'/g" $tmp.out
763                         if diff $seq.out $tmp.out >/dev/null 2>&1
764                         then
765                             if $err
766                             then
767                                 :
768                             else
769                                 echo "$seqnum `expr $stop - $start`" >>$tmp.time
770                                 echo -n " `expr $stop - $start`s"
771                             fi
772                             echo ""
773                         else
774                             echo " - output mismatch (see $seqres.out.bad)"
775                             mv $tmp.out $seqres.out.bad
776                             $diff $seq.out $seqres.out.bad | {
777                                 if test "$DIFF_LENGTH" -le 0; then
778                                         cat
779                                 else
780                                         head -n "$DIFF_LENGTH"
781                                         echo "..."
782                                         echo "(Run '$diff $seq.out $seqres.out.bad'" \
783                                                 " to see the entire diff)"
784                                 fi; } | \
785                                 sed -e 's/^\(.\)/    \1/'
786                             err_msg="output mismatch (see $diff $seq.out $seqres.out.bad)"
787                             err=true
788                         fi
789                     fi
790                     try="$try $seqnum"
791                     n_try=`expr $n_try + 1`
792                     _check_filesystems
793                     _check_dmesg || err=true
794                 fi
795
796             fi
797
798             # come here for each test, except when $showme is true
799             #
800             if $err
801             then
802                 bad="$bad $seqnum"
803                 n_bad=`expr $n_bad + 1`
804                 quick=false
805                 tc_status="fail"
806             fi
807             if $do_report; then
808                 _make_testcase_report "$tc_status"
809             fi
810             seq="after_$seqnum"
811         done
812         sect_stop=`_wallclock`
813         interrupt=false
814         _wrapup
815         interrupt=true
816         echo
817
818         _test_unmount 2> /dev/null
819         _scratch_unmount 2> /dev/null
820 done
821
822 interrupt=false
823 status=`expr $sum_bad`
824 exit