#! /bin/sh
## --------------------- ##
## M4sh Initialization.  ##
## --------------------- ##

# Be Bourne compatible
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  emulate sh
  NULLCMD=:
  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  set -o posix
fi
DUALCASE=1; export DUALCASE # for MKS sh

# Support unset when possible.
if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  as_unset=unset
else
  as_unset=false
fi


# Work around bugs in pre-3.0 UWIN ksh.
$as_unset ENV MAIL MAILPATH
PS1='$ '
PS2='> '
PS4='+ '

# NLS nuisances.
for as_var in \
  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  LC_TELEPHONE LC_TIME
do
  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
    eval $as_var=C; export $as_var
  else
    $as_unset $as_var
  fi
done

# Required to use basename.
if expr a : '\(a\)' >/dev/null 2>&1; then
  as_expr=expr
else
  as_expr=false
fi

if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  as_basename=basename
else
  as_basename=false
fi


# Name of the executable.
as_me=`$as_basename "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
	 X"$0" : 'X\(//\)$' \| \
	 X"$0" : 'X\(/\)$' \| \
	 .     : '\(.\)' 2>/dev/null ||
echo X/"$0" |
    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  	  /^X\/\(\/\/\)$/{ s//\1/; q; }
  	  /^X\/\(\/\).*/{ s//\1/; q; }
  	  s/.*/./; q'`


# PATH needs CR, and LINENO needs CR and PATH.
# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits

# The user is always right.
if test "${PATH_SEPARATOR+set}" != set; then
  echo "#! /bin/sh" >conf$$.sh
  echo  "exit 0"   >>conf$$.sh
  chmod +x conf$$.sh
  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
    PATH_SEPARATOR=';'
  else
    PATH_SEPARATOR=:
  fi
  rm -f conf$$.sh
fi


  as_lineno_1=$LINENO
  as_lineno_2=$LINENO
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
  test "x$as_lineno_1" != "x$as_lineno_2" &&
  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
  # Find who we are.  Look in the path if we contain no path at all
  # relative or not.
  case $0 in
    *[\\/]* ) as_myself=$0 ;;
    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
done

       ;;
  esac
  # We did not find ourselves, most probably we were run as `sh COMMAND'
  # in which case we are not to be found in the path.
  if test "x$as_myself" = x; then
    as_myself=$0
  fi
  if test ! -f "$as_myself"; then
    { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
   { (exit 1); exit 1; }; }
  fi
  case $CONFIG_SHELL in
  '')
    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  for as_base in sh bash ksh sh5; do
	 case $as_dir in
	 /*)
	   if ("$as_dir/$as_base" -c '
  as_lineno_1=$LINENO
  as_lineno_2=$LINENO
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
  test "x$as_lineno_1" != "x$as_lineno_2" &&
  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
	     $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
	     $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
	     CONFIG_SHELL=$as_dir/$as_base
	     export CONFIG_SHELL
	     exec "$CONFIG_SHELL" "$0" ${1+"$@"}
	   fi;;
	 esac
       done
done
;;
  esac

  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
  # uniformly replaced by the line number.  The first 'sed' inserts a
  # line-number line before each line; the second 'sed' does the real
  # work.  The second script uses 'N' to pair each line-number line
  # with the numbered line, and appends trailing '-' during
  # substitution so that $LINENO is not a special case at line end.
  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
  sed '=' <$as_myself |
    sed '
      N
      s,$,-,
      : loop
      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
      t loop
      s,-$,,
      s,^['$as_cr_digits']*\n,,
    ' >$as_me.lineno &&
  chmod +x $as_me.lineno ||
    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
   { (exit 1); exit 1; }; }

  # Don't try to exec as it changes $[0], causing all sort of problems
  # (the dirname of $[0] is not the place where we might find the
  # original and so on.  Autoconf is especially sensible to this).
  . ./$as_me.lineno
  # Exit status is that of the last command.
  exit
}


case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
  *c*,-n*) ECHO_N= ECHO_C='
' ECHO_T='	' ;;
  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
esac

if expr a : '\(a\)' >/dev/null 2>&1; then
  as_expr=expr
else
  as_expr=false
fi

rm -f conf$$ conf$$.exe conf$$.file
echo >conf$$.file
if ln -s conf$$.file conf$$ 2>/dev/null; then
  # We could just check for DJGPP; but this test a) works b) is more generic
  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
  if test -f conf$$.exe; then
    # Don't use ln at all; we don't have any links
    as_ln_s='cp -p'
  else
    as_ln_s='ln -s'
  fi
elif ln conf$$.file conf$$ 2>/dev/null; then
  as_ln_s=ln
else
  as_ln_s='cp -p'
fi
rm -f conf$$ conf$$.exe conf$$.file

if mkdir -p . 2>/dev/null; then
  as_mkdir_p=:
else
  test -d ./-p && rmdir ./-p
  as_mkdir_p=false
fi

as_executable_p="test -f"

# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"

# Sed expression to map a string onto a valid variable name.
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"


# IFS
# We need space, tab and new line, in precisely that order.
as_nl='
'
IFS=" 	$as_nl"

# CDPATH.
$as_unset CDPATH


SHELL=${CONFIG_SHELL-/bin/sh}

# How were we run?
at_cli_args="$@"

# Load the config file.
for at_file in atconfig atlocal
do
  test -r $at_file || continue
  . ./$at_file || { echo "$as_me: error: invalid content: $at_file" >&2
   { (exit 1); exit 1; }; }
done

# atconfig delivers paths relative to the directory the test suite is
# in, but the groups themselves are run in testsuite-dir/group-dir.
if test -n "$at_top_srcdir"; then
  builddir=../..
  for at_dir in srcdir top_srcdir top_builddir
  do
    at_val=`eval echo '${'at_$at_dir'}'`
    eval "$at_dir=\$at_val/../.."
  done
fi

# Not all shells have the 'times' builtin; the subshell is needed to make
# sure we discard the 'times: not found' message from the shell.
at_times_p=false
(times) >/dev/null 2>&1 && at_times_p=:

# CLI Arguments to pass to the debugging scripts.
at_debug_args=
# -e sets to true
at_errexit_p=false
# Shall we be verbose?
at_verbose=:
at_quiet=echo

# Shall we keep the debug scripts?  Must be `:' when the suite is
# run by a debug script, so that the script doesn't remove itself.
at_debug_p=false
# Display help message?
at_help_p=false
# List test groups?
at_list_p=false
# Test groups to run
at_groups=

# The directory we are in.
at_dir=`pwd`
# The directory the whole suite works in.
# Should be absolutely to let the user `cd' at will.
at_suite_dir=$at_dir/$as_me.dir
# The file containing the suite.
at_suite_log=$at_dir/$as_me.log
# The file containing the location of the last AT_CHECK.
at_check_line_file=$at_suite_dir/at-check-line
# The file containing the exit status of the last command.
at_status_file=$at_suite_dir/at-status
# The files containing the output of the tested commands.
at_stdout=$at_suite_dir/at-stdout
at_stder1=$at_suite_dir/at-stder1
at_stderr=$at_suite_dir/at-stderr
# The file containing dates.
at_times_file=$at_suite_dir/at-times

# List of the tested programs.
at_tested='cobc'
# List of the all the test groups.
at_groups_all=' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17'
# As many dots as there are digits in the last test group number.
# Used to normalize the test group numbers so that `ls' lists them in
# numerical order.
at_format='..'
# Description of all the test groups.
at_help_all='1;binary.at:23;BINARY: 2-4-8 big-endian;;
2;binary.at:207;BINARY: 2-4-8 native;;
3;binary.at:396;BINARY: 1-2-4-8 big-endian;;
4;binary.at:580;BINARY: 1-2-4-8 native;;
5;binary.at:770;BINARY: 1--8 big-endian;;
6;binary.at:954;BINARY: 1--8 native;;
7;binary.at:1144;BINARY: full-print;;
8;display.at:22;DISPLAY: Sign ASCII;;
9;display.at:80;DISPLAY: Sign ASCII (2);;
10;display.at:125;DISPLAY: Sign EBCDIC;;
11;packed.at:25;PACKED-DECIMAL dump;;
12;packed.at:160;PACKED-DECIMAL display;;
13;packed.at:207;PACKED-DECIMAL move;;
14;packed.at:256;PACKED-DECIMAL arithmetic (1);;
15;packed.at:291;PACKED-DECIMAL arithmetic (2);;
16;packed.at:324;PACKED-DECIMAL numeric test;;
17;pointer.at:22;POINTER: display;;
'

at_keywords=
at_prev=
for at_option
do
  # If the previous option needs an argument, assign it.
  if test -n "$at_prev"; then
    at_option=$at_prev=$at_option
    at_prev=
  fi

  at_optarg=`expr "x$at_option" : 'x[^=]*=\(.*\)'`

  # Accept the important Cygnus configure options, so we can diagnose typos.

  case $at_option in
    --help | -h )
	at_help_p=:
	;;

    --list | -l )
	at_list_p=:
	;;

    --version | -V )
	echo "$as_me (OpenCOBOL 1.1)"
	exit 0
	;;

    --clean | -c )
	rm -rf $at_suite_dir $at_suite_log
	exit 0
	;;

    --debug | -d )
	at_debug_p=:
	;;

    --errexit | -e )
	at_debug_p=:
	at_errexit_p=:
	;;

    --verbose | -v )
	at_verbose=echo; at_quiet=:
	;;

    --trace | -x )
	at_traceon='set -vx'; at_traceoff='set +vx'
	;;

    [0-9] | [0-9][0-9] | [0-9][0-9][0-9] | [0-9][0-9][0-9][0-9])
	at_groups="$at_groups$at_option "
	;;

    # Ranges
    [0-9]- | [0-9][0-9]- | [0-9][0-9][0-9]- | [0-9][0-9][0-9][0-9]-)
	at_range_start=`echo $at_option |tr -d '-'`
	at_range=`echo " $at_groups_all " | \
	  sed -e 's,^.* '$at_range_start' ,'$at_range_start' ,'`
	at_groups="$at_groups$at_range "
	;;

    -[0-9] | -[0-9][0-9] | -[0-9][0-9][0-9] | -[0-9][0-9][0-9][0-9])
	at_range_end=`echo $at_option |tr -d '-'`
	at_range=`echo " $at_groups_all " | \
	  sed -e 's, '$at_range_end' .*$, '$at_range_end','`
	at_groups="$at_groups$at_range "
	;;

    [0-9]-[0-9] | [0-9]-[0-9][0-9] | [0-9]-[0-9][0-9][0-9] | \
    [0-9]-[0-9][0-9][0-9][0-9] | [0-9][0-9]-[0-9][0-9] | \
    [0-9][0-9]-[0-9][0-9][0-9] | [0-9][0-9]-[0-9][0-9][0-9][0-9] | \
    [0-9][0-9][0-9]-[0-9][0-9][0-9] | \
    [0-9][0-9][0-9]-[0-9][0-9][0-9][0-9] | \
    [0-9][0-9][0-9][0-9]-[0-9][0-9][0-9][0-9] )
	at_range_start=`echo $at_option |sed 's,-.*,,'`
	at_range_end=`echo $at_option |sed 's,.*-,,'`
	# FIXME: Maybe test to make sure start <= end?
	at_range=`echo " $at_groups_all " | \
	  sed -e 's,^.* '$at_range_start' ,'$at_range_start' ,' \
	      -e 's, '$at_range_end' .*$, '$at_range_end','`
	at_groups="$at_groups$at_range "
	;;

    # Keywords.
    --keywords | -k )
	at_prev=--keywords
	;;
    --keywords=* )
	at_keywords="$at_keywords,$at_optarg"
	;;

    *=*)
  	at_envvar=`expr "x$at_option" : 'x\([^=]*\)='`
  	# Reject names that are not valid shell variable names.
  	expr "x$at_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
  	  { echo "$as_me: error: invalid variable name: $at_envvar" >&2
   { (exit 1); exit 1; }; }
  	at_value=`echo "$at_optarg" | sed "s/'/'\\\\\\\\''/g"`
  	eval "$at_envvar='$at_value'"
  	export $at_envvar
	# Propagate to debug scripts.
  	at_debug_args="$at_debug_args $at_option"
  	;;

     *) echo "$as_me: invalid option: $at_option" >&2
	echo "Try \`$0 --help' for more information." >&2
	exit 1
	;;
  esac
done

# Process the --keywords
if test -n "$at_keywords"; then
  at_groups_selected=$at_help_all
  for at_keyword in `IFS=,; set X $at_keywords; shift; echo ${1+$@}`
  do
    # It is on purpose that we match the test group titles too.
    at_groups_selected=`echo "$at_groups_selected" |
			grep -i "^[^;]*;[^;]*.*[; ]$at_keyword[ ;]"`
  done
  at_groups_selected=`echo "$at_groups_selected" | sed 's/;.*//'`
  # Smash the end of lines.
  at_groups_selected=`echo $at_groups_selected`
  at_groups="$at_groups$at_groups_selected "
fi

# Selected test groups.
test -z "$at_groups" && at_groups=$at_groups_all

# Help message.
if $at_help_p; then
  cat <<_ATEOF
Usage: $0 [OPTION]... [VARIABLE=VALUE]... [TESTS]

Run all the tests, or the selected TESTS, and save a detailed log file.
Upon failure, create debugging scripts.

You should not change environment variables unless explicitly passed
as command line arguments.  Set \`AUTOTEST_PATH' to select the executables
to exercise.  Each relative directory is expanded as build and source
directories relatively to the top level of this distribution.  E.g.,

  $ $0 AUTOTEST_PATH=bin

possibly amounts into

  PATH=/tmp/foo-1.0/bin:/src/foo-1.0/bin:\$PATH
_ATEOF
cat <<_ATEOF

Operation modes:
  -h, --help     print the help message, then exit
  -V, --version  print version number, then exit
  -c, --clean    remove all the files this test suite might create and exit
  -l, --list     describes all the tests, or the selected TESTS
_ATEOF
cat <<_ATEOF

Execution tuning:
  -k, --keywords=KEYWORDS
	         select the tests matching all the comma separated KEYWORDS
	         accumulates
  -e, --errexit  abort as soon as a test fails; implies --debug
  -v, --verbose  force more detailed output
	         default for debugging scripts
  -d, --debug    inhibit clean up and debug script creation
	         default for debugging scripts
  -x, --trace    enable tests shell tracing
_ATEOF
cat <<_ATEOF

Report bugs to <open-cobol-list@lists.sourceforge.net>.
_ATEOF
  exit 0
fi

# List of tests.
if $at_list_p; then
  cat <<_ATEOF
OpenCOBOL 1.1 test suite: Data Representation test groups:

 NUM: FILENAME:LINE      TEST-GROUP-NAME
      KEYWORDS

_ATEOF
  # "  1 42  45 " => "^(1|42|45);".
  at_groups_pattern=`echo "$at_groups" | sed 's/^  *//;s/  *$//;s/  */|/g'`
  echo "$at_help_all" |
    awk 'BEGIN { FS = ";" }
	 { if ($1 !~ /^('"$at_groups_pattern"')$/) next }
	 { if ($1) printf " %3d: %-18s %s\n", $1, $2, $3
	   if ($4) printf "      %s\n", $4 } '
  exit 0
fi

# Don't take risks: use only absolute directories in PATH.
#
# For stand-alone test suites, AUTOTEST_PATH is relative to `.'.
#
# For embedded test suites, AUTOTEST_PATH is relative to the top level
# of the package.  Then expand it into build/src parts, since users
# may create executables in both places.
#
# There might be directories that don't exist, but don't redirect
# builtins' (eg., cd) stderr directly: Ultrix's sh hates that.
AUTOTEST_PATH=`echo $AUTOTEST_PATH | tr ':' $PATH_SEPARATOR`
at_path=
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $AUTOTEST_PATH $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  case $as_dir in
  [\\/]* | ?:[\\/]* )
    at_path=$at_path$PATH_SEPARATOR$as_dir
    ;;
  * )
    if test -z "$at_top_builddir"; then
      # Stand-alone test suite.
      at_path=$at_path$PATH_SEPARATOR$as_dir
    else
      # Embedded test suite.
      at_path=$at_path$PATH_SEPARATOR$at_top_builddir/$as_dir
      at_path=$at_path$PATH_SEPARATOR$at_top_srcdir/$as_dir
    fi
    ;;
esac
done


# Now build and simplify PATH.
PATH=
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $at_path
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  as_dir=`(cd "$as_dir" && pwd) 2>/dev/null`
test -d "$as_dir" || continue
case $PATH in
	          $as_dir                 | \
	          $as_dir$PATH_SEPARATOR* | \
  *$PATH_SEPARATOR$as_dir                 | \
  *$PATH_SEPARATOR$as_dir$PATH_SEPARATOR* ) ;;

  '') PATH=$as_dir ;;
   *) PATH=$PATH$PATH_SEPARATOR$as_dir ;;
esac
done

export PATH

# Setting up the FDs.
# 5 is the log file.  Not to be overwritten if `-d'.

$at_debug_p && at_suite_log=/dev/null
exec 5>$at_suite_log

# Banners and logs.
cat <<\_ASBOX
## ---------------------------------------------- ##
## OpenCOBOL 1.1 test suite: Data Representation. ##
## ---------------------------------------------- ##
_ASBOX
{
  cat <<\_ASBOX
## ---------------------------------------------- ##
## OpenCOBOL 1.1 test suite: Data Representation. ##
## ---------------------------------------------- ##
_ASBOX
  echo

  echo "$as_me: command line was:"
  echo "  $ $0 $at_cli_args"
  echo

  # Try to find a few ChangeLogs in case it might help determining the
  # exact version.  Use the relative dir: if the top dir is a symlink,
  # find will not follow it (and options to follow the links are not
  # portable), which would result in no output here.
  if test -n "$at_top_srcdir"; then
    cat <<\_ASBOX
## ----------- ##
## ChangeLogs. ##
## ----------- ##
_ASBOX
    echo
    for at_file in `find "$at_top_srcdir" -name ChangeLog -print`
    do
      echo "$as_me: $at_file:"
      sed 's/^/| /;10q' $at_file
      echo
    done

    {
cat <<_ASUNAME
## --------- ##
## Platform. ##
## --------- ##

hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
uname -m = `(uname -m) 2>/dev/null || echo unknown`
uname -r = `(uname -r) 2>/dev/null || echo unknown`
uname -s = `(uname -s) 2>/dev/null || echo unknown`
uname -v = `(uname -v) 2>/dev/null || echo unknown`

/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`

/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`

_ASUNAME

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  echo "PATH: $as_dir"
done

}
    echo
  fi

  # Contents of the config files.
  for at_file in atconfig atlocal
  do
    test -r $at_file || continue
    echo "$as_me: $at_file:"
    sed 's/^/| /' $at_file
    echo
  done

  cat <<\_ASBOX
## ---------------- ##
## Tested programs. ##
## ---------------- ##
_ASBOX
  echo
} >&5

# Report what programs are being tested.
for at_program in : $at_tested
do
  test "$at_program" = : && continue
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  test -f $as_dir/$at_program && break
done

  if test -f $as_dir/$at_program; then
    {
      echo "data-rep.at:21: $as_dir/$at_program --version"
      $as_dir/$at_program --version
      echo
    } >&5 2>&1
  else
    { { echo "$as_me:$LINENO: error: cannot find $at_program" >&5
echo "$as_me: error: cannot find $at_program" >&2;}
   { (exit 1); exit 1; }; }
  fi
done

{
  cat <<\_ASBOX
## ------------------ ##
## Running the tests. ##
## ------------------ ##
_ASBOX
} >&5

at_start_date=`date`
at_start_time=`(date +%s) 2>/dev/null`
echo "$as_me: starting at: $at_start_date" >&5
at_xpass_list=
at_xfail_list=
at_pass_list=
at_fail_list=
at_skip_list=
at_group_count=0

# Create the master directory if it doesn't already exist.
test -d $at_suite_dir ||
  mkdir $at_suite_dir ||
  { { echo "$as_me:$LINENO: error: cannot create $at_suite_dir" >&5
echo "$as_me: error: cannot create $at_suite_dir" >&2;}
   { (exit 1); exit 1; }; }

# Can we diff with `/dev/null'?  DU 5.0 refuses.
if diff /dev/null /dev/null >/dev/null 2>&1; then
  at_devnull=/dev/null
else
  at_devnull=$at_suite_dir/devnull
  cp /dev/null $at_devnull
fi

# Use `diff -u' when possible.
if diff -u $at_devnull $at_devnull >/dev/null 2>&1; then
  at_diff='diff -u'
else
  at_diff=diff
fi


for at_group in $at_groups
do
  # Be sure to come back to the top test directory.
  cd $at_suite_dir

  case $at_group in
    banner-*)
      at_group_log=$at_suite_log
      ;;

    *)
      # Skip tests we already run (using --keywords makes it easy to get
      # duplication).
      case " $at_pass_test $at_skip_test $at_fail_test " in
	*" $at_group "* ) continue;;
      esac

      # Normalize the test group number.
      at_group_normalized=`expr "00000$at_group" : ".*\($at_format\)"`

      # Create a fresh directory for the next test group, and enter.
      at_group_dir=$at_suite_dir/$at_group_normalized
      at_group_log=$at_group_dir/$as_me.log
      rm -rf $at_group_dir
      mkdir $at_group_dir ||
	{ { echo "$as_me:$LINENO: error: cannot create $at_group_dir" >&5
echo "$as_me: error: cannot create $at_group_dir" >&2;}
   { (exit 1); exit 1; }; }
      cd $at_group_dir
      ;;
  esac

  echo 0 > $at_status_file

  # Clearly separate the test groups when verbose.
  test $at_group_count != 0 && $at_verbose

  # In verbose mode, append to the log file *and* show on
  # the standard output; in quiet mode only write to the log
  if test $at_verbose = echo; then
    at_tee_pipe="tee -a $at_group_log"
  else
    at_tee_pipe="cat >> $at_group_log"
  fi

  case $at_group in
  1 ) # 1. binary.at:23: BINARY: 2-4-8 big-endian
    at_setup_line='binary.at:23'
    at_desc='BINARY: 2-4-8 big-endian'
    $at_quiet $ECHO_N "  1: BINARY: 2-4-8 big-endian                     $ECHO_C"
    at_xfail=no
    (
      echo "1. binary.at:23: testing ..."
      $at_traceon


cat >test.conf <<'_ATEOF'

include "cobol2002.conf"
binary-size: 2-4-8
binary-byteorder: big-endian
_ATEOF


cat >dump.c <<'_ATEOF'

#include <stdio.h>
int dump (unsigned char *data);
int dump (unsigned char *data)
{
  int i;
  for (i = 0; i < 8; i++)
    printf ("%02x", data[i]);
  puts ("");
  return 0;
}
_ATEOF


$at_traceoff
echo "binary.at:44: \${CC} \${SHROPT} -o dump.\${SHREXT} dump.c"
echo binary.at:44 >$at_check_line_file
( $at_traceon; ${CC} ${SHROPT} -o dump.${SHREXT} dump.c ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:44: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


sed -e 's/@USAGE@/BINARY/' ${TEMPLATE}/numeric-dump.cob > prog.cob

$at_traceoff
echo "binary.at:48: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo binary.at:48 >$at_check_line_file
( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:48: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "binary.at:158: ./prog"
echo binary.at:158 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "0001202020202020
000c202020202020
007b202020202020
04d2202020202020
0000303920202020
0001e24020202020
0012d68720202020
00bc614e20202020
075bcd1520202020
00000000499602d2
00000002dfdc1c35
0000001cbe991a14
0000011f71fb04cb
00000b3a73ce2ff2
00007048860ddf79
000462d53c8abac0
002bdc545d6b4b87
01b69b4ba630f34e
ffff202020202020
fff4202020202020
ff85202020202020
fb2e202020202020
ffffcfc720202020
fffe1dc020202020
ffed297920202020
ff439eb220202020
f8a432eb20202020
ffffffffb669fd2e
fffffffd2023e3cb
ffffffe34166e5ec
fffffee08e04fb35
fffff4c58c31d00e
ffff8fb779f22087
fffb9d2ac3754540
ffd423aba294b479
fe4964b459cf0cb2
0000202020202020
0000202020202020
0000202020202020
0000202020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000202020202020
0000202020202020
0000202020202020
0000202020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000202020202020
0000202020202020
0000202020202020
0000202020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000202020202020
0000202020202020
0000202020202020
0000202020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:158: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


sed -e 's/@USAGE@/BINARY/' ${TEMPLATE}/numeric-display.cob > prog.cob

$at_traceoff
echo "binary.at:162: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo binary.at:162 >$at_check_line_file
( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:162: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "binary.at:200: ./prog"
echo binary.at:200 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "1
12
123
1234
12345
123456
1234567
12345678
123456789
1234567890
12345678901
123456789012
1234567890123
12345678901234
123456789012345
1234567890123456
12345678901234567
123456789012345678
-1
-12
-123
-1234
-12345
-123456
-1234567
-12345678
-123456789
-1234567890
-12345678901
-123456789012
-1234567890123
-12345678901234
-123456789012345
-1234567890123456
-12345678901234567
-123456789012345678
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:200: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


      $at_traceoff
      $at_times_p && times >$at_times_file
    ) 5>&1 2>&1 | eval $at_tee_pipe
    at_status=`cat $at_status_file`
    ;;

  2 ) # 2. binary.at:207: BINARY: 2-4-8 native
    at_setup_line='binary.at:207'
    at_desc='BINARY: 2-4-8 native'
    $at_quiet $ECHO_N "  2: BINARY: 2-4-8 native                         $ECHO_C"
    at_xfail=no
    (
      echo "2. binary.at:207: testing ..."
      $at_traceon


if test "x$COB_BIGENDIAN" = "xyes"; then
$at_traceoff
echo "binary.at:210: true"
echo binary.at:210 >$at_check_line_file
( $at_traceon; true ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:210: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

else

cat >test.conf <<'_ATEOF'

include "cobol2002.conf"
binary-size: 2-4-8
binary-byteorder: native
_ATEOF


cat >dump.c <<'_ATEOF'

#include <stdio.h>
int dump (unsigned char *data);
int dump (unsigned char *data)
{
  int i;
  for (i = 0; i < 8; i++)
    printf ("%02x", data[i]);
  puts ("");
  return 0;
}
_ATEOF


$at_traceoff
echo "binary.at:232: \${CC} \${SHROPT} -o dump.\${SHREXT} dump.c"
echo binary.at:232 >$at_check_line_file
( $at_traceon; ${CC} ${SHROPT} -o dump.${SHREXT} dump.c ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:232: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


sed -e 's/@USAGE@/BINARY/' ${TEMPLATE}/numeric-dump.cob > prog.cob

$at_traceoff
echo "binary.at:236: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo binary.at:236 >$at_check_line_file
( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:236: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "binary.at:346: ./prog"
echo binary.at:346 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "0100202020202020
0c00202020202020
7b00202020202020
d204202020202020
3930000020202020
40e2010020202020
87d6120020202020
4e61bc0020202020
15cd5b0720202020
d202964900000000
351cdcdf02000000
141a99be1c000000
cb04fb711f010000
f22fce733a0b0000
79df0d8648700000
c0ba8a3cd5620400
874b6b5d54dc2b00
4ef330a64b9bb601
ffff202020202020
f4ff202020202020
85ff202020202020
2efb202020202020
c7cfffff20202020
c01dfeff20202020
7929edff20202020
b29e43ff20202020
eb32a4f820202020
2efd69b6ffffffff
cbe32320fdffffff
ece56641e3ffffff
35fb048ee0feffff
0ed0318cc5f4ffff
8720f279b78fffff
404575c32a9dfbff
79b494a2ab23d4ff
b20ccf59b46449fe
0000202020202020
0000202020202020
0000202020202020
0000202020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000202020202020
0000202020202020
0000202020202020
0000202020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000202020202020
0000202020202020
0000202020202020
0000202020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000202020202020
0000202020202020
0000202020202020
0000202020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:346: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


sed -e 's/@USAGE@/BINARY/' ${TEMPLATE}/numeric-display.cob > prog.cob

$at_traceoff
echo "binary.at:350: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo binary.at:350 >$at_check_line_file
( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:350: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "binary.at:388: ./prog"
echo binary.at:388 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "1
12
123
1234
12345
123456
1234567
12345678
123456789
1234567890
12345678901
123456789012
1234567890123
12345678901234
123456789012345
1234567890123456
12345678901234567
123456789012345678
-1
-12
-123
-1234
-12345
-123456
-1234567
-12345678
-123456789
-1234567890
-12345678901
-123456789012
-1234567890123
-12345678901234
-123456789012345
-1234567890123456
-12345678901234567
-123456789012345678
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:388: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

fi

      $at_traceoff
      $at_times_p && times >$at_times_file
    ) 5>&1 2>&1 | eval $at_tee_pipe
    at_status=`cat $at_status_file`
    ;;

  3 ) # 3. binary.at:396: BINARY: 1-2-4-8 big-endian
    at_setup_line='binary.at:396'
    at_desc='BINARY: 1-2-4-8 big-endian'
    $at_quiet $ECHO_N "  3: BINARY: 1-2-4-8 big-endian                   $ECHO_C"
    at_xfail=no
    (
      echo "3. binary.at:396: testing ..."
      $at_traceon


cat >test.conf <<'_ATEOF'

include "cobol2002.conf"
binary-size: 1-2-4-8
binary-byteorder: big-endian
_ATEOF


cat >dump.c <<'_ATEOF'

#include <stdio.h>
int dump (unsigned char *data);
int dump (unsigned char *data)
{
  int i;
  for (i = 0; i < 8; i++)
    printf ("%02x", data[i]);
  puts ("");
  return 0;
}
_ATEOF


$at_traceoff
echo "binary.at:417: \${CC} \${SHROPT} -o dump.\${SHREXT} dump.c"
echo binary.at:417 >$at_check_line_file
( $at_traceon; ${CC} ${SHROPT} -o dump.${SHREXT} dump.c ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:417: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


sed -e 's/@USAGE@/BINARY/' ${TEMPLATE}/numeric-dump.cob > prog.cob

$at_traceoff
echo "binary.at:421: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo binary.at:421 >$at_check_line_file
( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:421: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "binary.at:531: ./prog"
echo binary.at:531 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "0120202020202020
0c20202020202020
007b202020202020
04d2202020202020
0000303920202020
0001e24020202020
0012d68720202020
00bc614e20202020
075bcd1520202020
00000000499602d2
00000002dfdc1c35
0000001cbe991a14
0000011f71fb04cb
00000b3a73ce2ff2
00007048860ddf79
000462d53c8abac0
002bdc545d6b4b87
01b69b4ba630f34e
ff20202020202020
f420202020202020
ff85202020202020
fb2e202020202020
ffffcfc720202020
fffe1dc020202020
ffed297920202020
ff439eb220202020
f8a432eb20202020
ffffffffb669fd2e
fffffffd2023e3cb
ffffffe34166e5ec
fffffee08e04fb35
fffff4c58c31d00e
ffff8fb779f22087
fffb9d2ac3754540
ffd423aba294b479
fe4964b459cf0cb2
0020202020202020
0020202020202020
0000202020202020
0000202020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0020202020202020
0020202020202020
0000202020202020
0000202020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0020202020202020
0020202020202020
0000202020202020
0000202020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0020202020202020
0020202020202020
0000202020202020
0000202020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:531: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


sed -e 's/@USAGE@/BINARY/' ${TEMPLATE}/numeric-display.cob > prog.cob

$at_traceoff
echo "binary.at:535: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo binary.at:535 >$at_check_line_file
( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:535: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "binary.at:573: ./prog"
echo binary.at:573 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "1
12
123
1234
12345
123456
1234567
12345678
123456789
1234567890
12345678901
123456789012
1234567890123
12345678901234
123456789012345
1234567890123456
12345678901234567
123456789012345678
-1
-12
-123
-1234
-12345
-123456
-1234567
-12345678
-123456789
-1234567890
-12345678901
-123456789012
-1234567890123
-12345678901234
-123456789012345
-1234567890123456
-12345678901234567
-123456789012345678
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:573: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


      $at_traceoff
      $at_times_p && times >$at_times_file
    ) 5>&1 2>&1 | eval $at_tee_pipe
    at_status=`cat $at_status_file`
    ;;

  4 ) # 4. binary.at:580: BINARY: 1-2-4-8 native
    at_setup_line='binary.at:580'
    at_desc='BINARY: 1-2-4-8 native'
    $at_quiet $ECHO_N "  4: BINARY: 1-2-4-8 native                       $ECHO_C"
    at_xfail=no
    (
      echo "4. binary.at:580: testing ..."
      $at_traceon


if test "x$COB_BIGENDIAN" = "xyes"; then
$at_traceoff
echo "binary.at:583: true"
echo binary.at:583 >$at_check_line_file
( $at_traceon; true ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:583: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

else

cat >test.conf <<'_ATEOF'

include "cobol2002.conf"
binary-size: 1-2-4-8
binary-byteorder: native
_ATEOF


cat >dump.c <<'_ATEOF'

#include <stdio.h>
int dump (unsigned char *data);
int dump (unsigned char *data)
{
  int i;
  for (i = 0; i < 8; i++)
    printf ("%02x", data[i]);
  puts ("");
  return 0;
}
_ATEOF


$at_traceoff
echo "binary.at:605: \${CC} \${SHROPT} -o dump.\${SHREXT} dump.c"
echo binary.at:605 >$at_check_line_file
( $at_traceon; ${CC} ${SHROPT} -o dump.${SHREXT} dump.c ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:605: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


sed -e 's/@USAGE@/BINARY/' ${TEMPLATE}/numeric-dump.cob > prog.cob

$at_traceoff
echo "binary.at:609: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo binary.at:609 >$at_check_line_file
( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:609: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "binary.at:719: ./prog"
echo binary.at:719 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "0120202020202020
0c20202020202020
7b00202020202020
d204202020202020
3930000020202020
40e2010020202020
87d6120020202020
4e61bc0020202020
15cd5b0720202020
d202964900000000
351cdcdf02000000
141a99be1c000000
cb04fb711f010000
f22fce733a0b0000
79df0d8648700000
c0ba8a3cd5620400
874b6b5d54dc2b00
4ef330a64b9bb601
ff20202020202020
f420202020202020
85ff202020202020
2efb202020202020
c7cfffff20202020
c01dfeff20202020
7929edff20202020
b29e43ff20202020
eb32a4f820202020
2efd69b6ffffffff
cbe32320fdffffff
ece56641e3ffffff
35fb048ee0feffff
0ed0318cc5f4ffff
8720f279b78fffff
404575c32a9dfbff
79b494a2ab23d4ff
b20ccf59b46449fe
0020202020202020
0020202020202020
0000202020202020
0000202020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0020202020202020
0020202020202020
0000202020202020
0000202020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0020202020202020
0020202020202020
0000202020202020
0000202020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0020202020202020
0020202020202020
0000202020202020
0000202020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000020202020
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:719: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


sed -e 's/@USAGE@/BINARY/' ${TEMPLATE}/numeric-display.cob > prog.cob

$at_traceoff
echo "binary.at:723: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo binary.at:723 >$at_check_line_file
( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:723: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "binary.at:761: ./prog"
echo binary.at:761 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "1
12
123
1234
12345
123456
1234567
12345678
123456789
1234567890
12345678901
123456789012
1234567890123
12345678901234
123456789012345
1234567890123456
12345678901234567
123456789012345678
-1
-12
-123
-1234
-12345
-123456
-1234567
-12345678
-123456789
-1234567890
-12345678901
-123456789012
-1234567890123
-12345678901234
-123456789012345
-1234567890123456
-12345678901234567
-123456789012345678
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:761: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


fi

      $at_traceoff
      $at_times_p && times >$at_times_file
    ) 5>&1 2>&1 | eval $at_tee_pipe
    at_status=`cat $at_status_file`
    ;;

  5 ) # 5. binary.at:770: BINARY: 1--8 big-endian
    at_setup_line='binary.at:770'
    at_desc='BINARY: 1--8 big-endian'
    $at_quiet $ECHO_N "  5: BINARY: 1--8 big-endian                      $ECHO_C"
    at_xfail=no
    (
      echo "5. binary.at:770: testing ..."
      $at_traceon


cat >test.conf <<'_ATEOF'

include "cobol2002.conf"
binary-size: 1--8
binary-byteorder: big-endian
_ATEOF


cat >dump.c <<'_ATEOF'

#include <stdio.h>
int dump (unsigned char *data);
int dump (unsigned char *data)
{
  int i;
  for (i = 0; i < 8; i++)
    printf ("%02x", data[i]);
  puts ("");
  return 0;
}
_ATEOF


$at_traceoff
echo "binary.at:791: \${CC} \${SHROPT} -o dump.\${SHREXT} dump.c"
echo binary.at:791 >$at_check_line_file
( $at_traceon; ${CC} ${SHROPT} -o dump.${SHREXT} dump.c ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:791: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


sed -e 's/@USAGE@/BINARY/' ${TEMPLATE}/numeric-dump.cob > prog.cob

$at_traceoff
echo "binary.at:795: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo binary.at:795 >$at_check_line_file
( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:795: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "binary.at:905: ./prog"
echo binary.at:905 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "0120202020202020
0c20202020202020
007b202020202020
04d2202020202020
0030392020202020
01e2402020202020
12d6872020202020
00bc614e20202020
075bcd1520202020
00499602d2202020
02dfdc1c35202020
1cbe991a14202020
011f71fb04cb2020
0b3a73ce2ff22020
007048860ddf7920
0462d53c8abac020
002bdc545d6b4b87
01b69b4ba630f34e
ff20202020202020
f420202020202020
ff85202020202020
fb2e202020202020
ffcfc72020202020
fe1dc02020202020
ffed297920202020
ff439eb220202020
f8a432eb20202020
ffb669fd2e202020
fd2023e3cb202020
ffe34166e5ec2020
fee08e04fb352020
f4c58c31d00e2020
ff8fb779f2208720
fb9d2ac375454020
ffd423aba294b479
fe4964b459cf0cb2
0020202020202020
0020202020202020
0000202020202020
0000202020202020
0000002020202020
0000002020202020
0000002020202020
0000000020202020
0000000020202020
0000000000202020
0000000000202020
0000000000202020
0000000000002020
0000000000002020
0000000000000020
0000000000000020
0000000000000000
0000000000000000
0020202020202020
0020202020202020
0000202020202020
0000202020202020
0000002020202020
0000002020202020
0000000020202020
0000000020202020
0000000020202020
0000000000202020
0000000000202020
0000000000002020
0000000000002020
0000000000002020
0000000000000020
0000000000000020
0000000000000000
0000000000000000
0020202020202020
0020202020202020
0000202020202020
0000202020202020
0000002020202020
0000002020202020
0000002020202020
0000000020202020
0000000020202020
0000000000202020
0000000000202020
0000000000202020
0000000000002020
0000000000002020
0000000000000020
0000000000000020
0000000000000000
0000000000000000
0020202020202020
0020202020202020
0000202020202020
0000202020202020
0000002020202020
0000002020202020
0000000020202020
0000000020202020
0000000020202020
0000000000202020
0000000000202020
0000000000002020
0000000000002020
0000000000002020
0000000000000020
0000000000000020
0000000000000000
0000000000000000
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:905: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


sed -e 's/@USAGE@/BINARY/' ${TEMPLATE}/numeric-display.cob > prog.cob

$at_traceoff
echo "binary.at:909: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo binary.at:909 >$at_check_line_file
( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:909: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "binary.at:947: ./prog"
echo binary.at:947 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "1
12
123
1234
12345
123456
1234567
12345678
123456789
1234567890
12345678901
123456789012
1234567890123
12345678901234
123456789012345
1234567890123456
12345678901234567
123456789012345678
-1
-12
-123
-1234
-12345
-123456
-1234567
-12345678
-123456789
-1234567890
-12345678901
-123456789012
-1234567890123
-12345678901234
-123456789012345
-1234567890123456
-12345678901234567
-123456789012345678
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:947: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


      $at_traceoff
      $at_times_p && times >$at_times_file
    ) 5>&1 2>&1 | eval $at_tee_pipe
    at_status=`cat $at_status_file`
    ;;

  6 ) # 6. binary.at:954: BINARY: 1--8 native
    at_setup_line='binary.at:954'
    at_desc='BINARY: 1--8 native'
    $at_quiet $ECHO_N "  6: BINARY: 1--8 native                          $ECHO_C"
    at_xfail=no
    (
      echo "6. binary.at:954: testing ..."
      $at_traceon


if test "x$COB_BIGENDIAN" = "xyes"; then
$at_traceoff
echo "binary.at:957: true"
echo binary.at:957 >$at_check_line_file
( $at_traceon; true ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:957: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

else

cat >test.conf <<'_ATEOF'

include "cobol2002.conf"
binary-size: 1--8
binary-byteorder: native
_ATEOF


cat >dump.c <<'_ATEOF'

#include <stdio.h>
int dump (unsigned char *data);
int dump (unsigned char *data)
{
  int i;
  for (i = 0; i < 8; i++)
    printf ("%02x", data[i]);
  puts ("");
  return 0;
}
_ATEOF


$at_traceoff
echo "binary.at:979: \${CC} \${SHROPT} -o dump.\${SHREXT} dump.c"
echo binary.at:979 >$at_check_line_file
( $at_traceon; ${CC} ${SHROPT} -o dump.${SHREXT} dump.c ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:979: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


sed -e 's/@USAGE@/BINARY/' ${TEMPLATE}/numeric-dump.cob > prog.cob

$at_traceoff
echo "binary.at:983: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo binary.at:983 >$at_check_line_file
( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:983: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "binary.at:1093: ./prog"
echo binary.at:1093 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "0120202020202020
0c20202020202020
7b00202020202020
d204202020202020
3930002020202020
40e2012020202020
87d6122020202020
4e61bc0020202020
15cd5b0720202020
d202964900202020
351cdcdf02202020
141a99be1c202020
cb04fb711f012020
f22fce733a0b2020
79df0d8648700020
c0ba8a3cd5620420
874b6b5d54dc2b00
4ef330a64b9bb601
ff20202020202020
f420202020202020
85ff202020202020
2efb202020202020
c7cfff2020202020
c01dfe2020202020
7929edff20202020
b29e43ff20202020
eb32a4f820202020
2efd69b6ff202020
cbe32320fd202020
ece56641e3ff2020
35fb048ee0fe2020
0ed0318cc5f42020
8720f279b78fff20
404575c32a9dfb20
79b494a2ab23d4ff
b20ccf59b46449fe
0020202020202020
0020202020202020
0000202020202020
0000202020202020
0000002020202020
0000002020202020
0000002020202020
0000000020202020
0000000020202020
0000000000202020
0000000000202020
0000000000202020
0000000000002020
0000000000002020
0000000000000020
0000000000000020
0000000000000000
0000000000000000
0020202020202020
0020202020202020
0000202020202020
0000202020202020
0000002020202020
0000002020202020
0000000020202020
0000000020202020
0000000020202020
0000000000202020
0000000000202020
0000000000002020
0000000000002020
0000000000002020
0000000000000020
0000000000000020
0000000000000000
0000000000000000
0020202020202020
0020202020202020
0000202020202020
0000202020202020
0000002020202020
0000002020202020
0000002020202020
0000000020202020
0000000020202020
0000000000202020
0000000000202020
0000000000202020
0000000000002020
0000000000002020
0000000000000020
0000000000000020
0000000000000000
0000000000000000
0020202020202020
0020202020202020
0000202020202020
0000202020202020
0000002020202020
0000002020202020
0000000020202020
0000000020202020
0000000020202020
0000000000202020
0000000000202020
0000000000002020
0000000000002020
0000000000002020
0000000000000020
0000000000000020
0000000000000000
0000000000000000
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:1093: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


sed -e 's/@USAGE@/BINARY/' ${TEMPLATE}/numeric-display.cob > prog.cob

$at_traceoff
echo "binary.at:1097: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo binary.at:1097 >$at_check_line_file
( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:1097: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "binary.at:1135: ./prog"
echo binary.at:1135 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "1
12
123
1234
12345
123456
1234567
12345678
123456789
1234567890
12345678901
123456789012
1234567890123
12345678901234
123456789012345
1234567890123456
12345678901234567
123456789012345678
-1
-12
-123
-1234
-12345
-123456
-1234567
-12345678
-123456789
-1234567890
-12345678901
-123456789012
-1234567890123
-12345678901234
-123456789012345
-1234567890123456
-12345678901234567
-123456789012345678
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:1135: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


fi

      $at_traceoff
      $at_times_p && times >$at_times_file
    ) 5>&1 2>&1 | eval $at_tee_pipe
    at_status=`cat $at_status_file`
    ;;

  7 ) # 7. binary.at:1144: BINARY: full-print
    at_setup_line='binary.at:1144'
    at_desc='BINARY: full-print'
    $at_quiet $ECHO_N "  7: BINARY: full-print                           $ECHO_C"
    at_xfail=no
    (
      echo "7. binary.at:1144: testing ..."
      $at_traceon


cat >test.conf <<'_ATEOF'

include "cobol2002.conf"
binary-size: 1--8
pretty-display: no
_ATEOF


sed -e 's/@USAGE@/BINARY/' ${TEMPLATE}/numeric-display.cob > prog.cob

$at_traceoff
echo "binary.at:1154: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo binary.at:1154 >$at_check_line_file
( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:1154: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "binary.at:1192: ./prog"
echo binary.at:1192 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "001
012
00123
01234
00012345
00123456
01234567
0012345678
0123456789
0001234567890
0012345678901
0123456789012
001234567890123
012345678901234
00123456789012345
01234567890123456
00012345678901234567
00123456789012345678
-001
-012
-00123
-01234
-00012345
-00123456
-0001234567
-0012345678
-0123456789
-0001234567890
-0012345678901
-000123456789012
-001234567890123
-012345678901234
-00123456789012345
-01234567890123456
-00012345678901234567
-00123456789012345678
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "binary.at:1192: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


      $at_traceoff
      $at_times_p && times >$at_times_file
    ) 5>&1 2>&1 | eval $at_tee_pipe
    at_status=`cat $at_status_file`
    ;;

  8 ) # 8. display.at:22: DISPLAY: Sign ASCII
    at_setup_line='display.at:22'
    at_desc='DISPLAY: Sign ASCII'
    $at_quiet $ECHO_N "  8: DISPLAY: Sign ASCII                          $ECHO_C"
    at_xfail=no
    (
      echo "8. display.at:22: testing ..."
      $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC X(5).
         02 X-9         REDEFINES X PIC 9(4).
         02 X-S9        REDEFINES X PIC S9(4).
         02 X-S9-L      REDEFINES X PIC S9(4) LEADING.
         02 X-S9-LS     REDEFINES X PIC S9(4) LEADING SEPARATE.
         02 X-S9-T      REDEFINES X PIC S9(4) TRAILING.
         02 X-S9-TS     REDEFINES X PIC S9(4) TRAILING SEPARATE.
       PROCEDURE        DIVISION.
           MOVE ZERO TO X. MOVE  1234 TO X-9.     DISPLAY X
           END-DISPLAY.
           MOVE ZERO TO X. MOVE  1234 TO X-S9.    DISPLAY X
           END-DISPLAY.
           MOVE ZERO TO X. MOVE -1234 TO X-S9.    DISPLAY X
           END-DISPLAY.
           MOVE ZERO TO X. MOVE  1234 TO X-S9-L.  DISPLAY X
           END-DISPLAY.
           MOVE ZERO TO X. MOVE -1234 TO X-S9-L.  DISPLAY X
           END-DISPLAY.
           MOVE ZERO TO X. MOVE  1234 TO X-S9-LS. DISPLAY X
           END-DISPLAY.
           MOVE ZERO TO X. MOVE -1234 TO X-S9-LS. DISPLAY X
           END-DISPLAY.
           MOVE ZERO TO X. MOVE  1234 TO X-S9-T.  DISPLAY X
           END-DISPLAY.
           MOVE ZERO TO X. MOVE -1234 TO X-S9-T.  DISPLAY X
           END-DISPLAY.
           MOVE ZERO TO X. MOVE  1234 TO X-S9-TS. DISPLAY X
           END-DISPLAY.
           MOVE ZERO TO X. MOVE -1234 TO X-S9-TS. DISPLAY X
           END-DISPLAY.
           STOP RUN.
_ATEOF


$at_traceoff
echo "display.at:63: \${COMPILE} -fsign-ascii -o prog prog.cob"
echo display.at:63 >$at_check_line_file
( $at_traceon; ${COMPILE} -fsign-ascii -o prog prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "display.at:63: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "display.at:76: ./prog"
echo display.at:76 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "12340
12340
123t0
12340
q2340
+1234
-1234
12340
123t0
1234+
1234-
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "display.at:76: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


      $at_traceoff
      $at_times_p && times >$at_times_file
    ) 5>&1 2>&1 | eval $at_tee_pipe
    at_status=`cat $at_status_file`
    ;;

  9 ) # 9. display.at:80: DISPLAY: Sign ASCII (2)
    at_setup_line='display.at:80'
    at_desc='DISPLAY: Sign ASCII (2)'
    $at_quiet $ECHO_N "  9: DISPLAY: Sign ASCII (2)                      $ECHO_C"
    at_xfail=no
    (
      echo "9. display.at:80: testing ..."
      $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC X(10).
         02 X-S99       REDEFINES X PIC S99.
         02 X-S9        REDEFINES X PIC S9 OCCURS 10.
       PROCEDURE        DIVISION.
           MOVE 0 TO X-S9(1).
           MOVE 1 TO X-S9(2).
           MOVE 2 TO X-S9(3).
           MOVE 3 TO X-S9(4).
           MOVE 4 TO X-S9(5).
           MOVE 5 TO X-S9(6).
           MOVE 6 TO X-S9(7).
           MOVE 7 TO X-S9(8).
           MOVE 8 TO X-S9(9).
           MOVE 9 TO X-S9(10).
           DISPLAY X NO ADVANCING
           END-DISPLAY.
           MOVE -10 TO X-S99. MOVE X(2:1) TO X(1:1).
           MOVE -1 TO X-S9(2).
           MOVE -2 TO X-S9(3).
           MOVE -3 TO X-S9(4).
           MOVE -4 TO X-S9(5).
           MOVE -5 TO X-S9(6).
           MOVE -6 TO X-S9(7).
           MOVE -7 TO X-S9(8).
           MOVE -8 TO X-S9(9).
           MOVE -9 TO X-S9(10).
           DISPLAY X NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


$at_traceoff
echo "display.at:119: \${COMPILE} -fsign-ascii  -o prog prog.cob"
echo display.at:119 >$at_check_line_file
( $at_traceon; ${COMPILE} -fsign-ascii  -o prog prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "display.at:119: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "display.at:120: ./prog"
echo display.at:120 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "0123456789pqrstuvwxy" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "display.at:120: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


      $at_traceoff
      $at_times_p && times >$at_times_file
    ) 5>&1 2>&1 | eval $at_tee_pipe
    at_status=`cat $at_status_file`
    ;;

  10 ) # 10. display.at:125: DISPLAY: Sign EBCDIC
    at_setup_line='display.at:125'
    at_desc='DISPLAY: Sign EBCDIC'
    $at_quiet $ECHO_N " 10: DISPLAY: Sign EBCDIC                         $ECHO_C"
    at_xfail=no
    (
      echo "10. display.at:125: testing ..."
      $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC X(10).
         02 X-S99       REDEFINES X PIC S99.
         02 X-S9        REDEFINES X PIC S9 OCCURS 10.
       PROCEDURE        DIVISION.
           MOVE 0 TO X-S9(1).
           MOVE 1 TO X-S9(2).
           MOVE 2 TO X-S9(3).
           MOVE 3 TO X-S9(4).
           MOVE 4 TO X-S9(5).
           MOVE 5 TO X-S9(6).
           MOVE 6 TO X-S9(7).
           MOVE 7 TO X-S9(8).
           MOVE 8 TO X-S9(9).
           MOVE 9 TO X-S9(10).
           DISPLAY X NO ADVANCING
           END-DISPLAY.
           MOVE -10 TO X-S99. MOVE X(2:1) TO X(1:1).
           MOVE -1 TO X-S9(2).
           MOVE -2 TO X-S9(3).
           MOVE -3 TO X-S9(4).
           MOVE -4 TO X-S9(5).
           MOVE -5 TO X-S9(6).
           MOVE -6 TO X-S9(7).
           MOVE -7 TO X-S9(8).
           MOVE -8 TO X-S9(9).
           MOVE -9 TO X-S9(10).
           DISPLAY X NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


$at_traceoff
echo "display.at:164: \${COMPILE} -fsign-ebcdic -o prog prog.cob"
echo display.at:164 >$at_check_line_file
( $at_traceon; ${COMPILE} -fsign-ebcdic -o prog prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "display.at:164: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "display.at:165: ./prog"
echo display.at:165 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "{ABCDEFGHI}JKLMNOPQR" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "display.at:165: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


      $at_traceoff
      $at_times_p && times >$at_times_file
    ) 5>&1 2>&1 | eval $at_tee_pipe
    at_status=`cat $at_status_file`
    ;;

  11 ) # 11. packed.at:25: PACKED-DECIMAL dump
    at_setup_line='packed.at:25'
    at_desc='PACKED-DECIMAL dump'
    $at_quiet $ECHO_N " 11: PACKED-DECIMAL dump                          $ECHO_C"
    at_xfail=no
    (
      echo "11. packed.at:25: testing ..."
      $at_traceon


cat >dump.c <<'_ATEOF'

#include <stdio.h>
int dump (unsigned char *data);
int dump (unsigned char *data)
{
  int i;
  for (i = 0; i < 10; i++)
    printf ("%02x", data[i]);
  puts ("");
  return 0;
}
_ATEOF


$at_traceoff
echo "packed.at:40: \${CC} \${SHROPT} -o dump.\${SHREXT} dump.c"
echo packed.at:40 >$at_check_line_file
( $at_traceon; ${CC} ${SHROPT} -o dump.${SHREXT} dump.c ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "packed.at:40: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


sed -e 's/@USAGE@/PACKED-DECIMAL/' ${TEMPLATE}/numeric-dump.cob > prog.cob

$at_traceoff
echo "packed.at:44: \${COMPILE} prog.cob"
echo packed.at:44 >$at_check_line_file
( $at_traceon; ${COMPILE} prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "packed.at:44: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "packed.at:154: ./prog"
echo packed.at:154 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "1f202020202020202020
012f2020202020202020
123f2020202020202020
01234f20202020202020
12345f20202020202020
0123456f202020202020
1234567f202020202020
012345678f2020202020
123456789f2020202020
01234567890f20202020
12345678901f20202020
0123456789012f202020
1234567890123f202020
012345678901234f2020
123456789012345f2020
01234567890123456f20
12345678901234567f20
0123456789012345678f
1d202020202020202020
012d2020202020202020
123d2020202020202020
01234d20202020202020
12345d20202020202020
0123456d202020202020
1234567d202020202020
012345678d2020202020
123456789d2020202020
01234567890d20202020
12345678901d20202020
0123456789012d202020
1234567890123d202020
012345678901234d2020
123456789012345d2020
01234567890123456d20
12345678901234567d20
0123456789012345678d
0f202020202020202020
000f2020202020202020
000f2020202020202020
00000f20202020202020
00000f20202020202020
0000000f202020202020
0000000f202020202020
000000000f2020202020
000000000f2020202020
00000000000f20202020
00000000000f20202020
0000000000000f202020
0000000000000f202020
000000000000000f2020
000000000000000f2020
00000000000000000f20
00000000000000000f20
0000000000000000000f
0c202020202020202020
000c2020202020202020
000c2020202020202020
00000c20202020202020
00000c20202020202020
0000000c202020202020
0000000c202020202020
000000000c2020202020
000000000c2020202020
00000000000c20202020
00000000000c20202020
0000000000000c202020
0000000000000c202020
000000000000000c2020
000000000000000c2020
00000000000000000c20
00000000000000000c20
0000000000000000000c
0f202020202020202020
000f2020202020202020
000f2020202020202020
00000f20202020202020
00000f20202020202020
0000000f202020202020
0000000f202020202020
000000000f2020202020
000000000f2020202020
00000000000f20202020
00000000000f20202020
0000000000000f202020
0000000000000f202020
000000000000000f2020
000000000000000f2020
00000000000000000f20
00000000000000000f20
0000000000000000000f
0c202020202020202020
000c2020202020202020
000c2020202020202020
00000c20202020202020
00000c20202020202020
0000000c202020202020
0000000c202020202020
000000000c2020202020
000000000c2020202020
00000000000c20202020
00000000000c20202020
0000000000000c202020
0000000000000c202020
000000000000000c2020
000000000000000c2020
00000000000000000c20
00000000000000000c20
0000000000000000000c
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "packed.at:154: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


      $at_traceoff
      $at_times_p && times >$at_times_file
    ) 5>&1 2>&1 | eval $at_tee_pipe
    at_status=`cat $at_status_file`
    ;;

  12 ) # 12. packed.at:160: PACKED-DECIMAL display
    at_setup_line='packed.at:160'
    at_desc='PACKED-DECIMAL display'
    $at_quiet $ECHO_N " 12: PACKED-DECIMAL display                       $ECHO_C"
    at_xfail=no
    (
      echo "12. packed.at:160: testing ..."
      $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X-99          PIC 99   USAGE PACKED-DECIMAL.
       01 X-S99         PIC S99  USAGE PACKED-DECIMAL.
       01 X-999         PIC 999  USAGE PACKED-DECIMAL.
       01 X-S999        PIC S999 USAGE PACKED-DECIMAL.
       PROCEDURE        DIVISION.
           MOVE    0 TO X-99.   DISPLAY X-99
           END-DISPLAY.
           MOVE   99 TO X-99.   DISPLAY X-99
           END-DISPLAY.
           MOVE    0 TO X-S99.  DISPLAY X-S99
           END-DISPLAY.
           MOVE   -1 TO X-S99.  DISPLAY X-S99
           END-DISPLAY.
           MOVE    0 TO X-999.  DISPLAY X-999
           END-DISPLAY.
           MOVE  123 TO X-999.  DISPLAY X-999
           END-DISPLAY.
           MOVE    0 TO X-S999. DISPLAY X-S999
           END-DISPLAY.
           MOVE -123 TO X-S999. DISPLAY X-S999
           END-DISPLAY.
           STOP RUN.
_ATEOF


$at_traceoff
echo "packed.at:191: \${COMPILE} prog.cob"
echo packed.at:191 >$at_check_line_file
( $at_traceon; ${COMPILE} prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "packed.at:191: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "packed.at:201: ./prog"
echo packed.at:201 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "00
99
+00
-01
000
123
+000
-123
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "packed.at:201: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


      $at_traceoff
      $at_times_p && times >$at_times_file
    ) 5>&1 2>&1 | eval $at_tee_pipe
    at_status=`cat $at_status_file`
    ;;

  13 ) # 13. packed.at:207: PACKED-DECIMAL move
    at_setup_line='packed.at:207'
    at_desc='PACKED-DECIMAL move'
    $at_quiet $ECHO_N " 13: PACKED-DECIMAL move                          $ECHO_C"
    at_xfail=no
    (
      echo "13. packed.at:207: testing ..."
      $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X-99          PIC 99   USAGE PACKED-DECIMAL.
       01 X-S99         PIC S99  USAGE PACKED-DECIMAL.
       01 X-999         PIC 999  USAGE PACKED-DECIMAL.
       01 X-S999        PIC S999 USAGE PACKED-DECIMAL.
       01 C-P1234       PIC 9999  VALUE 1234.
       01 C-N1234       PIC S9999 VALUE -1234.
       PROCEDURE        DIVISION.
           MOVE C-P1234 TO X-99.   DISPLAY X-99
           END-DISPLAY.
           MOVE C-P1234 TO X-S99.  DISPLAY X-S99
           END-DISPLAY.
           MOVE C-P1234 TO X-999.  DISPLAY X-999
           END-DISPLAY.
           MOVE C-P1234 TO X-S999. DISPLAY X-S999
           END-DISPLAY.
           MOVE C-N1234 TO X-99.   DISPLAY X-99
           END-DISPLAY.
           MOVE C-N1234 TO X-S99.  DISPLAY X-S99
           END-DISPLAY.
           MOVE C-N1234 TO X-999.  DISPLAY X-999
           END-DISPLAY.
           MOVE C-N1234 TO X-S999. DISPLAY X-S999
           END-DISPLAY.
           STOP RUN.
_ATEOF


$at_traceoff
echo "packed.at:240: \${COMPILE} prog.cob"
echo packed.at:240 >$at_check_line_file
( $at_traceon; ${COMPILE} prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "packed.at:240: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "packed.at:250: ./prog"
echo packed.at:250 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "34
+34
234
+234
34
-34
234
-234
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "packed.at:250: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


      $at_traceoff
      $at_times_p && times >$at_times_file
    ) 5>&1 2>&1 | eval $at_tee_pipe
    at_status=`cat $at_status_file`
    ;;

  14 ) # 14. packed.at:256: PACKED-DECIMAL arithmetic (1)
    at_setup_line='packed.at:256'
    at_desc='PACKED-DECIMAL arithmetic (1)'
    $at_quiet $ECHO_N " 14: PACKED-DECIMAL arithmetic (1)                $ECHO_C"
    at_xfail=no
    (
      echo "14. packed.at:256: testing ..."
      $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X-99          PIC 99   USAGE PACKED-DECIMAL.
       01 X-S99         PIC S99  USAGE PACKED-DECIMAL.
       01 X-999         PIC 999  USAGE PACKED-DECIMAL.
       01 X-S999        PIC S999 USAGE PACKED-DECIMAL.
       PROCEDURE        DIVISION.
           INITIALIZE X-99.   DISPLAY X-99
           END-DISPLAY.
           INITIALIZE X-S99.  DISPLAY X-S99
           END-DISPLAY.
           INITIALIZE X-999.  DISPLAY X-999
           END-DISPLAY.
           INITIALIZE X-S999. DISPLAY X-S999
           END-DISPLAY.
           STOP RUN.
_ATEOF


$at_traceoff
echo "packed.at:279: \${COMPILE} prog.cob"
echo packed.at:279 >$at_check_line_file
( $at_traceon; ${COMPILE} prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "packed.at:279: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "packed.at:285: ./prog"
echo packed.at:285 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "00
+00
000
+000
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "packed.at:285: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


      $at_traceoff
      $at_times_p && times >$at_times_file
    ) 5>&1 2>&1 | eval $at_tee_pipe
    at_status=`cat $at_status_file`
    ;;

  15 ) # 15. packed.at:291: PACKED-DECIMAL arithmetic (2)
    at_setup_line='packed.at:291'
    at_desc='PACKED-DECIMAL arithmetic (2)'
    $at_quiet $ECHO_N " 15: PACKED-DECIMAL arithmetic (2)                $ECHO_C"
    at_xfail=no
    (
      echo "15. packed.at:291: testing ..."
      $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC 99 USAGE PACKED-DECIMAL VALUE 0.
       01 Y             PIC 99 USAGE PACKED-DECIMAL VALUE 9.
       PROCEDURE        DIVISION.
           COMPUTE X = 1
           END-COMPUTE.     DISPLAY X
           END-DISPLAY.
           COMPUTE X = Y
           END-COMPUTE.     DISPLAY X
           END-DISPLAY.
           COMPUTE X = X + Y
           END-COMPUTE. DISPLAY X
           END-DISPLAY.
           STOP RUN.
_ATEOF


$at_traceoff
echo "packed.at:313: \${COMPILE} prog.cob"
echo packed.at:313 >$at_check_line_file
( $at_traceon; ${COMPILE} prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "packed.at:313: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "packed.at:318: ./prog"
echo packed.at:318 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "01
09
18
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "packed.at:318: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


      $at_traceoff
      $at_times_p && times >$at_times_file
    ) 5>&1 2>&1 | eval $at_tee_pipe
    at_status=`cat $at_status_file`
    ;;

  16 ) # 16. packed.at:324: PACKED-DECIMAL numeric test
    at_setup_line='packed.at:324'
    at_desc='PACKED-DECIMAL numeric test'
    $at_quiet $ECHO_N " 16: PACKED-DECIMAL numeric test                  $ECHO_C"
    at_xfail=no
    (
      echo "16. packed.at:324: testing ..."
      $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X-2         PIC X(2).
         02 N-2         REDEFINES X-2 PIC 99 USAGE PACKED-DECIMAL.
         02 N-S2        REDEFINES X-2 PIC S99 USAGE PACKED-DECIMAL.
       PROCEDURE        DIVISION.
           MOVE X"0000" TO X-2.
           IF N-2  IS NUMERIC
            DISPLAY "NG"
            END-DISPLAY
           ELSE
            DISPLAY "OK"
            END-DISPLAY
           END-IF.
           IF N-S2 IS NUMERIC
            DISPLAY "NG"
            END-DISPLAY
           ELSE
            DISPLAY "OK"
            END-DISPLAY
           END-IF.
           MOVE X"000c" TO X-2.
           IF N-2  IS NUMERIC
            DISPLAY "NG"
            END-DISPLAY
           ELSE
            DISPLAY "OK"
            END-DISPLAY
           END-IF.
           IF N-S2 IS NUMERIC
            DISPLAY "OK"
            END-DISPLAY
           ELSE
            DISPLAY "NG"
            END-DISPLAY
           END-IF.
           MOVE X"000d" TO X-2.
           IF N-2  IS NUMERIC
            DISPLAY "NG"
            END-DISPLAY
           ELSE
            DISPLAY "OK"
            END-DISPLAY
           END-IF.
           IF N-S2 IS NUMERIC
            DISPLAY "OK"
            END-DISPLAY
           ELSE
            DISPLAY "NG"
            END-DISPLAY
           END-IF.
           MOVE X"000f" TO X-2.
           IF N-2  IS NUMERIC
            DISPLAY "OK"
            END-DISPLAY
           ELSE
            DISPLAY "NG"
            END-DISPLAY
           END-IF.
           IF N-S2 IS NUMERIC
            DISPLAY "OK"
            END-DISPLAY
           ELSE
            DISPLAY "NG"
            END-DISPLAY
           END-IF.
           MOVE X"1234" TO X-2.
           IF N-2  IS NUMERIC
            DISPLAY "NG"
            END-DISPLAY
           ELSE
            DISPLAY "OK"
            END-DISPLAY
           END-IF.
           IF N-S2 IS NUMERIC
            DISPLAY "NG"
            END-DISPLAY
           ELSE
            DISPLAY "OK"
            END-DISPLAY
           END-IF.
           MOVE X"999f" TO X-2.
           IF N-2  IS NUMERIC
            DISPLAY "OK"
            END-DISPLAY
           ELSE
            DISPLAY "NG"
            END-DISPLAY
           END-IF.
           IF N-S2 IS NUMERIC
            DISPLAY "OK"
            END-DISPLAY
           ELSE
            DISPLAY "NG"
            END-DISPLAY
           END-IF.
           MOVE X"ffff" TO X-2.
           IF N-2  IS NUMERIC
            DISPLAY "NG"
            END-DISPLAY
           ELSE
            DISPLAY "OK"
            END-DISPLAY
           END-IF.
           IF N-S2 IS NUMERIC
            DISPLAY "NG"
            END-DISPLAY
           ELSE
            DISPLAY "OK"
            END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


$at_traceoff
echo "packed.at:444: \${COMPILE} prog.cob"
echo packed.at:444 >$at_check_line_file
( $at_traceon; ${COMPILE} prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "packed.at:444: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "packed.at:460: ./prog"
echo packed.at:460 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo >>$at_stdout; echo "OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
" | $at_diff - $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "packed.at:460: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


      $at_traceoff
      $at_times_p && times >$at_times_file
    ) 5>&1 2>&1 | eval $at_tee_pipe
    at_status=`cat $at_status_file`
    ;;

  17 ) # 17. pointer.at:22: POINTER: display
    at_setup_line='pointer.at:22'
    at_desc='POINTER: display'
    $at_quiet $ECHO_N " 17: POINTER: display                             $ECHO_C"
    at_xfail=no
    (
      echo "17. pointer.at:22: testing ..."
      $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 PTR           USAGE POINTER VALUE NULL.
       PROCEDURE        DIVISION.
           DISPLAY PTR
           END-DISPLAY.
           SET PTR UP BY 1
           DISPLAY PTR
           END-DISPLAY.
           STOP RUN.
_ATEOF


$at_traceoff
echo "pointer.at:39: \${COMPILE} -o prog prog.cob"
echo pointer.at:39 >$at_check_line_file
( $at_traceon; ${COMPILE} -o prog prog.cob ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
$at_diff $at_devnull $at_stdout || at_failed=:
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "pointer.at:39: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon

$at_traceoff
echo "pointer.at:40: ./prog"
echo pointer.at:40 >$at_check_line_file
( $at_traceon; ./prog ) >$at_stdout 2>$at_stder1
at_status=$?
grep '^ *+' $at_stder1 >&2
grep -v '^ *+' $at_stder1 >$at_stderr
at_failed=false
$at_diff $at_devnull $at_stderr || at_failed=:
echo stdout:; cat $at_stdout
case $at_status in
   77) echo 77 > $at_status_file
            exit 77;;
   0) ;;
   *) echo "pointer.at:40: exit code was $at_status, expected 0"
      at_failed=:;;
esac
if $at_failed; then

  echo 1 > $at_status_file
  exit 1
fi

$at_traceon


      $at_traceoff
      $at_times_p && times >$at_times_file
    ) 5>&1 2>&1 | eval $at_tee_pipe
    at_status=`cat $at_status_file`
    ;;


  * )
    echo "$as_me: no such test group: $at_group" >&2
    continue
    ;;
  esac

  # Be sure to come back to the suite directory, in particular
  # since below we might `rm' the group directory we are in currently.
  cd $at_suite_dir

  case $at_group in
    banner-*) ;;
    *)
      if test ! -f $at_check_line_file; then
	sed "s/^ */$as_me: warning: /" <<_ATEOF
	A failure happened in a test group before any test could be
	run. This means that test suite is improperly designed.  Please
	report this failure to <open-cobol-list@lists.sourceforge.net>.
_ATEOF
    	echo "$at_setup_line" >$at_check_line_file
      fi
      at_group_count=`expr 1 + $at_group_count`
      $at_verbose $ECHO_N "$at_group. $at_setup_line: $ECHO_C"
      echo $ECHO_N "$at_group. $at_setup_line: $ECHO_C" >> $at_group_log
      case $at_xfail:$at_status in
	yes:0)
	    at_msg="UNEXPECTED PASS"
	    at_xpass_list="$at_xpass_list $at_group"
	    at_errexit=$at_errexit_p
	    ;;
	no:0)
	    at_msg="ok"
	    at_pass_list="$at_pass_list $at_group"
	    at_errexit=false
	    ;;
	*:77)
	    at_msg="skipped (`cat $at_check_line_file`)"
	    at_skip_list="$at_skip_list $at_group"
	    at_errexit=false
	    ;;
	yes:*)
	    at_msg="expected failure (`cat $at_check_line_file`)"
	    at_xfail_list="$at_xfail_list $at_group"
	    at_errexit=false
	    ;;
	no:*)
	    at_msg="FAILED (`cat $at_check_line_file`)"
	    at_fail_list="$at_fail_list $at_group"
	    at_errexit=$at_errexit_p
	    ;;
      esac
      echo $at_msg
      at_log_msg="$at_group. $at_desc ($at_setup_line): $at_msg"
      case $at_status in
	0|77)
	  # $at_times_file is only available if the group succeeded.
	  # We're not including the group log, so the success message
	  # is written in the global log separately.  But we also
	  # write to the group log in case they're using -d.
	  if test -f $at_times_file; then
	    at_log_msg="$at_log_msg	(`sed 1d $at_times_file`)"
	    rm -f $at_times_file
          fi
	  echo "$at_log_msg" >> $at_group_log
	  echo "$at_log_msg" >&5

	  # Cleanup the group directory, unless the user wants the files.
	  $at_debug_p || rm -rf $at_group_dir
	  ;;
	*)
	  # Upon failure, include the log into the testsuite's global
	  # log.  The failure message is written in the group log.  It
	  # is later included in the global log.
	  echo "$at_log_msg" >> $at_group_log

	  # Upon failure, keep the group directory for autopsy, and
	  # create the debugging script.
	  {
	    echo "#! /bin/sh"
	    echo 'test "${ZSH_VERSION+set}" = set && alias -g '\''${1+"$@"}'\''='\''"$@"'\'''
	    echo "cd $at_dir"
	    echo 'exec ${CONFIG_SHELL-'"$SHELL"'}' "$0" \
	         '-v -d' "$at_debug_args" "$at_group" '${1+"$@"}'
	    echo 'exit 1'
	  } >$at_group_dir/run
	  chmod +x $at_group_dir/run
	  $at_errexit && break
	  ;;
      esac
      ;;
  esac
done

# Back to the top directory.
cd $at_dir

# Compute the duration of the suite.
at_stop_date=`date`
at_stop_time=`(date +%s) 2>/dev/null`
echo "$as_me: ending at: $at_stop_date" >&5
at_duration_s=`(expr $at_stop_time - $at_start_time) 2>/dev/null`
at_duration_m=`(expr $at_duration_s / 60) 2>/dev/null`
at_duration_h=`(expr $at_duration_m / 60) 2>/dev/null`
at_duration_s=`(expr $at_duration_s % 60) 2>/dev/null`
at_duration_m=`(expr $at_duration_m % 60) 2>/dev/null`
at_duration="${at_duration_h}h ${at_duration_m}m ${at_duration_s}s"
if test "$at_duration" != "h m s"; then
  echo "$as_me: test suite duration: $at_duration" >&5
fi

# Wrap up the test suite with summary statistics.
at_skip_count=`set dummy $at_skip_list; shift; echo $#`
at_fail_count=`set dummy $at_fail_list; shift; echo $#`
at_xpass_count=`set dummy $at_xpass_list; shift; echo $#`
at_xfail_count=`set dummy $at_xfail_list; shift; echo $#`

at_run_count=`expr $at_group_count - $at_skip_count`
at_unexpected_count=`expr $at_xpass_count + $at_fail_count`
at_total_fail_count=`expr $at_xfail_count + $at_fail_count`

echo
cat <<\_ASBOX
## ------------- ##
## Test results. ##
## ------------- ##
_ASBOX
echo
{
  echo
  cat <<\_ASBOX
## ------------- ##
## Test results. ##
## ------------- ##
_ASBOX
  echo
} >&5

if test $at_run_count = 1; then
  at_result="1 test"
  at_were=was
else
  at_result="$at_run_count tests"
  at_were=were
fi
if $at_errexit_p && test $at_unexpected_count != 0; then
  if test $at_xpass_count = 1; then
    at_result="$at_result $at_were run, one passed"
  else
    at_result="$at_result $at_were run, one failed"
  fi
  at_result="$at_result unexpectedly and inhibited subsequent tests."
else
  # Don't you just love exponential explosion of the number of cases?
  case $at_xpass_count:$at_fail_count:$at_xfail_count in
    # So far, so good.
    0:0:0) at_result="$at_result $at_were successful." ;;
    0:0:*) at_result="$at_result behaved as expected." ;;

    # Some unexpected failures
    0:*:0) at_result="$at_result $at_were run,
$at_fail_count failed unexpectedly." ;;

    # Some failures, both expected and unexpected
    0:*:1) at_result="$at_result $at_were run,
$at_total_fail_count failed ($at_xfail_count expected failure)." ;;
    0:*:*) at_result="$at_result $at_were run,
$at_total_fail_count failed ($at_xfail_count expected failures)." ;;

    # No unexpected failures, but some xpasses
    *:0:*) at_result="$at_result $at_were run,
$at_xpass_count passed unexpectedly." ;;

    # No expected failures, but failures and xpasses
    *:1:0) at_result="$at_result $at_were run,
$at_unexpected_count did not behave as expected ($at_fail_count unexpected failure)." ;;
    *:*:0) at_result="$at_result $at_were run,
$at_unexpected_count did not behave as expected ($at_fail_count unexpected failures)." ;;

    # All of them.
    *:*:1) at_result="$at_result $at_were run,
$at_xpass_count passed unexpectedly,
$at_total_fail_count failed ($at_xfail_count expected failure)." ;;
    *:*:*) at_result="$at_result $at_were run,
$at_xpass_count passed unexpectedly,
$at_total_fail_count failed ($at_xfail_count expected failures)." ;;
  esac

  if test $at_skip_count = 0 && test $at_run_count -gt 1; then
    at_result="All $at_result"
  fi
fi

# Now put skips in the mix.
case $at_skip_count in
  0) ;;
  1) at_result="$at_result
1 test was skipped." ;;
  *) at_result="$at_result
$at_skip_count tests were skipped." ;;
esac

if test $at_unexpected_count = 0; then
  echo "$at_result"
  echo "$at_result" >&5
else
  echo "ERROR: $at_result" >&2
  echo "ERROR: $at_result" >&5
  {
    echo
    cat <<\_ASBOX
## ------------------------ ##
## Summary of the failures. ##
## ------------------------ ##
_ASBOX

    # Summary of failed and skipped tests.
    if test $at_fail_count != 0; then
      echo "Failed tests:"
      $SHELL $0 $at_fail_list --list
      echo
    fi
    if test $at_skip_count != 0; then
      echo "Skipped tests:"
      $SHELL $0 $at_skip_list --list
      echo
    fi
    if test $at_xpass_count != 0; then
      echo "Unexpected passes:"
      $SHELL $0 $at_xpass_list --list
      echo
    fi
    if test $at_fail_count != 0; then
      cat <<\_ASBOX
## ---------------------- ##
## Detailed failed tests. ##
## ---------------------- ##
_ASBOX
      echo
      for at_group in $at_fail_list
      do
        # Normalize the test group number.
        at_group_normalized=`expr "00000$at_group" : ".*\($at_format\)"`
        # Create a fresh directory for the next test group, and enter.
        at_group_dir=$at_suite_dir/$at_group_normalized
        at_group_log=$at_group_dir/$as_me.log
        cat $at_group_log
        echo
      done
      echo
    fi
    if test -n "$at_top_srcdir"; then
      sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## $at_top_builddir/config.log ##
_ASBOX
      sed 's/^/| /' $at_top_builddir/config.log
      echo
    fi
  } >&5

  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## $as_me.log was created. ##
_ASBOX

  echo
  echo "Please send \`$as_me.log' and all information you think might help:"
  echo
  echo "   To: <open-cobol-list@lists.sourceforge.net>"
  echo "   Subject: [OpenCOBOL 1.1] $as_me:$at_fail_list${at_fail_list:+ failed${at_xpass_list:+,}}$at_xpass_list${at_xpass_list:+ passed unexpectedly}"
  echo
  if test $at_debug_p = false; then
    echo
    echo 'You may investigate any problem if you feel able to do so, in which'
    echo 'case the test suite provides a good starting point.'
    echo
  fi
    exit 1
fi

exit 0


