1#! /bin/sh 2# Generated from DDSTest.at by GNU Autoconf 2.69. 3# 4# Copyright (C) 2009-2012 Free Software Foundation, Inc. 5# 6# This test suite is free software; the Free Software Foundation gives 7# unlimited permission to copy, distribute and modify it. 8## -------------------- ## 9## M4sh Initialization. ## 10## -------------------- ## 11 12# Be more Bourne compatible 13DUALCASE=1; export DUALCASE # for MKS sh 14if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : 15 emulate sh 16 NULLCMD=: 17 # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which 18 # is contrary to our usage. Disable this feature. 19 alias -g '${1+"$@"}'='"$@"' 20 setopt NO_GLOB_SUBST 21else 22 case `(set -o) 2>/dev/null` in #( 23 *posix*) : 24 set -o posix ;; #( 25 *) : 26 ;; 27esac 28fi 29 30 31as_nl=' 32' 33export as_nl 34# Printing a long string crashes Solaris 7 /usr/bin/printf. 35as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' 36as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo 37as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo 38# Prefer a ksh shell builtin over an external printf program on Solaris, 39# but without wasting forks for bash or zsh. 40if test -z "$BASH_VERSION$ZSH_VERSION" \ 41 && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then 42 as_echo='print -r --' 43 as_echo_n='print -rn --' 44elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then 45 as_echo='printf %s\n' 46 as_echo_n='printf %s' 47else 48 if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then 49 as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' 50 as_echo_n='/usr/ucb/echo -n' 51 else 52 as_echo_body='eval expr "X$1" : "X\\(.*\\)"' 53 as_echo_n_body='eval 54 arg=$1; 55 case $arg in #( 56 *"$as_nl"*) 57 expr "X$arg" : "X\\(.*\\)$as_nl"; 58 arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; 59 esac; 60 expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" 61 ' 62 export as_echo_n_body 63 as_echo_n='sh -c $as_echo_n_body as_echo' 64 fi 65 export as_echo_body 66 as_echo='sh -c $as_echo_body as_echo' 67fi 68 69# The user is always right. 70if test "${PATH_SEPARATOR+set}" != set; then 71 PATH_SEPARATOR=: 72 (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { 73 (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || 74 PATH_SEPARATOR=';' 75 } 76fi 77 78 79# IFS 80# We need space, tab and new line, in precisely that order. Quoting is 81# there to prevent editors from complaining about space-tab. 82# (If _AS_PATH_WALK were called with IFS unset, it would disable word 83# splitting by setting IFS to empty value.) 84IFS=" "" $as_nl" 85 86# Find who we are. Look in the path if we contain no directory separator. 87as_myself= 88case $0 in #(( 89 *[\\/]* ) as_myself=$0 ;; 90 *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 91for as_dir in $PATH 92do 93 IFS=$as_save_IFS 94 test -z "$as_dir" && as_dir=. 95 test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break 96 done 97IFS=$as_save_IFS 98 99 ;; 100esac 101# We did not find ourselves, most probably we were run as `sh COMMAND' 102# in which case we are not to be found in the path. 103if test "x$as_myself" = x; then 104 as_myself=$0 105fi 106if test ! -f "$as_myself"; then 107 $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 108 exit 1 109fi 110 111# Unset variables that we do not need and which cause bugs (e.g. in 112# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" 113# suppresses any "Segmentation fault" message there. '((' could 114# trigger a bug in pdksh 5.2.14. 115for as_var in BASH_ENV ENV MAIL MAILPATH 116do eval test x\${$as_var+set} = xset \ 117 && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : 118done 119PS1='$ ' 120PS2='> ' 121PS4='+ ' 122 123# NLS nuisances. 124LC_ALL=C 125export LC_ALL 126LANGUAGE=C 127export LANGUAGE 128 129# CDPATH. 130(unset CDPATH) >/dev/null 2>&1 && unset CDPATH 131 132if test "x$CONFIG_SHELL" = x; then 133 as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : 134 emulate sh 135 NULLCMD=: 136 # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which 137 # is contrary to our usage. Disable this feature. 138 alias -g '\${1+\"\$@\"}'='\"\$@\"' 139 setopt NO_GLOB_SUBST 140else 141 case \`(set -o) 2>/dev/null\` in #( 142 *posix*) : 143 set -o posix ;; #( 144 *) : 145 ;; 146esac 147fi 148" 149 as_required="as_fn_return () { (exit \$1); } 150as_fn_success () { as_fn_return 0; } 151as_fn_failure () { as_fn_return 1; } 152as_fn_ret_success () { return 0; } 153as_fn_ret_failure () { return 1; } 154 155exitcode=0 156as_fn_success || { exitcode=1; echo as_fn_success failed.; } 157as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } 158as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } 159as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } 160if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : 161 162else 163 exitcode=1; echo positional parameters were not saved. 164fi 165test x\$exitcode = x0 || exit 1 166test -x / || exit 1" 167 as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO 168 as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO 169 eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && 170 test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 171test \$(( 1 + 1 )) = 2 || exit 1" 172 if (eval "$as_required") 2>/dev/null; then : 173 as_have_required=yes 174else 175 as_have_required=no 176fi 177 if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : 178 179else 180 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 181as_found=false 182for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH 183do 184 IFS=$as_save_IFS 185 test -z "$as_dir" && as_dir=. 186 as_found=: 187 case $as_dir in #( 188 /*) 189 for as_base in sh bash ksh sh5; do 190 # Try only shells that exist, to save several forks. 191 as_shell=$as_dir/$as_base 192 if { test -f "$as_shell" || test -f "$as_shell.exe"; } && 193 { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : 194 CONFIG_SHELL=$as_shell as_have_required=yes 195 if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : 196 break 2 197fi 198fi 199 done;; 200 esac 201 as_found=false 202done 203$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && 204 { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : 205 CONFIG_SHELL=$SHELL as_have_required=yes 206fi; } 207IFS=$as_save_IFS 208 209 210 if test "x$CONFIG_SHELL" != x; then : 211 export CONFIG_SHELL 212 # We cannot yet assume a decent shell, so we have to provide a 213# neutralization value for shells without unset; and this also 214# works around shells that cannot unset nonexistent variables. 215# Preserve -v and -x to the replacement shell. 216BASH_ENV=/dev/null 217ENV=/dev/null 218(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV 219case $- in # (((( 220 *v*x* | *x*v* ) as_opts=-vx ;; 221 *v* ) as_opts=-v ;; 222 *x* ) as_opts=-x ;; 223 * ) as_opts= ;; 224esac 225exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} 226# Admittedly, this is quite paranoid, since all the known shells bail 227# out after a failed `exec'. 228$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 229exit 255 230fi 231 232 if test x$as_have_required = xno; then : 233 $as_echo "$0: This script requires a shell more modern than all" 234 $as_echo "$0: the shells that I found on your system." 235 if test x${ZSH_VERSION+set} = xset ; then 236 $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" 237 $as_echo "$0: be upgraded to zsh 4.3.4 or later." 238 else 239 $as_echo "$0: Please tell bug-autoconf@gnu.org about your system, 240$0: including any error possibly output before this 241$0: message. Then install a modern shell, or manually run 242$0: the script under such a shell if you do have one." 243 fi 244 exit 1 245fi 246fi 247fi 248SHELL=${CONFIG_SHELL-/bin/sh} 249export SHELL 250# Unset more variables known to interfere with behavior of common tools. 251CLICOLOR_FORCE= GREP_OPTIONS= 252unset CLICOLOR_FORCE GREP_OPTIONS 253 254## --------------------- ## 255## M4sh Shell Functions. ## 256## --------------------- ## 257# as_fn_unset VAR 258# --------------- 259# Portably unset VAR. 260as_fn_unset () 261{ 262 { eval $1=; unset $1;} 263} 264as_unset=as_fn_unset 265 266# as_fn_set_status STATUS 267# ----------------------- 268# Set $? to STATUS, without forking. 269as_fn_set_status () 270{ 271 return $1 272} # as_fn_set_status 273 274# as_fn_exit STATUS 275# ----------------- 276# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. 277as_fn_exit () 278{ 279 set +e 280 as_fn_set_status $1 281 exit $1 282} # as_fn_exit 283 284# as_fn_mkdir_p 285# ------------- 286# Create "$as_dir" as a directory, including parents if necessary. 287as_fn_mkdir_p () 288{ 289 290 case $as_dir in #( 291 -*) as_dir=./$as_dir;; 292 esac 293 test -d "$as_dir" || eval $as_mkdir_p || { 294 as_dirs= 295 while :; do 296 case $as_dir in #( 297 *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( 298 *) as_qdir=$as_dir;; 299 esac 300 as_dirs="'$as_qdir' $as_dirs" 301 as_dir=`$as_dirname -- "$as_dir" || 302$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ 303 X"$as_dir" : 'X\(//\)[^/]' \| \ 304 X"$as_dir" : 'X\(//\)$' \| \ 305 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || 306$as_echo X"$as_dir" | 307 sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ 308 s//\1/ 309 q 310 } 311 /^X\(\/\/\)[^/].*/{ 312 s//\1/ 313 q 314 } 315 /^X\(\/\/\)$/{ 316 s//\1/ 317 q 318 } 319 /^X\(\/\).*/{ 320 s//\1/ 321 q 322 } 323 s/.*/./; q'` 324 test -d "$as_dir" && break 325 done 326 test -z "$as_dirs" || eval "mkdir $as_dirs" 327 } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" 328 329 330} # as_fn_mkdir_p 331 332# as_fn_executable_p FILE 333# ----------------------- 334# Test if FILE is an executable regular file. 335as_fn_executable_p () 336{ 337 test -f "$1" && test -x "$1" 338} # as_fn_executable_p 339# as_fn_append VAR VALUE 340# ---------------------- 341# Append the text in VALUE to the end of the definition contained in VAR. Take 342# advantage of any shell optimizations that allow amortized linear growth over 343# repeated appends, instead of the typical quadratic growth present in naive 344# implementations. 345if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : 346 eval 'as_fn_append () 347 { 348 eval $1+=\$2 349 }' 350else 351 as_fn_append () 352 { 353 eval $1=\$$1\$2 354 } 355fi # as_fn_append 356 357# as_fn_arith ARG... 358# ------------------ 359# Perform arithmetic evaluation on the ARGs, and store the result in the 360# global $as_val. Take advantage of shells that can avoid forks. The arguments 361# must be portable across $(()) and expr. 362if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : 363 eval 'as_fn_arith () 364 { 365 as_val=$(( $* )) 366 }' 367else 368 as_fn_arith () 369 { 370 as_val=`expr "$@" || test $? -eq 1` 371 } 372fi # as_fn_arith 373 374 375# as_fn_error STATUS ERROR [LINENO LOG_FD] 376# ---------------------------------------- 377# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are 378# provided, also output the error to LOG_FD, referencing LINENO. Then exit the 379# script with STATUS, using 1 if that was 0. 380as_fn_error () 381{ 382 as_status=$1; test $as_status -eq 0 && as_status=1 383 if test "$4"; then 384 as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack 385 $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 386 fi 387 $as_echo "$as_me: error: $2" >&2 388 as_fn_exit $as_status 389} # as_fn_error 390 391if expr a : '\(a\)' >/dev/null 2>&1 && 392 test "X`expr 00001 : '.*\(...\)'`" = X001; then 393 as_expr=expr 394else 395 as_expr=false 396fi 397 398if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then 399 as_basename=basename 400else 401 as_basename=false 402fi 403 404as_me=`$as_basename -- "$0" || 405$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ 406 X"$0" : 'X\(//\)$' \| \ 407 X"$0" : 'X\(/\)' \| . 2>/dev/null || 408$as_echo X/"$0" | 409 sed '/^.*\/\([^/][^/]*\)\/*$/{ 410 s//\1/ 411 q 412 } 413 /^X\/\(\/\/\)$/{ 414 s//\1/ 415 q 416 } 417 /^X\/\(\/\).*/{ 418 s//\1/ 419 q 420 } 421 s/.*/./; q'` 422 423if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then 424 as_dirname=dirname 425else 426 as_dirname=false 427fi 428 429# Avoid depending upon Character Ranges. 430as_cr_letters='abcdefghijklmnopqrstuvwxyz' 431as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' 432as_cr_Letters=$as_cr_letters$as_cr_LETTERS 433as_cr_digits='0123456789' 434as_cr_alnum=$as_cr_Letters$as_cr_digits 435 436 437 as_lineno_1=$LINENO as_lineno_1a=$LINENO 438 as_lineno_2=$LINENO as_lineno_2a=$LINENO 439 eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && 440 test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { 441 # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) 442 sed -n ' 443 p 444 /[$]LINENO/= 445 ' <$as_myself | 446 sed ' 447 s/[$]LINENO.*/&-/ 448 t lineno 449 b 450 :lineno 451 N 452 :loop 453 s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ 454 t loop 455 s/-\n.*// 456 ' >$as_me.lineno && 457 chmod +x "$as_me.lineno" || 458 { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } 459 460 # If we had to re-execute with $CONFIG_SHELL, we're ensured to have 461 # already done that, so ensure we don't try to do so again and fall 462 # in an infinite loop. This has already happened in practice. 463 _as_can_reexec=no; export _as_can_reexec 464 # Don't try to exec as it changes $[0], causing all sort of problems 465 # (the dirname of $[0] is not the place where we might find the 466 # original and so on. Autoconf is especially sensitive to this). 467 . "./$as_me.lineno" 468 # Exit status is that of the last command. 469 exit 470} 471 472ECHO_C= ECHO_N= ECHO_T= 473case `echo -n x` in #((((( 474-n*) 475 case `echo 'xy\c'` in 476 *c*) ECHO_T=' ';; # ECHO_T is single tab character. 477 xy) ECHO_C='\c';; 478 *) echo `echo ksh88 bug on AIX 6.1` > /dev/null 479 ECHO_T=' ';; 480 esac;; 481*) 482 ECHO_N='-n';; 483esac 484 485rm -f conf$$ conf$$.exe conf$$.file 486if test -d conf$$.dir; then 487 rm -f conf$$.dir/conf$$.file 488else 489 rm -f conf$$.dir 490 mkdir conf$$.dir 2>/dev/null 491fi 492if (echo >conf$$.file) 2>/dev/null; then 493 if ln -s conf$$.file conf$$ 2>/dev/null; then 494 as_ln_s='ln -s' 495 # ... but there are two gotchas: 496 # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. 497 # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. 498 # In both cases, we have to default to `cp -pR'. 499 ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || 500 as_ln_s='cp -pR' 501 elif ln conf$$.file conf$$ 2>/dev/null; then 502 as_ln_s=ln 503 else 504 as_ln_s='cp -pR' 505 fi 506else 507 as_ln_s='cp -pR' 508fi 509rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file 510rmdir conf$$.dir 2>/dev/null 511 512if mkdir -p . 2>/dev/null; then 513 as_mkdir_p='mkdir -p "$as_dir"' 514else 515 test -d ./-p && rmdir ./-p 516 as_mkdir_p=false 517fi 518 519as_test_x='test -x' 520as_executable_p=as_fn_executable_p 521 522# Sed expression to map a string onto a valid CPP name. 523as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" 524 525# Sed expression to map a string onto a valid variable name. 526as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" 527 528 529 530 531 532SHELL=${CONFIG_SHELL-/bin/sh} 533 534# How were we run? 535at_cli_args="$@" 536 537 538# Not all shells have the 'times' builtin; the subshell is needed to make 539# sure we discard the 'times: not found' message from the shell. 540at_times_p=false 541(times) >/dev/null 2>&1 && at_times_p=: 542 543# CLI Arguments to pass to the debugging scripts. 544at_debug_args= 545# -e sets to true 546at_errexit_p=false 547# Shall we be verbose? ':' means no, empty means yes. 548at_verbose=: 549at_quiet= 550# Running several jobs in parallel, 0 means as many as test groups. 551at_jobs=1 552at_traceon=: 553at_trace_echo=: 554at_check_filter_trace=: 555 556# Shall we keep the debug scripts? Must be `:' when the suite is 557# run by a debug script, so that the script doesn't remove itself. 558at_debug_p=false 559# Display help message? 560at_help_p=false 561# Display the version message? 562at_version_p=false 563# List test groups? 564at_list_p=false 565# --clean 566at_clean=false 567# Test groups to run 568at_groups= 569# Whether to rerun failed tests. 570at_recheck= 571# Whether a write failure occurred 572at_write_fail=0 573 574# The directory we run the suite in. Default to . if no -C option. 575at_dir=`pwd` 576# An absolute reference to this testsuite script. 577case $as_myself in 578 [\\/]* | ?:[\\/]* ) at_myself=$as_myself ;; 579 * ) at_myself=$at_dir/$as_myself ;; 580esac 581# Whether -C is in effect. 582at_change_dir=false 583 584# Whether to enable colored test results. 585at_color=no 586# List of the tested programs. 587at_tested='' 588# As many question marks as there are digits in the last test group number. 589# Used to normalize the test group numbers so that `ls' lists them in 590# numerical order. 591at_format='??' 592# Description of all the test groups. 593at_help_all="1;DDSTest.at:48;DDS \$abs_srcdir/dds-testsuite/3B42.980909.5.hacked.HDF.das.dds;dds; 5942;DDSTest.at:49;DDS \$abs_srcdir/dds-testsuite/3B42.980909.5.HDF.das.dds;dds; 5953;DDSTest.at:50;DDS \$abs_srcdir/dds-testsuite/3B42.980909.5.HDF.dds;dds; 5964;DDSTest.at:51;DDS \$abs_srcdir/dds-testsuite/AsciiOutputTest1.dds;dds; 5975;DDSTest.at:52;DDS \$abs_srcdir/dds-testsuite/fnoc1.nc.das.dds;dds; 5986;DDSTest.at:53;DDS \$abs_srcdir/dds-testsuite/fnoc1.nc.dds;dds; 5997;DDSTest.at:54;DDS \$abs_srcdir/dds-testsuite/S2000415.HDF.das.dds;dds; 6008;DDSTest.at:55;DDS \$abs_srcdir/dds-testsuite/S2000415.HDF.dds;dds; 6019;DDSTest.at:56;DDS \$abs_srcdir/dds-testsuite/test.1.dds;dds; 60210;DDSTest.at:57;DDS \$abs_srcdir/dds-testsuite/test.10.dds;dds; 60311;DDSTest.at:58;DDS \$abs_srcdir/dds-testsuite/test.11.dds;dds; 60412;DDSTest.at:59;DDS \$abs_srcdir/dds-testsuite/test.12.dds;dds; 60513;DDSTest.at:60;DDS \$abs_srcdir/dds-testsuite/test.13.dds;dds; 60614;DDSTest.at:61;DDS \$abs_srcdir/dds-testsuite/test.14.dds;dds; 60715;DDSTest.at:62;DDS \$abs_srcdir/dds-testsuite/test.15.dds;dds; 60816;DDSTest.at:63;DDS \$abs_srcdir/dds-testsuite/test.16.dds;dds; 60917;DDSTest.at:64;DDS \$abs_srcdir/dds-testsuite/test.17.dds;dds; 61018;DDSTest.at:65;DDS \$abs_srcdir/dds-testsuite/test.18.dds;dds; 61119;DDSTest.at:66;DDS \$abs_srcdir/dds-testsuite/test.19.dds;dds; 61220;DDSTest.at:67;DDS \$abs_srcdir/dds-testsuite/test.19b.das.dds;dds; 61321;DDSTest.at:68;DDS \$abs_srcdir/dds-testsuite/test.19b.dds;dds; 61422;DDSTest.at:69;DDS \$abs_srcdir/dds-testsuite/test.2.dds;dds; 61523;DDSTest.at:70;DDS \$abs_srcdir/dds-testsuite/test.20.dds;dds; 61624;DDSTest.at:71;DDS \$abs_srcdir/dds-testsuite/test.3.dds;dds; 61725;DDSTest.at:72;DDS \$abs_srcdir/dds-testsuite/test.4.dds;dds; 61826;DDSTest.at:73;DDS \$abs_srcdir/dds-testsuite/test.6.dds;dds; 61927;DDSTest.at:74;DDS \$abs_srcdir/dds-testsuite/test.7.dds;dds; 62028;DDSTest.at:75;DDS \$abs_srcdir/dds-testsuite/test.8.dds;dds; 62129;DDSTest.at:76;DDS \$abs_srcdir/dds-testsuite/test.9.dds;dds; 62230;DDSTest.at:80;DDS \$abs_srcdir/dds-testsuite/test.21.dds;dds; 62331;DDSTest.at:81;DDS \$abs_srcdir/dds-testsuite/test.22.dds;dds; 62432;DDSTest.at:82;DDS \$abs_srcdir/dds-testsuite/test.23.dds;dds; 62533;DDSTest.at:83;DDS \$abs_srcdir/dds-testsuite/test.24.dds;dds; 62634;DDSTest.at:86;DDS \$abs_srcdir/dds-testsuite/test.25.dds;dds; 62735;DDSTest.at:87;DDS \$abs_srcdir/dds-testsuite/test.26.dds;dds; 628" 629# List of the all the test groups. 630at_groups_all=`$as_echo "$at_help_all" | sed 's/;.*//'` 631 632# at_fn_validate_ranges NAME... 633# ----------------------------- 634# Validate and normalize the test group number contained in each variable 635# NAME. Leading zeroes are treated as decimal. 636at_fn_validate_ranges () 637{ 638 for at_grp 639 do 640 eval at_value=\$$at_grp 641 if test $at_value -lt 1 || test $at_value -gt 35; then 642 $as_echo "invalid test group: $at_value" >&2 643 exit 1 644 fi 645 case $at_value in 646 0*) # We want to treat leading 0 as decimal, like expr and test, but 647 # AS_VAR_ARITH treats it as octal if it uses $(( )). 648 # With XSI shells, ${at_value#${at_value%%[1-9]*}} avoids the 649 # expr fork, but it is not worth the effort to determine if the 650 # shell supports XSI when the user can just avoid leading 0. 651 eval $at_grp='`expr $at_value + 0`' ;; 652 esac 653 done 654} 655 656## 657## Set up package specific options. 658## 659 660at_arg_given_baselines=false 661 662 663at_prev= 664for at_option 665do 666 # If the previous option needs an argument, assign it. 667 if test -n "$at_prev"; then 668 at_option=$at_prev=$at_option 669 at_prev= 670 fi 671 672 case $at_option in 673 *=?*) at_optarg=`expr "X$at_option" : '[^=]*=\(.*\)'` ;; 674 *) at_optarg= ;; 675 esac 676 677 # Accept the important Cygnus configure options, so we can diagnose typos. 678 679 case $at_option in 680 --help | -h ) 681 at_help_p=: 682 ;; 683 684 --list | -l ) 685 at_list_p=: 686 ;; 687 688 --version | -V ) 689 at_version_p=: 690 ;; 691 692 --clean | -c ) 693 at_clean=: 694 ;; 695 696 --color ) 697 at_color=always 698 ;; 699 --color=* ) 700 case $at_optarg in 701 no | never | none) at_color=never ;; 702 auto | tty | if-tty) at_color=auto ;; 703 always | yes | force) at_color=always ;; 704 *) at_optname=`echo " $at_option" | sed 's/^ //; s/=.*//'` 705 as_fn_error $? "unrecognized argument to $at_optname: $at_optarg" ;; 706 esac 707 ;; 708 709 --debug | -d ) 710 at_debug_p=: 711 ;; 712 713 --errexit | -e ) 714 at_debug_p=: 715 at_errexit_p=: 716 ;; 717 718 --verbose | -v ) 719 at_verbose=; at_quiet=: 720 ;; 721 722 --trace | -x ) 723 at_traceon='set -x' 724 at_trace_echo=echo 725 at_check_filter_trace=at_fn_filter_trace 726 ;; 727 728 [0-9] | [0-9][0-9] | [0-9][0-9][0-9] | [0-9][0-9][0-9][0-9]) 729 at_fn_validate_ranges at_option 730 as_fn_append at_groups "$at_option$as_nl" 731 ;; 732 733 # Ranges 734 [0-9]- | [0-9][0-9]- | [0-9][0-9][0-9]- | [0-9][0-9][0-9][0-9]-) 735 at_range_start=`echo $at_option |tr -d X-` 736 at_fn_validate_ranges at_range_start 737 at_range=`$as_echo "$at_groups_all" | \ 738 sed -ne '/^'$at_range_start'$/,$p'` 739 as_fn_append at_groups "$at_range$as_nl" 740 ;; 741 742 -[0-9] | -[0-9][0-9] | -[0-9][0-9][0-9] | -[0-9][0-9][0-9][0-9]) 743 at_range_end=`echo $at_option |tr -d X-` 744 at_fn_validate_ranges at_range_end 745 at_range=`$as_echo "$at_groups_all" | \ 746 sed -ne '1,/^'$at_range_end'$/p'` 747 as_fn_append at_groups "$at_range$as_nl" 748 ;; 749 750 [0-9]-[0-9] | [0-9]-[0-9][0-9] | [0-9]-[0-9][0-9][0-9] | \ 751 [0-9]-[0-9][0-9][0-9][0-9] | [0-9][0-9]-[0-9][0-9] | \ 752 [0-9][0-9]-[0-9][0-9][0-9] | [0-9][0-9]-[0-9][0-9][0-9][0-9] | \ 753 [0-9][0-9][0-9]-[0-9][0-9][0-9] | \ 754 [0-9][0-9][0-9]-[0-9][0-9][0-9][0-9] | \ 755 [0-9][0-9][0-9][0-9]-[0-9][0-9][0-9][0-9] ) 756 at_range_start=`expr $at_option : '\(.*\)-'` 757 at_range_end=`expr $at_option : '.*-\(.*\)'` 758 if test $at_range_start -gt $at_range_end; then 759 at_tmp=$at_range_end 760 at_range_end=$at_range_start 761 at_range_start=$at_tmp 762 fi 763 at_fn_validate_ranges at_range_start at_range_end 764 at_range=`$as_echo "$at_groups_all" | \ 765 sed -ne '/^'$at_range_start'$/,/^'$at_range_end'$/p'` 766 as_fn_append at_groups "$at_range$as_nl" 767 ;; 768 769 # Directory selection. 770 --directory | -C ) 771 at_prev=--directory 772 ;; 773 --directory=* ) 774 at_change_dir=: 775 at_dir=$at_optarg 776 if test x- = "x$at_dir" ; then 777 at_dir=./- 778 fi 779 ;; 780 781 # Parallel execution. 782 --jobs | -j ) 783 at_jobs=0 784 ;; 785 --jobs=* | -j[0-9]* ) 786 if test -n "$at_optarg"; then 787 at_jobs=$at_optarg 788 else 789 at_jobs=`expr X$at_option : 'X-j\(.*\)'` 790 fi 791 case $at_jobs in *[!0-9]*) 792 at_optname=`echo " $at_option" | sed 's/^ //; s/[0-9=].*//'` 793 as_fn_error $? "non-numeric argument to $at_optname: $at_jobs" ;; 794 esac 795 ;; 796 797 # Keywords. 798 --keywords | -k ) 799 at_prev=--keywords 800 ;; 801 --keywords=* ) 802 at_groups_selected=$at_help_all 803 at_save_IFS=$IFS 804 IFS=, 805 set X $at_optarg 806 shift 807 IFS=$at_save_IFS 808 for at_keyword 809 do 810 at_invert= 811 case $at_keyword in 812 '!'*) 813 at_invert="-v" 814 at_keyword=`expr "X$at_keyword" : 'X!\(.*\)'` 815 ;; 816 esac 817 # It is on purpose that we match the test group titles too. 818 at_groups_selected=`$as_echo "$at_groups_selected" | 819 grep -i $at_invert "^[1-9][^;]*;.*[; ]$at_keyword[ ;]"` 820 done 821 # Smash the keywords. 822 at_groups_selected=`$as_echo "$at_groups_selected" | sed 's/;.*//'` 823 as_fn_append at_groups "$at_groups_selected$as_nl" 824 ;; 825 --recheck) 826 at_recheck=: 827 ;; 828 --baselines ) 829 at_prev=--baselines 830 ;; 831 --baselines=* ) 832 at_arg_baselines=$at_optarg 833 at_arg_given_baselines=: 834 echo "baselines set to $at_arg_baselines"; 835 baselines=$at_arg_baselines 836 ;; 837 838 839 *=*) 840 at_envvar=`expr "x$at_option" : 'x\([^=]*\)='` 841 # Reject names that are not valid shell variable names. 842 case $at_envvar in 843 '' | [0-9]* | *[!_$as_cr_alnum]* ) 844 as_fn_error $? "invalid variable name: \`$at_envvar'" ;; 845 esac 846 at_value=`$as_echo "$at_optarg" | sed "s/'/'\\\\\\\\''/g"` 847 # Export now, but save eval for later and for debug scripts. 848 export $at_envvar 849 as_fn_append at_debug_args " $at_envvar='$at_value'" 850 ;; 851 852 *) $as_echo "$as_me: invalid option: $at_option" >&2 853 $as_echo "Try \`$0 --help' for more information." >&2 854 exit 1 855 ;; 856 esac 857done 858 859# Verify our last option didn't require an argument 860if test -n "$at_prev"; then : 861 as_fn_error $? "\`$at_prev' requires an argument" 862fi 863 864# The file containing the suite. 865at_suite_log=$at_dir/$as_me.log 866 867# Selected test groups. 868if test -z "$at_groups$at_recheck"; then 869 at_groups=$at_groups_all 870else 871 if test -n "$at_recheck" && test -r "$at_suite_log"; then 872 at_oldfails=`sed -n ' 873 /^Failed tests:$/,/^Skipped tests:$/{ 874 s/^[ ]*\([1-9][0-9]*\):.*/\1/p 875 } 876 /^Unexpected passes:$/,/^## Detailed failed tests/{ 877 s/^[ ]*\([1-9][0-9]*\):.*/\1/p 878 } 879 /^## Detailed failed tests/q 880 ' "$at_suite_log"` 881 as_fn_append at_groups "$at_oldfails$as_nl" 882 fi 883 # Sort the tests, removing duplicates. 884 at_groups=`$as_echo "$at_groups" | sort -nu | sed '/^$/d'` 885fi 886 887if test x"$at_color" = xalways \ 888 || { test x"$at_color" = xauto && test -t 1; }; then 889 at_red=`printf '\033[0;31m'` 890 at_grn=`printf '\033[0;32m'` 891 at_lgn=`printf '\033[1;32m'` 892 at_blu=`printf '\033[1;34m'` 893 at_std=`printf '\033[m'` 894else 895 at_red= at_grn= at_lgn= at_blu= at_std= 896fi 897 898## 899## Process package specific options when _not_ supplied. 900## 901 902if $at_arg_given_baselines; then : 903 904else 905 baselines= 906fi 907 908# Help message. 909if $at_help_p; then 910 cat <<_ATEOF || at_write_fail=1 911Usage: $0 [OPTION]... [VARIABLE=VALUE]... [TESTS] 912 913Run all the tests, or the selected TESTS, given by numeric ranges, and 914save a detailed log file. Upon failure, create debugging scripts. 915 916Do not change environment variables directly. Instead, set them via 917command line arguments. Set \`AUTOTEST_PATH' to select the executables 918to exercise. Each relative directory is expanded as build and source 919directories relative to the top level of this distribution. 920E.g., from within the build directory /tmp/foo-1.0, invoking this: 921 922 $ $0 AUTOTEST_PATH=bin 923 924is equivalent to the following, assuming the source directory is /src/foo-1.0: 925 926 PATH=/tmp/foo-1.0/bin:/src/foo-1.0/bin:\$PATH $0 927_ATEOF 928cat <<_ATEOF || at_write_fail=1 929 930Operation modes: 931 -h, --help print the help message, then exit 932 -V, --version print version number, then exit 933 -c, --clean remove all the files this test suite might create and exit 934 -l, --list describes all the tests, or the selected TESTS 935_ATEOF 936cat <<_ATEOF || at_write_fail=1 937 938Execution tuning: 939 -C, --directory=DIR 940 change to directory DIR before starting 941 --color[=never|auto|always] 942 enable colored test results on terminal, or always 943 -j, --jobs[=N] 944 Allow N jobs at once; infinite jobs with no arg (default 1) 945 -k, --keywords=KEYWORDS 946 select the tests matching all the comma-separated KEYWORDS 947 multiple \`-k' accumulate; prefixed \`!' negates a KEYWORD 948 --recheck select all tests that failed or passed unexpectedly last time 949 -e, --errexit abort as soon as a test fails; implies --debug 950 -v, --verbose force more detailed output 951 default for debugging scripts 952 -d, --debug inhibit clean up and top-level logging 953 default for debugging scripts 954 -x, --trace enable tests shell tracing 955_ATEOF 956cat <<_ATEOF || at_write_fail=1 957 958Other options: 959_ATEOF 960 961cat <<_ATEOF || at_write_fail=1 962--baselines=yes|no Build the baseline file for parser test 'arg' 963_ATEOF 964cat <<_ATEOF || at_write_fail=1 965 966Report bugs to <opendap-tech@opendap.org>. 967_ATEOF 968 exit $at_write_fail 969fi 970 971# List of tests. 972if $at_list_p; then 973 cat <<_ATEOF || at_write_fail=1 974libdap 3.20.8 test suite: dds-test test groups: 975 976 NUM: FILE-NAME:LINE TEST-GROUP-NAME 977 KEYWORDS 978 979_ATEOF 980 # Pass an empty line as separator between selected groups and help. 981 $as_echo "$at_groups$as_nl$as_nl$at_help_all" | 982 awk 'NF == 1 && FS != ";" { 983 selected[$ 1] = 1 984 next 985 } 986 /^$/ { FS = ";" } 987 NF > 0 { 988 if (selected[$ 1]) { 989 printf " %3d: %-18s %s\n", $ 1, $ 2, $ 3 990 if ($ 4) { 991 lmax = 79 992 indent = " " 993 line = indent 994 len = length (line) 995 n = split ($ 4, a, " ") 996 for (i = 1; i <= n; i++) { 997 l = length (a[i]) + 1 998 if (i > 1 && len + l > lmax) { 999 print line 1000 line = indent " " a[i] 1001 len = length (line) 1002 } else { 1003 line = line " " a[i] 1004 len += l 1005 } 1006 } 1007 if (n) 1008 print line 1009 } 1010 } 1011 }' || at_write_fail=1 1012 exit $at_write_fail 1013fi 1014if $at_version_p; then 1015 $as_echo "$as_me (libdap 3.20.8)" && 1016 cat <<\_ATEOF || at_write_fail=1 1017 1018Copyright (C) 2012 Free Software Foundation, Inc. 1019This test suite is free software; the Free Software Foundation gives 1020unlimited permission to copy, distribute and modify it. 1021_ATEOF 1022 exit $at_write_fail 1023fi 1024 1025# Should we print banners? Yes if more than one test is run. 1026case $at_groups in #( 1027 *$as_nl* ) 1028 at_print_banners=: ;; #( 1029 * ) at_print_banners=false ;; 1030esac 1031# Text for banner N, set to a single space once printed. 1032 1033# Take any -C into account. 1034if $at_change_dir ; then 1035 test x != "x$at_dir" && cd "$at_dir" \ 1036 || as_fn_error $? "unable to change directory" 1037 at_dir=`pwd` 1038fi 1039 1040# Load the config files for any default variable assignments. 1041for at_file in atconfig atlocal 1042do 1043 test -r $at_file || continue 1044 . ./$at_file || as_fn_error $? "invalid content: $at_file" 1045done 1046 1047# Autoconf <=2.59b set at_top_builddir instead of at_top_build_prefix: 1048: "${at_top_build_prefix=$at_top_builddir}" 1049 1050# Perform any assignments requested during argument parsing. 1051eval "$at_debug_args" 1052 1053# atconfig delivers names relative to the directory the test suite is 1054# in, but the groups themselves are run in testsuite-dir/group-dir. 1055if test -n "$at_top_srcdir"; then 1056 builddir=../.. 1057 for at_dir_var in srcdir top_srcdir top_build_prefix 1058 do 1059 eval at_val=\$at_$at_dir_var 1060 case $at_val in 1061 [\\/$]* | ?:[\\/]* ) at_prefix= ;; 1062 *) at_prefix=../../ ;; 1063 esac 1064 eval "$at_dir_var=\$at_prefix\$at_val" 1065 done 1066fi 1067 1068## -------------------- ## 1069## Directory structure. ## 1070## -------------------- ## 1071 1072# This is the set of directories and files used by this script 1073# (non-literals are capitalized): 1074# 1075# TESTSUITE - the testsuite 1076# TESTSUITE.log - summarizes the complete testsuite run 1077# TESTSUITE.dir/ - created during a run, remains after -d or failed test 1078# + at-groups/ - during a run: status of all groups in run 1079# | + NNN/ - during a run: meta-data about test group NNN 1080# | | + check-line - location (source file and line) of current AT_CHECK 1081# | | + status - exit status of current AT_CHECK 1082# | | + stdout - stdout of current AT_CHECK 1083# | | + stder1 - stderr, including trace 1084# | | + stderr - stderr, with trace filtered out 1085# | | + test-source - portion of testsuite that defines group 1086# | | + times - timestamps for computing duration 1087# | | + pass - created if group passed 1088# | | + xpass - created if group xpassed 1089# | | + fail - created if group failed 1090# | | + xfail - created if group xfailed 1091# | | + skip - created if group skipped 1092# + at-stop - during a run: end the run if this file exists 1093# + at-source-lines - during a run: cache of TESTSUITE line numbers for extraction 1094# + 0..NNN/ - created for each group NNN, remains after -d or failed test 1095# | + TESTSUITE.log - summarizes the group results 1096# | + ... - files created during the group 1097 1098# The directory the whole suite works in. 1099# Should be absolute to let the user `cd' at will. 1100at_suite_dir=$at_dir/$as_me.dir 1101# The file containing the suite ($at_dir might have changed since earlier). 1102at_suite_log=$at_dir/$as_me.log 1103# The directory containing helper files per test group. 1104at_helper_dir=$at_suite_dir/at-groups 1105# Stop file: if it exists, do not start new jobs. 1106at_stop_file=$at_suite_dir/at-stop 1107# The fifo used for the job dispatcher. 1108at_job_fifo=$at_suite_dir/at-job-fifo 1109 1110if $at_clean; then 1111 test -d "$at_suite_dir" && 1112 find "$at_suite_dir" -type d ! -perm -700 -exec chmod u+rwx \{\} \; 1113 rm -f -r "$at_suite_dir" "$at_suite_log" 1114 exit $? 1115fi 1116 1117# Don't take risks: use only absolute directories in PATH. 1118# 1119# For stand-alone test suites (ie. atconfig was not found), 1120# AUTOTEST_PATH is relative to `.'. 1121# 1122# For embedded test suites, AUTOTEST_PATH is relative to the top level 1123# of the package. Then expand it into build/src parts, since users 1124# may create executables in both places. 1125AUTOTEST_PATH=`$as_echo "$AUTOTEST_PATH" | sed "s|:|$PATH_SEPARATOR|g"` 1126at_path= 1127as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 1128for as_dir in $AUTOTEST_PATH $PATH 1129do 1130 IFS=$as_save_IFS 1131 test -z "$as_dir" && as_dir=. 1132 test -n "$at_path" && as_fn_append at_path $PATH_SEPARATOR 1133case $as_dir in 1134 [\\/]* | ?:[\\/]* ) 1135 as_fn_append at_path "$as_dir" 1136 ;; 1137 * ) 1138 if test -z "$at_top_build_prefix"; then 1139 # Stand-alone test suite. 1140 as_fn_append at_path "$as_dir" 1141 else 1142 # Embedded test suite. 1143 as_fn_append at_path "$at_top_build_prefix$as_dir$PATH_SEPARATOR" 1144 as_fn_append at_path "$at_top_srcdir/$as_dir" 1145 fi 1146 ;; 1147esac 1148 done 1149IFS=$as_save_IFS 1150 1151 1152# Now build and simplify PATH. 1153# 1154# There might be directories that don't exist, but don't redirect 1155# builtins' (eg., cd) stderr directly: Ultrix's sh hates that. 1156at_new_path= 1157as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 1158for as_dir in $at_path 1159do 1160 IFS=$as_save_IFS 1161 test -z "$as_dir" && as_dir=. 1162 test -d "$as_dir" || continue 1163case $as_dir in 1164 [\\/]* | ?:[\\/]* ) ;; 1165 * ) as_dir=`(cd "$as_dir" && pwd) 2>/dev/null` ;; 1166esac 1167case $PATH_SEPARATOR$at_new_path$PATH_SEPARATOR in 1168 *$PATH_SEPARATOR$as_dir$PATH_SEPARATOR*) ;; 1169 $PATH_SEPARATOR$PATH_SEPARATOR) at_new_path=$as_dir ;; 1170 *) as_fn_append at_new_path "$PATH_SEPARATOR$as_dir" ;; 1171esac 1172 done 1173IFS=$as_save_IFS 1174 1175PATH=$at_new_path 1176export PATH 1177 1178# Setting up the FDs. 1179 1180 1181 1182# 5 is the log file. Not to be overwritten if `-d'. 1183if $at_debug_p; then 1184 at_suite_log=/dev/null 1185else 1186 : >"$at_suite_log" 1187fi 1188exec 5>>"$at_suite_log" 1189 1190# Banners and logs. 1191$as_echo "## ----------------------------------- ## 1192## libdap 3.20.8 test suite: dds-test. ## 1193## ----------------------------------- ##" 1194{ 1195 $as_echo "## ----------------------------------- ## 1196## libdap 3.20.8 test suite: dds-test. ## 1197## ----------------------------------- ##" 1198 echo 1199 1200 $as_echo "$as_me: command line was:" 1201 $as_echo " \$ $0 $at_cli_args" 1202 echo 1203 1204 # If ChangeLog exists, list a few lines in case it might help determining 1205 # the exact version. 1206 if test -n "$at_top_srcdir" && test -f "$at_top_srcdir/ChangeLog"; then 1207 $as_echo "## ---------- ## 1208## ChangeLog. ## 1209## ---------- ##" 1210 echo 1211 sed 's/^/| /;10q' "$at_top_srcdir/ChangeLog" 1212 echo 1213 fi 1214 1215 { 1216cat <<_ASUNAME 1217## --------- ## 1218## Platform. ## 1219## --------- ## 1220 1221hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` 1222uname -m = `(uname -m) 2>/dev/null || echo unknown` 1223uname -r = `(uname -r) 2>/dev/null || echo unknown` 1224uname -s = `(uname -s) 2>/dev/null || echo unknown` 1225uname -v = `(uname -v) 2>/dev/null || echo unknown` 1226 1227/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` 1228/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` 1229 1230/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` 1231/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` 1232/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` 1233/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` 1234/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` 1235/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` 1236/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` 1237 1238_ASUNAME 1239 1240as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 1241for as_dir in $PATH 1242do 1243 IFS=$as_save_IFS 1244 test -z "$as_dir" && as_dir=. 1245 $as_echo "PATH: $as_dir" 1246 done 1247IFS=$as_save_IFS 1248 1249} 1250 echo 1251 1252 # Contents of the config files. 1253 for at_file in atconfig atlocal 1254 do 1255 test -r $at_file || continue 1256 $as_echo "$as_me: $at_file:" 1257 sed 's/^/| /' $at_file 1258 echo 1259 done 1260} >&5 1261 1262 1263## ------------------------- ## 1264## Autotest shell functions. ## 1265## ------------------------- ## 1266 1267# at_fn_banner NUMBER 1268# ------------------- 1269# Output banner NUMBER, provided the testsuite is running multiple groups and 1270# this particular banner has not yet been printed. 1271at_fn_banner () 1272{ 1273 $at_print_banners || return 0 1274 eval at_banner_text=\$at_banner_text_$1 1275 test "x$at_banner_text" = "x " && return 0 1276 eval "at_banner_text_$1=\" \"" 1277 if test -z "$at_banner_text"; then 1278 $at_first || echo 1279 else 1280 $as_echo "$as_nl$at_banner_text$as_nl" 1281 fi 1282} # at_fn_banner 1283 1284# at_fn_check_prepare_notrace REASON LINE 1285# --------------------------------------- 1286# Perform AT_CHECK preparations for the command at LINE for an untraceable 1287# command; REASON is the reason for disabling tracing. 1288at_fn_check_prepare_notrace () 1289{ 1290 $at_trace_echo "Not enabling shell tracing (command contains $1)" 1291 $as_echo "$2" >"$at_check_line_file" 1292 at_check_trace=: at_check_filter=: 1293 : >"$at_stdout"; : >"$at_stderr" 1294} 1295 1296# at_fn_check_prepare_trace LINE 1297# ------------------------------ 1298# Perform AT_CHECK preparations for the command at LINE for a traceable 1299# command. 1300at_fn_check_prepare_trace () 1301{ 1302 $as_echo "$1" >"$at_check_line_file" 1303 at_check_trace=$at_traceon at_check_filter=$at_check_filter_trace 1304 : >"$at_stdout"; : >"$at_stderr" 1305} 1306 1307# at_fn_check_prepare_dynamic COMMAND LINE 1308# ---------------------------------------- 1309# Decide if COMMAND at LINE is traceable at runtime, and call the appropriate 1310# preparation function. 1311at_fn_check_prepare_dynamic () 1312{ 1313 case $1 in 1314 *$as_nl*) 1315 at_fn_check_prepare_notrace 'an embedded newline' "$2" ;; 1316 *) 1317 at_fn_check_prepare_trace "$2" ;; 1318 esac 1319} 1320 1321# at_fn_filter_trace 1322# ------------------ 1323# Remove the lines in the file "$at_stderr" generated by "set -x" and print 1324# them to stderr. 1325at_fn_filter_trace () 1326{ 1327 mv "$at_stderr" "$at_stder1" 1328 grep '^ *+' "$at_stder1" >&2 1329 grep -v '^ *+' "$at_stder1" >"$at_stderr" 1330} 1331 1332# at_fn_log_failure FILE-LIST 1333# --------------------------- 1334# Copy the files in the list on stdout with a "> " prefix, and exit the shell 1335# with a failure exit code. 1336at_fn_log_failure () 1337{ 1338 for file 1339 do $as_echo "$file:"; sed 's/^/> /' "$file"; done 1340 echo 1 > "$at_status_file" 1341 exit 1 1342} 1343 1344# at_fn_check_skip EXIT-CODE LINE 1345# ------------------------------- 1346# Check whether EXIT-CODE is a special exit code (77 or 99), and if so exit 1347# the test group subshell with that same exit code. Use LINE in any report 1348# about test failure. 1349at_fn_check_skip () 1350{ 1351 case $1 in 1352 99) echo 99 > "$at_status_file"; at_failed=: 1353 $as_echo "$2: hard failure"; exit 99;; 1354 77) echo 77 > "$at_status_file"; exit 77;; 1355 esac 1356} 1357 1358# at_fn_check_status EXPECTED EXIT-CODE LINE 1359# ------------------------------------------ 1360# Check whether EXIT-CODE is the EXPECTED exit code, and if so do nothing. 1361# Otherwise, if it is 77 or 99, exit the test group subshell with that same 1362# exit code; if it is anything else print an error message referring to LINE, 1363# and fail the test. 1364at_fn_check_status () 1365{ 1366 case $2 in 1367 $1 ) ;; 1368 77) echo 77 > "$at_status_file"; exit 77;; 1369 99) echo 99 > "$at_status_file"; at_failed=: 1370 $as_echo "$3: hard failure"; exit 99;; 1371 *) $as_echo "$3: exit code was $2, expected $1" 1372 at_failed=:;; 1373 esac 1374} 1375 1376# at_fn_diff_devnull FILE 1377# ----------------------- 1378# Emit a diff between /dev/null and FILE. Uses "test -s" to avoid useless diff 1379# invocations. 1380at_fn_diff_devnull () 1381{ 1382 test -s "$1" || return 0 1383 $at_diff "$at_devnull" "$1" 1384} 1385 1386# at_fn_test NUMBER 1387# ----------------- 1388# Parse out test NUMBER from the tail of this file. 1389at_fn_test () 1390{ 1391 eval at_sed=\$at_sed$1 1392 sed "$at_sed" "$at_myself" > "$at_test_source" 1393} 1394 1395# at_fn_create_debugging_script 1396# ----------------------------- 1397# Create the debugging script $at_group_dir/run which will reproduce the 1398# current test group. 1399at_fn_create_debugging_script () 1400{ 1401 { 1402 echo "#! /bin/sh" && 1403 echo 'test "${ZSH_VERSION+set}" = set && alias -g '\''${1+"$@"}'\''='\''"$@"'\''' && 1404 $as_echo "cd '$at_dir'" && 1405 $as_echo "exec \${CONFIG_SHELL-$SHELL} \"$at_myself\" -v -d $at_debug_args $at_group \${1+\"\$@\"}" && 1406 echo 'exit 1' 1407 } >"$at_group_dir/run" && 1408 chmod +x "$at_group_dir/run" 1409} 1410 1411## -------------------------------- ## 1412## End of autotest shell functions. ## 1413## -------------------------------- ## 1414{ 1415 $as_echo "## ---------------- ## 1416## Tested programs. ## 1417## ---------------- ##" 1418 echo 1419} >&5 1420 1421# Report what programs are being tested. 1422for at_program in : $at_tested 1423do 1424 test "$at_program" = : && continue 1425 case $at_program in 1426 [\\/]* | ?:[\\/]* ) $at_program_=$at_program ;; 1427 * ) 1428 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 1429for as_dir in $PATH 1430do 1431 IFS=$as_save_IFS 1432 test -z "$as_dir" && as_dir=. 1433 test -f "$as_dir/$at_program" && break 1434 done 1435IFS=$as_save_IFS 1436 1437 at_program_=$as_dir/$at_program ;; 1438 esac 1439 if test -f "$at_program_"; then 1440 { 1441 $as_echo "$at_srcdir/DDSTest.at:3: $at_program_ --version" 1442 "$at_program_" --version </dev/null 1443 echo 1444 } >&5 2>&1 1445 else 1446 as_fn_error $? "cannot find $at_program" "$LINENO" 5 1447 fi 1448done 1449 1450{ 1451 $as_echo "## ------------------ ## 1452## Running the tests. ## 1453## ------------------ ##" 1454} >&5 1455 1456at_start_date=`date` 1457at_start_time=`date +%s 2>/dev/null` 1458$as_echo "$as_me: starting at: $at_start_date" >&5 1459 1460# Create the master directory if it doesn't already exist. 1461as_dir="$at_suite_dir"; as_fn_mkdir_p || 1462 as_fn_error $? "cannot create \`$at_suite_dir'" "$LINENO" 5 1463 1464# Can we diff with `/dev/null'? DU 5.0 refuses. 1465if diff /dev/null /dev/null >/dev/null 2>&1; then 1466 at_devnull=/dev/null 1467else 1468 at_devnull=$at_suite_dir/devnull 1469 >"$at_devnull" 1470fi 1471 1472# Use `diff -u' when possible. 1473if at_diff=`diff -u "$at_devnull" "$at_devnull" 2>&1` && test -z "$at_diff" 1474then 1475 at_diff='diff -u' 1476else 1477 at_diff=diff 1478fi 1479 1480# Get the last needed group. 1481for at_group in : $at_groups; do :; done 1482 1483# Extract the start and end lines of each test group at the tail 1484# of this file 1485awk ' 1486BEGIN { FS="" } 1487/^#AT_START_/ { 1488 start = NR 1489} 1490/^#AT_STOP_/ { 1491 test = substr ($ 0, 10) 1492 print "at_sed" test "=\"1," start "d;" (NR-1) "q\"" 1493 if (test == "'"$at_group"'") exit 1494}' "$at_myself" > "$at_suite_dir/at-source-lines" && 1495. "$at_suite_dir/at-source-lines" || 1496 as_fn_error $? "cannot create test line number cache" "$LINENO" 5 1497rm -f "$at_suite_dir/at-source-lines" 1498 1499# Set number of jobs for `-j'; avoid more jobs than test groups. 1500set X $at_groups; shift; at_max_jobs=$# 1501if test $at_max_jobs -eq 0; then 1502 at_jobs=1 1503fi 1504if test $at_jobs -ne 1 && 1505 { test $at_jobs -eq 0 || test $at_jobs -gt $at_max_jobs; }; then 1506 at_jobs=$at_max_jobs 1507fi 1508 1509# If parallel mode, don't output banners, don't split summary lines. 1510if test $at_jobs -ne 1; then 1511 at_print_banners=false 1512 at_quiet=: 1513fi 1514 1515# Set up helper dirs. 1516rm -rf "$at_helper_dir" && 1517mkdir "$at_helper_dir" && 1518cd "$at_helper_dir" && 1519{ test -z "$at_groups" || mkdir $at_groups; } || 1520as_fn_error $? "testsuite directory setup failed" "$LINENO" 5 1521 1522# Functions for running a test group. We leave the actual 1523# test group execution outside of a shell function in order 1524# to avoid hitting zsh 4.x exit status bugs. 1525 1526# at_fn_group_prepare 1527# ------------------- 1528# Prepare for running a test group. 1529at_fn_group_prepare () 1530{ 1531 # The directory for additional per-group helper files. 1532 at_job_dir=$at_helper_dir/$at_group 1533 # The file containing the location of the last AT_CHECK. 1534 at_check_line_file=$at_job_dir/check-line 1535 # The file containing the exit status of the last command. 1536 at_status_file=$at_job_dir/status 1537 # The files containing the output of the tested commands. 1538 at_stdout=$at_job_dir/stdout 1539 at_stder1=$at_job_dir/stder1 1540 at_stderr=$at_job_dir/stderr 1541 # The file containing the code for a test group. 1542 at_test_source=$at_job_dir/test-source 1543 # The file containing dates. 1544 at_times_file=$at_job_dir/times 1545 1546 # Be sure to come back to the top test directory. 1547 cd "$at_suite_dir" 1548 1549 # Clearly separate the test groups when verbose. 1550 $at_first || $at_verbose echo 1551 1552 at_group_normalized=$at_group 1553 1554 eval 'while :; do 1555 case $at_group_normalized in #( 1556 '"$at_format"'*) break;; 1557 esac 1558 at_group_normalized=0$at_group_normalized 1559 done' 1560 1561 1562 # Create a fresh directory for the next test group, and enter. 1563 # If one already exists, the user may have invoked ./run from 1564 # within that directory; we remove the contents, but not the 1565 # directory itself, so that we aren't pulling the rug out from 1566 # under the shell's notion of the current directory. 1567 at_group_dir=$at_suite_dir/$at_group_normalized 1568 at_group_log=$at_group_dir/$as_me.log 1569 if test -d "$at_group_dir"; then 1570 find "$at_group_dir" -type d ! -perm -700 -exec chmod u+rwx {} \; 1571 rm -fr "$at_group_dir"/* "$at_group_dir"/.[!.] "$at_group_dir"/.??* 1572fi || 1573 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: test directory for $at_group_normalized could not be cleaned" >&5 1574$as_echo "$as_me: WARNING: test directory for $at_group_normalized could not be cleaned" >&2;} 1575 # Be tolerant if the above `rm' was not able to remove the directory. 1576 as_dir="$at_group_dir"; as_fn_mkdir_p 1577 1578 echo 0 > "$at_status_file" 1579 1580 # In verbose mode, append to the log file *and* show on 1581 # the standard output; in quiet mode only write to the log. 1582 if test -z "$at_verbose"; then 1583 at_tee_pipe='tee -a "$at_group_log"' 1584 else 1585 at_tee_pipe='cat >> "$at_group_log"' 1586 fi 1587} 1588 1589# at_fn_group_banner ORDINAL LINE DESC PAD [BANNER] 1590# ------------------------------------------------- 1591# Declare the test group ORDINAL, located at LINE with group description DESC, 1592# and residing under BANNER. Use PAD to align the status column. 1593at_fn_group_banner () 1594{ 1595 at_setup_line="$2" 1596 test -n "$5" && at_fn_banner $5 1597 at_desc="$3" 1598 case $1 in 1599 [0-9]) at_desc_line=" $1: ";; 1600 [0-9][0-9]) at_desc_line=" $1: " ;; 1601 *) at_desc_line="$1: " ;; 1602 esac 1603 as_fn_append at_desc_line "$3$4" 1604 $at_quiet $as_echo_n "$at_desc_line" 1605 echo "# -*- compilation -*-" >> "$at_group_log" 1606} 1607 1608# at_fn_group_postprocess 1609# ----------------------- 1610# Perform cleanup after running a test group. 1611at_fn_group_postprocess () 1612{ 1613 # Be sure to come back to the suite directory, in particular 1614 # since below we might `rm' the group directory we are in currently. 1615 cd "$at_suite_dir" 1616 1617 if test ! -f "$at_check_line_file"; then 1618 sed "s/^ */$as_me: WARNING: /" <<_ATEOF 1619 A failure happened in a test group before any test could be 1620 run. This means that test suite is improperly designed. Please 1621 report this failure to <opendap-tech@opendap.org>. 1622_ATEOF 1623 $as_echo "$at_setup_line" >"$at_check_line_file" 1624 at_status=99 1625 fi 1626 $at_verbose $as_echo_n "$at_group. $at_setup_line: " 1627 $as_echo_n "$at_group. $at_setup_line: " >> "$at_group_log" 1628 case $at_xfail:$at_status in 1629 yes:0) 1630 at_msg="UNEXPECTED PASS" 1631 at_res=xpass 1632 at_errexit=$at_errexit_p 1633 at_color=$at_red 1634 ;; 1635 no:0) 1636 at_msg="ok" 1637 at_res=pass 1638 at_errexit=false 1639 at_color=$at_grn 1640 ;; 1641 *:77) 1642 at_msg='skipped ('`cat "$at_check_line_file"`')' 1643 at_res=skip 1644 at_errexit=false 1645 at_color=$at_blu 1646 ;; 1647 no:* | *:99) 1648 at_msg='FAILED ('`cat "$at_check_line_file"`')' 1649 at_res=fail 1650 at_errexit=$at_errexit_p 1651 at_color=$at_red 1652 ;; 1653 yes:*) 1654 at_msg='expected failure ('`cat "$at_check_line_file"`')' 1655 at_res=xfail 1656 at_errexit=false 1657 at_color=$at_lgn 1658 ;; 1659 esac 1660 echo "$at_res" > "$at_job_dir/$at_res" 1661 # In parallel mode, output the summary line only afterwards. 1662 if test $at_jobs -ne 1 && test -n "$at_verbose"; then 1663 $as_echo "$at_desc_line $at_color$at_msg$at_std" 1664 else 1665 # Make sure there is a separator even with long titles. 1666 $as_echo " $at_color$at_msg$at_std" 1667 fi 1668 at_log_msg="$at_group. $at_desc ($at_setup_line): $at_msg" 1669 case $at_status in 1670 0|77) 1671 # $at_times_file is only available if the group succeeded. 1672 # We're not including the group log, so the success message 1673 # is written in the global log separately. But we also 1674 # write to the group log in case they're using -d. 1675 if test -f "$at_times_file"; then 1676 at_log_msg="$at_log_msg ("`sed 1d "$at_times_file"`')' 1677 rm -f "$at_times_file" 1678 fi 1679 $as_echo "$at_log_msg" >> "$at_group_log" 1680 $as_echo "$at_log_msg" >&5 1681 1682 # Cleanup the group directory, unless the user wants the files 1683 # or the success was unexpected. 1684 if $at_debug_p || test $at_res = xpass; then 1685 at_fn_create_debugging_script 1686 if test $at_res = xpass && $at_errexit; then 1687 echo stop > "$at_stop_file" 1688 fi 1689 else 1690 if test -d "$at_group_dir"; then 1691 find "$at_group_dir" -type d ! -perm -700 -exec chmod u+rwx \{\} \; 1692 rm -fr "$at_group_dir" 1693 fi 1694 rm -f "$at_test_source" 1695 fi 1696 ;; 1697 *) 1698 # Upon failure, include the log into the testsuite's global 1699 # log. The failure message is written in the group log. It 1700 # is later included in the global log. 1701 $as_echo "$at_log_msg" >> "$at_group_log" 1702 1703 # Upon failure, keep the group directory for autopsy, and create 1704 # the debugging script. With -e, do not start any further tests. 1705 at_fn_create_debugging_script 1706 if $at_errexit; then 1707 echo stop > "$at_stop_file" 1708 fi 1709 ;; 1710 esac 1711} 1712 1713 1714## ------------ ## 1715## Driver loop. ## 1716## ------------ ## 1717 1718 1719if (set -m && set +m && set +b) >/dev/null 2>&1; then 1720 set +b 1721 at_job_control_on='set -m' at_job_control_off='set +m' at_job_group=- 1722else 1723 at_job_control_on=: at_job_control_off=: at_job_group= 1724fi 1725 1726for at_signal in 1 2 15; do 1727 trap 'set +x; set +e 1728 $at_job_control_off 1729 at_signal='"$at_signal"' 1730 echo stop > "$at_stop_file" 1731 trap "" $at_signal 1732 at_pgids= 1733 for at_pgid in `jobs -p 2>/dev/null`; do 1734 at_pgids="$at_pgids $at_job_group$at_pgid" 1735 done 1736 test -z "$at_pgids" || kill -$at_signal $at_pgids 2>/dev/null 1737 wait 1738 if test "$at_jobs" -eq 1 || test -z "$at_verbose"; then 1739 echo >&2 1740 fi 1741 at_signame=`kill -l $at_signal 2>&1 || echo $at_signal` 1742 set x $at_signame 1743 test 1 -gt 2 && at_signame=$at_signal 1744 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: caught signal $at_signame, bailing out" >&5 1745$as_echo "$as_me: WARNING: caught signal $at_signame, bailing out" >&2;} 1746 as_fn_arith 128 + $at_signal && exit_status=$as_val 1747 as_fn_exit $exit_status' $at_signal 1748done 1749 1750rm -f "$at_stop_file" 1751at_first=: 1752 1753if test $at_jobs -ne 1 && 1754 rm -f "$at_job_fifo" && 1755 test -n "$at_job_group" && 1756 ( mkfifo "$at_job_fifo" && trap 'exit 1' PIPE STOP TSTP ) 2>/dev/null 1757then 1758 # FIFO job dispatcher. 1759 1760 trap 'at_pids= 1761 for at_pid in `jobs -p`; do 1762 at_pids="$at_pids $at_job_group$at_pid" 1763 done 1764 if test -n "$at_pids"; then 1765 at_sig=TSTP 1766 test "${TMOUT+set}" = set && at_sig=STOP 1767 kill -$at_sig $at_pids 2>/dev/null 1768 fi 1769 kill -STOP $$ 1770 test -z "$at_pids" || kill -CONT $at_pids 2>/dev/null' TSTP 1771 1772 echo 1773 # Turn jobs into a list of numbers, starting from 1. 1774 at_joblist=`$as_echo "$at_groups" | sed -n 1,${at_jobs}p` 1775 1776 set X $at_joblist 1777 shift 1778 for at_group in $at_groups; do 1779 $at_job_control_on 2>/dev/null 1780 ( 1781 # Start one test group. 1782 $at_job_control_off 1783 if $at_first; then 1784 exec 7>"$at_job_fifo" 1785 else 1786 exec 6<&- 1787 fi 1788 trap 'set +x; set +e 1789 trap "" PIPE 1790 echo stop > "$at_stop_file" 1791 echo >&7 1792 as_fn_exit 141' PIPE 1793 at_fn_group_prepare 1794 if cd "$at_group_dir" && 1795 at_fn_test $at_group && 1796 . "$at_test_source" 1797 then :; else 1798 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unable to parse test group: $at_group" >&5 1799$as_echo "$as_me: WARNING: unable to parse test group: $at_group" >&2;} 1800 at_failed=: 1801 fi 1802 at_fn_group_postprocess 1803 echo >&7 1804 ) & 1805 $at_job_control_off 1806 if $at_first; then 1807 at_first=false 1808 exec 6<"$at_job_fifo" 7>"$at_job_fifo" 1809 fi 1810 shift # Consume one token. 1811 if test $# -gt 0; then :; else 1812 read at_token <&6 || break 1813 set x $* 1814 fi 1815 test -f "$at_stop_file" && break 1816 done 1817 exec 7>&- 1818 # Read back the remaining ($at_jobs - 1) tokens. 1819 set X $at_joblist 1820 shift 1821 if test $# -gt 0; then 1822 shift 1823 for at_job 1824 do 1825 read at_token 1826 done <&6 1827 fi 1828 exec 6<&- 1829 wait 1830else 1831 # Run serially, avoid forks and other potential surprises. 1832 for at_group in $at_groups; do 1833 at_fn_group_prepare 1834 if cd "$at_group_dir" && 1835 at_fn_test $at_group && 1836 . "$at_test_source"; then :; else 1837 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unable to parse test group: $at_group" >&5 1838$as_echo "$as_me: WARNING: unable to parse test group: $at_group" >&2;} 1839 at_failed=: 1840 fi 1841 at_fn_group_postprocess 1842 test -f "$at_stop_file" && break 1843 at_first=false 1844 done 1845fi 1846 1847# Wrap up the test suite with summary statistics. 1848cd "$at_helper_dir" 1849 1850# Use ?..???? when the list must remain sorted, the faster * otherwise. 1851at_pass_list=`for f in */pass; do echo $f; done | sed '/\*/d; s,/pass,,'` 1852at_skip_list=`for f in */skip; do echo $f; done | sed '/\*/d; s,/skip,,'` 1853at_xfail_list=`for f in */xfail; do echo $f; done | sed '/\*/d; s,/xfail,,'` 1854at_xpass_list=`for f in ?/xpass ??/xpass ???/xpass ????/xpass; do 1855 echo $f; done | sed '/?/d; s,/xpass,,'` 1856at_fail_list=`for f in ?/fail ??/fail ???/fail ????/fail; do 1857 echo $f; done | sed '/?/d; s,/fail,,'` 1858 1859set X $at_pass_list $at_xpass_list $at_xfail_list $at_fail_list $at_skip_list 1860shift; at_group_count=$# 1861set X $at_xpass_list; shift; at_xpass_count=$#; at_xpass_list=$* 1862set X $at_xfail_list; shift; at_xfail_count=$# 1863set X $at_fail_list; shift; at_fail_count=$#; at_fail_list=$* 1864set X $at_skip_list; shift; at_skip_count=$# 1865 1866as_fn_arith $at_group_count - $at_skip_count && at_run_count=$as_val 1867as_fn_arith $at_xpass_count + $at_fail_count && at_unexpected_count=$as_val 1868as_fn_arith $at_xfail_count + $at_fail_count && at_total_fail_count=$as_val 1869 1870# Back to the top directory. 1871cd "$at_dir" 1872rm -rf "$at_helper_dir" 1873 1874# Compute the duration of the suite. 1875at_stop_date=`date` 1876at_stop_time=`date +%s 2>/dev/null` 1877$as_echo "$as_me: ending at: $at_stop_date" >&5 1878case $at_start_time,$at_stop_time in 1879 [0-9]*,[0-9]*) 1880 as_fn_arith $at_stop_time - $at_start_time && at_duration_s=$as_val 1881 as_fn_arith $at_duration_s / 60 && at_duration_m=$as_val 1882 as_fn_arith $at_duration_m / 60 && at_duration_h=$as_val 1883 as_fn_arith $at_duration_s % 60 && at_duration_s=$as_val 1884 as_fn_arith $at_duration_m % 60 && at_duration_m=$as_val 1885 at_duration="${at_duration_h}h ${at_duration_m}m ${at_duration_s}s" 1886 $as_echo "$as_me: test suite duration: $at_duration" >&5 1887 ;; 1888esac 1889 1890echo 1891$as_echo "## ------------- ## 1892## Test results. ## 1893## ------------- ##" 1894echo 1895{ 1896 echo 1897 $as_echo "## ------------- ## 1898## Test results. ## 1899## ------------- ##" 1900 echo 1901} >&5 1902 1903if test $at_run_count = 1; then 1904 at_result="1 test" 1905 at_were=was 1906else 1907 at_result="$at_run_count tests" 1908 at_were=were 1909fi 1910if $at_errexit_p && test $at_unexpected_count != 0; then 1911 if test $at_xpass_count = 1; then 1912 at_result="$at_result $at_were run, one passed" 1913 else 1914 at_result="$at_result $at_were run, one failed" 1915 fi 1916 at_result="$at_result unexpectedly and inhibited subsequent tests." 1917 at_color=$at_red 1918else 1919 # Don't you just love exponential explosion of the number of cases? 1920 at_color=$at_red 1921 case $at_xpass_count:$at_fail_count:$at_xfail_count in 1922 # So far, so good. 1923 0:0:0) at_result="$at_result $at_were successful." at_color=$at_grn ;; 1924 0:0:*) at_result="$at_result behaved as expected." at_color=$at_lgn ;; 1925 1926 # Some unexpected failures 1927 0:*:0) at_result="$at_result $at_were run, 1928$at_fail_count failed unexpectedly." ;; 1929 1930 # Some failures, both expected and unexpected 1931 0:*:1) at_result="$at_result $at_were run, 1932$at_total_fail_count failed ($at_xfail_count expected failure)." ;; 1933 0:*:*) at_result="$at_result $at_were run, 1934$at_total_fail_count failed ($at_xfail_count expected failures)." ;; 1935 1936 # No unexpected failures, but some xpasses 1937 *:0:*) at_result="$at_result $at_were run, 1938$at_xpass_count passed unexpectedly." ;; 1939 1940 # No expected failures, but failures and xpasses 1941 *:1:0) at_result="$at_result $at_were run, 1942$at_unexpected_count did not behave as expected ($at_fail_count unexpected failure)." ;; 1943 *:*:0) at_result="$at_result $at_were run, 1944$at_unexpected_count did not behave as expected ($at_fail_count unexpected failures)." ;; 1945 1946 # All of them. 1947 *:*:1) at_result="$at_result $at_were run, 1948$at_xpass_count passed unexpectedly, 1949$at_total_fail_count failed ($at_xfail_count expected failure)." ;; 1950 *:*:*) at_result="$at_result $at_were run, 1951$at_xpass_count passed unexpectedly, 1952$at_total_fail_count failed ($at_xfail_count expected failures)." ;; 1953 esac 1954 1955 if test $at_skip_count = 0 && test $at_run_count -gt 1; then 1956 at_result="All $at_result" 1957 fi 1958fi 1959 1960# Now put skips in the mix. 1961case $at_skip_count in 1962 0) ;; 1963 1) at_result="$at_result 19641 test was skipped." ;; 1965 *) at_result="$at_result 1966$at_skip_count tests were skipped." ;; 1967esac 1968 1969if test $at_unexpected_count = 0; then 1970 echo "$at_color$at_result$at_std" 1971 echo "$at_result" >&5 1972else 1973 echo "${at_color}ERROR: $at_result$at_std" >&2 1974 echo "ERROR: $at_result" >&5 1975 { 1976 echo 1977 $as_echo "## ------------------------ ## 1978## Summary of the failures. ## 1979## ------------------------ ##" 1980 1981 # Summary of failed and skipped tests. 1982 if test $at_fail_count != 0; then 1983 echo "Failed tests:" 1984 $SHELL "$at_myself" $at_fail_list --list 1985 echo 1986 fi 1987 if test $at_skip_count != 0; then 1988 echo "Skipped tests:" 1989 $SHELL "$at_myself" $at_skip_list --list 1990 echo 1991 fi 1992 if test $at_xpass_count != 0; then 1993 echo "Unexpected passes:" 1994 $SHELL "$at_myself" $at_xpass_list --list 1995 echo 1996 fi 1997 if test $at_fail_count != 0; then 1998 $as_echo "## ---------------------- ## 1999## Detailed failed tests. ## 2000## ---------------------- ##" 2001 echo 2002 for at_group in $at_fail_list 2003 do 2004 at_group_normalized=$at_group 2005 2006 eval 'while :; do 2007 case $at_group_normalized in #( 2008 '"$at_format"'*) break;; 2009 esac 2010 at_group_normalized=0$at_group_normalized 2011 done' 2012 2013 cat "$at_suite_dir/$at_group_normalized/$as_me.log" 2014 echo 2015 done 2016 echo 2017 fi 2018 if test -n "$at_top_srcdir"; then 2019 sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX 2020## ${at_top_build_prefix}config.log ## 2021_ASBOX 2022 sed 's/^/| /' ${at_top_build_prefix}config.log 2023 echo 2024 fi 2025 } >&5 2026 2027 sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX 2028## $as_me.log was created. ## 2029_ASBOX 2030 2031 echo 2032 if $at_debug_p; then 2033 at_msg='per-test log files' 2034 else 2035 at_msg="\`${at_testdir+${at_testdir}/}$as_me.log'" 2036 fi 2037 $as_echo "Please send $at_msg and all information you think might help: 2038 2039 To: <opendap-tech@opendap.org> 2040 Subject: [libdap 3.20.8] $as_me: $at_fail_list${at_fail_list:+ failed${at_xpass_list:+, }}$at_xpass_list${at_xpass_list:+ passed unexpectedly} 2041 2042You may investigate any problem if you feel able to do so, in which 2043case the test suite provides a good starting point. Its output may 2044be found below \`${at_testdir+${at_testdir}/}$as_me.dir'. 2045" 2046 exit 1 2047fi 2048 2049exit 0 2050 2051## ------------- ## 2052## Actual tests. ## 2053## ------------- ## 2054#AT_START_1 2055at_fn_group_banner 1 'DDSTest.at:48' \ 2056 "DDS \$abs_srcdir/dds-testsuite/3B42.980909.5.hacked.HDF.das.dds" "" 2057at_xfail=no 2058 test "" = "xfail" && at_xfail=yes 2059( 2060 $as_echo "1. $at_setup_line: testing $at_desc ..." 2061 $at_traceon 2062 2063 2064 2065 input=$abs_srcdir/dds-testsuite/3B42.980909.5.hacked.HDF.das.dds 2066 baseline=$abs_srcdir/dds-testsuite/3B42.980909.5.hacked.HDF.das.dds.base 2067 2068 if test -n "$baselines" -a x$baselines = xyes; then : 2069 2070 # The --baselines=yes option works only for tests that write to stdout 2071 { set +x 2072$as_echo "$at_srcdir/DDSTest.at:48: \$abs_builddir/dds-test -p < \$input || true" 2073at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:48" 2074( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2075) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2076at_status=$? at_failed=false 2077$at_check_filter 2078echo stderr:; cat "$at_stderr" 2079echo stdout:; tee stdout <"$at_stdout" 2080at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:48" 2081$at_failed && at_fn_log_failure 2082$at_traceon; } 2083 2084 { set +x 2085$as_echo "$at_srcdir/DDSTest.at:48: mv stdout \$baseline.tmp" 2086at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:48" 2087( $at_check_trace; mv stdout $baseline.tmp 2088) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2089at_status=$? at_failed=false 2090$at_check_filter 2091at_fn_diff_devnull "$at_stderr" || at_failed=: 2092at_fn_diff_devnull "$at_stdout" || at_failed=: 2093at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:48" 2094$at_failed && at_fn_log_failure 2095$at_traceon; } 2096 2097 2098else 2099 2100 # Added '|| true' to ensure the command returns '0' 2101 { set +x 2102$as_echo "$at_srcdir/DDSTest.at:48: \$abs_builddir/dds-test -p < \$input || true" 2103at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:48" 2104( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2105) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2106at_status=$? at_failed=false 2107$at_check_filter 2108echo stderr:; tee stderr <"$at_stderr" 2109echo stdout:; tee stdout <"$at_stdout" 2110at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:48" 2111$at_failed && at_fn_log_failure 2112$at_traceon; } 2113 2114 # Need to compare either stdout or stderr 2115 { set +x 2116$as_echo "$at_srcdir/DDSTest.at:48: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 2117at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:48" 2118( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 2119) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2120at_status=$? at_failed=false 2121$at_check_filter 2122at_fn_diff_devnull "$at_stderr" || at_failed=: 2123echo stdout:; cat "$at_stdout" 2124at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:48" 2125$at_failed && at_fn_log_failure 2126$at_traceon; } 2127 2128 2129 2130fi 2131 2132 set +x 2133 $at_times_p && times >"$at_times_file" 2134) 5>&1 2>&1 7>&- | eval $at_tee_pipe 2135read at_status <"$at_status_file" 2136#AT_STOP_1 2137#AT_START_2 2138at_fn_group_banner 2 'DDSTest.at:49' \ 2139 "DDS \$abs_srcdir/dds-testsuite/3B42.980909.5.HDF.das.dds" "" 2140at_xfail=no 2141 test "" = "xfail" && at_xfail=yes 2142( 2143 $as_echo "2. $at_setup_line: testing $at_desc ..." 2144 $at_traceon 2145 2146 2147 2148 input=$abs_srcdir/dds-testsuite/3B42.980909.5.HDF.das.dds 2149 baseline=$abs_srcdir/dds-testsuite/3B42.980909.5.HDF.das.dds.base 2150 2151 if test -n "$baselines" -a x$baselines = xyes; then : 2152 2153 # The --baselines=yes option works only for tests that write to stdout 2154 { set +x 2155$as_echo "$at_srcdir/DDSTest.at:49: \$abs_builddir/dds-test -p < \$input || true" 2156at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:49" 2157( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2158) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2159at_status=$? at_failed=false 2160$at_check_filter 2161echo stderr:; cat "$at_stderr" 2162echo stdout:; tee stdout <"$at_stdout" 2163at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:49" 2164$at_failed && at_fn_log_failure 2165$at_traceon; } 2166 2167 { set +x 2168$as_echo "$at_srcdir/DDSTest.at:49: mv stdout \$baseline.tmp" 2169at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:49" 2170( $at_check_trace; mv stdout $baseline.tmp 2171) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2172at_status=$? at_failed=false 2173$at_check_filter 2174at_fn_diff_devnull "$at_stderr" || at_failed=: 2175at_fn_diff_devnull "$at_stdout" || at_failed=: 2176at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:49" 2177$at_failed && at_fn_log_failure 2178$at_traceon; } 2179 2180 2181else 2182 2183 # Added '|| true' to ensure the command returns '0' 2184 { set +x 2185$as_echo "$at_srcdir/DDSTest.at:49: \$abs_builddir/dds-test -p < \$input || true" 2186at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:49" 2187( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2188) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2189at_status=$? at_failed=false 2190$at_check_filter 2191echo stderr:; tee stderr <"$at_stderr" 2192echo stdout:; tee stdout <"$at_stdout" 2193at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:49" 2194$at_failed && at_fn_log_failure 2195$at_traceon; } 2196 2197 # Need to compare either stdout or stderr 2198 { set +x 2199$as_echo "$at_srcdir/DDSTest.at:49: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 2200at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:49" 2201( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 2202) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2203at_status=$? at_failed=false 2204$at_check_filter 2205at_fn_diff_devnull "$at_stderr" || at_failed=: 2206echo stdout:; cat "$at_stdout" 2207at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:49" 2208$at_failed && at_fn_log_failure 2209$at_traceon; } 2210 2211 2212 2213fi 2214 2215 set +x 2216 $at_times_p && times >"$at_times_file" 2217) 5>&1 2>&1 7>&- | eval $at_tee_pipe 2218read at_status <"$at_status_file" 2219#AT_STOP_2 2220#AT_START_3 2221at_fn_group_banner 3 'DDSTest.at:50' \ 2222 "DDS \$abs_srcdir/dds-testsuite/3B42.980909.5.HDF.dds" "" 2223at_xfail=no 2224 test "" = "xfail" && at_xfail=yes 2225( 2226 $as_echo "3. $at_setup_line: testing $at_desc ..." 2227 $at_traceon 2228 2229 2230 2231 input=$abs_srcdir/dds-testsuite/3B42.980909.5.HDF.dds 2232 baseline=$abs_srcdir/dds-testsuite/3B42.980909.5.HDF.dds.base 2233 2234 if test -n "$baselines" -a x$baselines = xyes; then : 2235 2236 # The --baselines=yes option works only for tests that write to stdout 2237 { set +x 2238$as_echo "$at_srcdir/DDSTest.at:50: \$abs_builddir/dds-test -p < \$input || true" 2239at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:50" 2240( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2241) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2242at_status=$? at_failed=false 2243$at_check_filter 2244echo stderr:; cat "$at_stderr" 2245echo stdout:; tee stdout <"$at_stdout" 2246at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:50" 2247$at_failed && at_fn_log_failure 2248$at_traceon; } 2249 2250 { set +x 2251$as_echo "$at_srcdir/DDSTest.at:50: mv stdout \$baseline.tmp" 2252at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:50" 2253( $at_check_trace; mv stdout $baseline.tmp 2254) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2255at_status=$? at_failed=false 2256$at_check_filter 2257at_fn_diff_devnull "$at_stderr" || at_failed=: 2258at_fn_diff_devnull "$at_stdout" || at_failed=: 2259at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:50" 2260$at_failed && at_fn_log_failure 2261$at_traceon; } 2262 2263 2264else 2265 2266 # Added '|| true' to ensure the command returns '0' 2267 { set +x 2268$as_echo "$at_srcdir/DDSTest.at:50: \$abs_builddir/dds-test -p < \$input || true" 2269at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:50" 2270( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2271) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2272at_status=$? at_failed=false 2273$at_check_filter 2274echo stderr:; tee stderr <"$at_stderr" 2275echo stdout:; tee stdout <"$at_stdout" 2276at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:50" 2277$at_failed && at_fn_log_failure 2278$at_traceon; } 2279 2280 # Need to compare either stdout or stderr 2281 { set +x 2282$as_echo "$at_srcdir/DDSTest.at:50: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 2283at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:50" 2284( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 2285) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2286at_status=$? at_failed=false 2287$at_check_filter 2288at_fn_diff_devnull "$at_stderr" || at_failed=: 2289echo stdout:; cat "$at_stdout" 2290at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:50" 2291$at_failed && at_fn_log_failure 2292$at_traceon; } 2293 2294 2295 2296fi 2297 2298 set +x 2299 $at_times_p && times >"$at_times_file" 2300) 5>&1 2>&1 7>&- | eval $at_tee_pipe 2301read at_status <"$at_status_file" 2302#AT_STOP_3 2303#AT_START_4 2304at_fn_group_banner 4 'DDSTest.at:51' \ 2305 "DDS \$abs_srcdir/dds-testsuite/AsciiOutputTest1.dds" "" 2306at_xfail=no 2307 test "" = "xfail" && at_xfail=yes 2308( 2309 $as_echo "4. $at_setup_line: testing $at_desc ..." 2310 $at_traceon 2311 2312 2313 2314 input=$abs_srcdir/dds-testsuite/AsciiOutputTest1.dds 2315 baseline=$abs_srcdir/dds-testsuite/AsciiOutputTest1.dds.base 2316 2317 if test -n "$baselines" -a x$baselines = xyes; then : 2318 2319 # The --baselines=yes option works only for tests that write to stdout 2320 { set +x 2321$as_echo "$at_srcdir/DDSTest.at:51: \$abs_builddir/dds-test -p < \$input || true" 2322at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:51" 2323( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2324) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2325at_status=$? at_failed=false 2326$at_check_filter 2327echo stderr:; cat "$at_stderr" 2328echo stdout:; tee stdout <"$at_stdout" 2329at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:51" 2330$at_failed && at_fn_log_failure 2331$at_traceon; } 2332 2333 { set +x 2334$as_echo "$at_srcdir/DDSTest.at:51: mv stdout \$baseline.tmp" 2335at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:51" 2336( $at_check_trace; mv stdout $baseline.tmp 2337) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2338at_status=$? at_failed=false 2339$at_check_filter 2340at_fn_diff_devnull "$at_stderr" || at_failed=: 2341at_fn_diff_devnull "$at_stdout" || at_failed=: 2342at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:51" 2343$at_failed && at_fn_log_failure 2344$at_traceon; } 2345 2346 2347else 2348 2349 # Added '|| true' to ensure the command returns '0' 2350 { set +x 2351$as_echo "$at_srcdir/DDSTest.at:51: \$abs_builddir/dds-test -p < \$input || true" 2352at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:51" 2353( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2354) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2355at_status=$? at_failed=false 2356$at_check_filter 2357echo stderr:; tee stderr <"$at_stderr" 2358echo stdout:; tee stdout <"$at_stdout" 2359at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:51" 2360$at_failed && at_fn_log_failure 2361$at_traceon; } 2362 2363 # Need to compare either stdout or stderr 2364 { set +x 2365$as_echo "$at_srcdir/DDSTest.at:51: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 2366at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:51" 2367( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 2368) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2369at_status=$? at_failed=false 2370$at_check_filter 2371at_fn_diff_devnull "$at_stderr" || at_failed=: 2372echo stdout:; cat "$at_stdout" 2373at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:51" 2374$at_failed && at_fn_log_failure 2375$at_traceon; } 2376 2377 2378 2379fi 2380 2381 set +x 2382 $at_times_p && times >"$at_times_file" 2383) 5>&1 2>&1 7>&- | eval $at_tee_pipe 2384read at_status <"$at_status_file" 2385#AT_STOP_4 2386#AT_START_5 2387at_fn_group_banner 5 'DDSTest.at:52' \ 2388 "DDS \$abs_srcdir/dds-testsuite/fnoc1.nc.das.dds" " " 2389at_xfail=no 2390 test "" = "xfail" && at_xfail=yes 2391( 2392 $as_echo "5. $at_setup_line: testing $at_desc ..." 2393 $at_traceon 2394 2395 2396 2397 input=$abs_srcdir/dds-testsuite/fnoc1.nc.das.dds 2398 baseline=$abs_srcdir/dds-testsuite/fnoc1.nc.das.dds.base 2399 2400 if test -n "$baselines" -a x$baselines = xyes; then : 2401 2402 # The --baselines=yes option works only for tests that write to stdout 2403 { set +x 2404$as_echo "$at_srcdir/DDSTest.at:52: \$abs_builddir/dds-test -p < \$input || true" 2405at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:52" 2406( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2407) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2408at_status=$? at_failed=false 2409$at_check_filter 2410echo stderr:; cat "$at_stderr" 2411echo stdout:; tee stdout <"$at_stdout" 2412at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:52" 2413$at_failed && at_fn_log_failure 2414$at_traceon; } 2415 2416 { set +x 2417$as_echo "$at_srcdir/DDSTest.at:52: mv stdout \$baseline.tmp" 2418at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:52" 2419( $at_check_trace; mv stdout $baseline.tmp 2420) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2421at_status=$? at_failed=false 2422$at_check_filter 2423at_fn_diff_devnull "$at_stderr" || at_failed=: 2424at_fn_diff_devnull "$at_stdout" || at_failed=: 2425at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:52" 2426$at_failed && at_fn_log_failure 2427$at_traceon; } 2428 2429 2430else 2431 2432 # Added '|| true' to ensure the command returns '0' 2433 { set +x 2434$as_echo "$at_srcdir/DDSTest.at:52: \$abs_builddir/dds-test -p < \$input || true" 2435at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:52" 2436( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2437) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2438at_status=$? at_failed=false 2439$at_check_filter 2440echo stderr:; tee stderr <"$at_stderr" 2441echo stdout:; tee stdout <"$at_stdout" 2442at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:52" 2443$at_failed && at_fn_log_failure 2444$at_traceon; } 2445 2446 # Need to compare either stdout or stderr 2447 { set +x 2448$as_echo "$at_srcdir/DDSTest.at:52: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 2449at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:52" 2450( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 2451) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2452at_status=$? at_failed=false 2453$at_check_filter 2454at_fn_diff_devnull "$at_stderr" || at_failed=: 2455echo stdout:; cat "$at_stdout" 2456at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:52" 2457$at_failed && at_fn_log_failure 2458$at_traceon; } 2459 2460 2461 2462fi 2463 2464 set +x 2465 $at_times_p && times >"$at_times_file" 2466) 5>&1 2>&1 7>&- | eval $at_tee_pipe 2467read at_status <"$at_status_file" 2468#AT_STOP_5 2469#AT_START_6 2470at_fn_group_banner 6 'DDSTest.at:53' \ 2471 "DDS \$abs_srcdir/dds-testsuite/fnoc1.nc.dds" " " 2472at_xfail=no 2473 test "" = "xfail" && at_xfail=yes 2474( 2475 $as_echo "6. $at_setup_line: testing $at_desc ..." 2476 $at_traceon 2477 2478 2479 2480 input=$abs_srcdir/dds-testsuite/fnoc1.nc.dds 2481 baseline=$abs_srcdir/dds-testsuite/fnoc1.nc.dds.base 2482 2483 if test -n "$baselines" -a x$baselines = xyes; then : 2484 2485 # The --baselines=yes option works only for tests that write to stdout 2486 { set +x 2487$as_echo "$at_srcdir/DDSTest.at:53: \$abs_builddir/dds-test -p < \$input || true" 2488at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:53" 2489( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2490) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2491at_status=$? at_failed=false 2492$at_check_filter 2493echo stderr:; cat "$at_stderr" 2494echo stdout:; tee stdout <"$at_stdout" 2495at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:53" 2496$at_failed && at_fn_log_failure 2497$at_traceon; } 2498 2499 { set +x 2500$as_echo "$at_srcdir/DDSTest.at:53: mv stdout \$baseline.tmp" 2501at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:53" 2502( $at_check_trace; mv stdout $baseline.tmp 2503) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2504at_status=$? at_failed=false 2505$at_check_filter 2506at_fn_diff_devnull "$at_stderr" || at_failed=: 2507at_fn_diff_devnull "$at_stdout" || at_failed=: 2508at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:53" 2509$at_failed && at_fn_log_failure 2510$at_traceon; } 2511 2512 2513else 2514 2515 # Added '|| true' to ensure the command returns '0' 2516 { set +x 2517$as_echo "$at_srcdir/DDSTest.at:53: \$abs_builddir/dds-test -p < \$input || true" 2518at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:53" 2519( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2520) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2521at_status=$? at_failed=false 2522$at_check_filter 2523echo stderr:; tee stderr <"$at_stderr" 2524echo stdout:; tee stdout <"$at_stdout" 2525at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:53" 2526$at_failed && at_fn_log_failure 2527$at_traceon; } 2528 2529 # Need to compare either stdout or stderr 2530 { set +x 2531$as_echo "$at_srcdir/DDSTest.at:53: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 2532at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:53" 2533( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 2534) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2535at_status=$? at_failed=false 2536$at_check_filter 2537at_fn_diff_devnull "$at_stderr" || at_failed=: 2538echo stdout:; cat "$at_stdout" 2539at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:53" 2540$at_failed && at_fn_log_failure 2541$at_traceon; } 2542 2543 2544 2545fi 2546 2547 set +x 2548 $at_times_p && times >"$at_times_file" 2549) 5>&1 2>&1 7>&- | eval $at_tee_pipe 2550read at_status <"$at_status_file" 2551#AT_STOP_6 2552#AT_START_7 2553at_fn_group_banner 7 'DDSTest.at:54' \ 2554 "DDS \$abs_srcdir/dds-testsuite/S2000415.HDF.das.dds" "" 2555at_xfail=no 2556 test "" = "xfail" && at_xfail=yes 2557( 2558 $as_echo "7. $at_setup_line: testing $at_desc ..." 2559 $at_traceon 2560 2561 2562 2563 input=$abs_srcdir/dds-testsuite/S2000415.HDF.das.dds 2564 baseline=$abs_srcdir/dds-testsuite/S2000415.HDF.das.dds.base 2565 2566 if test -n "$baselines" -a x$baselines = xyes; then : 2567 2568 # The --baselines=yes option works only for tests that write to stdout 2569 { set +x 2570$as_echo "$at_srcdir/DDSTest.at:54: \$abs_builddir/dds-test -p < \$input || true" 2571at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:54" 2572( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2573) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2574at_status=$? at_failed=false 2575$at_check_filter 2576echo stderr:; cat "$at_stderr" 2577echo stdout:; tee stdout <"$at_stdout" 2578at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:54" 2579$at_failed && at_fn_log_failure 2580$at_traceon; } 2581 2582 { set +x 2583$as_echo "$at_srcdir/DDSTest.at:54: mv stdout \$baseline.tmp" 2584at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:54" 2585( $at_check_trace; mv stdout $baseline.tmp 2586) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2587at_status=$? at_failed=false 2588$at_check_filter 2589at_fn_diff_devnull "$at_stderr" || at_failed=: 2590at_fn_diff_devnull "$at_stdout" || at_failed=: 2591at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:54" 2592$at_failed && at_fn_log_failure 2593$at_traceon; } 2594 2595 2596else 2597 2598 # Added '|| true' to ensure the command returns '0' 2599 { set +x 2600$as_echo "$at_srcdir/DDSTest.at:54: \$abs_builddir/dds-test -p < \$input || true" 2601at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:54" 2602( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2603) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2604at_status=$? at_failed=false 2605$at_check_filter 2606echo stderr:; tee stderr <"$at_stderr" 2607echo stdout:; tee stdout <"$at_stdout" 2608at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:54" 2609$at_failed && at_fn_log_failure 2610$at_traceon; } 2611 2612 # Need to compare either stdout or stderr 2613 { set +x 2614$as_echo "$at_srcdir/DDSTest.at:54: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 2615at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:54" 2616( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 2617) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2618at_status=$? at_failed=false 2619$at_check_filter 2620at_fn_diff_devnull "$at_stderr" || at_failed=: 2621echo stdout:; cat "$at_stdout" 2622at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:54" 2623$at_failed && at_fn_log_failure 2624$at_traceon; } 2625 2626 2627 2628fi 2629 2630 set +x 2631 $at_times_p && times >"$at_times_file" 2632) 5>&1 2>&1 7>&- | eval $at_tee_pipe 2633read at_status <"$at_status_file" 2634#AT_STOP_7 2635#AT_START_8 2636at_fn_group_banner 8 'DDSTest.at:55' \ 2637 "DDS \$abs_srcdir/dds-testsuite/S2000415.HDF.dds" " " 2638at_xfail=no 2639 test "" = "xfail" && at_xfail=yes 2640( 2641 $as_echo "8. $at_setup_line: testing $at_desc ..." 2642 $at_traceon 2643 2644 2645 2646 input=$abs_srcdir/dds-testsuite/S2000415.HDF.dds 2647 baseline=$abs_srcdir/dds-testsuite/S2000415.HDF.dds.base 2648 2649 if test -n "$baselines" -a x$baselines = xyes; then : 2650 2651 # The --baselines=yes option works only for tests that write to stdout 2652 { set +x 2653$as_echo "$at_srcdir/DDSTest.at:55: \$abs_builddir/dds-test -p < \$input || true" 2654at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:55" 2655( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2656) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2657at_status=$? at_failed=false 2658$at_check_filter 2659echo stderr:; cat "$at_stderr" 2660echo stdout:; tee stdout <"$at_stdout" 2661at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:55" 2662$at_failed && at_fn_log_failure 2663$at_traceon; } 2664 2665 { set +x 2666$as_echo "$at_srcdir/DDSTest.at:55: mv stdout \$baseline.tmp" 2667at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:55" 2668( $at_check_trace; mv stdout $baseline.tmp 2669) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2670at_status=$? at_failed=false 2671$at_check_filter 2672at_fn_diff_devnull "$at_stderr" || at_failed=: 2673at_fn_diff_devnull "$at_stdout" || at_failed=: 2674at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:55" 2675$at_failed && at_fn_log_failure 2676$at_traceon; } 2677 2678 2679else 2680 2681 # Added '|| true' to ensure the command returns '0' 2682 { set +x 2683$as_echo "$at_srcdir/DDSTest.at:55: \$abs_builddir/dds-test -p < \$input || true" 2684at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:55" 2685( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2686) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2687at_status=$? at_failed=false 2688$at_check_filter 2689echo stderr:; tee stderr <"$at_stderr" 2690echo stdout:; tee stdout <"$at_stdout" 2691at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:55" 2692$at_failed && at_fn_log_failure 2693$at_traceon; } 2694 2695 # Need to compare either stdout or stderr 2696 { set +x 2697$as_echo "$at_srcdir/DDSTest.at:55: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 2698at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:55" 2699( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 2700) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2701at_status=$? at_failed=false 2702$at_check_filter 2703at_fn_diff_devnull "$at_stderr" || at_failed=: 2704echo stdout:; cat "$at_stdout" 2705at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:55" 2706$at_failed && at_fn_log_failure 2707$at_traceon; } 2708 2709 2710 2711fi 2712 2713 set +x 2714 $at_times_p && times >"$at_times_file" 2715) 5>&1 2>&1 7>&- | eval $at_tee_pipe 2716read at_status <"$at_status_file" 2717#AT_STOP_8 2718#AT_START_9 2719at_fn_group_banner 9 'DDSTest.at:56' \ 2720 "DDS \$abs_srcdir/dds-testsuite/test.1.dds" " " 2721at_xfail=no 2722 test "" = "xfail" && at_xfail=yes 2723( 2724 $as_echo "9. $at_setup_line: testing $at_desc ..." 2725 $at_traceon 2726 2727 2728 2729 input=$abs_srcdir/dds-testsuite/test.1.dds 2730 baseline=$abs_srcdir/dds-testsuite/test.1.dds.base 2731 2732 if test -n "$baselines" -a x$baselines = xyes; then : 2733 2734 # The --baselines=yes option works only for tests that write to stdout 2735 { set +x 2736$as_echo "$at_srcdir/DDSTest.at:56: \$abs_builddir/dds-test -p < \$input || true" 2737at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:56" 2738( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2739) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2740at_status=$? at_failed=false 2741$at_check_filter 2742echo stderr:; cat "$at_stderr" 2743echo stdout:; tee stdout <"$at_stdout" 2744at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:56" 2745$at_failed && at_fn_log_failure 2746$at_traceon; } 2747 2748 { set +x 2749$as_echo "$at_srcdir/DDSTest.at:56: mv stdout \$baseline.tmp" 2750at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:56" 2751( $at_check_trace; mv stdout $baseline.tmp 2752) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2753at_status=$? at_failed=false 2754$at_check_filter 2755at_fn_diff_devnull "$at_stderr" || at_failed=: 2756at_fn_diff_devnull "$at_stdout" || at_failed=: 2757at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:56" 2758$at_failed && at_fn_log_failure 2759$at_traceon; } 2760 2761 2762else 2763 2764 # Added '|| true' to ensure the command returns '0' 2765 { set +x 2766$as_echo "$at_srcdir/DDSTest.at:56: \$abs_builddir/dds-test -p < \$input || true" 2767at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:56" 2768( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2769) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2770at_status=$? at_failed=false 2771$at_check_filter 2772echo stderr:; tee stderr <"$at_stderr" 2773echo stdout:; tee stdout <"$at_stdout" 2774at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:56" 2775$at_failed && at_fn_log_failure 2776$at_traceon; } 2777 2778 # Need to compare either stdout or stderr 2779 { set +x 2780$as_echo "$at_srcdir/DDSTest.at:56: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 2781at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:56" 2782( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 2783) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2784at_status=$? at_failed=false 2785$at_check_filter 2786at_fn_diff_devnull "$at_stderr" || at_failed=: 2787echo stdout:; cat "$at_stdout" 2788at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:56" 2789$at_failed && at_fn_log_failure 2790$at_traceon; } 2791 2792 2793 2794fi 2795 2796 set +x 2797 $at_times_p && times >"$at_times_file" 2798) 5>&1 2>&1 7>&- | eval $at_tee_pipe 2799read at_status <"$at_status_file" 2800#AT_STOP_9 2801#AT_START_10 2802at_fn_group_banner 10 'DDSTest.at:57' \ 2803 "DDS \$abs_srcdir/dds-testsuite/test.10.dds" " " 2804at_xfail=no 2805 test "" = "xfail" && at_xfail=yes 2806( 2807 $as_echo "10. $at_setup_line: testing $at_desc ..." 2808 $at_traceon 2809 2810 2811 2812 input=$abs_srcdir/dds-testsuite/test.10.dds 2813 baseline=$abs_srcdir/dds-testsuite/test.10.dds.base 2814 2815 if test -n "$baselines" -a x$baselines = xyes; then : 2816 2817 # The --baselines=yes option works only for tests that write to stdout 2818 { set +x 2819$as_echo "$at_srcdir/DDSTest.at:57: \$abs_builddir/dds-test -p < \$input || true" 2820at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:57" 2821( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2822) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2823at_status=$? at_failed=false 2824$at_check_filter 2825echo stderr:; cat "$at_stderr" 2826echo stdout:; tee stdout <"$at_stdout" 2827at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:57" 2828$at_failed && at_fn_log_failure 2829$at_traceon; } 2830 2831 { set +x 2832$as_echo "$at_srcdir/DDSTest.at:57: mv stdout \$baseline.tmp" 2833at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:57" 2834( $at_check_trace; mv stdout $baseline.tmp 2835) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2836at_status=$? at_failed=false 2837$at_check_filter 2838at_fn_diff_devnull "$at_stderr" || at_failed=: 2839at_fn_diff_devnull "$at_stdout" || at_failed=: 2840at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:57" 2841$at_failed && at_fn_log_failure 2842$at_traceon; } 2843 2844 2845else 2846 2847 # Added '|| true' to ensure the command returns '0' 2848 { set +x 2849$as_echo "$at_srcdir/DDSTest.at:57: \$abs_builddir/dds-test -p < \$input || true" 2850at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:57" 2851( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2852) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2853at_status=$? at_failed=false 2854$at_check_filter 2855echo stderr:; tee stderr <"$at_stderr" 2856echo stdout:; tee stdout <"$at_stdout" 2857at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:57" 2858$at_failed && at_fn_log_failure 2859$at_traceon; } 2860 2861 # Need to compare either stdout or stderr 2862 { set +x 2863$as_echo "$at_srcdir/DDSTest.at:57: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 2864at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:57" 2865( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 2866) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2867at_status=$? at_failed=false 2868$at_check_filter 2869at_fn_diff_devnull "$at_stderr" || at_failed=: 2870echo stdout:; cat "$at_stdout" 2871at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:57" 2872$at_failed && at_fn_log_failure 2873$at_traceon; } 2874 2875 2876 2877fi 2878 2879 set +x 2880 $at_times_p && times >"$at_times_file" 2881) 5>&1 2>&1 7>&- | eval $at_tee_pipe 2882read at_status <"$at_status_file" 2883#AT_STOP_10 2884#AT_START_11 2885at_fn_group_banner 11 'DDSTest.at:58' \ 2886 "DDS \$abs_srcdir/dds-testsuite/test.11.dds" " " 2887at_xfail=no 2888 test "" = "xfail" && at_xfail=yes 2889( 2890 $as_echo "11. $at_setup_line: testing $at_desc ..." 2891 $at_traceon 2892 2893 2894 2895 input=$abs_srcdir/dds-testsuite/test.11.dds 2896 baseline=$abs_srcdir/dds-testsuite/test.11.dds.base 2897 2898 if test -n "$baselines" -a x$baselines = xyes; then : 2899 2900 # The --baselines=yes option works only for tests that write to stdout 2901 { set +x 2902$as_echo "$at_srcdir/DDSTest.at:58: \$abs_builddir/dds-test -p < \$input || true" 2903at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:58" 2904( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2905) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2906at_status=$? at_failed=false 2907$at_check_filter 2908echo stderr:; cat "$at_stderr" 2909echo stdout:; tee stdout <"$at_stdout" 2910at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:58" 2911$at_failed && at_fn_log_failure 2912$at_traceon; } 2913 2914 { set +x 2915$as_echo "$at_srcdir/DDSTest.at:58: mv stdout \$baseline.tmp" 2916at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:58" 2917( $at_check_trace; mv stdout $baseline.tmp 2918) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2919at_status=$? at_failed=false 2920$at_check_filter 2921at_fn_diff_devnull "$at_stderr" || at_failed=: 2922at_fn_diff_devnull "$at_stdout" || at_failed=: 2923at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:58" 2924$at_failed && at_fn_log_failure 2925$at_traceon; } 2926 2927 2928else 2929 2930 # Added '|| true' to ensure the command returns '0' 2931 { set +x 2932$as_echo "$at_srcdir/DDSTest.at:58: \$abs_builddir/dds-test -p < \$input || true" 2933at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:58" 2934( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2935) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2936at_status=$? at_failed=false 2937$at_check_filter 2938echo stderr:; tee stderr <"$at_stderr" 2939echo stdout:; tee stdout <"$at_stdout" 2940at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:58" 2941$at_failed && at_fn_log_failure 2942$at_traceon; } 2943 2944 # Need to compare either stdout or stderr 2945 { set +x 2946$as_echo "$at_srcdir/DDSTest.at:58: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 2947at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:58" 2948( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 2949) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2950at_status=$? at_failed=false 2951$at_check_filter 2952at_fn_diff_devnull "$at_stderr" || at_failed=: 2953echo stdout:; cat "$at_stdout" 2954at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:58" 2955$at_failed && at_fn_log_failure 2956$at_traceon; } 2957 2958 2959 2960fi 2961 2962 set +x 2963 $at_times_p && times >"$at_times_file" 2964) 5>&1 2>&1 7>&- | eval $at_tee_pipe 2965read at_status <"$at_status_file" 2966#AT_STOP_11 2967#AT_START_12 2968at_fn_group_banner 12 'DDSTest.at:59' \ 2969 "DDS \$abs_srcdir/dds-testsuite/test.12.dds" " " 2970at_xfail=no 2971 test "" = "xfail" && at_xfail=yes 2972( 2973 $as_echo "12. $at_setup_line: testing $at_desc ..." 2974 $at_traceon 2975 2976 2977 2978 input=$abs_srcdir/dds-testsuite/test.12.dds 2979 baseline=$abs_srcdir/dds-testsuite/test.12.dds.base 2980 2981 if test -n "$baselines" -a x$baselines = xyes; then : 2982 2983 # The --baselines=yes option works only for tests that write to stdout 2984 { set +x 2985$as_echo "$at_srcdir/DDSTest.at:59: \$abs_builddir/dds-test -p < \$input || true" 2986at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:59" 2987( $at_check_trace; $abs_builddir/dds-test -p < $input || true 2988) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2989at_status=$? at_failed=false 2990$at_check_filter 2991echo stderr:; cat "$at_stderr" 2992echo stdout:; tee stdout <"$at_stdout" 2993at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:59" 2994$at_failed && at_fn_log_failure 2995$at_traceon; } 2996 2997 { set +x 2998$as_echo "$at_srcdir/DDSTest.at:59: mv stdout \$baseline.tmp" 2999at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:59" 3000( $at_check_trace; mv stdout $baseline.tmp 3001) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3002at_status=$? at_failed=false 3003$at_check_filter 3004at_fn_diff_devnull "$at_stderr" || at_failed=: 3005at_fn_diff_devnull "$at_stdout" || at_failed=: 3006at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:59" 3007$at_failed && at_fn_log_failure 3008$at_traceon; } 3009 3010 3011else 3012 3013 # Added '|| true' to ensure the command returns '0' 3014 { set +x 3015$as_echo "$at_srcdir/DDSTest.at:59: \$abs_builddir/dds-test -p < \$input || true" 3016at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:59" 3017( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3018) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3019at_status=$? at_failed=false 3020$at_check_filter 3021echo stderr:; tee stderr <"$at_stderr" 3022echo stdout:; tee stdout <"$at_stdout" 3023at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:59" 3024$at_failed && at_fn_log_failure 3025$at_traceon; } 3026 3027 # Need to compare either stdout or stderr 3028 { set +x 3029$as_echo "$at_srcdir/DDSTest.at:59: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 3030at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:59" 3031( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 3032) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3033at_status=$? at_failed=false 3034$at_check_filter 3035at_fn_diff_devnull "$at_stderr" || at_failed=: 3036echo stdout:; cat "$at_stdout" 3037at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:59" 3038$at_failed && at_fn_log_failure 3039$at_traceon; } 3040 3041 3042 3043fi 3044 3045 set +x 3046 $at_times_p && times >"$at_times_file" 3047) 5>&1 2>&1 7>&- | eval $at_tee_pipe 3048read at_status <"$at_status_file" 3049#AT_STOP_12 3050#AT_START_13 3051at_fn_group_banner 13 'DDSTest.at:60' \ 3052 "DDS \$abs_srcdir/dds-testsuite/test.13.dds" " " 3053at_xfail=no 3054 test "" = "xfail" && at_xfail=yes 3055( 3056 $as_echo "13. $at_setup_line: testing $at_desc ..." 3057 $at_traceon 3058 3059 3060 3061 input=$abs_srcdir/dds-testsuite/test.13.dds 3062 baseline=$abs_srcdir/dds-testsuite/test.13.dds.base 3063 3064 if test -n "$baselines" -a x$baselines = xyes; then : 3065 3066 # The --baselines=yes option works only for tests that write to stdout 3067 { set +x 3068$as_echo "$at_srcdir/DDSTest.at:60: \$abs_builddir/dds-test -p < \$input || true" 3069at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:60" 3070( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3071) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3072at_status=$? at_failed=false 3073$at_check_filter 3074echo stderr:; cat "$at_stderr" 3075echo stdout:; tee stdout <"$at_stdout" 3076at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:60" 3077$at_failed && at_fn_log_failure 3078$at_traceon; } 3079 3080 { set +x 3081$as_echo "$at_srcdir/DDSTest.at:60: mv stdout \$baseline.tmp" 3082at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:60" 3083( $at_check_trace; mv stdout $baseline.tmp 3084) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3085at_status=$? at_failed=false 3086$at_check_filter 3087at_fn_diff_devnull "$at_stderr" || at_failed=: 3088at_fn_diff_devnull "$at_stdout" || at_failed=: 3089at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:60" 3090$at_failed && at_fn_log_failure 3091$at_traceon; } 3092 3093 3094else 3095 3096 # Added '|| true' to ensure the command returns '0' 3097 { set +x 3098$as_echo "$at_srcdir/DDSTest.at:60: \$abs_builddir/dds-test -p < \$input || true" 3099at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:60" 3100( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3101) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3102at_status=$? at_failed=false 3103$at_check_filter 3104echo stderr:; tee stderr <"$at_stderr" 3105echo stdout:; tee stdout <"$at_stdout" 3106at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:60" 3107$at_failed && at_fn_log_failure 3108$at_traceon; } 3109 3110 # Need to compare either stdout or stderr 3111 { set +x 3112$as_echo "$at_srcdir/DDSTest.at:60: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 3113at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:60" 3114( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 3115) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3116at_status=$? at_failed=false 3117$at_check_filter 3118at_fn_diff_devnull "$at_stderr" || at_failed=: 3119echo stdout:; cat "$at_stdout" 3120at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:60" 3121$at_failed && at_fn_log_failure 3122$at_traceon; } 3123 3124 3125 3126fi 3127 3128 set +x 3129 $at_times_p && times >"$at_times_file" 3130) 5>&1 2>&1 7>&- | eval $at_tee_pipe 3131read at_status <"$at_status_file" 3132#AT_STOP_13 3133#AT_START_14 3134at_fn_group_banner 14 'DDSTest.at:61' \ 3135 "DDS \$abs_srcdir/dds-testsuite/test.14.dds" " " 3136at_xfail=no 3137 test "" = "xfail" && at_xfail=yes 3138( 3139 $as_echo "14. $at_setup_line: testing $at_desc ..." 3140 $at_traceon 3141 3142 3143 3144 input=$abs_srcdir/dds-testsuite/test.14.dds 3145 baseline=$abs_srcdir/dds-testsuite/test.14.dds.base 3146 3147 if test -n "$baselines" -a x$baselines = xyes; then : 3148 3149 # The --baselines=yes option works only for tests that write to stdout 3150 { set +x 3151$as_echo "$at_srcdir/DDSTest.at:61: \$abs_builddir/dds-test -p < \$input || true" 3152at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:61" 3153( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3154) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3155at_status=$? at_failed=false 3156$at_check_filter 3157echo stderr:; cat "$at_stderr" 3158echo stdout:; tee stdout <"$at_stdout" 3159at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:61" 3160$at_failed && at_fn_log_failure 3161$at_traceon; } 3162 3163 { set +x 3164$as_echo "$at_srcdir/DDSTest.at:61: mv stdout \$baseline.tmp" 3165at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:61" 3166( $at_check_trace; mv stdout $baseline.tmp 3167) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3168at_status=$? at_failed=false 3169$at_check_filter 3170at_fn_diff_devnull "$at_stderr" || at_failed=: 3171at_fn_diff_devnull "$at_stdout" || at_failed=: 3172at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:61" 3173$at_failed && at_fn_log_failure 3174$at_traceon; } 3175 3176 3177else 3178 3179 # Added '|| true' to ensure the command returns '0' 3180 { set +x 3181$as_echo "$at_srcdir/DDSTest.at:61: \$abs_builddir/dds-test -p < \$input || true" 3182at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:61" 3183( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3184) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3185at_status=$? at_failed=false 3186$at_check_filter 3187echo stderr:; tee stderr <"$at_stderr" 3188echo stdout:; tee stdout <"$at_stdout" 3189at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:61" 3190$at_failed && at_fn_log_failure 3191$at_traceon; } 3192 3193 # Need to compare either stdout or stderr 3194 { set +x 3195$as_echo "$at_srcdir/DDSTest.at:61: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 3196at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:61" 3197( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 3198) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3199at_status=$? at_failed=false 3200$at_check_filter 3201at_fn_diff_devnull "$at_stderr" || at_failed=: 3202echo stdout:; cat "$at_stdout" 3203at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:61" 3204$at_failed && at_fn_log_failure 3205$at_traceon; } 3206 3207 3208 3209fi 3210 3211 set +x 3212 $at_times_p && times >"$at_times_file" 3213) 5>&1 2>&1 7>&- | eval $at_tee_pipe 3214read at_status <"$at_status_file" 3215#AT_STOP_14 3216#AT_START_15 3217at_fn_group_banner 15 'DDSTest.at:62' \ 3218 "DDS \$abs_srcdir/dds-testsuite/test.15.dds" " " 3219at_xfail=no 3220 test "" = "xfail" && at_xfail=yes 3221( 3222 $as_echo "15. $at_setup_line: testing $at_desc ..." 3223 $at_traceon 3224 3225 3226 3227 input=$abs_srcdir/dds-testsuite/test.15.dds 3228 baseline=$abs_srcdir/dds-testsuite/test.15.dds.base 3229 3230 if test -n "$baselines" -a x$baselines = xyes; then : 3231 3232 # The --baselines=yes option works only for tests that write to stdout 3233 { set +x 3234$as_echo "$at_srcdir/DDSTest.at:62: \$abs_builddir/dds-test -p < \$input || true" 3235at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:62" 3236( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3237) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3238at_status=$? at_failed=false 3239$at_check_filter 3240echo stderr:; cat "$at_stderr" 3241echo stdout:; tee stdout <"$at_stdout" 3242at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:62" 3243$at_failed && at_fn_log_failure 3244$at_traceon; } 3245 3246 { set +x 3247$as_echo "$at_srcdir/DDSTest.at:62: mv stdout \$baseline.tmp" 3248at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:62" 3249( $at_check_trace; mv stdout $baseline.tmp 3250) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3251at_status=$? at_failed=false 3252$at_check_filter 3253at_fn_diff_devnull "$at_stderr" || at_failed=: 3254at_fn_diff_devnull "$at_stdout" || at_failed=: 3255at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:62" 3256$at_failed && at_fn_log_failure 3257$at_traceon; } 3258 3259 3260else 3261 3262 # Added '|| true' to ensure the command returns '0' 3263 { set +x 3264$as_echo "$at_srcdir/DDSTest.at:62: \$abs_builddir/dds-test -p < \$input || true" 3265at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:62" 3266( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3267) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3268at_status=$? at_failed=false 3269$at_check_filter 3270echo stderr:; tee stderr <"$at_stderr" 3271echo stdout:; tee stdout <"$at_stdout" 3272at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:62" 3273$at_failed && at_fn_log_failure 3274$at_traceon; } 3275 3276 # Need to compare either stdout or stderr 3277 { set +x 3278$as_echo "$at_srcdir/DDSTest.at:62: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 3279at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:62" 3280( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 3281) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3282at_status=$? at_failed=false 3283$at_check_filter 3284at_fn_diff_devnull "$at_stderr" || at_failed=: 3285echo stdout:; cat "$at_stdout" 3286at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:62" 3287$at_failed && at_fn_log_failure 3288$at_traceon; } 3289 3290 3291 3292fi 3293 3294 set +x 3295 $at_times_p && times >"$at_times_file" 3296) 5>&1 2>&1 7>&- | eval $at_tee_pipe 3297read at_status <"$at_status_file" 3298#AT_STOP_15 3299#AT_START_16 3300at_fn_group_banner 16 'DDSTest.at:63' \ 3301 "DDS \$abs_srcdir/dds-testsuite/test.16.dds" " " 3302at_xfail=no 3303 test "" = "xfail" && at_xfail=yes 3304( 3305 $as_echo "16. $at_setup_line: testing $at_desc ..." 3306 $at_traceon 3307 3308 3309 3310 input=$abs_srcdir/dds-testsuite/test.16.dds 3311 baseline=$abs_srcdir/dds-testsuite/test.16.dds.base 3312 3313 if test -n "$baselines" -a x$baselines = xyes; then : 3314 3315 # The --baselines=yes option works only for tests that write to stdout 3316 { set +x 3317$as_echo "$at_srcdir/DDSTest.at:63: \$abs_builddir/dds-test -p < \$input || true" 3318at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:63" 3319( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3320) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3321at_status=$? at_failed=false 3322$at_check_filter 3323echo stderr:; cat "$at_stderr" 3324echo stdout:; tee stdout <"$at_stdout" 3325at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:63" 3326$at_failed && at_fn_log_failure 3327$at_traceon; } 3328 3329 { set +x 3330$as_echo "$at_srcdir/DDSTest.at:63: mv stdout \$baseline.tmp" 3331at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:63" 3332( $at_check_trace; mv stdout $baseline.tmp 3333) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3334at_status=$? at_failed=false 3335$at_check_filter 3336at_fn_diff_devnull "$at_stderr" || at_failed=: 3337at_fn_diff_devnull "$at_stdout" || at_failed=: 3338at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:63" 3339$at_failed && at_fn_log_failure 3340$at_traceon; } 3341 3342 3343else 3344 3345 # Added '|| true' to ensure the command returns '0' 3346 { set +x 3347$as_echo "$at_srcdir/DDSTest.at:63: \$abs_builddir/dds-test -p < \$input || true" 3348at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:63" 3349( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3350) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3351at_status=$? at_failed=false 3352$at_check_filter 3353echo stderr:; tee stderr <"$at_stderr" 3354echo stdout:; tee stdout <"$at_stdout" 3355at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:63" 3356$at_failed && at_fn_log_failure 3357$at_traceon; } 3358 3359 # Need to compare either stdout or stderr 3360 { set +x 3361$as_echo "$at_srcdir/DDSTest.at:63: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 3362at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:63" 3363( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 3364) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3365at_status=$? at_failed=false 3366$at_check_filter 3367at_fn_diff_devnull "$at_stderr" || at_failed=: 3368echo stdout:; cat "$at_stdout" 3369at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:63" 3370$at_failed && at_fn_log_failure 3371$at_traceon; } 3372 3373 3374 3375fi 3376 3377 set +x 3378 $at_times_p && times >"$at_times_file" 3379) 5>&1 2>&1 7>&- | eval $at_tee_pipe 3380read at_status <"$at_status_file" 3381#AT_STOP_16 3382#AT_START_17 3383at_fn_group_banner 17 'DDSTest.at:64' \ 3384 "DDS \$abs_srcdir/dds-testsuite/test.17.dds" " " 3385at_xfail=no 3386 test "" = "xfail" && at_xfail=yes 3387( 3388 $as_echo "17. $at_setup_line: testing $at_desc ..." 3389 $at_traceon 3390 3391 3392 3393 input=$abs_srcdir/dds-testsuite/test.17.dds 3394 baseline=$abs_srcdir/dds-testsuite/test.17.dds.base 3395 3396 if test -n "$baselines" -a x$baselines = xyes; then : 3397 3398 # The --baselines=yes option works only for tests that write to stdout 3399 { set +x 3400$as_echo "$at_srcdir/DDSTest.at:64: \$abs_builddir/dds-test -p < \$input || true" 3401at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:64" 3402( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3403) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3404at_status=$? at_failed=false 3405$at_check_filter 3406echo stderr:; cat "$at_stderr" 3407echo stdout:; tee stdout <"$at_stdout" 3408at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:64" 3409$at_failed && at_fn_log_failure 3410$at_traceon; } 3411 3412 { set +x 3413$as_echo "$at_srcdir/DDSTest.at:64: mv stdout \$baseline.tmp" 3414at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:64" 3415( $at_check_trace; mv stdout $baseline.tmp 3416) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3417at_status=$? at_failed=false 3418$at_check_filter 3419at_fn_diff_devnull "$at_stderr" || at_failed=: 3420at_fn_diff_devnull "$at_stdout" || at_failed=: 3421at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:64" 3422$at_failed && at_fn_log_failure 3423$at_traceon; } 3424 3425 3426else 3427 3428 # Added '|| true' to ensure the command returns '0' 3429 { set +x 3430$as_echo "$at_srcdir/DDSTest.at:64: \$abs_builddir/dds-test -p < \$input || true" 3431at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:64" 3432( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3433) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3434at_status=$? at_failed=false 3435$at_check_filter 3436echo stderr:; tee stderr <"$at_stderr" 3437echo stdout:; tee stdout <"$at_stdout" 3438at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:64" 3439$at_failed && at_fn_log_failure 3440$at_traceon; } 3441 3442 # Need to compare either stdout or stderr 3443 { set +x 3444$as_echo "$at_srcdir/DDSTest.at:64: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 3445at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:64" 3446( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 3447) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3448at_status=$? at_failed=false 3449$at_check_filter 3450at_fn_diff_devnull "$at_stderr" || at_failed=: 3451echo stdout:; cat "$at_stdout" 3452at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:64" 3453$at_failed && at_fn_log_failure 3454$at_traceon; } 3455 3456 3457 3458fi 3459 3460 set +x 3461 $at_times_p && times >"$at_times_file" 3462) 5>&1 2>&1 7>&- | eval $at_tee_pipe 3463read at_status <"$at_status_file" 3464#AT_STOP_17 3465#AT_START_18 3466at_fn_group_banner 18 'DDSTest.at:65' \ 3467 "DDS \$abs_srcdir/dds-testsuite/test.18.dds" " " 3468at_xfail=no 3469 test "" = "xfail" && at_xfail=yes 3470( 3471 $as_echo "18. $at_setup_line: testing $at_desc ..." 3472 $at_traceon 3473 3474 3475 3476 input=$abs_srcdir/dds-testsuite/test.18.dds 3477 baseline=$abs_srcdir/dds-testsuite/test.18.dds.base 3478 3479 if test -n "$baselines" -a x$baselines = xyes; then : 3480 3481 # The --baselines=yes option works only for tests that write to stdout 3482 { set +x 3483$as_echo "$at_srcdir/DDSTest.at:65: \$abs_builddir/dds-test -p < \$input || true" 3484at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:65" 3485( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3486) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3487at_status=$? at_failed=false 3488$at_check_filter 3489echo stderr:; cat "$at_stderr" 3490echo stdout:; tee stdout <"$at_stdout" 3491at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:65" 3492$at_failed && at_fn_log_failure 3493$at_traceon; } 3494 3495 { set +x 3496$as_echo "$at_srcdir/DDSTest.at:65: mv stdout \$baseline.tmp" 3497at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:65" 3498( $at_check_trace; mv stdout $baseline.tmp 3499) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3500at_status=$? at_failed=false 3501$at_check_filter 3502at_fn_diff_devnull "$at_stderr" || at_failed=: 3503at_fn_diff_devnull "$at_stdout" || at_failed=: 3504at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:65" 3505$at_failed && at_fn_log_failure 3506$at_traceon; } 3507 3508 3509else 3510 3511 # Added '|| true' to ensure the command returns '0' 3512 { set +x 3513$as_echo "$at_srcdir/DDSTest.at:65: \$abs_builddir/dds-test -p < \$input || true" 3514at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:65" 3515( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3516) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3517at_status=$? at_failed=false 3518$at_check_filter 3519echo stderr:; tee stderr <"$at_stderr" 3520echo stdout:; tee stdout <"$at_stdout" 3521at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:65" 3522$at_failed && at_fn_log_failure 3523$at_traceon; } 3524 3525 # Need to compare either stdout or stderr 3526 { set +x 3527$as_echo "$at_srcdir/DDSTest.at:65: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 3528at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:65" 3529( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 3530) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3531at_status=$? at_failed=false 3532$at_check_filter 3533at_fn_diff_devnull "$at_stderr" || at_failed=: 3534echo stdout:; cat "$at_stdout" 3535at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:65" 3536$at_failed && at_fn_log_failure 3537$at_traceon; } 3538 3539 3540 3541fi 3542 3543 set +x 3544 $at_times_p && times >"$at_times_file" 3545) 5>&1 2>&1 7>&- | eval $at_tee_pipe 3546read at_status <"$at_status_file" 3547#AT_STOP_18 3548#AT_START_19 3549at_fn_group_banner 19 'DDSTest.at:66' \ 3550 "DDS \$abs_srcdir/dds-testsuite/test.19.dds" " " 3551at_xfail=no 3552 test "" = "xfail" && at_xfail=yes 3553( 3554 $as_echo "19. $at_setup_line: testing $at_desc ..." 3555 $at_traceon 3556 3557 3558 3559 input=$abs_srcdir/dds-testsuite/test.19.dds 3560 baseline=$abs_srcdir/dds-testsuite/test.19.dds.base 3561 3562 if test -n "$baselines" -a x$baselines = xyes; then : 3563 3564 # The --baselines=yes option works only for tests that write to stdout 3565 { set +x 3566$as_echo "$at_srcdir/DDSTest.at:66: \$abs_builddir/dds-test -p < \$input || true" 3567at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:66" 3568( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3569) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3570at_status=$? at_failed=false 3571$at_check_filter 3572echo stderr:; cat "$at_stderr" 3573echo stdout:; tee stdout <"$at_stdout" 3574at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:66" 3575$at_failed && at_fn_log_failure 3576$at_traceon; } 3577 3578 { set +x 3579$as_echo "$at_srcdir/DDSTest.at:66: mv stdout \$baseline.tmp" 3580at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:66" 3581( $at_check_trace; mv stdout $baseline.tmp 3582) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3583at_status=$? at_failed=false 3584$at_check_filter 3585at_fn_diff_devnull "$at_stderr" || at_failed=: 3586at_fn_diff_devnull "$at_stdout" || at_failed=: 3587at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:66" 3588$at_failed && at_fn_log_failure 3589$at_traceon; } 3590 3591 3592else 3593 3594 # Added '|| true' to ensure the command returns '0' 3595 { set +x 3596$as_echo "$at_srcdir/DDSTest.at:66: \$abs_builddir/dds-test -p < \$input || true" 3597at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:66" 3598( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3599) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3600at_status=$? at_failed=false 3601$at_check_filter 3602echo stderr:; tee stderr <"$at_stderr" 3603echo stdout:; tee stdout <"$at_stdout" 3604at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:66" 3605$at_failed && at_fn_log_failure 3606$at_traceon; } 3607 3608 # Need to compare either stdout or stderr 3609 { set +x 3610$as_echo "$at_srcdir/DDSTest.at:66: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 3611at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:66" 3612( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 3613) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3614at_status=$? at_failed=false 3615$at_check_filter 3616at_fn_diff_devnull "$at_stderr" || at_failed=: 3617echo stdout:; cat "$at_stdout" 3618at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:66" 3619$at_failed && at_fn_log_failure 3620$at_traceon; } 3621 3622 3623 3624fi 3625 3626 set +x 3627 $at_times_p && times >"$at_times_file" 3628) 5>&1 2>&1 7>&- | eval $at_tee_pipe 3629read at_status <"$at_status_file" 3630#AT_STOP_19 3631#AT_START_20 3632at_fn_group_banner 20 'DDSTest.at:67' \ 3633 "DDS \$abs_srcdir/dds-testsuite/test.19b.das.dds" " " 3634at_xfail=no 3635 test "" = "xfail" && at_xfail=yes 3636( 3637 $as_echo "20. $at_setup_line: testing $at_desc ..." 3638 $at_traceon 3639 3640 3641 3642 input=$abs_srcdir/dds-testsuite/test.19b.das.dds 3643 baseline=$abs_srcdir/dds-testsuite/test.19b.das.dds.base 3644 3645 if test -n "$baselines" -a x$baselines = xyes; then : 3646 3647 # The --baselines=yes option works only for tests that write to stdout 3648 { set +x 3649$as_echo "$at_srcdir/DDSTest.at:67: \$abs_builddir/dds-test -p < \$input || true" 3650at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:67" 3651( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3652) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3653at_status=$? at_failed=false 3654$at_check_filter 3655echo stderr:; cat "$at_stderr" 3656echo stdout:; tee stdout <"$at_stdout" 3657at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:67" 3658$at_failed && at_fn_log_failure 3659$at_traceon; } 3660 3661 { set +x 3662$as_echo "$at_srcdir/DDSTest.at:67: mv stdout \$baseline.tmp" 3663at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:67" 3664( $at_check_trace; mv stdout $baseline.tmp 3665) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3666at_status=$? at_failed=false 3667$at_check_filter 3668at_fn_diff_devnull "$at_stderr" || at_failed=: 3669at_fn_diff_devnull "$at_stdout" || at_failed=: 3670at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:67" 3671$at_failed && at_fn_log_failure 3672$at_traceon; } 3673 3674 3675else 3676 3677 # Added '|| true' to ensure the command returns '0' 3678 { set +x 3679$as_echo "$at_srcdir/DDSTest.at:67: \$abs_builddir/dds-test -p < \$input || true" 3680at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:67" 3681( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3682) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3683at_status=$? at_failed=false 3684$at_check_filter 3685echo stderr:; tee stderr <"$at_stderr" 3686echo stdout:; tee stdout <"$at_stdout" 3687at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:67" 3688$at_failed && at_fn_log_failure 3689$at_traceon; } 3690 3691 # Need to compare either stdout or stderr 3692 { set +x 3693$as_echo "$at_srcdir/DDSTest.at:67: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 3694at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:67" 3695( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 3696) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3697at_status=$? at_failed=false 3698$at_check_filter 3699at_fn_diff_devnull "$at_stderr" || at_failed=: 3700echo stdout:; cat "$at_stdout" 3701at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:67" 3702$at_failed && at_fn_log_failure 3703$at_traceon; } 3704 3705 3706 3707fi 3708 3709 set +x 3710 $at_times_p && times >"$at_times_file" 3711) 5>&1 2>&1 7>&- | eval $at_tee_pipe 3712read at_status <"$at_status_file" 3713#AT_STOP_20 3714#AT_START_21 3715at_fn_group_banner 21 'DDSTest.at:68' \ 3716 "DDS \$abs_srcdir/dds-testsuite/test.19b.dds" " " 3717at_xfail=no 3718 test "" = "xfail" && at_xfail=yes 3719( 3720 $as_echo "21. $at_setup_line: testing $at_desc ..." 3721 $at_traceon 3722 3723 3724 3725 input=$abs_srcdir/dds-testsuite/test.19b.dds 3726 baseline=$abs_srcdir/dds-testsuite/test.19b.dds.base 3727 3728 if test -n "$baselines" -a x$baselines = xyes; then : 3729 3730 # The --baselines=yes option works only for tests that write to stdout 3731 { set +x 3732$as_echo "$at_srcdir/DDSTest.at:68: \$abs_builddir/dds-test -p < \$input || true" 3733at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:68" 3734( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3735) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3736at_status=$? at_failed=false 3737$at_check_filter 3738echo stderr:; cat "$at_stderr" 3739echo stdout:; tee stdout <"$at_stdout" 3740at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:68" 3741$at_failed && at_fn_log_failure 3742$at_traceon; } 3743 3744 { set +x 3745$as_echo "$at_srcdir/DDSTest.at:68: mv stdout \$baseline.tmp" 3746at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:68" 3747( $at_check_trace; mv stdout $baseline.tmp 3748) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3749at_status=$? at_failed=false 3750$at_check_filter 3751at_fn_diff_devnull "$at_stderr" || at_failed=: 3752at_fn_diff_devnull "$at_stdout" || at_failed=: 3753at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:68" 3754$at_failed && at_fn_log_failure 3755$at_traceon; } 3756 3757 3758else 3759 3760 # Added '|| true' to ensure the command returns '0' 3761 { set +x 3762$as_echo "$at_srcdir/DDSTest.at:68: \$abs_builddir/dds-test -p < \$input || true" 3763at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:68" 3764( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3765) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3766at_status=$? at_failed=false 3767$at_check_filter 3768echo stderr:; tee stderr <"$at_stderr" 3769echo stdout:; tee stdout <"$at_stdout" 3770at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:68" 3771$at_failed && at_fn_log_failure 3772$at_traceon; } 3773 3774 # Need to compare either stdout or stderr 3775 { set +x 3776$as_echo "$at_srcdir/DDSTest.at:68: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 3777at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:68" 3778( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 3779) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3780at_status=$? at_failed=false 3781$at_check_filter 3782at_fn_diff_devnull "$at_stderr" || at_failed=: 3783echo stdout:; cat "$at_stdout" 3784at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:68" 3785$at_failed && at_fn_log_failure 3786$at_traceon; } 3787 3788 3789 3790fi 3791 3792 set +x 3793 $at_times_p && times >"$at_times_file" 3794) 5>&1 2>&1 7>&- | eval $at_tee_pipe 3795read at_status <"$at_status_file" 3796#AT_STOP_21 3797#AT_START_22 3798at_fn_group_banner 22 'DDSTest.at:69' \ 3799 "DDS \$abs_srcdir/dds-testsuite/test.2.dds" " " 3800at_xfail=no 3801 test "" = "xfail" && at_xfail=yes 3802( 3803 $as_echo "22. $at_setup_line: testing $at_desc ..." 3804 $at_traceon 3805 3806 3807 3808 input=$abs_srcdir/dds-testsuite/test.2.dds 3809 baseline=$abs_srcdir/dds-testsuite/test.2.dds.base 3810 3811 if test -n "$baselines" -a x$baselines = xyes; then : 3812 3813 # The --baselines=yes option works only for tests that write to stdout 3814 { set +x 3815$as_echo "$at_srcdir/DDSTest.at:69: \$abs_builddir/dds-test -p < \$input || true" 3816at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:69" 3817( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3818) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3819at_status=$? at_failed=false 3820$at_check_filter 3821echo stderr:; cat "$at_stderr" 3822echo stdout:; tee stdout <"$at_stdout" 3823at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:69" 3824$at_failed && at_fn_log_failure 3825$at_traceon; } 3826 3827 { set +x 3828$as_echo "$at_srcdir/DDSTest.at:69: mv stdout \$baseline.tmp" 3829at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:69" 3830( $at_check_trace; mv stdout $baseline.tmp 3831) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3832at_status=$? at_failed=false 3833$at_check_filter 3834at_fn_diff_devnull "$at_stderr" || at_failed=: 3835at_fn_diff_devnull "$at_stdout" || at_failed=: 3836at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:69" 3837$at_failed && at_fn_log_failure 3838$at_traceon; } 3839 3840 3841else 3842 3843 # Added '|| true' to ensure the command returns '0' 3844 { set +x 3845$as_echo "$at_srcdir/DDSTest.at:69: \$abs_builddir/dds-test -p < \$input || true" 3846at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:69" 3847( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3848) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3849at_status=$? at_failed=false 3850$at_check_filter 3851echo stderr:; tee stderr <"$at_stderr" 3852echo stdout:; tee stdout <"$at_stdout" 3853at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:69" 3854$at_failed && at_fn_log_failure 3855$at_traceon; } 3856 3857 # Need to compare either stdout or stderr 3858 { set +x 3859$as_echo "$at_srcdir/DDSTest.at:69: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 3860at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:69" 3861( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 3862) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3863at_status=$? at_failed=false 3864$at_check_filter 3865at_fn_diff_devnull "$at_stderr" || at_failed=: 3866echo stdout:; cat "$at_stdout" 3867at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:69" 3868$at_failed && at_fn_log_failure 3869$at_traceon; } 3870 3871 3872 3873fi 3874 3875 set +x 3876 $at_times_p && times >"$at_times_file" 3877) 5>&1 2>&1 7>&- | eval $at_tee_pipe 3878read at_status <"$at_status_file" 3879#AT_STOP_22 3880#AT_START_23 3881at_fn_group_banner 23 'DDSTest.at:70' \ 3882 "DDS \$abs_srcdir/dds-testsuite/test.20.dds" " " 3883at_xfail=no 3884 test "" = "xfail" && at_xfail=yes 3885( 3886 $as_echo "23. $at_setup_line: testing $at_desc ..." 3887 $at_traceon 3888 3889 3890 3891 input=$abs_srcdir/dds-testsuite/test.20.dds 3892 baseline=$abs_srcdir/dds-testsuite/test.20.dds.base 3893 3894 if test -n "$baselines" -a x$baselines = xyes; then : 3895 3896 # The --baselines=yes option works only for tests that write to stdout 3897 { set +x 3898$as_echo "$at_srcdir/DDSTest.at:70: \$abs_builddir/dds-test -p < \$input || true" 3899at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:70" 3900( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3901) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3902at_status=$? at_failed=false 3903$at_check_filter 3904echo stderr:; cat "$at_stderr" 3905echo stdout:; tee stdout <"$at_stdout" 3906at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:70" 3907$at_failed && at_fn_log_failure 3908$at_traceon; } 3909 3910 { set +x 3911$as_echo "$at_srcdir/DDSTest.at:70: mv stdout \$baseline.tmp" 3912at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:70" 3913( $at_check_trace; mv stdout $baseline.tmp 3914) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3915at_status=$? at_failed=false 3916$at_check_filter 3917at_fn_diff_devnull "$at_stderr" || at_failed=: 3918at_fn_diff_devnull "$at_stdout" || at_failed=: 3919at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:70" 3920$at_failed && at_fn_log_failure 3921$at_traceon; } 3922 3923 3924else 3925 3926 # Added '|| true' to ensure the command returns '0' 3927 { set +x 3928$as_echo "$at_srcdir/DDSTest.at:70: \$abs_builddir/dds-test -p < \$input || true" 3929at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:70" 3930( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3931) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3932at_status=$? at_failed=false 3933$at_check_filter 3934echo stderr:; tee stderr <"$at_stderr" 3935echo stdout:; tee stdout <"$at_stdout" 3936at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:70" 3937$at_failed && at_fn_log_failure 3938$at_traceon; } 3939 3940 # Need to compare either stdout or stderr 3941 { set +x 3942$as_echo "$at_srcdir/DDSTest.at:70: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 3943at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:70" 3944( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 3945) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3946at_status=$? at_failed=false 3947$at_check_filter 3948at_fn_diff_devnull "$at_stderr" || at_failed=: 3949echo stdout:; cat "$at_stdout" 3950at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:70" 3951$at_failed && at_fn_log_failure 3952$at_traceon; } 3953 3954 3955 3956fi 3957 3958 set +x 3959 $at_times_p && times >"$at_times_file" 3960) 5>&1 2>&1 7>&- | eval $at_tee_pipe 3961read at_status <"$at_status_file" 3962#AT_STOP_23 3963#AT_START_24 3964at_fn_group_banner 24 'DDSTest.at:71' \ 3965 "DDS \$abs_srcdir/dds-testsuite/test.3.dds" " " 3966at_xfail=no 3967 test "" = "xfail" && at_xfail=yes 3968( 3969 $as_echo "24. $at_setup_line: testing $at_desc ..." 3970 $at_traceon 3971 3972 3973 3974 input=$abs_srcdir/dds-testsuite/test.3.dds 3975 baseline=$abs_srcdir/dds-testsuite/test.3.dds.base 3976 3977 if test -n "$baselines" -a x$baselines = xyes; then : 3978 3979 # The --baselines=yes option works only for tests that write to stdout 3980 { set +x 3981$as_echo "$at_srcdir/DDSTest.at:71: \$abs_builddir/dds-test -p < \$input || true" 3982at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:71" 3983( $at_check_trace; $abs_builddir/dds-test -p < $input || true 3984) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3985at_status=$? at_failed=false 3986$at_check_filter 3987echo stderr:; cat "$at_stderr" 3988echo stdout:; tee stdout <"$at_stdout" 3989at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:71" 3990$at_failed && at_fn_log_failure 3991$at_traceon; } 3992 3993 { set +x 3994$as_echo "$at_srcdir/DDSTest.at:71: mv stdout \$baseline.tmp" 3995at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:71" 3996( $at_check_trace; mv stdout $baseline.tmp 3997) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3998at_status=$? at_failed=false 3999$at_check_filter 4000at_fn_diff_devnull "$at_stderr" || at_failed=: 4001at_fn_diff_devnull "$at_stdout" || at_failed=: 4002at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:71" 4003$at_failed && at_fn_log_failure 4004$at_traceon; } 4005 4006 4007else 4008 4009 # Added '|| true' to ensure the command returns '0' 4010 { set +x 4011$as_echo "$at_srcdir/DDSTest.at:71: \$abs_builddir/dds-test -p < \$input || true" 4012at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:71" 4013( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4014) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4015at_status=$? at_failed=false 4016$at_check_filter 4017echo stderr:; tee stderr <"$at_stderr" 4018echo stdout:; tee stdout <"$at_stdout" 4019at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:71" 4020$at_failed && at_fn_log_failure 4021$at_traceon; } 4022 4023 # Need to compare either stdout or stderr 4024 { set +x 4025$as_echo "$at_srcdir/DDSTest.at:71: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 4026at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:71" 4027( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 4028) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4029at_status=$? at_failed=false 4030$at_check_filter 4031at_fn_diff_devnull "$at_stderr" || at_failed=: 4032echo stdout:; cat "$at_stdout" 4033at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:71" 4034$at_failed && at_fn_log_failure 4035$at_traceon; } 4036 4037 4038 4039fi 4040 4041 set +x 4042 $at_times_p && times >"$at_times_file" 4043) 5>&1 2>&1 7>&- | eval $at_tee_pipe 4044read at_status <"$at_status_file" 4045#AT_STOP_24 4046#AT_START_25 4047at_fn_group_banner 25 'DDSTest.at:72' \ 4048 "DDS \$abs_srcdir/dds-testsuite/test.4.dds" " " 4049at_xfail=no 4050 test "" = "xfail" && at_xfail=yes 4051( 4052 $as_echo "25. $at_setup_line: testing $at_desc ..." 4053 $at_traceon 4054 4055 4056 4057 input=$abs_srcdir/dds-testsuite/test.4.dds 4058 baseline=$abs_srcdir/dds-testsuite/test.4.dds.base 4059 4060 if test -n "$baselines" -a x$baselines = xyes; then : 4061 4062 # The --baselines=yes option works only for tests that write to stdout 4063 { set +x 4064$as_echo "$at_srcdir/DDSTest.at:72: \$abs_builddir/dds-test -p < \$input || true" 4065at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:72" 4066( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4067) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4068at_status=$? at_failed=false 4069$at_check_filter 4070echo stderr:; cat "$at_stderr" 4071echo stdout:; tee stdout <"$at_stdout" 4072at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:72" 4073$at_failed && at_fn_log_failure 4074$at_traceon; } 4075 4076 { set +x 4077$as_echo "$at_srcdir/DDSTest.at:72: mv stdout \$baseline.tmp" 4078at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:72" 4079( $at_check_trace; mv stdout $baseline.tmp 4080) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4081at_status=$? at_failed=false 4082$at_check_filter 4083at_fn_diff_devnull "$at_stderr" || at_failed=: 4084at_fn_diff_devnull "$at_stdout" || at_failed=: 4085at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:72" 4086$at_failed && at_fn_log_failure 4087$at_traceon; } 4088 4089 4090else 4091 4092 # Added '|| true' to ensure the command returns '0' 4093 { set +x 4094$as_echo "$at_srcdir/DDSTest.at:72: \$abs_builddir/dds-test -p < \$input || true" 4095at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:72" 4096( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4097) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4098at_status=$? at_failed=false 4099$at_check_filter 4100echo stderr:; tee stderr <"$at_stderr" 4101echo stdout:; tee stdout <"$at_stdout" 4102at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:72" 4103$at_failed && at_fn_log_failure 4104$at_traceon; } 4105 4106 # Need to compare either stdout or stderr 4107 { set +x 4108$as_echo "$at_srcdir/DDSTest.at:72: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 4109at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:72" 4110( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 4111) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4112at_status=$? at_failed=false 4113$at_check_filter 4114at_fn_diff_devnull "$at_stderr" || at_failed=: 4115echo stdout:; cat "$at_stdout" 4116at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:72" 4117$at_failed && at_fn_log_failure 4118$at_traceon; } 4119 4120 4121 4122fi 4123 4124 set +x 4125 $at_times_p && times >"$at_times_file" 4126) 5>&1 2>&1 7>&- | eval $at_tee_pipe 4127read at_status <"$at_status_file" 4128#AT_STOP_25 4129#AT_START_26 4130at_fn_group_banner 26 'DDSTest.at:73' \ 4131 "DDS \$abs_srcdir/dds-testsuite/test.6.dds" " " 4132at_xfail=no 4133 test "" = "xfail" && at_xfail=yes 4134( 4135 $as_echo "26. $at_setup_line: testing $at_desc ..." 4136 $at_traceon 4137 4138 4139 4140 input=$abs_srcdir/dds-testsuite/test.6.dds 4141 baseline=$abs_srcdir/dds-testsuite/test.6.dds.base 4142 4143 if test -n "$baselines" -a x$baselines = xyes; then : 4144 4145 # The --baselines=yes option works only for tests that write to stdout 4146 { set +x 4147$as_echo "$at_srcdir/DDSTest.at:73: \$abs_builddir/dds-test -p < \$input || true" 4148at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:73" 4149( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4150) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4151at_status=$? at_failed=false 4152$at_check_filter 4153echo stderr:; cat "$at_stderr" 4154echo stdout:; tee stdout <"$at_stdout" 4155at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:73" 4156$at_failed && at_fn_log_failure 4157$at_traceon; } 4158 4159 { set +x 4160$as_echo "$at_srcdir/DDSTest.at:73: mv stdout \$baseline.tmp" 4161at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:73" 4162( $at_check_trace; mv stdout $baseline.tmp 4163) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4164at_status=$? at_failed=false 4165$at_check_filter 4166at_fn_diff_devnull "$at_stderr" || at_failed=: 4167at_fn_diff_devnull "$at_stdout" || at_failed=: 4168at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:73" 4169$at_failed && at_fn_log_failure 4170$at_traceon; } 4171 4172 4173else 4174 4175 # Added '|| true' to ensure the command returns '0' 4176 { set +x 4177$as_echo "$at_srcdir/DDSTest.at:73: \$abs_builddir/dds-test -p < \$input || true" 4178at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:73" 4179( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4180) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4181at_status=$? at_failed=false 4182$at_check_filter 4183echo stderr:; tee stderr <"$at_stderr" 4184echo stdout:; tee stdout <"$at_stdout" 4185at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:73" 4186$at_failed && at_fn_log_failure 4187$at_traceon; } 4188 4189 # Need to compare either stdout or stderr 4190 { set +x 4191$as_echo "$at_srcdir/DDSTest.at:73: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 4192at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:73" 4193( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 4194) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4195at_status=$? at_failed=false 4196$at_check_filter 4197at_fn_diff_devnull "$at_stderr" || at_failed=: 4198echo stdout:; cat "$at_stdout" 4199at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:73" 4200$at_failed && at_fn_log_failure 4201$at_traceon; } 4202 4203 4204 4205fi 4206 4207 set +x 4208 $at_times_p && times >"$at_times_file" 4209) 5>&1 2>&1 7>&- | eval $at_tee_pipe 4210read at_status <"$at_status_file" 4211#AT_STOP_26 4212#AT_START_27 4213at_fn_group_banner 27 'DDSTest.at:74' \ 4214 "DDS \$abs_srcdir/dds-testsuite/test.7.dds" " " 4215at_xfail=no 4216 test "" = "xfail" && at_xfail=yes 4217( 4218 $as_echo "27. $at_setup_line: testing $at_desc ..." 4219 $at_traceon 4220 4221 4222 4223 input=$abs_srcdir/dds-testsuite/test.7.dds 4224 baseline=$abs_srcdir/dds-testsuite/test.7.dds.base 4225 4226 if test -n "$baselines" -a x$baselines = xyes; then : 4227 4228 # The --baselines=yes option works only for tests that write to stdout 4229 { set +x 4230$as_echo "$at_srcdir/DDSTest.at:74: \$abs_builddir/dds-test -p < \$input || true" 4231at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:74" 4232( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4233) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4234at_status=$? at_failed=false 4235$at_check_filter 4236echo stderr:; cat "$at_stderr" 4237echo stdout:; tee stdout <"$at_stdout" 4238at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:74" 4239$at_failed && at_fn_log_failure 4240$at_traceon; } 4241 4242 { set +x 4243$as_echo "$at_srcdir/DDSTest.at:74: mv stdout \$baseline.tmp" 4244at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:74" 4245( $at_check_trace; mv stdout $baseline.tmp 4246) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4247at_status=$? at_failed=false 4248$at_check_filter 4249at_fn_diff_devnull "$at_stderr" || at_failed=: 4250at_fn_diff_devnull "$at_stdout" || at_failed=: 4251at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:74" 4252$at_failed && at_fn_log_failure 4253$at_traceon; } 4254 4255 4256else 4257 4258 # Added '|| true' to ensure the command returns '0' 4259 { set +x 4260$as_echo "$at_srcdir/DDSTest.at:74: \$abs_builddir/dds-test -p < \$input || true" 4261at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:74" 4262( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4263) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4264at_status=$? at_failed=false 4265$at_check_filter 4266echo stderr:; tee stderr <"$at_stderr" 4267echo stdout:; tee stdout <"$at_stdout" 4268at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:74" 4269$at_failed && at_fn_log_failure 4270$at_traceon; } 4271 4272 # Need to compare either stdout or stderr 4273 { set +x 4274$as_echo "$at_srcdir/DDSTest.at:74: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 4275at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:74" 4276( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 4277) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4278at_status=$? at_failed=false 4279$at_check_filter 4280at_fn_diff_devnull "$at_stderr" || at_failed=: 4281echo stdout:; cat "$at_stdout" 4282at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:74" 4283$at_failed && at_fn_log_failure 4284$at_traceon; } 4285 4286 4287 4288fi 4289 4290 set +x 4291 $at_times_p && times >"$at_times_file" 4292) 5>&1 2>&1 7>&- | eval $at_tee_pipe 4293read at_status <"$at_status_file" 4294#AT_STOP_27 4295#AT_START_28 4296at_fn_group_banner 28 'DDSTest.at:75' \ 4297 "DDS \$abs_srcdir/dds-testsuite/test.8.dds" " " 4298at_xfail=no 4299 test "" = "xfail" && at_xfail=yes 4300( 4301 $as_echo "28. $at_setup_line: testing $at_desc ..." 4302 $at_traceon 4303 4304 4305 4306 input=$abs_srcdir/dds-testsuite/test.8.dds 4307 baseline=$abs_srcdir/dds-testsuite/test.8.dds.base 4308 4309 if test -n "$baselines" -a x$baselines = xyes; then : 4310 4311 # The --baselines=yes option works only for tests that write to stdout 4312 { set +x 4313$as_echo "$at_srcdir/DDSTest.at:75: \$abs_builddir/dds-test -p < \$input || true" 4314at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:75" 4315( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4316) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4317at_status=$? at_failed=false 4318$at_check_filter 4319echo stderr:; cat "$at_stderr" 4320echo stdout:; tee stdout <"$at_stdout" 4321at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:75" 4322$at_failed && at_fn_log_failure 4323$at_traceon; } 4324 4325 { set +x 4326$as_echo "$at_srcdir/DDSTest.at:75: mv stdout \$baseline.tmp" 4327at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:75" 4328( $at_check_trace; mv stdout $baseline.tmp 4329) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4330at_status=$? at_failed=false 4331$at_check_filter 4332at_fn_diff_devnull "$at_stderr" || at_failed=: 4333at_fn_diff_devnull "$at_stdout" || at_failed=: 4334at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:75" 4335$at_failed && at_fn_log_failure 4336$at_traceon; } 4337 4338 4339else 4340 4341 # Added '|| true' to ensure the command returns '0' 4342 { set +x 4343$as_echo "$at_srcdir/DDSTest.at:75: \$abs_builddir/dds-test -p < \$input || true" 4344at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:75" 4345( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4346) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4347at_status=$? at_failed=false 4348$at_check_filter 4349echo stderr:; tee stderr <"$at_stderr" 4350echo stdout:; tee stdout <"$at_stdout" 4351at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:75" 4352$at_failed && at_fn_log_failure 4353$at_traceon; } 4354 4355 # Need to compare either stdout or stderr 4356 { set +x 4357$as_echo "$at_srcdir/DDSTest.at:75: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 4358at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:75" 4359( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 4360) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4361at_status=$? at_failed=false 4362$at_check_filter 4363at_fn_diff_devnull "$at_stderr" || at_failed=: 4364echo stdout:; cat "$at_stdout" 4365at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:75" 4366$at_failed && at_fn_log_failure 4367$at_traceon; } 4368 4369 4370 4371fi 4372 4373 set +x 4374 $at_times_p && times >"$at_times_file" 4375) 5>&1 2>&1 7>&- | eval $at_tee_pipe 4376read at_status <"$at_status_file" 4377#AT_STOP_28 4378#AT_START_29 4379at_fn_group_banner 29 'DDSTest.at:76' \ 4380 "DDS \$abs_srcdir/dds-testsuite/test.9.dds" " " 4381at_xfail=no 4382 test "" = "xfail" && at_xfail=yes 4383( 4384 $as_echo "29. $at_setup_line: testing $at_desc ..." 4385 $at_traceon 4386 4387 4388 4389 input=$abs_srcdir/dds-testsuite/test.9.dds 4390 baseline=$abs_srcdir/dds-testsuite/test.9.dds.base 4391 4392 if test -n "$baselines" -a x$baselines = xyes; then : 4393 4394 # The --baselines=yes option works only for tests that write to stdout 4395 { set +x 4396$as_echo "$at_srcdir/DDSTest.at:76: \$abs_builddir/dds-test -p < \$input || true" 4397at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:76" 4398( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4399) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4400at_status=$? at_failed=false 4401$at_check_filter 4402echo stderr:; cat "$at_stderr" 4403echo stdout:; tee stdout <"$at_stdout" 4404at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:76" 4405$at_failed && at_fn_log_failure 4406$at_traceon; } 4407 4408 { set +x 4409$as_echo "$at_srcdir/DDSTest.at:76: mv stdout \$baseline.tmp" 4410at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:76" 4411( $at_check_trace; mv stdout $baseline.tmp 4412) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4413at_status=$? at_failed=false 4414$at_check_filter 4415at_fn_diff_devnull "$at_stderr" || at_failed=: 4416at_fn_diff_devnull "$at_stdout" || at_failed=: 4417at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:76" 4418$at_failed && at_fn_log_failure 4419$at_traceon; } 4420 4421 4422else 4423 4424 # Added '|| true' to ensure the command returns '0' 4425 { set +x 4426$as_echo "$at_srcdir/DDSTest.at:76: \$abs_builddir/dds-test -p < \$input || true" 4427at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:76" 4428( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4429) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4430at_status=$? at_failed=false 4431$at_check_filter 4432echo stderr:; tee stderr <"$at_stderr" 4433echo stdout:; tee stdout <"$at_stdout" 4434at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:76" 4435$at_failed && at_fn_log_failure 4436$at_traceon; } 4437 4438 # Need to compare either stdout or stderr 4439 { set +x 4440$as_echo "$at_srcdir/DDSTest.at:76: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 4441at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:76" 4442( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 4443) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4444at_status=$? at_failed=false 4445$at_check_filter 4446at_fn_diff_devnull "$at_stderr" || at_failed=: 4447echo stdout:; cat "$at_stdout" 4448at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:76" 4449$at_failed && at_fn_log_failure 4450$at_traceon; } 4451 4452 4453 4454fi 4455 4456 set +x 4457 $at_times_p && times >"$at_times_file" 4458) 5>&1 2>&1 7>&- | eval $at_tee_pipe 4459read at_status <"$at_status_file" 4460#AT_STOP_29 4461#AT_START_30 4462at_fn_group_banner 30 'DDSTest.at:80' \ 4463 "DDS \$abs_srcdir/dds-testsuite/test.21.dds" " " 4464at_xfail=no 4465 test "" = "xfail" && at_xfail=yes 4466( 4467 $as_echo "30. $at_setup_line: testing $at_desc ..." 4468 $at_traceon 4469 4470 4471 4472 input=$abs_srcdir/dds-testsuite/test.21.dds 4473 baseline=$abs_srcdir/dds-testsuite/test.21.dds.base 4474 4475 if test -n "$baselines" -a x$baselines = xyes; then : 4476 4477 # The --baselines=yes option works only for tests that write to stdout 4478 { set +x 4479$as_echo "$at_srcdir/DDSTest.at:80: \$abs_builddir/dds-test -p < \$input || true" 4480at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:80" 4481( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4482) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4483at_status=$? at_failed=false 4484$at_check_filter 4485echo stderr:; cat "$at_stderr" 4486echo stdout:; tee stdout <"$at_stdout" 4487at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:80" 4488$at_failed && at_fn_log_failure 4489$at_traceon; } 4490 4491 { set +x 4492$as_echo "$at_srcdir/DDSTest.at:80: mv stdout \$baseline.tmp" 4493at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:80" 4494( $at_check_trace; mv stdout $baseline.tmp 4495) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4496at_status=$? at_failed=false 4497$at_check_filter 4498at_fn_diff_devnull "$at_stderr" || at_failed=: 4499at_fn_diff_devnull "$at_stdout" || at_failed=: 4500at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:80" 4501$at_failed && at_fn_log_failure 4502$at_traceon; } 4503 4504 4505else 4506 4507 # Added '|| true' to ensure the command returns '0' 4508 { set +x 4509$as_echo "$at_srcdir/DDSTest.at:80: \$abs_builddir/dds-test -p < \$input || true" 4510at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:80" 4511( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4512) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4513at_status=$? at_failed=false 4514$at_check_filter 4515echo stderr:; tee stderr <"$at_stderr" 4516echo stdout:; tee stdout <"$at_stdout" 4517at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:80" 4518$at_failed && at_fn_log_failure 4519$at_traceon; } 4520 4521 # Need to compare either stdout or stderr 4522 { set +x 4523$as_echo "$at_srcdir/DDSTest.at:80: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 4524at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:80" 4525( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 4526) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4527at_status=$? at_failed=false 4528$at_check_filter 4529at_fn_diff_devnull "$at_stderr" || at_failed=: 4530echo stdout:; cat "$at_stdout" 4531at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:80" 4532$at_failed && at_fn_log_failure 4533$at_traceon; } 4534 4535 4536 4537fi 4538 4539 set +x 4540 $at_times_p && times >"$at_times_file" 4541) 5>&1 2>&1 7>&- | eval $at_tee_pipe 4542read at_status <"$at_status_file" 4543#AT_STOP_30 4544#AT_START_31 4545at_fn_group_banner 31 'DDSTest.at:81' \ 4546 "DDS \$abs_srcdir/dds-testsuite/test.22.dds" " " 4547at_xfail=no 4548 test "" = "xfail" && at_xfail=yes 4549( 4550 $as_echo "31. $at_setup_line: testing $at_desc ..." 4551 $at_traceon 4552 4553 4554 4555 input=$abs_srcdir/dds-testsuite/test.22.dds 4556 baseline=$abs_srcdir/dds-testsuite/test.22.dds.base 4557 4558 if test -n "$baselines" -a x$baselines = xyes; then : 4559 4560 # The --baselines=yes option works only for tests that write to stdout 4561 { set +x 4562$as_echo "$at_srcdir/DDSTest.at:81: \$abs_builddir/dds-test -p < \$input || true" 4563at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:81" 4564( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4565) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4566at_status=$? at_failed=false 4567$at_check_filter 4568echo stderr:; cat "$at_stderr" 4569echo stdout:; tee stdout <"$at_stdout" 4570at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:81" 4571$at_failed && at_fn_log_failure 4572$at_traceon; } 4573 4574 { set +x 4575$as_echo "$at_srcdir/DDSTest.at:81: mv stdout \$baseline.tmp" 4576at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:81" 4577( $at_check_trace; mv stdout $baseline.tmp 4578) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4579at_status=$? at_failed=false 4580$at_check_filter 4581at_fn_diff_devnull "$at_stderr" || at_failed=: 4582at_fn_diff_devnull "$at_stdout" || at_failed=: 4583at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:81" 4584$at_failed && at_fn_log_failure 4585$at_traceon; } 4586 4587 4588else 4589 4590 # Added '|| true' to ensure the command returns '0' 4591 { set +x 4592$as_echo "$at_srcdir/DDSTest.at:81: \$abs_builddir/dds-test -p < \$input || true" 4593at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:81" 4594( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4595) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4596at_status=$? at_failed=false 4597$at_check_filter 4598echo stderr:; tee stderr <"$at_stderr" 4599echo stdout:; tee stdout <"$at_stdout" 4600at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:81" 4601$at_failed && at_fn_log_failure 4602$at_traceon; } 4603 4604 # Need to compare either stdout or stderr 4605 { set +x 4606$as_echo "$at_srcdir/DDSTest.at:81: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 4607at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:81" 4608( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 4609) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4610at_status=$? at_failed=false 4611$at_check_filter 4612at_fn_diff_devnull "$at_stderr" || at_failed=: 4613echo stdout:; cat "$at_stdout" 4614at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:81" 4615$at_failed && at_fn_log_failure 4616$at_traceon; } 4617 4618 4619 4620fi 4621 4622 set +x 4623 $at_times_p && times >"$at_times_file" 4624) 5>&1 2>&1 7>&- | eval $at_tee_pipe 4625read at_status <"$at_status_file" 4626#AT_STOP_31 4627#AT_START_32 4628at_fn_group_banner 32 'DDSTest.at:82' \ 4629 "DDS \$abs_srcdir/dds-testsuite/test.23.dds" " " 4630at_xfail=no 4631 test "" = "xfail" && at_xfail=yes 4632( 4633 $as_echo "32. $at_setup_line: testing $at_desc ..." 4634 $at_traceon 4635 4636 4637 4638 input=$abs_srcdir/dds-testsuite/test.23.dds 4639 baseline=$abs_srcdir/dds-testsuite/test.23.dds.base 4640 4641 if test -n "$baselines" -a x$baselines = xyes; then : 4642 4643 # The --baselines=yes option works only for tests that write to stdout 4644 { set +x 4645$as_echo "$at_srcdir/DDSTest.at:82: \$abs_builddir/dds-test -p < \$input || true" 4646at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:82" 4647( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4648) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4649at_status=$? at_failed=false 4650$at_check_filter 4651echo stderr:; cat "$at_stderr" 4652echo stdout:; tee stdout <"$at_stdout" 4653at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:82" 4654$at_failed && at_fn_log_failure 4655$at_traceon; } 4656 4657 { set +x 4658$as_echo "$at_srcdir/DDSTest.at:82: mv stdout \$baseline.tmp" 4659at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:82" 4660( $at_check_trace; mv stdout $baseline.tmp 4661) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4662at_status=$? at_failed=false 4663$at_check_filter 4664at_fn_diff_devnull "$at_stderr" || at_failed=: 4665at_fn_diff_devnull "$at_stdout" || at_failed=: 4666at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:82" 4667$at_failed && at_fn_log_failure 4668$at_traceon; } 4669 4670 4671else 4672 4673 # Added '|| true' to ensure the command returns '0' 4674 { set +x 4675$as_echo "$at_srcdir/DDSTest.at:82: \$abs_builddir/dds-test -p < \$input || true" 4676at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:82" 4677( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4678) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4679at_status=$? at_failed=false 4680$at_check_filter 4681echo stderr:; tee stderr <"$at_stderr" 4682echo stdout:; tee stdout <"$at_stdout" 4683at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:82" 4684$at_failed && at_fn_log_failure 4685$at_traceon; } 4686 4687 # Need to compare either stdout or stderr 4688 { set +x 4689$as_echo "$at_srcdir/DDSTest.at:82: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 4690at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:82" 4691( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 4692) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4693at_status=$? at_failed=false 4694$at_check_filter 4695at_fn_diff_devnull "$at_stderr" || at_failed=: 4696echo stdout:; cat "$at_stdout" 4697at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:82" 4698$at_failed && at_fn_log_failure 4699$at_traceon; } 4700 4701 4702 4703fi 4704 4705 set +x 4706 $at_times_p && times >"$at_times_file" 4707) 5>&1 2>&1 7>&- | eval $at_tee_pipe 4708read at_status <"$at_status_file" 4709#AT_STOP_32 4710#AT_START_33 4711at_fn_group_banner 33 'DDSTest.at:83' \ 4712 "DDS \$abs_srcdir/dds-testsuite/test.24.dds" " " 4713at_xfail=no 4714 test "xpass" = "xfail" && at_xfail=yes 4715( 4716 $as_echo "33. $at_setup_line: testing $at_desc ..." 4717 $at_traceon 4718 4719 4720 4721 input=$abs_srcdir/dds-testsuite/test.24.dds 4722 baseline=$abs_srcdir/dds-testsuite/test.24.dds.base 4723 4724 if test -n "$baselines" -a x$baselines = xyes; then : 4725 4726 # The --baselines=yes option works only for tests that write to stdout 4727 { set +x 4728$as_echo "$at_srcdir/DDSTest.at:83: \$abs_builddir/dds-test -p < \$input || true" 4729at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:83" 4730( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4731) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4732at_status=$? at_failed=false 4733$at_check_filter 4734echo stderr:; cat "$at_stderr" 4735echo stdout:; tee stdout <"$at_stdout" 4736at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:83" 4737$at_failed && at_fn_log_failure 4738$at_traceon; } 4739 4740 { set +x 4741$as_echo "$at_srcdir/DDSTest.at:83: mv stdout \$baseline.tmp" 4742at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:83" 4743( $at_check_trace; mv stdout $baseline.tmp 4744) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4745at_status=$? at_failed=false 4746$at_check_filter 4747at_fn_diff_devnull "$at_stderr" || at_failed=: 4748at_fn_diff_devnull "$at_stdout" || at_failed=: 4749at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:83" 4750$at_failed && at_fn_log_failure 4751$at_traceon; } 4752 4753 4754else 4755 4756 # Added '|| true' to ensure the command returns '0' 4757 { set +x 4758$as_echo "$at_srcdir/DDSTest.at:83: \$abs_builddir/dds-test -p < \$input || true" 4759at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:83" 4760( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4761) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4762at_status=$? at_failed=false 4763$at_check_filter 4764echo stderr:; tee stderr <"$at_stderr" 4765echo stdout:; tee stdout <"$at_stdout" 4766at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:83" 4767$at_failed && at_fn_log_failure 4768$at_traceon; } 4769 4770 # Need to compare either stdout or stderr 4771 { set +x 4772$as_echo "$at_srcdir/DDSTest.at:83: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 4773at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:83" 4774( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 4775) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4776at_status=$? at_failed=false 4777$at_check_filter 4778at_fn_diff_devnull "$at_stderr" || at_failed=: 4779echo stdout:; cat "$at_stdout" 4780at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:83" 4781$at_failed && at_fn_log_failure 4782$at_traceon; } 4783 4784 4785 4786fi 4787 4788 set +x 4789 $at_times_p && times >"$at_times_file" 4790) 5>&1 2>&1 7>&- | eval $at_tee_pipe 4791read at_status <"$at_status_file" 4792#AT_STOP_33 4793#AT_START_34 4794at_fn_group_banner 34 'DDSTest.at:86' \ 4795 "DDS \$abs_srcdir/dds-testsuite/test.25.dds" " " 4796at_xfail=no 4797 test "xpass" = "xfail" && at_xfail=yes 4798( 4799 $as_echo "34. $at_setup_line: testing $at_desc ..." 4800 $at_traceon 4801 4802 4803 4804 input=$abs_srcdir/dds-testsuite/test.25.dds 4805 baseline=$abs_srcdir/dds-testsuite/test.25.dds.base 4806 4807 if test -n "$baselines" -a x$baselines = xyes; then : 4808 4809 # The --baselines=yes option works only for tests that write to stdout 4810 { set +x 4811$as_echo "$at_srcdir/DDSTest.at:86: \$abs_builddir/dds-test -p < \$input || true" 4812at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:86" 4813( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4814) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4815at_status=$? at_failed=false 4816$at_check_filter 4817echo stderr:; cat "$at_stderr" 4818echo stdout:; tee stdout <"$at_stdout" 4819at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:86" 4820$at_failed && at_fn_log_failure 4821$at_traceon; } 4822 4823 { set +x 4824$as_echo "$at_srcdir/DDSTest.at:86: mv stdout \$baseline.tmp" 4825at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:86" 4826( $at_check_trace; mv stdout $baseline.tmp 4827) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4828at_status=$? at_failed=false 4829$at_check_filter 4830at_fn_diff_devnull "$at_stderr" || at_failed=: 4831at_fn_diff_devnull "$at_stdout" || at_failed=: 4832at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:86" 4833$at_failed && at_fn_log_failure 4834$at_traceon; } 4835 4836 4837else 4838 4839 # Added '|| true' to ensure the command returns '0' 4840 { set +x 4841$as_echo "$at_srcdir/DDSTest.at:86: \$abs_builddir/dds-test -p < \$input || true" 4842at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:86" 4843( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4844) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4845at_status=$? at_failed=false 4846$at_check_filter 4847echo stderr:; tee stderr <"$at_stderr" 4848echo stdout:; tee stdout <"$at_stdout" 4849at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:86" 4850$at_failed && at_fn_log_failure 4851$at_traceon; } 4852 4853 # Need to compare either stdout or stderr 4854 { set +x 4855$as_echo "$at_srcdir/DDSTest.at:86: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 4856at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:86" 4857( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 4858) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4859at_status=$? at_failed=false 4860$at_check_filter 4861at_fn_diff_devnull "$at_stderr" || at_failed=: 4862echo stdout:; cat "$at_stdout" 4863at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:86" 4864$at_failed && at_fn_log_failure 4865$at_traceon; } 4866 4867 4868 4869fi 4870 4871 set +x 4872 $at_times_p && times >"$at_times_file" 4873) 5>&1 2>&1 7>&- | eval $at_tee_pipe 4874read at_status <"$at_status_file" 4875#AT_STOP_34 4876#AT_START_35 4877at_fn_group_banner 35 'DDSTest.at:87' \ 4878 "DDS \$abs_srcdir/dds-testsuite/test.26.dds" " " 4879at_xfail=no 4880 test "xpass" = "xfail" && at_xfail=yes 4881( 4882 $as_echo "35. $at_setup_line: testing $at_desc ..." 4883 $at_traceon 4884 4885 4886 4887 input=$abs_srcdir/dds-testsuite/test.26.dds 4888 baseline=$abs_srcdir/dds-testsuite/test.26.dds.base 4889 4890 if test -n "$baselines" -a x$baselines = xyes; then : 4891 4892 # The --baselines=yes option works only for tests that write to stdout 4893 { set +x 4894$as_echo "$at_srcdir/DDSTest.at:87: \$abs_builddir/dds-test -p < \$input || true" 4895at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:87" 4896( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4897) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4898at_status=$? at_failed=false 4899$at_check_filter 4900echo stderr:; cat "$at_stderr" 4901echo stdout:; tee stdout <"$at_stdout" 4902at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:87" 4903$at_failed && at_fn_log_failure 4904$at_traceon; } 4905 4906 { set +x 4907$as_echo "$at_srcdir/DDSTest.at:87: mv stdout \$baseline.tmp" 4908at_fn_check_prepare_dynamic "mv stdout $baseline.tmp" "DDSTest.at:87" 4909( $at_check_trace; mv stdout $baseline.tmp 4910) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4911at_status=$? at_failed=false 4912$at_check_filter 4913at_fn_diff_devnull "$at_stderr" || at_failed=: 4914at_fn_diff_devnull "$at_stdout" || at_failed=: 4915at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:87" 4916$at_failed && at_fn_log_failure 4917$at_traceon; } 4918 4919 4920else 4921 4922 # Added '|| true' to ensure the command returns '0' 4923 { set +x 4924$as_echo "$at_srcdir/DDSTest.at:87: \$abs_builddir/dds-test -p < \$input || true" 4925at_fn_check_prepare_dynamic "$abs_builddir/dds-test -p < $input || true" "DDSTest.at:87" 4926( $at_check_trace; $abs_builddir/dds-test -p < $input || true 4927) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4928at_status=$? at_failed=false 4929$at_check_filter 4930echo stderr:; tee stderr <"$at_stderr" 4931echo stdout:; tee stdout <"$at_stdout" 4932at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:87" 4933$at_failed && at_fn_log_failure 4934$at_traceon; } 4935 4936 # Need to compare either stdout or stderr 4937 { set +x 4938$as_echo "$at_srcdir/DDSTest.at:87: diff -b -B \$baseline stdout || diff -b -B \$baseline stderr" 4939at_fn_check_prepare_dynamic "diff -b -B $baseline stdout || diff -b -B $baseline stderr" "DDSTest.at:87" 4940( $at_check_trace; diff -b -B $baseline stdout || diff -b -B $baseline stderr 4941) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4942at_status=$? at_failed=false 4943$at_check_filter 4944at_fn_diff_devnull "$at_stderr" || at_failed=: 4945echo stdout:; cat "$at_stdout" 4946at_fn_check_status 0 $at_status "$at_srcdir/DDSTest.at:87" 4947$at_failed && at_fn_log_failure 4948$at_traceon; } 4949 4950 4951 4952fi 4953 4954 set +x 4955 $at_times_p && times >"$at_times_file" 4956) 5>&1 2>&1 7>&- | eval $at_tee_pipe 4957read at_status <"$at_status_file" 4958#AT_STOP_35 4959